示例#1
0
        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);
        }
示例#2
0
        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)));
        }
示例#3
0
        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>());
        }
示例#4
0
        public void InstanceDependencyGeneric()
        {
            ISignableContract contract = new SignableContract();

            contract.Describe(10);

            ISignedContract signedContract = contract.Sign();

            Assert.AreEqual(signedContract.Resolve <int>(), 10);
        }
示例#5
0
        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"));
        }
示例#6
0
        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);
        }
示例#7
0
        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));
        }
示例#8
0
 public static object Resolve(this ISignedContract contract, Type type)
 => contract.Resolve(type);
示例#9
0
 public static T Resolve <T>(this ISignedContract contract, Identifier identifier)
 => (T)contract.Resolve(typeof(T), identifier);
示例#10
0
 public static T Resolve <T>(this ISignedContract contract, string identifier)
 => (T)contract.Resolve(typeof(T), new Identifier(identifier, identifier.GetHashCode()));
示例#11
0
 public Injector(object patient, ISignedContract contract) : base(patient)
 {
     this.Contract = contract;
 }
示例#12
0
 public void SignWith(ISignedContract contract)
 {
     Contract = contract;
 }
示例#13
0
 public static T Construct <T>(ISignedContract contract, int constructorIndex)
 => (T)Construct(typeof(T), contract, constructorIndex);
示例#14
0
 public static object Construct(Type type, ISignedContract contract)
 => Construct(type, contract, 0);
示例#15
0
 public void AddContract(ISignedContract contract)
 {
 }
示例#16
0
 public static object Resolve(this ISignedContract contract, Type type, string identifier)
 => contract.Resolve(type, new Identifier(identifier, identifier.GetHashCode()));
示例#17
0
 public static T Construct <T>(ISignedContract contract)
 => (T)Construct(typeof(T), contract, 0);
示例#18
0
 public static T Resolve <T>(this ISignedContract contract)
 => (T)contract.Resolve(typeof(T));
示例#19
0
 public void AddContract(ISignedContract contract)
 {
     _subContracts.Add(contract);
 }