【Expression 序列化】WCF的简单使用及其Expression Lambada的序列化问题初步解决方案（一）

在园子里混迹多年，始终保持着“只看帖不回帖”的习惯，看了很多，学了很多，却从不敢写些东西贴出来，一来没什么可写的，二来水平不够，怕误人子弟……

最近在做一个MVC+WCF+EF的项目，遇到问题不少，但大多数问题都是前人遇到并解决了的，感谢园子里的大牛们的无私奉献。

俗话说“礼尚往来”，我也在此分享一个最近在项目中遇到的问题，就是远程调用时的Expression表达式的序列化问题的初始解决方案，希望抛出的这块石头能引出完美的钻石来，同时第一次写博客，请大家多多赐教……

为了说明问题，我将用一个简单的示例来演示，文章的最后会有示例的源代码下载。

• 示例说明：

演示项目还是使用传统的四层结构：

WCF服务契约：契约很简单，一个Member类的Model，一个通过表达式来查找Member信息的GetMember(Expression<Func<Member, bool>>)方法

using System;
using System.Linq.Expressions;
using System.Runtime.Serialization;
using System.ServiceModel;

namespace Liuliu.Wcf.IContract
{
    [ServiceContract]
    public interface IAccountContract
    {
        [OperationContract]
        Member GetMember(Expression<Func<Member, bool>> predicate);
    }

    [DataContract]
    public class Member
    {
        [DataMember]
        public int MemberID { get; set; }

        [DataMember]
        public string UserName { get; set; }

        [DataMember]
        public string Email { get; set; }
    }
}

为简化客户端的调用操作，在Contracts项目中添加一个WcfHelper辅助类

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using System.Text;

namespace Liuliu.Wcf.IContract.Helper
{
    public class WcfHelper
    {
        public static TReturn InvokeService<TContract, TReturn>(Func<TContract, TReturn> func)
        {
            var channelFactory = new ChannelFactory<TContract>("*");
            var proxy = channelFactory.CreateChannel();
            var iproxy = proxy as ICommunicationObject;
            if (iproxy == null)
            {
                throw new ArgumentException("执行远程方法时服务契约代理协议为空。");
            }
            try
            {
                iproxy.Open();
                var result = func(proxy);
                iproxy.Close();
                return result;
            }
            catch (CommunicationException)
            {
                iproxy.Abort();
                throw;
            }
            catch (TimeoutException)
            {
                iproxy.Abort();
                throw;
            }
            catch (Exception)
            {
                iproxy.Close();
                throw;
            }
        }
    }
}

服务的实现也非常简单，就是从数据源DataSource中按条件查找相关信息并返回

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using Liuliu.Wcf.IContract;

namespace Liuliu.Wcf.Services
{
    public class AccountService : IAccountContract
    {
        private readonly static List<Member> DataSource = new List<Member>
        {
            new Member {MemberID = 3, UserName = "zhangsan", Email = "zhangsan@abc.com"},
            new Member {MemberID = 4, UserName = "lisi", Email = "lisi@abc.com"},
            new Member {MemberID = 5, UserName = "wangwu", Email = "wangwu@abc.com"},
            new Member {MemberID = 6, UserName = "zhaoliu", Email = "zhaoliu@abc.com"}
        };

        public Member GetMember(Expression<Func<Member, bool>> predicate)
        {
            return DataSource.SingleOrDefault(predicate.Compile());
        }
    }
}

服务端以一个控制台的程序来承载，第一次写博客，可以力求完美一点^_^

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;

using Liuliu.Wcf.Services;

namespace Liuliu.Wcf.Hosting
{
    class Program
    {
        private static readonly List<ServiceHost> OpenedHosts = new List<ServiceHost>();

        private static void Main(string[] args)
        {
            try
            {
                var accountHost = new ServiceHost(typeof(AccountService));
                var hosts = new List<ServiceHost> { accountHost };
                CreateHosting(hosts);
                OpenHosting(hosts);
                Console.WriteLine("按任意键关闭服务。");
                Console.ReadKey();
                CloseHosting(OpenedHosts);

            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Console.ReadLine();
            }
        }

        private static void OpenHosting(IEnumerable<ServiceHost> hosts)
        {
            foreach (var host in hosts)
            {
                try
                {
                    host.Open();
                    if (!OpenedHosts.Contains(host))
                    {
                        OpenedHosts.Add(host);
                    }
                }
                catch (Exception)
                {
                    foreach (var openedHost in OpenedHosts)
                    {
                        openedHost.Close();
                    }
                    throw;
                }
            }
        }

        private static void CreateHosting(IEnumerable<ServiceHost> hosts)
        {
            hosts.ToList().ForEach(host =>
            {
                host.Opened += host_Opened;
                host.Closed += host_Closed;
                host.UnknownMessageReceived += host_UnknownMessageReceived;
            });
        }

        private static void CloseHosting(IEnumerable<ServiceHost> hosts)
        {
            hosts.ToList().ForEach(host => host.Close());
        }

        static void host_UnknownMessageReceived(object sender, UnknownMessageReceivedEventArgs e)
        {
            var host = (ServiceHost)sender;
            Console.WriteLine("{0}收到未知消息。", host.Description.ConfigurationName);
        }

        static void host_Closed(object sender, EventArgs e)
        {
            var host = (ServiceHost)sender;
            Console.WriteLine("{0}已成功关闭。", host.Description.ConfigurationName);
        }

        static void host_Opened(object sender, EventArgs e)
        {
            var host = (ServiceHost)sender;
            Console.WriteLine("{0}服务启动完毕\n监听地址：{1}", host.Description.ConfigurationName, host.Description.Endpoints.First().ListenUri);
        }
    }
}

当然现在服务端还不能启动，还需要必要的配置信息，在Hosting项目中添加一个App.Config来进行配置，可以通过VS2010中菜单“工具” - “WCF服务配置编辑器” 来进行可视化添加

为了简化配置，这里不进行调用的验证了，设置 clientCredentialType="None"

 

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <bindings>
            <netTcpBinding>
                <binding name="NewBinding0">
                    <security>
                        <message clientCredentialType="None" />
                    </security>
                </binding>
            </netTcpBinding>
        </bindings>
        <services>
            <service name="Liuliu.Wcf.Services.AccountService">
                <endpoint address="net.tcp://127.0.0.1:9000/account" binding="netTcpBinding"
                    bindingConfiguration="NewBinding0" contract="Liuliu.Wcf.IContract.IAccountContract" />
            </service>
        </services>
    </system.serviceModel>
</configuration>

 

 

 

有了前面的WcfHelper的辅助，客户端调用就非常惬意了，由UserName查找Member信息并显示结果的Email信息

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;

using Liuliu.Wcf.IContract;
using Liuliu.Wcf.IContract.Helper;

namespace Liuliu.Wcf.Client
{
    class Program
    {
        static void Main(string[] args)
        {
            Expression<Func<Member, bool>> predicate = m => m.UserName == "张三";
            var result = WcfHelper.InvokeService<IAccountContract, Member>(wcf => wcf.GetMember(predicate));
            Console.WriteLine(result.Email);
        }
    }
}

当然，还要客户端的配置信息，由“WCF服务配置编辑器”工具可直接由上面配置的服务端配置来生成客户端配置

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <bindings>
            <netTcpBinding>
                <binding name="NewBinding0">
                    <security>
                        <message clientCredentialType="None" />
                    </security>
                </binding>
            </netTcpBinding>
        </bindings>
        <client>
            <endpoint address="net.tcp://127.0.0.1:9000/account" binding="netTcpBinding"
                bindingConfiguration="NewBinding0" contract="Liuliu.Wcf.IContract.IAccountContract"
                name="" kind="" endpointConfiguration="" />
        </client>
    </system.serviceModel>
</configuration>

 

至此，演示项目的基本架构搭建完毕，理论上运行的话应该能顺利启动，右键解决方案 - 设置启动项目，设置启动为多项目启动：

当我们信心满满的点下启动按键之后，结果却不是我们所期待的，服务端在执行到OpenHosting(hosts)的时候引发了异常：

捕捉到 System.Runtime.Serialization.InvalidDataContractException
  Message=无法序列化类型“System.Linq.Expressions.Expression`1[System.Func`2[Liuliu.Wcf.IContract.Member,System.Boolean]]”。请考虑将其标以 DataContractAttribute 特性，并将其所有要序列化的成员标以 DataMemberAttribute 特性。如果类型为集合，则请考虑将其标以 CollectionDataContractAttribute 特性。有关其他受支持的类型，请参见 Microsoft .NET Framework 文档。
  Source=System.Runtime.Serialization
  StackTrace:
       在 System.Runtime.Serialization.DataContract.DataContractCriticalHelper.ThrowInvalidDataContractException(String message, Type type)
       在 System.Runtime.Serialization.DataContract.DataContractCriticalHelper.CreateDataContract(Int32 id, RuntimeTypeHandle typeHandle, Type type)
       在 System.Runtime.Serialization.DataContract.DataContractCriticalHelper.GetDataContractSkipValidation(Int32 id, RuntimeTypeHandle typeHandle, Type type)
       在 System.Runtime.Serialization.XsdDataContractExporter.GetSchemaTypeName(Type type)
       在 System.ServiceModel.Dispatcher.DataContractSerializerOperationFormatter.ValidateDataContractType(Type type)
       在 System.ServiceModel.Dispatcher.DataContractSerializerOperationFormatter.CreatePartInfo(MessagePartDescription part, OperationFormatStyle style, DataContractSerializerOperationBehavior serializerFactory)
       在 System.ServiceModel.Dispatcher.DataContractSerializerOperationFormatter.CreateMessageInfo(DataContractFormatAttribute dataContractFormatAttribute, MessageDescription messageDescription, DataContractSerializerOperationBehavior serializerFactory)
       在 System.ServiceModel.Dispatcher.DataContractSerializerOperationFormatter..ctor(OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute, DataContractSerializerOperationBehavior serializerFactory)
       在 System.ServiceModel.Description.DataContractSerializerOperationBehavior.GetFormatter(OperationDescription operation, Boolean& formatRequest, Boolean& formatReply, Boolean isProxy)
       在 System.ServiceModel.Description.DataContractSerializerOperationBehavior.System.ServiceModel.Description.IOperationBehavior.ApplyDispatchBehavior(OperationDescription description, DispatchOperation dispatch)
       在 System.ServiceModel.Description.DispatcherBuilder.BindOperations(ContractDescription contract, ClientRuntime proxy, DispatchRuntime dispatch)
       在 System.ServiceModel.Description.DispatcherBuilder.InitializeServiceHost(ServiceDescription description, ServiceHostBase serviceHost)
       在 System.ServiceModel.ServiceHostBase.InitializeRuntime()
       在 System.ServiceModel.ServiceHostBase.OnBeginOpen()
       在 System.ServiceModel.ServiceHostBase.OnOpen(TimeSpan timeout)
       在 System.ServiceModel.Channels.CommunicationObject.Open(TimeSpan timeout)
       在 System.ServiceModel.Channels.CommunicationObject.Open()
       在 Liuliu.Wcf.Hosting.Program.OpenHosting(IEnumerable`1 hosts) 位置 D:\我的文档\Visual Studio 2010\Projects\LambadaSerializeDemo\Liuliu.Wcf.Hosting\Program.cs:行号 52
       在 Liuliu.Wcf.Hosting.Program.Main(String[] args) 位置 D:\我的文档\Visual Studio 2010\Projects\LambadaSerializeDemo\Liuliu.Wcf.Hosting\Program.cs:行号 21
  InnerException: 

 

由异常信息我们可以很明确的看到，System.Linq.Expressions.Expression类不支持序列化操作，以Expression作为查询条件的参数传递是行不通的。
此路不通，我们只能另辟蹊径了

以“Expression”，“序列化”，“Lambada”等为关键字百度Google了一把，终于还是收获不少，找到了Expression Tree Serializer 这根救命稻草

有路了就要往下走，后面还会遇到什么问题，且听下回分解……

 最后，把本文的源代码发上来以供参考，注意：为了保持现场，这个源码包的程序并不能运行

LambadaSerializeDemo01.rar