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); }