/// <summary>
/// Configurates the specified export provider.
/// </summary>
/// <param name="exportProvider">The export provider.</param>
/// <param name="loggerFactoryName">Name of the logger factory.</param>
/// <exception cref="System.ArgumentNullException">exportProvider</exception>
public static void Configurate(ExportProvider exportProvider, string loggerFactoryName = null)
{
if (exportProvider == null)
throw new ArgumentNullException("exportProvider");
var lazyLogFactory = exportProvider.GetExports<ILoggerFactory, ILoggerFactoryMetadata>()
.Where(f => string.IsNullOrEmpty(loggerFactoryName) || f.Metadata.Name.Equals(loggerFactoryName, StringComparison.OrdinalIgnoreCase))
.OrderBy(f => f.Metadata.Priority)
.FirstOrDefault();
if (lazyLogFactory == null)
return;
var metadata = lazyLogFactory.Metadata;
var configFiles = new List<string>();
if (!string.IsNullOrEmpty(metadata.ConfigFileName))
{
configFiles.Add(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, metadata.ConfigFileName));
configFiles.Add(Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Config"), metadata.ConfigFileName));
}
var facotry = lazyLogFactory.Value;
if (!facotry.Initialize(configFiles.ToArray()))
return;
m_Current = facotry;
}
/// <summary>
/// Resolves an collection of objects wrapped inside <see cref="Lazy{T}"/>
/// from an <see cref="ExportProvider"/>.
/// </summary>
/// <param name="exportProvider">Export provider.</param>
/// <param name="type">Type to be resolved.</param>
/// <param name="name">Optional name.</param>
/// <returns>Resolved collection of lazy instances or null, if no instance has been found.</returns>
/// <remarks>
/// Does not resolve instances which are provided by means of
/// <see cref="FactoryExportProvider"/>.
/// </remarks>
public static IEnumerable<Lazy<object>> ResolveAll(ExportProvider exportProvider, Type type, string name)
{
if (exportProvider == null)
{
throw new ArgumentNullException("exportProvider");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
var exports = exportProvider.GetExports(type, null, name);
if (exports.Count() == 0)
return Enumerable.Empty<Lazy<object>>();
var list = new List<Lazy<object>>();
foreach (var export in exports)
{
var lazyExportMetadata = export.Metadata as IDictionary<string, object>;
if (lazyExportMetadata != null &&
lazyExportMetadata.ContainsKey(FactoryExportDefinition.IsFactoryExportMetadataName) &&
true.Equals(lazyExportMetadata[FactoryExportDefinition.IsFactoryExportMetadataName]))
{
continue;
}
list.Add(export);
}
return list;
}
/// <summary>
/// Resolves an object wrapped inside <see cref="Lazy{T}"/> from an <see cref="ExportProvider"/>.
/// </summary>
/// <param name="exportProvider">Export provider.</param>
/// <param name="type">Type to be resolved.</param>
/// <param name="name">Optional name.</param>
/// <returns>Resolved instance or null, if no instance has been found.</returns>
/// <remarks>
/// Does not resolve instances which are provided by means of
/// <see cref="FactoryExportProvider"/>.
/// </remarks>
public static Lazy<object> Resolve(ExportProvider exportProvider, Type type, string name)
{
if (exportProvider == null)
{
throw new ArgumentNullException("exportProvider");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
var exports = exportProvider.GetExports(type, null, name);
if (exports.Count() == 0)
return null;
if (exports.Count() > 1)
throw new ImportCardinalityMismatchException(Resources.TooManyInstances);
var lazyExport = exports.First();
var lazyExportMetadata = lazyExport.Metadata as IDictionary<string, object>;
if (lazyExportMetadata != null &&
lazyExportMetadata.ContainsKey(FactoryExportDefinition.IsFactoryExportMetadataName) &&
true.Equals(lazyExportMetadata[FactoryExportDefinition.IsFactoryExportMetadataName]))
{
return null;
}
return lazyExport;
}
private static CompositionResult <IEnumerable <Export> > TryGetExports(ExportProvider provider,
ComposablePart part, ImportDefinition definition, AtomicComposition atomicComposition)
{
try
{
IEnumerable <Export> exports = null;
if (provider != null)
{
exports = provider.GetExports(definition, atomicComposition).AsArray();
}
return(new CompositionResult <IEnumerable <Export> >(exports));
}
catch (ImportCardinalityMismatchException ex)
{
// Either not enough or too many exports that match the definition
CompositionException exception = new CompositionException(ErrorBuilder.CreateImportCardinalityMismatch(ex, definition));
return(new CompositionResult <IEnumerable <Export> >(
ErrorBuilder.CreatePartCannotSetImport(part, definition, exception)));
}
}
/// <summary>
/// Resolves an object wrapped inside <see cref="Lazy{T}"/> from an <see cref="ExportProvider"/>.
/// </summary>
/// <param name="exportProvider">Export provider.</param>
/// <param name="type">Type to be resolved.</param>
/// <param name="name">Optional name.</param>
/// <returns>Resolved instance or null, if no instance has been found.</returns>
/// <remarks>
/// Does not resolve instances which are provided by means of
/// <see cref="RegistrationBasedFactoryExportProvider"/>.
/// </remarks>
public static Lazy<object> Resolve(ExportProvider exportProvider, Type type, string name)
{
var exports = exportProvider.GetExports(type, null, name);
if (exports.Count() == 0)
return null;
if (exports.Count() > 1)
throw new ImportCardinalityMismatchException(Resources.TooManyInstances);
var lazyExport = exports.First();
var lazyExportMetadata = lazyExport.Metadata as IDictionary<string, object>;
if (lazyExportMetadata != null &&
lazyExportMetadata.ContainsKey(ExporterConstants.IsContractBasedExportMetadataName) &&
true.Equals(lazyExportMetadata[ExporterConstants.IsContractBasedExportMetadataName]))
{
return null;
}
return lazyExport;
}
/// <summary>
/// Resolves an collection of objects wrapped inside <see cref="Lazy{T}"/>
/// from an <see cref="ExportProvider"/>.
/// </summary>
/// <param name="exportProvider">Export provider.</param>
/// <param name="type">Type to be resolved.</param>
/// <param name="name">Optional name.</param>
/// <returns>Resolved collection of lazy instances or null, if no instance has been found.</returns>
/// <remarks>
/// Does not resolve instances which are provided by means of
/// <see cref="RegistrationBasedFactoryExportProvider"/>.
/// </remarks>
public static IEnumerable<Lazy<object>> ResolveAll(ExportProvider exportProvider, Type type, string name)
{
var exports = exportProvider.GetExports(type, null, name);
if (exports.Count() == 0)
return Enumerable.Empty<Lazy<object>>();
var list = new List<Lazy<object>>();
foreach (var export in exports)
{
var lazyExportMetadata = export.Metadata as IDictionary<string, object>;
if (lazyExportMetadata != null &&
lazyExportMetadata.ContainsKey(ExporterConstants.IsContractBasedExportMetadataName) &&
true.Equals(lazyExportMetadata[ExporterConstants.IsContractBasedExportMetadataName]))
{
continue;
}
list.Add(export);
}
return list;
}
static ImportDefinitionInfo AnalyzeImportDefinition(ExportProvider host, IEnumerable<PartDefinitionInfo> availableParts, ImportDefinition id)
{
IEnumerable<ExportDefinition> actuals = Enumerable.Empty<ExportDefinition>();
Exception exception = null;
IEnumerable<UnsuitableExportDefinitionInfo> unsuitableExportDefinitions =
Enumerable.Empty<UnsuitableExportDefinitionInfo>();
try
{
actuals = host.GetExports(id).Select(e => e.Definition).ToArray();
}
catch (Exception ex)
{
exception = ex;
}
var cbid = id as ContractBasedImportDefinition;
if (cbid != null)
{
unsuitableExportDefinitions =
(from pd in availableParts
from ed in pd.PartDefinition.ExportDefinitions
where ed.ContractName == cbid.ContractName &&
!actuals.Contains(ed)
select new UnsuitableExportDefinitionInfo(cbid, ed, pd)).ToArray();
}
return new ImportDefinitionInfo(id, exception, actuals, unsuitableExportDefinitions);
}
private static CompositionResult<IEnumerable<Export>> TryGetExports(ExportProvider provider,
ComposablePart part, ImportDefinition definition, AtomicComposition atomicComposition)
{
try
{
var exports = provider.GetExports(definition, atomicComposition).AsArray();
return new CompositionResult<IEnumerable<Export>>(exports);
}
catch (ImportCardinalityMismatchException ex)
{
// Either not enough or too many exports that match the definition
CompositionException exception = new CompositionException(ErrorBuilder.CreateImportCardinalityMismatch(ex, definition));
return new CompositionResult<IEnumerable<Export>>(
ErrorBuilder.CreatePartCannotSetImport(part, definition, exception));
}
}
