C#动态调用WCF接口

写在前面

接触WCF还是它在最初诞生之处，一个分布式应用的巨作。从开始接触到现在断断续续，真正使用的项目少之又少，更谈不上深入WCF内部实现机制和原理去研究，最近自己做一个项目时用到了WCF。从这个小项目中我学会了两个地方： 1、利用IIS部署WCF服务，也就是大家接触到的发布SVC文件。2、动态调用WCF接口。

在这个项目中接触WCF时遇到的其实不仅仅是这两个问题，甚至连IIS支持SVC文件也让我折腾了好几把，IIS都重新卸载了两次。我在这篇文章里用两种方式来实现。

如何使用

1、第一种方式比较简单，而且也是大家喜欢的，因为不需要任何配置文件就可解决，只需知道服务契约接口和服务地址就可以调用。

2、使用Invoke的方式，但是需要在调用客户端配置WCF，配置后在Invoke类里封装服务契约接口即可。

客户端调用DEMO

//第一种方式

string url = "http://localhost:3000/DoubleService.svc";

IDoubleService proxy = WcfInvokeFactory.CreateServiceByUrl<IDoubleService>(url);

int result = proxy.Add(1, 3);

//第二种方式<br><br>int result1 = WCFInvoke.Invoke(t => t.Add(1, 3));<br><br>

<system.serviceModel>

<behaviors>

<endpointBehaviors>

<behavior name="NewBehavior">

<dataContractSerializer maxItemsInObjectGraph="65536000" />

</behavior>

</endpointBehaviors>

</behaviors>

<bindings>

<basicHttpBinding>

<binding name="BasicHttpBinding_IDoubleService"

closeTimeout="01:00:00"

openTimeout="01:00:00"

sendTimeout="01:00:00"

receiveTimeout="01:00:00"

maxBufferSize="2147483647"

maxBufferPoolSize="524288"

maxReceivedMessageSize="2147483647">

<readerQuotas maxDepth="128" maxStringContentLength="2147483647" maxArrayLength="16384" maxBytesPerRead="4096" maxNameTableCharCount="16384" />

</binding>

</basicHttpBinding>

<netMsmqBinding>

<binding name="NetMsmqBinding_IAsyncSender">

<security mode="None" />

</binding>

</netMsmqBinding>

</bindings>

<client>

<endpoint address="http://localhost:3000/DoubleService.svc"

binding="basicHttpBinding"

bindingConfiguration="BasicHttpBinding_IDoubleService"

contract="DoubleStone.WebHost.IDoubleService"

name="BasicHttpBinding_IDoubleService" />

</client>

</system.serviceModel>

第一种调用方式

public class WcfInvokeFactory

{

#region WCF服务工厂

public static T CreateServiceByUrl<T>(string url)

{

return CreateServiceByUrl<T>(url, "basicHttpBinding");

}

public static T CreateServiceByUrl<T>(string url, string bing)

{

try

{

if (string.IsNullOrEmpty(url)) throw new NotSupportedException("This url is not Null or Empty!");

EndpointAddress address = new EndpointAddress(url);

Binding binding = CreateBinding(bing);

ChannelFactory<T> factory = new ChannelFactory<T>(binding, address);

return factory.CreateChannel();

}

catch (Exception ex)

{

throw new Exception("创建服务工厂出现异常.");

}

#endregion

#region 创建传输协议

/// <summary>

/// 创建传输协议

/// </summary>

/// <param name="binding">传输协议名称</param>

/// <returns></returns>

private static Binding CreateBinding(string binding)

{

Binding bindinginstance = null;

if (binding.ToLower() == "basichttpbinding")

{

BasicHttpBinding ws = new BasicHttpBinding();

ws.MaxBufferSize = 2147483647;

ws.MaxBufferPoolSize = 2147483647;

ws.MaxReceivedMessageSize = 2147483647;

ws.ReaderQuotas.MaxStringContentLength = 2147483647;

ws.CloseTimeout = new TimeSpan(0, 30, 0);

ws.OpenTimeout = new TimeSpan(0, 30, 0);

ws.ReceiveTimeout = new TimeSpan(0, 30, 0);

ws.SendTimeout = new TimeSpan(0, 30, 0);

bindinginstance = ws;

}

else if (binding.ToLower() == "nettcpbinding")

{

NetTcpBinding ws = new NetTcpBinding();

ws.MaxReceivedMessageSize = 65535000;

ws.Security.Mode = SecurityMode.None;

bindinginstance = ws;

}

else if (binding.ToLower() == "wshttpbinding")

{

WSHttpBinding ws = new WSHttpBinding(SecurityMode.None);

ws.MaxReceivedMessageSize = 65535000;

ws.Security.Message.ClientCredentialType = System.ServiceModel.MessageCredentialType.Windows;

ws.Security.Transport.ClientCredentialType = System.ServiceModel.HttpClientCredentialType.Windows;

bindinginstance = ws;

}

return bindinginstance;

}

#endregion

}

第二种调用方式

public class WCFInvoke

{

/// <summary>

/// 你需要调用的服务契约

/// </summary>

/// <typeparam name="T"></typeparam>

/// <param name="func"></param>

/// <returns></returns>

public static T Invoke<T>(Func<IDoubleService, T> func)

{

IServiceInvoker serviceInvoker=new WCFServiceInvoker();

return serviceInvoker.InvokeService(func);

}

public interface IServiceInvoker

{

void InvokeService<T>(Action<T> invokeHandler) where T : class;

TReslt InvokeService<T, TReslt>(Func<T, TReslt> invokeHandler) where T : class;

}

public class WCFServiceInvoker:IServiceInvoker

{

private static readonly ChannelFactoryManager FactoryManager = new ChannelFactoryManager();

private static readonly ClientSection ClientSection =

ConfigurationManager.GetSection("system.serviceModel/client") as ClientSection;

public void InvokeService<T>(Action<T> invokeHandler) where T : class

{

KeyValuePair<string, string> endpointNameAddressPair = GetEndpointNameAddressPair(typeof(T));

var arg = FactoryManager.CreateChannel<T>(endpointNameAddressPair.Key, endpointNameAddressPair.Value);

var obj2 = (ICommunicationObject)arg;

try

{

invokeHandler(arg);

}

finally

{

try

{

if (obj2.State != CommunicationState.Faulted)

{

obj2.Close();

}

catch

{

obj2.Abort();

}

public TReslt InvokeService<T, TReslt>(Func<T, TReslt> invokeHandler) where T : class

{

KeyValuePair<string, string> endpointNameAddressPair = GetEndpointNameAddressPair(typeof(T));

var arg = FactoryManager.CreateChannel<T>(endpointNameAddressPair.Key, endpointNameAddressPair.Value);

var obj2 = (ICommunicationObject)arg;

try

{

return invokeHandler(arg);

}

finally

{

try

{

if (obj2.State != CommunicationState.Closed || obj2.State != CommunicationState.Faulted)

{

obj2.Close();

}

catch

{

obj2.Abort();

}

private KeyValuePair<string, string> GetEndpointNameAddressPair(Type serviceContractType)

{

var configException =

new ConfigurationErrorsException(

string.Format(

"No client endpoint found for type {0}. Please add the section <client><endpoint name=\"myservice\" address=\"http://address/\" binding=\"basicHttpBinding\" contract=\"{0}\"/></client> in the config file."

,

serviceContractType));

if (((ClientSection == null) || (ClientSection.Endpoints == null)) || (ClientSection.Endpoints.Count < 1))

{

throw configException;

}

foreach (ChannelEndpointElement element in ClientSection.Endpoints)

{

if (element.Contract == serviceContractType.ToString())

{

return new KeyValuePair<string, string>(element.Name, element.Address.AbsoluteUri);

}

throw configException;

}

100

101

102

103

104

105

106

107

108

109

110

public class ChannelFactoryManager : IDisposable

{

private static readonly Dictionary<Type, ChannelFactory> Factories = new Dictionary<Type, ChannelFactory>();

private static readonly object SyncRoot = new object();

public void Dispose()

{

Dispose(true);

}

public virtual T CreateChannel<T>() where T : class

{

return CreateChannel<T>("*", null);

}

public virtual T CreateChannel<T>(string endpointConfigurationName) where T : class

{

return CreateChannel<T>(endpointConfigurationName, null);

}

public virtual T CreateChannel<T>(string endpointConfigurationName, string endpointAddress) where T : class

{

T local = GetFactory<T>(endpointConfigurationName, endpointAddress).CreateChannel();

((IClientChannel)local).Faulted += ChannelFaulted;

return local;

}

protected virtual ChannelFactory<T> GetFactory<T>(string endpointConfigurationName, string endpointAddress)

where T : class

{

lock (SyncRoot)

{

ChannelFactory factory;

if (!Factories.TryGetValue(typeof(T), out factory))

{

factory = CreateFactoryInstance<T>(endpointConfigurationName, endpointAddress);

Factories.Add(typeof(T), factory);

}

return (factory as ChannelFactory<T>);

}

private ChannelFactory CreateFactoryInstance<T>(string endpointConfigurationName, string endpointAddress)

{

ChannelFactory factory = null;

factory = !string.IsNullOrEmpty(endpointAddress) ? new ChannelFactory<T>(endpointConfigurationName, new EndpointAddress(endpointAddress)) : new ChannelFactory<T>(endpointConfigurationName);

factory.Faulted += FactoryFaulted;

factory.Open();

return factory;

}

private void ChannelFaulted(object sender, EventArgs e)

{

var channel = (IClientChannel)sender;

try

{

channel.Close();

}

catch

{

channel.Abort();

}

private void FactoryFaulted(object sender, EventArgs args)

{

var factory = (ChannelFactory)sender;

try

{

factory.Close();

}

catch

{

factory.Abort();

}

Type[] genericArguments = factory.GetType().GetGenericArguments();

if ((genericArguments.Length == 1))

{

Type key = genericArguments[0];

if (Factories.ContainsKey(key))

{

Factories.Remove(key);

}

protected virtual void Dispose(bool disposing)

{

if (disposing)

{

lock (SyncRoot)

{

foreach (Type type in Factories.Keys)

{

ChannelFactory factory = Factories[type];

try

{

factory.Close();

}

catch

{

factory.Abort();

}

Factories.Clear();

}

总结

第一种方式比较常见，第二种方式是我参考另外一个项目中的写法，其中的有一些细节我还没有搞明白，实现了这个功能后还需要再看看这部分代码，再消化消化。由于是直接在项目中，所以没有提供源代码下载，有朋友需要的话我会整理出demo，稍后放出下载链接。