public static ISignedContract WriteContract(Identifier contractId)
{
if (Settings.cachingEnabled && CachedContracts.ContainsKey(contractId))
{
return(CachedContracts[contractId]);
}
if (!RawData.contractWriterTypeNames.ContainsKey(contractId))
{
Debug.LogError("Invalid contract id " + contractId);
return(EmptySignedContract.Instance);
}
ContractWriter contractWriter = NewWriter(RawData.contractWriterTypeNames[contractId]);
ISignableContract contract = NewContract();
contractWriter.Write(contract);
ISignedContract signedContract = contract.Sign();
if (Settings.cachingEnabled)
{
CachedContracts[contractId] = signedContract;
}
return(signedContract);
}
public void FactoryDependency()
{
ISignableContract contract = new SignableContract();
contract.Describe(typeof(TestClass)).AsFactory(_ => new TestClass());
ISignedContract signedContract = contract.Sign();
Assert.AreNotEqual(signedContract.Resolve(typeof(TestClass)), signedContract.Resolve(typeof(TestClass)));
}
public void FactoryDependencyGeneric()
{
ISignableContract contract = new SignableContract();
contract.Describe <TestClass>().AsFactory(_ => new TestClass());
ISignedContract signedContract = contract.Sign();
Assert.AreNotEqual(signedContract.Resolve <TestClass>(), signedContract.Resolve <TestClass>());
}
public void InstanceDependencyGeneric()
{
ISignableContract contract = new SignableContract();
contract.Describe(10);
ISignedContract signedContract = contract.Sign();
Assert.AreEqual(signedContract.Resolve <int>(), 10);
}
public void InstanceDependency()
{
ISignableContract contract = new SignableContract();
contract.Describe(typeof(int)).AsInstance(10);
contract.Describe(typeof(int)).AsInstance(15).WithIdentifier("testId");
ISignedContract signedContract = contract.Sign();
Assert.AreEqual(10, signedContract.Resolve(typeof(int)));
Assert.AreEqual(15, signedContract.Resolve(typeof(int), "testId"));
}
protected ISignedContract GetContextContract(Context context)
{
if (ContextContracts.ContainsKey(context))
{
return(ContextContracts[context]);
}
ISignedContract groupedContract = Contracts[context.usedContractWriterIds.First()];
for (int i = 1; i < context.usedContractWriterIds.Length; i++)
{
groupedContract.AddContract(Contracts[context.usedContractWriterIds[i]]);
}
return(ContextContracts[context] = groupedContract);
}
public static object Construct(Type type, ISignedContract contract, int constructorIndex)
{
const BindingFlags flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
ConstructorInfo[] constructors = type.GetConstructors(flags);
if (constructorIndex >= constructors.Length)
{
throw new MissingMemberException($"Invalid constructor index {type.Name}:{constructorIndex}");
}
ConstructorInfo constructor = constructors[constructorIndex];
ParameterInfo[] parameters = constructor.GetParameters();
var parameterValues = new object[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
parameterValues[i] = contract.Resolve(parameters[i].ParameterType);
}
return(constructor.Invoke(parameterValues));
}
public static object Resolve(this ISignedContract contract, Type type) => contract.Resolve(type);
public static T Resolve <T>(this ISignedContract contract, Identifier identifier) => (T)contract.Resolve(typeof(T), identifier);
public static T Resolve <T>(this ISignedContract contract, string identifier) => (T)contract.Resolve(typeof(T), new Identifier(identifier, identifier.GetHashCode()));
public Injector(object patient, ISignedContract contract) : base(patient)
{
this.Contract = contract;
}
public void SignWith(ISignedContract contract)
{
Contract = contract;
}
public static T Construct <T>(ISignedContract contract, int constructorIndex) => (T)Construct(typeof(T), contract, constructorIndex);
public static object Construct(Type type, ISignedContract contract) => Construct(type, contract, 0);
public void AddContract(ISignedContract contract)
{
}
public static object Resolve(this ISignedContract contract, Type type, string identifier) => contract.Resolve(type, new Identifier(identifier, identifier.GetHashCode()));
public static T Construct <T>(ISignedContract contract) => (T)Construct(typeof(T), contract, 0);
public static T Resolve <T>(this ISignedContract contract) => (T)contract.Resolve(typeof(T));
public void AddContract(ISignedContract contract)
{
_subContracts.Add(contract);
}
