public void Compos() { ContainerConfiguration config = new ContainerConfiguration(); config.WithAssembly(Assembly.GetExecutingAssembly()); // 将DLL的所有的类型导入容器中 CompositionHost container = config.CreateContainer(); var car = container.GetExport <IMotol>("QiChe"); var motol = container.GetExport <IMotol>("MoTuo"); car.Name = motol.Name; //使用数组导入 Accepter accepter = new Accepter(); container.SatisfyImports(accepter); foreach (var motolTarget in accepter.Accept) { var s = motolTarget.Name; } //使用Lazy container.SatisfyImports(accepter); Car c = accepter.Compose.Value; var kvpair = accepter.Compose.Metadata; }
public LocalTests() { CompositionHost.SatisfyImports(this); var result = TemplateInitializer.Initialize().Result; Ensure.IsSuccessResult(result); }
ExtensionContainer() { CompositionHost.SatisfyImports(this); LoggerManager.LoggerFactory.CreateLogger <ExtensionContainer <T> >() .LogDebug("Composed {0} part(s) of type '{1}'.", Factories.Count(), typeof(T).Name); }
public DocumentBuilder( IEnumerable <Assembly> assemblies, ImmutableArray <string> postProcessorNames, string templateHash, string intermediateFolder = null, string commitFromSHA = null, string commitToSHA = null) { Logger.LogVerbose("Loading plug-in..."); using (new LoggerPhaseScope("ImportPlugins", true)) { var assemblyList = assemblies?.ToList(); _container = GetContainer(assemblyList); _container.SatisfyImports(this); _currentBuildInfo.CommitFromSHA = commitFromSHA; _currentBuildInfo.CommitToSHA = commitToSHA; if (intermediateFolder != null) { _currentBuildInfo.PluginHash = ComputePluginHash(assemblyList); _currentBuildInfo.TemplateHash = templateHash; _currentBuildInfo.DirectoryName = IncrementalUtility.CreateRandomDirectory(intermediateFolder); } } Logger.LogInfo($"{Processors.Count()} plug-in(s) loaded."); foreach (var processor in Processors) { Logger.LogVerbose($"\t{processor.Name} with build steps ({string.Join(", ", from bs in processor.BuildSteps orderby bs.BuildOrder select bs.Name)})"); } _postProcessors = GetPostProcessor(postProcessorNames); _intermediateFolder = intermediateFolder; _lastBuildInfo = LoadLastBuildInfo(); }
public DocumentBuilder( IEnumerable <Assembly> assemblies, ImmutableArray <string> postProcessorNames, string templateHash, string intermediateFolder = null, string commitFromSHA = null, string commitToSHA = null, bool cleanupCacheHistory = false) { Logger.LogVerbose("Loading plug-in..."); using (new LoggerPhaseScope("ImportPlugins", LogLevel.Verbose)) { var assemblyList = assemblies?.ToList() ?? new List <Assembly>(); assemblyList.Add(typeof(DocumentBuilder).Assembly); _container = CompositionContainer.GetContainer(assemblyList); _container.SatisfyImports(this); _assemblyList = assemblyList; } Logger.LogInfo($"{Processors.Count()} plug-in(s) loaded."); foreach (var processor in Processors) { Logger.LogVerbose($"\t{processor.Name} with build steps ({string.Join(", ", from bs in processor.BuildSteps orderby bs.BuildOrder select bs.Name)})"); } _commitFromSHA = commitFromSHA; _commitToSHA = commitToSHA; _templateHash = templateHash; _intermediateFolder = intermediateFolder; _cleanupCacheHistory = cleanupCacheHistory; _postProcessorsManager = new PostProcessorsManager(_container, postProcessorNames); }
public void InitializeContainer(params Type[] parts) { var configuration = new ContainerConfiguration().WithParts(parts); using (CompositionHost host = configuration.CreateContainer()) { host.SatisfyImports(_calcImport); } }
public static void SatisfyImports(object part) { if (host == null) { throw new InvalidOperationException(); } host.SatisfyImports(part); }
public static void SatisfyImports(object part) { if (host == null) { throw new InvalidOperationException(Resources.CompositionHostNotInitialized); } host.SatisfyImports(part); }
private void Bootstrapper() { var configuration = new ContainerConfiguration().WithPart <Calculator>(); using (CompositionHost host = configuration.CreateContainer()) { //Calculator = host.GetExport<ICalculator>(); host.SatisfyImports(this); } }
public MainPage() { var containerConfiguration = new ContainerConfiguration().WithAssembly(typeof(App).GetTypeInfo().Assembly); CompositionHost host = containerConfiguration.CreateContainer(); host.SatisfyImports(this); this.InitializeComponent(); this.Loaded += MainPage_Loaded; }
public void Class2SharedTest() { var class2A = _container.GetExports <Class2Shared>().First(); var class2B = _container.GetExports <Class2Shared>().First(); Assert.That(class2A, Is.SameAs(class2B)); var c = new Class1Container(); _container.SatisfyImports(c); }
private static ICciDifferenceWriter GetDifferenceWriter(TextWriter writer, IDifferenceFilter filter) { CompositionHost container = GetCompositionHost(); Func <IDifferenceRuleMetadata, bool> ruleFilter = delegate(IDifferenceRuleMetadata ruleMetadata) { if (ruleMetadata.OptionalRule && !s_enforceOptionalRules) { return(false); } if (ruleMetadata.MdilServicingRule && !s_mdil) { return(false); } return(true); }; if (s_mdil && s_excludeNonBrowsable) { Trace.TraceWarning("Enforcing MDIL servicing rules and exclusion of non-browsable types are both enabled, but they are not compatible so non-browsable types will not be excluded."); } MappingSettings settings = new MappingSettings(); settings.Comparers = GetComparers(); settings.Filter = GetCciFilter(s_mdil, s_excludeNonBrowsable); settings.DiffFilter = GetDiffFilter(settings.Filter); settings.DiffFactory = new ElementDifferenceFactory(container, ruleFilter); settings.GroupByAssembly = s_groupByAssembly; settings.IncludeForwardedTypes = true; if (filter == null) { filter = new DifferenceFilter <IncompatibleDifference>(); } ICciDifferenceWriter diffWriter = new DifferenceWriter(writer, settings, filter); ExportCciSettings.StaticSettings = settings.TypeComparer; ExportCciSettings.StaticOperands = new DifferenceOperands() { Contract = s_contractOperand, Implementation = s_implementationOperand, }; ExportCciSettings.StaticAttributeFilter = new AttributeFilter(s_excludeAttributesList); // Always compose the diff writer to allow it to import or provide exports container.SatisfyImports(diffWriter); return(diffWriter); }
public DocumentBuilder(IEnumerable <Assembly> assemblies = null) { Logger.LogVerbose("Loading plug-in..."); var assemblyList = assemblies?.ToList(); _container = GetContainer(assemblyList); _container.SatisfyImports(this); _currentBuildInfo.PluginHash = ComputePluginHash(assemblyList); Logger.LogInfo($"{Processors.Count()} plug-in(s) loaded."); foreach (var processor in Processors) { Logger.LogVerbose($"\t{processor.Name} with build steps ({string.Join(", ", from bs in processor.BuildSteps orderby bs.BuildOrder select bs.Name)})"); } }
private TestHost() { var configuration = new ContainerConfiguration() .WithAssemblies(new[] { typeof(TestHost).GetTypeInfo().Assembly, // this assembly typeof(Drawing).GetTypeInfo().Assembly, // BCad.Core.dll typeof(DxfFileHandler).GetTypeInfo().Assembly, // BCad.FileHandlers.dll }); container = configuration.CreateContainer(); container.SatisfyImports(this); Workspace.Update(drawing: new Drawing()); }
public DocumentBuilder(IEnumerable <Assembly> assemblies = null) { using (new LoggerPhaseScope(PhaseName)) { Logger.LogVerbose("Loading plug-in..."); _container = GetContainer(assemblies); _container.SatisfyImports(this); Logger.LogInfo($"{Processors.Count()} plug-in(s) loaded."); foreach (var processor in Processors) { Logger.LogVerbose($"\t{processor.Name} with build steps ({string.Join(", ", from bs in processor.BuildSteps orderby bs.BuildOrder select bs.Name)})"); } } }
public void ReceiveMetadataByCustomType() { ContainerConfiguration cfg = new ContainerConfiguration().WithAssembly(Assembly.GetExecutingAssembly()); ReflectionAndComposition r = new ReflectionAndComposition(); using (CompositionHost container = cfg.CreateContainer()) { container.SatisfyImports(r); } ImportMetadata meta = r.CurPlayer.Metadata; Console.WriteLine($"{nameof(ImportMetadata.MaxTracks)}:" + $"{meta.MaxTracks}\n{nameof(ImportMetadata.Skin)}:" + $"{meta.Skin}"); }
public void ImportManyTypes() { Assembly currentAssembly = Assembly.GetExecutingAssembly(); ContainerConfiguration config = new ContainerConfiguration().WithAssembly(currentAssembly); SomeAnimalSamples samples = new SomeAnimalSamples(); using (CompositionHost container = config.CreateContainer()) { container.SatisfyImports(samples); } foreach (var an in samples.AnimalList) { Console.WriteLine($"Name: {an.Name}\nFamily: {an.Family}\n"); } }
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); } }
public AssembliesLoader(object parent) { List <Assembly> assemblies = new List <Assembly>() { Assembly.Load("Lorn.GridTradingStaff.Tests"), Assembly.Load("Lorn.GridTradingStaff.DataAdapters.TuShare"), Assembly.Load("Lorn.GridTradingStaff.Businesses"), Assembly.Load("Lorn.GridTradingStaff.SecurityBusinesses"), Assembly.Load("Lorn.GridTradingStaff.DataAdapters.LocalDb"), Assembly.Load("Lorn.GridTradingStaff.DataAdapters.LocalDb.Sqlite") }; ContainerConfiguration configuration = new ContainerConfiguration(); configuration = configuration.WithAssemblies(assemblies); host = configuration.CreateContainer(); host.SatisfyImports(parent); }
public void ExportMetadata() { ContainerConfiguration cfg = new ContainerConfiguration().WithAssembly(Assembly.GetExecutingAssembly()); ReflectionAndComposition r = new ReflectionAndComposition(); using (CompositionHost container = cfg.CreateContainer()) { container.SatisfyImports(r); } TestOne t = r.ComposObject.Value; t.Run(); IDictionary <string, object> metas = r.ComposObject.Metadata; foreach (var kv in metas) { Console.WriteLine($"Key:{kv.Key}, value: {kv.Value}"); } }
public void Bootstrap() { var conventions = new ConventionBuilder(); //使用ForTypesDerivedFrom<ICalculator>().Export<ICalculator>()方法来代替Export特性 导出ICalculator conventions.ForTypesDerivedFrom <ICalculator>().Export <ICalculator>(); //使用ConventionBaseHost类的约定规则 代替Impor特性 导入ICalculator类型的属性。属性使用lambda表达式定义 conventions.ForType <ConventionBaseHost>().ImportProperty <ICalculator>(p => p.Calculator); // 通过ContainerConfiguration.WithDefaultConventions 配置使用ConventionBuilder定义的约定 // 在定义了要使用的约定后,可以像之前那样使用WithPart方法,指定部件中应当应用约定的部分。 // 为了使之比以前更加灵活,现在WithAssemblies方法用于指定应该应用的程序集。 // 过滤传递给这个方法的所有程序集,得到派生自ICalculator接口的类型,来应用出口。 var configuration = new ContainerConfiguration().WithDefaultConventions(conventions).WithAssemblies(GetAssemblies("C:/addins")); using (CompositionHost host = configuration.CreateContainer()) { host.SatisfyImports(this, conventions); } }
public DocumentBuilder( IEnumerable <Assembly> assemblies, ImmutableArray <string> postProcessorNames, string templateHash, string intermediateFolder = null, string commitFromSHA = null, string commitToSHA = null) { Logger.LogVerbose("Loading plug-in..."); using (new LoggerPhaseScope("ImportPlugins", LogLevel.Verbose)) { var assemblyList = assemblies?.ToList() ?? new List <Assembly>(); assemblyList.Add(typeof(DocumentBuilder).Assembly); _container = CompositionUtility.GetContainer(assemblyList); _container.SatisfyImports(this); _currentBuildInfo.CommitFromSHA = commitFromSHA; _currentBuildInfo.CommitToSHA = commitToSHA; if (intermediateFolder != null) { _currentBuildInfo.PluginHash = ComputePluginHash(assemblyList); _currentBuildInfo.TemplateHash = templateHash; _currentBuildInfo.DirectoryName = IncrementalUtility.CreateRandomDirectory(intermediateFolder); } } Logger.LogInfo($"{Processors.Count()} plug-in(s) loaded."); foreach (var processor in Processors) { Logger.LogVerbose($"\t{processor.Name} with build steps ({string.Join(", ", from bs in processor.BuildSteps orderby bs.BuildOrder select bs.Name)})"); } if (intermediateFolder != null) { var expanded = Environment.ExpandEnvironmentVariables(intermediateFolder); if (expanded.Length == 0) { expanded = "."; } _intermediateFolder = Path.GetFullPath(expanded); } _lastBuildInfo = BuildInfo.Load(_intermediateFolder); _postProcessorsManager = new PostProcessorsManager(_container, postProcessorNames); }
private void LoadLightHandlers() { var assemblies = Directory .GetFiles("./", "MEF.*.dll", SearchOption.AllDirectories) .Select(x => Path.Combine(Directory.GetCurrentDirectory(), x)) .Select(AssemblyLoadContext.Default.LoadFromAssemblyPath) .ToList(); var conventions = new ConventionBuilder(); conventions.ForTypesDerivedFrom <ILightHandlerContract>() .Export <ILightHandlerContract>() .Shared(); var configuration = new ContainerConfiguration() .WithExport <IHttpClientFactory>(_serviceProvider.GetService <IHttpClientFactory>()) .WithAssemblies(assemblies, conventions); _lighthandlerContainer = configuration.CreateContainer(); _lighthandlerContainer.SatisfyImports(this); _lighthandlers = _lighthandlerContainer.GetExports <ILightHandlerContract>(); }
public DocumentBuilder( IEnumerable <Assembly> assemblies, ImmutableArray <string> postProcessorNames, string intermediateFolder = null) { Logger.LogVerbose("Loading plug-in..."); using (new PerformanceScope("ImportPlugins", LogLevel.Diagnostic)) { var assemblyList = assemblies?.ToList(); _container = GetContainer(assemblyList); _container.SatisfyImports(this); _currentBuildInfo.PluginHash = ComputePluginHash(assemblyList); } Logger.LogInfo($"{Processors.Count()} plug-in(s) loaded."); foreach (var processor in Processors) { Logger.LogVerbose($"\t{processor.Name} with build steps ({string.Join(", ", from bs in processor.BuildSteps orderby bs.BuildOrder select bs.Name)})"); } _postProcessors = GetPostProcessor(postProcessorNames); _intermediateFolder = intermediateFolder; _lastBuildInfo = LoadLastBuildInfo(); }
public RuntimeConfigGenerationBatchTest() { CompositionHost.SatisfyImports(this); }
public void SatisfyImports(object importConsumer) { host.SatisfyImports(importConsumer); }
private static ICciDifferenceWriter GetDifferenceWriter(TextWriter writer, IDifferenceFilter filter, bool enforceOptionalRules, bool mdil, bool excludeNonBrowsable, string remapFile, bool groupByAssembly, string leftOperand, string rightOperand, string excludeAttributes, bool allowDefaultInterfaceMethods) { CompositionHost container = GetCompositionHost(); bool RuleFilter(IDifferenceRuleMetadata ruleMetadata) { if (ruleMetadata.OptionalRule && !enforceOptionalRules) { return(false); } if (ruleMetadata.MdilServicingRule && !mdil) { return(false); } return(true); } if (mdil && excludeNonBrowsable) { Trace.TraceWarning("Enforcing MDIL servicing rules and exclusion of non-browsable types are both enabled, but they are not compatible so non-browsable types will not be excluded."); } var settings = new MappingSettings { Comparers = GetComparers(remapFile), Filter = GetCciFilter(mdil, excludeNonBrowsable) }; settings.DiffFilter = GetDiffFilter(settings.Filter); settings.DiffFactory = new ElementDifferenceFactory(container, RuleFilter); settings.GroupByAssembly = groupByAssembly; settings.IncludeForwardedTypes = true; if (filter == null) { filter = new DifferenceFilter <IncompatibleDifference>(); } var diffWriter = new DifferenceWriter(writer, settings, filter); ExportCciSettings.StaticSettings = settings.TypeComparer; ExportCciSettings.StaticOperands = new DifferenceOperands() { Contract = leftOperand, Implementation = rightOperand }; ExportCciSettings.StaticAttributeFilter = new AttributeFilter(excludeAttributes); ExportCciSettings.StaticRuleSettings = new RuleSettings { AllowDefaultInterfaceMethods = allowDefaultInterfaceMethods }; // Always compose the diff writer to allow it to import or provide exports container.SatisfyImports(diffWriter); return(diffWriter); }
public DatabricksRuntimeConfigGenerationTest() { CompositionHost.SatisfyImports(this); }
public static void SatisfyImports(object objectWithLooseImports) { CompositionHost.SatisfyImports(objectWithLooseImports); }
public CompositionTest() { CompositionHost.SatisfyImports(this); }