C# Type.FindInterfaces方法代码示例

 public static IEnumerable<Type> TypesToGenerateForType(Type type)
 {
   foreach (var interfaceType in type.FindInterfaces((ignored, data) => true, null))
   {
     yield return interfaceType;
   }
   yield return type;
 }

 public RoleSet(Type _Class)
 {
     TypeFilter filter = new TypeFilter(RoleFilter);
     Type[] Roles = _Class.FindInterfaces(filter, (object)__RoleTypes);
     _Set = new HashSet<Type>();
     foreach (Type r in Roles) {
         _Set.Add(r);
     }
 }

 public static bool TypeImplementsInterface(Type type, Type typeToImplement)
 {
     Type[] interfaces = type.FindInterfaces(
             (typ, obj) => typ == typeToImplement,
             type);
     if (interfaces != null && interfaces.Length > 0)
         return true;
     return false;
 }

        /// <summary>
        /// InterfacePresentInClass check that an inteface is implimented for the specific dll type
        /// </summary>
        /// <param name="checkType">The type to check i.e the class</param>
        /// <param name="compareType">The interface type</param>
        /// <returns>Returns true if the interface is implemented in the class</returns>
        public static bool InterfacePresentInType(Type checkType, Type compareType)
        {
            TypeFilter interfaceFilter = InterfaceFilter;
            Type[] list = checkType.FindInterfaces(interfaceFilter, compareType);
            if (list != null && list.Length > 0)
                return true;

            return false;
        }

 private static Type FindCollectionInterface(Type type)
 {
     Type[] array = type.FindInterfaces(new TypeFilter(CollectionUtils.IsCollectionInterface), null);
     if (array.Length == 1)
     {
         return array[0];
     }
     return null;
 }

        private static Type ElementType(Type collectionType)
        {
            Debug.Assert(collectionType != null);
            Debug.Assert(typeof(IEnumerable).IsAssignableFrom(collectionType));

            Type[] stronglyTypedInterfaces = collectionType.FindInterfaces((m, c) => m.IsConstructedGenericType && m.GetGenericTypeDefinition() == typeof(IEnumerable<>), null);

            if (stronglyTypedInterfaces == null || stronglyTypedInterfaces.Length == 0 || stronglyTypedInterfaces.Length > 1)
            {
                return null;  // not a strongly typed collection, or a strongly typed collection of more than one thing (yikes)
            }

            return stronglyTypedInterfaces[0].GetGenericArguments()[0];
        }

        private Type GetInterfaceType(Type type)
        {
            lock (_cacheLock)
            {
                Type interfaceType;

                if (!_cache.TryGetValue(type, out interfaceType))
                {
                    _cache[type] = interfaceType = type.FindInterfaces((t, o) => ((Type[])o).All(c => t == c || !t.IsAssignableFrom(c)), type.GetInterfaces()).Single();
                }

                return interfaceType;
            }
        }

        public static Type FindGenericInterface(Type gType, Type gInterface)
        {
            // maybe gType is generic interface?
            if (gType.IsGenericType && gType.GetGenericTypeDefinition() == gInterface)
                return gType;

            string interfaceName = gInterface.Name;
            Type[] foundInterfaces = gType.FindInterfaces(Module.FilterTypeName, interfaceName);
            if (foundInterfaces != null)
                for (int i = 0; i < foundInterfaces.Length; i++) {
                    Type deff = foundInterfaces[i].GetGenericTypeDefinition();
                    if (deff == gInterface)
                        return foundInterfaces[i];
                }
            return null;
        }

		/// <summary>
		/// true if type is array, IEnumerable, etc
		/// </summary>
		/// <param name="type"></param>
		/// <returns></returns>
		public static bool IsCollectionType(Type type)
		{
			if (type.IsArray) return true;
			if (type == typeof(IList)) return true; 
			if (type == typeof(string)) return false;

			if (type.IsGenericType)
			{
				if (type.GetGenericTypeDefinition() == typeof (IEnumerable<>)) return true;

				var types = type.FindInterfaces((typ, cri) => (
					typ.IsGenericType && typ.GetGenericTypeDefinition() == typeof(IEnumerable<>)), null);
				return types.Length != 0;
			}

			return false;
		}

        public static PropertyInfo[] GetProperties(Type IType, Type clazz)
        {
            PropertyInfo[] pi = IType.GetProperties();
            Type[] interfaces = clazz.FindInterfaces(new TypeFilter(MyInterfaceFilter), IType);

            if (interfaces.Length == 0)
                return pi;

            PropertyInfo[] piChild = interfaces[0].GetProperties();
            if (piChild.Length == 0)
                return pi;

            PropertyInfo[] res = new PropertyInfo[pi.Length + piChild.Length];
            pi.CopyTo(res, 0);
            piChild.CopyTo(res, pi.Length);
            return res;
        }

		protected void CollectMethodsToProxy(ArrayList methodList, Type type, bool onlyVirtuals)
		{
			CollectMethods(methodList, type, onlyVirtuals);

			if (type.IsInterface)
			{
				Type[] typeChain = type.FindInterfaces(new TypeFilter(NoFilter), null);

				foreach(Type interType in typeChain)
				{
					CollectMethods(methodList, interType, onlyVirtuals);
				}
			}
		}

        /// <summary>
        /// Returns the "T" in the IQueryable of T implementation of type.
        /// </summary>
        /// <param name="type">Type to check.</param>
        /// <param name="typeFilter">filter against which the type is checked</param>
        /// <returns>
        /// The element type for the generic IQueryable interface of the type,
        /// or null if it has none or if it's ambiguous.
        /// </returns>
        internal static Type GetGenericInterfaceElementType(Type type, TypeFilter typeFilter)
        {
            Debug.Assert(type != null, "type != null");
            Debug.Assert(!type.IsGenericTypeDefinition, "!type.IsGenericTypeDefinition");

            if (typeFilter(type, null))
            {
                return type.GetGenericArguments()[0];
            }

            Type[] queriables = type.FindInterfaces(typeFilter, null);
            if (queriables != null && queriables.Length == 1)
            {
                return queriables[0].GetGenericArguments()[0];
            }
            else
            {
                return null;
            }
        }

		private static MethodInfo FindInterfaceMethod( Type targetType, Type interfaceType, string name, Type[] parameterTypes )
		{
			if ( targetType.GetIsInterface() )
			{
				return targetType.FindInterfaces( ( type, _ ) => type == interfaceType, null ).Single().GetMethod( name, parameterTypes );
			}

			var map = targetType.GetInterfaceMap( interfaceType );

#if !SILVERLIGHT
			int index = Array.FindIndex( map.InterfaceMethods, method => method.Name == name && method.GetParameters().Select( p => p.ParameterType ).SequenceEqual( parameterTypes ) );
#else
			int index = map.InterfaceMethods.FindIndex( method => method.Name == name && method.GetParameters().Select( p => p.ParameterType ).SequenceEqual( parameterTypes ) );
#endif

			if ( index < 0 )
			{
#if DEBUG
				Contract.Assert( false, interfaceType + "::" + name + "(" + String.Join( ", ", parameterTypes.Select( t => t.ToString() ).ToArray() ) + ") is not found in " + targetType );
#endif
				return null;
			}
			else
			{
				return map.TargetMethods[ index ];
			}
		}

        /// <summary>
        /// Finds and returns the constructed type of an interface 
        /// generic type definition if the type implements it. Otherwise
        /// returns a <c>null</c> reference.
        /// </summary>
        /// <exception cref="System.ArgumentNullException">
        /// Either <paramref name="type"/> or <paramref name="genericTypeDefinition"/> 
        /// is a null reference.
        /// </exception>

        internal static Type FindConstructionOfGenericInterfaceDefinition(Type type, Type genericTypeDefinition)
        {
            if (type == null) throw new ArgumentNullException("type");
            if (genericTypeDefinition == null) throw new ArgumentNullException("genericTypeDefinition");

            Type[] interfaces = type.FindInterfaces(new TypeFilter(IsConstructionOfGenericInterfaceDefinition), genericTypeDefinition);
            return interfaces.Length == 0 ? null : interfaces[0];
        }

        /// <summary>
        /// Selects the range of all the lists that are keyed on the type
        /// name given or the name of any parent class or interface. For
        /// example, giving typeof(string) will return any for
        /// "System.String" or "System.Object" and so on.
        /// </summary>
        public IList Select(Type type)
        {
            // Create a list
            ArrayList list = new ArrayList();

            // Ignore nulls (since that happens at the top-most object)
            if (type == null)
                return list;

            // Add this type's keys
            IList l = (IList) lists[type.FullName];

            if (l != null)
                list.AddRange(l);

            // Add the base types
            list.AddRange(Select(type.BaseType));

            // Add the interfaces, if any
            Type [] interfaces
                = type.FindInterfaces(new TypeFilter(FindAllTypes), null);

            foreach (Type iType in interfaces)
                list.AddRange(Select(iType));

            // Return the list
            return list;
        }