博客园_风云

松耦合服务调用利器-服务分发器

2011-12-19T09:23:00Z

引言

对象和对象之间是通过消息来进行通信的。具体过程如下：

创建对象a
创建对象b
创建请求消息request
调用对象b的方法
对象b返回对应的response

通过上面的过程可以看出通信的调用方需要依赖如下元素：

被调用方（服务契约）
请求消息request( 数据契约）
被调用方的方法（操作契约）
响应消息（数据契约）

那么我们可以把通信的过程通过引入一个间接层-服务分发器来解耦对象间的之间通信，具体过程如下：

创建对象a
创建服务分发器dipatcher
创建请求消息request
调用分发器的分发方法
分发器创建对象b,并调用对象b的方法
对象b返回对应的response 给分发器，分发器把response结果返回给对象a

服务分发器接口定义

定义服务分发器接口

[Contract]
    public interface IServiceDispatcher
    {
        IServiceResponse Dispatch(IServiceRequest req);
    }

定义请求接口

public inter  IServiceRequest
    {
        string ServiceName { get; }
        string OperationName { get; }
        IDictionary<string,object> Arguments { get; }
    }

定义响应接口

public interface IServiceResponse 
    {
        bool Success { get; }
        object Result { get; set; }
        Exception[] Exceptions { get; }
    }
   定义服务分发器门面类ServiceDispatcher

public static class ServiceDispatcher
    {
      public static IServiceResponse Dispatch(IServiceRequest req);
      public static TResult Dispatch<TResult>(string serviceName, string operationName);
      public static TResult Dispatch<TResult>(string serviceName, string operationName, object requestArgs)
     }

服务分发器功能特征

服务类不能是抽象的
服务类必须以“Service”结尾（效仿mvc控制器的约定）
服务类支持别名
服务Action必须是BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public
如果服务Action上含有IgnoreAttribute标签则忽略
服务Action支持方法重载
服务Action支持别名
服务Action暂不支持引用参数和输出参数
支持参数模型绑定机制
支持Filter机制
支持分布式调用
支持和MVC进行整合（把控制器的功能整合到服务中，不需要开发控制器）
整合Mini容器

Demo 例子

添加NLite.dll 引用（可以从NLite 官网下载)
添加Ndf.dll 引用（可以从 Ndf官网下载）
创建一个CalculateService

using NLite;
namespace ConsoleDemo
{
    [Component]
    public class CalculateService
    {
        public int Add(int a, int b)
        {
            return a + b;
        }
        public int Sub(int a, int b)
        {
            return a - b;
        }
        public int Multiply(int a, int b)
        {
            return a * b;
        }
        public int Divide(int a, int b)
        {
            return a / b;
        }
    }
}

4. 添加测试程序

using System;
using NLite;
using NLite.Cfg;
using NLite.Domain;

namespace ConsoleDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Config Ndf 组件
            new Configuration().Configure();

            //Registery CalculteService in current assembly
            ServiceRegistry.RegisteryFromAssemblyOf<Program>();

            //call CalculteService.Add method
            int result = ServiceDispatcher.Dispatch<int>("calculate", "add", new { a = 2, b = 3 });
            Console.WriteLine("2 + 3 = " + result.ToString());

            //call CalculteService.Sub method
            result = ServiceDispatcher.Dispatch<int>("calculate", "sub", new { a = 2, b = 3 });
            Console.WriteLine("2 - 3 = " + result.ToString());

            //call CalculteService.Multiply method
            result = ServiceDispatcher.Dispatch<int>("calculate", "multiply", new { a = 2, b = 3 });
            Console.WriteLine("2 * 3 = " + result.ToString());

            //call CalculteService.Divide method
            result = ServiceDispatcher.Dispatch<int>("calculate", "divide", new { a = 2, b = 3 });
            Console.WriteLine("2 / 3 = " + result.ToString());

            Console.Read();
        }
    }
}

运行结果如下：

最后附上Demo代码

本文链接

为ASP.NET MVC创建一个基于Mini容器的ControllerFactory

2011-12-19T04:13:00Z

背景

随着Asp.net mvc的越来越流行，关于和Mvc整合的DI容器也非常的多，而Mini容器一致没有把整合的方案发布出来，以至于不时的收到有些网友询问这些事，于是便有了该文。[源代码从这里下载，Mini容器官方地址]

解决方案

创建自定义工厂

public class NLiteControllerFactory : DefaultControllerFactory
    {
        private IServiceLocator ServiceLocator;
        public NLiteControllerFactory(IServiceLocator serviceLocator)
        {
            this.ServiceLocator = serviceLocator;
        }

        protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)
        {
            return (IController)ServiceLocator.Get(controllerType);
        }
    }

Demo 例子

为了演示效果效果, 用Artech兄的为ASP.NET MVC创建一个基于Unity的ControllerFactory这篇博客的例子了. 要创建一个维护联系人的应用，我们通过具有如下定义的Contact类型表示联系人，而IContactRepository接口定义了一个从存储中获取所有联系人的GetAllContacts方法，DefaultContactRepository是对IContactRepository接口的实现

public class Contact
    {
        public string Name { get; set; }
        public string Gender { get; set; }
        public string Address { get; set; }
    }
    
    [Contract]
    public interface IContactRepository
    {
        IEnumerable<Contact> GetAllContacts();
    }

    public class DefaultContactRepository : IContactRepository
    {
        public IEnumerable<Contact> GetAllContacts()
        {
            yield return new Contact
            {
                Name = "Zhang San",
                Gender = "Male",
                Address = "#328, XingHu Street, Su Zhou, Jiang Su Province, PRC."
            };

            yield return new Contact
            {
                Name = "Li Si",
                Gender = "Female",
                Address = "#328, Jin Ji Hu Road, Su Zhou, Jiang Su Province, PRC."
            };
        }
    }

我们在Web应用的主页显示联系人列表，为此我创建了如下一个HomeController。在这里我们演示的是构造器注入，所以我们通过构造函数指定的IContactRepository对象来初始化Repository属性。在Action方法Index中调用IContactRepository的GetAllContacts方法为对应的View指定Model。

public class HomeController : Controller
    {
        public IContactRepository Repository { get; private set; }
        public HomeController(IContactRepository repository)
        {
            this.Repository = repository;
        }
        public ActionResult Index()
        {
            return View(this.Repository.GetAllContacts());
        }

    }

在Global 文件中注册Mvc 的自定义控制器工厂

public class MvcApplication : System.Web.HttpApplication
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new HandleErrorAttribute());
        }

        public static void RegisterRoutes(RouteCollection routes)
        {
           routes.IgnoreRoute("favicon.ico");
           routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            routes.MapRoute(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            );

        }

        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();

            RegisterGlobalFilters(GlobalFilters.Filters);
            RegisterRoutes(RouteTable.Routes);

            //创建Mini容器
            NLiteEnvironment.Refresh();
            
            //设置组件的生命周期缺省是临时的
            LifestyleType.Default = LifestyleFlags.Transient;

            //注册联系人仓储组件
            ServiceRegistry.Register<DefaultContactRepository>();

            //设置自定义控制器工厂
            ControllerBuilder.Current.SetControllerFactory(new NLiteControllerFactory(ServiceLocator.Current));
        }
    }

Index.cshtml代码如下所示，这是一个Model类型为IEnumerable<Contact>的View，它将所有的联系人信息列出来。

@model IEnumerable< NLite.Mvc.Models.Contact>
   @{
       ViewBag.Title = "Index";
   }
    
   <h2>Contact List</h2>
    
   <div>
   <ul>
   @foreach (var contact in this.Model)
   { 
       <li>
           <h3>@contact.Name</h3>
           <p>Gender: @contact.Gender</p>
           <p>Address: @contact.Address</p>
           <hr />
       </li>
   }
   </ul>
   </div>

运行浏览器显示效果

本文链接

数据库性能优化-摘录

2011-06-20T07:12:00Z

1. 树表设计，建议在树表中增加字段TreePath

2. 记录超过一百万的表要考虑是否需要使用分区表。对于能够明确确定分区字段，并且经常通过分区访问记录的。分区表会提高查询性能。

3. 反范式

在第三范式设计的基础上，针对具体的数据情况和应用访问数据情况进行的设计，使用适当的数据冗余和数据不一致风险，提供更高的数据访问性能，以保障应用的性能要求。

4. 避免使用Select *

5. 使用Set代替Select进行赋值

6. 必要的时候，使用关键字”NOLOCK”避免锁定

7. 不需要排序的时候，不要使用关键字”Order

8. 字符列字节长度小于等于10时，使用char或者nchar

9. 字符列字节长度大于10时，使用varchar或者nvarchar（实际长度设置需要根据业务需要仔细规划，长度关系到存储空间，关系到缓存占用）

10. 需要使用小数时，不要使用数据类型float，而使用decimal

11. 日期存储时，使用datetime，不要使用字符类型

12. 请不要使用ntext，text，image数据类型，而使用nvarchar(max)，varchar(max)，varbinary(max)类型

13. 考虑自增长列的长度（例如：部件关系表数据量会溢出int类型数据的范围）

14. 索引

*组合或者引用关系的子表（数据量较大的时候），需要在关联主表的列上建立非聚集索引（如订单明细表中的产品ID字段、订单明细表中关联的订单ID字段）

*索引键的大小不能超过900个字节，当列表的大小超过900个字节或者若干列的和超过900个字节时，数据库将报错。

*表中如果建有大量索引将会影响INSERT、UPDATE和DELETE语句的性能，因为在表中的数据更改时，所有的索引都将必须进行适当的调整。需要避免对经常更新的表进行过多的索引，并且索引应保持较窄，就是说：列要尽可能的少。

*为经常用于查询的谓词创建索引，如用于下拉参照快速查找的code、name等。在平台现有下拉参照的查询sql语句中的like条件语句要改成不带前置通配符。还有需要关注Order By和Group By谓词的索引设计，Order By和Group By的谓词是需要排序的，某些情况下为Order By和Group By的谓词建立索引，会避免查询时的排序动作。

*对于内容基本重复的列，比如只有1和0，禁止建立索引，因为该索引选择性极差，在特定的情况下会误导优化器做出错误的选择，导致查询速度极大下降。

*当一个索引有多个列构成时，应注意将选择性强的列放在前面。仅仅前后次序的不同，性能上就可能出现数量级的差异。

*对小表进行索引可能不能产生优化效果，因为查询优化器在遍历用于搜索数据的索引时，花费的时间可能比执行简单的表扫描还长，设计索引时需要考虑表的大小。记录数不大于100的表不要建立索引。频繁操作的小数量表不建议建立索引（记录数不大于5000条）

阻塞原因

在默认事务隔离情况下，数据库事务越长，一方面独占锁被持有的时间越长，写操作阻塞读操作的机会就越多；另一方面，在默认的读提交隔离模式下，读操作使用共享锁与独占锁不兼容，读操作也会阻塞写操作。

阻塞也是死锁产生的基本条件，改善了阻塞就能有效减少死锁。

在软件开发后期，在对大数据量的集成测试工程中，通过活动查看器可以观察到阻塞情况，主要产生阻塞的原因就是读和写相互阻塞在对同一个大表的操作上。因此对于读写阻塞问题需要加以足够考虑。

减少阻塞一些指导原则

整体原则

*归结起来也依赖于代码、sql的优化，一方面要使逻辑代码优化到最快。另一方面，一个耗时较长的sql语句将会阻塞全部用户等待几十秒甚至几分钟，针对查询sql语句的优化也是最重要的。

*修改批量操作的需求，批量操作耗时和记录数量是成正比的。为此设计时要避免在同一个自动事务服务方法中做批量的循环操作，可以将循环操作放到UI控制端，这一就使一个长事务变成多个短小的事务，将减少阻塞的机会。

*减少读写操作使用锁的数量，比如减少批更新操作中修改行的数量，保证行锁定少，同时减少锁升级至表锁的机会。

*一些耗时大、锁定数据多的操作需要避免和正常业务操作冲突，可以使用调度计划在系统闲置的时候来运行，或者使用互斥机制来保证其它用户暂退出操作独立运行，视业务情况而定。

读写锁阻塞的处理原则

*减少读操作需要的共享锁

1、将事务隔离级别由默认读提交（ReadCommited）修改成读未提交（ReadUnCommited）,将不会有读写阻塞，但是会造成读取其它事务未提交的数据。

方法一：如果服务方法为自动事务，则在服务方法特性SerivceMethod指定IsolationLevel属性为ReadUnCommited

方法二：对于使用手工事务的情况，使用DBSession接口带隔离级别参数的方法session.beginTransaction(IsolationLevel), level值为 ReadUnCommited.

2、在select语句中带NoLock提示，事务内无锁提示也不会有读写阻塞，与上面一样也会有脏读。

Select上加无锁控制，在执行select操作时加 with(nolock)。如：SELECT * FROM person WITH(NoLock)

上面两种方式需要平台和业务涉及人员根据情况使用。事务隔离级别控制粒度较粗，使用时需要考虑对多个select语句的影响，NoLock提示控制单个select语句，粒度更细。

*在sqlserver2005中使用基于行版本的快照隔离模式

在快照模式下，读取数据不再使用共享锁，阻塞的现象能大大减少。

方法：在建立数据库后执行下面命令：

ALTER DATABASE 替换的数据库名 SET READ_COMMITIED_SNAPSHOT ON;

ALTER DATABASE 替换的数据库名 SET ALLOW_SNAPSHOT_ISOLATION ON;

注意：sqlserver2005和with(no lock)语句，这两种方案都能够避免阻塞，但是这两种方式是有区别的。

举个小例子说明一下：比如数据库表T1中有两个字段Col1且其默认值为1.此时恰好有个A事务通过Update语句修改表T1的Col字段值为2，但还未提交，如下：

A事务：

{

Begion tran

Update T1 set Col1=2

//Commit;//注释掉此句，模拟A事务未提交。

}

这时如果另一个事务如果使用Sql server2005的快照模式获取T1表Col1字段的值则取到的值是之前默认的1；而使用with（no lock）的方式获取到Col1字段的值为2.

其实不管使用哪种方式，得到的数据都不确保是准确的，这要取决于A事务是否执行并提交成功。

==============================================================================================

死锁原因：

死锁是由两个相互阻塞的线程组成，它们互相等待对方完成，一般死锁情况下两个数据库事务之间存在着相反的操作。sqlserver中死锁监视器定时检查死锁，如果发现死锁，将选择其中回滚消耗最小的任务，这时候发生1025数据库错误。可以通过启用sqlserver2005快照模式，避免一些读/写的逆向阻塞造成的死锁.但是对于一些写/写阻塞的死锁可能无法解决，很多时候需要从业务的角度来避免一些写/写的逆向操作阻塞情况。

死锁问题的解决很困难，但是可以通过一些手段来使死锁最小化。

死锁最小化方法：

从理论上讲，数据库死锁无法避免，但是可以遵循一定原则使死锁发生的概率尽量降低。

写/写死锁

*用相同的顺序访问对象，如果涉及到多于一张表的操作，要保证事务中都按照相同的顺序访问这些表。

*减少一个事务中的大批量更新的操作，大批量操作写操作涉及记录独占锁太多而且一直到事务结束才能释放，更容易与其它事务造成死锁。

读/写死锁（原则上与前面提到的减少读/写阻塞方式一致）

*去掉读操作的共享锁

最佳方式是使用sql2005的快照模式，其次方式是使用读未提交隔离模式或使用NOLock提示，需要平台和业务设计时依据情况进行sql组织的设计。

按照相同的顺序访问对象可以避免相互持有对方请求资源的情况发生。例如一个操作主从表的处理流程，涉及查询和修改两个步骤。如果查询时是先查主表再查从表，则修改也应先修改主表再修改从表。

另一个降低事务大小的一个主要手段，是将查询操作尽可能地提前（包括使用一些中间变量记录下查询结果提供后续使用），而把插入、修改等操作集中在方法靠后的部分。这样，可以让一个事务需要持有独占锁的时间尽可能缩短，减少死锁的发生概率。

==============================================================================================

1、参数化sql

对于一般简单查询，数据库能自动参数啊以重用计划缓存，如：

在sqlserver内部能自动参数化这个查询，SELECT * FROM table WHERE id=@1

但是一旦sql语句中带有join、union、top……等关键字，sqlserver内部将不会自动参数化。

在sql2005中，通过alter database XXX set paramenterization forced的强制参数化命令能够将所有sql中的常量参数化，但是强制参数化会因为常量类型不一致造成查询结果误差。

2、使用查询中的索引有效

a）、单列索引使用原则

单列索引能响应大部分的简单比较，包括等价和不等价。对于like操作无前置通配符也是有效的。如：

能有效使用索引的条件语句：

[col1]=1
[col1]>100
[col1] between 0 and 100
[col1] like 'abc%'

下列条件语句不会有效利用索引:

ABS([col1])=1

[col1]+1>100

[col1]+10 between 0 and 100

[col1] like '%abc%'

b)、避免在WHERE字句中对字段进行函数或表达式操作

看一下下面效率低下的例子和其解决方法

效率低下的写法：

SELECT *
FROM Production.Product
WHERE SafetystockLevel/2=100

高效写法：

SELECT *
FROM Production.Product
WHERE SafetystockLevel=2*100

下面是SQLServer2005的优化报告

类似的例子：

效率低下的写法	高效的写法
SELECT * FROM Production.Product WHERE SubString(name,1,3)=’abc’	SELECT * FROM Production.Product WHERE name like ’abc%’
SELECT * FROM Production.Product WHERE datediff(day ,modifiedDate,’2005-11-30’)=0	SELECT * FROM Production.Product WHERE modifiedDate>=’2005-11-30’ andmodifiedDate<’2005-12-1’

任何对列的操作都将导致表扫描，它包括数据库函数、计算表达式等等，查询时要尽可能将操作移至等号右边。

避免使用！=或<>、is null 或is not null、 in、not in等这样的操作符，因为这会是系统无法使用索引，而只能直接搜索表中数据。

例如：

select id from employee where id!=’B%’

优化器将无法通过索引来确定将要命中的行数，因此需要搜索该表的所有行。

c)、多列索引使用原则

则应考虑列的顺序。用于等于(=)、大于(>)、小于(<)或between搜索条件的where 字句或者参与联接的列应该放在最前面。其它列应该基于其非重要级别进行排序，就是说，从最不重复的列到最重复的列。

例如：

如果表中存在索引定义为LastName、FirstName,则该索引在搜索条件为where LastName=’Smith’或where LastName=Smith and FirstName like ’j%’时将很有用。不过，查询优化器不会将此索引用于基于FirstName(where FirstName=’Jane’)而搜索的查询。

==============================================================================================

一、SQL拼写建议

1、查询时不返回不需要的行、列

业务代码要根据实际情况尽量减少对表的访问行数，最小化结果集，在查询时，不要过多地使用通配符如：select * from table1语句，要用到几列就选择几列，如：select col1,col2 from table1;在可能的情况下尽量限制结果集行数如：select top 100 col1,col2,col3 from talbe2,因为某些情况下用户是不需要那么多的数据的。

2、合理使用EXISTS, NOT EXISTS字句

如下所示：

SELECT SUM(T1.C1) FROM T1 WHERE ((SELECT COUNT(*) FROM T2 WHERE T2.C2=T1.C2)>0)

SELECT SUM(T1.C1) FROM T1 WHERE EXISTS(SELECT * FROM T2 WHERE T2.C2=T1.C2)

两种产生相同的结果，但是后者的效率显然要高过于前者。银行后者不会产生大量锁定的表扫描或是索引扫描。

经常需要些一个T_SQLL语句比较一个父结果集和子结果集，从而找到是否存在在父结果集中有而在子结果集中乜嘢的记录，如：

SELECT _a.hdr_key FROM hdr_tb1 a -----------tb1 a 表示tb1用别名a代替

WHERE NOT EXISTS (SELECT * FROM dt1_tb1 b WHERE a.hdr_key = b.hdr_key)

SELECT _a.hdr_key FROM hdr_tb1 a -----------tb1 a 表示tb1用别名a代替

LEFT JION dt1_tb1 b ON a.hdr_key = b.hdr_key WHERE b.hdr_key IS NULL

SELECT hdr_key FROM hdr_tb1

WHERE hdr_key NOT IN (SELECT hdr_key FROM dt1_tb1)

三种写法都可以得到同样的结果集，但是效率是依次降低

3、充分利用连接条件

在某种情况下，两个表之间可能不止一个的连接条件，这时在where 字句中将谅解条件完整的写上，有可能大大提高查询速度。

例：

a)、SELECT SUM(A.AMOUNT) FROM ACCOUNT A left jion CARD B on A.CARD_NO = B.CARD_NO

b)、SELECT SUM(A.AMOUNT) FROM ACCOUNT A left jion CARD B on A.CARD_NO = B.CARD_NO AND A.ACCOUNT_NO = B.ACCOUNT_NO

第二句将比第一句执行快得多。

4、WHERE 字句中关系运算符的选择

a)、在关系运算中，尽量使用=，尽量不要使用<>。

b)、WHERE字句中尽量不要使用NOT运算符，如：NOT IN ,NOT EXISTS, NOT>、NOT<等等NOT运算符一般可以去除。如NOT SALARY >10000K可以改为：salary<=100,如避免使用NOT IN,可以使用 left outer jion代替它。

c)、where 字句中条件表达式间逻辑关系为AND时，将条件为假的概率高的放在前面，概率相同、条件计算简单的放在前面。

d)、尽可能不要用Order by字句。使用Order by时，尽量减少列数、尽量减少排序数据行数、排序字段尽量是数字型（尽量不要是字符型）。GROUP BY、 SELECT DITINCT、UNION等字句，也经常导致Order运算。

e)、不要使用Select count(*)方式来判断记录是否存在，建议使用Select top 1 from table1 where ……。

f)、不要使用Group by而没有聚合列。

g)、避免Select 语句的Where 字句条件用于假。如：where 1=0;

h)、如果有多表连接时，应该有主从表之分，并尽量从一个表读取数，如select a.col1,a.col2 from a jion b on a.col3=b.col4 where b.col5=’a’.

i)、在where 字句中，如果有多个过滤条件，应将所有列或过滤记录数量最多的条件应该放在前面。

二、使用Truncate清空表

Truncate会将表中记录全部清空，而不能有选择性的删除指定记录。而DELETE可以指定删除的记录。由于Truncate操作在TransactionLog中只记录被Truncate的页号，而DELETE需要记载被删除记录的详细内容，因此Truncate会比DELETE更迅速。对大数据表使用Truncate，效果更加明显。Truncate Table只会删除表中记录。而不会对表的索引和结构造成影响。

三、Union和Union all

Union将两个结果集合并后，会消除重复记录，而Union all不会消除重复记录，而是直接将两个结果集直接合并。明确得知两个结果集中没有重复记录或者重复记录不影响使用，建议使用Union all 代替Union。因为Union在消除重复记录的过程中需要进行排序过滤操作，对大结果集这种排序操作会非常影响性能。下面是Union 和Union all的简单性能比较：

---------------Union

select * from table1 where code=’01’

Union

select * from table1 where code=’02’

---------------Union all

select * from table1 where code=’01’

union all

select * from talbe1 where code=’02’

==============================================================================================

本文链接

Web 高性能开发汇总

2011-06-20T06:53:00Z

以下内容收集了Web高性能开发的相关文章

1. Http服务器：

让Windows Server 2008+IIS 7+ASP.NET支持10万个同时请求

大规模网站架构实战之体系结构（一）

大规模网站架构之WEB加速器SQUID(二)

iis负载均衡

Nginx 常见配置总结

nginx实现网站负载均衡(windows+IIS负载实测)

玩玩负载均衡---在window与linux下配置nginx

Windows版本nginx

大型架构.net平台篇(WEB层均衡负载nginx)

构建高性能ASP.NET站点开篇

构建高性能ASP.NET站点之一剖析页面的处理过程（前端）

构建高性能ASP.NET站点之二优化HTTP请求(前端)

　　构建高性能ASP.NET站点之三细节决定成败

构建高性能ASP.NET站点第五章—性能调优综述（前篇）

大型高性能ASP.NET系统架构设计

构建高性能ASP.NET站点第五章—性能调优综述（中篇）

构建高性能ASP.NET站点第五章—性能调优综述（后篇）

构建高性能ASP.NET站点第六章—性能瓶颈诊断与初步调优（上篇）—识别性能瓶颈

构建高性能ASP.NET站点第六章—性能瓶颈诊断与初步调优（下前篇）—简单的优化措施

构建高性能ASP.NET站点第六章—性能瓶颈诊断与初步调优（下后篇）—减少不必要的请求

构建高性能ASP.NET站点第七章如何解决内存的问题(前篇)—托管资源优化—垃圾回收机制深度剖析

构建高性能ASP.NET站点第七章如何解决内存的问题(前中篇)—托管资源优化—监测CLR性能

关于大型asp.net应用系统的架构—如何做到高性能高可伸缩性

本文链接

数据库大型应用解决方案总结 - 笔记

2011-06-20T05:48:00Z

　　数据库大型应用解决方案总结，这篇文章非常详细的总结了在大型项目中，关于数据库的解决方案。

负载均衡技术
读写分离技术
分库（垂直，按功能模块）分表（水平，顺序拆分，hash取模分，在认证库中保存数据库配置）技术

当数据库读取压力太大时应当考虑读写分离技术。

当master负载太高时就要垂直分区-分库

当系统中特定的表异常大时就要考虑进行水平分区（分表）

大型的应用必然会经过一个从单一DB server,到Master/salve,再到垂直分区（分库），然后再到水平分区（分表，sharding）的过程，而在这个过程中，Master/salve 以及垂直分区相对比较容易，对应用的影响也不是很大，但是分表会引起一些棘手的问题，比如不能跨越多个分区join查询数据，如何平衡各个shards的负载等等，这个时候就需要一个通用的DAL框架来屏蔽底层数据存储对应用逻辑的影响，使得底层数据的访问对应用透明化

本文链接

DI 容器-Mini容器工作机制剖析(下篇）

2011-04-22T09:12:00Z

上篇介绍了DI容器最基本功能，组件注册和组件创建和组件获取。这里将陆续把依赖注入进行详细介绍。

1. 看看组件工厂接口-IActivator的代码：

    /// <summary>
    /// 组件工厂
    /// </summary>
    public interface IActivator
    {
        /// <summary>
        /// 创建组件
        /// </summary>
        /// <param name="ctx">创建上下文</param>
        /// <returns>返回所创建的组件</returns>
        object Create(IPreCreationContext ctx);
    }

2. AbstractActivator 抽象组件工厂定义了创建组件的一系列模板步骤，具体的子类只要实现各自的具体步骤即可，下面是抽象组件工厂的源代码：

/// <summary>
    /// 抽象组件工厂
    /// </summary>
    [Serializable]
    public abstract class AbstractActivator : BooleanDisposable, IActivator
    {
        private readonly object SyncRoot = new object();
        private bool hasLock;

        /// <summary>
        /// 创建组件
        /// </summary>
        /// <param name="context">创建上下文</param>
        /// <returns>返回所创建的组件</returns>
        public virtual object Create(IPreCreationContext context)
        {

            //1. 记录并跟踪组件创建的对象图
            Tracker.Track(context);

            //2. 检查是否循环依赖创建组件,如果是Throw LoopDependencyException
            if (hasLock)
                throw ExceptionManager.HandleAndWrapper<LoopDependencyException>(Tracker.CallStack);

            object instance = null;

            lock (SyncRoot)
            {
                hasLock = true;

                //3. 得到组件监听管理器
                var componentListner = context.Kernel.ListenerManager as IComponentListener;

                //4. 在组件创建前进行监听
                if (componentListner != null)
                    componentListner.OnPreCreation(context);
               
                //5. 具体的 Create instance
                instance = InternalCreate(context);

                if (componentListner != null)
                {
                    //6. 在组件创建后进行监听（这里就是依赖注入的扩张点）
                    var postCreateContext = new PostCreationContext(context.Kernel, context.Component, instance);
                    componentListner.OnPostCreation(postCreateContext);

                    //7. 在组件创建后对组件初始化进行监听
                    componentListner.OnInitialization(postCreateContext);
                    //8. 在组件初始化后进行监听
                    componentListner.OnPostInitialization(postCreateContext);
                }

                Tracker.Clear();

                hasLock = false;
            }

            return instance;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        protected virtual object InternalCreate(IPreCreationContext context) { throw new NotImplementedException(); }
    }

通过代码可以看出组件工厂里面并没有提供任何依赖注入的扩展，但是有一系列组件监听器的监听方法：

OnPreCreation
OnPostCreation
OnInitialization
OnPostInitialization

通过这些监听方法可以非常方便的对组件内部的字段，属性进行初始化（也就是依赖注入）

3. 完整的组件监听器接口定义：

/// <summary>
    /// 组件监听阶段枚举
    /// </summary>
    [Flags]
    public enum ComponentListenStage
    {
        /// <summary>
        /// 空
        /// </summary>
        None = 1,

        /// <summary>
        /// 组件元数据注册后阶段
        /// </summary>
        MetadataRegistered = None * 2,

        /// <summary>
        /// 组件创建前阶段
        /// </summary>
        PreCreation = MetadataRegistered * 2,

        /// <summary>
        /// 组件创建后阶段
        /// </summary>
        PostCreation = PreCreation * 2,

        /// <summary>
        /// 初始化阶段
        /// </summary>
        Initialization = PostCreation * 2,

        /// <summary>
        /// 初始化后阶段
        /// </summary>
        PostInitialization = Initialization * 2,

        /// <summary>
        /// 组件释放前阶段
        /// </summary>
        PreDestroy = PostInitialization * 2,

        /// <summary>
        /// 组件释放后阶段
        /// </summary>
        PostDestroy = PreDestroy * 2,
    }


    /// <summary>
    /// 组件监听器接口，在组件元数据注册，组件创建前后，组件初始化前后以及组件释放前后进行监听
    /// </summary>
    [Contract]
    public interface IComponentListener:IListener<ComponentListenStage>
    {
        /// <summary>
        /// 初始化监听器
        /// </summary>
        /// <param name="kernel"></param>
        void Init(IKernel kernel);

        /// <summary>
        /// 得到内核容器对象
        /// </summary>
        IKernel Kernel { get;  }

        /// <summary>
        /// 在组件元数据注册后进行监听，例如Aop监听器
        /// </summary>
        /// <param name="info"></param>
        void OnMetadataRegistered(IComponentInfo info);

        /// <summary>
        /// 在组件创建前进行监听
        /// </summary>
        /// <param name="ctx"></param>
        void OnPreCreation(IPreCreationContext ctx);

        /// <summary>
        /// 在组件创建后进行监听
        /// </summary>
        /// <param name="ctx"></param>
        void OnPostCreation(IPostCreationContext ctx);

        /// <summary>
        /// 在组件创建后对组件初始化进行监听
        /// </summary>
        /// <param name="ctx"></param>
        void OnInitialization(IPostCreationContext ctx);

        /// <summary>
        /// 在组件初始化后进行监听
        /// </summary>
        /// <param name="ctx"></param>
        void OnPostInitialization(IPostCreationContext ctx);

        /// <summary>
        /// 在组件释放前进行监听
        /// </summary>
        /// <param name="info"></param>
        /// <param name="instance"></param>
        void OnPreDestroy(IComponentInfo info, object instance);

        /// <summary>
        /// 在组件释放后进行监听
        /// </summary>
        /// <param name="info"></param>
        void OnPostDestroy(IComponentInfo info);
    }

4. Mini容器构造函数里面默认注册的组件监听器：

public Kernel(
            IComponentListenerManager listnerManager,
            ILifestyleManagerFactory lifestyleManagerRegistry,
            IActivatorFactory activatorFactory,
            IClassLoader classLoader)
        {
            ListenerManager = listnerManager;
            LifestyleManagerRegistry = lifestyleManagerRegistry;
            ActivatorRegistry = activatorFactory;

            IdStores = new ConcurrentMap<string, ComponentPair>(StringComparer.OrdinalIgnoreCase);
            TypeStores = new ConcurrentMap<Type, List<ComponentPair>>();

            Listner = ListenerManager as IComponentListener;

            RegisterInstance("ServiceLocator", typeof(IServiceLocator), this);
            RegisterInstance("ServiceRegistry", typeof(IServiceRegistry), this);
            

            if (classLoader != null)
                RegisterInstance(AppDomain.CurrentDomain.Id.ToString() + ":" + classLoader.GetType(), typeof(IClassLoader), classLoader);

            if (ListenerManager != null)
                ListenerManager.Init(this);

            RegisterListners();
        }

        //注册默认监听器
        private void RegisterListners()
        {
            ListenerManager.Register(new AopListener());//Aop监听器
            ListenerManager.Register(new DisposalListener());//Dispose监听器
            ListenerManager.Register(new InitializationListener());//初始化监听器
            ListenerManager.Register(new SupportInitializeListener());//Support初始化监听器
            ListenerManager.Register(new StartableListener());//启动停止监听器
            ListenerManager.Register(new SubscribeListener());//消息总线的订阅监听器
            ListenerManager.Register(new InjectionListener());//注入监听器
            ListenerManager.Register(new InjectionManyListener());//批量注入监听器
            ListenerManager.Register(new ComponentMemberRegisterListner());//组件成员导出与注入监听器
            ListenerManager.Register(new AppSettingInjectionListener());//AppSetting注入监听器
        }


        /// <summary>
        /// 父容器
        /// </summary>
        public IKernel Parent { get; set; }

        /// <summary>
        /// 组件监听管理器
        /// </summary>
        public IComponentListenerManager ListenerManager { get; private set; }

5. Mini容器提供了很多监听器，下面看看注入监听器的代码：

using System.Linq;
using NLite.Mini.Context;
using NLite.Reflection;
using NLite.Collections;
using System.Reflection;
using NLite.Mini.Internal;
using NLite.Mini.Listener.Internal;
using NLite.Reflection.Internal;

namespace NLite.Mini.Listener
{
    /// <summary>
    /// 注入监听器
    /// </summary>
    public sealed class InjectionListener:ComponentListenerAdapter
    {
        private const BindingFlags Flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
        private const BindingFlags FieldFlags = BindingFlags.SetField | Flags;
        private const BindingFlags PropertyFlags = BindingFlags.SetProperty | Flags;

        /// <summary>
        /// 
        /// </summary>
        public InjectionListener():base(ComponentListenStage.PostCreation)
        {
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ctx"></param>
        public override void OnPostCreation(NLite.Mini.Context.IPostCreationContext ctx)
        {
            if (ctx.Instance == null)
                return;

            const string Key = "InjectionMany";
            Lazy<InjectionInfo[]> lazy = null;
            if (ctx.Component.ExtendedProperties.Contains(Key))
                lazy = ctx.Component.ExtendedProperties[Key] as Lazy<InjectionInfo[]>;

            if (lazy == null)//基于Lazy的方式创建组件的注入元数据
            {
                lazy = new Lazy<InjectionInfo[]>(() =>
                {
                    var instanceType = ctx.Instance.GetType();
                    return (from f in instanceType.GetFields(FieldFlags)
                            let att = f.GetAttribute<InjectAttribute>(true)//字段上有InjectAttribute标签
                            let ignoreAtt = f.GetAttribute<IgnoreInjectAttribute>(true)
                            let id = att != null ? att.Id : string.Empty
                            where ignoreAtt == null
                            where att != null
                            where !f.HasAttribute<InjectManyAttribute>(false)
                            select new InjectionInfo//字段注入元数据
                            {
                                Id = id
                                ,
                                Source = InjectionSource.Container
                                ,
                                Setter = f.ToMemberSetter()//通过Emit的方式进行注入
                                ,
                                MemberType = f.FieldType
                            }

                       )
                       .Union(
                       from p in instanceType.GetProperties(PropertyFlags)
                       let ps = p.GetIndexParameters()
                       let att = p.GetAttribute<InjectAttribute>(false)
                       let ignoreAtt = p.GetAttribute<IgnoreInjectAttribute>(false)
                       let id = att != null ? att.Id : string.Empty
                       where ignoreAtt == null || ps == null || ps.Length == 0
                       where att != null
                       where !p.HasAttribute<InjectManyAttribute>(false)
                       select new InjectionInfo//属性注入元数据
                       {
                           Id = id
                           ,
                           Setter = p.ToMemberSetter()//通过Emit的方式进行注入

                           ,
                           MemberType = p.PropertyType
                           ,
                           Source = InjectionSource.Container
                       })
                       .Union(
                       from m in instanceType.GetMethods(Flags)
                       let ps = m.GetParameters()
                       let att = m.GetAttribute<InjectAttribute>(false)
                       let ignoreAtt = m.GetAttribute<IgnoreInjectAttribute>(false)
                       where ignoreAtt == null
                             && m.ReturnType == Types.Void
                             && att != null
                             && ps.TrueForAll(p => !p.HasAttribute<InjectManyAttribute>(false))
                       select new InjectionInfo//方法注入元数据
                       {
                           Id = att.Id
                           ,
                           Method = DynamicMethodFactory.GetProc(m)
                           ,
                           Parameters = ps
                           ,
                           Source = InjectionSource.Container
                       }
                       ).ToArray();
                });

                ctx.Component.ExtendedProperties[Key] = lazy;
            }

            if (lazy.Value.Length == 0)//没有注入元数据则返回
                return;

            foreach (var item in lazy.Value)
            {
                if (item.MemberType != null)//是字段或属性注入吗
                    InjectMember(ctx, item);
                else
                    InjectMemberByMethod(ctx, item);//方法注入
            }
        }

        //执行方法注入
        private static void InjectMemberByMethod(IPostCreationContext ctx, IInjectionInfo item)
        {
            item.Method(ctx.Instance, ReflectionHelper.GetParameters(ctx.Kernel, item.Parameters));
        }

        //执行字段注或属性注入
        private static void InjectMember(IPostCreationContext ctx, IInjectionInfo item)
        {
            if (!MemberMatcher.Match(item.MemberType, ctx.Kernel))
                return;
            item.Setter(ctx.Instance, InjectService.Get(item.Id, item.MemberType, ctx.Kernel, false));
        }
    }
}

从注入监听器的代码中可以看出，当组件创建后，注入监听器将扫描组件的所有字段，属性和方法，找出所有可以被注入的成员，然后对这些成员进行注入。

具体注入的过程就是，通过注入的元数据找到依赖的组件类型或组件Id，然后根据组件类型或Id从DI容器中找出对应的依赖组件，然后把该依赖的组件通过字段，属性或方法调用的方式进行初始化，这样就完成了注入。

上篇文章全是文字没有代码，这篇基本上全是用代码堆起来的，文字很少，不过代码中有很多注释，通过代码注释基本上可以了解整个被注入的过程。通过这两篇文章已经把Mini容器的整个精髓和骨架勾勒出来，注册组件->创建组件元数据（Id,组件类型，组件契约，生命周期管理器，组件工厂），获取组件->组件生命周期管理器->组件工厂->组件监听器（依赖注入等），通过上篇的脑图可以更详细的了解Mini容器的内部结构，望能够给那些对DI容器不太了解或对DI容器工作机制不太了解的朋友给些帮助，这样就够了！　　

为了加深大家对Mini容器DI容器更进一步了解，下面提供3个有关字段注入，属性注入，方法注入等的链接

Mini 容器学习笔记7——构造函数注入

Mini 容器学习笔记8——字段注入

Mini 容器学习笔记9——属性注入

Mini 容器学习笔记10——方法注入

Mini 容器学习笔记11——Lazy注入
本文链接

DI 容器-Mini容器工作机制剖析(上篇）

2011-04-21T09:45:00Z

DI容器在DotNet 中已经不是什么稀罕东西了，如Castle，Unity，Ninject，StructureMap，Spring，MEF等等，这些DI容器都是老外设计的，国内开发的DI容器是少之又少，Mini容器便是少之又少中的一员。关于Mini容器的介绍,请参考去年7月份写的这篇文章：Mini容器介绍。

DI容器核心功能包含2大件，服务注册表和服务定位器。

服务注册表：掌管服务的配置或注册，服务注册成功后，DI容器会生成组件的元数据信息包含：

　组件Id标志（服务定位器根据该标志获取组件实例），如果组件在注册时未提供标志，那么系统根据组件类型动态生成一个标志
组件类型
契约接口集合，一个组件可以实现多个契约接口，契约接口必须贴上ContractAttribute方可有效，这和WCF的服务契约一样
组件工厂，用来创建组件的，分为：1）：缺省工厂（Emit反射创建对象），2）：Instance工厂（如果注册了一个组件对象那么就用实例工厂），3):委派工厂（如注册代理对象等），4:)动态代理工厂(供Aop使用）
生命周期管理器（管理组件生命周期的，是组件的容器），分为：单利，临时，线程内单利，泛型单利，泛型临时，泛型线程内单利
扩展属性，用来扩展元数据的，常常供监听器使用。

服务定位器：用来查找组件的。这个查找功能是DI容器中最核心也是最复杂的。下面将详细描述一下细节，关于嵌套容器暂不陈述。

DI的查找接口有很多：具体请参看：http://nlite.codeplex.com/SourceControl/changeset/view/76470#1519585,在这里以一个最简单的接口方法：

object Get(Type serviceType);

为例进行细述（仅仅叙述常规路径）

根据serviceType找到组件元数据，然后定位到生命周期管理器
从生命周期管理器获取组件进行返回。

组件生命周期怎样获取组件并返回的，这需要看具体的组件生命周期管理器了：

单利管理器，首先判断容器内是否有已经创建好的组件，如果有直接返回，没有则委托组件工厂进行创建，然后存储并返回
临时管理器，每次都委派组件工厂进行创建然后直接返回创建好的组件
线程管理器，首先从线程局部存储容器中获取已经创建好的组件，如果有直接返回，没有则委托组件工厂进行创建，然后存储到TLS中并返回
泛型单利/l临时/线程管理器，和前三种类似，不过是基于泛型的创建而已，在这里先不做陈述。

组件生命周期管理器仅仅是一个组件生命容器，不做具体的创建工作的，而具体的创建工作是由组件工厂完成的。组件工厂有分很多种，不同的组件工厂其创建策略都不同。

实例工厂，直接返回组件实例（因为组件实例是在注册组件是提供的）
委派工厂，通过委托函数（组件在注册时自己提供了基于委托函数的工厂）创建并返回
缺省工厂，通过一定的算法进行选择合适的构造函数进行创建并返回，具体算法请参见：Mini容器学习笔记7-构造函数注入
动态代理工厂，比较复杂，以后将单独开篇进行细述。

到这里为止介绍了DI容器最基本功能，组件注册和组件创建和组件获取，但是缺少了依赖注入功能，依赖注入功能将在下篇进行详细介绍，这里附上我花了很大功夫才画好的Mini容器脑图：

关于Mini容器的其它相关文章介绍：

Mini 容器介绍

Mini 容器学习目录

Mini 容器学习笔记1——环境搭建(基础篇)

Mini 容器学习笔记2——组件元数据(基础篇)

Mini 容器学习笔记3——组件的注册(基础篇)

Mini 容器学习笔记4——组件的生命周期(应用篇)

Mini 容器学习笔记5——组件的获取

Mini 容器学习笔记6——组件的获取(应用)

Mini 容器学习笔记7——构造函数注入

Mini 容器学习笔记8——字段注入

Mini 容器学习笔记9——属性注入

Mini 容器学习笔记10——方法注入

Mini 容器学习笔记11——Lazy注入

Mini 容器学习笔记12——组合实例

Mini 容器学习笔记13——插件注入

本文链接

Struct 创建性能大比拼（反射，泛型反射，泛型创建，缓存Emit）

2011-04-19T03:18:00Z

上篇介绍了 Class 创建性能大比拼（反射，泛型反射，泛型创建，缓存Emit，非缓存Emit), 在这里做一个总结（执行10万次）

直接创建Class对象最快 5ms
缓存Emit 6ms (不包含Emit时间）
泛型反射147ms
泛型创建159ms(其实是编译器的语法糖，内部仍然调用泛型反射）
反射340ms
非缓存Emit 12786ms

经过上面的对比应该很清楚了Class创建原则：

直接创建->用缓存Emit->泛型反射->泛型创建->反射（反射大约比直接调用慢68倍左右），避免非缓存Emit

这篇就来一个Struct创建性能大比拼。因为Struct和Class一个是值类型一个是引用类型，一个是分配在栈上一个是分配在堆上，用在Class上创建原则未必都和在Struct上的创建原则一致。咱们仍然以代码来说话。

被测试的Struct：

 struct TestEntity { }

1. 手工创建

[TestInfo(Category = "Struct.Constructor", Name = "Direct")]
        class DirectInvokeMode : IRunable
        {
            public void Run()
            {
                new TestEntity();
            }
        }

2. 反射创建

[TestInfo(Category = "Struct.Constructor", Name = "Reflect")]
        class ReflectInvokeMode : IRunable
        {
            public void Run()
            {
                Activator.CreateInstance(typeof(TestEntity));
            }
        }

3. 泛型反射创建

[TestInfo(Category = "Struct.Constructor", Name = "GenericReflect")]
        class GenericReflectInvokeMode : IRunable
        {
            public void Run()
            {
                Activator.CreateInstance<TestEntity>();
            }
        }

4. 泛型直接创建

[TestInfo(Category = "Struct.Constructor", Name = "Generic Create")]
        class GenericCreateInvokeMode : IRunable
        {
            public void Run()
            {
                Create<TestEntity>();
            }

            static T Create<T>() where T : new()
            {
                return new T();
            }
        }

5. 缓存Emit创建：因为结构体没有缺省构造函数，不能用IL 进行emit,这里用ExpressionTree进行Emit

/// <summary>
        /// 得到缺省构造函数委托
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static DefaultConstructorHandler GetDefaultCreator(this Type type)
        {
            if(type == Types.String)
            {
                DefaultConstructorHandler s = ()=>null;
                return s;
            }

            var ctorExpression = Expression.Lambda<DefaultConstructorHandler>(Expression.Convert(Expression.New(type), typeof(object)));
            var ctor = ctorExpression.Compile();

            DefaultConstructorHandler handler = () =>
            {
                try
                {
                    return ctor();
                }
                catch (TargetInvocationException ex)
                {
                    throw ex.InnerException.Handle();
                }
                catch (Exception ex)
                {
                    throw ex.Handle();
                }
            };

            return handler;
        }

基于上面Emit代码进行创建的Struct，代码如下：

[TestInfo(Category = "Struct.Constructor", Name = "Emit")]
        class EmitInvokeMode : IRunable
        {
            //结构体没有缺省构造函数
            static readonly DefaultConstructorHandler Ctor = typeof(TestEntity).GetDefaultCreator();

            public void Run()
            {
                Ctor();
            }
        }

测试函数：

for (int i = 0; i < 3; i++)
            {
                foreach (var item in Mappers)
                    CodeTimer.Time(item.Metadata.Category + "->" + item.Metadata.Name, 100000, () => item.Value.Run());
            }

输出结果如下：

------ Test started: Assembly: NLite.Test.dll ------

Struct.Constructor->Direct
	Time Elapsed:	4ms
	CPU Cycles:	156,250
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Reflect
	Time Elapsed:	330ms
	CPU Cycles:	2,968,750
	Gen 0: 		1
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->GenericReflect
	Time Elapsed:	26ms
	CPU Cycles:	156,250
	Gen 0: 		1
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Generic Create
	Time Elapsed:	3ms
	CPU Cycles:	156,250
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Emit
	Time Elapsed:	7ms
	CPU Cycles:	0
	Gen 0: 		1
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Direct
	Time Elapsed:	1ms
	CPU Cycles:	0
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Reflect
	Time Elapsed:	329ms
	CPU Cycles:	3,281,250
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->GenericReflect
	Time Elapsed:	22ms
	CPU Cycles:	312,500
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Generic Create
	Time Elapsed:	4ms
	CPU Cycles:	156,250
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Emit
	Time Elapsed:	3ms
	CPU Cycles:	156,250
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Direct
	Time Elapsed:	1ms
	CPU Cycles:	0
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Reflect
	Time Elapsed:	339ms
	CPU Cycles:	3,437,500
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->GenericReflect
	Time Elapsed:	22ms
	CPU Cycles:	312,500
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Generic Create
	Time Elapsed:	2ms
	CPU Cycles:	0
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0

Struct.Constructor->Emit
	Time Elapsed:	3ms
	CPU Cycles:	0
	Gen 0: 		0
	Gen 1: 		0
	Gen 2: 		0


1 passed, 0 failed, 0 skipped, took 2.53 seconds (NUnit 2.5.5).

从测试结果可以看出一个非常离奇的问题，泛型创建超过Emit超过泛型反射，这在Class的创建测试中，Emit超过泛型反射，泛型反射超过泛型创建。

本文链接

Class 创建性能大比拼（反射，泛型反射，泛型创建，缓存Emit，非缓存Emit）

2011-04-18T08:37:00Z

一说到反射，很多人都想到了性能，更有甚者直接说“慎用反射，遗患无穷”，“用反射，感觉怎么像是退步啊～”，看到这种言论，直接把反射妖魔化了，如果这种言论长此以往，势必会对很多对反射初学者造成负面影响。反射是一把双刃剑，看你怎样使用了，下面我就用代码说话。

class TestEntity { }

1. 手工创建TestEntity

      [TestInfo(Category = "Class.Constructor", Name = "Direct")]
        class DirectInvokeMode:IRunable
        {
            public void Run()
            {
                new TestEntity();
            }
        }

2. 反射创建TestEntity

[TestInfo(Category = "Class.Constructor", Name = "Reflect")]
        class ReflectInvokeMode : IRunable
        {
            public void Run()
            {
                Activator.CreateInstance(typeof(TestEntity));
            }
        }

3. 泛型反射创建TestEntity

[TestInfo(Category = "Class.Constructor", Name = "GenericReflect")]
        class GenericReflectInvokeMode : IRunable
        {
            public void Run()
            {
                Activator.CreateInstance<TestEntity>();
            }
        }

4. Generic 直接创建

[TestInfo(Category = "Class.Constructor", Name = "Generic Create")]
        class GenericCreateInvokeMode : IRunable
        {
            public void Run()
            {
                Create<TestEntity>();
            }

            static T Create<T>() where T : new()
            {
                return new T();
            }
        }

5. Emit创建

[TestInfo(Category = "Class.Constructor", Name = "Emit")]
        class EmitInvokeMode : IRunable
        {
            static readonly ConstructorHandler Ctor = typeof(TestEntity).GetConstructor(Type.EmptyTypes).GetCreator();

            public void Run()
            {
                Ctor();
            }
        }

6. 不缓存Emit的创建

[TestInfo(Category = "Class.Constructor", Name = "NoCacheEmit")]
        class NoCacheEmitInvokeMode : IRunable
        {
            public void Run()
            {
                typeof(TestEntity).GetConstructor(Type.EmptyTypes).GetCreator()();
            }
        }

测试程序：（执行10万次创建Class对象）

foreach (var item in Mappers)
   CodeTimer.Time(item.Metadata.Category + "->" + item.Metadata.Name, 100000, () => item.Value.Run());

输出结果：

------ Test started: Assembly: NLite.Test.dll ------


Class.Constructor->Direct
    Time Elapsed:    5ms
    CPU Cycles:    0
    Gen 0:         1
    Gen 1:         0
    Gen 2:         0

Class.Constructor->Reflect
    Time Elapsed:    320ms
    CPU Cycles:    2,968,750
    Gen 0:         1
    Gen 1:         0
    Gen 2:         0

Class.Constructor->GenericReflect
    Time Elapsed:    147ms
    CPU Cycles:    1,250,000
    Gen 0:         1
    Gen 1:         0
    Gen 2:         0

Class.Constructor->Generic Create
    Time Elapsed:    159ms
    CPU Cycles:    1,406,250
    Gen 0:         1
    Gen 1:         0
    Gen 2:         0

Class.Constructor->Emit
    Time Elapsed:    6ms
    CPU Cycles:    0
    Gen 0:         2
    Gen 1:         0
    Gen 2:         0

Class.Constructor->NoCacheEmit
    Time Elapsed:    12,786ms
    CPU Cycles:    119,218,750
    Gen 0:         162
    Gen 1:         81
    Gen 2:         0

1 passed, 0 failed, 0 skipped, took 67.77 seconds (NUnit 2.5.5).

性能比较结果应该是一目了然了！

附上源代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using System.Reflection;
using NLite.Reflection;

namespace NLite.Test.Reflection
{
    [Contract]
    public interface IRunable
    {
        void Run();
    }

    //测试器元数据
    public interface ITestInfo
    {
        //目录
        string Category { get; }
        //名称
        string Name { get; }
    }

    //映射器元数据注解
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    [MetadataAttributeAttribute]
    public class TestInfoAttribute : ComponentAttribute
    {
        public string Category { get; set; }
        public string Name { get; set; }
    }


    [TestFixture]
    public class SpecBase
    {
        public SpecBase()
        {
        }

        [SetUp]
        public void SetUp()
        {
            Given();
            When();
        }

        public virtual void Given() { }
        public virtual void When()
        {
        }

        [Test]
        public void Test()
        {
            
        }
    }

    public abstract class PerformanceSpecBase : SpecBase
    {
        [InjectMany]
        protected Lazy<IRunable, ITestInfo>[] Mappers;

        protected abstract void RegisterComponents();

        public virtual int Times
        {
            get { return 100000; }
        }

        public override void Given()
        {
            RegisterComponents();
            ServiceRegistry.Compose(this);
        }


        public override void When()
        {
            for (int i = 0; i < 3; i++)
            {
                foreach (var item in Mappers)
                    CodeTimer.Time(item.Metadata.Category + "->" + item.Metadata.Name, Times, () => item.Value.Run());
            }
        }
    }

    public class InvokeConstructorPerformanceSpec : PerformanceSpecBase
    {
        class TestEntity { }

        protected override void RegisterComponents()
        {
            ServiceRegistry
                .Register<DirectInvokeMode>()
                .Register<ReflectInvokeMode>()
                .Register<GenericReflectInvokeMode>()
                .Register <GenericCreateInvokeMode>()
                .Register<EmitInvokeMode>()
                .Register < NoCacheEmitInvokeMode>()
                .Register < GenericReflectInvokeMode2>()
                ;
        }
        [TestInfo(Category = "Class.Constructor", Name = "Direct")]
        class DirectInvokeMode:IRunable
        {
            public void Run()
            {
                new TestEntity();
            }
        }

        [TestInfo(Category = "Class.Constructor", Name = "Reflect")]
        class ReflectInvokeMode : IRunable
        {
            public void Run()
            {
                Activator.CreateInstance(typeof(TestEntity));
            }
        }

        [TestInfo(Category = "Class.Constructor", Name = "GenericReflect")]
        class GenericReflectInvokeMode : IRunable
        {
            public void Run()
            {
                Activator.CreateInstance<TestEntity>();
            }
        }

        [TestInfo(Category = "Class.Constructor", Name = "Reflect->Reflect")]
        class GenericReflectInvokeMode2 : IRunable
        {
            static readonly MethodInfo CreateMethod = typeof(Activator)
                .GetMethod("CreateInstance", Type.EmptyTypes)
                .MakeGenericMethod(typeof(TestEntity));

            public void Run()
            {
                CreateMethod.Invoke(null,null);
            }


        }

        

        [TestInfo(Category = "Class.Constructor", Name = "Generic Create")]
        class GenericCreateInvokeMode : IRunable
        {
            public void Run()
            {
                Create<TestEntity>();
            }

            static T Create<T>() where T : new()
            {
                return new T();
            }
        }

        [TestInfo(Category = "Class.Constructor", Name = "Emit")]
        class EmitInvokeMode : IRunable
        {
            static readonly ConstructorHandler Ctor = typeof(TestEntity).GetConstructor(Type.EmptyTypes).GetCreator();

            public void Run()
            {
                Ctor();
            }
        }


        [TestInfo(Category = "Class.Constructor", Name = "NoCacheEmit")]
        class NoCacheEmitInvokeMode : IRunable
        {
            public void Run()
            {
                typeof(TestEntity).GetConstructor(Type.EmptyTypes).GetCreator()();
            }
        }


    }

   
}

最后给大家一个思考题：Struct 创建性能大比拼的结果是怎样的？（注意Struct是值类型，Class是引用类型，值类型是分配在栈上的，引用类型是分配在堆上的）

本文链接

EmitMapper,AutoMapper,NLiteMapper和手工映射性能大比拼

2011-04-13T04:49:00Z

在大比拼之前先讲一个小插曲，我这个人以前比较低调，做了很多好东西仅仅在公司内的朋友圈项目圈内分享，很少在博客园内进行分享，后来在dudu 老大的文章博客园现代化建设——AutoMapper有感便推荐一下OOMapper 组件,于是乎接连写了几篇入门性的介绍使用文章：

在园友Repository 兄的NLiteMapper与EmitMapper性能简单比较中了解到NLiteMapper与EmitMapper的性能巨大差距，于是乎进行了两天的性能优化，同时总结了优化过程：一次性能优化最佳实践。在这里非常感谢Repository 兄的测试，也非常感谢他把OOMapper纠正为NLiteMapper,否则NLiteMapper的性能是非常低下的，同时感谢dudu,感谢博客园给大家一个平台，在这个平台使我学到了很多很多......

不说废话进入主题。

准备工作：

　　软硬件环境：VS2008，.net3.5, xp 双核
测试组件（都是最新Release版本）：AutoMapper.dll(v2.0), EmitMappe.dll (V1.0),NLite.dll(V1.0)

性能测试工具：老赵的CodeTimer

测试接口代码：

    [Contract]
    public interface IObjectToObjectMapper
    {
        //初始化映射器
        void Initialize();
        //执行映射
        void Map();
    }

为了输出更友好的结果定义一下测试元数据代码：

   //测试映射器元数据
    public interface IMapperMetadata
    {
        //目录
        string Category { get; }
        //名称
        string Name { get; }
        string Descrption { get; }
    }

    //映射器元数据注解
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
    [MetadataAttributeAttribute]
    public class MapperAttribute : ComponentAttribute
    {
        public string Category { get; set; }
        public string Name { get; set; }
        public string Descrption { get; set; }
    }

利用NLite的Mini容器书写测试框架代码如下：测试次数10万次

   class Program
    {
        [InjectMany]
        private Lazy<IObjectToObjectMapper,IMapperMetadata>[] Mappers;

        //初始化映射器，并做一次映射操作
        void Init()
        {
            foreach (var item in Mappers)
            {
                item.Value.Initialize();
                item.Value.Map();
            }

        }

        //进行测试
        void Run()
        {
            foreach (var item in Mappers)
                CodeTimer.Time(item.Metadata.Category +"->" + item.Metadata.Name , 100000,() => item.Value.Map());
        }

        static void Main(string[] args)
        {
            ServiceRegistry.RegisteryFromAssemblyOf<Program>();

            var host = new Program();
            ServiceRegistry.Compose(host);

            host.Init();
            host.Run();

            Console.Read();
        }
    }

这样完成了测试框架的搭建，现在就开始书写测试代码了。

定义测试数据：

        public class ModelObject
        {
            public DateTime BaseDate { get; set; }
            public ModelSubObject Sub { get; set; }
            public ModelSubObject Sub2 { get; set; }
            public ModelSubObject SubWithExtraName { get; set; }
        }

        public class ModelSubObject
        {
            public string ProperName { get; set; }
            public ModelSubSubObject SubSub { get; set; }
        }

        public class ModelSubSubObject
        {
            public string IAmACoolProperty { get; set; }
        }

        public class ModelDto
        {
            public DateTime BaseDate { get; set; }
            public string SubProperName { get; set; }
            public string Sub2ProperName { get; set; }
            public string SubWithExtraNameProperName { get; set; }
            public string SubSubSubIAmACoolProperty { get; set; }
        }

定义测试基类：

        public abstract class MapperBase : IObjectToObjectMapper
        {
            protected ModelObject _source;
            protected ModelDto _target;

            protected virtual void OnInitialize() { }
            public void Initialize()
            {
                OnInitialize();

                _source = new ModelObject
                {
                    BaseDate = new DateTime(2007, 4, 5),
                    Sub = new ModelSubObject
                    {
                        ProperName = "Some name",
                        SubSub = new ModelSubSubObject
                        {
                            IAmACoolProperty = "Cool daddy-o"
                        }
                    },
                    Sub2 = new ModelSubObject
                    {
                        ProperName = "Sub 2 name"
                    },
                    SubWithExtraName = new ModelSubObject
                    {
                        ProperName = "Some other name"
                    },
                };
            }

            public abstract void Map();
        }

手工映射代码：

       [Mapper(Category = "Flattening.Class", Name = "Manual")]
        public class ManualMapper : MapperBase
        {
            public override void Map()
            {
                var destination = new ModelDto
                {
                    BaseDate = _source.BaseDate,
                    Sub2ProperName = _source.Sub2.ProperName,
                    SubProperName = _source.Sub.ProperName,
                    SubSubSubIAmACoolProperty = _source.Sub.SubSub.IAmACoolProperty,
                    SubWithExtraNameProperName = _source.SubWithExtraName.ProperName
                };
            }
        }

AutoMapper 映射代码：

  [Mapper(Category = "Flattening.Class", Name = "AutoMapper")]
        public class AutoMapperWrapper : MapperBase
        {
            protected override  void OnInitialize()
            {
                AutoMapper.Mapper.Initialize(cfg =>
                {
                    cfg.CreateMap<ModelObject, ModelDto>();
                });
                AutoMapper.Mapper.AssertConfigurationIsValid();
            }

            public override void Map()
            {
                _target =AutoMapper.Mapper.Map<ModelObject, ModelDto>(_source);
            }
        }

EmitMapper映射代码：

        [Mapper(Category = "Flattening.Class", Name = "EmitMapper")]
        public class EmitMapperWrapper : MapperBase
        {
            ObjectsMapper<ModelObject, ModelDto> mapper;
            protected override void OnInitialize()
            {
                mapper = ObjectMapperManager.DefaultInstance.GetMapper<ModelObject, ModelDto>(new FlatteringConfig());
            }

            protected override ModelDto MapImp()
            {
                return mapper.Map(Source);
            }
        }

EmitMapper映射器默认不支持Flatter 映射，如果支持需要写自定义配置:

class FlatteringConfig : DefaultMapConfig
        {
            protected Func<string, string, bool> nestedMembersMatcher;

            public FlatteringConfig()
            {
                nestedMembersMatcher = (m1, m2) => m1.StartsWith(m2);
            }

            public override IMappingOperation[] GetMappingOperations(Type from, Type to)
            {
                var destinationMembers = GetDestinationMemebers(to);
                var sourceMembers = GetSourceMemebers(from);
                var result = new List<IMappingOperation>();
                foreach (var dest in destinationMembers)
                {
                    var matchedChain = GetMatchedChain(dest.Name, sourceMembers).ToArray();
                    if (matchedChain == null || matchedChain.Length == 0)
                    {
                        continue;
                    }
                    result.Add(
                        new ReadWriteSimple
                        {
                            Source = new MemberDescriptor(matchedChain),
                            Destination = new MemberDescriptor(new[] { dest })
                        }
                    );
                }
                return result.ToArray();
            }

            public DefaultMapConfig MatchNestedMembers(Func<string, string, bool> nestedMembersMatcher)
            {
                this.nestedMembersMatcher = nestedMembersMatcher;
                return this;
            }

            private List<MemberInfo> GetMatchedChain(string destName, List<MemberInfo> sourceMembers)
            {
                var matches = sourceMembers.Where(s => MatchMembers(destName, s.Name) || nestedMembersMatcher(destName, s.Name));
                int len = 0;
                MemberInfo match = null;
                foreach (var m in matches)
                {
                    if (m.Name.Length > len)
                    {
                        len = m.Name.Length;
                        match = m;
                    }
                }
                if (match == null)
                {
                    return null;
                }
                var result = new List<MemberInfo> { match };
                if (!MatchMembers(destName, match.Name))
                {
                    result.AddRange(
                        GetMatchedChain(destName.Substring(match.Name.Length), GetDestinationMemebers(match))
                    );
                }
                return result;
            }

            private static List<MemberInfo> GetSourceMemebers(Type t)
            {
                return GetMemebers(t)
                    .Where(
                        m =>
                            m.MemberType == MemberTypes.Field ||
                            m.MemberType == MemberTypes.Property ||
                            m.MemberType == MemberTypes.Method
                    )
                    .ToList();
            }

            private static List<MemberInfo> GetDestinationMemebers(MemberInfo mi)
            {
                Type t;
                if (mi.MemberType == MemberTypes.Field)
                {
                    t = mi.DeclaringType.GetField(mi.Name).FieldType;
                }
                else
                {
                    t = mi.DeclaringType.GetProperty(mi.Name).PropertyType;
                }
                return GetDestinationMemebers(t);
            }

            private static List<MemberInfo> GetDestinationMemebers(Type t)
            {
                return GetMemebers(t).Where(m => m.MemberType == MemberTypes.Field || m.MemberType == MemberTypes.Property).ToList();
            }

            private static List<MemberInfo> GetMemebers(Type t)
            {
                BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
                return t.GetMembers(bindingFlags).ToList();
            }
        }

NLiteMapper映射代码：

[Mapper(Category = "Flattening.Class", Name = "NLiteMapper")]
        public class NLiteMaperWrapper : MapperBase
        {
            private NLite.Mapping.IMapper<ModelObject, ModelDto> mapper;
            protected override void OnInitialize()
            {
                base.OnInitialize();

                mapper = NLite.Mapper.CreateMapper<ModelObject, ModelDto>();
            }

            public override void Map()
            {
                _target = mapper.Map(_source);
            }
        }

Ok，完成代码用Release编译，然后再输出bin中找到exe文件，连续执行三次，下面是三次执行结果的截图：

------ Test started: Assembly: NLite.Test.dll ------

Flattening.Class->AutoMapper
	Time Elapsed:	1,112ms
	CPU Cycles:	6,718,750
	Gen 0: 		173
	Gen 1: 		1
	Gen 2: 		0

Flattening.Class->NLiteMapper
	Time Elapsed:	68ms
	CPU Cycles:	781,250
	Gen 0: 		4
	Gen 1: 		1
	Gen 2: 		0

Flattening.Class->EmitMapper
	Time Elapsed:	23ms
	CPU Cycles:	156,250
	Gen 0: 		3
	Gen 1: 		0
	Gen 2: 		0

Flattening.Class->Manual
	Time Elapsed:	8ms
	CPU Cycles:	0
	Gen 0: 		3
	Gen 1: 		1
	Gen 2: 		0

------ Test started: Assembly: NLite.Test.dll ------

Flattening.Class->AutoMapper
	Time Elapsed:	1,701ms
	CPU Cycles:	10,468,750
	Gen 0: 		173
	Gen 1: 		0
	Gen 2: 		0

Flattening.Class->NLiteMapper
	Time Elapsed:	69ms
	CPU Cycles:	781,250
	Gen 0: 		4
	Gen 1: 		1
	Gen 2: 		0

Flattening.Class->EmitMapper
	Time Elapsed:	22ms
	CPU Cycles:	0
	Gen 0: 		3
	Gen 1: 		0
	Gen 2: 		0

Flattening.Class->Manual
	Time Elapsed:	10ms
	CPU Cycles:	312,500
	Gen 0: 		3
	Gen 1: 		1
	Gen 2: 		0


1 passed, 0 failed, 0 skipped, took 2.98 seconds (NUnit 2.5.5).

------ Test started: Assembly: NLite.Test.dll ------

Flattening.Class->AutoMapper
	Time Elapsed:	1,205ms
	CPU Cycles:	10,156,250
	Gen 0: 		177
	Gen 1: 		0
	Gen 2: 		0

Flattening.Class->NLiteMapper
	Time Elapsed:	66ms
	CPU Cycles:	781,250
	Gen 0: 		4
	Gen 1: 		0
	Gen 2: 		0

Flattening.Class->EmitMapper
	Time Elapsed:	18ms
	CPU Cycles:	312,500
	Gen 0: 		3
	Gen 1: 		0
	Gen 2: 		0

Flattening.Class->Manual
	Time Elapsed:	9ms
	CPU Cycles:	0
	Gen 0: 		3
	Gen 1: 		0
	Gen 2: 		0


1 passed, 0 failed, 0 skipped, took 2.56 seconds (NUnit 2.5.5).

通过测试结果可以看出:

　手工映射速度最快
EmitMapper第二（大约比手工慢了2-6倍，）
NLiteMapper第三（大约比EmitMapper慢了3倍）
最后是AutoMapper（大约比手工慢了200倍）

内存开销结果：

手工映射 Gen 0： 3
EmitMapper Gen 0：3
NLiteMapper Gen 0： 4
AutoMapper Gen 0：173

总结：无论从性能和内存EmitMapper都接近于手工，NLiteMapper次之，AutoMapper最后。NLiteMapper，EmitMapper，AutoMapper都是通过Emit的方式进行Get和Set的，为什么性能差别如此之大，设想如果NLiteMapper不进行优化的话（NLiteMapper一直是通过Emit方式进行的），那么NLiteMapper肯定是高高垫背的（NLiteMapper比EmitMapper慢了15000倍）。。。。。。

这次测试结果不代表整体结果，仅仅代表Class->Class（包括级联）的映射性能，欢迎大家对这几种OO映射器进行性能比较。最后附上整个测试代码：测试代码。

　　备注：EmitMapper的测试代码修改过，添加了FlatteringConfig class 这样测试就公平了。

附上的源代码是老代码，最新代码：http://nlite.codeplex.com/SourceControl/changeset/view/76359#1528885

本文链接

博客园_风云

松耦合服务调用利器-服务分发器

为ASP.NET MVC创建一个基于Mini容器的ControllerFactory

数据库性能优化-摘录

Web 高性能开发汇总

1. Http服务器：

数据库大型应用解决方案总结 - 笔记

DI 容器-Mini容器工作机制剖析(下篇）

Mini 容器学习笔记7——构造函数注入

Mini 容器学习笔记8——字段注入

Mini 容器学习笔记9——属性注入

Mini 容器学习笔记10——方法注入

Mini 容器学习笔记11——Lazy注入本文链接

DI 容器-Mini容器工作机制剖析(上篇）

Struct 创建性能大比拼（反射，泛型反射，泛型创建，缓存Emit）

Class 创建性能大比拼（反射，泛型反射，泛型创建，缓存Emit，非缓存Emit）

EmitMapper,AutoMapper,NLiteMapper和手工映射性能大比拼

Mini 容器学习笔记11——Lazy注入
本文链接