C# IEnumerable.Each方法代码示例

    public SolutionGraph(IEnumerable<Solution> solutions)
    {
        _allNugets = new Lazy<IEnumerable<NugetSpec>>(() => _solutions.SelectMany(x => x.PublishedNugets).ToList());

            solutions.Each(s => _solutions[s.Name] = s);
            solutions.Each(s => s.DetermineDependencies(FindNugetSpec));

            _orderedSolutions = new Lazy<IList<Solution>>(() =>
            {
                var graph = new DependencyGraph<Solution>(s => s.Name, s => s.SolutionDependencies().Select(x => x.Name));
                solutions.Each(graph.RegisterItem);
                return graph.Ordered().ToList();
            });
    }

        public FubuMvcContext(IFubuMvcSystem system)
        {
            _system = system;

            _contextualProviders = system.ContextualProviders ?? new IContextualInfoProvider[0];
            _contextualProviders.Each(x => x.Reset());
        }

        public ThreadSafeLocaleCache(CultureInfo culture, IEnumerable<LocalString> strings)
        {
            _data = new Dictionary<LocalizationKey, string>();
            strings.Each(s => _data.Add(new LocalizationKey(s.value), s.display));

            _culture = culture;
        }

        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();
        }

 public static FileInclusionPolicy CreateInclusionPolicy(IEnumerable<string> excludes = null, IEnumerable<string> includes = null)
 {
     var policy = new FileInclusionPolicy();
     if (excludes != null) excludes.Each(policy.AddExclude);
     if(includes != null) includes.Each(policy.AddInclude);
     return policy;
 }

        public AggregateResult(IEnumerable<GameResult> results)
        {
            _playerToScoreMap = new Dictionary<BotPlayer, int>();
              results.SelectMany(x => x.Players).Each(x => _playerToScoreMap[x] = 0);

              results.Each(result =>
              {
            if (result.IsTie)
            {
              result.Players.Each(player =>
              {
            _playerToScoreMap[player]++;
              });
            }
            else
            {
              _playerToScoreMap[result.Winner] += 3;
            }
              });

              var winners = _playerToScoreMap.GroupBy(x => x.Value).OrderByDescending(x => x.Key).First();

              if (winners.Count() == _playerToScoreMap.Count)
              {
            IsTie = true;
              }
              else
              {
            Winner = winners.First().Key;
              }
        }

        public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
        {
            var provider = new FileSystemVirtualPathProvider();
            HostingEnvironment.RegisterVirtualPathProvider(provider);

            packages.Each(x => x.ForFolder(FubuMvcPackages.WebContentFolder, provider.RegisterContentDirectory));
        }

        public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
        {
            ReadScriptConfig(FubuMvcPackageFacility.GetApplicationPath(), log);
            packages.Each(p => p.ForFolder(BottleFiles.WebContentFolder, folder => ReadScriptConfig(folder, log)));

            _assets.CompileDependencies(log);
        }

        public void Report(IEnumerable<SuiteRunResult> executed)
        {
            var totalPasses = executed.Sum(x => x.Passes);
            var totalFailures = executed.Sum(x => x.Failures);
            var total = totalPasses + totalFailures;

            _output.WriteLine("Loaded: {0}".FormatWith(executed.Select(s => s.Name).Join(", ")));
            _output.WriteLine("  {0} {1} loaded.".FormatWith(
                total,
                "test".Pluralize(total)));
            _output.WriteLine("  {0}/{1} {2} passed ({3} {4}).".FormatWith(
                totalPasses,
                total,
                "test".Pluralize(total),
                totalFailures,
                "failure".Pluralize(totalFailures)));

            if (totalFailures > 0)
                _output.WriteLine("Failures: ");
            executed.Each(suiteResult => suiteResult
                .Results
                .Where(containerResult => containerResult.Results.Any(r => !r.Pass))
                .Each(f =>
                {
                    _output.WriteLine("  {0}.{1} contained {2} failures.".FormatWith(suiteResult.Name, f.Name, f.Failures));
                    f.Results.Where(r => !r.Pass).Each(r => _output.WriteLine("    {0} failed. [{1}]".FormatWith(r.Name, r.Message)));
                }));

            _output.Flush();
        }

		public void EachWithFunc( IEnumerable<object> sut )
		{
			var copy = sut.ToList();
			Func<object, bool> action = copy.Remove;
			var results = sut.Each( action );
			Assert.All( results,  b => b.IsFalse( () => { throw new InvalidOperationException( "was not true." ); } ) );
		}

		public void Each( IEnumerable<object> sut )
		{
			var count = 0;
			Action<object> action = o => count++;
			sut.Each( action );
			Assert.Equal( sut.Count(), count );
		}

        public IEnumerable<IActivator> Bootstrap(IPackageLog log)
        {
            _services = _inner.Bootstrap(log).Select(x => new BottleService(x, log));
            _services.Each(x => x.Start());

            return new IActivator[0];
        }

 public void Draw(IEnumerable<Card> cards)
 {
     cards.Each(card =>
                    {
                        RemoveCardFromDeck(card);
                        Player.AddCardToHand(card);
                    });
 }

 public void Discard(IEnumerable<Card> cards)
 {
     cards.Each(card =>
                    {
                        RemoveCardFromDeck(card);
                        Player.AddToDiscard(card);
                    });
 }

 protected override void applyBufferingToChildSectionLines(IEnumerable<Line> sectionLines, int index)
 {
     if (isSubsequentLine(index))
     {
         var buffer = (Convert.ToChar(9475).ToString() + " ").PadLeft(_tabWidth);
         sectionLines.Each(x => x.Prepend(buffer));
     }
 }