WINCE调用WCF示例代码

只要修改一下就能用了...用WINCE微软的命令行生成的代理MaxReceivedMessageSize只有65536左右的大小.

using System.Windows.Forms;
namespace Microsoft.Tools.ServiceModel
{


    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.NetCFSvcUtil", "3.5.0.0")]
public class CFClientBase<TChannel>
where TChannel :  class
    {

private System.ServiceModel.BasicHttpBinding binding;

private System.ServiceModel.Channels.IChannelFactory<System.ServiceModel.Channels.IRequestChannel> _requestChannelFactory;

private System.ServiceModel.Channels.IChannelFactory<System.ServiceModel.Channels.IOutputChannel> _outputChannelFactory;

private System.ServiceModel.Description.ClientCredentials _clientCredentials;

private System.ServiceModel.EndpointAddress remoteAddress;

private System.ServiceModel.Channels.BindingParameterCollection _parameters;

private object requestChannelFactorySyncObject;

private object outputChannelFactorySyncObject;

private System.Collections.Generic.Dictionary<CFContractSerializerInfo, System.Runtime.Serialization.XmlObjectSerializer> serializers = new System.Collections.Generic.Dictionary<CFContractSerializerInfo, System.Runtime.Serialization.XmlObjectSerializer>(2);

public CFClientBase(System.ServiceModel.BasicHttpBinding binding, System.ServiceModel.EndpointAddress remoteAddress)
        {
if ((binding == null))
            {
throw new System.ArgumentNullException("binding");
            }
if ((remoteAddress == null))
            {
throw new System.ArgumentNullException("remoteAddress");
            }
this.remoteAddress = remoteAddress;

this.binding = binding;

this._clientCredentials = new System.ServiceModel.Description.ClientCredentials();
this._parameters = new System.ServiceModel.Channels.BindingParameterCollection();
this._parameters.Add(this._clientCredentials);
this.outputChannelFactorySyncObject = new object();
this.requestChannelFactorySyncObject = new object();
        }

public System.ServiceModel.Description.ClientCredentials ClientCredentials
        {
get
            {
return this._clientCredentials;
            }
        }

protected System.ServiceModel.Channels.BindingParameterCollection Parameters
        {
get
            {
return this._parameters;
            }
        }
#region IOutputChannel
//private System.ServiceModel.Channels.IChannelFactory<System.ServiceModel.Channels.IOutputChannel> OutputChannelFactory
//{
//    get
//    {
//        if ((this._outputChannelFactory == null))
//        {
//            System.Threading.Monitor.Enter(this.outputChannelFactorySyncObject);
//            try
//            {
//                if ((this._outputChannelFactory == null))
//                {
//                    if ((this.oneWayBinding == null))
//                    {
//                        this.oneWayBinding = new System.ServiceModel.Channels.CustomBinding(this.binding);
//                    }
//                    if (this.oneWayBinding.CanBuildChannelFactory<System.ServiceModel.Channels.IOutputChannel>(this.Parameters))
//                    {
//                        this._outputChannelFactory = this.oneWayBinding.BuildChannelFactory<System.ServiceModel.Channels.IOutputChannel>(this.Parameters);
//                        this._outputChannelFactory.Open();
//                    }
//                }
//            }
//            finally
//            {
//                System.Threading.Monitor.Exit(this.outputChannelFactorySyncObject);
//            }
//        }
//        return this._outputChannelFactory;
//    }
//}
        #endregion


private System.ServiceModel.Channels.IChannelFactory<System.ServiceModel.Channels.IRequestChannel> RequestChannelFactory
        {
get
            {
if ((this._requestChannelFactory == null))
                {
                    System.Threading.Monitor.Enter(this.requestChannelFactorySyncObject);
try
                    {
if ((this._requestChannelFactory == null))
                        {
if (this.binding.CanBuildChannelFactory<System.ServiceModel.Channels.IRequestChannel>(this.Parameters))
                            {
this._requestChannelFactory = this.binding.BuildChannelFactory<System.ServiceModel.Channels.IRequestChannel>(this.Parameters);
this._requestChannelFactory.Open();
                            }
                        }
                    }
finally
                    {
                        System.Threading.Monitor.Exit(this.requestChannelFactorySyncObject);
                    }
                }
return this._requestChannelFactory;
            }
        }

protected static void ApplyProtection(string action, System.ServiceModel.Security.ScopedMessagePartSpecification parts, bool protection)
        {
            System.ServiceModel.Security.MessagePartSpecification partSpec;
if (protection)
            {
                partSpec = new System.ServiceModel.Security.MessagePartSpecification(true);
            }
else
            {
                partSpec = System.ServiceModel.Security.MessagePartSpecification.NoParts;
            }
            parts.AddParts(partSpec, action);
        }

protected static bool IsSecureMessageBinding(System.ServiceModel.Channels.Binding binding)
        {
if (typeof(System.ServiceModel.BasicHttpBinding).IsInstanceOfType(binding))
            {
return false;
            }
if (typeof(System.ServiceModel.Channels.CustomBinding).IsInstanceOfType(binding))
            {
return ((System.ServiceModel.Channels.CustomBinding)(binding)).Elements.Contains(typeof(System.ServiceModel.Channels.AsymmetricSecurityBindingElement));
            }
throw new System.NotSupportedException("Unsupported binding type.");
        }

protected void Close()
        {
if ((this.RequestChannelFactory != null))
            {
                System.Threading.Monitor.Enter(this.RequestChannelFactory);
try
                {
this.RequestChannelFactory.Close();
                }
finally
                {
                    System.Threading.Monitor.Exit(this.RequestChannelFactory);
                }
            }

        }

protected TRESPONSE Invoke<TREQUEST, TRESPONSE>(CFInvokeInfo info, TREQUEST request)


        {
            CFContractSerializerInfo serializerInfo = new CFContractSerializerInfo();
            serializerInfo.MessageContractType = typeof(TREQUEST);
            serializerInfo.IsWrapped = info.RequestIsWrapped;
            serializerInfo.ExtraTypes = info.ExtraTypes;
            serializerInfo.UseEncoded = info.UseEncoded;
            System.ServiceModel.Channels.Message msg = System.ServiceModel.Channels.Message.CreateMessage(this.binding.MessageVersion, info.Action, request, GetContractSerializer(serializerInfo));
return this.getResult<TRESPONSE>(this.getReply(msg), info);
        }

protected void Invoke<TREQUEST>(CFInvokeInfo info, TREQUEST request)

        {
            CFContractSerializerInfo serializerInfo = new CFContractSerializerInfo();
            serializerInfo.MessageContractType = typeof(TREQUEST);
            serializerInfo.IsWrapped = info.RequestIsWrapped;
            serializerInfo.ExtraTypes = info.ExtraTypes;
            serializerInfo.UseEncoded = info.UseEncoded;
            System.ServiceModel.Channels.Message msg = System.ServiceModel.Channels.Message.CreateMessage(this.binding.MessageVersion, info.Action, request, GetContractSerializer(serializerInfo));
if (info.IsOneWay)
            {
if ((this._outputChannelFactory != null))
                {
this.postOneWayMessage(msg);
                }
else
                {
this.getReply(msg);
                }
            }
else
            {
this.processReply(this.getReply(msg));
            }
        }

private void postOneWayMessage(System.ServiceModel.Channels.Message msg)
        {
//if ((this.OutputChannelFactory == null))
//{
//    // transport doesn't support one-way messages
//    throw new System.NotSupportedException();
//}
//System.ServiceModel.Channels.IOutputChannel outputChannel;
//System.Threading.Monitor.Enter(this.OutputChannelFactory);
//try
//{
//    outputChannel = this.OutputChannelFactory.CreateChannel(this.remoteAddress);
//}
//finally
//{
//    System.Threading.Monitor.Exit(this.OutputChannelFactory);
//}
//outputChannel.Open();
//try
//{
//    outputChannel.Send(msg);
//}
//finally
//{
//    outputChannel.Close();
//}
        }

private System.ServiceModel.Channels.Message getReply(System.ServiceModel.Channels.Message msg)
        {
if ((this.RequestChannelFactory == null))
            {
// transport doesn't support requests
                throw new System.NotSupportedException();
            }
            System.ServiceModel.Channels.IRequestChannel requestChannel;
            System.Threading.Monitor.Enter(this.RequestChannelFactory);
try
            {
                requestChannel = this.RequestChannelFactory.CreateChannel(this.remoteAddress);
            }
finally
            {
                System.Threading.Monitor.Exit(this.RequestChannelFactory);
            }
            requestChannel.Open();
try
            {
return requestChannel.Request(msg);
            }
finally
            {
if ((requestChannel.State == System.ServiceModel.CommunicationState.Opened))
                {
                    requestChannel.Close();
                }
            }
        }

private void processReply(System.ServiceModel.Channels.Message reply)
        {
            System.Diagnostics.Debug.Assert((reply != null));
if (reply.IsFault)
            {
                System.Xml.XmlDictionaryReader reader = reply.GetReaderAtBodyContents();
try
                {
//throw new CFFaultException(reader.ReadOuterXml());
                    MessageBox.Show("服务器错误\n"+reader.ReadOuterXml());
//写日志
                }
finally
                {
                    reader.Close();
                }
            }
        }

protected virtual System.Runtime.Serialization.XmlObjectSerializer GetContractSerializer(CFContractSerializerInfo info)
        {
            System.Runtime.Serialization.XmlObjectSerializer serializer;
            System.Threading.Monitor.Enter(this.serializers);
try
            {
if (serializers.ContainsKey(info))
                {
                    serializer = this.serializers[info];
                }
else
                {
                    serializer = new CFContractSerializer(info);
                    serializers[info] = serializer;
                }
            }
finally
            {
                System.Threading.Monitor.Exit(this.serializers);
            }
return serializer;
        }

private TRESPONSE getResult<TRESPONSE>(System.ServiceModel.Channels.Message reply, CFInvokeInfo info)

        {
            System.Diagnostics.Debug.Assert((reply != null));
this.processReply(reply);
            TRESPONSE retVal = default(TRESPONSE);
if ((reply.IsEmpty == false))
            {
                CFContractSerializerInfo serializerInfo = new CFContractSerializerInfo();
                serializerInfo.MessageContractType = typeof(TRESPONSE);
                serializerInfo.IsWrapped = info.ResponseIsWrapped;
                serializerInfo.IsResponse = true;
                serializerInfo.ExtraTypes = info.ExtraTypes;
                serializerInfo.UseEncoded = info.UseEncoded;
                retVal = reply.GetBody<TRESPONSE>(this.GetContractSerializer(serializerInfo));
            }
return retVal;
        }

        [System.Diagnostics.DebuggerStepThroughAttribute()]
        [System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.Tools.ServiceModel.NetCFSvcUtil", "3.5.0.0")]
private class CFContractSerializer : System.Runtime.Serialization.XmlObjectSerializer
        {

private CFContractSerializerInfo info;

private System.Xml.Serialization.XmlSerializer serializer;

private static System.Xml.XmlQualifiedName artificialWrapper = new System.Xml.XmlQualifiedName("wrapper", "");

public CFContractSerializer(CFContractSerializerInfo info)
            {
this.info = info;
if ((this.info.ExtraTypes == null))
                {
this.info.ExtraTypes = new System.Type[0];
                }
this.createSerializer(null);
            }

private void createSerializer(System.Xml.XmlQualifiedName wrapper)
            {
if ((wrapper == null))
                {
if (((this.info.IsWrapped == false) 
&& this.info.IsResponse))
                    {
                        wrapper = artificialWrapper;
                    }
                }
if (this.info.UseEncoded)
                {
                    System.Xml.Serialization.SoapAttributeOverrides overrides = new System.Xml.Serialization.SoapAttributeOverrides();
if ((wrapper != null))
                    {
                        System.Xml.Serialization.SoapAttributes attributes = new System.Xml.Serialization.SoapAttributes();
                        attributes.SoapType = new System.Xml.Serialization.SoapTypeAttribute(wrapper.Name, wrapper.Namespace);
                        overrides.Add(this.info.MessageContractType, attributes);
                    }
                    System.Xml.Serialization.SoapReflectionImporter soapImporter = new System.Xml.Serialization.SoapReflectionImporter(overrides, this.info.DefaultNamespace);
for (int i = 0; (i < this.info.ExtraTypes.Length); i = (i + 1))
                    {
                        soapImporter.IncludeType(this.info.ExtraTypes[i]);
                    }
                    System.Xml.Serialization.XmlTypeMapping mapping = soapImporter.ImportTypeMapping(this.info.MessageContractType);
this.serializer = new System.Xml.Serialization.XmlSerializer(mapping);
                }
else
                {
                    System.Xml.Serialization.XmlRootAttribute rootAttr = null;
if ((wrapper != null))
                    {
                        rootAttr = new System.Xml.Serialization.XmlRootAttribute();
                        rootAttr.ElementName = wrapper.Name;
                        rootAttr.Namespace = wrapper.Namespace;
                    }
this.serializer = new System.Xml.Serialization.XmlSerializer(this.info.MessageContractType, null, this.info.ExtraTypes, rootAttr, this.info.DefaultNamespace);
                }
            }

public override bool IsStartObject(System.Xml.XmlDictionaryReader reader)
            {
throw new System.NotImplementedException();
            }

public override object ReadObject(System.Xml.XmlDictionaryReader reader, bool verifyObjectName)
            {
if ((verifyObjectName == false))
                {
throw new System.NotSupportedException();
                }
if (this.info.IsWrapped)
                {
// Some WSDLs incorrectly advertise their response message namespaces.
// Attempt to interop with these by coercing our expected namespace to match.
                    if ((this.serializer.CanDeserialize(reader) == false))
                    {
this.createSerializer(new System.Xml.XmlQualifiedName(System.Xml.XmlConvert.DecodeName(reader.LocalName), reader.NamespaceURI));
                    }
return this.serializer.Deserialize(reader);
                }
else
                {
                    System.IO.MemoryStream ms = new System.IO.MemoryStream();
                    System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
                    settings.OmitXmlDeclaration = true;
                    System.Xml.XmlWriter innerWriter = System.Xml.XmlDictionaryWriter.Create(ms, settings);
                    innerWriter.WriteStartElement(artificialWrapper.Name, artificialWrapper.Namespace);
string[] commonPrefixes = new string[] {
"xsi",
"xsd"};
for (int i = 0; (i < commonPrefixes.Length); i = (i + 1))
                    {
string ns = reader.LookupNamespace(commonPrefixes[i]);
if ((ns != null))
                        {
                            innerWriter.WriteAttributeString("xmlns", commonPrefixes[i], null, ns);
                        }
                    }
for (
                    ; ((reader.NodeType == System.Xml.XmlNodeType.EndElement) 
== false); 
                    )
                    {
                        innerWriter.WriteNode(reader, false);
                    }
                    innerWriter.WriteEndElement();
                    innerWriter.Close();
                    ms.Position = 0;
                    System.Xml.XmlReader innerReader = System.Xml.XmlDictionaryReader.Create(ms);
return this.serializer.Deserialize(innerReader);
                }
            }

public override void WriteStartObject(System.Xml.XmlDictionaryWriter writer, object graph)
            {
throw new System.NotImplementedException();
            }

public override void WriteObjectContent(System.Xml.XmlDictionaryWriter writer, object graph)
            {
throw new System.NotImplementedException();
            }

public override void WriteEndObject(System.Xml.XmlDictionaryWriter writer)
            {
throw new System.NotImplementedException();
            }

public override void WriteObject(System.Xml.XmlDictionaryWriter writer, object graph)
            {
if (this.info.IsWrapped)
                {
this.serializer.Serialize(writer, graph);
                }
else
                {
                    System.IO.MemoryStream ms = new System.IO.MemoryStream();
                    System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
                    settings.OmitXmlDeclaration = true;
                    System.Xml.XmlWriter innerWriter = System.Xml.XmlDictionaryWriter.Create(ms, settings);
this.serializer.Serialize(innerWriter, graph);
                    innerWriter.Close();
                    ms.Position = 0;
                    System.Xml.XmlReader innerReader = System.Xml.XmlDictionaryReader.Create(ms);
                    innerReader.Read();
                    writer.WriteAttributes(innerReader, false);
if ((innerReader.IsEmptyElement == false))
                    {
                        innerReader.Read();
for (
                        ; ((innerReader.NodeType == System.Xml.XmlNodeType.EndElement) 
== false); 
                        )
                        {
                            writer.WriteNode(innerReader, false);
                        }
                    }
                    innerReader.Close();
                }
            }
        }

protected struct CFContractSerializerInfo
        {

public System.Type MessageContractType;

public bool IsWrapped;

public bool IsResponse;

public System.Type[] ExtraTypes;

public string DefaultNamespace;

public bool UseEncoded;
        }

protected class CFInvokeInfo
        {

public string Action;

public string ReplyAction;

public bool IsOneWay;

public bool RequestIsWrapped;

public bool ResponseIsWrapped;

public System.Type[] ExtraTypes;

public bool UseEncoded;

public override bool Equals(object obj)
            {
if (((obj != null) 
&& (obj.GetType() == typeof(CFInvokeInfo))))
                {
return (this.Action == ((CFInvokeInfo)(obj)).Action);
                }
return false;
            }

public override int GetHashCode()
            {
if ((this.Action != null))
                {
return this.Action.GetHashCode();
                }
else
                {
return base.GetHashCode();
                }
            }
        }
    }

public class CFFaultException : System.ServiceModel.CommunicationException
    {

private string _faultMessage;

public CFFaultException(string faultMessage)
        {
this._faultMessage = faultMessage;
        }

public string FaultMessage
        {
get
            {
return this._faultMessage;
            }
        }
    }
}

转载于:https://www.cnblogs.com/alisande/archive/2011/07/13/2105687.html