protected override void Configure()
{
_container = new CompositionContainer(new AggregateCatalog(AssemblySource
.Instance
.Select(x => new AssemblyCatalog(x))
.OfType<ComposablePartCatalog>()
)
);
var batch = new CompositionBatch();
_portName = SerialPort.GetPortNames()[0];
_ecr = new Dp25(_portName);
var messenger = new MessageAggregator();
messenger.GetStream<SelectedPortChangedEvent>()
.Subscribe(e => _ecr.ChangePort(e.PortName));
batch.AddExportedValue<IWindowManager>(new WindowManager());
batch.AddExportedValue<IMessageAggregator>(messenger);
batch.AddExportedValue<Dp25>(_ecr);
batch.AddExportedValue(_container);
_container.Compose(batch);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
#if (DEBUG != true)
// Don't handle the exceptions in Debug mode because otherwise the Debugger wouldn't
// jump into the code when an exception occurs.
DispatcherUnhandledException += AppDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
#endif
XmlConfigurator.Configure();
_log.Debug("OnStartup called");
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Controller).Assembly));
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
catalog.Catalogs.Add(new AssemblyCatalog(typeof(IApplicationController).Assembly));
catalog.Catalogs.Add(new AssemblyCatalog(typeof(ValidationModel).Assembly));
_container = new CompositionContainer(catalog);
var batch = new CompositionBatch();
batch.AddExportedValue(_container);
_container.Compose(batch);
_controller = _container.GetExportedValue<IApplicationController>();
_controller.Initialize();
_controller.Run();
}
public static CompositionContainer GetMefContainer(string binDirPath, CompositionBatch batch = null, RegistrationBuilder builder = null)
{
if (builder == null)
builder = new RegistrationBuilder();
builder.ForTypesDerivedFrom<Controller>()
.SetCreationPolicy(CreationPolicy.NonShared).Export();
builder.ForTypesDerivedFrom<ApiController>()
.SetCreationPolicy(CreationPolicy.NonShared).Export();
var catalogs = new DirectoryCatalog(binDirPath, builder);
var container = new CompositionContainer(catalogs, CompositionOptions.DisableSilentRejection |
CompositionOptions.IsThreadSafe);
if (batch == null)
batch = new CompositionBatch();
// make container availalbe for di
batch.AddExportedValue(container);
container.Compose(batch);
return container;
}
private bool Compose()
{
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
//catalog.Catalogs.Add(new AssemblyCatalog(typeof(IEmailService).Assembly));
_container = new CompositionContainer(catalog);
var batch = new CompositionBatch();
batch.AddPart(this);
#if DEBUG
_container.Compose(batch);
#else
try
{
_container.Compose(batch);
}
catch (CompositionException compositionException)
{
MessageBox.Show(compositionException.ToString());
Shutdown(1);
return false;
}
#endif
return true;
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
DispatcherUnhandledException += AppDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
catalog = new AggregateCatalog();
// Add the WpfApplicationFramework assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(typeof(IMessageService).Assembly));
// Load module assemblies as well. See App.config file.
foreach (string moduleAssembly in Settings.Default.ModuleAssemblies)
{
catalog.Catalogs.Add(new AssemblyCatalog(moduleAssembly));
}
container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
// Initialize all presentation services
var presentationServices = container.GetExportedValues<IPresentationService>();
foreach (var presentationService in presentationServices) { presentationService.Initialize(); }
// Initialize and run all module controllers
moduleControllers = container.GetExportedValues<IModuleController>();
foreach (var moduleController in moduleControllers) { moduleController.Initialize(); }
foreach (var moduleController in moduleControllers) { moduleController.Run(); }
}
public void ComposeWithTypesExportedFromPythonAndCSharp(
object compositionTarget,
string scriptsToImport,
params Type[] typesToImport)
{
ScriptSource script;
var engine = Python.CreateEngine();
using (var scriptStream = GetType().Assembly.
GetManifestResourceStream(GetType(), scriptsToImport))
using (var scriptText = new StreamReader(scriptStream))
{
script = engine.CreateScriptSourceFromString(scriptText.ReadToEnd());
}
var typeExtractor = new ExtractTypesFromScript(engine);
var exports = typeExtractor.GetPartsFromScript(script, typesToImport).ToList();
var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
var container = new CompositionContainer(catalog);
var batch = new CompositionBatch(exports, new ComposablePart[] { });
container.Compose(batch);
container.SatisfyImportsOnce(compositionTarget);
}
internal static void Initialize(Kernel knl, LogicMgr logicMgr)
{
lock (syncRoot)
{
var itasks = container.GetExportedValues <IServise>();
foreach (var servise in itasks)
{
var lgc = (CoreLogic)servise;
lgc.Ctor(knl);
logicMgr.Add(lgc);
LogHelper.Info(lgc.Name + " loading...");
Csl.Wl(lgc.Name + " loading...");
}
knl.Ctor(logicMgr);
var batch = new CompositionBatch();
foreach (var logic in knl.GetLgcs())
{
batch.AddPart(logic);
}
try
{
container.Compose(batch);
}
catch (CompositionException compositionException)
{
Debug.WriteLine(compositionException.ToString());
throw;
}
}
}
protected override void Configure()
{
_container = new CompositionContainer(
new AggregateCatalog(AssemblySource.Instance.Select(x => new AssemblyCatalog(x)))
);
var batch = new CompositionBatch();
var fileStream = new FileStream(LocalSettings.ClientXmlFilePath, FileMode.OpenOrCreate, FileAccess.Read);
_settings = SettingsManager.LoadSettings<LocalSettings>(fileStream);
if (_settings == null)
{
_settings = new LocalSettings { FirstRun = true };
}
else
{
_settings.FirstRun = false;
}
batch.AddExportedValue(_settings);
batch.AddExportedValue<IWindowManager>(new WindowManager());
batch.AddExportedValue<IEventAggregator>(new EventAggregator());
batch.AddExportedValue(_container);
_container.Compose(batch);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
#if (DEBUG != true)
// Don't handle the exceptions in Debug mode because otherwise the Debugger wouldn't
// jump into the code when an exception occurs.
DispatcherUnhandledException += AppDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
#endif
catalog = new AggregateCatalog();
// Add the WpfApplicationFramework assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Controller).Assembly));
// Load module assemblies as well. See App.config file.
foreach (string moduleAssembly in Settings.Default.ModuleAssemblies)
{
catalog.Catalogs.Add(new AssemblyCatalog(moduleAssembly));
}
container = new CompositionContainer(catalog);
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
// Initialize all presentation services
var presentationServices = container.GetExportedValues<IPresentationService>();
foreach (var presentationService in presentationServices) { presentationService.Initialize(); }
// Initialize and run all module controllers
moduleControllers = container.GetExportedValues<IModuleController>();
foreach (var moduleController in moduleControllers) { moduleController.Initialize(); }
foreach (var moduleController in moduleControllers) { moduleController.Run(); }
}
protected override void OnStartup( StartupEventArgs e )
{
base.OnStartup( e );
new UnhandledExceptionHook( this );
Application.Current.Exit += OnShutdown;
var catalog = new AssemblyCatalog( GetType().Assembly );
myContainer = new CompositionContainer( catalog, CompositionOptions.DisableSilentRejection );
myContainer.Compose( new CompositionBatch() );
var shell = myContainer.GetExportedValue<Shell>();
myContainer.SatisfyImportsOnce( shell.myDesigner );
( ( Shell )MainWindow ).myProperties.DataContext = shell.myDesigner.SelectionService;
Application.Current.MainWindow = shell;
Application.Current.MainWindow.Show();
var args = Environment.GetCommandLineArgs();
if( args.Length == 2 )
{
shell.myDesigner.Open( args[ 1 ] );
}
}
public void ConventionCatalog_should_support_type_exports()
{
var registry = new PartRegistry();
registry.TypeScanner = new AssemblyTypeScanner(Assembly.GetExecutingAssembly());
registry
.Part()
.ForType<SampleExport>()
.Export();
var catalog =
new ConventionCatalog(registry);
var instance =
new ConventionPart<SampleExport>();
var batch =
new CompositionBatch();
batch.AddPart(instance);
var container =
new CompositionContainer(catalog);
container.Compose(batch);
instance.Imports.Count().ShouldEqual(1);
}
public void Compose(BaseParameters parameters)
{
try
{
var catalog = new AggregateCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()),
new AssemblyCatalog(typeof(Logic.SanityCheck).Assembly));
LoadPlugins(catalog, parameters);
var container = new CompositionContainer(catalog);
var batch = new CompositionBatch();
batch.AddPart(this);
batch.AddPart(parameters);
var config = new Configuration(parameters.FileSystem, parameters.Path);
config.ReadFromFile();
batch.AddExportedValue((IConfiguration)config);
container.Compose(batch);
}
catch (ReflectionTypeLoadException ex)
{
Console.WriteLine(@"Unable to load: \r\n{0}",
string.Join("\r\n", ex.LoaderExceptions.Select(e => e.Message)));
throw;
}
}
private void Compose()
{
var container = new CompositionContainer(directories);
var batch = new CompositionBatch();
batch.AddPart(this);
container.Compose(batch);
}
private bool Compose()
{
var catalog = new System.ComponentModel.Composition.Hosting.AggregateCatalog();
// var catalog = new AggregatingComposablePartCatalog();
catalog.Catalogs.Add(
new RubyCatalog(new RubyPartFile("calculator_ops.rb")));
catalog.Catalogs.Add(
new AssemblyCatalog(Assembly.GetExecutingAssembly()));
_container = new System.ComponentModel.Composition.Hosting.CompositionContainer(catalog);
//_container. AddPart(this);
var batch = new System.ComponentModel.Composition.Hosting.CompositionBatch();
batch.AddPart(this);
//_container.AddPart(this);
//_container.Compose(this);
try
{
_container.Compose(batch);
}
catch (CompositionException compositionException)
{
MessageBox.Show(compositionException.ToString());
return false;
}
return true;
}
public void Compose()
{
AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
string executionPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string generatorsPath = Path.Combine(executionPath, "Generators");
CreatePathIfRequied(generatorsPath);
generatorsCatalog = new DirectoryCatalog(generatorsPath);
string uiPath = Path.Combine(executionPath, "UI");
CreatePathIfRequied(uiPath);
UICatalog = new DirectoryCatalog(uiPath);
AggregateCatalog catalog = new AggregateCatalog();
catalog.Catalogs.Add(generatorsCatalog);
catalog.Catalogs.Add(UICatalog);
//Set the defaults....
CatalogExportProvider mainProvider = new CatalogExportProvider(assemblyCatalog);
CompositionContainer container = new CompositionContainer(catalog, mainProvider);
mainProvider.SourceProvider = container;
var batch = new CompositionBatch();
batch.AddPart(this);
RefreshCatalog refreshCatalog = new RefreshCatalog(generatorsCatalog, UICatalog);
container.ComposeParts(refreshCatalog);
container.Compose(batch);
Logger.Write("Compose complete");
}
public Runner Init(IFeedbackProvider feedbackProvider, string[] args)
{
var catalog = new AggregateCatalog(new AssemblyCatalog(typeof(Bootstrapper).Assembly));
var currentDir = Environment.CurrentDirectory;
var assemblyDir = new FileInfo(new Uri(Assembly.GetExecutingAssembly().CodeBase).AbsolutePath).Directory.FullName;
var paths = new string[]
{
assemblyDir,
Path.Combine(assemblyDir, "Tasks"),
currentDir,
Path.Combine(currentDir, "Tasks")
}.Unique();
var dirCatalogs = paths.Where(x => Directory.Exists(x))
.Select(x => new DirectoryCatalog(x, "*.Tasks.dll"));
dirCatalogs.Apply(x => catalog.Catalogs.Add(x));
var container = new CompositionContainer(catalog);
var parsed = new ArgumentParser().Parse(args);
var runner = new Runner(parsed.ActualArgs.ToArray());
var batch = new CompositionBatch();
batch.AddExportedValue<IFeedbackProvider>(feedbackProvider);
parsed.Options.Apply(x => batch.AddExportedValue<string>(x.Item1, x.Item2));
parsed.Switches.Apply(x => batch.AddExportedValue<bool>(x, true));
batch.AddPart(runner);
container.Compose(batch);
return runner;
}
public void GetValuesByType()
{
var cat = CatalogFactory.CreateDefaultAttributed();
var container = new CompositionContainer(cat);
string itestName = AttributedModelServices.GetContractName(typeof(ITest));
var e1 = container.GetExportedValues<ITest>();
var e2 = container.GetExports<ITest, object>(itestName);
Assert.IsInstanceOfType(e1.First(), typeof(T1), "First should be T1");
Assert.IsInstanceOfType(e1.Skip(1).First(), typeof(T2), "Second should be T2");
Assert.IsInstanceOfType(e2.First().Value, typeof(T1), "First should be T1");
Assert.IsInstanceOfType(e2.Skip(1).First().Value, typeof(T2), "Second should be T2");
CompositionContainer childContainer = new CompositionContainer(container);
CompositionBatch batch = new CompositionBatch();
batch.AddPart(new T1());
container.Compose(batch);
var t1 = childContainer.GetExportedValue<ITest>();
var t2 = childContainer.GetExport<ITest, object>(itestName);
Assert.IsInstanceOfType(t1, typeof(T1), "First (resolved) should be T1");
Assert.IsInstanceOfType(t2.Value, typeof(T1), "First (resolved) should be T1");
}
/// <summary>
/// By default, we are configured to use MEF
/// </summary>
protected override void Configure()
{
// Add all assemblies to AssemblySource (using a temporary DirectoryCatalog).
var directoryCatalog = new DirectoryCatalog(@"./");
AssemblySource.Instance.AddRange(
directoryCatalog.Parts
.Select(part => ReflectionModelServices.GetPartType(part).Value.Assembly)
.Where(assembly => !AssemblySource.Instance.Contains(assembly)));
// Prioritise the executable assembly. This allows the client project to override exports, including IShell.
// The client project can override SelectAssemblies to choose which assemblies are prioritised.
var priorityAssemblies = SelectAssemblies().ToList();
var priorityCatalog = new AggregateCatalog(priorityAssemblies.Select(x => new AssemblyCatalog(x)));
var priorityProvider = new CatalogExportProvider(priorityCatalog);
// Now get all other assemblies (excluding the priority assemblies).
var mainCatalog = new AggregateCatalog(
AssemblySource.Instance
.Where(assembly => !priorityAssemblies.Contains(assembly))
.Select(x => new AssemblyCatalog(x)));
var mainProvider = new CatalogExportProvider(mainCatalog);
Container = new CompositionContainer(priorityProvider, mainProvider);
priorityProvider.SourceProvider = Container;
mainProvider.SourceProvider = Container;
var batch = new CompositionBatch();
BindServices(batch);
batch.AddExportedValue(mainCatalog);
Container.Compose(batch);
}
public void DualContainers()
{
var container1 = new CompositionContainer();
TypeDescriptorServices dat1 = new TypeDescriptorServices();
CompositionBatch batch = new CompositionBatch();
batch.AddPart(dat1);
container1.Compose(batch);
MetadataStore.AddAttribute(
typeof(DynamicMetadataTestClass),
( type, attributes) =>
Enumerable.Concat(
attributes,
new Attribute[] { new TypeConverterAttribute(typeof(DynamicMetadataTestClassConverter)) }
),
container1
);
var container2 = new CompositionContainer();
CompositionBatch batch2 = new CompositionBatch();
TypeDescriptorServices dat2 = new TypeDescriptorServices();
batch2.AddPart(dat2);
container2.Compose(batch2);
DynamicMetadataTestClass val = DynamicMetadataTestClass.Get("42");
var attached1 = dat1.GetConverter(val.GetType());
Assert.IsTrue(attached1.CanConvertFrom(typeof(string)), "The new type converter for DynamicMetadataTestClass should support round tripping");
var attached2 = dat2.GetConverter(val.GetType());
Assert.IsFalse(attached2.CanConvertFrom(typeof(string)), "The default type converter for DynamicMetadataTestClass shouldn't support round tripping");
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
DispatcherUnhandledException += AppDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
catalog = new AggregateCatalog();
// Add the WpfApplicationFramework assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(typeof(ViewModel).Assembly));
// Add the Waf.BookLibrary.Library.Presentation assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
// Add the Waf.BookLibrary.Library.Applications assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(typeof(ShellViewModel).Assembly));
// Load module assemblies as well (e.g. Reporting extension). See App.config file.
foreach(string moduleAssembly in Settings.Default.ModuleAssemblies)
{
catalog.Catalogs.Add(new AssemblyCatalog(moduleAssembly));
}
container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
moduleControllers = container.GetExportedValues<IModuleController>();
foreach (IModuleController moduleController in moduleControllers) { moduleController.Initialize(); }
foreach (IModuleController moduleController in moduleControllers) { moduleController.Run(); }
}
internal static IServiceLocator GetServiceLocator(Assembly assembly, CompositionBatch batch)
{
var assemblyLocation = assembly.Location;
var file = new FileInfo(assemblyLocation);
var catalogs = new List<ComposablePartCatalog>
{
new AssemblyCatalog(assembly),
new DirectoryCatalog(file.DirectoryName ?? ".")
};
var catalog = new AggregateCatalog(catalogs);
var container = new CompositionContainer(catalog,
CompositionOptions.DisableSilentRejection |
CompositionOptions.IsThreadSafe );
var serviceLocator = new MefServiceLocator(container);
batch.AddExportedValue(container);
batch.AddExportedValue<IServiceLocator>(serviceLocator);
container.Compose(batch);
return serviceLocator;
}
public ExportProvider CreateExportProvider(CompositionBatch additionalValues) {
var container = new CompositionContainer(_catalogLazy.Value, CompositionOptions.DisableSilentRejection);
AddValues(container);
container.Compose(additionalValues);
_containers.Enqueue(container);
return container;
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
#if (DEBUG != true)
// Don't handle the exceptions in Debug mode because otherwise the Debugger wouldn't
// jump into the code when an exception occurs.
DispatcherUnhandledException += AppDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
#endif
catalog = new AggregateCatalog();
// Add the WpfApplicationFramework assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Controller).Assembly));
// Add the Waf.BookLibrary.Library.Presentation assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
// Add the Waf.BookLibrary.Library.Applications assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(typeof(ShellViewModel).Assembly));
// Load module assemblies as well (e.g. Reporting extension). See App.config file.
foreach(string moduleAssembly in Settings.Default.ModuleAssemblies)
{
catalog.Catalogs.Add(new AssemblyCatalog(moduleAssembly));
}
container = new CompositionContainer(catalog);
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
moduleControllers = container.GetExportedValues<IModuleController>();
foreach (IModuleController moduleController in moduleControllers) { moduleController.Initialize(); }
foreach (IModuleController moduleController in moduleControllers) { moduleController.Run(); }
}
protected override void Configure()
{
_container = new CompositionContainer(
new AggregateCatalog(
AssemblySource.Instance.Select(x => new AssemblyCatalog(x)).OfType<ComposablePartCatalog>()
)
);
MessageBinder.SpecialValues.Add("$orignalsourcecontext", context =>
{
var args = context.EventArgs as RoutedEventArgs;
if (args == null)
{
return null;
}
var fe = args.OriginalSource as FrameworkElement;
if (fe == null)
{
return null;
}
return fe.DataContext;
});
var batch = new CompositionBatch();
batch.AddExportedValue<IWindowManager>(new WindowManager());
batch.AddExportedValue<IEventAggregator>(new EventAggregator());
batch.AddExportedValue(_container);
_container.Compose(batch);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
#if !(DEBUG)
DispatcherUnhandledException += AppDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
#endif
InitializeCultures();
catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(WafConfiguration).Assembly));
catalog.Catalogs.Add(new AssemblyCatalog(typeof(ShellViewModel).Assembly));
catalog.Catalogs.Add(new AssemblyCatalog(typeof(App).Assembly));
container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
// Initialize all presentation services
var presentationServices = container.GetExportedValues<IPresentationService>();
foreach (var presentationService in presentationServices) { presentationService.Initialize(); }
// Initialize and run all module controllers
moduleControllers = container.GetExportedValues<IModuleController>();
foreach (var moduleController in moduleControllers) { moduleController.Initialize(); }
foreach (var moduleController in moduleControllers) { moduleController.Run(); }
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
#if (DEBUG != true)
// Don't handle the exceptions in Debug mode because otherwise the Debugger wouldn't
// jump into the code when an exception occurs.
DispatcherUnhandledException += AppDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += AppDomainUnhandledException;
#endif
AggregateCatalog catalog = new AggregateCatalog();
// Add the BigEggApplicationFramework assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Controller).Assembly));
// Add the FMStudio.Presentation assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
// Add the FMStudio.Applications assembly to the catalog
catalog.Catalogs.Add(new AssemblyCatalog(typeof(IApplicationController).Assembly));
container = new CompositionContainer(catalog);
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
controller = container.GetExportedValue<IApplicationController>();
controller.Initialize();
controller.Run();
}
public static void Compose(object o)
{
var container = new CompositionContainer(new DirectoryCatalog(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin")));
var batch = new CompositionBatch();
batch.AddPart(o);
container.Compose(batch);
}
private void InitializeMEF()
{
CompositionContainer container = new CompositionContainer(new AssemblyCatalog(GetType().Assembly));
CompositionBatch batch = new CompositionBatch();
batch.AddExportedValue(container);
container.Compose(batch);
container.SatisfyImportsOnce(this);
}
private static void Configure()
{
var funcCatalog = new FuncCatalog();
funcCatalog.AddPart<ILogger>(ep => new ConsoleLogger());
container = new CompositionContainer(funcCatalog);
var batch = new CompositionBatch();
batch.AddExportedValue<ExportProvider>(container);
container.Compose(batch);
}
private void LoadExtensions()
{
var location = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var catalog = new DirectoryCatalog(location + "\\Extensions\\");
var container = new CompositionContainer(catalog);
var batch = new CompositionBatch();
batch.AddPart(this);
container.Compose(batch);
}
private static CompositionContainer CreateContainer()
{
var Catalog = new AssemblyCatalog(System.Reflection.Assembly.GetEntryAssembly());
var Container = new CompositionContainer(Catalog);
var Batch = new CompositionBatch();
Batch.AddExportedValue(Container);
Container.Compose(Batch);
return Container;
}
/// <summary>
/// Add export instances
/// </summary>
/// <param name="attributedParts">instances that has export attributes</param>
#endregion // Documentation
public static void ComposeParts(params object[] attributedParts)
{
#region Validation
if (_container == null)
{
throw new NullReferenceException("container does not initialized");
}
if (attributedParts == null || attributedParts.Length == 0)
{
return;
}
#endregion // Validation
CompositionBatch batch = new CompositionBatch(
attributedParts.Select(attributedPart => AttributedModelServices.CreatePart(attributedPart)).ToArray(),
Enumerable.Empty <ComposablePart>());
_container.Compose(batch);
}
