C# ILifetimeScope.Debug方法代码示例

        object buildFromGenericByUsingAGenerator(ILifetimeScope lifetimeScope, Type genericInterface)
        {
            Debug.Assert(genericInterface.IsInterface && genericInterface.IsGenericType && !genericInterface.IsGenericTypeDefinition);
            var def = genericInterface.GetGenericTypeDefinition();

            var factoryMethod = tryResolveFactoryMethod(def);

            if (factoryMethod == null)
                throw new ResolveException("failed to resolve generic type {0}: failed to resolve interface", genericInterface);

            var arguments = genericInterface.GetGenericArguments();
            var methodTypeArguments = factoryMethod.GetGenericArguments();
            if (arguments.Length != methodTypeArguments.Length)
                throw new ResolveException("failed to find generators method for type {0}, number of type arguments are not matching", genericInterface);

            var concreteMethod = factoryMethod.MakeGenericMethod(arguments);

            var generated_ = callStaticMethod(lifetimeScope, concreteMethod);
            // a generated object must be owned by the scope!
            lifetimeScope.own(generated_);

            lifetimeScope.Debug("gent {2,8:X}: {0} => {1}".fmt(genericInterface.Name, generated_, generated_ == null ? 0 : (uint)generated_.GetHashCode()));

            return generated_;
        }

        /*
            This method is the only entry point to build and instantiate an instance of type t that is
            bound to the given lifetime scope.
        */
        object IKonstruktor.build(ILifetimeScope lifetimeScope, Type t)
        {
            #if DEBUG
            lifetimeScope.Debug("building {0}".fmt(t.Name));

            Debug.Assert(_frozen);
            #endif
            Func<ILifetimeScope, object> explicitGenerator;
            if (_explicitGenerators.TryGetValue(t, out explicitGenerator))
                return buildByExplicitGenerator(explicitGenerator, lifetimeScope);

            return t.IsInterface ? buildFromInterface(lifetimeScope, t) : instantiate(lifetimeScope, t);
        }

        object instantiateByReflectionConstructor(ILifetimeScope lifetimeScope, Type t)
        {
            var constructors = t.GetConstructors();
            if (constructors.Length == 0)
                throw new ResolveException("failed to instantiate type {0}: no public constructor", t);

            var constructor = selectPreferredConstructor(constructors);
            var parameters = constructor.GetParameters();

            var resolvedObjects = new object[parameters.Length];

            foreach (var p in parameters.indices())
            {
                var obj = lifetimeScope.resolve(parameters[p].ParameterType);
                resolvedObjects[p] = obj;
            }

            var instance = constructor.Invoke(resolvedObjects);

            lifetimeScope.Debug("inst {2,8:X}: {0} => {1}".fmt(t.Name, instance, (uint)instance.GetHashCode()));

            return instance;
        }