【Expression 序列化】WCF的簡單使用及其Expression Lambada的序列化問題初步解決方案（三）

　　接上文【Expression 序列化】WCF的簡單使用及其Expression Lambada的序列化問題初步解決方案（二）

　　上文最后留下了一個問題，引起這個問題的操作是把原來通過硬編碼字符串來設置的Expression參數改為接收用戶輸入。這是個非常正常的需求，可以說如果這個問題不解決，上文的Expression序列化的方法是無法應用到實際項目中的。下面來分析異常引起的原因。

　　首先，來查看一下接收輸入來組裝的Expression與硬編碼的方式生成有什么不同：

private static void Method02()
{
    Expression<Func<Member, bool>> predicate = m => m.UserName == "zhangsan";
    Console.WriteLine("硬編碼生成的表達式：\n"+predicate);
    Console.WriteLine("------------------------華麗的分割線--------------------------");

    var input = Console.ReadLine();
    predicate = m => m.UserName == input;
    Console.WriteLine("接收輸入生成的表達式：\n"+predicate);
}

 

執行程序，輸入“zhangsan”，運行的結果：

　　可以看出，接收輸入生成的Expression表達式確實長得很奇異，這也解釋了為什么報異常的原因。因為“Liuliu.TestConsole.Program+<>c__DisplayClass0”這個類是客戶端運行時生成的，而服務端在對傳過去的XElement進行反序列化時，無法識別出這個類型，自然就報錯了。

　　怎么解決呢？通過上文中提到的KnownTypeExpressionXmlConverter類把這個類傳給服務端讓它變成已知類型？顯然這是做不到的，因為Liuliu.TestConsole.Program+<>c__DisplayClass0這個類是運行時生成的，在運行之前根本不存在。看來此路不通。

　　看來只有一條路了，那就是讓輸入參數input與客戶端分離，解除對客戶端程序的依賴。而NuGet上面正好有一個叫“Dynamic Expression API”的開源組件能解決這個問題，添加引用到項目中，把上面的測試代碼修改如下：

private static void Method02()
{
    Expression<Func<Member, bool>> predicate = m => m.UserName == "zhangsan";
    Console.WriteLine("硬編碼生成的表達式：\n"+predicate);
    Console.WriteLine("------------------------華麗的分割線--------------------------");

    var input = Console.ReadLine();
    predicate = m => m.UserName == input;
    Console.WriteLine("接收輸入生成的表達式：\n"+predicate);
    Console.WriteLine("------------------------華麗的分割線--------------------------");

    input = Console.ReadLine();
    predicate = System.Linq.Dynamic.DynamicExpression.ParseLambda<Member, bool>("UserName=@0", input);
    Console.WriteLine("Dynamic Expression API生成的表達式：\n" + predicate);
}

 

由13行可以看到，Dynamic Expression API 是使用字符串拼接的方式來生成Expression的，雖然看起來似乎是歷史的倒退，但確實解除了input對客戶端的依賴，看運行結果：

可以看到通過Dynamic Expression API生成的Expression與硬編碼生成的完全一致，回到了原生的形式，這樣，理論上把問題解決了。

　　回到我們的WCF，把WCF客戶端代碼修改如下，只需要把原來的20行修改為21行：

static void Main(string[] args)
{
    Console.WriteLine("按任意建執行客戶端調用：");
    Console.ReadLine();
    try
    {
        Expression<Func<Member, bool>> predicate = m => m.UserName == "zhangsan";
        Console.WriteLine(predicate);
        var assemblies = new List<Assembly> { typeof(Member).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
        var resolver = new TypeResolver(assemblies, new[] { typeof(Member) });
        var knownTypeConverter = new KnownTypeExpressionXmlConverter(resolver);
        var serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { knownTypeConverter });
        var xmlPredicate = serializer.Serialize(predicate);
        var result = WcfHelper.InvokeService<IAccountContract, Member>(wcf => wcf.GetMember(xmlPredicate));
        Console.WriteLine(result.Email);

        var input = Console.ReadLine();
        if (!string.IsNullOrEmpty(input))
        {
            //predicate = m => m.UserName == input;
            predicate = System.Linq.Dynamic.DynamicExpression.ParseLambda<Member, bool>("UserName=@0", input);
            Console.WriteLine(predicate);
            xmlPredicate = serializer.Serialize(predicate);
            result = WcfHelper.InvokeService<IAccountContract, Member>(wcf => wcf.GetMember(xmlPredicate));
            Console.WriteLine(result.Email);
        }
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
    }
    Console.ReadLine();
}

 

運行結果與預期一致：

我們的演示項目經過幾次的大手術，已經變得面目全非了，作為一個完美主義的程序員，這是不可容忍的。所以，對項目進行重構是必然的步驟。

1.客戶端Client與服務實現Services中都存在 ExpressionSerializer 對象實例化的相同代碼，而客戶端與服務實現的一個相同點就是都引用了服務契約Contracts

所以，應該把這部分重復代碼重構進Contracts中。

2.為了避免每個使用到Dynamic Expression API的地方都要對其進行引用，也應該把Dynamic Expression API封裝到Contracts中。

我們把以上兩個重構點封裝成一個SerializeHelper靜態類，使用的時候就直接調用即可。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Xml.Linq;

using ExpressionSerialization;


namespace Liuliu.Wcf.IContract.Helper
{
    public static class SerializeHelper
    {

        public static Expression<Func<T, TS>> CreateExpression<T, TS>(string expression, params object[] values)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }
            return System.Linq.Dynamic.DynamicExpression.ParseLambda<T, TS>(expression, values);
        }

        public static XElement SerializeExpression(Expression predicate, IEnumerable<Type> knownTypes = null)
        {
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate");
            }
            var serializer = CreateSerializer(knownTypes);
            return serializer.Serialize(predicate);
        }

        public static XElement SerializeExpression<T, TS>(Expression<Func<T, TS>> predicate)
        {
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate");
            }
            var knownTypes = new List<Type> { typeof(T) };
            var serializer = CreateSerializer(knownTypes);
            return serializer.Serialize(predicate);
        }

        public static Expression DeserializeExpression(XElement xmlExpression)
        {
            if (xmlExpression == null)
            {
                throw new ArgumentNullException("xmlExpression");
            }
            var serializer = CreateSerializer();
            return serializer.Deserialize(xmlExpression);
        }

        public static Expression<Func<T, TS>> DeserializeExpression<T, TS>(XElement xmlExpression)
        {
            if (xmlExpression == null)
            {
                throw new ArgumentNullException("xmlExpression");
            }
            var knownTypes = new List<Type> { typeof(T) };
            var serializer = CreateSerializer(knownTypes);
            return serializer.Deserialize<Func<T, TS>>(xmlExpression);
        }

        public static Expression<Func<T, TS>> DeserializeExpression<T, TS>(XElement xmlExpression, IEnumerable<Type> knownTypes)
        {
            if (xmlExpression == null)
            {
                throw new ArgumentNullException("xmlExpression");
            }
            var serializer = CreateSerializer(knownTypes);
            return serializer.Deserialize<Func<T, TS>>(xmlExpression);
        }

        private static ExpressionSerializer CreateSerializer(IEnumerable<Type> knownTypes = null)
        {
            if (knownTypes == null || !knownTypes.Any())
            {
                return new ExpressionSerializer();
            }
            var assemblies = new List<Assembly> { typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
            knownTypes.ToList().ForEach(type => assemblies.Add(type.Assembly));
            var resolver = new TypeResolver(assemblies, knownTypes);
            var knownTypeConverter = new KnownTypeExpressionXmlConverter(resolver);
            var serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { knownTypeConverter });
            return serializer;
        }
    }
}

 

服務實現代碼重構：

public Member GetMember(XElement xmlPredicate)
{
    var predicate = SerializeHelper.DeserializeExpression<Member, bool>(xmlPredicate);
    return DataSource.SingleOrDefault(predicate.Compile());
}

 

客戶端代碼重構：

static void Main(string[] args)
{
    Console.WriteLine("按任意建執行客戶端調用：");
    Console.ReadLine();
    try
    {
        Expression<Func<Member, bool>> predicate = m => m.UserName == "zhangsan";
        Console.WriteLine(predicate);
        var xmlPredicate = SerializeHelper.SerializeExpression(predicate);
        var result = WcfHelper.InvokeService<IAccountContract, Member>(wcf => wcf.GetMember(xmlPredicate));
        Console.WriteLine(result.Email);

        var input = Console.ReadLine();
        if (!string.IsNullOrEmpty(input))
        {
            predicate = SerializeHelper.CreateExpression<Member, bool>("UserName=@0", input);
            xmlPredicate = SerializeHelper.SerializeExpression(predicate);
            result = WcfHelper.InvokeService<IAccountContract, Member>(wcf => wcf.GetMember(xmlPredicate));
            Console.WriteLine(result.Email);
        }
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
    }
    Console.ReadLine();
}

 

服務端代碼無變化。重構之后，一切都變得井然有序，生活多么美好。

至此，Expression表達式的遠程傳輸中序列化的問題得到了比較圓滿的解決，但是使用Dynamic Expression API生成表達式的步驟失去了原來Lambada表達式的優勢，返祖了。

所以，這只是一個比較初級的解決方案，希望能有更優良的解決方案來保持Lambada表達式的優勢。

第一次寫博客，結構比較凌亂，基本上是按我解決問題的思路流水下來的，不夠清晰，敬請大家諒解……

最后，奉上本文涉及的源代碼：

LambadaSerializeDemo03（重構前）.rar

LambadaSerializeDemo03（重構后）.rar