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);
}
