public static CompositionError InvalidStateForRecompposition(ComposablePart part)
{
return(CompositionError.Create(
CompositionErrorId.ImportEngine_InvalidStateForRecomposition,
SR.ImportEngine_InvalidStateForRecomposition,
part.ToElement().DisplayName));
}
public static CompositionError ComposeTookTooManyIterations(int maximumNumberOfCompositionIterations)
{
return(CompositionError.Create(
CompositionErrorId.ImportEngine_ComposeTookTooManyIterations,
SR.ImportEngine_ComposeTookTooManyIterations,
maximumNumberOfCompositionIterations));
}
public static CompositionError CreatePartCannotSetImport(ComposablePart part, ImportDefinition definition, Exception innerException)
{
if (part == null)
{
throw new ArgumentNullException(nameof(part));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
if (innerException == null)
{
throw new ArgumentNullException(nameof(innerException));
}
ICompositionElement element = definition.ToElement();
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PartCannotSetImport,
element,
innerException,
SR.ImportEngine_PartCannotSetImport,
element.DisplayName,
part.ToElement().DisplayName));
}
public static CompositionError PreventedByExistingImport(ComposablePart part, ImportDefinition import)
{
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PreventedByExistingImport,
SR.ImportEngine_PreventedByExistingImport,
import.ToElement().DisplayName,
part.ToElement().DisplayName));
}
public static CompositionError CreateImportCardinalityMismatch(ImportCardinalityMismatchException exception, ImportDefinition definition)
{
Assumes.NotNull(exception, definition);
return(CompositionError.Create(
CompositionErrorId.ImportEngine_ImportCardinalityMismatch,
exception.Message,
definition.ToElement(),
(Exception)null));
}
public static CompositionError CreatePartCycle(ComposablePart part)
{
Assumes.NotNull(part);
ICompositionElement element = part.ToElement();
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PartCycle,
element,
SR.ImportEngine_PartCycle,
element.DisplayName));
}
public static CompositionError CreatePartCannotActivate(ComposablePart part, Exception innerException)
{
Assumes.NotNull(part, innerException);
ICompositionElement element = part.ToElement();
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PartCannotActivate,
element,
innerException,
SR.ImportEngine_PartCannotActivate,
element.DisplayName));
}
public static CompositionError CreateCannotGetExportedValue(ComposablePart part, ExportDefinition definition, Exception innerException)
{
Assumes.NotNull(part, definition, innerException);
ICompositionElement element = definition.ToElement();
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PartCannotGetExportedValue,
element,
innerException,
SR.ImportEngine_PartCannotGetExportedValue,
element.DisplayName,
part.ToElement().DisplayName));
}
public static CompositionError CreatePartCycle(ComposablePart part)
{
if (part == null)
{
throw new ArgumentNullException(nameof(part));
}
ICompositionElement element = part.ToElement();
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PartCycle,
element,
SR.ImportEngine_PartCycle,
element.DisplayName));
}
private object GetInstance()
{
var result = CompositionResult.SucceededResult;
// We only need this guard if we are pulling on the lazy exports during this call
// but if we do the pulling in SetImport it isn't needed.
//if (currentlyExecuting)
//{
// var issue = CompositionError.Create("CM:CreationCycleDetected",
// "This failed because there is a creation cycle");
// return result.MergeIssue(issue).ToResult<object>(null);
//}
try
{
currentlyExecuting = true;
List <object> constructorArgs = new List <object>();
foreach (ImportDefinition import in this.ImportDefinitions
.Where(i => i.IsPrerequisite))
{
object importValue;
if (!this._imports.TryGetValue(import, out importValue))
{
result = result.MergeError(CompositionError.Create(CompositionErrorId.ImportNotSetOnPart,
"The import '{0}' is required for construction of '{1}'", import.ToString(), _type.FullName));
continue;
}
constructorArgs.Add(importValue);
}
if (!result.Succeeded)
{
throw new CompositionException(result.Errors);
}
object obj = this._constructor.Invoke(constructorArgs.ToArray());
return(obj);
}
finally
{
currentlyExecuting = false;
}
}
public static CompositionError CreatePartCannotSetImport(ComposablePart part, ImportDefinition definition, Exception innerException)
{
ArgumentNullException.ThrowIfNull(part);
ArgumentNullException.ThrowIfNull(definition);
ArgumentNullException.ThrowIfNull(innerException);
ICompositionElement element = definition.ToElement();
return(CompositionError.Create(
CompositionErrorId.ImportEngine_PartCannotSetImport,
element,
innerException,
SR.ImportEngine_PartCannotSetImport,
element.DisplayName,
part.ToElement().DisplayName));
}
public static CompositionError CreateImportCardinalityMismatch(ImportCardinalityMismatchException exception, ImportDefinition definition)
{
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
return(CompositionError.Create(
CompositionErrorId.ImportEngine_ImportCardinalityMismatch,
exception.Message,
definition.ToElement(),
(Exception?)null));
}