/// <summary>
/// This method adds all depencencies of a typeof()-argument of an attribute to the dependencies of the type.
/// </summary>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
/// <param name="sourceFile">The corresdonding source code location.</param>
/// <param name="parameterType">A string representing the type of the parameter.</param>
/// <param name="parameterValue">The argument that is passed for this attribute parameter.</param>
private static void VisitAttributeParameters(DependencyCollection dependencies, SourceFile sourceFile, string parameterType, object parameterValue)
{
if (parameterType.Equals("System.Type"))
{
// In the case of external types IL code contains the informations on the assembly defining the type
String[] typeParts = parameterValue.ToString().Split(',');
string cleanedDependency = typeParts[0].Replace("+", "/");
// Remove terminating "\0"
// Bug ID 2268: Cecil sometimes terminates constructor parameters in attributes that use typeof() with "\0". The reason therefore is unclear.
if (cleanedDependency.EndsWith("\0"))
{
cleanedDependency = cleanedDependency.Remove(cleanedDependency.Length - 2);
}
if (!cleanedDependency.Equals(String.Empty))
{
dependencies.AddDependency(cleanedDependency, DirectTypeDependency, sourceFile);
}
}
else if (parameterType.Equals("System.Type[]"))
{
foreach (CustomAttributeArgument arrayMember in (CustomAttributeArgument[])parameterValue)
{
string memberType = arrayMember.Value.ToString();
// In the case of external types IL code contains the informations on the assembly defining the type
string[] typeParts = memberType.Split(',');
string cleanedDependency = typeParts[0].Replace("+", "/");
if (!cleanedDependency.Equals(string.Empty))
{
dependencies.AddDependency(cleanedDependency, DirectTypeDependency, sourceFile);
}
}
}
}
public void AddDependency(DependencyLifetime lifetime)
{
_dependencies.AddDependency(_contract, _implementation, lifetime);
var dependency = _dependencies.GetRequiredDependency(_contract);
dependency.Contracts.Should().Contain(_contract);
dependency.Implementation.Should().Be(_implementation);
dependency.Lifetime.Should().Be(lifetime);
}
public static DependencyCollection AddHttpHandler(this DependencyCollection collection,
Func <IDependencyScope, IHttpRequestHandler> builder,
DependencyLifetime lifetime = DependencyLifetime.Singleton)
{
collection.AddDependency(builder, lifetime);
return(collection);
}
public void TryRegister(DependencyCollection collection, Type implementation)
{
if (ECSUtils.TryGetImplementedSystemInterfaces(implementation, out var contracts))
{
collection.AddDependency(contracts, implementation, _lifetime);
}
}
/// <summary>
/// Collects the dependencies from an instruction that has a MemberReference as operand.
/// </summary>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
/// <param name="sourceFile">The corresdonding source code location.</param>
/// <param name="memberRef">The MemberReference to investigate.</param>
private static void VisitMemberReference(DependencyCollection dependencies, SourceFile sourceFile, MemberReference memberRef)
{
if (memberRef.DeclaringType != null)
{
string memberName = memberRef.Name;
if (memberRef is MethodReference)
{
memberName = Formatter.FormatMethodReference(((MethodReference)memberRef));
}
dependencies.AddDependency(memberRef.DeclaringType.FullName, memberName, sourceFile);
}
if (memberRef.DeclaringType is GenericInstanceType)
{
GenericInstanceType declaringType = (GenericInstanceType)memberRef.DeclaringType;
VisitGenericArguments(declaringType.GenericArguments, dependencies, sourceFile);
}
if (memberRef is MethodReference)
{
VisitMethodReference(dependencies, sourceFile, (MethodReference)memberRef);
}
else if (memberRef is FieldReference)
{
VisitFieldReference(dependencies, sourceFile, (FieldReference)memberRef);
}
}
public static DependencyCollection AddHttpHandler <THandler>(this DependencyCollection collection,
DependencyLifetime lifetime = DependencyLifetime.Singleton)
where THandler : class, IHttpRequestHandler
{
collection.AddDependency(Typeof <IHttpRequestHandler> .Raw, typeof(THandler), lifetime);
return(collection);
}
/// <summary>
/// Collects the dependency information contained in a single IL instruction.
/// </summary>
/// <param name="instruction">The Instruction to investigate.</param>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
private static void VisitInstruction(Instruction instruction, DependencyCollection dependencies)
{
if (!IsValidOperandType(instruction.OpCode.OperandType))
{
return;
}
if (instruction.Operand != null)
{
SourceFile sourceFile = new SourceFile(instruction.SequencePoint);
if (instruction.Operand is GenericParameter)
{
return;
}
else if (instruction.Operand is GenericInstanceType)
{
GenericInstanceType instType = (GenericInstanceType)instruction.Operand;
VisitGenericArguments(instType.GenericArguments, dependencies, sourceFile);
dependencies.AddDependency(instType.FullName, DirectTypeDependency, sourceFile);
}
else if (instruction.Operand is TypeReference)
{
TypeReference typeRef = (TypeReference)instruction.Operand;
VisitGenericParameters(typeRef.GenericParameters, dependencies, sourceFile);
if (!IsGenericTypeVariable(typeRef))
{
dependencies.AddDependency(typeRef.FullName, DirectTypeDependency, sourceFile);
}
}
else if (instruction.Operand is MemberReference)
{
MemberReference memberRef = (MemberReference)instruction.Operand;
VisitMemberReference(dependencies, sourceFile, memberRef);
}
else if (instruction.Operand is CallSite)
{
// Calls to non-managed code - currently not supported
}
else
{ // This should never happen:
Console.WriteLine("\n\n Strange Operand found: {0}\n", instruction.Operand);
}
}
else return;
}
public void TryRegister(DependencyCollection collection, Type implementation)
{
if (!_contract.IsAssignableFrom(implementation))
{
return;
}
collection.AddDependency(_contract, implementation, _lifetime);
}
public static DependencyCollection AddLogWriter <TWriter>(this DependencyCollection collection,
DependencyLifetime lifetime = DependencyLifetime.Singleton)
where TWriter : ILogWriter
{
var implementation = Typeof <TWriter> .Raw;
var contracts = new[] { Typeof <ILogWriter> .Raw, implementation };
collection.AddDependency(contracts, implementation, lifetime);
return(collection);
}
public void TryRegister(DependencyCollection collection, Type implementation)
{
var contracts = new LocalList <Type>();
TryAdd(ref contracts, _beginUpdateSystem, implementation);
TryAdd(ref contracts, _endUpdateSystem, implementation);
TryAdd(ref contracts, _initializeSystem, implementation);
TryAdd(ref contracts, _updateSystem, implementation);
collection.AddDependency(contracts.ToArray(), implementation, DependencyLifetime.Scoped);
}
private static void InsertDependentTypes(TypeReference typeRef, DependencyCollection dependencies, SourceFile sourceFile)
{
if (!IsGenericTypeVariable(typeRef))
{
dependencies.AddDependency(typeRef.FullName, DirectTypeDependency, sourceFile);
}
if (typeRef is GenericInstanceType)
{
VisitGenericArguments(((GenericInstanceType)typeRef).GenericArguments, dependencies, sourceFile);
}
}
/// <summary>
/// Collects the dependency information contained in parameter lists (e.g. the parameters of a method).
/// </summary>
/// <param name="parameters">The ParameterDefinitionCollection to investigate.</param>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
/// <param name="sourceFile">The corresdonding source code location.</param>
private static void VisitParameters(Collection<ParameterDefinition> parameters, DependencyCollection dependencies, SourceFile sourceFile)
{
foreach (ParameterDefinition paraDef in parameters)
{
if (!IsGenericTypeVariable(paraDef.ParameterType))
{
dependencies.AddDependency(paraDef.ParameterType.FullName, DirectTypeDependency, sourceFile);
}
VisitGenericParameters(paraDef.ParameterType.GenericParameters, dependencies, sourceFile);
}
}
/// <summary>
/// Collects the dependency information for a given GenericParameterCollection.
/// The parameter definition itself does not contain any depencencies, only the constraints for generic parameters may contain dependencies.
/// </summary>
/// <param name="parameters">The GenericParameterCollection to investigate.</param>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
/// <param name="sourceFile">The corresdonding source code location.</param>
private static void VisitGenericParameters(Collection<GenericParameter> parameters, DependencyCollection dependencies, SourceFile sourceFile)
{
// only the types metioned in the constraints are of importance
foreach (GenericParameter param in parameters)
{
foreach (TypeReference constraint in param.Constraints)
{
dependencies.AddDependency(constraint.FullName, DirectTypeDependency, sourceFile);
VisitGenericParameters(constraint.GenericParameters, dependencies, sourceFile);
}
}
}
// ReSharper disable once InconsistentNaming
public static DependencyCollection AddECSSystem <TSystem>(this DependencyCollection collection,
DependencyLifetime lifetime = DependencyLifetime.Singleton)
where TSystem : class, ISystem
{
var type = typeof(TSystem);
var systemsInterfaces = ReflectionUtils.GetInterfaceImplementations(type, typeof(ISystem));
systemsInterfaces.Add(type);
collection.AddDependency(systemsInterfaces.ToArray(), type, lifetime);
return(collection);
}
private static void AddTransient(DependencyCollection dependencies, ServiceDescriptor descriptor)
{
if (descriptor.ImplementationFactory == null)
{
dependencies.AddTransient(descriptor.ServiceType, descriptor.ImplementationType);
}
else
{
var contracts = new[] { descriptor.ServiceType };
var resolver = BuildDelegateResolver(descriptor);
dependencies.AddDependency(new TransientDependency(contracts, resolver));
}
}
public void TryRegister(DependencyCollection collection, Type implementation)
{
var interfaces = implementation.GetInterfaces();
foreach (var interfaceType in interfaces)
{
if (!ReflectionUtils.IsGenericTypeImplementation(interfaceType, _genericContract))
{
continue;
}
collection.AddDependency(interfaceType, implementation, _lifetime);
return;
}
}
private static bool AddDependencies(
DependencyCollection collection,
Type implementation,
Type[] genericInterfaces,
DependencyLifetime lifetime)
{
var contracts = ReflectionUtils.GetGenericInterfaceImplementations(implementation, genericInterfaces);
if (contracts.Length == 0)
{
return(false);
}
contracts.Add(implementation);
collection.AddDependency(contracts.ToArray(), implementation, lifetime);
return(true);
}
private static void AddSingleton(DependencyCollection dependencies, ServiceDescriptor descriptor)
{
if (descriptor.ImplementationInstance != null)
{
dependencies.AddInstance(descriptor.ServiceType, descriptor.ImplementationInstance);
}
else if (descriptor.ImplementationFactory == null)
{
dependencies.AddSingleton(descriptor.ServiceType, descriptor.ImplementationType);
}
else
{
var contracts = new[] { descriptor.ServiceType };
var resolver = BuildDelegateResolver(descriptor);
dependencies.AddDependency(new SingletonDependency(contracts, resolver));
}
}
public void TryRegister(DependencyCollection collection, Type implementation)
{
var contracts = ReflectionUtils.GetGenericInterfaceImplementations(implementation, _processorTypes);
if (contracts.Length == 0)
{
return;
}
if (implementation.IsGenericTypeDefinition)
{
var contract = contracts[0];
collection.AddFactory(new GenericFactory(contract, implementation, _lifetime));
}
else
{
contracts.Add(implementation);
collection.AddDependency(contracts.ToArray(), implementation, _lifetime);
}
}
private static void InsertDependentTypes(TypeReference typeRef, DependencyCollection dependencies, SourceFile sourceFile)
{
if (!IsGenericTypeVariable(typeRef))
{
dependencies.AddDependency(typeRef.FullName, DirectTypeDependency, sourceFile);
}
if (typeRef is GenericInstanceType)
{
VisitGenericArguments(((GenericInstanceType)typeRef).GenericArguments, dependencies, sourceFile);
}
}
/// <summary>
/// This method adds all depencencies of a typeof()-argument of an attribute to the dependencies of the type.
/// </summary>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
/// <param name="sourceFile">The corresdonding source code location.</param>
/// <param name="parameterType">A string representing the type of the parameter.</param>
/// <param name="parameterValue">The argument that is passed for this attribute parameter.</param>
private static void VisitAttributeParameters(DependencyCollection dependencies, SourceFile sourceFile, string parameterType, object parameterValue)
{
if (parameterType.Equals("System.Type"))
{
// In the case of external types IL code contains the informations on the assembly defining the type
String[] typeParts = parameterValue.ToString().Split(',');
string cleanedDependency = typeParts[0].Replace("+", "/");
// Remove terminating "\0"
// Bug ID 2268: Cecil sometimes terminates constructor parameters in attributes that use typeof() with "\0". The reason therefore is unclear.
if (cleanedDependency.EndsWith("\0"))
{
cleanedDependency = cleanedDependency.Remove(cleanedDependency.Length - 2);
}
if (!cleanedDependency.Equals(String.Empty))
{
dependencies.AddDependency(cleanedDependency, DirectTypeDependency, sourceFile);
}
}
else if (parameterType.Equals("System.Type[]"))
{
foreach (CustomAttributeArgument arrayMember in (CustomAttributeArgument[])parameterValue)
{
string memberType = arrayMember.Value.ToString();
// In the case of external types IL code contains the informations on the assembly defining the type
string[] typeParts = memberType.Split(',');
string cleanedDependency = typeParts[0].Replace("+", "/");
if (!cleanedDependency.Equals(string.Empty))
{
dependencies.AddDependency(cleanedDependency, DirectTypeDependency, sourceFile);
}
}
}
}
/// <summary>
/// Collects the dependency information for a given GenericParameterCollection.
/// The parameter definition itself does not contain any depencencies, only the constraints for generic parameters may contain dependencies.
/// </summary>
/// <param name="parameters">The GenericParameterCollection to investigate.</param>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
/// <param name="sourceFile">The corresdonding source code location.</param>
private static void VisitGenericParameters(Collection<GenericParameter> parameters, DependencyCollection dependencies, SourceFile sourceFile)
{
// only the types metioned in the constraints are of importance
foreach (GenericParameter param in parameters)
{
foreach (TypeReference constraint in param.Constraints)
{
dependencies.AddDependency(constraint.FullName, DirectTypeDependency, sourceFile);
VisitGenericParameters(constraint.GenericParameters, dependencies, sourceFile);
}
}
}
/// <summary>
/// Collects the dependency information contained in a single IL instruction.
/// </summary>
/// <param name="instruction">The Instruction to investigate.</param>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
private static void VisitInstruction(Instruction instruction, DependencyCollection dependencies)
{
if (!IsValidOperandType(instruction.OpCode.OperandType))
{
return;
}
if (instruction.Operand != null)
{
SourceFile sourceFile = new SourceFile(instruction.SequencePoint);
if (instruction.Operand is GenericParameter)
{
return;
}
else if (instruction.Operand is GenericInstanceType)
{
GenericInstanceType instType = (GenericInstanceType)instruction.Operand;
VisitGenericArguments(instType.GenericArguments, dependencies, sourceFile);
dependencies.AddDependency(instType.FullName, DirectTypeDependency, sourceFile);
}
else if (instruction.Operand is TypeReference)
{
TypeReference typeRef = (TypeReference)instruction.Operand;
VisitGenericParameters(typeRef.GenericParameters, dependencies, sourceFile);
if (!IsGenericTypeVariable(typeRef))
{
dependencies.AddDependency(typeRef.FullName, DirectTypeDependency, sourceFile);
}
}
else if (instruction.Operand is MemberReference)
{
MemberReference memberRef = (MemberReference)instruction.Operand;
VisitMemberReference(dependencies, sourceFile, memberRef);
}
else if (instruction.Operand is CallSite)
{
// Calls to non-managed code - currently not supported
}
else
{ // This should never happen:
Console.WriteLine("\n\n Strange Operand found: {0}\n", instruction.Operand);
}
}
else return;
}
/// <summary>
/// Collects the dependencies from an instruction that has a MemberReference as operand.
/// </summary>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
/// <param name="sourceFile">The corresdonding source code location.</param>
/// <param name="memberRef">The MemberReference to investigate.</param>
private static void VisitMemberReference(DependencyCollection dependencies, SourceFile sourceFile, MemberReference memberRef)
{
if (memberRef.DeclaringType != null)
{
string memberName = memberRef.Name;
if (memberRef is MethodReference)
{
memberName = Formatter.FormatMethodReference(((MethodReference)memberRef));
}
dependencies.AddDependency(memberRef.DeclaringType.FullName, memberName, sourceFile);
}
if (memberRef.DeclaringType is GenericInstanceType)
{
GenericInstanceType declaringType = (GenericInstanceType)memberRef.DeclaringType;
VisitGenericArguments(declaringType.GenericArguments, dependencies, sourceFile);
}
if (memberRef is MethodReference)
{
VisitMethodReference(dependencies, sourceFile, (MethodReference)memberRef);
}
else if (memberRef is FieldReference)
{
VisitFieldReference(dependencies, sourceFile, (FieldReference)memberRef);
}
}
/// <summary>
/// Collects the dependency information contained in parameter lists (e.g. the parameters of a method).
/// </summary>
/// <param name="parameters">The ParameterDefinitionCollection to investigate.</param>
/// <param name="dependencies">The collection of dependencies into which all found dependencies are inserted. (Can be regared as an out-parameter.)</param>
/// <param name="sourceFile">The corresdonding source code location.</param>
private static void VisitParameters(Collection<ParameterDefinition> parameters, DependencyCollection dependencies, SourceFile sourceFile)
{
foreach (ParameterDefinition paraDef in parameters)
{
if (!IsGenericTypeVariable(paraDef.ParameterType))
{
dependencies.AddDependency(paraDef.ParameterType.FullName, DirectTypeDependency, sourceFile);
}
VisitGenericParameters(paraDef.ParameterType.GenericParameters, dependencies, sourceFile);
}
}