C# IEnumerable.ForEach方法代码示例

        public DisableAndEnableButtons()
        {
            _modules = CreateMenuElementGroup() ;
            _toolbar = CreateMenuElements();

            AddAction("Enable Toolbar", () =>
                      _toolbar.ForEach(x => x.Enable()));
            AddAction("Disable Toolbar", () =>
                      _toolbar.ForEach(x => x.Disable()));
        }

        protected Action<object> SetupProxy(Type eventType, IEnumerable<Type> constraintHandlerTypes = null)
        {
            ids = new ConcurrentBag<string>();
            events = new ConcurrentBag<object>();
            typeName = eventType.FullName;
            typeNames = new[] { typeName }.Select(t => new EventType { Type = t }).ToList();

            Action<object> handler = null;
            WhenCalling<ITypeFinder>(x => x.ListEventTypes()).Return(new[] { eventType });
            WhenCalling<ITypeFinder>(x => x.GetEventType(Arg<string>.Is.Anything)).Return(eventType);
            if (constraintHandlerTypes != null)
                constraintHandlerTypes.ForEach(t => Register(Activator.CreateInstance((Type) t)));
            WhenCalling<ITypeFinder>(x => x.GetConstraintHandlerTypes(Arg<Type>.Is.Anything))
                    .Return(constraintHandlerTypes != null ? constraintHandlerTypes : Enumerable.Empty<Type>());

            WhenCalling<IEventAggregator>(x => x.Subscribe(Arg<Action<object>>.Is.Anything)).Callback<Action<object>>(h =>
            {
                handler = h;
                return true;
            });
            WhenAccessing<IRequest, IPrincipal>(x => x.User).Return(Thread.CurrentPrincipal);

            var client = new Client(events);

            WhenCalling<IHubConnectionContext<dynamic>>(x => x.Client(Arg<string>.Is.Anything)).Return(client);
            WhenAccessing<IHubContext, IHubConnectionContext<dynamic>>(x => x.Clients).Return(Get<IHubConnectionContext<dynamic>>());
            Mock<IConnectionManager>();
            WhenCalling<IConnectionManager>(x => x.GetHubContext<EventAggregatorProxyHub>()).Return(Get<IHubContext>());

            eventProxy = new EventProxy();

            return handler;
        }

        public static void SendEmail(
            IEnumerable<string> toAddresses,
            string fromAddress,
            string subject,
            string body)
        {
            if (!toAddresses.Any() ||
                string.IsNullOrEmpty(subject) ||
                string.IsNullOrEmpty(body))
            {
                throw new ArgumentNullException("SendEmail", "Invalid email request");
            }

            if (string.IsNullOrEmpty(fromAddress))
            {
                fromAddress = ConfigurationManager.AppSettings["Email.DefaultFrom"];
            }

            var message = new MailMessage();
            toAddresses.ForEach(message.To.Add);
            message.From = new MailAddress(fromAddress);
            message.Subject = subject;
            message.Body = body;
            message.BodyEncoding = Encoding.UTF8;

            string host = ConfigurationManager.AppSettings["Email.Host"];
            int port = int.Parse(ConfigurationManager.AppSettings["Email.Port"]);

            SmtpClient client = new SmtpClient(host, port);
            client.Send(message);
        }

 public void AddChange(uint id, IEnumerable<RelationName> relations)
 {
     if (this.relations.ContainsKey(id) == false)
         this.relations.Add(id, new List<RelationName>());
     relations.ForEach(
         (RelationName relation) => this.relations[id].Add(relation));
 }

 public bool SendMessage(string subject, string body, IEnumerable<string> recepients)
 {
     var smtp = new SmtpClient
     {
         Host = "smtp.gmail.com",
         Port = 587,
         EnableSsl = true,
         DeliveryMethod = SmtpDeliveryMethod.Network,
         UseDefaultCredentials = false,
         Credentials = new NetworkCredential(UserName, Password)
     };
     using (var message = new MailMessage
     {
         Subject = subject,
         Body = body,
     })
     {
         message.From = new MailAddress(FromAddress, FromName);
         message.IsBodyHtml = true;
         recepients.ForEach(x => message.To.Add(new MailAddress(x)));
         try
         {
             smtp.Send(message);
         }
         catch (Exception)
         {
             //TODO: shouild be logged
             return false;
         }
     }
     return true;
 }

 protected void SetModelStateErrors(IEnumerable<IValidationError> errors)
 {
     if (errors != null)
     {
         errors.ForEach(e => { ModelState.AddModelError(e.Property, e.ErrorMessage); });
     }
 }

        protected CommandResult SaveEnumerable( IEnumerable<object> models )
        {
            try
            {
                var list = new BulkPersist( true, false, models );
                var body = list.ToString();

                var result = Post( body );
                var updates = result.GetResultAs<SaveResponse[]>().ToDictionary( x => x.Id, x => x.Revision );
                models
                    .ForEach( x =>
                                  {
                                      var documentId = x.GetDocumentIdAsJson();
                                      string newRev = null;
                                      if ( updates.TryGetValue( documentId, out newRev ) )
                                      {
                                          x.SetDocumentRevision( newRev );
                                      }
                                  } );
                return result;
            }
            catch ( Exception ex )
            {
                throw Exception(
                    ex,
                    "An exception occurred trying to save a collection documents at {0}. \r\n\t {1}",
                    Uri.ToString(),
                    ex
                    );
            }
        }

            internal CommandMediator( Window window, Interaction interaction, bool bindCancelToClose )
            {
                Contract.Requires( window != null );

                this.window = window;
                this.window.Closing += OnWindowClosing;

                if ( interaction == null )
                    return;

                commands = interaction.Commands;
                commands.ForEach( c => c.Executed += OnExecuted );

                if ( !bindCancelToClose )
                    return;

                // determine if behavior is already applied
                var behaviors = System.Windows.Interactivity.Interaction.GetBehaviors( this.window );
                var behavior = behaviors.OfType<WindowCloseBehavior>().FirstOrDefault();

                // add behavior which can support binding the cancel command to the window close button (X)
                if ( behavior == null )
                {
                    behavior = new WindowCloseBehavior();
                    behaviors.Add( behavior );
                }

                behavior.CloseCommand = interaction.CancelCommand;
            }

 private void UpdateChain(IEnumerable<IFilter> filter, bool attach)
 {
     if (filter != null)
     {
         if (attach)
         {
             filter.ForEach(f => f.RequireReaccept += filter_RequireReaccept);
             filter.ForEach(f => f.RequirePartialReaccept += filter_RequirePartialReaccept);
         }
         else
         {
             filter.ForEach(f => f.RequireReaccept -= filter_RequireReaccept);
             filter.ForEach(f => f.RequirePartialReaccept -= filter_RequirePartialReaccept);
         }
     }
 }

        private void Check(IEnumerable<Tuple<int, int, int>> gen)
        {
            gen.ForEach(t =>
            {
                var len = t.Item1;
                var win = t.Item2;
                var step = t.Item3;

                var af = Source.FromEnumerator(() => Enumerable.Range(0, int.MaxValue).Take(len).GetEnumerator())
                    .Sliding(win, step)
                    .RunAggregate(new List<IEnumerable<int>>(), (ints, e) =>
                    {
                        ints.Add(e);
                        return ints;
                    }, Materializer);

                var input = Enumerable.Range(0, int.MaxValue).Take(len).ToList();
                var cf = Source.FromEnumerator(() => Sliding(input, win, step).GetEnumerator())
                    .RunAggregate(new List<IEnumerable<int>>(), (ints, e) =>
                    {
                        ints.Add(e);
                        return ints;
                    }, Materializer);

                af.Wait(TimeSpan.FromSeconds(30)).Should().BeTrue();
                cf.Wait(TimeSpan.FromSeconds(30)).Should().BeTrue();
                af.Result.ShouldAllBeEquivalentTo(cf.Result);
            });
        }

 private static string CreateMessage(object message, IEnumerable<Type> handlerTypes)
 {
     var exceptionMessage = "There are multiple handlers registered for the message type:{0}.\nIf you are getting this because you have registered a listener as a test spy have your listener implement ISynchronousBusMessageSpy and the exception will disappear"
         .FormatWith(message.GetType());
     handlerTypes.ForEach(handlerType => exceptionMessage += "{0}{1}".FormatWith(Environment.NewLine, handlerType.FullName));
     return exceptionMessage;
 }

 public void RegisterDeasy(IEnumerable<AttributeInfo<DeasyAttribute>> deasyList)
 {
     deasyList.ForEach(d =>
     {
         Register(d);
     });
 }

        public static Type Create(Type parent, IEnumerable<Type> interfaces)
        {
            var proxy = module.DefineType(moduleName + '.' + parent.Name,
                                          TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoLayout,
                                          parent);

            interfaces.ForEach(
                @interface =>
                    {
                        proxy.AddInterfaceImplementation(@interface);
                        @interface.GetMethods().ForEach(method => method.ImplementIn(proxy));
                    });
            proxy.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
                .ForEach(
                    constructor =>
                        {
                            switch (constructor.Attributes & MethodAttributes.MemberAccessMask)
                            {
                                case MethodAttributes.Family:
                                case MethodAttributes.Public:
                                case MethodAttributes.FamORAssem:
                                    constructor.ImplementIn(proxy);
                                    break;
                            }
                        });

            return proxy.CreateType();
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="PluginManager"/> class.
 /// </summary>
 /// <param name="Repositories">The repositories.</param>
 /// <param name="Bootstrapper">The bootstrapper.</param>
 public PluginManager(IEnumerable<string> Repositories, IBootstrapper Bootstrapper)
 {
     Contract.Requires<ArgumentNullException>(Repositories != null, "Repositories");
     this.Bootstrapper = Bootstrapper;
     PackageRepositories = Repositories.ForEach(x => PackageRepositoryFactory.Default.CreateRepository(x));
     Initialize();
 }

 public MigrationsManager(IEnumerable<IMigrateSchema> schemas, IRunMigrations runner)
 {
     schemas.MustNotBeNull();
     schemas.ForEach(s => s.Runner = runner);
     _schemas = Sort(schemas);
     _runner = runner;
 }