/// <summary>
/// Perform the bootstrapping of all configured services.
/// </summary>
/// <returns>Collection of generated notifications.</returns>
public IEnumerable <BootstrapperNotification> Bootstrapp()
{
if (useMef)
{
using (var container = new ContainerConfiguration()
.WithParts(ReflectionTools.GetAllTypes())
.CreateContainer())
{
MEFServices = container.GetExports <IBootstrapperService>();
}
}
BootstrappServices(useMef ? MEFServices : RegisteredServices);
if (throwExceptionOnErrorNotif && notifications.Any(n => n.Type == BootstrapperNotificationType.Error))
{
throw new BootstrappingException(notifications);
}
if (OnPostBootstrapping != null)
{
OnPostBootstrapping(new PostBootstrappingContext
{
Notifications = notifications,
Scope = DIManager.IsInit ? DIManager.BeginScope() : null
});
OnPostBootstrapping = null; //Unsubscribe all
}
return(notifications.AsEnumerable());
}
static ExtensionContainerBase()
{
var assemblies = new DirectoryInfo(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
"AudioWorks",
"Extensions",
RuntimeChecker.GetShortFolderName()))
.GetDirectories()
.SelectMany(extensionDir => extensionDir.GetFiles("AudioWorks.Extensions.*.dll"))
.Select(fileInfo => new ExtensionAssemblyResolver(fileInfo.FullName).Assembly)
.ToList();
var logger = LoggerManager.LoggerFactory.CreateLogger <ExtensionContainerBase>();
logger.LogDebug("Discovered {0} extension assemblies.", assemblies.Count);
// Remove any extension assemblies that can't have prerequisites handled automatically
using (var unvalidatedContainer = new ContainerConfiguration().WithAssemblies(assemblies).CreateContainer())
foreach (var handler in unvalidatedContainer.GetExports <IPrerequisiteHandler>())
{
if (!handler.Handle())
{
var validatorAssembly = handler.GetType().Assembly;
logger.LogDebug("Extension assembly {0} failed prerequisite check. Removing.",
validatorAssembly.FullName);
assemblies.RemoveAll(assembly =>
assembly.Location.Equals(validatorAssembly.Location, StringComparison.OrdinalIgnoreCase));
}
}
CompositionHost = new ContainerConfiguration()
.WithAssemblies(assemblies).CreateContainer();
}
public void Many()
{
var types = new[] { typeof(Implemented), typeof(AnotherImplemented) }.AsApplicationParts();
var container = new ContainerConfiguration().WithParts( types.AsEnumerable() ).WithProvider( SingletonExportDescriptorProvider.Default ).CreateContainer();
var exports = container.GetExports<ISingleton>().Fixed();
Assert.Contains( Implemented.Default, exports );
Assert.Contains( AnotherImplemented.Default, exports );
}
/// <summary>
/// Inicializa los datos
/// </summary>
public void Initialize(List <string> pathPlugins, string extensionPlugins = ".plugin.dll")
{
// Crea el contenedor
Container = new ContainerConfiguration().WithAssemblies(GetPluginsAssemblies(pathPlugins, NormalizeExtension(extensionPlugins)),
GetConventionsBuilder()).CreateContainer();
// Obtiene el manager de plugins
Plugins = Container.GetExports <TypePlugin>().ToList();
}
private GallerySourceHost()
{
var host = new ContainerConfiguration()
.WithAssembly(typeof(GallerySourceHost).GetTypeInfo().Assembly)
.CreateContainer();
Sources = host.GetExports <IGallery>().ToArray();
}
// Re-run this method with TD.NET AdHoc runner to regenerate CodeFixNames.g.cs as needed.
public void GenerateCodeFixNames()
{
var composition = new ContainerConfiguration()
.WithAssemblies(MefHostServices
.DefaultAssemblies
.Add(typeof(CodeFixNamesGenerator).Assembly))
.CreateContainer();
var providers = composition.GetExports <Lazy <CodeFixProvider, CodeChangeProviderMetadata> >();
var allFixes = new HashSet <string>();
var codeFixes = new Dictionary <string, HashSet <string> >
{
{ "All", allFixes }
};
foreach (var provider in providers.Where(x => !string.IsNullOrEmpty(x.Metadata.Name)))
{
foreach (var language in provider.Metadata.Languages)
{
if (!codeFixes.ContainsKey(language))
{
codeFixes.Add(language, new HashSet <string>());
}
codeFixes[language].Add(provider.Metadata.Name);
allFixes.Add(provider.Metadata.Name);
}
}
var ns = NamespaceDeclaration(ParseName("Stunts.Processors"))
.AddMembers(ClassDeclaration("CodeFixNames")
.WithModifiers(TokenList(Token(SyntaxKind.PartialKeyword)))
.WithMembers(List <MemberDeclarationSyntax>(codeFixes.Select(lang
=> ClassDeclaration(lang.Key.Replace(" ", "").Replace("#", "Sharp"))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword), Token(SyntaxKind.PartialKeyword)))
.WithMembers(List <MemberDeclarationSyntax>(lang.Value.OrderBy(x => x).Select(fix
=> FieldDeclaration(VariableDeclaration(
PredefinedType(Token(SyntaxKind.StringKeyword)),
SeparatedList(new[] {
VariableDeclarator(fix.Replace(" ", ""))
.WithInitializer(EqualsValueClause(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(fix))))
})
))
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.ConstKeyword)))
)
))
))
)
);
using (var output = new StreamWriter(@"..\..\..\Stunts.Sdk\Processors\CodeFixNames.g.cs", false))
{
ns.NormalizeWhitespace().WriteTo(output);
}
}
public void CreateContainer_ExportsToInheritedProperties_DontInterfereWithBase()
{
var conventions = new ConventionBuilder();
conventions.ForType <DerivedFromBaseWithExport2>()
.ExportProperty(b => b.Exported);
CompositionHost container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(BaseWithExport2))
.WithParts(typeof(DerivedFromBaseWithExport2))
.CreateContainer();
Assert.Equal(new string[] { "A", "A" }, container.GetExports <string>());
}
public void ConventionsCanApplyExportsToInheritedPropertiesWithoutInterferingWithBase()
{
var conventions = new ConventionBuilder();
conventions.ForType <DerivedFromBaseWithExport2>()
.ExportProperty(b => b.Exported);
var container = new ContainerConfiguration()
.WithDefaultConventions(conventions)
.WithParts(typeof(BaseWithExport2))
.WithParts(typeof(DerivedFromBaseWithExport2))
.CreateContainer();
var s = container.GetExports <string>();
Assert.Equal(2, s.Count());
}
/// <summary>
/// Try get an instance from a specific assembly
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="assembly">The assembly.</param>
/// <param name="name">The name.</param>
/// <param name="instance">The instance.</param>
/// <returns></returns>
public static bool TryGetInstance <T>(Assembly assembly, string name, out T instance)
where T : class
{
//Load container
using (var container = new ContainerConfiguration().WithAssembly(assembly).CreateContainer())
{
//Try to get instance
var exports = container.GetExports(typeof(T)).ToArray();
var foundinstance = exports.FirstOrDefault(x => x.GetType().FullName == name) ?? exports.FirstOrDefault(x => x.GetType().Name == name);
if (foundinstance != null)
{
instance = foundinstance as T;
return(true);
}
else
{
instance = null;
return(false);
}
}
}
private void Compose()
{
using var container = new ContainerConfiguration().WithAssemblies(GetAssemblies()).CreateContainer();
Commands = container.GetExports <ICommand>().ToList();
}
