private void CheckTarget(CompositionDependency dependency, HashSet <ExportDescriptorPromise> @checked, Stack <CompositionDependency> checking)
{
if (dependency.IsError)
{
var message = new StringBuilder();
dependency.DescribeError(message);
message.AppendLine();
message.Append(DescribeCompositionStack(dependency, checking));
var ex = new CompositionFailedException(message.ToString());
Debug.WriteLine(SR.Diagnostic_ThrowingException, ex.ToString());
throw ex;
}
if (@checked.Contains(dependency.Target))
{
return;
}
@checked.Add(dependency.Target);
checking.Push(dependency);
foreach (var dep in dependency.Target.Dependencies)
{
CheckDependency(dep, @checked, checking);
}
checking.Pop();
}
public void Ctor_Message(string message)
{
var exception = new CompositionFailedException(message);
Assert.Equal(message, exception.Message);
Assert.Null(exception.InnerException);
}
public void ExceptionIsSerializable()
{
var discovery = TestUtilities.V2Discovery;
var catalog = TestUtilities.EmptyCatalog.AddParts(new[] { discovery.CreatePart(typeof(Tree)) });
var configuration = CompositionConfiguration.Create(catalog);
CompositionFailedException exception = null;
try
{
configuration.ThrowOnErrors();
Assert.True(false, "Expected exception not thrown.");
}
catch (CompositionFailedException ex)
{
exception = ex;
}
var formatter = new BinaryFormatter();
var ms = new MemoryStream();
formatter.Serialize(ms, exception);
ms.Position = 0;
var actual = (CompositionFailedException)formatter.Deserialize(ms);
Assert.Equal(exception.Message, actual.Message);
Assert.NotNull(actual.Errors);
Assert.False(actual.Errors.IsEmpty);
Assert.Equal(1, actual.Errors.Peek().Count);
Assert.Equal(exception.Errors.Peek().Single().Message, actual.Errors.Peek().Single().Message);
}
public void Ctor_Default()
{
var exception = new CompositionFailedException();
Assert.NotEmpty(exception.Message);
Assert.Null(exception.InnerException);
}
static public CompositionFailedException CompositionException(string message)
{
var e = new CompositionFailedException(message);
LogException(e);
return(e);
}
static public CompositionFailedException CardinalityMismatch_TooManyExports(string exportKey)
{
var e = new CompositionFailedException(string.Format(Resources.CardinalityMismatch_TooManyExports, exportKey));
LogException(e);
return(e);
}
/// <summary>
/// Find the broadest lifetime context within all of the specified sharing boundaries.
/// </summary>
/// <param name="sharingBoundary">The sharing boundary to find a lifetime context within.</param>
/// <returns>The broadest lifetime context within all of the specified sharing boundaries.</returns>
/// <remarks>Currently, the root cannot be a boundary.</remarks>
public LifetimeContext FindContextWithin(string sharingBoundary)
{
if (sharingBoundary == null)
{
return(_root);
}
var toCheck = this;
while (toCheck != null)
{
foreach (var implemented in toCheck._sharingBoundaries)
{
if (implemented == sharingBoundary)
{
return(toCheck);
}
}
toCheck = toCheck._parent;
}
// To generate acceptable error messages here we're going to need to pass in a description
// of the component, or otherwise find a way to get one.
string message = SR.Format(SR.Component_NotCreatableOutsideSharingBoundary, sharingBoundary);
var ex = new CompositionFailedException(message);
Debug.WriteLine(SR.Diagnostic_ThrowingException, ex.ToString());
throw ex;
}
public void Ctor_Message_InnerException(string message)
{
var innerException = new DivideByZeroException();
var exception = new CompositionFailedException(message, innerException);
Assert.Equal(message, exception.Message);
Assert.Same(innerException, exception.InnerException);
}
private static TValue GetMetadataValue <TValue>(IDictionary <string, object> metadata, string name, DefaultValueAttribute defaultValue)
{
object result;
if (metadata.TryGetValue(name, out result))
{
return((TValue)result);
}
if (defaultValue != null)
{
return((TValue)defaultValue.Value);
}
// This could be significantly improved by describing the target metadata property.
var message = SR.Format(SR.MetadataViewProvider_MissingMetadata, name);
var ex = new CompositionFailedException(message);
Debug.WriteLine(SR.Diagnostic_ThrowingException, ex.ToString());
throw ex;
}
private void CheckDependency(CompositionDependency dependency, HashSet <ExportDescriptorPromise> @checked, Stack <CompositionDependency> checking)
{
if (@checked.Contains(dependency.Target))
{
var sharedSeen = false;
var nonPrereqSeen = !dependency.IsPrerequisite;
foreach (var step in checking)
{
if (step.Target.IsShared)
{
sharedSeen = true;
}
if (sharedSeen && nonPrereqSeen)
{
break;
}
if (step.Target.Equals(dependency.Target))
{
var message = new StringBuilder();
message.AppendFormat(SR.ExportDescriptor_UnsupportedCycle, dependency.Target.Origin);
message.AppendLine();
message.Append(DescribeCompositionStack(dependency, checking));
var ex = new CompositionFailedException(message.ToString());
Debug.WriteLine(SR.Diagnostic_ThrowingException, ex.ToString());
throw ex;
}
if (!step.IsPrerequisite)
{
nonPrereqSeen = true;
}
}
}
CheckTarget(dependency, @checked, checking);
}
public bool TryGetSingleForExport(CompositionContract exportKey, out ExportDescriptor defaultForExport)
{
ExportDescriptor[] allForExport;
if (!_partDefinitions.TryGetValue(exportKey, out allForExport))
{
lock (_thisLock)
{
if (!_partDefinitions.ContainsKey(exportKey))
{
var updatedDefinitions = new Dictionary <CompositionContract, ExportDescriptor[]>(_partDefinitions);
var updateOperation = new ExportDescriptorRegistryUpdate(updatedDefinitions, _exportDescriptorProviders);
updateOperation.Execute(exportKey);
_partDefinitions = updatedDefinitions;
}
}
allForExport = (ExportDescriptor[])_partDefinitions[exportKey];
}
if (allForExport.Length == 0)
{
defaultForExport = null;
return(false);
}
// This check is duplicated in the update process- the update operation will catch
// cardinality violations in advance of this in all but a few very rare scenarios.
if (allForExport.Length != 1)
{
var ex = new CompositionFailedException(SR.Format(SR.CardinalityMismatch_TooManyExports, exportKey.ToString()));
Debug.WriteLine(SR.Diagnostic_ThrowingException, ex.ToString());
throw ex;
}
defaultForExport = allForExport[0];
return(true);
}
