C# XmlRpcSerializer.SerializeRequest方法代码示例

    public void SerializeObjectParams()
    {
      Stream stm = new MemoryStream();
      XmlRpcRequest req = new XmlRpcRequest();
      req.args = new Object[] { new object[] { 1, "one" } };
      req.method = "Foo";
      req.mi = typeof(IFoo).GetMethod("Foo");
      XmlRpcSerializer ser = new XmlRpcSerializer();
      ser.SerializeRequest(stm, req);
      stm.Position = 0;
      TextReader tr = new StreamReader(stm);
      string reqstr = tr.ReadToEnd();
      Assert.AreEqual(
        @"<?xml version=""1.0""?>
<methodCall>
  <methodName>Foo</methodName>
  <params>
    <param>
      <value>
        <i4>1</i4>
      </value>
    </param>
    <param>
      <value>
        <string>one</string>
      </value>
    </param>
  </params>
</methodCall>", reqstr);
    }

    public void NoIndentation()
    {
      Stream stm = new MemoryStream();
      XmlRpcRequest req = new XmlRpcRequest();
      req.args = new Object[] { 1234567 };
      req.method = "Foo";
      XmlRpcSerializer ser = new XmlRpcSerializer();
      ser.UseIndentation = false;
      ser.SerializeRequest(stm, req);
      stm.Position = 0;
      TextReader tr = new StreamReader(stm);
      string reqstr = tr.ReadToEnd();

      Assert.AreEqual(
        "<?xml version=\"1.0\"?><methodCall><methodName>Foo</methodName>"+
        "<params><param><value><i4>1234567</i4></value></param></params>"+
        "</methodCall>", reqstr);
    }

    public void DefaultFormatting()
    {
      Stream stm = new MemoryStream();
      XmlRpcRequest req = new XmlRpcRequest();
      req.args = new Object[] { 1234567 };
      req.method = "Foo";
      XmlRpcSerializer ser = new XmlRpcSerializer();
      ser.SerializeRequest(stm, req);
      stm.Position = 0;
      TextReader tr = new StreamReader(stm);
      string reqstr = tr.ReadToEnd();

      Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
  <methodName>Foo</methodName>
  <params>
    <param>
      <value>
        <i4>1234567</i4>
      </value>
    </param>
  </params>
</methodCall>", reqstr);
    }

 public void NullParameter()
 {
   Stream stm = new MemoryStream();
   XmlRpcRequest req = new XmlRpcRequest();
   req.args = new Object[] { null };
   req.method = "Foo";
   XmlRpcSerializer ser = new XmlRpcSerializer();
   ser.SerializeRequest(stm, req);
 }

    public void RecursiveArrayMemberTest()
    {
      Stream stm = new MemoryStream();
      XmlRpcRequest req = new XmlRpcRequest();
      var example = new RecursiveArrayMember
      {
        Level = "1",
        childExamples = new RecursiveArrayMember[]
        {
          new RecursiveArrayMember
          {
            Level = "1-1",
            childExamples = new RecursiveArrayMember[]
            {
              new RecursiveArrayMember
              {
                Level = "1-1-1",
                childExamples = new RecursiveArrayMember[]
                {
                }
              },
              new RecursiveArrayMember
              {
                Level = "1-1-2",
                childExamples = new RecursiveArrayMember[]
                {
                }
              }
            }
          },
          new RecursiveArrayMember
          {
            Level = "1-2",
            childExamples = new RecursiveArrayMember[]
            {
              new RecursiveArrayMember
              {
                Level = "1-2-1",
                childExamples = new RecursiveArrayMember[]
                {
                }
              },
              new RecursiveArrayMember
              {
                Level = "1-2-2",
                childExamples = new RecursiveArrayMember[]
                {
                }
              }
            }
          }
        }
      };
      req.args = new Object[] { example };
      req.method = "Foo";
      XmlRpcSerializer ser = new XmlRpcSerializer();
      ser.UseStringTag = false;
      ser.SerializeRequest(stm, req);
      stm.Position = 0;
      TextReader tr = new StreamReader(stm);
      string reqstr = tr.ReadToEnd();
      Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
  <methodName>Foo</methodName>
  <params>
    <param>
      <value>
        <struct>
          <member>
            <name>Level</name>
            <value>1</value>
          </member>
          <member>
            <name>childExamples</name>
            <value>
              <array>
                <data>
                  <value>
                    <struct>
                      <member>
                        <name>Level</name>
                        <value>1-1</value>
                      </member>
                      <member>
                        <name>childExamples</name>
                        <value>
                          <array>
                            <data>
                              <value>
                                <struct>
                                  <member>
                                    <name>Level</name>
                                    <value>1-1-1</value>
                                  </member>
                                  <member>
                                    <name>childExamples</name>
                                    <value>
                                      <array>
                                        <data />
//.........这里部分代码省略.........

    public void NonSerializedClass()
    {
      Stream stm = new MemoryStream();
      XmlRpcRequest req = new XmlRpcRequest();
      req.args = new Object[] { new Class4() };
      req.method = "Foo";
      XmlRpcSerializer ser = new XmlRpcSerializer();
      ser.SerializeRequest(stm, req);
      stm.Position = 0;
      TextReader tr = new StreamReader(stm);
      string reqstr = tr.ReadToEnd();
      Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
  <methodName>Foo</methodName>
  <params>
    <param>
      <value>
        <struct>
          <member>
            <name>y</name>
            <value>
              <i4>0</i4>
            </value>
          </member>
        </struct>
      </value>
    </param>
  </params>
</methodCall>", reqstr);
    }

 public void SerializeIntNoParams()
 {
     Stream stm = new MemoryStream();
       XmlRpcRequest req = new XmlRpcRequest();
       req.args = new object[] { new int[] { 1, 2, 3 } };
       req.method = "BarNotParams";
       req.mi = typeof(IFoo).GetMethod("BarNotParams");
       XmlRpcSerializer ser = new XmlRpcSerializer();
       ser.SerializeRequest(stm, req);
       stm.Position = 0;
       TextReader tr = new StreamReader(stm);
       string reqstr = tr.ReadToEnd();
       Assert.AreEqual(
     @"<?xml version=""1.0""?>
     <methodCall>
       <methodName>BarNotParams</methodName>
       <params>
     <param>
       <value>
     <array>
       <data>
     <value>
       <i4>1</i4>
     </value>
     <value>
       <i4>2</i4>
     </value>
     <value>
       <i4>3</i4>
     </value>
       </data>
     </array>
       </value>
     </param>
       </params>
     </methodCall>", reqstr);
 }

    public object Invoke(
      Object clientObj,
      MethodInfo mi,
      params object[] parameters)
    {
#if (!COMPACT_FRAMEWORK && !SILVERLIGHT)
      _responseHeaders = null;
      _responseCookies = null;
#endif
      WebRequest webReq = null;
      object reto = null;
      try
      {
        string useUrl = GetEffectiveUrl(clientObj);
        webReq = GetWebRequest(new Uri(useUrl));
        XmlRpcRequest req = MakeXmlRpcRequest(webReq, mi, parameters,
          clientObj, _xmlRpcMethod, _id);
        SetProperties(webReq);
#if (!SILVERLIGHT)
        SetRequestHeaders(_headers, webReq);
#endif
#if (!COMPACT_FRAMEWORK && !SILVERLIGHT)
        SetClientCertificates(_clientCertificates, webReq);
#endif
        Stream serStream = null;
        Stream reqStream = null;
        bool logging = (RequestEvent != null);
        if (!logging)
          serStream = reqStream = webReq.GetRequestStream();
        else
          serStream = new MemoryStream(2000);
        try
        {
          XmlRpcSerializer serializer = new XmlRpcSerializer();
          if (_xmlEncoding != null)
            serializer.XmlEncoding = _xmlEncoding;
          serializer.UseIndentation = _useIndentation;
          serializer.Indentation = _indentation;
          serializer.NonStandard = _nonStandard;
          serializer.UseStringTag = _useStringTag;
          serializer.UseIntTag = _useIntTag;
          serializer.UseEmptyParamsTag = _useEmptyParamsTag;
          serializer.SerializeRequest(serStream, req);
          if (logging)
          {
            reqStream = webReq.GetRequestStream();
            serStream.Position = 0;
            Util.CopyStream(serStream, reqStream);
            reqStream.Flush();
            serStream.Position = 0;
            OnRequest(new XmlRpcRequestEventArgs(req.proxyId, req.number,
              serStream));
          }
        }
        finally
        {
          if (reqStream != null)
            reqStream.Close();
        }
        HttpWebResponse webResp = GetWebResponse(webReq) as HttpWebResponse;
#if (!COMPACT_FRAMEWORK && !SILVERLIGHT)
        _responseCookies = webResp.Cookies;
#endif
#if (!COMPACT_FRAMEWORK && !SILVERLIGHT)
        _responseHeaders = webResp.Headers;
#endif
        Stream respStm = null;
        Stream deserStream;
        logging = (ResponseEvent != null);
        try
        {
          respStm = webResp.GetResponseStream();
          if (!logging)
          {
            deserStream = respStm;
          }
          else
          {
            deserStream = new MemoryStream(2000);
            Util.CopyStream(respStm, deserStream);
            deserStream.Flush();
            deserStream.Position = 0;
          }
#if (!COMPACT_FRAMEWORK && !SILVERLIGHT)
          deserStream = MaybeDecompressStream((HttpWebResponse)webResp, 
            deserStream);          
#endif
          try
          {
            XmlRpcResponse resp = ReadResponse(req, webResp, deserStream, null);
            reto = resp.retVal;
          }
          finally
          {
            if (logging)
            {
              deserStream.Position = 0;
              OnResponse(new XmlRpcResponseEventArgs(req.proxyId, req.number,
                deserStream));
            }
//.........这里部分代码省略.........

 public void StructParamsTooManyParams()
 {
   Stream stm = new MemoryStream();
   XmlRpcRequest req = new XmlRpcRequest();
   req.args = new Object[] { 1234, "test", 10.1, "lopol" };
   req.method = "Foo";
   req.mi = this.GetType().GetMethod("Foo");
   XmlRpcSerializer ser = new XmlRpcSerializer();
   ser.Indentation = 2;
   ser.UseIntTag = true;
   ser.SerializeRequest(stm, req);
 }

    public void StructParams()
    {
      Stream stm = new MemoryStream();
      XmlRpcRequest req = new XmlRpcRequest();
      req.args = new Object[] { 1234, "test", 10.1 };
      req.method = "Foo";
      req.mi = this.GetType().GetMethod("Foo");
      XmlRpcSerializer ser = new XmlRpcSerializer();
      ser.Indentation = 2;
      ser.UseIntTag = true;
      ser.SerializeRequest(stm, req);
      stm.Position = 0;
      TextReader tr = new StreamReader(stm);
      string reqstr = tr.ReadToEnd();

      Assert.AreEqual(
        @"<?xml version=""1.0""?>
<methodCall>
  <methodName>Foo</methodName>
  <params>
    <param>
      <value>
        <struct>
          <member>
            <name>x</name>
            <value>
              <int>1234</int>
            </value>
          </member>
          <member>
            <name>y</name>
            <value>
              <string>test</string>
            </value>
          </member>
          <member>
            <name>z</name>
            <value>
              <double>10.1</double>
            </value>
          </member>
        </struct>
      </value>
    </param>
  </params>
</methodCall>", reqstr);
    }

    public void UseInt()
    {
      Stream stm = new MemoryStream();
      XmlRpcRequest req = new XmlRpcRequest();
      req.args = new Object[] { 1234 };
      req.method = "Foo";
      XmlRpcSerializer ser = new XmlRpcSerializer();
      ser.Indentation = 4;
      ser.UseIntTag = true;
      ser.SerializeRequest(stm, req);
      stm.Position = 0;
      TextReader tr = new StreamReader(stm);
      string reqstr = tr.ReadToEnd();

      Assert.AreEqual(
        @"<?xml version=""1.0""?>
<methodCall>
    <methodName>Foo</methodName>
    <params>
        <param>
            <value>
                <int>1234</int>
            </value>
        </param>
    </params>
</methodCall>", reqstr);
    }

    public void StringDefaultTag()
    {
      Stream stm = new MemoryStream();
      XmlRpcRequest req = new XmlRpcRequest();
      req.args = new Object[] { "string default tag" };
      req.method = "Foo";
      XmlRpcSerializer ser = new XmlRpcSerializer();
      ser.Indentation = 4;
      ser.SerializeRequest(stm, req);
      stm.Position = 0;
      TextReader tr = new StreamReader(stm);
      string reqstr = tr.ReadToEnd();

      Assert.AreEqual(
        @"<?xml version=""1.0""?>
<methodCall>
    <methodName>Foo</methodName>
    <params>
        <param>
            <value>
                <string>string default tag</string>
            </value>
        </param>
    </params>
</methodCall>", reqstr);
    }

        public void DateTimeLocales()
        {
            CultureInfo oldci = Thread.CurrentThread.CurrentCulture;
              try
              {
            foreach (string locale in Utils.GetLocales())
            {
              try
              {
            CultureInfo ci = new CultureInfo(locale);
            Thread.CurrentThread.CurrentCulture = ci;
            if (ci.LCID == 0x401    // ar-SA  (Arabic - Saudi Arabia)
              || ci.LCID == 0x465   // div-MV (Dhivehi - Maldives)
              || ci.LCID == 0x41e)  // th-TH  (Thai - Thailand)
              break;

            DateTime dt = new DateTime(1900, 01, 02, 03, 04, 05);
            while (dt < DateTime.Now)
            {
              Stream stm = new MemoryStream();
              XmlRpcRequest req = new XmlRpcRequest();
              req.args = new Object[] { dt };
              req.method = "Foo";
              XmlRpcSerializer ser = new XmlRpcSerializer();
              ser.SerializeRequest(stm, req);
              stm.Position = 0;

              XmlRpcSerializer serializer = new XmlRpcSerializer();
              XmlRpcRequest request = serializer.DeserializeRequest(stm, null);

              Assert.IsTrue(request.args[0] is DateTime,
                "argument is DateTime");
              DateTime dt0 = (DateTime)request.args[0];
              Assert.AreEqual(dt0, dt, "DateTime argument 0");
              dt += new TimeSpan(100, 1, 1, 1);
            }
              }
              catch (Exception ex)
              {
              Assert.Fail(String.Format("unexpected exception {0}: {1}",
                locale, ex.Message));
              }
            }
              }
              finally
              {
            Thread.CurrentThread.CurrentCulture = oldci;
              }
        }

 public void SerializeZeroParametersNoParams()
 {
     Stream stm = new MemoryStream();
       XmlRpcRequest req = new XmlRpcRequest();
       req.args = new Object[0];
       req.method = "FooZeroParameters";
       req.mi = typeof(IFoo).GetMethod("FooZeroParameters");
       XmlRpcSerializer ser = new XmlRpcSerializer();
       ser.UseEmptyParamsTag = false;
       ser.SerializeRequest(stm, req);
       stm.Position = 0;
       TextReader tr = new StreamReader(stm);
       string reqstr = tr.ReadToEnd();
       Assert.AreEqual(
     @"<?xml version=""1.0""?>
     <methodCall>
       <methodName>FooZeroParameters</methodName>
     </methodCall>", reqstr);
 }

 public void SerializeMassimo()
 {
     object[] param1 = new object[] { "test/Gain1", "Gain", 1, 1,
                                new double[] { 0.5 } };
       object[] param2 = new object[] { "test/METER", "P1", 1, 1,
                                new double[] { -1.0 } };
       Stream stm = new MemoryStream();
       XmlRpcRequest req = new XmlRpcRequest();
       req.args = new Object[] { "IFTASK",
     new object[] { param1, param2 } };
       req.method = "Send_Param";
       req.mi = this.GetType().GetMethod("Send_Param");
       XmlRpcSerializer ser = new XmlRpcSerializer();
       ser.SerializeRequest(stm, req);
       stm.Position = 0;
       TextReader tr = new StreamReader(stm);
       string reqstr = tr.ReadToEnd();
       Assert.AreEqual(massimoRequest, reqstr);
 }