public MainMenuViewModel(CompositionContainer container)
{
_topLevelMenuItems = new ObservableCollection<MenuItemViewModel>();
_styleSelector = new MainMenuItemStyleSelector();
var menuItemImports = container.GetExports<IMenuItem, IMenuItemMetaData>();
var globalCommandImports = container.GetExports<IGlobalCommand>();
var menuBuilder = new MenuBuilder(globalCommandImports);
foreach (var import in menuItemImports.Where(x => x.Metadata.IsMainMenuItem))
{
menuBuilder.AddItem(import.Value, import.Metadata);
}
foreach (var rootItem in menuBuilder.Build().Children)
{
MenuItemViewModel viewModel;
if (rootItem is MenuSeparatorModel)
{
viewModel = new MenuSeparatorViewModel();
}
else
{
viewModel = new MenuItemViewModel(null, rootItem.HeaderText, rootItem.Command, rootItem.GestureText, rootItem.Children);
}
_topLevelMenuItems.Add(viewModel);
}
}
/// <summary>
/// Mains the specified args.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
public static void Main(string[] args)
{
WriteSignature();
using (AggregateCatalog aggregateCatalog = new AggregateCatalog())
{
RegistrationBuilder registrationBuilder = new RegistrationBuilder();
registrationBuilder.ForTypesDerivedFrom<ICommand>()
.Export(conf => conf.AsContractName(AttributedModelServices.GetContractName(typeof(ICommand))))
.SetCreationPolicy(CreationPolicy.NonShared);
aggregateCatalog.Catalogs.Add(new ApplicationCatalog(registrationBuilder));
string appPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string pluginPath = Path.Combine(appPath, "plugins");
if (Directory.Exists(pluginPath))
aggregateCatalog.Catalogs.Add(new DirectoryCatalog(pluginPath, registrationBuilder));
using (CompositionContainer container = new CompositionContainer(aggregateCatalog))
{
ICommandProvider[] providers = container.GetExports<ICommandProvider>().Select(l => l.Value).ToArray();
Type[] commands = providers.SelectMany(p => p.GetCommands()).ToArray();
Func<Type, object> mefActivator =
t =>
{
if (!typeof(ICommand).IsAssignableFrom(t))
return DefaultActivator.Instance.CreateInstance(t);
ImportDefinition importDefinition = new ImportDefinition(ed => (string)ed.Metadata[CompositionConstants.ExportTypeIdentityMetadataName] == AttributedModelServices.GetTypeIdentity(t),
AttributedModelServices.GetContractName(typeof(ICommand)),
ImportCardinality.ExactlyOne,
false,
true);
return container.GetExports(importDefinition).First().Value;
};
ArgumentParserSettings parserSettings = new ArgumentParserSettings
{
TypeActivator = new DelegateActivator(mefActivator)
};
ArgumentParser<ICommand> argumentParser = new ArgumentParser<ICommand>(parserSettings, commands);
ICommand command;
if (argumentParser.TryParse(args, out command))
{
command.Invoke(container);
}
}
}
}
public AixmConverter()
{
List<Assembly> source = AppDomain.CurrentDomain.GetAssemblies().ToList<Assembly>();
foreach (var asm in source)
{
AssemblyCatalog catalog = new AssemblyCatalog(asm);
CompositionContainer mefContainer = new CompositionContainer(catalog, true);
var plugins = mefContainer.GetExports<Func<IAixmConverter, JObject, XElement, IEnumerable<JObject>>, IAixmConverterMetadata>().ToArray();
_elementReaders.AddRange(plugins);
_elementWriters.AddRange(mefContainer.GetExports<Action<IAixmConverter,int, JObject, XmlWriter>, IAixmConverterMetadata>().ToArray());
}
_elementWriters = _elementWriters.OrderBy(k => k.Metadata.WriteOrder).ToList();
}
/// <summary>
/// Mains the specified args.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
public static void Main(string[] args)
{
WriteSignature();
using (AggregateCatalog aggregateCatalog = new AggregateCatalog())
{
aggregateCatalog.Catalogs.Add(new ApplicationCatalog());
string appPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string pluginPath = Path.Combine(appPath, "plugins");
if (Directory.Exists(pluginPath))
aggregateCatalog.Catalogs.Add(new DirectoryCatalog(pluginPath));
using (CompositionContainer container = new CompositionContainer(aggregateCatalog))
{
ICommandProvider[] providers = container.GetExports<ICommandProvider>().Select(l => l.Value).ToArray();
var commands = providers.SelectMany(p => p.GetCommands()).ToArray();
ArgumentParser<ICommand> argumentParser = new ArgumentParser<ICommand>(commands);
ICommand command;
if (argumentParser.TryParse(args, out command))
{
command.Invoke(container);
}
}
}
}
public static void LoadContainer(IUnityContainer container, string path, string pattern)
{
var directoryCatalog = new DirectoryCatalog(path, pattern);
var importDefinition = BuildImportDefinition();
try
{
using (var aggregateCatalog = new AggregateCatalog())
{
aggregateCatalog.Catalogs.Add(directoryCatalog);
using (var componsitionContainer = new CompositionContainer(aggregateCatalog))
{
IEnumerable<Export> exports = componsitionContainer.GetExports(importDefinition);
IEnumerable<IModule> modules = exports.Select(export => export.Value as IModule).Where(m => m != null);
foreach (IModule module in modules)
{
module.Initialize(container);
}
}
}
}
catch (ReflectionTypeLoadException typeLoadException)
{
var builder = new StringBuilder();
foreach (Exception loaderException in typeLoadException.LoaderExceptions)
{
builder.AppendFormat("{0}\n", loaderException.Message);
}
throw new TypeLoadException(builder.ToString(), typeLoadException);
}
}
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");
}
public static void LoadCodecs(string path = null, string search = null) {
if (path == null)
path = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().EscapedCodeBase).LocalPath);
if (search == null)
search = "Dicom.Native*.dll";
var log = LogManager.Default.GetLogger("Dicom.Imaging.Codec");
log.Debug("Searching {path}\\{wildcard} for Dicom codecs", path, search);
var foundAnyCodecs = false;
DirectoryCatalog catalog;
try {
catalog = new DirectoryCatalog(path, search);
}
catch (Exception ex) {
log.Error("Error encountered creating new DirectCatalog({path}, {search}) - {@exception}", path, search, ex);
throw;
}
var container = new CompositionContainer(catalog);
foreach (var lazy in container.GetExports<IDicomCodec>()) {
foundAnyCodecs = true;
var codec = lazy.Value;
log.Debug("Codec: {codecName}", codec.TransferSyntax.UID.Name);
_codecs[codec.TransferSyntax] = codec;
}
if (!foundAnyCodecs) {
log.Warn("No Dicom codecs were found after searching {path}\\{wildcard}", path, search);
}
}
public TreatyHelper()
{
var catalog = new AssemblyCatalog(this.GetType().Assembly);
var container = new CompositionContainer(catalog);
this.treaties = container.GetExports<ITreatyProvider>().ToList();
}
public void WhenExportIsFiltered_ThenPartIsAvailableButNotExport()
{
var catalog = new TypeCatalog(typeof(Foo));
var filtered = new FilteringReflectionCatalog(catalog)
{
ExportFilter = export => !(export.ExportingMember.MemberType == System.Reflection.MemberTypes.Property),
};
var container = new CompositionContainer(filtered);
var exports = container.GetExports<IFoo>();
var barExports = container.GetExports<IBar>();
Assert.True(exports.Any());
Assert.False(barExports.Any());
}
/// <summary>
/// Loads all SharpShell servers from an assembly.
/// </summary>
/// <param name="path">The path to the assembly.</param>
/// <returns>A ServerEntry for each SharpShell server in the assembly.</returns>
public static IEnumerable<ServerEntry> LoadServers(string path)
{
// Storage for the servers.
var servers = new List<ServerEntry>();
try
{
// Create an assembly catalog for the assembly and a container from it.
var catalog = new AssemblyCatalog(Path.GetFullPath(path));
var container = new CompositionContainer(catalog);
// Get all exports of type ISharpShellServer.
var serverTypes = container.GetExports<ISharpShellServer>();
// Go through each servertype (creating the instance from the lazy).
foreach(var serverType in serverTypes)
{
ISharpShellServer server = null;
try
{
server = serverType.Value;
}
catch (Exception)
{
servers.Add(new ServerEntry
{
ServerName = "Invalid",
ServerPath = path,
ServerType = ServerType.None,
ClassId = new Guid(),
Server = null,
IsInvalid = true
});
continue;
}
// Yield a server entry for the server type.
servers.Add(new ServerEntry
{
ServerName = server.DisplayName,
ServerPath = path,
ServerType = server.ServerType,
ClassId = server.ServerClsid,
Server = server
});
}
}
catch (Exception)
{
// It's almost certainly not a COM server.
MessageBox.Show("The file '" + Path.GetFileName(path) + "' is not a SharpShell Server.", "Warning");
}
// Return the servers.
return servers;
}
public void FilterBasedOnMetadataUsingContainsMetadataTest()
{
var catalog = new AssemblyCatalog(typeof(FilteringCatalogTests).Assembly);
var filteredCatalog = new FilteringCatalog(catalog, new ContainsMetadata("key", "value"));
var container = new CompositionContainer(filteredCatalog);
var components = container.GetExports<IMetadataComponent>();
Assert.That(components, Is.Not.Null);
Assert.That(components.Count(), Is.EqualTo(1));
}
/// <summary>
/// The register.
/// </summary>
/// <param name="container">
/// The container.
/// </param>
public static void Register(IWindsorContainer container)
{
var catalog =
new CatalogBuilder().ForAssembly(typeof(IComponentRegistrarMarker).Assembly).ForMvcAssembly(
Assembly.GetExecutingAssembly()).ForMvcAssembliesInDirectory(HttpRuntime.BinDirectory, "Leatn*.dll")
.Build();
var compositionContainer = new CompositionContainer(catalog);
compositionContainer.GetExports<IComponentRegistrar>().ForeEach(e => e.Value.Register(container));
}
public static int Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("File Watch Directory must be specifed");
Console.WriteLine("usage: engine.exe path");
return -1;
}
try
{
// Example of convention-based approach
var registration = new RegistrationBuilder();
registration.ForType<Logger>().Export<ILogger>();
var assemblyCatalog = new AssemblyCatalog(typeof(Logger).Assembly, registration);
var catalog = new AggregateCatalog(
assemblyCatalog,
new DirectoryCatalog(@".\addins"));
using (var container = new CompositionContainer(catalog))
{
var engine = new ProcessorEngine(new DirectoryInfo(args[0]));
// Bind exports to imports
container.ComposeParts(engine);
var exports = container.GetExports<IFileProcessor, IFileProcessorMetadata>().ToList();
Console.WriteLine("{0} File Processor(s) available", exports.Count);
if (exports.Count > 0)
{
foreach (var export in exports)
{
Console.WriteLine("{0} file type supported", export.Metadata.SupportedExtension);
}
engine.ProcessFiles();
}
else
{
Console.WriteLine("Add File Processors to the Add-in directory");
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
Console.ReadLine();
return -1;
}
Console.ReadLine();
return 0;
}
public void Parts_are_filtered_based_on_shared_lifetime_using_HasCreationPolicy_filter()
{
var catalog = new AssemblyCatalog(typeof(FilteringCatalogTests).Assembly);
var filteredCatalog = new FilteringCatalog(catalog, new HasCreationPolicy(CreationPolicy.Shared));
var container = new CompositionContainer(filteredCatalog);
var components = container.GetExports<ILifetimeComponent>();
Assert.That(components, Is.Not.Null);
Assert.That(components.Count(), Is.EqualTo(1));
Assert.That(components.First().Value.GetType(), Is.EqualTo(typeof(LifetimeComponent2)));
}
public void FilterBasedOnNonSharedLifetimeUsingHasCreationPolicyTest()
{
var catalog = new AssemblyCatalog(typeof(FilteringCatalogTests).Assembly);
var filteredCatalog = new FilteringCatalog(catalog, new HasCreationPolicy(CreationPolicy.NonShared));
var container = new CompositionContainer(filteredCatalog);
var components = container.GetExports<ILifetimeComponent>();
Assert.That(components, Is.Not.Null);
Assert.That(components.Count(), Is.EqualTo(1));
Assert.That(components.First().Value.GetType(), Is.EqualTo(typeof(LifetimeComponent3)));
}
public void FilterBasedOnAnyLifetimeUsingHasCreationPolicyTest()
{
var catalog = new AssemblyCatalog(typeof(FilteringCatalogTests).Assembly);
var filteredCatalog = new FilteringCatalog(catalog, new HasCreationPolicy(CreationPolicy.Any));
var container = new CompositionContainer(filteredCatalog);
var components = container.GetExports<ILifetimeComponent>();
Assert.That(components, Is.Not.Null);
Assert.That(components.Count(), Is.EqualTo(2));
Assert.That(components.Select(t => t.Value).OfType<LifetimeComponent1>().First().GetType(), Is.EqualTo(typeof(LifetimeComponent1)));
Assert.That(components.Select(t => t.Value).OfType<LifetimeComponent4>().First().GetType(), Is.EqualTo(typeof(LifetimeComponent4)));
}
public void FilterBasedOnMetadataUsingLambdaExpressionTest()
{
var catalog = new AssemblyCatalog(typeof(FilteringCatalogTests).Assembly);
var filteredCatalog = new FilteringCatalog(catalog,
partDefinition => partDefinition.Metadata.ContainsKey("key") &&
partDefinition.Metadata["key"].Equals("value"));
var container = new CompositionContainer(filteredCatalog);
var components = container.GetExports<IMetadataComponent>();
Assert.That(components, Is.Not.Null);
Assert.That(components.Count(), Is.EqualTo(1));
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.White;
AppDomain.CurrentDomain.AssemblyLoad += new AssemblyLoadEventHandler(CurrentDomain_AssemblyLoad);
ComposablePartCatalog catalog = CatalogServices.GetCatalog();
var container = new CompositionContainer(catalog);
var pluginExports = container.GetExports<IPlugin, IPluginMetadata>();
ShowPluginMetadata(pluginExports);
CreatePluginInstances(pluginExports);
Console.Read();
}
public static void Initialise()
{
var catalog = new CatalogBuilder()
.ForAssembly(typeof(IComponentRegistrarMarker).Assembly)
.ForMvcAssembly(Assembly.GetExecutingAssembly())
.ForMvcAssembliesInDirectory(HttpRuntime.BinDirectory, "Leatn*.dll") // Won't work in Partial trust
.Build();
var compositionContainer = new CompositionContainer(catalog);
compositionContainer.GetExports<IComponentInitialiser>()
.ForeEach(e => e.Value.Initialise());
}
private void OnApplicationLoaded(ApplicationLoadedMessage msg)
{
var catalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
_container = new CompositionContainer(catalog);
_container.ComposeParts(this);
var moduleContainers = _container.GetExports<IModuleContainer>();
foreach (var module in moduleContainers.SelectMany(mc => mc.Value.GetModules()))
{
_bus.SendMessage(new ModuleLoadedMessage(module));
}
}
public StatSet(Character character)
{
stats = new Dictionary<string, IStat>();
using(var container = new CompositionContainer(new AssemblyCatalog(typeof(StatSet).Assembly)))
{
foreach(var val in container.GetExports<Retriever>())
{
var method = val.Value;
var name = method.Method.Name;
var stat = new DynamicStat(method, character);
stats[name] = stat;
}
}
}
/// <summary>
/// Runs the task.
/// </summary>
/// <param name="container"></param>
public void Run(CompositionContainer container)
{
Throw.IfArgumentNull(container, "container");
var registrars = container
.GetExports<IRouteRegistrar, IOrderedMetadata>()
.OrderBy(r => r.Metadata.Order)
.Select(r => r.Value);
var routes = RouteTable.Routes;
foreach (var registrar in registrars)
registrar.RegisterRoutes(routes);
}
public static Assembly DiscoverMigrationAssembly() {
var catalog = new DirectoryCatalog(AppDomain.CurrentDomain.BaseDirectory);
var container = new CompositionContainer(catalog);
var migrations = container.GetExports<IMigration, IMigrationCapabilities>();
var assembliesWithMigrations = (from m in migrations
select m.Value.GetType().Assembly).Distinct();
if (assembliesWithMigrations.Count() > 1) {
throw new ApplicationException("Multiple assembly migrations are not supported.");
} else if(assembliesWithMigrations.Count() == 0) {
throw new ApplicationException("No migration assemblies were found");
} else {
return assembliesWithMigrations.First();
}
}
public void ImportAll(out IReadOnlyCollection<ImportedMigration> migrations, out IReadOnlyCollection<ImportedAggregateMigration> aggregateMigrations)
{
Log.Info("Importing migrations...");
DateTime start = DateTime.Now;
var container = new CompositionContainer(_catalog);
IEnumerable<Lazy<IMigration, IMigrationExportMetadata>> migrationExports = container.GetExports<IMigration, IMigrationExportMetadata>();
IEnumerable<Lazy<IMigration, IAggregateMigrationExportMetadata>> aggregateMigrationExports = container.GetExports<IMigration, IAggregateMigrationExportMetadata>(AggregateMigrationExportAttribute.ContractName);
migrations = migrationExports
.Select(l =>
{
var timestamp = ExtractTimestamp(l.Metadata.ModuleName, l.Value);
var migrationMetadata = new MigrationMetadata(timestamp, l.Metadata.ModuleName, l.Metadata.Tag);
return new ImportedMigration(l.Value, migrationMetadata, l.Metadata.UseModuleNameAsDefaultSchema);
}).ToList();
aggregateMigrations = aggregateMigrationExports
.Select(l =>
{
var timestamp = ExtractTimestamp(l.Metadata.ModuleName, l.Value);
var aggregateMigrationMetadata = new AggregateMigrationMetadata(timestamp, l.Metadata.ModuleName);
return new ImportedAggregateMigration(l.Value, aggregateMigrationMetadata);
}).ToList();
Log.Verbose(LogCategory.Performance, "Importing migrations took {0}s", (DateTime.Now - start).TotalSeconds);
Log.Info("Found {0} migration(s) and {1} aggregate migration(s)", migrations.Count, aggregateMigrations.Count);
}
public Parser()
{
if (_container == null)
{
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Parser).Assembly));
_container = new CompositionContainer(catalog);
_container.ComposeParts(this);
tags = _container.GetExports<IBBCode, IBBCodeData>();
}
}
public void WhenPartIsFiltered_ThenItsExportCannotBeRetrieved()
{
var catalog = new TypeCatalog(typeof(Foo));
var filtered = new FilteringReflectionCatalog(catalog)
{
//PartFilter = part => part.PartType != typeof(Foo),
PartFilter = part => part.PartDefinition.Metadata.ContainsKey("IsPublic"),
};
var container = new CompositionContainer(filtered);
var exports = container.GetExports<IFoo>();
Assert.False(exports.Any());
}
public static void LoadCodecs(string path = null, string search = null) {
if (path == null)
path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var log = LogManager.GetLogger("Dicom.Imaging.Codec");
var catalog = (search == null) ?
new DirectoryCatalog(path) :
new DirectoryCatalog(path, search);
var container = new CompositionContainer(catalog);
foreach (var lazy in container.GetExports<IDicomCodec>()) {
var codec = lazy.Value;
log.Debug("Codec: {0}", codec.TransferSyntax.UID.Name);
_codecs[codec.TransferSyntax] = codec;
}
}
public IProjectRule[] LoadRules()
{
Console.Out.WriteLine("INFO: Scanning for rules...");
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new DirectoryCatalog("."));
var container = new CompositionContainer(catalog);
var rules = container.GetExports<IProjectRule>().Select(x => x.Value).ToArray();
foreach (var rule in rules)
{
Console.Out.WriteLine("INFO: Rule {0} found.", rule.Id);
}
Console.Out.WriteLine("INFO: Scanning for rules finished! Rules found: {0}", rules.Count());
return rules.ToArray();
}
public static void LoadContainer(
ApplicationParameters parameters, IUnityContainer container, string path, string pattern)
{
var importDef = BuildImportDefinition();
using (var dirCat = new DirectoryCatalog(path, pattern))
using (var aggregateCatalog = new AggregateCatalog())
{
aggregateCatalog.Catalogs.Add(dirCat);
using (var componsitionContainer = new CompositionContainer(aggregateCatalog))
{
var modules = componsitionContainer.GetExports(importDef).Select(e => e.Value).OfType<IModule>();
var registrar = new ModuleRegistrar(container);
foreach (var module in modules)
{
module.Initialize(parameters, registrar);
}
}
}
}
public void PartAddedTwice_AppearsTwice()
{
// You probably shouldn't be adding a part to the container twice, but it's not something we're going to check for and throw an exception on
var container = new CompositionContainer();
var disposable = new AnyPartDisposable();
var part = AttributedModelServices.CreatePart(disposable);
var batch = new CompositionBatch();
batch.AddPart(part);
container.Compose(batch);
batch = new CompositionBatch();
batch.AddPart(part);
container.Compose(batch);
var exports = container.GetExports<AnyPartDisposable>();
Assert.AreEqual(2, exports.Count());
container.Dispose();
}