.NET框架设计—常被忽视的C#设计技巧

阅读目录：

• 1.开篇介绍

• 2.尽量使用Lambda匿名函数调用代替反射调用(走进声明式设计)

• 3.被忽视的特性(Attribute)设计方式

• 4.扩展方法让你的对象如虎添翼(要学会使用扩展方法的设计思想)

• 5.别怕Static属性(很多人都怕Static在Service模式下的设计，其实要学会使用线程本地存储(ThreadStatic))

• 6.泛型的协变与逆变(设计架构接口(Interface)时要时刻注意对象的协变、逆变)

• 7.使用泛型的类型推断(还在为参数类型烦恼吗)

• 8.链式编程(设计符合大脑思维习惯的处理流程)

  • 8.1.链式编程（多条件（方法碎片化）调用

  
  

• 9.部分类、部分方法的使用(扩大设计范围)

1.】开篇介绍

本文中的内容都是我无意中发现觉得有必要分享一下的设计经验，没有什么高深的技术，只是平时我们可能会忽视的一些设计技巧；为什么有这种想法是因为之前跟一些同事交流技术的时候会发现很多设计思维被固化了，比如之前我在做客户端框架开发的时候会去设计一些关于Validator、DTO Transfer等常用的Common function，但是发现在讨论某一些技术实现的时候会被弄的云里雾里的，会自我郁闷半天，不会及时的明白对方在说的问题；

后来发现他们一是没有把概念分清楚，比如.NETFramework、C#、VisualStudio，这三者之间的关系;二是没有理解.NET中各个对象的本质含义，比如这里的特性(Attribute)，大部分人都认为它是被用来作为代码说明、标识使用的，而没有突破这个思维限制，所以在设计一些东西的时候会绕很多弯路；还有一点是很多人对C#中的语法特性分不清版本，当然我们要大概的了解一下哪些特性或者语法是C#2的哪些是C#3的，这样在我们设计东西的时候不会由于项目的版本问题而导致你无法使用设计技巧，比如扩展方法就无法使用在低于.NET3.0版本中，LINQ也无法在低于.NET3.O的版本中使用；

.NETFramework的版本不断的在升级，目前差不多5.0都快面世了；.NETFramework的升级跟C#的升级没有必然的关系，这个要搞清楚；C#是为了更好的与.NET平台交互，它提供给我们的都是语法糖，最后都是.NETCTS中的类型；就比如大家都在写着LINQ，其实到最后LINQ也就被自动解析成对方法的直接调用；

2.】尽量使用委托调用代替反射调用

委托相信大家都玩的很熟，委托的发展到目前为止是相当不错的，从原本很繁琐的每次使用委托的时候都需要定义一个相应的方法用来实例化委托，这点在后来的C#2中得到了改进，支持匿名委托delegate{…}的方式使用，再到现在的C#3那就更方便了，直接使用面向函数式的Lambda表达式；那么这样还需要反射调用对象的方法吗？（当然特殊场合我们这里不考虑，只考虑常用的场景；）当然反射不是不好，只是反射需要考虑很多性能优化方面的东西，增加了代码的复杂性，也让框架变的很重（现在都是在追求轻量级，只有在DomainModel中需要将平面化的数据抽象；），所以何不使用简单方便的委托调用呢；

注：如果你是初学者，这里的委托可以理解成是我们平时常用的Lambda表达式，也可以将它与Expression结合起来使用，Expression是委托在运行时的数据结构，而非代码执行路径；（兴趣的朋友可以查看本人的：LINQ系列文章）

下面我们来看一下演示代码：

/*==============================================================================
 * Author:深度训练
 * Create time: 2013-07-28
 * Blog Address:http://www.cnblogs.com/wangiqngpei557/
 * Author Description:特定领域软件工程实践；
 *==============================================================================*/
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Linq;
using Infrastructure.Common.Cache;
using Infrastructure.Common.Validator;
namespace ConsoleApplication1.DomainModel
{
    /// 

    /// Order.
    /// 
    [EntityCache(10, true)]
    [EntityValidator(ValidatorOperationType.All)]
    public class Order
    {
        /// 

        /// Order code.
        /// 
        public string OrderCode { get; set; }
        /// 

        /// Items filed.
        /// 
        private List items = new List();
        /// 

        /// Gets items .
        /// 
        public IEnumerable Items { get { return items; } }
        /// 

        /// Submit order date.
        /// 
        public DateTime SubmitDate { get; set; }
        /// 

        /// Mark  Instance.
        /// 
        /// Order code. 
        public Order(string orderCode)
        {
            this.OrderCode = orderCode;
        }
        /// 

        /// Sum items prices.
        /// 
        /// item type.
        /// prices .
        public double SumPrices(int itemUsingType)
        {
            double resultPrices = 0.00;
            var currentItems = items.GroupBy(item => item.ItemUsingType).Single(group => group.Key == itemUsingType);
            if (currentItems.Count() > 0)
            {
                foreach (var item in currentItems)
                {
                    resultPrices += item.Price;
                }
            }
            return resultPrices;
        }
        /// 

        /// Add item to order.
        /// 
        /// Item.
        /// bool.
        public bool AddItem(Item item)
        {
            if (!item.ItemCode.Equals(string.Empty))
            {
                this.items.Add(item);
                return true;
            }
            return false;
        }
    }
}

这是一个订单领域实体，它里面引用了一个Item的商品类型；

/*==============================================================================
 * Author:深度训练
 * Create time: 2013-07-28
 * Blog Address:http://www.cnblogs.com/wangiqngpei557/
 * Author Description:特定领域软件工程实践；
 *==============================================================================*/
using System;
namespace ConsoleApplication1.DomainModel
{
    /// 

    /// Order item.
    /// 
    public class Item
    {
        /// 

        /// Item code.
        /// 
        public Guid ItemCode { get; set; }
        /// 

        /// Item price.
        /// 
        public float Price { get; set; }
        /// 

        /// Item using type.
        /// 
        public int ItemUsingType { get; set; }
    }
}

/*============================================================================== * Author:深度训练 * Create time: 2013-07-28 * Blog Address:http://www.cnblogs.com/wangiqngpei557/ * Author Description:特定领域软件工程实践； *==============================================================================*/using System;namespace ConsoleApplication1.DomainModel{/// 
/// Order item./// publicclass Item    {/// 
/// Item code./// public Guid ItemCode { get; set; }/// 
/// Item price./// publicfloat Price { get; set; }/// 
/// Item using type./// publicint ItemUsingType { get; set; }    }}

上面代码应该没有问题，基本的订单领域模型大家都太熟了；为了保证上面的代码是绝对的正确，以免程序错误造成阅读者的不爽，所以都会有100%的单元测试覆盖率；这里我们主要使用的是Order类中的SumPrices方法，所以它的UnitTest是100%覆盖；

图1：

Order中的SumPrices方法的UnitTest代码：

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using NSubstitute;
namespace ConsoleApplication.UnitTest
{
    using ConsoleApplication1.DomainModel;
    /// 

    /// Order unit test.
    /// 
    [TestClass]
    public class DomainModelOrderUnitTest
    {
        /// 

        /// Order sumprices using type 1 test.
        /// 
        [TestMethod]
        public void DomainModelOrderUnitTest_SumPrices_ItemUsingTypeIs1_UnitTest()
        {
            Order testOrder = new Order(Guid.NewGuid().ToString());
            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 10.0F });
            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 15.0F });
            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 20.0F });
            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 30.0F });
            double result = testOrder.SumPrices(1);
            Assert.AreEqual(result, 25.0F);
        }
        /// 

        /// Order sumprices using type is 2 test.
        /// 
        [TestMethod]
        public void DomainModelOrderUnitTest_SumPrices_ItemUsingTypeIs2_UnitTest()
        {
            Order testOrder = new Order(Guid.NewGuid().ToString());
            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 10.0F });
            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 15.0F });
            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 20.0F });
            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 30.0F });
            double result = testOrder.SumPrices(2);
            Assert.AreEqual(result, 50.0F);
        }
    }
}

using System;using Microsoft.VisualStudio.TestTools.UnitTesting;using NSubstitute;namespace ConsoleApplication.UnitTest{using ConsoleApplication1.DomainModel;/// 
/// Order unit test./// [TestClass]publicclass DomainModelOrderUnitTest    {/// 
/// Order sumprices using type 1 test./// [TestMethod]publicvoid DomainModelOrderUnitTest_SumPrices_ItemUsingTypeIs1_UnitTest()        {            Order testOrder = new Order(Guid.NewGuid().ToString());            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 10.0F });            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 15.0F });            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 20.0F });            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 30.0F });double result = testOrder.SumPrices(1);            Assert.AreEqual(result, 25.0F);        }/// 
/// Order sumprices using type is 2 test./// [TestMethod]publicvoid DomainModelOrderUnitTest_SumPrices_ItemUsingTypeIs2_UnitTest()        {            Order testOrder = new Order(Guid.NewGuid().ToString());            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 10.0F });            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 15.0F });            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 20.0F });            testOrder.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 30.0F });double result = testOrder.SumPrices(2);            Assert.AreEqual(result, 50.0F);        }    }}

在以往我基本上不写单元测试的，但是最近工作上基本上都需要写每个方法的单元测试，而且要求是100%覆盖，只有这样才能保证代码的正确性；也建议大家以后多写单元测试，确实很有好处，我们应该把单元测试做起来；下面我们言归正传；

由于我们的Order是在DomainModel Layer中，现在有一个需求就是在Infrastructure Layer 加入一个动态计算Order中指定Item.ItemUsingType的所有Prices的功能，其实也就是说需要将我们的一些关键数据通过这个功能发送给远程的Service之类的；这个功能是属于Infrastructure中的Common部分也就是说它是完全独立与项目的，在任何地方都可以通过它将DomainModel中的某些领域数据发送出去，那么这样的需求也算是合情合理，这里我是为了演示所以只在Order中加了一个SumPrices的方法，可能还会存在其他一些DomainModel对象，然后这些对象都有一些关键的业务数据需要在通过Infrastructure的时候将它们发送出去，比如发送给配送部门的Service Interface；

那么常规设计可能需要将扩展点配置出来放在指定的配置文件里面，然后当对象经过Infrastructure Layer中的指定Component时触发事件路由，然后从缓存中读取出配置的信息执行，那么配置文件可能大概是这样的一个结构：DomainEntity名称、触发动作、方法名称、参数，DomainEntity名称是确定聚合根，触发动作是对应Infrastructure中的组件，当然你也可以放在DomainModel中；这里只关心方法名称、参数；

当然这里只演示跟方法调用相关的代码，其他的不在代码中考虑；我们来看一下相关代码：

using System;
namespace Infrastructure.Common
{
    public interface IBusinessService
    {
        void SendBusinessData(object callAuthor, string methodName, object parameterInstance);
        void SendBusinessData
(Func callFun, P parameter);
    }
}

using System;namespace Infrastructure.Common{publicinterface IBusinessService    {void SendBusinessData(object callAuthor, string methodName, object parameterInstance);void SendBusinessData
(Funcobject> callFun, P parameter);    }}

这是业务调用接口；

using System;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;
namespace Infrastructure.Common
{
    /// 

    /// Business service .
    /// 
    public class BusinessService : IBusinessService
    {
        /// 

        /// Send service data interface .
        /// 
        private ISendServiceData sendService;
        /// 

        /// Mark  instance.
        /// 
        /// 
        public BusinessService(ISendServiceData sendService)
        {
            this.sendService = sendService;
        }
        /// 

        /// Send business data to service interface.
        /// 
        /// Object author.
        /// Method name.
        /// Method call parameter.
        public void SendBusinessData(object callAuthor, string methodName, object parameterInstance)
        {
            object result =
                callAuthor.GetType().GetMethod(methodName).Invoke(callAuthor, new object[] { parameterInstance });
            if (result != null)
            {
                sendService.Send(result);
            }
        }
        /// 

        /// Send business data to service interface.
        /// 
        /// 
        /// 
        /// 
        public void SendBusinessData
(Func callFun, P parameter)
        {
            object result = callFun(parameter);
            if (result != null)
            {
                sendService.Send(result);
            }
        }
    }
}

using System;using System.Reflection;using System.Linq;using System.Linq.Expressions;namespace Infrastructure.Common{/// 
/// Business service ./// publicclass BusinessService : IBusinessService    {/// 
/// Send service data interface ./// private ISendServiceData sendService;/// 
/// Mark  instance./// /// public BusinessService(ISendServiceData sendService)        {this.sendService = sendService;        }/// 
/// Send business data to service interface./// /// Object author./// Method name./// Method call parameter.publicvoid SendBusinessData(object callAuthor, string methodName, object parameterInstance)        {object result =                callAuthor.GetType().GetMethod(methodName).Invoke(callAuthor, newobject[] { parameterInstance });if (result != null)            {                sendService.Send(result);            }        }/// 
/// Send business data to service interface./// /// /// /// publicvoid SendBusinessData
(Funcobject> callFun, P parameter)        {object result = callFun(parameter);if (result != null)            {                sendService.Send(result);            }        }    }}

这里简单实现IBusinessService接口，其实代码很简单，第一个方法使用反射的方式调用代码，而第二个方法则使用委托调用；在实现类里面还包含了一个简单的接口；

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Infrastructure.Common
{
    public interface ISendServiceData
    {
        void Send(object sendObject);
    }
}

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace Infrastructure.Common{publicinterface ISendServiceData    {void Send(object sendObject);    }}

目的是为了方便单元测试，我们来看一下单元测试代码；

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Infrastructure.Common;
using ConsoleApplication1.DomainModel;
using NSubstitute;
namespace Infrastructure.Common.UnitTest
{
    [TestClass]
    public class InfrastructureCommonBusinsessServiceUnitTest
    {
        [TestMethod]
        public void InfrastructureCommonBusinsessServiceUnitTest_BusinessService_SendBusinessData()
        {
            Order order = new Order(Guid.NewGuid().ToString());
            order.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 10.0F });
            order.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 1, Price = 15.0F });
            order.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 20.0F });
            order.AddItem(new Item() { ItemCode = Guid.NewGuid(), ItemUsingType = 2, Price = 30.0F });
            ISendServiceData mockISendServiceData = Substitute.For();
            object sendresult = null;
            mockISendServiceData.When(isend => isend.Send(Arg.Any