/// <summary>
/// Recupera o valor exportado.
/// </summary>
/// <param name="definition"></param>
/// <returns></returns>
/// <exception cref="InvalidOperationException"></exception>
public override object GetExportedValue(System.ComponentModel.Composition.Primitives.ExportDefinition definition)
{
try
{
ProviderExportDefinition export = definition as ProviderExportDefinition;
if (export == null)
{
throw new InvalidOperationException("The supplied export definition was of an unknown type.");
}
if (export.Member == null)
{
throw new InvalidOperationException(string.Format("Not found member to export definition. {0}", export.ContractName));
}
ComposableMember exportable = export.Member.ToComposableMember();
object instance = null;
if (exportable.IsInstanceNeeded)
{
instance = this.GetActivatedInstance(exportable);
}
object value = exportable.GetValue(instance);
return(value);
}
catch (Exception ex)
{
ComposablePartErrorHandler.NotifyGetExportedValueError(definition, ex);
throw;
}
}
/// <summary>
///
/// </summary>
private void SatisfyPostCompositionImports()
{
IEnumerable <System.ComponentModel.Composition.Primitives.ImportDefinition> members = this.ImportDefinitions.Where(import => !import.IsPrerequisite);
foreach (var i in members)
{
var definition = i as ProviderImportDefinition;
if (definition == null)
{
continue;
}
ImportableInfo value;
if (this.ImportedValues.TryGetValue(definition, out value))
{
ComposableMember importable = definition.Member.ToComposableMember();
importable.SetValue(this.Instance, value.GetValue());
}
}
}
/// <summary>
/// Recupera o valor.
/// </summary>
/// <returns></returns>
public object GetValue()
{
ComposableMember importable = null;
if (_import == null)
{
if (_definition is ProviderParameterImportDefinition)
{
importable = ((ProviderParameterImportDefinition)_definition).Parameter.ToComposableMember();
}
else
{
throw new InvalidOperationException("The supplied import definition was of an unknown type.");
}
}
else
{
importable = _import.Member.ToComposableMember();
}
object value = importable.GetImportValueFromExports(_exports);
return(value);
}
/// <summary>
/// Creates a new instance of the <see cref="ComposableMember"/>, specified by the parameter, if it's needed.
/// </summary>
/// <param name="exportable">The exportable member to create an instance of, if it is required.</param>
/// <returns>An instance of the object specified by the provided <see cref="ComposableMember"/>.</returns>
private object GetActivatedInstance(ComposableMember exportable)
{
if (Definition.PartCreationPolicy == System.ComponentModel.Composition.CreationPolicy.Shared && this.Instance != null)
{
return(this.Instance);
}
var constructor = exportable as ComposableConstructor;
if (constructor == null)
{
try
{
if (this.Definition.UseDispatcher && Colosoft.Threading.DispatcherManager.Dispatcher != null && Colosoft.Threading.DispatcherManager.Dispatcher.Thread != System.Threading.Thread.CurrentThread)
{
this.Instance = Colosoft.Threading.DispatcherManager.Dispatcher.Invoke(new Func <Type, object>(Activator.CreateInstance), new object[] {
exportable.DeclaringType
});
}
else
{
this.Instance = Activator.CreateInstance(exportable.DeclaringType);
}
}
catch (Exception ex)
{
if (ex is System.Reflection.TargetInvocationException && ex.InnerException != null)
{
ex = ex.InnerException;
}
throw new ActivatedInstanceException(string.Format("An error ocurred when create instance for type '{0}'. \r\nMessage: {1}", exportable.DeclaringType, ex.Message), ex);
}
}
else
{
var ctorParameters = constructor.Constructor.GetParameters();
var parameters = new object[ctorParameters.Length];
var i = 0;
foreach (var j in Definition.ImportsParametersDefinitions)
{
var value = this.ImportedValues[j];
value.ClearExportValue();
try
{
parameters[i] = value.GetValue();
}
catch (Exception ex)
{
throw new ComposableMemberParameterException(exportable, j, ex);
}
i++;
}
try
{
if (this.Definition.UseDispatcher && Colosoft.Threading.DispatcherManager.Dispatcher != null && Colosoft.Threading.DispatcherManager.Dispatcher.Thread != System.Threading.Thread.CurrentThread)
{
var declaringType = exportable.DeclaringType;
this.Instance = Colosoft.Threading.DispatcherManager.Dispatcher.Invoke(new Func <Type, object[], object>(Activator.CreateInstance), new object[] {
declaringType,
parameters
});
}
else
{
this.Instance = constructor.Constructor.Invoke(parameters);
}
}
catch (Exception ex)
{
if (ex is System.Reflection.TargetInvocationException && ex.InnerException != null)
{
ex = ex.InnerException;
}
throw new ActivatedInstanceException(string.Format("An error ocurred when create instance for type '{0}'. \r\nMessage: {1}", exportable.DeclaringType, ex.Message), ex);
}
}
if (this.IsComposed)
{
this.SatisfyPostCompositionImports();
}
return(this.Instance);
}
/// <summary>
/// Construtro padrão.
/// </summary>
/// <param name="member"></param>
/// <param name="parameter"></param>
/// <param name="innerException"></param>
internal ComposableMemberParameterException(ComposableMember member, ProviderParameterImportDefinition parameter, Exception innerException) : base(ResourceMessageFormatter.Create(() => Properties.Resources.ComposableMemberParameterExcepton_Message, parameter != null ? parameter.Parameter.Name : null, parameter != null ? parameter.Parameter.ParameterType.FullName : null, member != null ? member.DeclaringType.FullName : null).Format(), innerException)
{
Member = member;
Parameter = parameter;
}
/// <summary>
/// Cria um <see cref="ComposableMember"/> para uma instancia de <see cref="System.Reflection.MemberInfo"/>.
/// </summary>
/// <param name="member">Instancia do <see cref="System.Reflection.MemberInfo"/> para criar o <see cref="ComposableMember"/>.</param>
/// <returns>A <see cref="ComposableMember"/> instance.</returns>
public static ComposableMember ToComposableMember(this System.Reflection.MemberInfo member)
{
return(ComposableMember.Create(member));
}
