C# Type.Where方法代码示例

        public void GenerateCode(Type[] types)
        {
            var actorTypes = types.Where(t => Utility.IsActorInterface(t)).ToArray();
            var observerTypes = types.Where(t => Utility.IsObserverInterface(t)).ToArray();

            var actorCodeGen = new InterfacedActorCodeGenerator() { Options = Options };
            foreach (var type in actorTypes)
                actorCodeGen.GenerateCode(type, CodeWriter);

            var observerCodeGen = new InterfacedObserverCodeGenerator() { Options = Options };
            foreach (var type in observerTypes)
                observerCodeGen.GenerateCode(type, CodeWriter);
        }

 static Type GetServiceSpecification(Type[] types)
 {
     return types
         .Where(x => x.HasInterface<IServiceSpecification>())
         .DefaultIfEmpty(typeof(DefaultServiceSpecification))
         .FirstOrDefault();
 }

 public void CheckTables(Type[] types, int unitNumber)
 {
     foreach (var type in types.Where(type => !TableExist(type.Name + unitNumber.ToString())))
     {
         CreateTable(type);
     }
 }

 public static ComponentInfo[] GetComponentInfos(Type[] types)
 {
     return types
         .Where(type => !type.IsInterface)
         .Where(type => type.GetInterfaces().Any(i => i.FullName == "Entitas.IComponent"))
         .Select(type => CreateComponentInfo(type))
         .ToArray();
 }

 public static Type[] TargetTypesToRun(Type[] availableTypes)
 {
     var targetTypesToRun = availableTypes
     .Where(t => !t.IsAbstract &&  t.IsSubclassOf(typeof(Spec)))
     .Select(t => t)
     .ToArray();
       return targetTypesToRun;
 }

 public static Type[] GetSystems(Type[] types) {
     return types
         .Where(type => !type.IsInterface
             && type != typeof(ReactiveSystem)
             && type != typeof(Systems)
             && type.GetInterfaces().Contains(typeof(ISystem)))
         .ToArray();
 }

 /// <summary>
 /// Provides the ability to pass in and configure femah with a predefined collection of FeatureSwitchTypes, i.e. those 
 /// types implementing IFeatureSwitch.  Predominantly used for unit testing purposes, allowing us to configure femah with
 /// a known subset of FeatureSwitchTypes.
 /// </summary>
 /// <param name="types" type="Type[]">An array containing the FeatureSwitchTypes to configure</param>
 /// <returns type="FemahFluentConfiguration" />
 public FemahFluentConfiguration WithSelectedFeatureSwitchTypes(Type[] types)
 {
     foreach (var t in types.Where(t => t.GetInterfaces().Contains(typeof(IFeatureSwitch))))
     {
         _config.StandardSwitchTypes.Add(t);
     }
     return this;
 }

 public IEnumerable<SqlQuery> PrepareQueries(Type[] types, bool onlyEnabledQueries = true)
 {
     // Search for types with at least one attribute that have a QueryAttribute
     return types.Where(t => !_ignoreTypes.Contains(t))
                 .SelectMany(t => t.GetCustomAttributes<QueryAttribute>()
                                   .Where(a => !onlyEnabledQueries || a.Enabled)
                                   .Select(a => new SqlQuery(t, a, _dapper)))
                 .ToArray();
 }

 public object Create(Type[] typesToProxy, object[] constructorArguments)
 {
     var callRouter = _callRouterFactory.Create(_context);
     var primaryProxyType = GetPrimaryProxyType(typesToProxy);
     var additionalTypes = typesToProxy.Where(x => x != primaryProxyType).ToArray();
     var proxy = _proxyFactory.GenerateProxy(callRouter, primaryProxyType, additionalTypes, constructorArguments);
     _callRouterResolver.Register(proxy, callRouter);
     return proxy;
 }

        public BaseApp FindBaseApp(Type[] assemblyTypes)
        {
            foreach (var t in assemblyTypes.Where(t => t.BaseType == typeof(BaseApp)))
            {
                return (BaseApp) Activator.CreateInstance(t);
            }

            throw new TypeLoadException("No class found subclassing BaseApp");
        }

        public static void ConfigureMapper(Type[] types)
        {
            var mapTypes = types.Where(t=>IsDefined(t,typeof(AutoMapAttribute))
                                    ||IsDefined(t,typeof(AutoMapFromAttribute))
                                    ||IsDefined(t,typeof(AutoMapToAttribute)));

            foreach (var type in mapTypes)
            {
                MapType(type);
            }
        }

 public CodeGenFile[] Generate(Type[] components) {
     return components
             .Where(shouldGenerate)
             .Aggregate(new List<CodeGenFile>(), (files, type) => {
                 files.Add(new CodeGenFile {
                     fileName = type + CLASS_SUFFIX,
                     fileContent = generateComponentExtension(type).ToUnixLineEndings()
                 });
                 return files;
             }).ToArray();
 }

 public CodeGenFile[] Generate(Type[] components)
 {
     return components
             .Where(shouldGenerate)
             .Aggregate(new List<CodeGenFile>(), (files, type) => {
                 files.Add(new CodeGenFile {
                     fileName = type + classSuffix,
                     fileContent = generateComponentExtension(type)
                 });
                 return files;
             }).ToArray();
 }

 public CodeGenFile[] Generate(Type[] systems) {
     return systems
             .Where(type => type.GetConstructor(new Type[0]) != null)
             .Aggregate(new List<CodeGenFile>(), (files, type) => {
                 files.Add(new CodeGenFile {
                     fileName = type + CLASS_SUFFIX,
                     fileContent = string.Format(CLASS_TEMPLATE, type.Name, type).ToUnixLineEndings()
                 });
                 return files;
                 })
             .ToArray();
 }

        public static ResourceQuery ParseUrnQuery(this Uri urn, Type [] models)
        {
            var urlModelLookup = models
                .Where(type => type.ContainsCustomAttribute<ResourceTypeAttribute>())
                .Select(type =>
                {
                    var resourceTypeAttr = type.GetCustomAttribute<ResourceTypeAttribute>();
                    return new KeyValuePair<string, Type>(resourceTypeAttr.Urn, type);
                })
                .ToDictionary();

            return new ResourceQuery();
        }