protected override void ConfigureServices()
{
var builder = new ContainerBuilder();
List<Type> typeCollection = GetTypesToRegister();
// Runtime Services
builder.RegisterType<CommandManager>().As<ICommandManager>();
builder.RegisterType<NotificationManager>().As<INotificationCenter>().SingleInstance();
builder.RegisterTypes(typeCollection.Where(type => type.IsAssignableTo<IInputCommand>()).ToArray())
.AsImplementedInterfaces()
.AsSelf();
// Marker Services
builder.RegisterTypes(typeCollection.Where(type => type.IsAssignableTo<IRepository>()).ToArray()).AsImplementedInterfaces();
builder.RegisterTypes(typeCollection.Where(type => type.IsAssignableTo<IService>()).ToArray()).AsImplementedInterfaces();
builder
.RegisterTypes(typeCollection.Where(type => type.IsAssignableTo<IComponent>()).ToArray())
.AsImplementedInterfaces();
builder
.RegisterTypes(typeCollection.Where(type => type.IsAssignableTo<IGameComponent>()).ToArray())
.AsImplementedInterfaces()
.OnActivating(args => ((IGameComponent)args.Instance).SetNotificationManager(this.container.Resolve<INotificationCenter>()));
// Server Services
builder.RegisterType<DefaultServer>().As<IServer>();
builder.RegisterType<ServerConfiguration>().As<IServerConfiguration>();
container = builder.Build();
CommandManagerFactory.SetFactory(() => container.Resolve<ICommandManager>());
CharacterFactory.SetFactory(
game => this.container.Resolve<IPlayer>(new TypedParameter(typeof(IGame), game)));
CommandFactory.SetFactory(CreateCommandFromAlias);
}
protected override void Load(ContainerBuilder builder)
{
logger.Information("Hi from pingo.filters Autofac.Load!");
var assembly = this.GetType().GetTypeInfo().Assembly;
var derivedTypes = TypeHelper<ActionFilterAttribute>.FindDerivedTypes(assembly).ToArray();
var derivedTypesName = derivedTypes.Select(x => x.GetTypeInfo().Name);
logger.Information("Found these types: {DerivedTypes}", derivedTypesName);
builder.RegisterTypes(derivedTypes).SingleInstance();
derivedTypes = TypeHelper<MiddlewarePlugin>.FindDerivedTypes(assembly).ToArray();
derivedTypesName = derivedTypes.Select(x => x.GetTypeInfo().Name);
logger.Information("Found these types: {DerivedTypes}", derivedTypesName);
builder.RegisterTypes(derivedTypes).SingleInstance();
/*
builder.RegisterType<AuthActionFilter>().SingleInstance();
builder.RegisterType<LogFilter>().SingleInstance();
builder.RegisterType<LogFilter2>().SingleInstance();
builder.RegisterType<LogFilter3>().SingleInstance();
*/
}
protected void Application_Start(object sender, EventArgs e)
{
System.Web.Http.GlobalConfiguration.Configuration.Routes.MapHttpRoute("htt", "{controller}/{action}");
System.Web.Http.GlobalConfiguration.Configuration.Filters.Add(new HaishanExceptionHandler());
System.Web.Http.GlobalConfiguration.Configuration.Filters.Add(new HaishanActionFilter());
var flagIScoped = typeof(IScoped);
var flagITransient = typeof(ITransient);
var lstAssembly = System.Web.Compilation.BuildManager.GetReferencedAssemblies().Cast <System.Reflection.Assembly>().ToList();
var lstType = lstAssembly.SelectMany(x => x.GetTypes()).ToList();
var lstIScoped = lstType.Where(x => x != flagIScoped && flagIScoped.IsAssignableFrom(x)).ToArray();
var lstITransient = lstType.Where(x => x != flagITransient && flagITransient.IsAssignableFrom(x)).ToArray();
var builder = new Autofac.ContainerBuilder();
builder.RegisterTypes(lstIScoped).AsSelf().AsImplementedInterfaces().PropertiesAutowired()
.InstancePerApiRequest();
builder.RegisterTypes(lstITransient).AsSelf().AsImplementedInterfaces().PropertiesAutowired()
.InstancePerDependency();
var controllerAssembly = System.Reflection.Assembly.GetExecutingAssembly();
builder.RegisterApiControllers(controllerAssembly).AsSelf().PropertiesAutowired()
.InstancePerDependency();
var resolver = new Autofac.Integration.WebApi.AutofacWebApiDependencyResolver(builder.Build());
System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver = resolver;
}
public static void Register()
{
//初始化AutoFac的相关功能
/*
* 1.0 告诉AutoFac初始化数据仓储层FB.CMS.Repository.dll中所有类的对象实例。这些对象实例以其接口的形式保存在AutoFac容器中
* 2.0 告诉AutoFac初始化业务逻辑层FB.CMS.Services.dll中所有类的对象实例。这些对象实例以其接口的形式保存在AutoFac容器中
* 3.0 将MVC默认的控制器工厂替换成AutoFac的工厂
*/
//第一步： 构造一个AutoFac的builder容器
ContainerBuilder builder = new Autofac.ContainerBuilder();
//第二步：告诉AutoFac控制器工厂，控制器类的创建去哪些程序集中查找（默认控制器工厂是去扫描bin目录下的所有程序集）
//2.1 从当前运行的bin目录下加载FB.CMS.MvcSite.dll程序集
Assembly controllerAss = Assembly.Load("Qingke365.RollCall.WebApi");
//2.2 告诉AutoFac控制器工厂，控制器的创建从controllerAss中查找（注意：RegisterControllers()方法是一个可变参数，如果你的控制器类的创建需要去多个程序集中查找的话，那么我们就再用Assembly controllerBss=Assembly.Load("需要的程序集名")加载需要的程序集，然后与controllerAss组成数组，然后将这个数组传递到RegisterControllers()方法中）
builder.RegisterControllers(controllerAss);
builder.RegisterApiControllers(controllerAss);
//第三步：告诉AutoFac容器，创建项目中的指定类的对象实例，以接口的形式存储（其实就是创建数据仓储层与业务逻辑层这两个程序集中所有类的对象实例，然后以其接口的形式保存到AutoFac容器内存中，当然如果有需要也可以创建其他程序集的所有类的对象实例，这个只需要我们指定就可以了）
//3.1 加载数据仓储层FB.CMS.Repository这个程序集。
Assembly repositoryAss = Assembly.Load("Qingke365.RollCall.Dal");
//3.2 反射扫描这个FB.CMS.Repository.dll程序集中所有的类，得到这个程序集中所有类的集合。
Type[] rtypes = repositoryAss.GetTypes();
//3.3 告诉AutoFac容器，创建rtypes这个集合中所有类的对象实例
builder.RegisterTypes(rtypes)
.AsImplementedInterfaces(); //指明创建的rtypes这个集合中所有类的对象实例，以其接口的形式保存
//3.4 加载业务逻辑层FB.CMS.Services这个程序集。
Assembly servicesAss = Assembly.Load("Qingke365.RollCall.Bll");
//3.5 反射扫描这个FB.CMS.Services.dll程序集中所有的类，得到这个程序集中所有类的集合。
Type[] stypes = servicesAss.GetTypes();
//3.6 告诉AutoFac容器，创建stypes这个集合中所有类的对象实例
builder.RegisterTypes(stypes)
.AsImplementedInterfaces(); //指明创建的stypes这个集合中所有类的对象实例，以其接口的形式保存
//第四步：创建一个真正的AutoFac的工作容器
var container = builder.Build();
//我们已经创建了指定程序集的所有类的对象实例，并以其接口的形式保存在AutoFac容器内存中了。那么我们怎么去拿它呢？
//从AutoFac容器内部根据指定的接口获取其实现类的对象实例
//假设我要拿到IsysFunctionServices这个接口的实现类的对象实例，怎么拿呢？
//var obj = container.Resolve<IsysFunctionServices>(); //只有有特殊需求的时候可以通过这样的形式来拿。一般情况下没有必要这样来拿，因为AutoFac会自动工作（即：会自动去类的带参数的构造函数中找与容器中key一致的参数类型，并将对象注入到类中，其实就是将对象赋值给构造函数的参数）
//第五步：将当前容器中的控制器工厂替换掉MVC默认的控制器工厂。（即：不要MVC默认的控制器工厂了，用AutoFac容器中的控制器工厂替代）此处使用的是将AutoFac工作容器交给MVC底层 (需要using System.Web.Mvc;)
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);
}
protected void Application_Start(object sender, EventArgs e)
{
System.Web.Mvc.AreaRegistration.RegisterAllAreas();
//mvc相关
System.Web.Routing.RouteTable.Routes.MapRoute("l2",
"{controller}/{action}",
defaults: new { controller = "Home", action = "Index" });
//ioc和aop相关
Type flagIScoped = typeof(IScoped);
Type flagISingleton = typeof(ISingleton);
Type flagITransient = typeof(ITransient);
//bin目录下的所有的类型
var lstType = System.Web.Compilation.BuildManager.GetReferencedAssemblies()
.Cast <System.Reflection.Assembly>()
.SelectMany(x => x.GetTypes())
.ToList();
var lstTypeIScoped = lstType.Where(x => flagIScoped.IsAssignableFrom(x))
.Where(x => x != flagIScoped).ToArray();
var lstTypeISingleton = lstType.Where(x => flagISingleton.IsAssignableFrom(x))
.Where(x => x != flagISingleton).ToArray();
var lstTypeITransient = lstType.Where(x => flagITransient.IsAssignableFrom(x))
.Where(x => x != flagITransient).ToArray();
var builder = new Autofac.ContainerBuilder();
builder.RegisterTypes(lstTypeIScoped).AsSelf().AsImplementedInterfaces()
.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies)
.InstancePerRequest();
builder.RegisterTypes(lstTypeISingleton).AsSelf().AsImplementedInterfaces()
.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies)
.SingleInstance();
builder.RegisterTypes(lstTypeITransient).AsSelf().AsImplementedInterfaces()
.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies)
.InstancePerDependency();
builder.RegisterGeneric(typeof(Azeroth.Util.Log <>))
.As(typeof(Azeroth.Util.ILog <>))
.SingleInstance();
builder.RegisterControllers(System.Reflection.Assembly.GetExecutingAssembly())
.AsSelf()
.PropertiesAutowired(PropertyWiringOptions.AllowCircularDependencies)
.InstancePerRequest()
.EnableClassInterceptors()
.InterceptedBy(typeof(App_Start.InterceptedHandler));
var container = builder.Build();
var resolver = new Autofac.Integration.Mvc.AutofacDependencyResolver(container);
System.Web.Mvc.DependencyResolver.SetResolver(resolver);
//日志信息相关的处理
this.LogConfigure(new Bll.Log(new Model.Entity.DbContext()));
}
public static void Register()
{
//第一步：初始化AutoFac的相关功能
ContainerBuilder builder = new Autofac.ContainerBuilder();
//第二步：告诉AutoFac控制器工厂，控制器类的创建去哪些程序集中查找（默认控制器工厂是去扫描bin目录下的所有程序集）
//2.1 从当前运行的bin目录下加载FB.CMS.MvcSite.dll程序集
Assembly controllerAss = Assembly.Load("WebApplication1");
//2.2 告诉AutoFac控制器工厂，控制器的创建从controllerAss中查找（注意：RegisterControllers()方法是一个可变参数，如果你的控制器类的创建需要去多个程序集中查找的话，那么我们就再用Assembly controllerBss=Assembly.Load("需要的程序集名")加载需要的程序集，然后与controllerAss组成数组，然后将这个数组传递到RegisterControllers()方法中）
builder.RegisterControllers(controllerAss);
//或者//builder.RegisterControllers(Assembly.GetExecutingAssembly());
//第三步：告诉AutoFac容器，创建项目中的指定类的对象实例，以接口的形式存储（其实就是创建数据仓储层与业务逻辑层这两个程序集中所有类的对象实例，然后以其接口的形式保存到AutoFac容器内存中，当然如果有需要也可以创建其他程序集的所有类的对象实例，这个只需要我们指定就可以了）
//3.1 加载数据仓储层WebApplication1这个程序集。
Assembly repositoryAss = Assembly.Load("ZM.CMS.Repository");
//3.2 反射扫描这个FB.CMS.Repository.dll程序集中所有的类，得到这个程序集中所有类的集合。
Type[] rtypes = repositoryAss.GetTypes();
//3.3 告诉AutoFac容器，创建rtypes这个集合中所有类的对象实例
builder.RegisterTypes(rtypes)
.AsImplementedInterfaces(); //指明创建的rtypes这个集合中所有类的对象实例，以其接口的形式保存
//3.4 加载业务逻辑层FB.CMS.Services这个程序集。
Assembly servicesAss = Assembly.Load("ZM.CMS.Services");
//3.5 反射扫描这个FB.CMS.Services.dll程序集中所有的类，得到这个程序集中所有类的集合。
Type[] stypes = servicesAss.GetTypes();
//3.6 告诉AutoFac容器，创建stypes这个集合中所有类的对象实例
builder.RegisterTypes(stypes)
.AsImplementedInterfaces(); //指明创建的stypes这个集合中所有类的对象实例，以其接口的形式保存
//第四步：创建一个真正的AutoFac的工作容器
var container = builder.Build();
//第五步：将当前容器中的控制器工厂替换掉MVC默认的控制器工厂。（即：不要MVC默认的控制器工厂了，用AutoFac容器中的控制器工厂替代）此处使用的是将AutoFac工作容器交给MVC底层 (需要using System.Web.Mvc;)
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
//我们知道控制器的创建是调用MVC默认的控制器工厂，默认的控制器工厂是调用控制器类的无参构造函数
//可是我们如果要使用AutoFac自动工厂，将对象通过构造函数注入类中，那么这个构造函数就需要带参数
//如果我们将控制器的无参构造函数删除，保留带参数的构造函数，MVC默认的控制器工厂来创建控制的时候
//就会去调用无参的构造函数，可是这时候发现没有无参的构造函数于是就报“没有为该对象定义无参数的构造函数”错误
//既然报错,那我们如果保留无参的构造函数，同时在声明一个带参数的构造函数是否可行呢？
//答案;行是行，但是创建控制器的时候，MVC默认的控制器工厂调用的是无参构造函数，它并不会去调用有参的构造函数
//这时候，我们就只能将AutoFac它的控制器工厂替换调用MVC默认的控制器工厂（控制器由AutoFac的控制器工厂来创建）
//而AutoFac控制器工厂在创建控制的时候只会扫描带参数的构造函数，并将对象注入到带参数的构造函数中
//AutofacDependencyResolver这个控制器工厂是继承了 IDependencyResolver接口的，而IDependencyResolver接口是MVC的东西
//MVC默认的控制器工厂名字叫：DefaultControllerFactory
//具体参考：http://www.cnblogs.com/artech/archive/2012/04/01/controller-activation-032.html
}
public static void Register()
{
//初始化一个autofac容器
var autoConainer = new ContainerBuilder();
//告诉autofac查找控制器类需要扫描的程序集
autoConainer.RegisterControllers(Assembly.Load("Test"));
//将指定程序集下的类的实例保存到autofac容器 用于注入
autoConainer.RegisterTypes(Assembly.Load("DAL").GetTypes()).AsImplementedInterfaces();
autoConainer.RegisterTypes(Assembly.Load("BLL").GetTypes()).AsImplementedInterfaces();
var c=autoConainer.Build();
//告诉mvc底层 创建控制器由autofac 容器接管
System.Web.Mvc.DependencyResolver.SetResolver(new AutofacDependencyResolver(c));
}
/// <summary>
/// WebApi的AutoFac配置
/// </summary>
/// <param name="projectName">WebApi项目名（命名空间）</param>
public static void Init_WebApi(string projectName = "")
{
//默认项目名称
projectName = string.IsNullOrEmpty(projectName) ? _DefaultApiName : projectName;
//构造一个AutoFac的builder容器
ContainerBuilder builder = new Autofac.ContainerBuilder();
var configuration = GlobalConfiguration.Configuration;
builder.RegisterWebApiFilterProvider(configuration);
Assembly apicontrollerAss = Assembly.Load(projectName);
builder.RegisterApiControllers(apicontrollerAss);
Assembly repositoryAss = Assembly.Load("Services"); //加载数据层程序集。
Type[] rtypes = repositoryAss.GetTypes();
builder.RegisterTypes(rtypes)
.AsImplementedInterfaces().InstancePerApiRequest();
//创建AutoFac工作容器
var container = builder.Build();
configuration.DependencyResolver = new AutofacWebApiDependencyResolver(container);//注册api容器
}
public static string _DefaultApiName = "O.AdminProApi"; //默认WebApi命名空间/项目名
/// <summary>
/// Web项目配置
/// </summary>
/// <param name="projectName">WebApi项目名（命名空间）</param>
public static void Init(string projectName = "")
{
//默认项目名称
projectName = string.IsNullOrEmpty(projectName) ? _DefaultName : projectName;
//构造一个AutoFac的builder容器
ContainerBuilder builder = new Autofac.ContainerBuilder();
//第二步：告诉AutoFac控制器工厂，控制器类的创建去哪些程序集中查找（默认控制器工厂是去扫描bin目录下的所有程序集）
Assembly controllerAss = Assembly.Load(projectName);
builder.RegisterControllers(controllerAss);
//加载业务逻辑层程序集。
Assembly servicesAss = Assembly.Load("Services");
Type[] stypes = servicesAss.GetTypes();
builder.RegisterTypes(stypes).AsImplementedInterfaces(); //指明创建的stypes这个集合中所有类的对象实例，以其接口的形式保存
//创建一个真正的AutoFac的工作容器
var container = builder.Build();
//将当前容器中的控制器工厂替换掉MVC默认的控制器工厂。
//（即：不要MVC默认的控制器工厂了，用AutoFac容器中的控制器工厂替代）此处使用的是将AutoFac工作容器交给MVC底层 (需要using System.Web.Mvc;)
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
/// <summary>
/// 注册
/// </summary>
public static AutofacWebApiDependencyResolver Register()
{
ContainerBuilder builder = new Autofac.ContainerBuilder();
// Assembly controllerAss = Assembly.Load(string.Format("{0}.Web", proname));
// builder.RegisterControllers(Assembly.GetExecutingAssembly());
// builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).PropertiesAutowired();
Assembly repositoryAss = Assembly.Load("serviceimpl");
Type[] rtypes = repositoryAss.GetTypes();
builder.RegisterTypes(rtypes)
.AsImplementedInterfaces();
// builder.RegisterTypes(typeof(SIC_WebClient)).SingleInstance().PropertiesAutowired();
var container = builder.Build();
// DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
// Set the dependency resolver for Web API.
return(new AutofacWebApiDependencyResolver(container));
//GlobalConfiguration.Configuration.DependencyResolver = webApiResolver;
}
/// <summary>
/// Initializes a new instance of the <see cref="MainWindow"/> class.
/// </summary>
public MainWindow()
{
this.InitializeComponent();
var builder = new ContainerBuilder();
builder.RegisterTypes(
typeof(RelayCloudBlobStorageProvider),
typeof(Channel),
typeof(PostalService),
typeof(OwnEndpointServices),
typeof(DirectEntryAddressBook),
typeof(HttpClientWrapper))
.AsSelf()
.AsImplementedInterfaces()
.SingleInstance()
.PropertiesAutowired();
builder.RegisterType(
typeof(ChatroomWindow))
.AsSelf()
.PropertiesAutowired();
builder.Register(ctxt => ctxt.Resolve<HttpClientWrapper>().Client);
builder.RegisterInstance(this)
.AsSelf()
.PropertiesAutowired();
this.container = builder.Build();
this.container.Resolve<MainWindow>(); // get properties satisfied
this.MessageRelayService.BlobPostUrl = new Uri(ConfigurationManager.ConnectionStrings["RelayBlobService"].ConnectionString);
this.MessageRelayService.InboxServiceUrl = new Uri(ConfigurationManager.ConnectionStrings["RelayInboxService"].ConnectionString);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterTypes(
ThisAssembly.GetExportedTypes()
.Where(x => x.Namespace != null && x.Namespace.EndsWith("Core"))
.ToArray());
}
private void AutofacInit()
{
Type flagMeta = typeof(Model.IAutofacFlag);
//bin下的所有程序集
List <System.Reflection.Assembly> lst = new List <System.Reflection.Assembly>();
// var System.Reflection.Assembly.LoadFrom("Azeroth.WCH.Bll.dll");
System.Reflection.Assembly[] allAssembly = System.Web.Compilation.BuildManager.GetReferencedAssemblies().Cast <System.Reflection.Assembly>().ToArray();
//AppDomain.CurrentDomain.GetAssemblies().ToArray();
//标识接口派生的类和接口
var allMeta = allAssembly.SelectMany(x => x.GetTypes()).Where(x => flagMeta.IsAssignableFrom(x) && x != flagMeta).ToArray();
var builder = new Autofac.ContainerBuilder();
builder.RegisterTypes(allMeta)
.AsSelf()
.AsImplementedInterfaces()
.InstancePerLifetimeScope()
.PropertiesAutowired(); //PropertiesAutowired注册为属性注入类型，所有实现IAutofacFlag的注册为InstancePerLifetimeScope生命周期
builder.Update(Container);
builder = new ContainerBuilder();
builder.RegisterControllers(allAssembly)
.AsSelf()
.InstancePerLifetimeScope()
.PropertiesAutowired();
builder.Update(Container);
DependencyResolver.SetResolver(new AutofacDependencyResolver(Container));
}
static void Main(string[] args)
{
var containerBuilder = new ContainerBuilder();
containerBuilder.RegisterType<Cpu>().As<ICpu>().SingleInstance();
containerBuilder.RegisterType<Emulator>().As<IEmulator>();
containerBuilder.RegisterType<Memory>().As<IMemory>().SingleInstance();
containerBuilder.RegisterType<Ppu>().As<IPpu>();
var instructionTypes = Assembly.GetExecutingAssembly().GetTypes().Where(f => typeof(IInstruction).IsAssignableFrom(f) && !f.IsAbstract).ToArray();
containerBuilder.RegisterTypes(instructionTypes)
.As<IInstruction>();
var container = containerBuilder.Build();
var emulator = container.Resolve<IEmulator>();
var memory = container.Resolve<IMemory>();
memory.SetCartridge(new Cartridge("../../roms/nestest.nes"));
emulator.Reset();
for (;;)
{
emulator.Step();
}
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterControllers(Assembly.GetExecutingAssembly());
builder.RegisterApiControllers(Assembly.GetExecutingAssembly());
// Register the SignalR hubs.
builder.RegisterHubs(Assembly.GetExecutingAssembly());
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.Where(t => t.Name.EndsWith("Repository", StringComparison.Ordinal))
.AsImplementedInterfaces();
builder.RegisterType<FeatureApplicationServices>().AsImplementedInterfaces();
builder.RegisterType<CommandSender>().As<ICommandSender>();
var innerBuilder = new ContainerBuilder();
innerBuilder.RegisterTypes(ThisAssembly.GetTypes().Where(_ => typeof(IHubBroadcasterFor).IsAssignableFrom(_)).ToArray())
.As<IHubBroadcasterFor>();
innerBuilder.RegisterTypes(ThisAssembly.GetTypes().Where(_ => typeof(IDatabaseBroadcasterFor).IsAssignableFrom(_)).ToArray())
.As<IDatabaseBroadcasterFor>();
innerBuilder.RegisterTypes(ThisAssembly.GetTypes().Where(_ => typeof(IHistoryBroadcasterFor).IsAssignableFrom(_)).ToArray())
.As<IHistoryBroadcasterFor>();
IContainer innerContainer = innerBuilder.Build();
var eventHandlers = new IEventHandler[] {
new DatabaseEventHandler(innerContainer.Resolve<IEnumerable<IDatabaseBroadcasterFor>>()),
new HubEventHandler(innerContainer.Resolve<IEnumerable<IHubBroadcasterFor>>()),
new HistoryEventHandler(innerContainer.Resolve<IEnumerable<IHistoryBroadcasterFor>>())
};
var dispatcher = new NEventStoreDispatcher(eventHandlers);
var nEventStore =
Wireup.Init()
.LogToOutputWindow()
.UsingSqlPersistence("FeatureBeeContext")
.WithDialect(new MsSqlDialect())
.InitializeStorageEngine()
// .EnlistInAmbientTransaction()
.UsingJsonSerialization()
.UsingSynchronousDispatchScheduler()
.DispatchTo(new DelegateMessageDispatcher(dispatcher.DispatchCommit))
.Build();
builder.RegisterInstance(nEventStore);
}
/// <summary>
/// 实现依赖注入接口<see cref="IDependency"/>实现类型的注册
/// </summary>
/// <param name="types">要注册的类型集合</param>
protected void RegisterDependencyTypes(Type[] types)
{
ContainerBuilder builder = new ContainerBuilder();
var builderSource = builder.RegisterTypes(types)
.AsSelf()
.AsImplementedInterfaces()
.InstancePerLifetimeScope();//所有实现IDependency的注册为InstancePerLifetimeScope生命周期
builder.Update(Container);
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterTypes(ThisAssembly);
builder.Register<Func<Type, object>>(context =>
{
var componentContext = context.Resolve<IComponentContext>();
return serviceType => componentContext.Resolve(serviceType);
});
}
public void Initialize()
{
var builder = new ContainerBuilder();
var loggerConfigurator = new LoggerConfigurator(_logLevel);
loggerConfigurator.Configure();
var logger = loggerConfigurator.GetLogger();
builder.RegisterInstance<ILog>(logger).Exported(x => x.As<ILog>());
builder.RegisterType<ReplConsole>().As<IConsole>().Exported(x => x.As<IConsole>());
var types = new[]
{
typeof (ScriptHostFactory),
typeof (FileSystem),
typeof (PackageAssemblyResolver),
typeof (PackageContainer),
typeof (FilePreProcessor),
typeof (ScriptPackResolver),
typeof (NugetInstallationProvider),
typeof (PackageInstaller),
typeof (AssemblyName)
};
builder.RegisterTypes(types).AsImplementedInterfaces();
if (_debug)
{
builder.RegisterType<DebugScriptExecutor>().As<IScriptExecutor>();
builder.RegisterType<RoslynScriptDebuggerEngine>().As<IScriptEngine>();
builder.RegisterType<FSharpScriptEngine>().As<IScriptEngine>();
}
else
{
builder.RegisterType<ScriptExecutor>().As<IScriptExecutor>();
builder.RegisterType<RoslynScriptEngine>().As<IScriptEngine>();
builder.RegisterType<FSharpScriptEngine>().As<IScriptEngine>();
}
builder.RegisterType<ScriptServiceRoot>().As<ScriptServiceRoot>();
if (_shouldInitDrirectoryCatalog)
{
var scriptPath = Path.Combine(Environment.CurrentDirectory, "bin");
if (Directory.Exists(scriptPath))
{
var catalog = new DirectoryCatalog(scriptPath);
builder.RegisterComposablePartCatalog(catalog);
}
}
_container = builder.Build();
_scriptServiceRoot = _container.Resolve<ScriptServiceRoot>();
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
builder.RegisterType<Fixture>().SingleInstance();
builder.RegisterTypes(
typeof(StringGenerator))
.SingleInstance();
builder.RegisterType<OperationGenerator>().SingleInstance();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<AutofacApplicationBus>()
.As<IApplicationBus>()
.SingleInstance();
builder.RegisterGeneric(typeof (NullHandler<,>))
.As(typeof (IRequestHandler<,>));
builder.RegisterTypes(_handlerTypes.Distinct()
.ToArray())
.AsImplementedInterfaces();
}
/// <summary>
/// 容器注册管理
/// </summary>
static void ContainerManagment()
{
var builder = new ContainerBuilder();
builder.RegisterModelBinders(Assembly.GetExecutingAssembly());
builder.RegisterModelBinderProvider();
builder.RegisterControllers(Assembly.GetExecutingAssembly());
//builder.RegisterType<UserRepository>().As<IUserRepository>();
builder.RegisterTypes(Assembly.Load("MvcEFTest.Autofac.Demo.Repositories").GetTypes()).AsImplementedInterfaces();
// Change controller action parameter injection by changing web.config.
builder.RegisterType<ExtensibleActionInvoker>().As<IActionInvoker>().InstancePerRequest();
IContainer container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
/// <summary>
/// 负责调用 autofac框架实现业务逻辑 和 数据仓储层程集中的类型对象的创建
/// 负责创建MVC控制器类的对象（调用控制器中的有残构造函数） ， 接管DefaultControllerFactory的工作
/// </summary>
public static void Register()
{
// 1.0 实例化autofac的创建容器
var bulider = new Autofac.ContainerBuilder();
// 2.0 告诉AutoFac 框架， 将来要创建的控制器类存放在哪个程序集(CRM.Site)
Assembly controllerAss = Assembly.Load("CRM.Site");
bulider.RegisterControllers(controllerAss);
// 3.0 告诉 autofac注册仓储层所在程序集中 所有类的对象的 对象实例
Assembly respAss = Assembly.Load("CRM.Repository");
//创建respAss中所有类 instance 以此的实现接口 存储
bulider.RegisterTypes(respAss.GetTypes()).AsImplementedInterfaces();//.InstancePerHttpRequest();
// 4.0 告诉 autofac注册业务逻辑层所在程序集中 所有类的对象的 对象实例
Assembly serAss = Assembly.Load("CRM.Services");
//创建respAss中所有类 instance 以此的实现接口 存储
bulider.RegisterTypes(serAss.GetTypes()).AsImplementedInterfaces(); //.InstancePerHttpRequest();
// 5.0 创建一个autofac 的容器
var container = bulider.Build();
// 5.01 将container 对象 缓存到 httpRuntime.cache 中， 并且 永久有效
CacheMgr.SetData(Keys.AutofacContainer, container);
// Resolve 方法可以从autofac 容器中获取IsysuserInfoSerices 的 具体实现类的实体对象
// 6.0 将MVC的控制器对象实例 交由autofac来创建
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
ContainerBuilder builder0 = new ContainerBuilder();
var Container = builder0.Build();
Type baseType = typeof(Model.IDependency);
System.Reflection.Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies().ToArray(); //获取已加载到此应用程序域的执行上下文中的程序集。
Type[] dependencyTypes = assemblies
.SelectMany(s => s.GetTypes())
.Where(p => baseType.IsAssignableFrom(p) && p != baseType).ToArray(); //得到接口和实现类
//RegisterDependencyTypes(dependencyTypes); //第一步：注册类型
Autofac.ContainerBuilder builder = new Autofac.ContainerBuilder();
//builder.RegisterType<DbContextScopeFactory>()
// .As<IDbContextScopeFactory>()
// .AsSelf()
// .AsImplementedInterfaces()
// .InstancePerLifetimeScope()
// .PropertiesAutowired();
builder.RegisterTypes(dependencyTypes)
.AsSelf()
.AsImplementedInterfaces()
.InstancePerLifetimeScope()
.PropertiesAutowired(); //PropertiesAutowired注册为属性注入类型，所有实现IDependency的注册为InstancePerLifetimeScope生命周期
builder.Update(Container);
//SetResolver(assemblies); //第二步：
ContainerBuilder builder2 = new ContainerBuilder();
builder2.RegisterControllers(assemblies)
.AsSelf()
.InstancePerLifetimeScope()
.PropertiesAutowired();
builder2.Update(Container);
DependencyResolver.SetResolver(new AutofacDependencyResolver(Container));
}
static Program()
{
//discover types
new DirectoryCatalog(".");
//bootstrap everything
var builder = new ContainerBuilder();
builder.RegisterType<FileEventSerializer>().As<IEventSerializer>();
builder.RegisterType<EventService>().As<IEventService>();
builder.RegisterType<ConsoleLogger>().As<ILogger>();
builder.RegisterGeneric(typeof(LoggingAspect<>)).As(typeof(IAspect<>));
builder.RegisterGeneric(typeof(TransactionAspect<>)).As(typeof(IAspect<>));
//find and register all features
var features = from feat in AppDomain.CurrentDomain.GetAssemblies().SelectMany( a=> a.GetTypes())
where !feat.IsInterface && !feat.IsAbstract
where (from @if in feat.GetInterfaces() where @if.IsGenericType select @if.GetGenericTypeDefinition()).FirstOrDefault() == typeof(IFeature<>)
select feat;
builder.RegisterTypes(features.ToArray());
var container = builder.Build();
_bus = container.Resolve<IEventService>();
_bus.CanRead = false;
_bus.CanWrite = true;
var logger = container.Resolve<ILogger>();
//find all commands
//var commands = from cmd in AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes())
// where !cmd.IsInterface && !cmd.IsAbstract && typeof(ICommand).IsAssignableFrom(cmd)
// select cmd;
////register/subscribe all commands with dmain handlers
//foreach (var cmd in commands)
//{
// var createHandler = typeof(DomainServicesExtensions).GetMethod("CreateHandler", BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(cmd);
// var handler = createHandler.Invoke(null, new[] { container });
// var subscribe = typeof(EventService).GetMethod("Subscribe").MakeGenericMethod(cmd);
// subscribe.Invoke(_bus, new[] { handler });
//}
}
private static IContainer ConfigureApplication()
{
var builder = new ContainerBuilder();
// builder.RegisterType<InputSource>().As<IInputSource>().SingleInstance();
builder.RegisterType<MyGame>().As<IPresenter>().As<IIO>().SingleInstance();
builder.RegisterType<Cpu>().As<ICpu>().SingleInstance();
builder.RegisterType<Emulator>().As<IEmulator>().SingleInstance();
builder.RegisterType<Memory>().As<IMemory>().SingleInstance();
builder.RegisterType<Ppu>().As<IPpu>().SingleInstance();
builder.RegisterType<StolenPpu>();
//var cartridge = new Cartridge("../../../LeetNES/roms/nestest.nes");
var instructionTypes = typeof(IInstruction).Assembly.GetTypes().Where(f => typeof(IInstruction).IsAssignableFrom(f) && !f.IsAbstract).ToArray();
builder.RegisterTypes(instructionTypes).As<IInstruction>();
return builder.Build();
}
public static void Register()
{
ContainerBuilder builder = new Autofac.ContainerBuilder();
Assembly controllerAss = Assembly.Load("LocateProject");
builder.RegisterControllers(controllerAss);
//Assembly repositoryAss = Assembly.Load("ILP_DAL");//接口层
//Type[] rtypes = repositoryAss.GetTypes();
//builder.RegisterTypes(rtypes)
// .AsImplementedInterfaces();
Assembly servicesAss = Assembly.Load("LP_DAL");
Type[] stypes = servicesAss.GetTypes();
builder.RegisterTypes(stypes)
.AsImplementedInterfaces();
var container = builder.Build();
DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
}
private static void Main(string[] args)
{
var builder = new ContainerBuilder();
builder.RegisterTypes(
typeof(Program),
typeof(RelayCloudBlobStorageProvider),
typeof(Channel),
typeof(OwnEndpointServices),
typeof(DirectEntryAddressBook),
typeof(HttpClientWrapper))
.AsSelf()
.AsImplementedInterfaces()
.SingleInstance()
.PropertiesAutowired();
builder.Register(ctxt => ctxt.Resolve<HttpClientWrapper>().Client);
var container = builder.Build();
var program = container.Resolve<Program>();
program.DoAsync().GetAwaiter().GetResult();
}
public void Initialize()
{
var builder = new ContainerBuilder();
var types = new[]
{
typeof (ScriptHostFactory),
typeof (FileSystem),
typeof (PackageAssemblyResolver),
typeof (PackageContainer),
typeof (FilePreProcessor),
typeof (ScriptPackResolver),
typeof (NugetInstallationProvider),
typeof (PackageInstaller)
};
builder.RegisterTypes(types).AsImplementedInterfaces();
if (_debug)
{
builder.RegisterType<DebugScriptExecutor>().As<IScriptExecutor>();
builder.RegisterType<RoslynScriptDebuggerEngine>().As<IScriptEngine>();
}
else
{
builder.RegisterType<ScriptExecutor>().As<IScriptExecutor>();
builder.RegisterType<RoslynScriptEngine>().As<IScriptEngine>();
}
builder.RegisterType<ScriptServiceRoot>().As<ScriptServiceRoot>();
var scriptPath = Path.Combine(Environment.CurrentDirectory, "bin") ;
if (Directory.Exists(scriptPath))
{
var catalog = new DirectoryCatalog(scriptPath);
builder.RegisterComposablePartCatalog(catalog);
}
_container = builder.Build();
_scriptServiceRoot = _container.Resolve<ScriptServiceRoot>();
}
public void Setup()
{
var builder = new ContainerBuilder();
// Register all of the available transformers.
builder
.RegisterTypes(MessageTransformFactory.GetAvailableTransformerTypes())
.AsImplementedInterfaces()
.AsSelf();
// Build the IoC container
this.container = builder.Build();
// Define our factory method for resolving the transformer based on device type.
MessageTransformFactory.SetTransformerFactory((type) =>
{
if (!type.IsAssignableTo<IMessageTransformer>())
{
throw new InvalidOperationException("The type provided to the message transform factory resolver can not be cast to IMessageTransformer");
}
return container.Resolve(type) as IMessageTransformer;
});
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterTypes(ThisAssembly);
}
private static void RegisterModelBuilders(ContainerBuilder builder)
{
builder.RegisterTypes(
Assembly.GetExecutingAssembly().GetTypes().Where(t => t.FullName.EndsWith("ModelBuilder")).ToArray())
.AsImplementedInterfaces();
}
/// <summary>
/// ioc依赖注入
/// </summary>
public static void ContainerBuilderRegister()
{
//初始化AutoFac的相关功能
/*
* 1.0 告诉AutoFac初始化数据仓储层FB.CMS.Repository.dll中所有类的对象实例。这些对象实例以其接口的形式保存在AutoFac容器中
* 2.0 告诉AutoFac初始化业务逻辑层FB.CMS.Services.dll中所有类的对象实例。这些对象实例以其接口的形式保存在AutoFac容器中
* 3.0 将MVC默认的控制器工厂替换成AutoFac的工厂
*/
//第一步： 构造一个AutoFac的builder容器
ContainerBuilder builder = new Autofac.ContainerBuilder();
//第二步：告诉AutoFac控制器工厂，控制器类的创建去哪些程序集中查找（默认控制器工厂是去扫描bin目录下的所有程序集）
//2.1 从当前运行的bin目录下加载FB.CMS.MvcSite.dll程序集
Assembly controllerAss = Assembly.Load("SR.Controllers");
//2.2 告诉AutoFac控制器工厂，控制器的创建从controllerAss中查找（注意：RegisterControllers()方法是一个可变参数，如果你的控制器类的创建需要去多个程序集中查找的话，那么我们就再用Assembly controllerBss=Assembly.Load("需要的程序集名")加载需要的程序集，然后与controllerAss组成数组，然后将这个数组传递到RegisterControllers()方法中）
builder.RegisterControllers(controllerAss);
//第三步：告诉AutoFac容器，创建项目中的指定类的对象实例，以接口的形式存储（其实就是创建数据仓储层与业务逻辑层这两个程序集中所有类的对象实例，然后以其接口的形式保存到AutoFac容器内存中，当然如果有需要也可以创建其他程序集的所有类的对象实例，这个只需要我们指定就可以了）
//3.1 加载数据仓储层FB.CMS.Repository这个程序集。
Assembly repositoryAss = Assembly.Load("SR.Interfaces");
//3.2 反射扫描这个FB.CMS.Repository.dll程序集中所有的类，得到这个程序集中所有类的集合。
Type[] rtypes = repositoryAss.GetTypes();
//3.3 告诉AutoFac容器，创建rtypes这个集合中所有类的对象实例
builder.RegisterTypes(rtypes)
.AsImplementedInterfaces(); //指明创建的rtypes这个集合中所有类的对象实例，以其接口的形式保存
//3.4 加载业务逻辑层FB.CMS.Services这个程序集。
Assembly servicesAss = Assembly.Load("SR.Service");
//3.5 反射扫描这个FB.CMS.Services.dll程序集中所有的类，得到这个程序集中所有类的集合。
Type[] stypes = servicesAss.GetTypes();
//3.6 告诉AutoFac容器，创建stypes这个集合中所有类的对象实例
builder.RegisterTypes(stypes)
.AsImplementedInterfaces(); //指明创建的stypes这个集合中所有类的对象实例，以其接口的形式保存
//Type type = typeof(IHelpYou);
//builder.RegisterType(type).AsImplementedInterfaces();
//第四步：创建一个真正的AutoFac的工作容器
var container1 = builder.Build();
//我们已经创建了指定程序集的所有类的对象实例，并以其接口的形式保存在AutoFac容器内存中了。那么我们怎么去拿它呢？
//从AutoFac容器内部根据指定的接口获取其实现类的对象实例
//假设我要拿到IsysFunctionServices这个接口的实现类的对象实例，怎么拿呢？
//var obj = container.Resolve<IsysFunctionServices>(); //只有有特殊需求的时候可以通过这样的形式来拿。一般情况下没有必要这样来拿，因为AutoFac会自动工作（即：会自动去类的带参数的构造函数中找与容器中key一致的参数类型，并将对象注入到类中，其实就是将对象赋值给构造函数的参数）
//第五步：将当前容器中的控制器工厂替换掉MVC默认的控制器工厂。（即：不要MVC默认的控制器工厂了，用AutoFac容器中的控制器工厂替代）此处使用的是将AutoFac工作容器交给MVC底层 (需要using System.Web.Mvc;)
DependencyResolver.SetResolver(new AutofacDependencyResolver(container1));
//我们知道控制器的创建是调用MVC默认的控制器工厂，默认的控制器工厂是调用控制器类的无参构造函数
//可是我们如果要使用AutoFac自动工厂，将对象通过构造函数注入类中，那么这个构造函数就需要带参数
//如果我们将控制器的无参构造函数删除，保留带参数的构造函数，MVC默认的控制器工厂来创建控制的时候
//就会去调用无参的构造函数，可是这时候发现没有无参的构造函数于是就报“没有为该对象定义无参数的构造函数”错误
//既然报错,那我们如果保留无参的构造函数，同时在声明一个带参数的构造函数是否可行呢？
//答案;行是行，但是创建控制器的时候，MVC默认的控制器工厂调用的是无参构造函数，它并不会去调用有参的构造函数
//这时候，我们就只能将AutoFac它的控制器工厂替换调用MVC默认的控制器工厂（控制器由AutoFac的控制器工厂来创建）
//而AutoFac控制器工厂在创建控制的时候只会扫描带参数的构造函数，并将对象注入到带参数的构造函数中
//AutofacDependencyResolver这个控制器工厂是继承了 IDependencyResolver接口的，而IDependencyResolver接口是MVC的东西
//MVC默认的控制器工厂名字叫：DefaultControllerFactory
//具体参考：http://www.cnblogs.com/artech/archive/2012/04/01/controller-activation-032.html
}
private void RegisterInProcServiceConfigurations()
{
containerBuilder.RegisterTypes(GetTypesWithAttribute <InProcServiceConfigurationAttribute>(true).ToArray())
.SingleInstance();
}
/// <summary>
/// Register job types for JobFactory
/// </summary>
private static void RegisterJobs(ContainerBuilder builder)
{
var jobs = TypeDiscovery.Discover<Job>().ToArray();
builder.RegisterTypes(jobs);
}
private static void RegisterReplCommands(ContainerBuilder builder)
{
var replCommands = AppDomain.CurrentDomain.GetAssemblies()
.Where(x => !x.IsDynamic)
.SelectMany(x => x.GetExportedTypes())
.Where(x => typeof(IReplCommand).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract)
.ToArray();
builder.RegisterTypes(replCommands).As<IReplCommand>();
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<SchoolContext>();
builder.RegisterTypes(ThisAssembly.GetTypes().Where(t => t.FullName.EndsWith("Repository")).ToArray())
.AsImplementedInterfaces();
}
private static void RegisterRequestHandlers(ContainerBuilder builder)
{
builder.RegisterTypes(RequestHandlers)
.As(type => new KeyedService("handler1", GetRequestHandlerType(type)))
.InstancePerMatchingLifetimeScope(MatchingScopeLifetimeTags.RequestLifetimeScopeTag);
}
private void RegisterLineProcessors(ContainerBuilder builder)
{
object processors;
this.Overrides.TryGetValue(typeof(ILineProcessor), out processors);
var processorList = (processors as IEnumerable<Type> ?? Enumerable.Empty<Type>()).ToArray();
var loadProcessorType = processorList
.FirstOrDefault(x => typeof(ILoadLineProcessor).IsAssignableFrom(x))
?? typeof(LoadLineProcessor);
var usingProcessorType = processorList
.FirstOrDefault(x => typeof(IUsingLineProcessor).IsAssignableFrom(x))
?? typeof(UsingLineProcessor);
var referenceProcessorType = processorList
.FirstOrDefault(x => typeof(IReferenceLineProcessor).IsAssignableFrom(x))
?? typeof(ReferenceLineProcessor);
var processorArray = new[] { loadProcessorType, usingProcessorType, referenceProcessorType }.Union(processorList).ToArray();
builder.RegisterTypes(processorArray).As<ILineProcessor>();
}
private static void RegisterValidators(ContainerBuilder builder)
{
builder.RegisterTypes(RequestValidators)
.AsClosedTypesOf(typeof(IValidator<>))
.AsImplementedInterfaces()
.InstancePerMatchingLifetimeScope(MatchingScopeLifetimeTags.RequestLifetimeScopeTag);
}
protected override void Load(ContainerBuilder builder)
{
string plocation = Path.Combine(_appEnv.ApplicationBasePath, "PluginsDir");
foreach (DirectoryInfo dInfo in new DirectoryInfo(plocation).GetDirectories("src", SearchOption.AllDirectories))
{
try
{
Assembly assembly = _extensionAssemblyLoader.WithPath(dInfo.FullName).Load(new AssemblyName(dInfo.Parent.Name));
var singleResolvables = assembly.ExportedTypes.Where(p => typeof(ISingleResolvable).IsAssignableFrom(p) && p.GetTypeInfo().IsClass)
.ToArray();
var pluginTypes = assembly.ExportedTypes.Where(p => typeof(IPlugin).IsAssignableFrom(p));
builder.RegisterTypes(singleResolvables).AsSelf().SingleInstance();
//builder.RegisterTypes(perResolvables).AsSelf().InstancePerDependency();
//singleResolvables.ForEach(p => builder.RegisterType(p).AsSelf().SingleInstance());
//perResolvables.ForEach(p => builder.RegisterType(p).AsSelf().InstancePerDependency());
foreach (Type type in pluginTypes)
{
builder.RegisterType(type).AsSelf().SingleInstance().OnActivated(
e =>
{
try
{
IPlugin plugin = (IPlugin)e.Context.Resolve(type);
plugin.OnLoad();
_logger.LogInformation("Plugin {0} has been loaded.", plugin.Name);
}
catch (Exception ex)
{
_logger.LogError("Error trying to load plugin {0}", dInfo.Parent.Name);
StackTrace st = new StackTrace(ex, true);
StackFrame[] frames = st.GetFrames();
if (frames != null)
{
foreach (StackFrame f in frames)
{
_logger.LogError(f.ToString());
}
}
_logger.LogError(ex.ToString());
}
});
}
}
catch (Exception ex)
{
_logger.LogError("Error trying to load plugin {0}", dInfo.Parent.Name);
StackTrace st = new StackTrace(ex, true);
StackFrame[] frames = st.GetFrames();
if (frames != null)
{
foreach (StackFrame f in frames)
{
_logger.LogError(f.ToString());
}
}
_logger.LogError(ex.ToString());
}
}
}
protected override void Load(ContainerBuilder builder)
{
builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).PropertiesAutowired();
builder.RegisterTypes().PropertiesAutowired();
builder.RegisterModule(new AutofacServiceModule());
}
private void RegisterLineProcessors(ContainerBuilder builder)
{
var loadProcessorType = _lineProcessors
.FirstOrDefault(x => typeof(ILoadLineProcessor).IsAssignableFrom(x))
?? typeof(LoadLineProcessor);
var usingProcessorType = _lineProcessors
.FirstOrDefault(x => typeof(IUsingLineProcessor).IsAssignableFrom(x))
?? typeof(UsingLineProcessor);
var referenceProcessorType = _lineProcessors
.FirstOrDefault(x => typeof(IReferenceLineProcessor).IsAssignableFrom(x))
?? typeof(ReferenceLineProcessor);
var lineProcessors = new[] { loadProcessorType, usingProcessorType, referenceProcessorType }.Union(_lineProcessors);
builder.RegisterTypes(lineProcessors.ToArray()).As<ILineProcessor>();
}
/// <summary>
/// 注册所有实现了IService的服务
/// </summary>
/// <param name="types">当前程序集中的类型集合</param>
/// <param name="builder">autofac构造器</param>
private static void InitService(Type[] types, ContainerBuilder builder)
{
builder.RegisterTypes(types.Where(t => typeof(IService).IsAssignableFrom(t)).ToArray()).AsImplementedInterfaces().InstancePerLifetimeScope();
}
