public void WhenInitializingAModuleWithNoCatalogPendingToBeLoaded_ThenInitializesTheModule()
{
var aggregateCatalog = new AggregateCatalog(new AssemblyCatalog(typeof(MefModuleInitializer).Assembly));
var compositionContainer = new CompositionContainer(aggregateCatalog);
compositionContainer.ComposeExportedValue(aggregateCatalog);
var serviceLocatorMock = new Mock<IServiceLocator>();
var loggerFacadeMock = new Mock<ILoggerFacade>();
var serviceLocator = serviceLocatorMock.Object;
var loggerFacade = loggerFacadeMock.Object;
compositionContainer.ComposeExportedValue(serviceLocator);
compositionContainer.ComposeExportedValue(loggerFacade);
aggregateCatalog.Catalogs.Add(new TypeCatalog(typeof(TestModuleForInitializer)));
var moduleInitializer = compositionContainer.GetExportedValue<IModuleInitializer>();
var moduleInfo = new ModuleInfo("TestModuleForInitializer", typeof(TestModuleForInitializer).AssemblyQualifiedName);
var module = compositionContainer.GetExportedValues<IModule>().OfType<TestModuleForInitializer>().First();
Assert.IsFalse(module.Initialized);
moduleInitializer.Initialize(moduleInfo);
Assert.IsTrue(module.Initialized);
}
public static void Main(string[] args)
{
// Initialize the composition catalog
var aggregationPath = Path.Combine(
Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
"Workflows");
if (Directory.Exists(aggregationPath))
{
var directoryCatalog = new DirectoryCatalog(aggregationPath);
using (CompositionContainer container = new CompositionContainer(directoryCatalog))
{
IEnumerable <IProcessDefinitionRegistry> registries =
container.GetExportedValues <IProcessDefinitionRegistry>();
WfDeployer.Registries = registries;
}
}
var parser = new FluentCommandLineParser <ApplicationArgumments>();
parser.Setup(a => a.Command).As('c', "command").Required().SetDefault("help");
parser.Setup(a => a.FlowId).As('f', "flowid").SetDefault(string.Empty);
parser.Setup(a => a.Version).As('v', "version").SetDefault(-1);
parser.Setup(a => a.RoleString).As('r', "role").SetDefault(string.Empty);
var result = parser.Parse(args);
if (!result.HasErrors)
{
Action <ApplicationArgumments> action;
if (!Commands.TryGetValue(parser.Object.Command, out action))
{
PrintHelp(parser.Object);
return;
}
action(parser.Object);
}
else
{
Console.WriteLine(result.ErrorText);
Console.WriteLine("Use -c help for help");
}
}
public EditorHost(CompositionContainer compositionContainer)
{
CompositionContainer = compositionContainer;
TextBufferFactoryService = CompositionContainer.GetExportedValue <ITextBufferFactoryService>();
TextEditorFactoryService = CompositionContainer.GetExportedValue <ITextEditorFactoryService>();
ProjectionBufferFactoryService = CompositionContainer.GetExportedValue <IProjectionBufferFactoryService>();
SmartIndentationService = CompositionContainer.GetExportedValue <ISmartIndentationService>();
EditorOperationsFactoryService = CompositionContainer.GetExportedValue <IEditorOperationsFactoryService>();
EditorOptionsFactoryService = CompositionContainer.GetExportedValue <IEditorOptionsFactoryService>();
TextSearchService = CompositionContainer.GetExportedValue <ITextSearchService>();
OutliningManagerService = CompositionContainer.GetExportedValue <IOutliningManagerService>();
TextBufferUndoManagerProvider = CompositionContainer.GetExportedValue <ITextBufferUndoManagerProvider>();
ContentTypeRegistryService = CompositionContainer.GetExportedValue <IContentTypeRegistryService>();
ClassificationTypeRegistryService = CompositionContainer.GetExportedValue <IClassificationTypeRegistryService>();
var errorHandlers = CompositionContainer.GetExportedValues <IExtensionErrorHandler>();
BasicUndoHistoryRegistry = CompositionContainer.GetExportedValue <IBasicUndoHistoryRegistry>();
}
private T GetRequiredImport <T>() where T : class
{
T import = CompositionContainer.GetExportedValueOrDefault <T>();
if (import == default(T))
{
int importCount = CompositionContainer.GetExportedValues <T>().Count();
string extensionTypeName = typeof(T).Name;
if (importCount > 1)
{
MessageBox.Show(String.Format("You may only include one {0} Extension. {1} were found.", extensionTypeName, importCount));
}
else
{
MessageBox.Show(String.Format("A {0} Extension must be included.", extensionTypeName));
}
}
return(import);
}
private void InitCatalog()
{
AggregateCatalog = new AggregateCatalog();
AggregateCatalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var pluginDirectory = SettingsService.GetPluginDirectory();
foreach (var directory in Directory.GetDirectories(pluginDirectory, "*.*", SearchOption.AllDirectories))
{
AggregateCatalog.Catalogs.Add(new DirectoryCatalog(directory, "*.dll"));
}
//var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
MefContainer = new CompositionContainer(AggregateCatalog);
MefContainer.ComposeParts();
foreach (ICheckoutAndBuildPlugin plugin in MefContainer.GetExportedValues <ICheckoutAndBuildPlugin>())
{
plugin.Init(new CheckoutAndBuildServiceProvider(this, MefContainer), pluginDirectory);
}
}
private static IEnumerable <IPlugin> GetPluginsFrom(string path)
{
if (Directory.Exists(path))
{
try
{
var result = new List <IPlugin>();
var container = new CompositionContainer(new DirectoryCatalog(path));
var imanga = typeof(Manga.IManga);
var ilogin = typeof(Account.ILogin);
foreach (var plugin in container.GetExportedValues <IPlugin>())
{
try
{
if (!imanga.IsAssignableFrom(plugin.MangaType))
{
throw new MangaReaderException($"Type in property {nameof(plugin.MangaType)} of " +
$"type {plugin.GetType()} must be implement {imanga} interface.");
}
if (!ilogin.IsAssignableFrom(plugin.LoginType))
{
throw new MangaReaderException($"Type in property {nameof(plugin.LoginType)} of " +
$"type {plugin.GetType()} must be implement {ilogin} interface.");
}
Log.Add($"Plugin {plugin.Name} loaded.");
result.Add(plugin);
}
catch (MangaReaderException mre)
{
Log.Exception(mre);
}
}
return(result);
}
catch (System.Exception ex)
{
Log.Exception(ex, string.Format("Plugins from {0} cannot be loaded.", path));
}
}
return(Enumerable.Empty <IPlugin>());
}
public async Task ClientSyncParams()
{
var container = new CompositionContainer(new AggregateCatalog(RegisterAssembly.Distinct().Select(_ => new AssemblyCatalog(_)).OfType <ComposablePartCatalog>()));
var values = container.GetExportedValues <Pv2ParamType>();
PayloadV2TestHelper.CreateParams(out var clientParams, out var serverParams, values);
serverParams.WriteInt(ParamDefinition.ParamInt1, 10);
serverParams.WriteInt(ParamDefinition.ParamInt2, 5);
await clientParams.RequestAll();
var readedInt = clientParams.ReadInt(ParamDefinition.ParamInt1);
Assert.Equal(10, readedInt);
var readedInt2 = clientParams.ReadInt(ParamDefinition.ParamInt2);
Assert.Equal(5, readedInt2);
}
/// <summary>
/// Gets all exports of type T
/// </summary>
public IEnumerable <T> GetExportedValues <T>()
{
lock (_exportedValuesLockObject)
{
IEnumerable values;
if (_exportedValues.TryGetValue(typeof(T), out values))
{
return(values.OfType <T>());
}
if (!_composableParts.IsCompleted)
{
_composableParts.Wait();
}
values = _compositionContainer.GetExportedValues <T>().ToList();
_exportedValues[typeof(T)] = values;
return(values.OfType <T>());
}
}
private static IEnumerable <Assembly> DiscoverAssembliesThatContainExtensionsUsingMef(string extensionsPath)
{
var catalog = new DirectoryCatalog(extensionsPath);
var compositionContainer = new CompositionContainer(catalog);
try
{
var modules = compositionContainer.GetExportedValues <IFunnelWebExtension>();
return(modules.Select(m => m.GetType().Assembly).Distinct());
}
catch (ReflectionTypeLoadException ex)
{
if (ex.LoaderExceptions.Length > 0)
{
throw new FunnelWebExtensionLoadException(string.Format("Failed to load {0}", ex.Types[0].Assembly.FullName), ex.LoaderExceptions[0]);
}
throw;
}
}
IEnumerable <RuntimeComponent> m_runtimeParts = null; // all the parts that MEF brings in
public MainWindow()
{
InitializeComponent();
m_cmdArgs = Environment.GetCommandLineArgs();
/************* MEF *********************/
try
{ // let MEF build the app out of discovered parts
var catalog = new AggregateCatalog(); // var type can not be init'd to null
// BadFormatImageException occurs as a first chance exception if attempting to load a flat dll
// as they are w/o a manifest, some32bitstd.dll. It can be safely ignored.
// The code will continue to load .net dlls relevant to using the Managed Extension Framework (MEF).
// 'relevant' means the component exports the IWx_Client interface
catalog = new AggregateCatalog(new DirectoryCatalog("."),
new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var container = new CompositionContainer(catalog);
m_runtimeParts = container.GetExportedValues <RuntimeComponent>(); // ctors of the individual user components for the views called here
}
catch (ReflectionTypeLoadException)
{
}
catch (Exception)
{
}
foreach (RuntimeComponent win in m_runtimeParts) // add the component to the ui grid + a separator line
{
RowDefinition gridRow = new RowDefinition();
gridMain.RowDefinitions.Add(gridRow);
StackPanel stackPnl = new StackPanel();
stackPnl.Children.Add((UIElement)win);
Grid.SetRow(stackPnl, gridMain.RowDefinitions.Count - 1);
gridMain.Children.Add(stackPnl);
RowDefinition gridRowBorder = new RowDefinition();
gridMain.RowDefinitions.Add(gridRowBorder);
Border border = new Border();
Grid.SetRow(border, gridMain.RowDefinitions.Count - 1);
border.Background = System.Windows.Media.Brushes.LemonChiffon;
border.Height = 10;
gridMain.Children.Add(border);
}
/************* MEF *********************/
}
public List <TResult> Load <TResult>() where TResult : class
{
List <TResult> instances = new List <TResult>();
try
{
if (_container != null)
{
(_container.Catalog as DirectoryCatalog).Refresh();
instances = _container.GetExportedValues <TResult>().ToList();
}
else
{
DirectoryCatalog catalog = new DirectoryCatalog(FolderPath);
_container = new CompositionContainer(catalog);
instances = _container.GetExportedValues <TResult>().ToList();
}
return(instances);
}
catch (ImportCardinalityMismatchException)//when no contract implementation
{
return(instances);
}
catch (ReflectionTypeLoadException)//when wrong contract implementation
{
return(instances);
}
catch (FileNotFoundException)//
{
return(instances);
}
catch (Exception ex)
{
if (Wrapper.instance != null)
{
Wrapper.instance.PrintException(ex);
}
throw new FormatException("Load of MEF file failed.", ex);
}
}
private void LoadPlugins()
{
try
{
if (!Directory.Exists(@".\Plugins"))
{
return;
}
var catalog = new DirectoryCatalog(@".\Plugins", "CInject.Plugin.*.dll");
catalog.Refresh();
var container = new CompositionContainer(catalog);
Plugins = container.GetExportedValues <IPlugin>();
var pluginArray = Plugins as IPlugin[] ?? Plugins.ToArray();
PluginList = pluginArray.ToList();
Parallel.ForEach(pluginArray, (current) =>
{
try
{
if (current.Menu != null)
{
PopulatePluginMenu(current);
}
}
catch
{
}
});
}
catch (AggregateException aggregateException)
{
string message = String.Concat(aggregateException.InnerExceptions.Select(x => x.Message));
MessageBox.Show(Resources.PluginLoadErrorAggregate + message);
}
catch (Exception exception)
{
MessageBox.Show(Resources.PluginLoadErrorAggregate + exception.Message);
}
}
public void DoWorkInShadowCopiedDomain()
{
// Use RegistrationBuilder to set up our MEF parts.
var regBuilder = new RegistrationBuilder();
regBuilder.ForTypesDerivedFrom <IExport>().Export <IExport>();
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Runner).Assembly, regBuilder));
directoryCatalog = new DirectoryCatalog(pluginPath, regBuilder);
catalog.Catalogs.Add(directoryCatalog);
container = new CompositionContainer(catalog);
container.ComposeExportedValue(container);
// Get our exports available to the rest of Program.
exports = container.GetExportedValues <IExport>();
Console.WriteLine("{0} exports in AppDomain {1}", exports.Count(), AppDomain.CurrentDomain.FriendlyName);
}
public object GetService(Type serviceType)
{
string contract = AttributedModelServices.GetContractName(serviceType);
var instance = container.GetExportedValues <object>(contract).FirstOrDefault();
if (instance != null)
{
return(instance);
}
instance = Create(serviceType);
if (instance != null)
{
return(instance);
}
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture,
"Could not locate any instances of contract {0}.", contract));
}
static PluginManager()
{
Logger.Debug("Creating");
DirectoryCatalog catalog = new DirectoryCatalog(Path.Combine(Directory.GetCurrentDirectory(), "Plugins"), "TAS.Server.*.dll");
ServerContainer = new CompositionContainer(catalog);
ServerContainer.ComposeExportedValue("AppSettings", ConfigurationManager.AppSettings);
try
{
_enginePlugins = ServerContainer.GetExportedValues <IEnginePluginFactory>();
}
catch (ReflectionTypeLoadException e)
{
Logger.Error(e, "Plugin load failed: {0}", e.LoaderExceptions);
}
catch (Exception e)
{
Logger.Error(e, "Plugin load failed: {0}", e);
}
}
void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
CompositionContainer cc;
AggregateCatalog cat = new AggregateCatalog();
cat.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
cc = new CompositionContainer(cat);
pdfList.DisplayMemberPath = "Name";
var list = cc.GetExportedValues <PDFTest>();
pdfList.ItemsSource = list;
if (list.Any())
{
pdfList.SelectedIndex = 0;
}
}
private void ImportModules()
{
var assemblyDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var modulesDirectory = Directory.GetDirectories(assemblyDirectory + @"\AdModules");
var catalog = new AggregateCatalog();
foreach (var module in modulesDirectory)
{
catalog.Catalogs.Add(
new DirectoryCatalog(module));
}
var container = new CompositionContainer(catalog);
container.ComposeParts(this);
_modules = container.GetExportedValues <IAdModule>().ToDictionary(k => k.Title, v => v);
}
public async Task UpdateRiseByServer()
{
var container = new CompositionContainer(new AggregateCatalog(RegisterAssembly.Distinct().Select(_ => new AssemblyCatalog(_)).OfType <ComposablePartCatalog>()));
var values = container.GetExportedValues <Pv2ParamType>();
PayloadV2TestHelper.CreateParams(out var clientParams, out var serverParams, values);
await clientParams.RequestAll();
var serverBefore = serverParams.ReadInt(ParamDefinition.ParamInt1);
var clientBefore = clientParams.ReadInt(ParamDefinition.ParamInt1);
Assert.Equal(serverBefore, clientBefore);
serverParams.WriteInt(ParamDefinition.ParamInt1, 100);
await Task.Delay(2_000);
var clientAfter = clientParams.ReadInt(ParamDefinition.ParamInt1);
var serverAfter = serverParams.ReadInt(ParamDefinition.ParamInt1);
Assert.Equal(clientAfter, serverAfter);
}
public EditorHost(CompositionContainer compositionContainer)
{
_compositionContainer = compositionContainer;
_textBufferFactoryService = _compositionContainer.GetExportedValue <ITextBufferFactoryService>();
_textEditorFactoryService = _compositionContainer.GetExportedValue <ITextEditorFactoryService>();
_projectionBufferFactoryService = _compositionContainer.GetExportedValue <IProjectionBufferFactoryService>();
_smartIndentationService = _compositionContainer.GetExportedValue <ISmartIndentationService>();
_editorOperationsFactoryService = _compositionContainer.GetExportedValue <IEditorOperationsFactoryService>();
_editorOptionsFactoryService = _compositionContainer.GetExportedValue <IEditorOptionsFactoryService>();
_textSearchService = _compositionContainer.GetExportedValue <ITextSearchService>();
_outliningManagerService = _compositionContainer.GetExportedValue <IOutliningManagerService>();
_textBufferUndoManagerProvider = _compositionContainer.GetExportedValue <ITextBufferUndoManagerProvider>();
_contentTypeRegistryService = _compositionContainer.GetExportedValue <IContentTypeRegistryService>();
_classificationTypeRegistryService = _compositionContainer.GetExportedValue <IClassificationTypeRegistryService>();
var errorHandlers = _compositionContainer.GetExportedValues <IExtensionErrorHandler>();
_protectedOperations = EditorUtilsFactory.CreateProtectedOperations(errorHandlers);
_basicUndoHistoryRegistry = _compositionContainer.GetExportedValue <IBasicUndoHistoryRegistry>();
}
internal static void Initialize(CompositionContainer composition)
{
List <Language> languages = new List <Language>();
if (composition != null)
{
languages.AddRange(composition.GetExportedValues <Language>());
}
else
{
languages.Add(new CSharpLanguage());
languages.Add(new VB.VBLanguage());
}
// Fix order: C#, VB, IL
var langs2 = new List <Language>();
var lang = languages.FirstOrDefault(a => a is CSharpLanguage);
if (lang != null)
{
languages.Remove(lang);
langs2.Add(lang);
}
lang = languages.FirstOrDefault(a => a is VB.VBLanguage);
if (lang != null)
{
languages.Remove(lang);
langs2.Add(lang);
}
langs2.Add(new ILLanguage(true));
for (int i = 0; i < langs2.Count; i++)
{
languages.Insert(i, langs2[i]);
}
#if DEBUG
languages.AddRange(ILAstLanguage.GetDebugLanguages());
languages.AddRange(CSharpLanguage.GetDebugLanguages());
#endif
allLanguages = languages.AsReadOnly();
}
public InteractiveManager()
{
var host = MefHostServices.Create(MefHostServices.DefaultAssemblies.Concat(new[]
{
Assembly.Load("Microsoft.CodeAnalysis.Features"),
Assembly.Load("Microsoft.CodeAnalysis.CSharp.Features"),
}));
_workspace = new InteractiveWorkspace(host);
_parseOptions = new CSharpParseOptions(kind: SourceCodeKind.Interactive);
_references = _assemblyTypes.Select(t =>
MetadataReference.CreateFromAssembly(t.Assembly)).ToArray();
_compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary,
usings: _assemblyTypes.Select(x => x.Namespace).ToImmutableArray());
var container = new CompositionContainer(new AssemblyCatalog(typeof(ISignatureHelpProvider).Assembly),
CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe);
_signatureHelpProviders = container.GetExportedValues <ISignatureHelpProvider>().ToArray();
}
internal static Collection <T> GetExportedPlugins <T>(string directory, string searchPattern = "*.dll")
{
Collection <T> plugins = new Collection <T>();
DirectoryCatalog catalog = new DirectoryCatalog(directory, searchPattern);
CompositionContainer container = new CompositionContainer(catalog);
try
{
foreach (var plugin in container.GetExportedValues <T>())
{
plugins.Add(plugin);
}
}
finally
{
catalog.Dispose();
container.Dispose();
}
return(plugins);
}
private T GetRequiredImport <T>()
where T : class
{
var imports = CompositionContainer.GetExportedValues <T>().ToList();
if (imports.Count > 1)
{
// If more then one required import, skip default imports
imports = imports.Where(_ => !_.GetType().GetCustomAttributes(typeof(DefaultRequiredImportAttribute), false).Any()).ToList();
}
if (imports.Count != 1)
{
var importCount = imports.Count;
string extensionTypeName = typeof(T).Name;
MessageBox.Show(importCount > 1 ? string.Format(MessageStrings.AppManager_OnlyIncludeOneExtension, extensionTypeName, importCount) : string.Format(MessageStrings.AppManager_NeedExtensionBecauseUIPluginFound, extensionTypeName));
return(null);
}
return(imports[0]);
}
/// <summary>
/// Loads the available plugins.
/// </summary>
public void LoadPlugins()
{
if (!Directory.Exists(this.pluginDirectory))
{
return;
}
if (String.IsNullOrEmpty(this.pluginDirectory))
{
return;
}
var aggregateCatalog = new AggregateCatalog();
var subDirs = Directory.GetDirectories(this.pluginDirectory);
foreach (var dir in subDirs)
{
var catalog = new DirectoryCatalog(dir);
try
{
CompositionContainer tmpContainer = new CompositionContainer(catalog);
tmpContainer.GetExportedValues <WsapmPluginBase>();
}
catch (Exception ex) // (CompositionException ex)
{
// Ignore plugins that fail to load.
WsapmLog.Log.WriteError(Resources.Wsapm_Core.PuginLoader_CompositionError, ex);
continue;
}
aggregateCatalog.Catalogs.Add(catalog);
}
var compositionContainer = new CompositionContainer(aggregateCatalog);
compositionContainer.ComposeParts(this);
CheckForDuplicateGuidsAndManifest();
}
// Load plugins
private static void LoadPlugins()
{
int archivePlugins = 0, compressionPlugins = 0, texturePlugins = 0;
try
{
// Get all of the DLLs in the Plugins directory and load them if they contain any classes that impliment IPuyoToolsPlugin.
AggregateCatalog catalog = new AggregateCatalog(new DirectoryCatalog("Plugins", "*.dll"), new AssemblyCatalog(Assembly.GetExecutingAssembly()));
CompositionContainer container = new CompositionContainer(catalog);
Plugins = container.GetExportedValues <IPuyoToolsPlugin>();
foreach (IPuyoToolsPlugin plugin in Plugins)
{
// Now, let's attempt to determine which type of plugin this is
// and add it to the appropiate module lists.
if (plugin is ArchiveBase archiveModule)
{
// Archive module
Archive.Formats.Add(ArchiveFormat.Plugin + archivePlugins, archiveModule);
archivePlugins++;
}
else if (plugin is CompressionBase compressionModule)
{
// Compression module
Compression.Formats.Add(CompressionFormat.Plugin + compressionPlugins, compressionModule);
compressionPlugins++;
}
else if (plugin is TextureBase textureModule)
{
// Texture module
Texture.Formats.Add(TextureFormat.Plugin + texturePlugins, textureModule);
texturePlugins++;
}
}
}
catch { }
}
public void RegisterRequiredServicesIfMissingAndUDPMessageHandler()
{
AggregateCatalog _catalog = new AggregateCatalog(new AssemblyCatalog("UAOOI.Networking.UDPMessageHandler.dll"));
AggregateCatalog _newCatalog = DefaultServiceRegistrar.RegisterServices(_catalog);
using (CompositionContainer _container = new CompositionContainer(_newCatalog))
{
Assert.AreEqual <int>(9, _container.Catalog.Parts.Count <ComposablePartDefinition>());
foreach (ComposablePartDefinition _part in _container.Catalog.Parts)
{
Debug.WriteLine("New Part");
foreach (ImportDefinition _import in _part.ImportDefinitions)
{
Debug.WriteLine(string.Format("Imported contracts name => '{0}'", _import.ContractName));
}
foreach (ExportDefinition _export in _part.ExportDefinitions)
{
Debug.WriteLine(string.Format("Exported contracts name => '{0}'", _export.ContractName));
}
}
IMessageHandlerFactory _messageHandlerFactory = _container.GetExportedValue <IMessageHandlerFactory>();
Assert.IsNotNull(_messageHandlerFactory);
INetworkingEventSourceProvider _baseEventSource = _messageHandlerFactory as INetworkingEventSourceProvider;
Assert.IsNull(_baseEventSource);
IEnumerable <INetworkingEventSourceProvider> _diagnosticProviders = _container.GetExportedValues <INetworkingEventSourceProvider>();
Assert.AreEqual <int>(3, _diagnosticProviders.Count <INetworkingEventSourceProvider>());
using (CompositeDisposable _Components = new CompositeDisposable())
{
EventSourceBootstrapper _eventSourceBootstrapper = _container.GetExportedValue <EventSourceBootstrapper>();
_Components.Add(_eventSourceBootstrapper);
Assert.AreEqual <int>(3, _eventSourceBootstrapper.EventSources.Count <INetworkingEventSourceProvider>());
ConsumerDataManagementSetup m_ConsumerConfigurationFactory = _container.GetExportedValue <ConsumerDataManagementSetup>();
_Components.Add(m_ConsumerConfigurationFactory);
OPCUAServerProducerSimulator m_OPCUAServerProducerSimulator = _container.GetExportedValue <OPCUAServerProducerSimulator>();
_Components.Add(m_OPCUAServerProducerSimulator);
Assert.AreEqual <int>(3, _Components.Count);
}
}
}
private List <TPlugin> LoadPlugin(string pluginDirectory)
{
CompositionContainer _container = null;
List <TPlugin> instances = new List <TPlugin>();
try
{
if (_container != null)
{
(_container.Catalog as DirectoryCatalog).Refresh();
instances = _container.GetExportedValues <TPlugin>().ToList();
}
else
{
DirectoryCatalog catalog = new DirectoryCatalog(pluginDirectory);
_container = new CompositionContainer(catalog);
instances = _container.GetExportedValues <TPlugin>().ToList();
}
return(instances);
}
catch (ImportCardinalityMismatchException)//when no contract implementation
{
return(instances);
}
catch (ReflectionTypeLoadException)//when wrong contract implementation
{
return(instances);
}
catch (FileNotFoundException)//
{
return(instances);
}
catch (Exception ex)
{
throw new FormatException("Load of MEF file failed.", ex);
}
}
public void AutoPopulateButtonPanel()
{
Assert.Inconclusive("The test must be adopted from the RI - container cannot be created because there are errors for imports satisfied by IRegionManager export.");
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Shell).Assembly));
CompositionContainer container = new CompositionContainer(catalog);
IEnumerable <object> _v1 = container.GetExportedValues <object>();
Assert.IsNotNull(_v1);
Assert.AreEqual <int>(2, _v1.Count <object>());
AutoPopulateExportedViewsBehavior behavior = container.GetExportedValue <AutoPopulateExportedViewsBehavior>();
Region region = new Region()
{
Name = RegionNames.ButtonsRegion
};
region.Behaviors.Add("", behavior);
Assert.AreEqual(1, region.Views.Cast <object>().Count());
Assert.IsTrue(region.Views.Cast <object>().Any(e => e.GetType() == typeof(ButtonsPanel)));
}
public void Execute(CompositionContainer container)
{
try
{
var providers = container.GetExportedValues <IInfoProvider>();
var location = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var root = XElement.Load(location + @"\\Config.xml");
var host = container.GetExportedValue <ISysInfoHost>();
Debug.Assert(host != null);
Tools.WriteLine($"{nameof(CurrentDiagnosticsTask)}: Collecting Diagnostics");
// Run all Info providers
var results = RunProviders(root, providers);
var result = new XElement($"SystemInfo",
new XAttribute("Date", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss")),
results);
// save XML to file
string resultFile = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location),
$"{ConfigurationManager.AppSettings["ResultDir"]}",
"Diagnostics.xml");
result.Save(resultFile);
// add XML result file to collected files
host.AddFile(resultFile, Path.GetFileName(resultFile), true);
}
catch (Exception ex)
{
_log.Error($"TASK FAILED: {ex.ToString()}.");
Tools.WriteError($"{nameof(CurrentDiagnosticsTask)}: TASK FAILED: {ex.Message}");
}
Tools.WriteLine($"{nameof(CurrentDiagnosticsTask)}: Finished successfully.", ConsoleColor.DarkGreen);
}
protected override object GetInstance(Type service, string key)
{
this.logger.Info("GetInstance {0}, {1}", service, key);
string contract = String.IsNullOrEmpty(key) ? AttributedModelServices.GetContractName(service) : key;
IEnumerable <object> exports;
try {
exports = container.GetExportedValues <object>(contract);
}
catch (System.Exception ex) {
this.logger.Error(ex);
throw;
}
if (exports.Any())
{
return(exports.First());
}
throw new ArgumentException(String.Format("Could not locate any instances of contract {0}.", contract));
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
DispatcherUnhandledException += App_OnDispatcherUnhandledException;
AppDomain.CurrentDomain.UnhandledException += AppDomain_OnUnhandledException;
_catalog = new AggregateCatalog();
_catalog.Catalogs.Add(new AssemblyCatalog(typeof(ViewModel).Assembly));
_catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
_catalog.Catalogs.Add(new AssemblyCatalog(typeof(IEntityController).Assembly));
_catalog.Catalogs.Add(new AssemblyCatalog(typeof(AppDbContext).Assembly));
_catalog.Catalogs.Add(new AssemblyCatalog(typeof(DataModelBase <>).Assembly));
_catalog.Catalogs.Add(new AssemblyCatalog(typeof(IEntityService).Assembly));
_catalog.Catalogs.Add(new AssemblyCatalog(typeof(ViewModelBase <,>).Assembly));
foreach (var assembly in AppSettings.Default.ModuleAssemblies)
{
_catalog.Catalogs.Add(new AssemblyCatalog(assembly));
}
_container = new CompositionContainer(_catalog, CompositionOptions.DisableSilentRejection);
var batch = new CompositionBatch();
batch.AddExportedValue(_container);
_container.Compose(batch);
_moduleControllers = _container.GetExportedValues <IModuleController>();
foreach (var moduleController in _moduleControllers)
{
moduleController.Initialize();
}
foreach (var moduleController in _moduleControllers)
{
moduleController.Run();
}
}
public void WhenInitializingAModuleWithACatalogPendingToBeLoaded_ThenLoadsTheCatalogInitializesTheModule()
{
var aggregateCatalog = new AggregateCatalog(new AssemblyCatalog(typeof(MefModuleInitializer).Assembly));
var compositionContainer = new CompositionContainer(aggregateCatalog);
compositionContainer.ComposeExportedValue(aggregateCatalog);
var serviceLocatorMock = new Mock<IServiceLocator>();
var loggerFacadeMock = new Mock<ILoggerFacade>();
var serviceLocator = serviceLocatorMock.Object;
var loggerFacade = loggerFacadeMock.Object;
compositionContainer.ComposeExportedValue(serviceLocator);
compositionContainer.ComposeExportedValue(loggerFacade);
var moduleInitializer = compositionContainer.GetExportedValue<IModuleInitializer>();
var repository = compositionContainer.GetExportedValue<DownloadedPartCatalogCollection>();
var moduleInfo = new ModuleInfo("TestModuleForInitializer", typeof(TestModuleForInitializer).AssemblyQualifiedName);
repository.Add(moduleInfo, new TypeCatalog(typeof(TestModuleForInitializer)));
moduleInitializer.Initialize(moduleInfo);
ComposablePartCatalog existingCatalog;
Assert.IsFalse(repository.TryGet(moduleInfo, out existingCatalog));
var module = compositionContainer.GetExportedValues<IModule>().OfType<TestModuleForInitializer>().First();
Assert.IsTrue(module.Initialized);
}
