public static CompositionBatch AddValue <TContract>(this CompositionBatch batch, TContract value)
{
string contractName = AttributedModelServices.GetContractName(typeof(TContract));
return(batch.AddValue(contractName, value));
}
public void CreatePart_ObjectInstance_ShouldProduceSharedPart()
{
var part = AttributedModelServices.CreatePart(typeof(MyExport));
Assert.Equal(CreationPolicy.Shared, part.Metadata.GetValue <CreationPolicy>(CompositionConstants.PartCreationPolicyMetadataName));
}
/// <summary>
/// GetServices
/// </summary>
/// <param name="serviceType"></param>
/// <returns></returns>
public IEnumerable <object> GetServices(Type serviceType)
{
return(Container.GetExportedValues <object>(AttributedModelServices.GetContractName(serviceType)));
}
protected override IEnumerable <object> DoGetAllInstances(Type serviceType)
{
var exports = provider.GetExportedValues <object>(AttributedModelServices.GetContractName(serviceType));
return(exports);
}
private static string[] GetDisplayNames(IEnumerable <Type> types)
{
return(GetDisplayNames(types.Select(t => AttributedModelServices.CreatePartDefinition(t, null))));
}
/// <summary>
/// Registers a type with the export provider.
/// </summary>
/// <param name="type">The type to register.</param>
public void RegisterType(Type type)
{
contractMapping.Add(AttributedModelServices.GetContractName(type), type);
}
/// <summary>
/// Export the component under typed contract <typeparamref name="TContract"/>.
/// </summary>
/// <typeparam name="TContract">Contract type.</typeparam>
/// <returns>Builder for additional configuration.</returns>
public ExportConfigurationBuilder As <TContract>()
{
WithMetadata(CompositionConstants.ExportTypeIdentityMetadataName, AttributedModelServices.GetTypeIdentity(typeof(TContract)));
ContractName = AttributedModelServices.GetContractName(typeof(TContract));
return(this);
}
/// <summary>
/// Locate all of the MEF exports registered as supplying contract type T.
/// </summary>
/// <typeparam name="T">The contract type.</typeparam>
/// <param name="context">The context to resolve exports from.</param>
/// <returns>A list of exports.</returns>
public static IEnumerable <Export> ResolveExports <T>(this IComponentContext context)
{
return(context.ResolveExports <T>(AttributedModelServices.GetContractName(typeof(T))));
}
public static IEnumerable <Lazy <T, TMetadata> > GetAllInstances <T, TMetadata>(string key = null)
{
var contract = string.IsNullOrEmpty(key) ? AttributedModelServices.GetContractName(typeof(T)) : key;
return(container.GetExports <T, TMetadata>(contract));
}
public ExportToSettingsAttribute(Type contractType)
: base(AttributedModelServices.GetContractName(contractType), typeof(ISettings))
{
}
public static void RegisterType(this CompositionContainer container, Type interfaceType, Type implementingType)
{
string key = AttributedModelServices.GetContractName(interfaceType);
container.ComposeExportedValue(key, Activator.CreateInstance(implementingType));
}
/// <summary>
/// Exports the class to the SettingsRoot.
/// </summary>
public ExportToSettingsAttribute()
: base(AttributedModelServices.GetContractName(typeof(SettingsRoot)), typeof(ISettings))
{
}
public object GetType(Type type)
{
var contractName = AttributedModelServices.GetContractName(type);
return(_container.GetExportedValueOrDefault <object>(contractName));
}
protected virtual IEnumerable <object> GetInstances(System.Type type)
{
var contractName = AttributedModelServices.GetContractName(type);
return(this.container.GetExportedValues <object>(contractName));
}
public MefSubstituteBuilder AddValueFactory <T1, T2, T3, T4, TValue>(string contractName, Func <T1, T2, T3, T4, TValue> valueFactory)
{
return(AddValueFactory(contractName, AttributedModelServices.CreatePartDefinition(typeof(ImportStub <T1, T2, T3, T4>), null), typeof(TValue), valueFactory));
}
// Protected Methods (2)
/// <summary>
///
/// </summary>
/// <see cref="ServiceLocatorBase.OnGetAllInstances(Type)" />
protected override IEnumerable <object> OnGetAllInstances(Type serviceType)
{
return(this._PROVIDER
.GetExportedValues <object>(AttributedModelServices.GetContractName(serviceType)));
}
static ExportServiceHostProvider()
{
MatchContractName = AttributedModelServices.GetContractName(typeof(ExportServiceHost <T>));
}
public static ComposablePart CreateAttributed(object instance)
{
return(AttributedModelServices.CreatePart(instance));
}
/// <summary>
/// Builds the given parameter.
/// </summary>
/// <param name="parameter"></param>
/// <param name="builder"></param>
void BuildParameter(ParameterInfo parameter, ImportBuilder builder)
{
Debug.Assert(parameter != null);
Debug.Assert(builder != null);
var name = parameter.ParameterType.FullName;
{
// decides whether the parameter is attempting to import many items
Type importManyType = null;
if (parameter.ParameterType.IsGenericType &&
parameter.ParameterType.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
importManyType = parameter.ParameterType.GetGenericArguments()[0];
}
if (parameter.ParameterType.IsGenericType &&
parameter.ParameterType.GetGenericTypeDefinition() == typeof(ICollection <>))
{
importManyType = parameter.ParameterType.GetGenericArguments()[0];
}
if (parameter.ParameterType.IsArray)
{
importManyType = parameter.ParameterType.GetElementType();
}
if (importManyType != null)
{
builder.AsContractType(importManyType);
builder.AsMany(true);
builder.AllowDefault();
return;
}
}
{
// decides whether the parameter is attempting to import a Func<T>; essentially an ExportFactory
Type funcType = null;
if (parameter.ParameterType.IsGenericType &&
parameter.ParameterType.GetGenericArguments().Length == 1 &&
parameter.ParameterType.GetGenericTypeDefinition() == typeof(Func <>))
{
funcType = parameter.ParameterType.GetGenericArguments()[0];
}
if (funcType != null)
{
// import a Func generated by our FuncFactory
var contractType = typeof(Func <>).MakeGenericType(funcType);
var contractName = "FuncFactory:" + AttributedModelServices.GetContractName(typeof(Func <>));
builder.AsContractType(contractType);
builder.AsContractName(contractName);
builder.AsMany(false);
builder.AllowDefault();
return;
}
}
// fall back to normal method
builder.AsContractType(parameter.ParameterType);
builder.AsMany(false);
return;
}
public static ImportingComposablePart CreateImporter <T>()
{
string contractName = AttributedModelServices.GetContractName(typeof(T));
return(CreateImporter(contractName));
}
private ComposablePartDefinition CreatePartDefinition(Type type)
{
ComposablePartDefinition partDefinition = AttributedModelServices.CreatePartDefinition(type, null);
return(this.CreateWrapped(partDefinition, type));
}
protected override object GetInstance(Type serviceType, string key)
{
string contract = string.IsNullOrEmpty(key) ? AttributedModelServices.GetContractName(serviceType) : key;
return(_container.GetExportedValue <object>(contract));
}
/// <summary>
/// Extension method to searches the composition container for an export that has a matching type name. This function
/// will first try to match on Type.AssemblyQualifiedName, then Type.FullName, and finally on Type.Name
///
/// This method will not throw if multiple types are found matching the name, it will just return the first one it finds.
/// </summary>
/// <typeparam name="T">The type of the export</typeparam>
/// <param name="typeName">The name of the type to find. This can be an assembly qualified name, a full name, or just the type's name</param>
/// <returns>The export instance</returns>
public T GetExportedValueByTypeName <T>(string typeName)
where T : class
{
try
{
lock (_exportedValuesLockObject)
{
T instance;
IEnumerable values;
var type = typeof(T);
if (_exportedValues.TryGetValue(type, out values))
{
// if we've alread loaded this part, then just return the same one
instance = values.OfType <T>().FirstOrDefault(x => x.GetType().MatchesTypeName(typeName));
if (instance != null)
{
return(instance);
}
}
// we want to get the requested part without instantiating each one of that type
var selectedPart = _compositionContainer.Catalog.Parts
.Select(x => new { part = x, Type = ReflectionModelServices.GetPartType(x).Value })
.Where(x => type.IsAssignableFrom(x.Type))
.Where(x => x.Type.MatchesTypeName(typeName))
.Select(x => x.part)
.FirstOrDefault();
if (selectedPart == null)
{
throw new ArgumentException(
"Unable to locate any exports matching the requested typeName: " + typeName, "typeName");
}
var exportDefinition =
selectedPart.ExportDefinitions.First(
x => x.ContractName == AttributedModelServices.GetContractName(type));
instance = (T)selectedPart.CreatePart().GetExportedValue(exportDefinition);
var exportedParts = instance.GetType().GetInterfaces()
.Where(interfaceType => interfaceType.GetCustomAttribute <InheritedExportAttribute>() != null);
foreach (var export in exportedParts)
{
var exportList = _exportedValues.SingleOrDefault(kvp => kvp.Key == export).Value;
// cache the new value for next time
if (exportList == null)
{
var list = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(export));
list.Add(instance);
_exportedValues[export] = list;
}
else
{
((IList)exportList).Add(instance);
}
}
return(instance);
}
}
catch (ReflectionTypeLoadException err)
{
foreach (var exception in err.LoaderExceptions)
{
Log.Error(exception);
Log.Error(exception.ToString());
}
if (err.InnerException != null)
{
Log.Error(err.InnerException);
}
throw;
}
}
private object GetServiceFromCompositionContainer(Type type)
{
var contract = AttributedModelServices.GetContractName(type);
return(_compositionContainer.GetExportedValueOrDefault <object>(contract));
}
public static ImportDefinition Create(Type contractType, ImportCardinality cardinality)
{
return(Create(AttributedModelServices.GetContractName(contractType), cardinality));
}
/// <summary>
/// Extension method to searches the composition container for an export that has a matching type name. This function
/// will first try to match on Type.AssemblyQualifiedName, then Type.FullName, and finally on Type.Name
///
/// This method will not throw if multiple types are found matching the name, it will just return the first one it finds.
/// </summary>
/// <typeparam name="T">The type of the export</typeparam>
/// <param name="typeName">The name of the type to find. This can be an assembly qualified name, a full name, or just the type's name</param>
/// <returns>The export instance</returns>
public T GetExportedValueByTypeName <T>(string typeName)
where T : class
{
lock (_exportedValuesLockObject)
{
T instance;
IEnumerable values;
var type = typeof(T);
if (_exportedValues.TryGetValue(type, out values))
{
// if we've alread loaded this part, then just reserve the same one
instance = values.OfType <T>().FirstOrDefault(x => x.GetType().MatchesTypeName(typeName));
if (instance != null)
{
return(instance);
}
}
// we want to get the requested part without instantiating each one of that type
var selectedPart = _compositionContainer.Catalog.Parts
.Select(x => new { part = x, Type = ReflectionModelServices.GetPartType(x).Value })
.Where(x => type.IsAssignableFrom(x.Type))
.Where(x => x.Type.MatchesTypeName(typeName))
.Select(x => x.part)
.FirstOrDefault();
if (selectedPart == null)
{
throw new ArgumentException("Unable to locate any exports matching the requested typeName: " + typeName, "typeName");
}
var exportDefinition = selectedPart.ExportDefinitions.First(x => x.ContractName == AttributedModelServices.GetContractName(type));
instance = (T)selectedPart.CreatePart().GetExportedValue(exportDefinition);
// cache the new value for next time
if (values == null)
{
values = new List <T> {
instance
};
_exportedValues[type] = values;
}
else
{
((List <T>)values).Add(instance);
}
return(instance);
}
}
/// <summary>
/// GetService
/// </summary>
/// <param name="serviceType"></param>
/// <returns></returns>
public object GetService(Type serviceType)
{
string contractName = AttributedModelServices.GetContractName(serviceType);
return(Container.GetExportedValueOrDefault <object>(contractName));
}
public LooseMetadataLazy(Func <T> factory, IDictionary <string, object> looseMetadata)
: base(factory, AttributedModelServices.GetMetadataView <TMetadata>(looseMetadata))
{
LooseMetadata = looseMetadata;
}
protected override IEnumerable <object> GetAllInstances(Type serviceType)
{
return(container.GetExportedValues <object>(AttributedModelServices.GetContractName(serviceType)));
}
/// <summary>
/// Creates a catalog for the contract specified by the given type.
/// </summary>
public DecoratorChainCatalog(Type contract)
: this(AttributedModelServices.GetContractName(contract))
{
}