C# SaveEventArgs类代码示例

        private void Album_saved(IContentService sender, SaveEventArgs<IContent> e)
        {
            foreach (IContent node in e.SavedEntities)
              {
            if (node.ContentType.ContentTypeCompositionExists("Album") || node.ContentType.Alias == "Album")
            {
              IMediaService ms = UmbracoContext.Current.Application.Services.MediaService;
              IContent parent = node.Parent();
              int media_parentId;
              if (parent.ContentType.ContentTypeCompositionExists("Album") || parent.ContentType.Alias == "Album")
              {
            IMedia media_parent = ms.GetRootMedia().Where(x => x.Name == parent.Name).First(x => x.ContentType.Alias == "Folder");
            if (media_parent == null)
            {
              media_parent = ms.CreateMedia(parent.Name, -1, "Folder");
              ms.Save(media_parent);
            }
            media_parentId = media_parent.Id;
              }
              else
            media_parentId = -1;

              IMedia media_album = ms.CreateMedia(node.Name, media_parentId, "Folder");
              ms.Save(media_album);
            }
              }
        }

        /// <summary>
        /// User saving event.
        /// </summary>
        /// <remarks>
        /// User is already saved but the object itself is not updated yet.
        /// </remarks>
        void User_Saving(IUserService service, SaveEventArgs<IUser> e)
        {
            foreach (var savedEntity in e.SavedEntities)
            {
                if (savedEntity != null)
                {
                    if (!savedEntity.IsNewEntity())
                    {

                        // Update permissions for old users if the user type changes.
                        IUser savedUser = service.GetUserById(savedEntity.Id);
                        if (savedEntity.UserType.Alias != savedUser.UserType.Alias)
                        {
                            _userTypePermissionsService.CopyPermissionsForSingleUser(savedUser);
                        }

                    }
                    else
                    {

                        // Set permissions for new users.
                        _userTypePermissionsService.CopyPermissionsForSingleUser(savedEntity);

                    }
                }
            }
        }

 /// <summary>
 /// Set auto-properties on content saving
 /// We can't do these properties on create as the source values will not exist
 /// </summary>
 /// <param name="sender">The content service</param>
 /// <param name="e">The save event arguments</param>
 protected void ContentServiceOnSaving(IContentService sender, SaveEventArgs<IContent> e)
 {
     foreach (IContent entity in e.SavedEntities)
     {
         entity.SetDefaultValue("headTitle", entity.Name);
     }
 }

 static void MediaServiceSaved(IMediaService sender, SaveEventArgs<IMedia> e)
 {
     foreach (var item in e.SavedEntities)
     {
         library.ClearLibraryCacheForMedia(item.Id);
     }
 }

        static void SetIsApproved(IMemberService sender, SaveEventArgs<IMember> e)
        {
            // Automatically approve all members, as we don't have an approval process now
            // This is needed as we added new membership after upgrading so IsApproved is
            // currently empty. First time a member gets saved now (login also saves the member)
            // IsApproved would turn false (default value of bool) so we want to prevent that

            // Note: Since July 23rd 2015 we need people to activate their accounts! Don't
            // approve automatically.
            var nonApprovedMembers = e.SavedEntities.Where(
                member => member.CreateDate < DateTime.Parse("2015-07-23")
                && member.Properties.Contains(Constants.Conventions.Member.IsApproved)
                && member.IsApproved == false);

            var memberService = ApplicationContext.Current.Services.MemberService;
            foreach (var member in nonApprovedMembers)
            {
                // Adds test for member having an Id, if they don't then it's a NEW member,
                // new members don't automatically get approved any more, only existing
                // member before July 23rd 2015
                if (member.HasIdentity)
                {
                    member.IsApproved = true;
                    memberService.Save(member, false);
                }
            }
        }

        private static void OnTemplateBuildingBlockSave(TemplateBuildingBlock subject, SaveEventArgs e, EventPhases phase)
        {
            if (!subject.IsAssemblyTemplateBuildingBlock())
                return;

            using (var session = subject.Session)
            {
                var templatingAssembly = new TemplatingAssembly(subject);

                foreach (var embeddedParameterSchema in templatingAssembly.EmbeddedParameterSchemas)
                {
                    if (session.IsExistingObject(String.Concat(subject.OrganizationalItem.WebDavUrl, "/", embeddedParameterSchema.Title, ".xsd")))
                        continue;

                    var parameterSchema = new Schema(session, subject.OrganizationalItem.Id)
                    {
                        Title = embeddedParameterSchema.Title,
                        Description = embeddedParameterSchema.Title,
                        Purpose = SchemaPurpose.TemplateParameters,
                        RootElementName = "Parameters",
                        Xsd = embeddedParameterSchema.Xsd
                    };

                    parameterSchema.Save(true);
                }

                foreach (var cSharpTemplateBuildingBlock in templatingAssembly.CSharpTemplateBuildingBlocks)
                {
                    //If a TBB already exists
                    if (session.IsExistingObject(String.Concat(subject.OrganizationalItem.WebDavUrl, "/", cSharpTemplateBuildingBlock.Title, ".tbbcs")))
                        continue;

                    //Create a new C# TBB
                    var templateBuildingBlock = new TemplateBuildingBlock(session, subject.OrganizationalItem.Id)
                    {
                        Title = cSharpTemplateBuildingBlock.Title,
                        TemplateType = TemplateTypes.CSharpTemplate,
                        Content = String.Format(CSharpTemplateBuildingBlockContent, templatingAssembly.Id, cSharpTemplateBuildingBlock.ClassName)
                    };

                    if (cSharpTemplateBuildingBlock.ParameterSchema != null)
                    {
                        if (cSharpTemplateBuildingBlock.ParameterSchema.ToLower().StartsWith("/webdav/") || cSharpTemplateBuildingBlock.ParameterSchema.ToLower().StartsWith("tcm:"))
                        {
                            var parameterSchema = (Schema) session.GetObject(cSharpTemplateBuildingBlock.ParameterSchema);
                            templateBuildingBlock.ParameterSchema = parameterSchema;
                        }
                        else if (cSharpTemplateBuildingBlock.ParameterSchema.ToLower().StartsWith("resource:"))
                        {
                            var parameterSchemaUrl = String.Concat(subject.OrganizationalItem.WebDavUrl, "/", Regex.Match(cSharpTemplateBuildingBlock.ParameterSchema, @"[\w ]*(?=\.xsd$)").Value, ".xsd");
                            var parameterSchema = (Schema)session.GetObject(parameterSchemaUrl);
                            templateBuildingBlock.ParameterSchema = parameterSchema;
                        }
                    }

                    templateBuildingBlock.Save(true);
                }
            }
        }

 /// <summary>
 /// The entity collection service on saved.
 /// </summary>
 /// <param name="sender">
 /// The sender.
 /// </param>
 /// <param name="e">
 /// The e.
 /// </param>
 private void EntityCollectionServiceOnSaved(IEntityCollectionService sender, SaveEventArgs<IEntityCollection> e)
 {
     if (!EntityCollectionProviderResolver.HasCurrent) return;
     foreach (var collection in e.SavedEntities)
     {
         EntityCollectionProviderResolver.Current.AddOrUpdateCache(collection);
     }
 }

 private void Member_AfterSave(Member sender, SaveEventArgs e)
 {
     //ensure that only the providers are flagged to listen execute
     var xml = sender.ToXml(new System.Xml.XmlDocument(), false).ToXElement();
     var providers = ExamineManager.Instance.IndexProviderCollection.OfType<BaseUmbracoIndexer>()
         .Where(x => x.EnableDefaultEventHandler);
     ExamineManager.Instance.ReIndexNode(xml, IndexTypes.Member, providers);
 }

 private void ExpireCache(IDataTypeService sender, SaveEventArgs<IDataTypeDefinition> e)
 {
     foreach (var dataType in e.SavedEntities)
     {
         ApplicationContext.Current.ApplicationCache.RuntimeCache.ClearCacheItem(
             string.Concat("Our.Umbraco.NestedContent.GetPreValuesCollectionByDataTypeId_", dataType.Id));
     }
 }

        private void GatewayProviderServiceOnSaved(IGatewayProviderService sender, SaveEventArgs<IGatewayProviderSettings> args)
        {
            var key = new Guid(Constants.GatewayProviderSettingsKey);
            var provider = args.SavedEntities.FirstOrDefault(x => key == x.Key && !x.HasIdentity);
            if (provider == null) return;

            MappingExtensions.SaveProcessorSettings(provider.ExtendedData, new SagePayProcessorSettings());
        }

        private static void GatewayProviderServiceOnSaved(IGatewayProviderService sender, SaveEventArgs<IGatewayProviderSettings> args)
        {
            var key = new Guid("C6BF6743-3565-401F-911A-33B68CACB11B");
            var provider = args.SavedEntities.FirstOrDefault(x => key == x.Key && !x.HasIdentity);
            if (provider == null) return;

            provider.ExtendedData.SaveProcessorSettings(new AuthorizeNetProcessorSettings());
        }

            private static void GatewayProviderServiceOnSaving(IGatewayProviderService sender, SaveEventArgs<IGatewayProviderSettings> args)
            {
                var key = new Guid("15C87B6F-7987-49D9-8444-A2B4406941A8");
                var provider = args.SavedEntities.FirstOrDefault(x => key == x.Key && !x.HasIdentity);
                if (provider == null) return;

                provider.ExtendedData.SaveProcessorSettings(new StripeProcessorSettings());
            }

        private void GatewayProviderServiceOnSaved(IGatewayProviderService sender, SaveEventArgs<IGatewayProviderSettings> args)
        {
            var key = new Guid("5F2E88D1-6D07-4809-B9AB-D4D6036473E9");
            var provider = args.SavedEntities.FirstOrDefault(x => key == x.Key && !x.HasIdentity);
            if (provider == null) return;

            provider.ExtendedData.SaveSmtpProviderSettings(new SmtpNotificationGatewayProviderSettings());
        }

        private void GatewayProviderServiceOnSaving(IGatewayProviderService sender, SaveEventArgs<IGatewayProviderSettings> saveEventArgs)
        {
            var key = new Guid(Constants.ProviderId);

              var provider = saveEventArgs.SavedEntities.FirstOrDefault(x => key == x.Key && !x.HasIdentity);
              if (provider == null) return;

              provider.ExtendedData.SaveProviderSettings(new QuickPayProviderSettings());
        }

        /// <summary>
        /// The gateway provider service on saving.
        /// </summary>
        /// <param name="sender">
        /// The sender.
        /// </param>
        /// <param name="saveEventArgs">
        /// The save event args.
        /// </param>
        private void GatewayProviderServiceOnSaving(IGatewayProviderService sender, SaveEventArgs<IGatewayProviderSettings> saveEventArgs)
        {
            var key = new Guid("DBC48C38-0617-44EA-989A-18AAD8D5DE52");
            var provider = saveEventArgs.SavedEntities.FirstOrDefault(x => key == x.Key && !x.HasIdentity);

            if (provider == null) return;

            provider.ExtendedData.SaveProviderSettings(new AvaTaxProviderSettings());
        }