/// <summary> /// Registers the conventions. /// </summary> /// <param name="builder">The registration builder.</param> public void RegisterConventions(ConventionBuilder builder) { builder .ForTypesDerivedFrom<IGameManager>() .Export(b => b.AsContractType<IGameManager>()) .Shared(ScopeNames.User); builder .ForTypesDerivedFrom<IUser>() .Export(b => b.AsContractType<IUser>()) .Shared(ScopeNames.User); }
private static AttributedModelProvider DefineConventions() { var rb = new ConventionBuilder(); rb.ForTypesDerivedFrom<IController>().Export(); rb.ForTypesDerivedFrom<IHttpController>().Export(); rb.ForTypesMatching(IsAPart) .Export() .ExportInterfaces(); return rb; }
public void MapType_OverridingSelectionOfConventionSelectedConstructor() { var builder = new ConventionBuilder(); builder. ForTypesDerivedFrom<IFoo>(). Export<IFoo>(); builder.ForType<FooImplWithConstructors>() .SelectConstructor(cis => cis.ElementAtOrDefault(1)); var fooImplWithConstructors = typeof(FooImplWithConstructors).GetTypeInfo(); var constructor1 = fooImplWithConstructors.DeclaredConstructors.Where(c => c.GetParameters().Length == 0).Single(); var constructor2 = fooImplWithConstructors.DeclaredConstructors.Where(c => c.GetParameters().Length == 1).Single(); var constructor3 = fooImplWithConstructors.DeclaredConstructors.Where(c => c.GetParameters().Length == 2).Single(); // necessary as BuildConventionConstructorAttributes is only called for type level query for attributes Assert.Equal(0, builder.GetCustomAttributes(typeof(FooImplWithConstructors), constructor1).Count()); Assert.Equal(0, builder.GetCustomAttributes(typeof(FooImplWithConstructors), constructor3).Count()); var ci = constructor2; var attrs = builder.GetCustomAttributes(typeof(FooImplWithConstructors), ci); Assert.Equal(1, attrs.Count()); Assert.Equal(typeof(ImportingConstructorAttribute), attrs.FirstOrDefault().GetType()); }
public static void ConfigureContainer() { var containerConventions = new ConventionBuilder(); containerConventions.ForType<DbProductRepository>() .ExportInterfaces() .SelectConstructorWithMostParameters() .InstancePerHttpRequest(); containerConventions.ForType<DbLogger>() .ExportInterfaces() .SelectConstructorWithMostParameters() .InstancePerHttpRequest(); containerConventions.ForType<ProductDbContext>() .Export() .InstancePerHttpRequest(); containerConventions.ForTypesDerivedFrom<Controller>() .Export<IController>() .Export() .SelectConstructorWithMostParameters(); var containerConfig = new ContainerConfiguration(); containerConfig.WithAssembly(Assembly.GetExecutingAssembly(), containerConventions); containerConfig.CreateContainer().UseWithMvc(); }
private ConventionBuilder GetExportBuilder() { // Define exports as matching a parent type, export as that parent type var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom(contractType).Export(exportConventionBuilder => exportConventionBuilder.AsContractType(contractType)); return(builder); }
static partial void AddUISpecificConventions( ConventionBuilder builder ) { var viewModel = new ViewModelSpecification(); builder.ForTypesDerivedFrom<IShellView>().Export().Export<IShellView>().Shared(); builder.ForTypesMatching( viewModel.IsSatisfiedBy ).Export(); builder.ForType<EventBroker>().Export<IEventBroker>().Shared(); }
public static ConventionBuilder NewParentConventions(bool isShared) { ConventionBuilder conventions = new ConventionBuilder(); if (isShared) { conventions.ForTypesDerivedFrom(typeof(IParent)) .Export() .Shared(); } else { conventions.ForTypesDerivedFrom(typeof(IParent)) .Export(); } return(conventions); }
public static async Task InitializeGeneratorsAsync(bool writeOutputMessages = false) { Current.Clear(); Debug.WriteLine($@"Scanning local directory for OutputExecutor libraries"); var assemblies = new List <Assembly>(); foreach (var file in Directory.EnumerateFiles(Environment.CurrentDirectory, "*" + GenesisDefaults.LibraryExtension, SearchOption.TopDirectoryOnly)) { assemblies.Add(Assembly.LoadFile(file)); //doesn't seem to mind loading everything... for now } var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IGeneralExecutor>() .Export <IGeneralExecutor>() .Shared(); var configuration = new ContainerConfiguration().WithAssemblies(assemblies, conventions); using var container = configuration.CreateContainer(); var generators = container.GetExports <IGeneralExecutor>(); Current.Clear(); foreach (var generator in generators) { Current.Add(generator); try { await generator.Initialize(); if (!writeOutputMessages) { continue; } Text.White($"'"); Text.Green(generator.CommandText); Text.White("' ("); Text.Cyan(generator.FriendlyName); Text.White(") was found in '"); Text.Blue(generator.GetType().Name); Text.White("'... "); Text.GreenLine("OK"); Console.ResetColor(); } catch (Exception exc) { if (!writeOutputMessages) { continue; } Text.CliCommand(generator.CommandText); Text.White(": "); Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(exc.Message); Console.ResetColor(); } } }
public void AsContractName_AndContractType_SetsContractNameAndType() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom<IFoo>().Export((e) => e.AsContractName("hey").AsContractType(typeof(IFoo))); ExportAttribute exportAtt = GetExportAttribute(builder); Assert.Equal("hey", exportAtt.ContractName); Assert.Equal(typeof(IFoo), exportAtt.ContractType); }
public void AsContractTypeOfT_SetsContractType() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom<IFoo>().Export((e) => e.AsContractType<IFoo>()); ExportAttribute exportAtt = GetExportAttribute(builder); Assert.Equal(typeof(IFoo), exportAtt.ContractType); Assert.Null(exportAtt.ContractName); }
private static ConventionBuilder GetConventions() { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IBinarySkimmer>() .Export <IBinarySkimmer>(); return(conventions); }
private static ConventionBuilder GetConventions <T>() { var conventions = new ConventionBuilder(); // New per-analyzer options mechanism conventions.ForTypesDerivedFrom <T>() .Export <T>(); return(conventions); }
internal async Task <bool> LoadCommandsAsync <T>() where T : IShellCommand { if (!Directory.Exists(Constants.COMMANDS_PATH)) { Directory.CreateDirectory(Constants.COMMANDS_PATH); } AssemblyCollection?.Clear(); AssemblyCollection = LoadAssemblies(); if (AssemblyCollection == null || AssemblyCollection.Count <= 0) { Logger.Trace("No command assemblies found."); return(false); } await LoadSync.WaitAsync().ConfigureAwait(false); try { ConventionBuilder conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <T>().Export <T>(); ContainerConfiguration configuration = new ContainerConfiguration().WithAssemblies(AssemblyCollection, conventions); using CompositionHost container = configuration.CreateContainer(); List <T> list = container.GetExports <T>().ToList(); if (list.Count <= 0) { return(false); } foreach (T command in list) { if (await IsExistingCommand <T>(command.UniqueId).ConfigureAwait(false)) { Logger.Warning($"'{command.CommandName}' shell command already exists. skipping..."); continue; } await command.InitAsync().ConfigureAwait(false); Interpreter.Commands.Add(command.CommandKey, command); Logger.Info($"Loaded external shell command -> {command.CommandName}"); } return(true); } catch (Exception e) { Logger.Exception(e); return(false); } finally { LoadSync.Release(); } }
private static AttributedModelProvider RegisterExports() { var builder = new ConventionBuilder(); //builder.ForType<learner>().Export<learner>(); //builder.ForTypesMatching // (x => x.GetProperty("SourceMaterial") != null).Export<exam>(); builder.ForTypesDerivedFrom<IJob>().Export<IJob>(); return builder; }
public void AsContractName_AndContractType_ComputeContractNameFromType() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom <IFoo>().Export(e => e.AsContractName(t => "Contract:" + t.FullName).AsContractType <IFoo>()); ExportAttribute exportAtt = GetExportAttribute(builder); Assert.Equal("Contract:" + typeof(FooImpl).FullName, exportAtt.ContractName); Assert.Equal(typeof(IFoo), exportAtt.ContractType); }
public void AsContractName_AndContractType_SetsContractNameAndType() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom <IFoo>().Export((e) => e.AsContractName("hey").AsContractType(typeof(IFoo))); ExportAttribute exportAtt = GetExportAttribute(builder); Assert.Equal("hey", exportAtt.ContractName); Assert.Equal(typeof(IFoo), exportAtt.ContractType); }
internal static ServiceConfigurations Find(Configuration config, ILogger logger) { logger.Information("Loading configuration", PluginDir); var configurations = new ServiceConfigurations(logger); AddInternalConfigurations(); AddExternalPlugins(); return(configurations); void AddInternalConfigurations() { logger.Information("Loading internal service configuration", PluginDir); var loader = Factory.CreateLoader(config, logger).Result; var addData = new SetData(loader, logger); configurations.Add(new Singletons()); configurations.Add(addData); if (config.EnablePrometheusMonitoring) { configurations.Add(new ServiceConfiguration.Prometheus()); } configurations.Add(new HealthCheck(addData, config.EnablePrometheusMonitoring)); configurations.Add(new Swagger()); configurations.Add(new ExceptionHandler()); } void AddExternalPlugins() { if (!config.EnableCustomPlugins) { return; } try { logger.Information("Loading external plugins from {path}", PluginDir); var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IPlugin>().Export <IPlugin>().Shared(); var containerConfig = new ContainerConfiguration().WithAssembliesInPath(PluginDir, conventions); using var container = containerConfig.CreateContainer(); var externalPlugins = container.GetExports <IPlugin>(); configurations.AddRange(externalPlugins); } catch (Exception e) { logger.Warning(e, "Error loading plugins from {path}", PluginDir); } } }
private void Configure(string path) { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IContextResolver>() .Export <IContextResolver>() .Shared(); Configuration = new ContainerConfiguration() .WithAssembliesInPath(path, conventions); }
public void AsContractTypeOfT_SetsContractType() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom <IFoo>().Export((e) => e.AsContractType <IFoo>()); ExportAttribute exportAtt = GetExportAttribute(builder); Assert.Equal(typeof(IFoo), exportAtt.ContractType); Assert.Null(exportAtt.ContractName); }
internal MefContainer(IEnumerable <Assembly> assemblies) { var conventionBuilder = new ConventionBuilder(); conventionBuilder.ForTypesDerivedFrom <TAbstractContract>().Export <TContract>(); this._container = new ContainerConfiguration() .WithAssemblies(assemblies, conventionBuilder) .CreateContainer(); this._exported = this._container.GetExports <ExportFactory <TContract, TTranscription> >(); }
public void AddMetadataFuncVal_AddsExportMetadataAttribute() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom <IFoo>().Export(e => e.AddMetadata("name", t => t.Name)); ExportMetadataAttribute exportAtt = GetExportMetadataAttribute(builder); Assert.Equal("name", exportAtt.Name); Assert.Equal(typeof(FooImpl).Name, exportAtt.Value); }
public void AddMetadata_AddsExportMetadataAttribute() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom <IFoo>().Export(e => e.AddMetadata("name", "val")); ExportMetadataAttribute exportAtt = GetExportMetadataAttribute(builder); Assert.Equal("name", exportAtt.Name); Assert.Equal("val", exportAtt.Value); }
public async Task <bool> LoadAsync() { AssemblyCollection?.Clear(); AssemblyCollection = LoadAssemblies(); if (AssemblyCollection == null || AssemblyCollection.Count <= 0) { Logger.Trace("No assemblies found."); return(false); } await ModuleLoaderSemaphore.WaitAsync().ConfigureAwait(false); try { ConventionBuilder conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IModuleBase>().Export <IModuleBase>(); ContainerConfiguration configuration = new ContainerConfiguration().WithAssemblies(AssemblyCollection, conventions); using CompositionHost container = configuration.CreateContainer(); List <IModuleBase> list = container.GetExports <IModuleBase>().ToList(); if (list.Count > 0) { foreach (IModuleBase bot in list) { Logger.Trace($"Loading module of type {ParseModuleType(bot.ModuleType)} ..."); bot.ModuleIdentifier = GenerateModuleIdentifier(); ModuleInfo <IModuleBase> data = new ModuleInfo <IModuleBase>(bot.ModuleIdentifier, ParseModuleType(bot.ModuleType), true) { Module = bot }; Logger.Trace($"Successfully loaded module with id {bot.ModuleIdentifier} of type {data.ModuleType.ToString()}"); if (Modules.Count > 0 && !Modules.Contains(bot)) { Modules.Add(bot); } ModulesCache.Add(data); } } } catch (Exception e) { Logger.Exception(e); return(false); } finally { ModuleLoaderSemaphore.Release(); } return(true); }
static void DefineFormatConventions(ConventionBuilder conventions) { conventions .ForTypesDerivedFrom <IFormat>() .Export <IFormat>( export => export .AddMetadata("Name", t => t.FullName) .AddMetadata("Type", t => t)) .SelectConstructor(ctors => ctors.OrderBy(ctor => ctor.GetParameters().Length) .First()); }
private static AttributedModelProvider RegisterExports() { var builder = new ConventionBuilder(); //builder.ForType<learner>().Export<learner>(); //builder.ForTypesMatching // (x => x.GetProperty("SourceMaterial") != null).Export<exam>(); builder.ForTypesDerivedFrom <IJob>().Export <IJob>(); return(builder); }
/// <summary> /// Static helper method Exports the <paramref name="exportType"/> on the given /// <paramref name="conventions"/>; applying /// <see cref="ConventionBuilder.ForTypesDerivedFrom"/>, /// <see cref="ConventionBuilder.ForType"/>, or both according to /// <paramref name="onlyDerivedTypesExclusively"/>. /// </summary> /// <param name="conventions">Not null.</param> /// <param name="exportType">Not null.</param> /// <param name="onlyDerivedTypesExclusively">Allows you to specify only /// <see cref="ConventionBuilder.ForTypesDerivedFrom"/> (if true), only /// <see cref="ConventionBuilder.ForType"/> (if false), or both (if null). /// If the type is abstract then ForType is not applied.</param> /// <returns>Returns the given <paramref name="conventions"/> /// for chaining.</returns> internal static ConventionBuilder ApplyConventions( this ConventionBuilder conventions, Type exportType, bool?onlyDerivedTypesExclusively) { if (conventions == null) { throw new ArgumentNullException(nameof(conventions)); } if (exportType == null) { throw new ArgumentNullException(nameof(exportType)); } switch (onlyDerivedTypesExclusively) { case true: case false when exportType.IsAbstract: case false when exportType.IsInterface: conventions.ForTypesDerivedFrom(exportType) .Export(); break; case false: conventions.ForType(exportType) .Export(); break; default: if (!exportType.IsInterface && !exportType.IsAbstract) { conventions.ForType(exportType) .Export(); } conventions.ForTypesDerivedFrom(exportType) .Export(); break; } return(conventions); }
private static ConventionBuilder GetConventions() { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IFormattingFilter>() .Export <IFormattingFilter>(); conventions.ForTypesDerivedFrom <ISyntaxFormattingRule>() .Export <ISyntaxFormattingRule>(); conventions.ForTypesDerivedFrom <ILocalSemanticFormattingRule>() .Export <ILocalSemanticFormattingRule>(); conventions.ForTypesDerivedFrom <IGlobalSemanticFormattingRule>() .Export <IGlobalSemanticFormattingRule>(); // New per-analyzer options mechanism, deriving // from VS Workspaces functionality conventions.ForTypesDerivedFrom <IOptionsProvider>() .Export <IOptionsProvider>(); // Legacy CodeFormatter rules options mechanism conventions.ForType <FormattingOptions>() .Export(); conventions.ForTypesDerivedFrom <IFormattingEngine>() .Export <IFormattingEngine>(); return(conventions); }
public static void Init() { try { lock (_sync) { if (IsInitialized) { Dispose(); } _logger.LogInformation("MEFLoader.Init start"); var startTime = DateTime.UtcNow; var rules = new ConventionBuilder(); var assemblyList = new List <Assembly>(); if (!MEFSkip.Skip) { assemblies.ToList().ForEach(a => { var assembly = Assembly.LoadFile(a); assemblyList.Add(assembly); var sharedExports = assembly.GetTypes() .Where(type => type.GetCustomAttribute <SharedPolicyCreationAttribute>(true) is SharedPolicyCreationAttribute policy && policy.Shared).ToList(); foreach (var item in sharedExports) { rules.ForTypesDerivedFrom(item).Shared(); } var debug = assembly.GetTypes().Where(t => t.GetCustomAttribute <ExportAttribute>(true) is ExportAttribute export); foreach (var t in debug) { _logger.LogInformation(t.FullName); } _logger.LogInformation($"Added types from {a} to the assembly list."); }); } _compositionHost = new ContainerConfiguration().WithAssemblies(assemblyList, rules).CreateContainer(); _logger.LogInformation($"MEF Init Time (in ms): {DateTime.UtcNow - startTime}"); } } catch (ReflectionTypeLoadException ex) { ex.LoaderExceptions.ToList().ForEach(e => { _logger.LogError($"---: {e.Message}"); e.InnerException.ActIfNotNull(() => _logger.LogError(e.InnerException.ToJsonString())); }); } }
private static ConventionBuilder GetConventions() { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom<IFormattingFilter>() .Export<IFormattingFilter>(); conventions.ForTypesDerivedFrom<ISyntaxFormattingRule>() .Export<ISyntaxFormattingRule>(); conventions.ForTypesDerivedFrom<ILocalSemanticFormattingRule>() .Export<ILocalSemanticFormattingRule>(); conventions.ForTypesDerivedFrom<IGlobalSemanticFormattingRule>() .Export<IGlobalSemanticFormattingRule>(); conventions.ForType<Options>() .Export(); conventions.ForTypesDerivedFrom<IFormattingEngine>() .Export<IFormattingEngine>(); return conventions; }
public void ConventionBuilderExportsOpenGenerics() { var rb = new ConventionBuilder(); rb.ForTypesDerivedFrom(typeof(IRepository <>)) .Export(eb => eb.AsContractType(typeof(IRepository <>))); var c = new ContainerConfiguration() .WithPart(typeof(EFRepository <>), rb) .CreateContainer(); var r = c.GetExport <IRepository <string> >(); }
private static AttributedModelProvider DefineConventions() { var rb = new ConventionBuilder(); rb.ForTypesDerivedFrom <IController>().Export(); //rb.ForTypesDerivedFrom<IHttpController>().Export(); //rb.ForTypesMatching(IsAPart) // .Export() // .ExportInterfaces(); return(rb); }
protected IList <CryptoFactoryBase> GetFactoriesFromAssemblies() { var dir = Directory.GetCurrentDirectory() + @"\Extensions"; if (!Directory.Exists(dir)) { throw new InvalidOperationException($"Директории с крипто библиотеками не существует.") { Source = GetType().AssemblyQualifiedName } } ; var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <CryptoFactoryBase>().Export <CryptoFactoryBase>().Shared(); var ass = DependencyContext.Default.GetDefaultAssemblyNames(); string[] dllsLintInExtensions = Directory.GetFiles(dir, "*dll", SearchOption.TopDirectoryOnly).ToArray(); var dllsFileInfo = dllsLintInExtensions.Select(s => new FileInfo(s)).ToArray(); var assemblies = dllsFileInfo.Select(s => { var first = ass.FirstOrDefault(name => s.Name.Contains(name.Name)); if (first == null) { return(AssemblyLoadContext.Default.LoadFromAssemblyPath(s.FullName)); } else { return(AssemblyBuilder.Load(first)); } //var assName = new AssemblyName(s.FullName); //if (first == null) // return AssemblyLoadContext.Default.LoadFromAssemblyPath(s.FullName); //else // return Assembly.Load(first); }).ToArray(); var configuration = new ContainerConfiguration().WithAssemblies(assemblies, conventions); using (var container = configuration.CreateContainer()) { var factories = container.GetExports <CryptoFactoryBase>(); CryptoFactories = factories.ToArray(); return(CryptoFactories); } }
internal async Task <bool> LoadAsync(bool isEnabled) { if (!isEnabled) { return(false); } var assemblyCollection = LoadAssemblies(); if (assemblyCollection == null || assemblyCollection.Count <= 0) { Logger.Trace("No assemblies found."); return(false); } assemblyCollection.Add(Assembly.GetExecutingAssembly()); await ModuleLoaderSemaphore.WaitAsync().ConfigureAwait(false); try { ConventionBuilder conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IModule>().Export <IModule>(); ContainerConfiguration configuration = new ContainerConfiguration().WithAssemblies(assemblyCollection, conventions); using CompositionHost container = configuration.CreateContainer(); foreach (IModule module in container.GetExports <IModule>()) { Logger.Trace($"Loading module {module.ModuleIdentifier} ..."); module.ModuleIdentifier = GenerateModuleIdentifier(module); ModuleWrapper <IModule> data = new ModuleWrapper <IModule>(module.ModuleIdentifier, module, true); Logger.Trace($"Loaded module with id {module.ModuleIdentifier} !"); if (!IsExisitingModule(module)) { Modules.Add(module); } ModulesCache.Add(data); } } catch (Exception e) { Logger.Exception(e); return(false); } finally { ModuleLoaderSemaphore.Release(); } return(true); }
public static CompositionHost CreateContainer() { EnsurePluginsFolder(); var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <IExtension>().Export <IExtension>(); var assemblies = AppDomain.CurrentDomain.GetAssemblies(); var configuration = new ContainerConfiguration().WithAssemblies(assemblies, conventions); return(configuration.CreateContainer()); }
private static void RegisterMefDependencyResolver() { /**---------------------------------------- * -- 说明:程序根据规则自动的导出部件 * ----------------------------------------- * 1. 所有的继承IHttpController的类 * 2. 命名空间中包含.Support的所有类 * ---------------------------------------- */ var conventions = new ConventionBuilder(); // Export 所有IHttpController到容器 conventions.ForTypesDerivedFrom <IHttpController>() .Export(); // Export namespace {*.Support.*} conventions.ForTypesMatching(t => t.Namespace != null && (t.Namespace.EndsWith(".Support") || t.Namespace.Contains(".Support.") || t.Namespace.EndsWith("Impl") || t.Namespace.Contains(".Impl."))) .Export() .ExportInterfaces(); var lstAssemlby = new List <Assembly>(); var dir = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory); foreach (var item in dir.GetFiles("Intime.OPC.*.dll")) { lstAssemlby.Add(Assembly.LoadFrom(item.FullName)); } //lstAssemlby.Add(Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "\\Intime.OPC.Repository.dll")); //lstAssemlby.Add(Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "\\Intime.OPC.Service.dll")); lstAssemlby.Add(Assembly.GetExecutingAssembly()); container = new ContainerConfiguration() .WithDefaultConventions(conventions) .WithAssemblies(lstAssemlby) .CreateContainer(); //var a = container.GetExport<IRmaService>(); //Console.WriteLine(a); // 设置WebApi的DependencyResolver // GlobalConfiguration.Configuration.DependencyResolver = new MefDependencyResolver(container); }
public void Bootstrap() { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom<ICalculator>().Export<ICalculator>().Shared(); conventions.ForType<Program>().ImportProperty<ICalculator>(p => p.Calculator); var configuration = new ContainerConfiguration() .WithDefaultConventions(conventions) .WithAssemblies(GetAssemblies("c:/addins")); using (CompositionHost host = configuration.CreateContainer()) { host.SatisfyImports(this, conventions); } }
private void Bootstrap() { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <ICalculator>().Export <ICalculator>().Shared(); conventions.ForType <Program>().ImportProperty <ICalculator>(program => program.Calculator); var configuration = new ContainerConfiguration() .WithDefaultConventions(conventions) .WithAssemblies(GetAssemblies("c:/addins")); using (var host = configuration.CreateContainer()) { host.SatisfyImports(this, conventions); } }
private static void Main(string[] args) { Console.WriteLine("开始......"); string ProjectPath = ConfigurationManager.AppSettings.Get("ProjectPath"); Project Pj; List <Conmgr> Conmgrs; List <Package> Packages; Dictionary <int, EzOleDbConnectionManager> CMS; using (AutossisEntities db = new AutossisEntities()) { Pj = db.Project.Where(p => p.ProjectName == projectName).First(); Conmgrs = db.Conmgr.Where(p => p.ProjectId == Pj.ProjectId).ToList(); Packages = db.Package.Where(p => p.ProjectId == Pj.ProjectId).ToList(); CMS = getOledbConnectionManagers(Conmgrs); } ConventionBuilder conventions = new ConventionBuilder(); conventions .ForTypesDerivedFrom <ICreatePackage>() .Export <ICreatePackage>() .Shared(); Assembly[] assemblies = new[] { typeof(Program).GetTypeInfo().Assembly }; ContainerConfiguration configuration = new ContainerConfiguration() .WithAssemblies(assemblies, conventions); ICreatePackage Cp; using (CompositionHost container = configuration.CreateContainer()) { Cp = container.GetExport <ICreatePackage>(ConfigurationManager.AppSettings.Get("ProjectType")); Cp.ezOleDbConnectionManagers = CMS; } foreach (Package package in Packages) { ez.AddPackage(Cp.Create(package)); Console.WriteLine(package.PackageName + " 生成成功。"); } JobControl(Pj, null); ez.SaveTo(ProjectPath + Pj.ProjectName + ".ispac"); Console.WriteLine("全部成功!"); Console.ReadKey(); }
/// <summary> /// Composes C# script class imports. /// </summary> /// <typeparam name="T">The script class type</typeparam> /// <param name="assembly">The compiled assembly.</param> /// <returns>The imported script objects collection.</returns> public static IEnumerable <T> Compose <T>(Assembly assembly) { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom <T>() .Export <T>() .SelectConstructor(selector => selector.FirstOrDefault()); var configuration = new ContainerConfiguration() .WithAssembly(assembly) .WithDefaultConventions(builder); using (var container = configuration.CreateContainer()) { return(container.GetExports <T>()); } }
public void Bootstrap() { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <ICalculator>().Export <ICalculator>().Shared(); conventions.ForType <Program>().ImportProperty <ICalculator>(p => p.Calculator); var cur = Directory.GetCurrentDirectory(); var configuration = new ContainerConfiguration() .WithDefaultConventions(conventions) .WithAssemblies(GetAssemblies(cur)); using (CompositionHost host = configuration.CreateContainer()) { host.SatisfyImports(this, conventions); } }
public void MapType_ShouldReturnProjectedAttributesForType() { var builder = new ConventionBuilder(); builder. ForTypesDerivedFrom<IFoo>(). Export<IFoo>(); var fooImplAttributes = builder.GetDeclaredAttributes(typeof(FooImpl), typeof(FooImpl).GetTypeInfo()); var fooImplWithConstructorsAttributes = builder.GetDeclaredAttributes(typeof(FooImplWithConstructors), typeof(FooImplWithConstructors).GetTypeInfo()); var exports = new List<object>(); exports.AddRange(fooImplAttributes); exports.AddRange(fooImplWithConstructorsAttributes); Assert.Equal(2, exports.Count); foreach (var exportAttribute in exports) { Assert.Equal(typeof(IFoo), ((ExportAttribute)exportAttribute).ContractType); Assert.Null(((ExportAttribute)exportAttribute).ContractName); } }
private static void ConfigureMef() { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom<ViewModelBase>() .Export(); conventions.ForTypesMatching(x => x.Name.EndsWith("Service")) .ExportInterfaces(); ViewLocator.BuildMefConventions(conventions); var configuration = new ContainerConfiguration() .WithAssembly(typeof(App).GetTypeInfo().Assembly, conventions) .WithAssembly(typeof(LinquaLib).GetTypeInfo().Assembly, conventions) .WithAssembly(typeof(FrameworkUwp).GetTypeInfo().Assembly) .WithProvider(new DefaultExportDescriptorProvider()); var container = configuration.CreateContainer(); CompositionManager.Initialize(container); App.CompositionManager = CompositionManager.Current; }
public static IDependencyResolver CreateWithDefaultConventions(Assembly[] appAssemblies) { var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom<IHttpController>() .Export(); conventions.ForTypesMatching(t => t.Namespace != null && t.Namespace.EndsWith(".Parts")) .Export() .ExportInterfaces(); var container = new ContainerConfiguration() .WithAssemblies(appAssemblies, conventions) .CreateContainer(); return new MefDependencyResolver(container); }
public void AddMetadata_AddsExportMetadataAttribute() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom<IFoo>().Export(e => e.AddMetadata("name", "val")); ExportMetadataAttribute exportAtt = GetExportMetadataAttribute(builder); Assert.Equal("name", exportAtt.Name); Assert.Equal("val", exportAtt.Value); }
public void AddMetadataFuncVal_AddsExportMetadataAttribute() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom<IFoo>().Export(e => e.AddMetadata("name", t => t.Name)); ExportMetadataAttribute exportAtt = GetExportMetadataAttribute(builder); Assert.Equal("name", exportAtt.Name); Assert.Equal(typeof(FooImpl).Name, exportAtt.Value); }
public void AsContractName_AndContractType_ComputeContractNameFromType() { var builder = new ConventionBuilder(); builder.ForTypesDerivedFrom<IFoo>().Export(e => e.AsContractName(t => "Contract:" + t.FullName).AsContractType<IFoo>()); ExportAttribute exportAtt = GetExportAttribute(builder); Assert.Equal("Contract:" + typeof(FooImpl).FullName, exportAtt.ContractName); Assert.Equal(typeof(IFoo), exportAtt.ContractType); }