C# IDependency.GetHashCode方法代码示例

        public int CompareTo(IDependency other)
        {
            var areEqual = (other.Name == this.Name && other.DependencyType == this.DependencyType);
            if (areEqual)
                return 0;

            var otherHash = other.GetHashCode();
            var thisHash = this.GetHashCode();

            var isGreater = otherHash > thisHash;

            return isGreater ? 1 : -1;
        }

        /// <summary>
        /// Emits a service as a singleton type.
        /// </summary>
        /// <param name="targetMethod">The <see cref="IMicroContainer.GetInstance"/> method implementation.</param>
        /// <param name="dependency">The dependency that will be instantiated by the container.</param>
        /// <param name="implementation">The implementation that will be used to instantiate the dependency.</param>
        /// <param name="serviceMap">The service map the contains the current application dependencies.</param>
        public void EmitService(MethodDefinition targetMethod, IDependency dependency, 
                                IImplementation implementation, IDictionary<IDependency, IImplementation> serviceMap)
        {
            MethodDefinition getInstanceMethod = null;

            var worker = targetMethod.GetILGenerator();

            // Emit only one singleton per dependency and call
            // the singleton GetInstance() method on every subsequent emit call
            if (_entries.ContainsKey(dependency))
            {
                getInstanceMethod = _entries[dependency];
                worker.Emit(OpCodes.Call, getInstanceMethod);
                return;
            }

            var declaringType = targetMethod.DeclaringType;
            var module = declaringType.Module;

            var serviceType = dependency.ServiceType;

            var typeName = serviceType.Name;
            var singletonName = string.Format("{0}ServiceSingleton-{1}", typeName, dependency.GetHashCode());
            const TypeAttributes typeAttributes = TypeAttributes.NotPublic | TypeAttributes.AutoClass | TypeAttributes.Sealed |
                                                  TypeAttributes.BeforeFieldInit;
            var objectType = module.Import(typeof(object));

            var singletonType = AddDefaultSingletonConstructor(module, singletonName, typeAttributes, objectType);

            var instanceField = new FieldDefinition("__instance", FieldAttributes.Assembly | FieldAttributes.InitOnly | FieldAttributes.Static, objectType);

            DefineNestedType(module, singletonType, instanceField, serviceMap, implementation, dependency,
                             targetMethod);

            getInstanceMethod = DefineGetInstance(singletonType, worker, instanceField);

            worker.Emit(OpCodes.Call, getInstanceMethod);

            var serviceTypeRef = module.Import(serviceType);
            worker.Emit(OpCodes.Unbox_Any, serviceTypeRef);

            // Cache the singleton method
            _entries[dependency] = getInstanceMethod;
        }

        /// <summary>
        /// Emits the instructions that will instantiate the cached service implementation.
        /// </summary>
        /// <param name="dependency">The dependency that describes the service to be instantiated.</param>
        /// <param name="serviceMap">The service map that contains the list of dependencies in the application.</param>
        /// <param name="targetMethod">The target method.</param>
        public void Emit(IDependency dependency, IDictionary<IDependency, IImplementation> serviceMap, MethodDefinition targetMethod)
        {
            var declaringType = targetMethod.DeclaringType;
            var module = declaringType.Module;

            // Use the ICache instance that resides within the current container
            var cacheType = module.ImportType<ICache>();
            var methodBody = targetMethod.Body;

            var locals = methodBody.Variables;

            var cacheVariable = new VariableDefinition(cacheType);
            locals.Add(cacheVariable);

            var worker = methodBody.GetILProcessor();

            // Convert the token into a System.RuntimeType
            var getTypeFromHandle = module.ImportMethod<Type>("GetTypeFromHandle");

            // var cache = (ICache)container.GetInstance(cacheType, string.Empty);
            var getCacheMethod = typeof(CacheRegistry).GetMethod("GetCache");
            var getCacheInstanceMethod = module.Import(getCacheMethod);

            worker.Emit(OpCodes.Ldarg_0);
            worker.Emit(OpCodes.Call, getCacheInstanceMethod);
            worker.Emit(OpCodes.Stloc, cacheVariable);

            worker.Emit(OpCodes.Ldloc, cacheVariable);

            var createInstance = worker.Create(OpCodes.Nop);
            worker.Emit(OpCodes.Brfalse, createInstance);

            // if (cache != null) {
            var getItemMethod = module.ImportMethod<ICache>("get_Item");

            var cacheKey = string.Format("Hiro Service Instance (ServiceName: {0}, ServiceType: {1}, Hash: {2})",
                dependency.ServiceName,
                dependency.ServiceType,
                dependency.GetHashCode());

            // cachedResult = cache[cacheKey];
            worker.Emit(OpCodes.Ldloc, cacheVariable);
            worker.Emit(OpCodes.Ldstr, cacheKey);
            worker.Emit(OpCodes.Callvirt, getItemMethod);
            worker.Emit(OpCodes.Brfalse, createInstance);

            // if (cachedResult != null)
            //    return cachedResult;
            var endLabel = worker.Create(OpCodes.Nop);

            var objectType = module.ImportType(typeof(object));
            var resultVariable = new VariableDefinition(objectType);
            methodBody.Variables.Add(resultVariable);

            worker.Emit(OpCodes.Ldloc, cacheVariable);
            worker.Emit(OpCodes.Ldstr, cacheKey);
            worker.Emit(OpCodes.Callvirt, getItemMethod);
            worker.Emit(OpCodes.Stloc, resultVariable);
            worker.Emit(OpCodes.Br, endLabel);

            worker.Append(createInstance);

            // Instantiate the actual service instance
            _actualImplementation.Emit(dependency, serviceMap, targetMethod);
            worker.Emit(OpCodes.Stloc, resultVariable);

            // Cache the results
            worker.Emit(OpCodes.Ldloc, cacheVariable);
            worker.Emit(OpCodes.Brfalse, endLabel);

            var setItemMethod = module.ImportMethod<ICache>("set_Item");

            // cache[cacheKey] = result;
            worker.Emit(OpCodes.Ldloc, cacheVariable);
            worker.Emit(OpCodes.Ldstr, cacheKey);
            worker.Emit(OpCodes.Ldloc, resultVariable);
            worker.Emit(OpCodes.Callvirt, setItemMethod);

            worker.Append(endLabel);
            worker.Emit(OpCodes.Ldloc, resultVariable);
        }

        /// <summary>
        /// Defines the nested type that will instantiate the actual singleton service instance.
        /// </summary>
        /// <param name="module">The module that will host the singleton type.</param>
        /// <param name="singletonType">The singleton type.</param>
        /// <param name="instanceField">The field that will hold the singleton instance.</param>
        /// <param name="serviceMap">The service map that contains the list of dependencies in the application.</param>
        /// <param name="implementation">The implementation that will instantiate the dependency.</param>
        /// <param name="dependency">The dependency that will be instantiated by the singleton.</param>
        /// <param name="targetMethod">The method that will be used to instantiate the actual service instance.</param>
        private void DefineNestedType(ModuleDefinition module, TypeDefinition singletonType, FieldDefinition instanceField, IDictionary<IDependency, IImplementation> serviceMap, IImplementation implementation, IDependency dependency, MethodDefinition targetMethod)
        {
            var objectType = module.ImportType(typeof (object));
            var nestedName = string.Format("Nested-{0}", dependency.GetHashCode());

            const TypeAttributes nestedAttributes = TypeAttributes.NestedFamORAssem | TypeAttributes.Sealed | TypeAttributes.AutoClass | TypeAttributes.Class | TypeAttributes.AnsiClass;
            var nestedType = module.DefineClass(nestedName, "Hiro.Containers.Internal", nestedAttributes, objectType);
            singletonType.NestedTypes.Add(nestedType);

            nestedType.Fields.Add(instanceField);

            // Emit the static constructor body
            var cctor = DefineNestedConstructors(module, nestedType);

            EmitSingletonInstantiation(dependency, implementation, serviceMap, instanceField, cctor, module, targetMethod);
        }