各大主流.Net的IOC框架性能测试比较

最新推荐文章于 2023-06-16 14:07:53 发布
最新推荐文章于 2023-06-16 14:07:53 发布
阅读量3.9k 收藏 3
点赞数
分类专栏： .Net技术 文章标签： ioc 测试 框架 .net database user
有人希望能有个性能上的测试，考虑到有那么多的IOC框架，而主流的有：Castle Windsor、微软企业库中的Unity、Spring.NET、StructureMap、Ninject等等。本篇文章主要针对这些IOC框架编写测试程序。

Autofac下载地址：http://code.google.com/p/autofac/

Castle Windsor下载地址：http://sourceforge.net/projects/castleproject/files/Windsor/2.5/Castle.Windsor.2.5.3.zip/download

Unity下载地址：http://entlib.codeplex.com/

Spring.NET下载地址：http://www.springframework.net/

StructureMap下载地址：http://sourceforge.net/projects/structuremap/files/

Ninject下载地址：http://ninject.org/download

其中，测试程序均采用最新的类库。

基础工作

1、程序还是引用上一篇的示例作为测试背景。

2、编写一个性能计数器，这里我采用老赵写的一个CodeTimer的类，具体介绍见：http://www.cnblogs.com/JeffreyZhao/archive/2009/03/10/codetimer.html

使用方式类似于：

int  iteration  =   100   *   1000 ; string  s  =   "" ; 
CodeTimer.Time( " String Concat " , iteration, ()  =>  { s  +=   " a " ; }); 
StringBuilder sb  =   new  StringBuilder(); 
CodeTimer.Time( " StringBuilder " , iteration, ()  =>  { sb.Append( " a " ); });
复制代码

3、编写一个IRunner运行接口：

public   interface  IRunner 
{ 
     void  Start(RunType runType); 
}
复制代码

以及RunnerBase抽象基础运行类：

public   abstract   class  RunnerBase 
{ 
     private   int  _iteration  =  Convert.ToInt32(System.Configuration.ConfigurationSettings.AppSettings[ " Iteration " ]  ??   " 10000 " ); 
     internal   int  Iteration 
    { 
         get  {  return  _iteration; } 
    }

     internal   void  Time(Action action) 
    { 
        CodeTimer.Time(Name, Iteration, action); 
    }

     protected   abstract   string  Name {  get ; } 
} 
复制代码

这里_iteration表示测试运行次数，通过配置文件来设置值。Time方法通过计数器对action方法进行Iteration次迭代。

编写一个RunManager的运行管理器：

public   class  RunManager 
{ 
     public   static   void  Start(IRunner runner) 
    { 
        Start(runner, RunType.Transient); 
    }

     public   static   void  Start(IRunner runner, RunType runType) 
    { 
        runner.Start(runType); 
    } 
}
复制代码

 
在测试中，我采用两种方式的性能比较，一个是单例状态，一个是非单例状态：

///   <summary>  
///  运行状态 
///   </summary>  
public   enum  RunType 
{ 
     ///   <summary>  
     ///  单例 
     ///   </summary>  
    Singleton,

     ///   <summary>  
     ///  瞬时 
     ///   </summary>  
    Transient 
} 
复制代码

好了，现在我的程序只要继承RunnerBase以及IRunnre接口，就可以实现各个IOC框架的初始化装配的工作了。基础工作已经做好。

各个IOC框架测试程序

1、Autofac：

public   class  AutofacRunner : RunnerBase, IRunner 
{ 
     protected   override   string  Name 
    { 
         get  {  return   " Autofac " ; } 
    }

     public   void  Start(RunType runType) 
    { 
        var builder  =   new  ContainerBuilder();

         // if (runType == RunType.Singleton) 
         //     builder.RegisterType<DatabaseManager>().SingleInstance(); 
         // else 
         //     builder.RegisterType<DatabaseManager>(); 
         // builder.RegisterType<SqlDatabase>().As<IDatabase>(); 
         /// /builder.RegisterModule(new ConfigurationSettingsReader("autofac"));

        builder.RegisterType < SqlDatabase > ().As < IDatabase > (); 
         if  (runType  ==  RunType.Singleton) 
            builder.Register(c  =>   new  DatabaseManager(c.Resolve < IDatabase > ())).SingleInstance(); 
         else  
            builder.Register(c  =>   new  DatabaseManager(c.Resolve < IDatabase > ()));  

        var container  =  builder.Build();

        Time(()  =>  
        { 
            var manager  =  container.Resolve < DatabaseManager > (); 
            manager.Search( " SELECT * FROM USER " ); 
        });

        container.Dispose(); 
    } 
} 
复制代码

2、Castle Windsor：

public   class  WindsorRunner : RunnerBase, IRunner 
{ 
     protected   override   string  Name 
    { 
         get  {  return   " Castle Windsor " ; } 
    }

     public   void  Start(RunType runType) 
    { 
        var container  =   new  WindsorContainer(); 
         if (runType  ==  RunType.Singleton) 
            container.Register(Component.For( typeof (DatabaseManager)).LifeStyle.Singleton); 
         else  
            container.Register(Component.For( typeof (DatabaseManager)).LifeStyle.Transient);

        container.Register(Component.For( typeof (IDatabase)).ImplementedBy( typeof (SqlDatabase)));

        Time(()  =>  
        { 
            var manager  =  container.Resolve < DatabaseManager > (); 
            manager.Search( " SELECT * FROM USER " ); 
        }); 
    } 
} 
复制代码

3、Unity：

public   class  UnityRunner : RunnerBase, IRunner 
{ 
     protected   override   string  Name 
    { 
         get  {  return   " Unity " ; } 
    }

     public   void  Start(RunType runType) 
    { 
        var container  =   new  UnityContainer(); 
         if (runType  ==  RunType.Singleton) 
            container.RegisterType < DatabaseManager > ( new  ContainerControlledLifetimeManager()); 
         else  
            container.RegisterType < DatabaseManager > ( new  TransientLifetimeManager()); 
        container.RegisterType < IDatabase, SqlDatabase > ();

        Time(()  =>  
            { 
                var manager  =  container.Resolve < DatabaseManager > (); 
                manager.Search( " SELECT * FROM USER " ); 
            }); 
    } 
} 
复制代码

4、Spring.NET：

public   class  SpringRunner : RunnerBase, IRunner 
{ 
     protected   override   string  Name 
    { 
         get  {  return   " Spring.NET " ; } 
    }

     public   void  Start(RunType runType) 
    { 
         string  databaseManagerName; 
         if  (runType  ==  RunType.Singleton) 
            databaseManagerName  =   " DatabaseManager_Singleton " ; 
         else  
            databaseManagerName  =   " DatabaseManager_Transient " ;

        Time(()  =>  
        { 
            IApplicationContext context  =  ContextRegistry.GetContext(); 
            var manager  =  (DatabaseManager)context.GetObject(databaseManagerName); 
            manager.Search( " SELECT * FROM USER " ); 
        }); 
    } 
} 
复制代码

5、StructureMap：

public   class  StructureMapRunner : RunnerBase, IRunner 
{ 
     protected   override   string  Name 
    { 
         get  {  return   " StructureMap " ; } 
    }

     public   void  Start(RunType runType) 
    { 
        ObjectFactory.Initialize(container  =>  
        { 
             if  (runType  ==  RunType.Singleton) 
                container.ForRequestedType < DatabaseManager > ().Singleton(); 
             else  
                container.ForRequestedType < DatabaseManager > (); 
            container.ForRequestedType < IDatabase > ().TheDefaultIsConcreteType < SqlDatabase > (); 
        });

        Time(()  =>  
            { 
                var manager  =  ObjectFactory.GetInstance < DatabaseManager > (); 
                manager.Search( " SELECT * FROM USER " ); 
            }); 
    } 
} 
复制代码

6、Ninject：

public   class  NinjectRunner : RunnerBase, IRunner 
{ 
     protected   override   string  Name 
    { 
         get  {  return   " Ninject " ; } 
    }

     public   void  Start(RunType runType) 
    { 
        IKernel kernel  =   new  StandardKernel( new  MyNinjectModule(runType));

        Time(()  =>  
        { 
            var manager  =  kernel.Get < DatabaseManager > (); 
            manager.Search( " SELECT * FROM USER " ); 
        }); 
    } 
} 
复制代码

客户端测试程序

static   void  Main( string [] args) 
{ 
    CodeTimer.Initialize();

    Console.WriteLine( " IOC - Singleton " ); 
     //  Autofac Singleton 
    RunManager.Start( new  AutofacRunner(), RunType.Singleton);        
     //  Castle Windsor 
    RunManager.Start( new  WindsorRunner(), RunType.Singleton); 
     //  Unity 
    RunManager.Start( new  UnityRunner(), RunType.Singleton); 
     //  Spring.NET 
    RunManager.Start( new  SpringRunner(), RunType.Singleton); 
     //  StructureMap 
    RunManager.Start( new  StructureMapRunner(), RunType.Singleton); 
     //  Ninject 
    RunManager.Start( new  NinjectRunner(), RunType.Singleton);

    Console.WriteLine( " =================================== " ); 
    Console.WriteLine( " IOC - Transient " ); 
     //  Autofac Singleton 
    RunManager.Start( new  AutofacRunner(), RunType.Transient); 
     //  Castle Windsor 
    RunManager.Start( new  WindsorRunner(), RunType.Transient); 
     //  Unity 
    RunManager.Start( new  UnityRunner(), RunType.Transient); 
     //  Spring.NET 
    RunManager.Start( new  SpringRunner(), RunType.Transient); 
     //  StructureMap 
    RunManager.Start( new  StructureMapRunner(), RunType.Transient); 
     //  Ninject 
    RunManager.Start( new  NinjectRunner(), RunType.Transient);

    Console.ReadKey(); 
} 
复制代码

通过修改App.config的Iteration配置值，来设置迭代次数。

< appSettings >  
   < add  key ="Iteration"  value ="100000"   />  
</ appSettings >  
复制代码

运行结果

1、Iteration=1000：

image

分析：在千数量级时，Autofac，CastleWindsor、StructureMap基本差不多，效率上比其他的要高。

2、Iteration=10000：

image

分析：在万数量级时，Autofac，CastleWindsor，StructureMap基本效率还是差不多，其中StructureMap效率稍稍有些下降；Spring.NET以及Ninject的性能比较低。

3、Iteration=100000：

image

分析：在十万数量级时，CastleWindsor的效率开始下降，而在Transient方面，StructureMap和Autofac基本差不多。

4、Iteration=1000000：

image

分析：在百万数量级时，Autofac和StructureMap两者还是保持比较高的效率，并且在Transient方面，StructureMap已经超过了Autofac。

总结：从测试中，可以看出Autofac和StructureMap在性能上面还是体现出比较大的优势，Ninject可以说性能上较低。而Spring.NET不仅仅专注于IOC方面，它还专注于其他方方面面的功能，所以在IOC方面的性能不是太高。另外，微软的Unity中规中矩，性能较为稳定，也是一个不错的选择。另外，可能测试程序会有所偏差，希望大家也能够指出问题！

测试程序源代码：IOCPerformanceTest.rar

  Autofac是一款IOC框架，比较于其他的IOC框架，如Spring.NET，Unity，Castle等等所包含的，它很轻量级性能上也是很高的。于是，今天抽空研究了下它。下载地址：http://code.google.com/p/autofac/downloads/list

1）解压它的压缩包，主要看到Autofac.dll，Autofac.Configuration.dll，这也是本篇文章重点使用的Autofac的类库。

2）创建一个控制台工程，并且引用以上的DLL文件。创建一个数据库操作接口IDatabase.cs：

///   <summary>
///  Database operate interface
///   </summary>
public   interface  IDatabase
{
string  Name {  get ; }

void  Select( string  commandText);

void  Insert( string  commandText);

void  Update( string  commandText);

void  Delete( string  commandText);
}
复制代码

这里包含CRUD四种操作的方法。

3）创建两种数据库的操作类，SqlDatabase.cs以及OracleDatabase.cs：

public   class  SqlDatabase : IDatabase 
{ 
     public   string  Name 
    { 
         get  {  return   " sqlserver " ; } 
    }

     public   void  Select( string  commandText) 
    { 
        Console.WriteLine( string .Format( " '{0}' is a query sql in {1}! " , commandText, Name)); 
    }

     public   void  Insert( string  commandText) 
    { 
        Console.WriteLine( string .Format( " '{0}' is a insert sql in {1}! " , commandText, Name)); 
    }

     public   void  Update( string  commandText) 
    { 
        Console.WriteLine( string .Format( " '{0}' is a update sql in {1}! " , commandText, Name)); 
    }

     public   void  Delete( string  commandText) 
    { 
        Console.WriteLine( string .Format( " '{0}' is a delete sql in {1}! " , commandText, Name)); 
    } 
} 
复制代码

以及

public   class  OracleDatabase : IDatabase 
{ 
     public   string  Name 
    { 
         get  {  return   " oracle " ; } 
    }

     public   void  Select( string  commandText) 
    { 
        Console.WriteLine( string .Format( " '{0}' is a query sql in {1}! " , commandText, Name)); 
    }

     public   void  Insert( string  commandText) 
    { 
        Console.WriteLine( string .Format( " '{0}' is a insert sql in {1}! " , commandText, Name)); 
    }

     public   void  Update( string  commandText) 
    { 
        Console.WriteLine( string .Format( " '{0}' is a update sql in {1}! " , commandText, Name)); 
    }

     public   void  Delete( string  commandText) 
    { 
        Console.WriteLine( string .Format( " '{0}' is a delete sql in {1}! " , commandText, Name)); 
    } 
}
复制代码

 
4）接着创建一个数据库管理器DatabaseManager.cs：

public   class  DatabaseManager 
{ 
    IDatabase _database;

     public  DatabaseManager(IDatabase database) 
    { 
        _database  =  database; 
    }

     public   void  Search( string  commandText) 
    { 
        _database.Select(commandText); 
    }

     public   void  Add( string  commandText) 
    { 
            _database.Insert(commandText); 
    }

     public   void  Save( string  commandText) 
    { 
            _database.Update(commandText); 
    }

     public   void  Remove( string  commandText) 
    { 
            _database.Delete(commandText); 
    }

}
复制代码

5）在控制台中，编写以下测试程序：

var builder  =   new  ContainerBuilder(); 
builder.RegisterType < DatabaseManager > (); 
builder.RegisterType < SqlDatabase > ().As < IDatabase > (); 
using  (var container  =  builder.Build()) 
{ 
    var manager  =  container.Resolve < DatabaseManager > (); 
    manager.Search( " SELECT * FORM USER " ); 
} 
复制代码

运行结果：

image

分析：

这里通过ContainerBuilder方法RegisterType对DatabaseManager进行注册，当注册的类型在相应得到的容器中可以Resolve你的DatabaseManager实例。

builder.RegisterType<SqlDatabase>().As<IDatabase>();通过AS可以让DatabaseManager类中通过构造函数依赖注入类型相应的接口。

Build()方法生成一个对应的Container实例，这样，就可以通过Resolve解析到注册的类型实例。

同样地，如果你修改数据库类型注册为：

builder.RegisterType<OracleDatabase>().As<IDatabase>();

运行结果：

image

6）显然以上的程序中，SqlDatabase或者OracleDatabase已经暴露于客户程序中了，现在我想将该类型选择通过文件配置进行读取。Autofac自带了一个Autofac.Configuration.dll 非常方便地对类型进行配置，避免了程序的重新编译。

修改App.config：

< configuration >  
   < configSections >  
     < section  name ="autofac"  type ="Autofac.Configuration.SectionHandler, Autofac.Configuration" />  
   </ configSections >  
   < autofac  defaultAssembly ="AutofacDemo" >  
     < components >  
       < component  type ="AutofacDemo.SqlDatabase, AutofacDemo"  service ="AutofacDemo.IDatabase"   />  
     </ components >  
   </ autofac >  
</ configuration >
复制代码

通过Autofac.Configuration.SectionHandler配置节点对组件进行处理。

对应的客户端程序改为：

var builder  =   new  ContainerBuilder(); 
builder.RegisterType < DatabaseManager > (); 
builder.RegisterModule( new  ConfigurationSettingsReader( " autofac " )); 
using  (var container  =  builder.Build()) 
{ 
    var manager  =  container.Resolve < DatabaseManager > (); 
    manager.Search( " SELECT * FORM USER " ); 
} 
复制代码

运行结果：

image


7）另外还有一种方式，通过Register方法进行注册：

var builder  =   new  ContainerBuilder(); 
// builder.RegisterType<DatabaseManager>(); 
builder.RegisterModule( new  ConfigurationSettingsReader( " autofac " )); 
builder.Register(c  =>   new  DatabaseManager(c.Resolve < IDatabase > ())); 
using  (var container  =  builder.Build()) 
{ 
    var manager  =  container.Resolve < DatabaseManager > (); 
    manager.Search( " SELECT * FORM USER " ); 
} 
复制代码

得到结果也是一样的。

8）现在我想通过一个用户类来控制操作权限，比如增删改的权限，创建一个用户类：

///   <summary>  
///  Id Identity Interface 
///   </summary>  
public   interface  Identity 
{ 
     int  Id {  get ;  set ; } 
} 


public   class  User : Identity 
{ 
     public   int  Id {  get ;  set ; } 
     public   string  Name {  get ;  set ; } 
}
复制代码

修改DatabaseManager.cs代码：

public   class  DatabaseManager 
{ 
    IDatabase _database; 
    User _user;

     public  DatabaseManager(IDatabase database) :  this (database,  null ) 
    { 
    }

     public  DatabaseManager(IDatabase database, User user) 
    { 
        _database  =  database; 
        _user  =  user; 
    }

     ///   <summary>  
     ///  Check Authority 
     ///   </summary>  
     ///   <returns></returns>  
     public   bool  IsAuthority() 
    { 
         bool  result  =  _user  !=   null   &&  _user.Id  ==   1   &&  _user.Name  ==   " leepy "   ?   true  :  false ; 
         if  ( ! result) 
            Console.WriteLine( " Not authority! " );

         return  result; 
    }

     public   void  Search( string  commandText) 
    { 
        _database.Select(commandText); 
    }

     public   void  Add( string  commandText) 
    { 
         if  (IsAuthority()) 
            _database.Insert(commandText); 
    }

     public   void  Save( string  commandText) 
    { 
         if  (IsAuthority()) 
            _database.Update(commandText); 
    }

     public   void  Remove( string  commandText) 
    { 
         if  (IsAuthority()) 
            _database.Delete(commandText); 
    } 
}
复制代码

在构造函数中增加了一个参数User，而Add,Save,Remove增加了权限判断。

修改客户端程序：

User user  =   new  User { Id  =   1 , Name  =   " leepy "  }; 
var builder  =   new  ContainerBuilder(); 
builder.RegisterModule( new  ConfigurationSettingsReader( " autofac " )); 
builder.RegisterInstance(user).As < User > (); 
builder.Register(c  =>   new  DatabaseManager(c.Resolve < IDatabase > (), c.Resolve < User > ()));

using  (var container  =  builder.Build()) 
{ 
    var manager  =  container.Resolve < DatabaseManager > ();

    manager.Add( " INSERT INTO USER ... " ); 
}
复制代码

运行结果：

image 
分析：

builder.RegisterInstance(user).As<User>();注册User实例。

builder.Register(c => new DatabaseManager(c.Resolve<IDatabase>(), c.Resolve<User>()));通过Lampda表达式注册DatabaseManager实例。

如果这里我修改User的属性值：

User user = new User { Id = 2, Name = "zhangsan" };

运行结果：

image

说明该用户无权限操作。


gd2008
关注
专栏目录
.NET与JAVA的区别【完整版】
weixin_48605808的博客
08-28 368
.NET与Java的这种相似为网站管理系统的开发提供了便利，如果您掌握了C，那么，掌握Java这个语言几乎是不费什么力气的，需要花费时间的只不过就是熟悉彼此的类库。.NET是.NET Framework，Java是J2SE。学习这两者的理论基础都是面向对象理论。所以，一名有着面向对象理论基础的人是很容易掌握.NET和Java的。 简介 .NET是微软推出的一种新的软件运行平台，它包括一整套应用范围广泛的技术，旨在迎接Java所带来的挑战。.NET给网站管理系统开发带来了很多新的技术，尤其是它的“混合语言”开
三大框架最新
06-07
Struts、Spring和Hibernate，简称SSH，是Java Web开发中的三大主流框架，它们各自负责不同的职责，协同工作以实现高效、灵活的后端应用开发。Struts提供了MVC（Model-View-Controller）架构模式，Spring则是一个全面...
.Net IOC框架入门之一 Unity
weixin_33911824的博客
12-05 204
一、概述 　　IOC:英文全称：Inversion of Control，中文名称：控制反转，它还有个名字叫依赖注入（Dependency Injection）。　　作用：将各层的对象以松耦合的方式组织在一起，解耦，各层对象的调用完全面向接口。当系统重构的时候，代码的改写量将大大减少。　　依赖注入： 当一个类的实例需要另一个类的实例协助时，在传统的程序设计过程中，通常有调用者来创建被调用者的...
Autofac一个优秀的.NET IoC框架
极客神殿
04-28 394
1 前置阅读 在阅读本文章之前，你可以先阅读： 什么是依赖注入 2 简介 Autofac与C#语言的结合非常紧密，并学习它非常的简单，也是.NET领域最为流行的IoC框架之一。 3 使用 首先，将Autofac的NuGet软件包安装到您的应用程序中。 Autofac 然后，我们通过创建ContainerBuilder来注册组件。 var builder = new ContainerBuilder(); builder.RegisterType<Knife>(); builder.Regi
.NET IOC框架——Unity容器基础入门
孙正_大正
02-28 6823
【C#高级语法特性锦集】 https://blog.csdn.net/qq_34202873/article/details/91043366 C# IOC容器Unity 控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框...
主要C＃DI / IoC框架如何比较？ [关闭]
w36680130的博客
07-11 425
At the risk of stepping into holy war territory, What are the strengths and weaknesses of these pop
多种IOC框架的比较
01-27
本文将对比分析几种主流的.NET IOC框架：Spring.NET、StructMap、EntLib、Unity以及Ninject等，探讨它们各自的优点与不足。 #### Spring.NET - **初始化方式**：Spring.NET支持XML配置和代码初始化两种方式。早期...
.NET依赖注入框架：Spring.NET 1.3.2 学习资源
在.NET社区中，存在多种替代的依赖注入框架，如Unity、StructureMap、Ninject、Castle Windsor和Autofac等，它们都是主流的选择，并且持续得到维护和更新。" Spring.NET 1.3.2是Spring.NET框架的一个历史版本，它...
ABP框架详解：领域驱动设计与.NET开发利器
ABP框架，全称为ASP.NET Boilerplate Project，是一个基于.NET平台的通用Web应用程序框架，由2014年5月4日在GitHub开源以来，持续发展并获得了广泛的关注。它的核心理念是采用领域驱动设计（DDD），旨在帮助.NET...
UNIT, AUTOfac ,ninject
05-26
UNIT, AUTOfac ,ninject,自己写的demo 留着自己用的，现在分享出来共大家使用
比较6个.NET控制反转(DI/IoC)框架
飞鹰的专栏
05-23 3325
授权与程序大小 框架 版本 授权 最少dll引用 大小(KB) Castle RC3 Apache  2 2 192 Unity 1.1 MS-PL 2 120 Ninject 1.0 Apache 2 1 (2 : autowiring) 147 (154) Autofac 1.2.7 MIT
17个IoC 软件包和项目
芝麻麻雀-Asp.Net学习之路
02-04 529
1、Autofac GitHub：https://github.com/autofac/Autofac 描述：An addictive .NET IoC container https://autofac.org Star：2.9k Fork：677 2、Ninject GitHub：https://github.com/ninject/ninject 描述：the ninja of .n...
如何在ASP.NET Core应用中实现与第三方IoC/DI框架的整合？
最新发布
chengxuyuanlaow的博客
06-16 1003
当MyServiceProvider的Dispose方法被调用的时候，提供的这些服务实例的Dispose方法会被调用。但是对于我们的MyServiceProvider对象来说，当调用它的GetService方法试图获取ServiceScopeFactory对象的时候，获取的实际上是被封装的那个SerivceProvider关联的ServiceScopeFactory，那么很自然创建的“子ServiceProvider”也与MyServiceProvider没有什么关系。三、如何解决这个问题？
ASP.NET MVC IOC 之AutoFac攻略
weixin_30484739的博客
07-28 902
一、为什么使用AutoFac？ 之前介绍了Unity和Ninject两个IOC容器，但是发现园子里用AutoFac的貌似更为普遍，于是捯饬了两天，发现这个东东确实是个高大上的IOC容器~ Autofac是.NET领域最为流行的IOC框架之一，传说是速度最快的一个： 优点： 它是C#语言联系很紧密，也就是说C#里的很多编程方式都可以为Autofac使用，例如可以用Lambda...
使用IOC轻量级框架Ninject开发
Newd's Blog
04-29 1407
本篇文章必备知识： 1、编程语言基础 2、对面向对象编程的深刻理解 3、  先说说什么是IOC，网上有很多介绍关于IOC的文章，比较官方的定义晦涩难懂，所以不在这里赘述了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值