C# IEnumerable.Where方法代码示例

        private  XElement ASIC(IEnumerable<XElement> rows) {
            bool hasASIC = rows.Where(x => x.Element("COMMODITYCLASS").Value == "ASIC").Any();
               if (hasASIC)
               {
                   XElement asic = new XElement("ASIC");
                   IEnumerable<string> orderkeys = rows.Where(x => x.Element("COMMODITYCLASS").Value == "ASIC").Select(x => x.Element("ORDERKEY").Value).Distinct();
                   foreach (string orderkey in orderkeys)
                   {
                       //表头/表体分组
                       XElement orderel = new XElement("ORDER");
                       orderel.Add(new XElement("ORDERKEY", orderkey));
                       string externorderkey = rows.Where(x =>
                           x.Element("ORDERKEY").Value == orderkey &&
                           x.Element("COMMODITYCLASS").Value == "ASIC").Select(x => x.Element("EXTERNORDERKEY").Value).First();
                       orderel.Add(new XElement("EXTERNORDERKEY", externorderkey));
                       string comcode = rows.Where(x =>
                           x.Element("ORDERKEY").Value == orderkey &&
                           x.Element("COMMODITYCLASS").Value == "ASIC").Select(x => x.Element("COMCODE").Value).First();
                       orderel.Add(new XElement("COMCODE", comcode));
                       XElement orderdetail = new XElement("ORDERDETAIL");
                       IEnumerable<XElement> detail = rows.Where(x =>
                           x.Element("ORDERKEY").Value == orderkey &&
                           x.Element("COMMODITYCLASS").Value == "ASIC").ToArray();
                       //orderdetail.Add(detail);
                       orderel.Add(detail);
                       asic.Add(orderel);

                   }
                   return asic;

               }
               else {
                   return null;
               }
        }

        private static void AbilityAnalyzer(ILogMetrics data, IEnumerable<LogEntry> log)
        {
            var abilityNames = log.Where(m => m.ability.name != "").Select(m => m.ability.name).Distinct();
            foreach (var name in abilityNames)
            {
                var metrics = new AbilityMetrics();
                var abilityLog = log.Where(m => m.ability.name == name);

                var damageLog = abilityLog.DamageEffects();
                var healingLog = abilityLog.HealingEffects();
                var threatLog = abilityLog.ThreatEffects();

                data.AbilityMetrics.Add(metrics);

                metrics.Name = name;
                metrics.Number = abilityLog.First().ability.number;
                metrics.Count = abilityLog.Count();
                
                metrics.MaximumDamage = damageLog.IfEmpty(0, l => l.Max(m => m.result.amount));
                metrics.MinimumDamage = damageLog.IfEmpty(0, l => l.Min(m => m.result.amount));
                metrics.AverageDamage = damageLog.IfEmpty(0, l => l.Average(m => m.result.amount));

                metrics.MaximumHealing = healingLog.IfEmpty(0, l => l.Max(m => m.result.amount));
                metrics.MinimumHealing = healingLog.IfEmpty(0, l => l.Min(m => m.result.amount));
                metrics.AverageHealing = healingLog.IfEmpty(0, l => l.Average(m => m.result.amount));

                metrics.MaximumThreat = threatLog.IfEmpty(0, l => l.Max(m => m.result.amount));
                metrics.MinimumThreat = threatLog.IfEmpty(0, l => l.Min(m => m.result.amount));
                metrics.AverageThreat = threatLog.IfEmpty(0, l => l.Average(m => m.result.amount));

                metrics.CountOfCriticals = abilityLog.Where(m => m.result.isCritical).Count();
            }
            data.AbilityMetrics = data.AbilityMetrics.OrderByDescending(m => m.Count).ThenBy(m => m.Name).ToList();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ClassTypeTree"/> class.
        /// </summary>
        /// <param name="types">The types to build the tree out of.</param>
        public ClassTypeTree(IEnumerable<Type> types)
        {
            // ReSharper disable DoNotCallOverridableMethodsInConstructor

            var childList = new List<ClassTypeTree>();

            // Remove duplicates
            types = types.Where(x => x.IsClass).Distinct();

            // Grab the lowest-level types
            var baseTypes = types.Where(x => !types.Any(y => x != y && y.IsAssignableFrom(x)));

            // Grab the possible child types
            var remainingTypes = types.Except(baseTypes);
            foreach (var bt in baseTypes)
            {
                // Recursively build the tree
                childList.Add(CreateNode(this, bt, remainingTypes));
            }

            // Add the wildcard for the base level
            childList.Add(CreateNode(this, null, null));

            // Store the children
            _children = FinalizeChildren(childList);

            // ReSharper restore DoNotCallOverridableMethodsInConstructor
        }

 protected SpecificationContainer(IEnumerable<Specification> specifications)
 {
   _totalSpecifications = specifications.Count();
   _passingSpecifications = specifications.Where(x => x.Status == Status.Passing).Count();
   _failingSpecifications = specifications.Where(x => x.Status == Status.Failing).Count();
   _notImplementedSpecifications = specifications.Where(x => x.Status == Status.NotImplemented).Count();
 }

        private static IEnumerable<LaneModel> GetOrderedLanes(IEnumerable<LaneModel> laneStats)
        {
            var orderedLaneStats = new List<LaneModel>();

            Func<LaneModel, bool> backLogPred = x => x.ClassType == LaneClassType.Backlog && x.Relation != "child";
            Func<LaneModel, bool> activePred = x => x.ClassType == LaneClassType.Active;
            Func<LaneModel, bool> archivePred = x => x.ClassType == LaneClassType.Archive && x.Relation != "child";

            if (laneStats.Any(backLogPred))
            {
                orderedLaneStats.AddRange(laneStats.Where(backLogPred).OrderBy(x => x.Index));
            }

            if (laneStats.Any(activePred))
            {
                orderedLaneStats.AddRange(laneStats.Where(activePred).OrderBy(x => x.Index));
            }

            if (laneStats.Any(archivePred))
            {
                orderedLaneStats.AddRange(laneStats.Where(archivePred).OrderBy(x => x.Index));
            }

            return orderedLaneStats;
        }

        //public void CallInitMethods(IEnumerable<string> initMethodNames, IEnumerable<string> endMethodNames, Func<string, MethodInfo> getMethod)
        //{
        //    Dictionary<string, MethodInfo> initMethods = CreateDictionary(initMethodNames);
        //    Dictionary<string, MethodInfo> endMethods = CreateDictionary(endMethodNames);

        //    bool callInit = _callInit;

        //    //if (forceCallInit)
        //    //    callInit = true;

        //    // check if init methods or end methods change
        //    if (!callInit && (!MethodsEquals(_initMethods, initMethods) || !MethodsEquals(_endMethods, endMethods)))
        //        callInit = true;


        //    if (callInit)
        //    {
        //        CallEndMethods();

        //        GetMethods(initMethods, getMethod);
        //        GetMethods(endMethods, getMethod);
        //        _initMethods = initMethods;
        //        _endMethods = endMethods;
        //        CallMethods(_initMethods, init: true);
        //        _callInit = false;
        //    }
        //}

        // callInit
        public void CallInitMethods(IEnumerable<InitEndMethod> initMethods, IEnumerable<InitEndMethod> endMethods, bool callInitRunOnce, Func<string, MethodInfo> getMethod)
        {
            Dictionary<string, MethodInfo> initMethodsRunAlways = CreateDictionary(initMethods.Where(method => method.RunType == RunType.Always).Select(method => method.Name));
            Dictionary<string, MethodInfo> endMethodsRunAlways = CreateDictionary(endMethods.Where(method => method.RunType == RunType.Always).Select(method => method.Name));
            Dictionary<string, MethodInfo> initMethodsRunOnce = CreateDictionary(initMethods.Where(method => method.RunType == RunType.Once).Select(method => method.Name));
            Dictionary<string, MethodInfo> endMethodsRunOnce = CreateDictionary(endMethods.Where(method => method.RunType == RunType.Once).Select(method => method.Name));

            //bool callInit = _callInit;

            // check if init methods or end methods change
            if (!callInitRunOnce && (!MethodsEquals(_initMethodsRunOnce, initMethodsRunOnce) || !MethodsEquals(_endMethodsRunOnce, endMethodsRunOnce)))
                callInitRunOnce = true;

            if (callInitRunOnce)
                CallEndMethodsRunOnce();

            CallEndMethodsRunAlways();

            if (callInitRunOnce)
            {
                GetMethods(initMethodsRunOnce, getMethod);
                GetMethods(endMethodsRunOnce, getMethod);
                _initMethodsRunOnce = initMethodsRunOnce;
                _endMethodsRunOnce = endMethodsRunOnce;
                CallMethods(_initMethodsRunOnce, always: false, init: true);
                _callInitRunOnce = false;
            }

            GetMethods(initMethodsRunAlways, getMethod);
            GetMethods(endMethodsRunAlways, getMethod);
            _endMethodsRunAlways = endMethodsRunAlways;
            CallMethods(initMethodsRunAlways, always: true, init: true);
        }

        public StringBuilder GenerateContent(string requestPath, IEnumerable<IFileInfo> contents)
        {
            if (contents == null)
            {
                throw new ArgumentNullException("contents");
            }

            var builder = new StringBuilder();
            builder.AppendFormat("{0}\r\n", requestPath);
            builder.Append("\r\n");

            foreach (var subdir in contents.Where(info => info.IsDirectory))
            {
                builder.AppendFormat("{0}/\r\n", subdir.Name);
            }
            builder.Append("\r\n");

            foreach (var file in contents.Where(info => !info.IsDirectory))
            {
                builder.AppendFormat("{0}, {1}, {2}\r\n", file.Name, file.Length, file.LastModified);
            }
            builder.Append("\r\n");

            return builder;
        }

        public IEnumerable<IOperation> Process(IEnumerable<IOperation> operations)
        {
            var operation = operations.Where(x => x.GetRequestCodec() != null)
                                .OrderByDescending(x => x.GetRequestCodec()).FirstOrDefault()
                            ?? operations.Where(x => x.Inputs.AllReady())
                                   .OrderByDescending(x => x.Inputs.CountReady()).FirstOrDefault();
            if (operation == null)
            {
                Log.OperationNotFound();
                yield break;
            }

            Log.OperationFound(operation);

            if (operation.GetRequestCodec() != null)
            {
                var codecInstance = CreateMediaTypeReader(operation);

                var codecType = codecInstance.GetType();
                Log.CodecLoaded(codecType);

                if (codecType.Implements(typeof(IKeyedValuesMediaTypeReader<>)))
                    if (TryAssignKeyedValues(_request.Entity, codecInstance, codecType, operation))
                    {
                        yield return operation;
                        yield break;
                    }

                if (codecType.Implements<IMediaTypeReader>())
                    if (!TryReadPayloadAsObject(_request.Entity, (IMediaTypeReader)codecInstance, operation))
                        yield break;
            }
            yield return operation;
        }

        public void PlaySounds(IEnumerable<ProjectStatus> currentBuildData)
        {
            var newlyBrokenBuilds =
                currentBuildData.Where(proj => proj.IsBroken)
                                .Intersect(_previousBuildData.Where(proj => !proj.IsBroken));

            if (newlyBrokenBuilds.Any())
            {
                _audioPlayer.Play(_brokenBuildSound);
                _audioPlayer.Say(_speechMaker.BuildIsBroken(newlyBrokenBuilds));
            }
            else
            {
                var newlyFixedBuilds =
                    currentBuildData.Where(proj => proj.IsSuccessful)
                                    .Intersect(_previousBuildData.Where(proj => !proj.IsSuccessful));

                if (newlyFixedBuilds.Any())
                {
                    _audioPlayer.Play(_fixedBuildSound);
                    _audioPlayer.Say(_speechMaker.BuildIsFixed(newlyFixedBuilds));
                }
            }

            _previousBuildData = currentBuildData;
        }

 /// <summary>
 /// Permet de filtrer sur les parametres d'une fonction pour les fonctions surchargées
 /// </summary>
 /// <param name="methods"></param>
 /// <param name="parameters"></param>
 /// <returns></returns>
 private static MethodInfo FilterMethodByParams(IEnumerable<MethodInfo> methods, IEnumerable<object> parameters)
 {
     if (parameters != null)
     {
         var paramsNull = parameters.Where(p => p.Equals(null));
         if (!paramsNull.Any())
         {
             IEnumerable<Type> types = parameters.Select(param => param.GetType());
             var methodsFiltered = methods.Where(m => m.GetParameters().Count() == parameters.Count());
             if (methodsFiltered.Any())
             {
                 foreach (var methodInfo in methodsFiltered)
                 {
                     if (types.SequenceEqual(methodInfo.GetParameters().Select(p => p.ParameterType).ToList()))
                     {
                         return methodInfo;
                     }
                 }
             }
         }
         else
         {
             var methodsFiltered = methods.Where(m => m.GetParameters().Count() == parameters.Count());
             if (methodsFiltered.Any())
             {
                 return methodsFiltered.First();
             }
         }
     }
     return null;
 }

        public PlayerDashBoardViewModel(IEnumerable<League> leagues, Season currentSeason, IEnumerable<PlayerPredictionSummary> predictions, IEnumerable<PlayerPredictionSummary> LastWeekPredictions, Player playerProfile, Week LastWeek, Boolean IsViewingMyOwnPage, IQueryable<Notification> repnotifications)
        {
            LeagueSelections = leagues.ToDictionary((x => x.Name), x => x.Id.ToString());
            CurrentSeasonText = string.Format("{0} - {1} to {2}", currentSeason.League.Name, currentSeason.SeasonStarts.ToLongDateString(), currentSeason.SeasonEnd.ToLongDateString());

            ThisWeek = currentSeason.GetCurrentWeekSeason();
            IsMyPage = IsViewingMyOwnPage;

            if (predictions != null)
            {
                PredictionsWithOutComes = predictions.Where(x => x.HasOutcome).OrderBy(y=>y.MatchDate);
                PredictionUpComingMatches = predictions.Where(x => !x.HasOutcome).OrderBy(y => y.MatchDate);
                ThisWeeksMotWId = ThisWeek != null && ThisWeek.MatchOfTheWeek != null ? ThisWeek.MatchOfTheWeek.Id : 0;
            }
            if (LastWeekPredictions != null)
            {
                PredictionsOfPreviousWeek = LastWeekPredictions.OrderBy(y => y.MatchDate);

                LastWeeksMotWId = LastWeek != null && LastWeek.MatchOfTheWeek != null ? LastWeek.MatchOfTheWeek.Id : 0;
            }

            //Build Players Table
            Points = currentSeason.Weeks.WeeksSoFar().Select(w => currentSeason.GetTotalPointsForAPlayersWeek(playerProfile, w)).ToList();
            WeekNames = currentSeason.Weeks.WeeksSoFar().Select(x => x.WeekStarts.Day.ordinalNum() + " " + x.WeekStarts.ToString("MMM")).ToArray();

            //set up notifications
            notifications = repnotifications.Take(3);

            AllPredictionsConfirmed = ThisWeek != null ? playerProfile.HasCompletedPredictions(ThisWeek) : true;
        }

        public BPLPlayerViewModel(IEnumerable<League> leagues, Season currentSeason, IEnumerable<PlayerPredictionSummary> predictions, IEnumerable<PlayerPredictionSummary> LastWeekPredictions, Player LoggedInPlayer, Week LastWeek)
        {
            LeagueSelections = leagues.ToDictionary((x => x.Name), x => x.Id.ToString());
            CurrentSeasonText = string.Format("{0} - {1} to {2}", currentSeason.League.Name, currentSeason.SeasonStarts.ToLongDateString(), currentSeason.SeasonEnd.ToLongDateString());

            ThisWeek = currentSeason.GetCurrentWeekSeason();

            if (predictions != null)
            {
                PredictionsWithOutComes = predictions.Where(x => x.HasOutcome).OrderBy(y=>y.MatchDate);
                PredictionUpComingMatches = predictions.Where(x => !x.HasOutcome).OrderBy(y => y.MatchDate);
                ThisWeeksMotWId = ThisWeek != null && ThisWeek.MatchOfTheWeek != null ? ThisWeek.MatchOfTheWeek.Id : 0;
            }
            if (LastWeekPredictions != null)
            {
                PredictionsOfPreviousWeek = LastWeekPredictions.OrderBy(y => y.MatchDate);

                LastWeeksMotWId = LastWeek != null && LastWeek.MatchOfTheWeek != null ? LastWeek.MatchOfTheWeek.Id : 0;
            }

            //Build Players Table
            Points = currentSeason.Weeks.WeeksSoFar().Select(w => currentSeason.GetTotalPointsForAPlayersWeek(LoggedInPlayer, w)).ToList();
            WeekNames = currentSeason.Weeks.WeeksSoFar().Select(x => x.WeekStarts.Day.ordinalNum() + " " + x.WeekStarts.ToString("MMM")).ToArray();

            AllPredictionsConfirmed = ThisWeek != null ? LoggedInPlayer.HasCompletedPredictions(ThisWeek) : true;
        }

        public IEnumerable<IAsset> Process(IEnumerable<IAsset> assets)
        {
            var results = assets.Where(a => !a.IsProcessable).ToList();

            IEnumerable<IGrouping<IAssetKey, IAsset>> assetGroups = assets.Where(a => a.IsProcessable).GroupBy(asset => asset.Key);

            foreach (IGrouping<IAssetKey, IAsset> assetGroup in assetGroups) {
                if (assetGroup.Count() == 1) {
                    results.Add(assetGroup.Single());
                } else {

                    var combinedTextBuilder = new StringBuilder();
                    var associatedFilePaths = new List<string>();
                    foreach (IAsset asset in assetGroup.OrderByDescending(a => a.OnLayoutPage)) {
                        associatedFilePaths.AddRange(asset.Reader.AssociatedFilePaths);
                        combinedTextBuilder.AppendLine(asset.Reader.Content);
                    }

                    var newContent = combinedTextBuilder.ToString();

                    var newAsset = assetGroup.First();
                    newAsset.Reader = new MemoryAssetReader(associatedFilePaths, newContent);
                    results.Add(newAsset);
                }
            }

            return results;
        }

        internal static EntityStoreSchemaFilterEffect GetEffectViaFilter(
            this EntityStoreSchemaFilterEntry entryToTest, IEnumerable<EntityStoreSchemaFilterEntry> filterEntries)
        {
            var effect = EntityStoreSchemaFilterEffect.Exclude;

            // Look for the all filter for specific type of object; this includes the 'All' types filter
            foreach (var entry in filterEntries.Where(e => e.Name == "%" && (e.Types & entryToTest.Types) == entryToTest.Types))
            {
                effect = entry.Effect;
                break;
            }

            // Look for the specific type of object
            foreach (var entry in filterEntries.Where(
                e =>
                e.Catalog.Equals(entryToTest.Catalog ?? String.Empty, StringComparison.CurrentCulture) &&
                e.Schema.Equals(entryToTest.Schema ?? String.Empty, StringComparison.CurrentCulture) &&
                e.Name.Equals(entryToTest.Name ?? String.Empty, StringComparison.CurrentCulture)))
            {
                effect = entry.Effect;
                break;
            }

            return effect;
        }

        private IEnumerable<CommandButtonViewModel<PaymentType>> CreatePaymentButtons(IEnumerable<PaymentType> paymentTypes, ForeignCurrency foreignCurrency)
        {
            var result = new List<CommandButtonViewModel<PaymentType>>();
            if (_settleCommand != null)
            {
                result.Add(new CommandButtonViewModel<PaymentType>
                {
                    Caption = Resources.Settle,
                    Command = _settleCommand,
                });
            }

            var pts = foreignCurrency == null ? paymentTypes.Where(x => x.Account == null || x.Account.ForeignCurrencyId == 0) : paymentTypes.Where(x => x.Account != null && x.Account.ForeignCurrencyId == foreignCurrency.Id);
            result.AddRange(pts
                .OrderBy(x => x.SortOrder)
                .Select(x => new CommandButtonViewModel<PaymentType>
                {
                    Caption = x.Name.Replace(" ", "\r"),
                    Command = _makePaymentCommand,
                    Color = x.ButtonColor,
                    Parameter = x
                }));

            if (_closeCommand != null)
            {
                result.Add(new CommandButtonViewModel<PaymentType>
                {
                    Caption = Resources.Close,
                    Command = _closeCommand,
                    Color = "Red"
                });
            }
            return result;
        }