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(Properties.Resources.ExportDescriptor_UnsupportedCycle, dependency.Target.Origin);
message.AppendLine();
message.Append(DescribeCompositionStack(dependency, checking));
throw ThrowHelper.CompositionException(message.ToString());
}
if (!step.IsPrerequisite)
nonPrereqSeen = true;
}
}
CheckTarget(dependency, @checked, checking);
}
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));
throw ThrowHelper.CompositionException(message.ToString());
}
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();
}
/// <summary>
/// Resolve dependencies on all implementations of a contract.
/// </summary>
/// <param name="site">A tag describing the dependency site.</param>
/// <param name="contract">The contract required by the site.</param>
/// <param name="isPrerequisite">True if the dependency must be satisifed before corresponding exports can be retrieved; otherwise, false.</param>
/// <returns>Dependencies for all implementations of the contact.</returns>
public IEnumerable<CompositionDependency> ResolveDependencies(object site, CompositionContract contract, bool isPrerequisite)
{
var all = GetPromises(contract).ToArray();
var result = new CompositionDependency[all.Length];
for (var i = 0; i < all.Length; ++i)
result[i] = CompositionDependency.Satisfied(contract, all[i], isPrerequisite, site);
return result;
}
/// <summary>
/// Resolve a required dependency on exactly one implemenation of a contract.
/// </summary>
/// <param name="site">A tag describing the dependency site.</param>
/// <param name="contract">The contract required by the site.</param>
/// <param name="isPrerequisite">True if the dependency must be satisifed before corresponding exports can be retrieved; otherwise, false.</param>
/// <returns>The dependency.</returns>
public CompositionDependency ResolveRequiredDependency(object site, CompositionContract contract, bool isPrerequisite)
{
CompositionDependency result;
if (!TryResolveOptionalDependency(site, contract, isPrerequisite, out result))
{
return(CompositionDependency.Missing(contract, site));
}
return(result);
}
/// <summary>
/// Resolve dependencies on all implementations of a contract.
/// </summary>
/// <param name="site">A tag describing the dependency site.</param>
/// <param name="contract">The contract required by the site.</param>
/// <param name="isPrerequisite">True if the dependency must be satisifed before corresponding exports can be retrieved; otherwise, false.</param>
/// <returns>Dependencies for all implementations of the contact.</returns>
public IEnumerable <CompositionDependency> ResolveDependencies(object site, CompositionContract contract, bool isPrerequisite)
{
var all = GetPromises(contract).ToArray();
var result = new CompositionDependency[all.Length];
for (var i = 0; i < all.Length; ++i)
{
result[i] = CompositionDependency.Satisfied(contract, all[i], isPrerequisite, site);
}
return(result);
}
/// <summary>
/// Resolve an optional dependency on exactly one implemenation of a contract.
/// </summary>
/// <param name="site">A tag describing the dependency site.</param>
/// <param name="contract">The contract required by the site.</param>
/// <param name="isPrerequisite">True if the dependency must be satisifed before corresponding exports can be retrieved; otherwise, false.</param>
/// <param name="dependency">The dependency, or null.</param>
/// <returns>True if the dependency could be resolved; otherwise, false.</returns>
public bool TryResolveOptionalDependency(object site, CompositionContract contract, bool isPrerequisite, out CompositionDependency dependency)
{
var all = GetPromises(contract).ToArray();
if (all.Length == 0)
{
dependency = null;
return false;
}
if (all.Length != 1)
{
dependency = CompositionDependency.Oversupplied(contract, all, site);
return true;
}
dependency = CompositionDependency.Satisfied(contract, all[0], isPrerequisite, site);
return true;
}
private StringBuilder DescribeCompositionStack(CompositionDependency import, IEnumerable <CompositionDependency> dependencies)
{
var result = new StringBuilder();
if (dependencies.FirstOrDefault() == null)
{
return(result);
}
foreach (var step in dependencies)
{
result.AppendFormat(Properties.Resources.ExportDescriptor_DependencyErrorLine, import.Site, step.Target.Origin);
result.AppendLine();
import = step;
}
result.AppendFormat(Properties.Resources.ExportDescriptor_DependencyErrorContract, import.Contract);
return(result);
}
/// <summary>
/// Resolve an optional dependency on exactly one implemenation of a contract.
/// </summary>
/// <param name="site">A tag describing the dependency site.</param>
/// <param name="contract">The contract required by the site.</param>
/// <param name="isPrerequisite">True if the dependency must be satisifed before corresponding exports can be retrieved; otherwise, false.</param>
/// <param name="dependency">The dependency, or null.</param>
/// <returns>True if the dependency could be resolved; otherwise, false.</returns>
public bool TryResolveOptionalDependency(object site, CompositionContract contract, bool isPrerequisite, out CompositionDependency dependency)
{
var all = GetPromises(contract).ToArray();
if (all.Length == 0)
{
dependency = null;
return(false);
}
if (all.Length != 1)
{
dependency = CompositionDependency.Oversupplied(contract, all, site);
return(true);
}
dependency = CompositionDependency.Satisfied(contract, all[0], isPrerequisite, site);
return(true);
}
private static StringBuilder DescribeCompositionStack(CompositionDependency import, Stack <CompositionDependency> dependencies)
{
var result = new StringBuilder();
if (dependencies.Count == 0 || dependencies.Peek() == null)
{
return(result);
}
foreach (CompositionDependency step in dependencies)
{
result.AppendFormat(SR.ExportDescriptor_DependencyErrorLine, import.Site, step.Target.Origin);
result.AppendLine();
import = step;
}
result.AppendFormat(SR.ExportDescriptor_DependencyErrorContract, import.Contract);
return(result);
}
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);
}
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));
throw ThrowHelper.CompositionException(message.ToString());
}
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();
}
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(System.Composition.Properties.Resources.ExportDescriptor_UnsupportedCycle, dependency.Target.Origin);
message.AppendLine();
message.Append(DescribeCompositionStack(dependency, checking));
throw ThrowHelper.CompositionException(message.ToString());
}
if (!step.IsPrerequisite)
{
nonPrereqSeen = true;
}
}
}
CheckTarget(dependency, @checked, checking);
}
private StringBuilder DescribeCompositionStack(CompositionDependency import, IEnumerable<CompositionDependency> dependencies)
{
var result = new StringBuilder();
if (dependencies.FirstOrDefault() == null)
{
return result;
}
foreach (var step in dependencies)
{
result.AppendFormat(Properties.Resources.ExportDescriptor_DependencyErrorLine, import.Site, step.Target.Origin);
result.AppendLine();
import = step;
}
result.AppendFormat(Properties.Resources.ExportDescriptor_DependencyErrorContract, import.Contract);
return result;
}
