C# Type.GetConstructors方法代码示例

        public static RuleRewriter Create(Type type, ISettings settings, Func<SemanticModel> semanticModel)
        {
            // A dictionary of all recognised constructor parameters.
            Dictionary<Type, Func<object>> parameterTypes = new Dictionary<Type, Func<object>>
            {
                { typeof(ISettings), () => settings },
                { typeof(SemanticModel), semanticModel },
            };

            // Get a list of the type's constructors together with the constructor parameters types,
            // ordered by number of parameters descending.
            var ctors = (from c in type.GetConstructors()
                         select new
                         {
                             ConstructorInfo = c,
                             Parameters = c.GetParameters()
                         }).OrderByDescending(x => x.Parameters.Length).ToArray();

            // Get the first constructor in which we recognise all parameter types.
            var ctor = ctors.FirstOrDefault(x => x.Parameters.All(p => parameterTypes.Keys.Contains(p.ParameterType)));

            object[] parameters = ctor.Parameters.Select(x => parameterTypes[x.ParameterType]()).ToArray();

            return (RuleRewriter)ctor.ConstructorInfo.Invoke(parameters);
        }

        public DataRowKeyInfoHelper(Type type)
        {
            this.type = type;

            this.properties = type
                .GetProperties()
                .Select(p => new {
                    Property = p,
                    Attribute = p.GetCustomAttributes(false)
                        .OfType<DataRowPropertyAttribute>()
                        .SingleOrDefault()
                })
                .Where(x => x.Attribute != null)
                .OrderBy(x => x.Attribute.Index)
                .Select(x => x.Property)
                .ToArray();

            this.ctor = type
                .GetConstructors()
                .Single();

            this.isLarge = this.type
                .GetCustomAttributes(false)
                .OfType<LargeDataRowAttribute>()
                .Any();
        }

        public static object Object(this DomainGenerator domaingenerator, Type type)
        {
            if (domaingenerator.constructionConventions.ContainsKey(type))
                return domaingenerator.constructionConventions[type]();

            var choiceConvention = domaingenerator.choiceConventions.FirstOrDefault(c => c.Type == type);
            if (choiceConvention != null)
                return choiceConvention.Possibilities.PickOne();

            var isPrimitiveGenerator = primitiveGenerators.Get(type);
            if (isPrimitiveGenerator != null)
            {
                return isPrimitiveGenerator.RandomAsObject();
            }

            var publicConstructors =
                type.GetConstructors(DomainGenerator.FlattenHierarchyBindingFlag);

            if (publicConstructors.Count() > 0)
            {
                var highestParameterCount = publicConstructors.Max(c => c.GetParameters().Count());
                var constructor = publicConstructors.First(c => c.GetParameters().Count() == highestParameterCount);
                return Construct(domaingenerator, constructor, highestParameterCount);
            }

            var allConstructors = type.GetConstructors(DomainGenerator.FlattenHierarchyBindingFlag);
            if (allConstructors.Count() > 0)
            {
                var highestParameterCount = allConstructors.Max(c => c.GetParameters().Count());
                var constructor = allConstructors.First(c => c.GetParameters().Count() == highestParameterCount);
                return Construct(domaingenerator, constructor, highestParameterCount);
            }
            return Activator.CreateInstance(type);
        }

        private ConstructorInfo GetConstructor(Type type)
        {
            ConstructorInfo constructor;
            if (constructors.TryGetValue(type, out constructor))
            {
                return constructor;
            }
            lock (syncHelper)
            {
                if (constructors.TryGetValue(type, out constructor))
                {
                    return constructor;
                }

                var candidates = type.GetConstructors().Where(c => c.GetCustomAttributes<InjectionAttribute>().Any());
                if (!candidates.Any())
                {
                    candidates = type.GetConstructors();
                }

                candidates = candidates.OrderByDescending(c => c.GetParameters().Count());
                constructor = candidates.FirstOrDefault();

                if (null == constructor)
                {
                    throw new ArgumentException("Cannot instantiate...", "type");
                }
                constructors[type] = constructor;
                return constructor;
            }
        }

        /// <summary>
        ///   Gets the given <paramref name="implementationType" />'s constructor that can be used by the
        ///   container to create that instance.
        /// </summary>
        /// <param name="serviceType">Type of the abstraction that is requested.</param>
        /// <param name="implementationType">Type of the implementation to find a suitable constructor for.</param>
        /// <returns>
        ///   The <see cref="T:System.Reflection.ConstructorInfo" />.
        /// </returns>
        /// <exception cref="T:SimpleInjector.ActivationException">Thrown when no suitable constructor could be found.</exception>
        public ConstructorInfo GetConstructor(Type serviceType, Type implementationType)
        {
            // note: this I want in the future to be pushed out to a rule overrides folder
            if (typeof(EntitiesContext).IsAssignableFrom(implementationType))
            {
                var defaultconstructor =
                    (from constructor in implementationType.GetConstructors()
                     where constructor.GetParameters().Count() == 0
                     select constructor).Take(1);

                if (defaultconstructor.Any()) return defaultconstructor.First();
            }

            if (serviceType.IsAssignableFrom(implementationType))
            {
                var longestConstructor =
                    (from constructor in implementationType.GetConstructors()
                     orderby constructor.GetParameters().Count() descending
                     select constructor).Take(1);

                if (longestConstructor.Any()) return longestConstructor.First();
            }

            // fall back to the container's default behavior.
            return _originalBehavior.GetConstructor(serviceType, implementationType);
        }

 public static void WarmInstanceConstructor(Type type)
 {
     if (!activators.ContainsKey(type))
     {
         var constructors = type.GetConstructors();
         if (constructors.Length == 1)
         {
             ConstructorInfo ctor = type.GetConstructors().First();
             activators.TryAdd(type, GetActivator(ctor));
         }
     }
 }

        public override ConstructorInfo GetConstructor(Type type)
        {
            var maxlen = type.GetConstructors().Max(x => x.GetParameters().Length);
            var candidates = type.GetConstructors()
                .Where(x => x.GetParameters().Length == maxlen)
                .ToArray();

            if (candidates.Length > 1)
                throw new DependencyConstructorException("Type {0} has at least two longest constructors", type.FullName);

            if (candidates.Length == 1)
                return candidates.First();

            return Next.GetConstructor(type);
        }

        public static Type GenerateType(Type baseType, IEnumerable<Type> interfaceTypes)
        {
            var newType = dynamicModule.DefineType(
                Prefix + "." + baseType.GetName(),
                TypeAttributes.AutoLayout | TypeAttributes.Public | TypeAttributes.Class,
                baseType);

            interfaceTypes.Each(interfaceType =>
            {
                newType.AddInterfaceImplementation(interfaceType);
                interfaceType.GetMethods().Each(method =>
                {
                    ImplementInterfaceMethod(newType, method);
                });
            });

            baseType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Each(constructor =>
            {
                switch (constructor.Attributes & MethodAttributes.MemberAccessMask)
                {
                    case MethodAttributes.Family:
                    case MethodAttributes.Public:
                    case MethodAttributes.FamORAssem:
                        ImplementConstructor(newType, constructor);
                        break;
                }
            });

            return newType.CreateType();
        }

 private static object CreateSubscriber(Type subscriberType)
 {
     var constructor = subscriberType.GetConstructors()[0];
     var parameterValues = new List<object>();
     constructor.GetParameters().ForEach(parameterInfo => parameterValues.Add(GetValueForType(parameterInfo.ParameterType)));
     return constructor.Invoke(parameterValues.ToArray());
 }

        public static Type GenerateType(string dynamicTypeName, Type baseType, Type interfaceType)
        {
            TypeBuilder newType = _dynamicModule.DefineType(
                "Xunit.{Dynamic}." + dynamicTypeName,
                TypeAttributes.AutoLayout | TypeAttributes.Public | TypeAttributes.Class,
                baseType
            );

            newType.AddInterfaceImplementation(interfaceType);

            foreach (MethodInfo interfaceMethod in interfaceType.GetMethods())
                ImplementInterfaceMethod(newType, interfaceMethod);

            foreach (ConstructorInfo ctor in baseType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
                switch (ctor.Attributes & MethodAttributes.MemberAccessMask)
                {
                    case MethodAttributes.Family:
                    case MethodAttributes.Public:
                    case MethodAttributes.FamORAssem:
                        ImplementConstructor(newType, ctor);
                        break;
                }

            return newType.CreateType();
        }

        /// <summary>
        /// Verify the expectations on a message type.
        /// </summary>
        /// <param name="type">The message type to assert on.</param>
        private static void TestType(Type type)
        {
            // get the fields of the type
            FieldInfo[] fields = type.GetFields();

            // all fields must be public readonly
            Assert.IsTrue(fields.All(f => f.IsPublic && f.IsInitOnly),
                "All fields must be marked public readonly. Not conforming:  {0}",
                fields.Where(f => !(f.IsPublic && f.IsInitOnly)).Select(f => f.Name).ToArray());

            // get the constructors of the type
            ConstructorInfo[] constructors = type.GetConstructors();

            // the type must have exactly one constructor
            Assert.Count(1, constructors, "The message type has {0} constructors and must have exactly 1", constructors.Count());
            ConstructorInfo constructor = constructors.Single();

            // get the parameters of the constructor
            ParameterInfo[] parameters = constructor.GetParameters();

            // the parameter count must be exactly as the field count
            Assert.Count(fields.Count(), parameters,
                "The constructor parameter {0} count must be the same as the field count {1} .", parameters.Count(), fields.Count());

            // get the names of the fields
            IEnumerable<string> fieldNames = fields.Select(f => f.Name.ToLowerInvariant());

            // get the names of the constructor parameters
            IEnumerable<string> paramNames = parameters.Select(p => p.Name.ToLowerInvariant());

            // assert they are the same
            Assert.AreElementsEqualIgnoringOrder(fieldNames, paramNames);
        }

        /// <summary>
        /// Selects the constructor marked with <see cref="ConstructAttribute"/>
        /// or with the minimum amount of parameters.
        /// </summary>
        /// <param name="type">Type from which reflection will be resolved.</param>
        /// <returns>The constructor.</returns>
        protected ConstructorInfo ResolveConstructor(Type type)
        {
            var constructors = type.GetConstructors(
                BindingFlags.FlattenHierarchy |
                BindingFlags.Public |
                BindingFlags.Instance |
                BindingFlags.InvokeMethod);

            if (constructors.Length == 0) {
                return null;
            }

            if (constructors.Length == 1) {
                return constructors[0];
            }

            ConstructorInfo shortestConstructor = null;
            for (int i = 0, length = 0, shortestLength = int.MaxValue; i < constructors.Length; i++) {
                var constructor = constructors[i];

                object[] attributes = constructor.GetCustomAttributes(typeof(Construct), true);

                if (attributes.Length > 0) {
                    return constructor;
                }

                length = constructor.GetParameters().Length;
                if (length < shortestLength) {
                    shortestLength = length;
                    shortestConstructor = constructor;
                }
            }

            return shortestConstructor;
        }

        public virtual object ResolveUnregistered(Type type)
        {
            var constructors = type.GetConstructors();
            foreach (var constructor in constructors)
            {
                try
                {
                    var parameters = constructor.GetParameters();
                    var parameterInstances = new List<object>();
                    foreach (var parameter in parameters)
                    {
                        var service = _container.Resolve(parameter.ParameterType);
                        if (service == null) throw new CoreException("Unkown dependency");
                        parameterInstances.Add(service);
                    }
                    return Activator.CreateInstance(type, parameterInstances.ToArray());
                }
                catch (CoreException)
                {

                }
            }

            throw new CoreException("No contructor was found that had all the dependencies satisfied.");
        }

        // Creates a new dynamic type that is a subclassed type of baseType and also implements methods of the specified
        // interfaces. The base type must already have method signatures that implicitly implement the given
        // interfaces. The signatures of all public (e.g. not private / internal) constructors from the baseType
        // will be duplicated for the subclassed type and the new constructors made public.
        public static Type GenerateType(string dynamicTypeName, Type baseType, IEnumerable<Type> interfaceTypes)
        {
            var newType = _dynamicModule.DefineType(
                "System.Web.Mvc.{Dynamic}." + dynamicTypeName,
                TypeAttributes.AutoLayout | TypeAttributes.Public | TypeAttributes.Class,
                baseType);

            foreach (Type interfaceType in interfaceTypes)
            {
                newType.AddInterfaceImplementation(interfaceType);
                foreach (MethodInfo interfaceMethod in interfaceType.GetMethods())
                {
                    ImplementInterfaceMethod(newType, interfaceMethod);
                }
            }

            // generate new constructors for each accessible base constructor
            foreach (ConstructorInfo ctor in baseType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
            {
                switch (ctor.Attributes & MethodAttributes.MemberAccessMask)
                {
                    case MethodAttributes.Family:
                    case MethodAttributes.Public:
                    case MethodAttributes.FamORAssem:
                        ImplementConstructor(newType, ctor);
                        break;
                }
            }

            Type bakedType = newType.CreateType();
            return bakedType;
        }

        public static object CreateAnonymous(this DbDataReader reader, Type type, QueryMap queryMap)
        {
            var ctor = type.GetConstructors()[0];
            var pp = ctor.GetParameters();
            var args = new object[pp.Length];
            QueryMap map2 = null;
            for (var i = 0; i < args.Length; i++)
            {
                var name = pp[i].Name;
                var map = queryMap.FirstOrDefault(_ => _.MemberPath.Sections[0] == name);
                if (map.MemberPath.Length == 1)
                {
                    args[i] = reader[map.ColumnAlias];
                }
                else
                {
                    if (map2 == null)
                    {
                        map2 = queryMap.LeftShift(1);
                    }
                    args[i] = Create(reader, pp[i].ParameterType, map2);
                }
            }

            return ctor.Invoke(args.ToArray());
        }