C# ContentType.Update方法代码示例

        static void CreateWingtipContentTypes()
        {
            ctypeProduct = CreateContentType("Product", "0x01");

              // add site columns
              FieldLinkCreationInformation fieldLinkProductCode = new FieldLinkCreationInformation();
              fieldLinkProductCode.Field = fieldProductCode;
              ctypeProduct.FieldLinks.Add(fieldLinkProductCode);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkProductListPrice = new FieldLinkCreationInformation();
              fieldLinkProductListPrice.Field = fieldProductListPrice;
              ctypeProduct.FieldLinks.Add(fieldLinkProductListPrice);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkProductCategory = new FieldLinkCreationInformation();
              fieldLinkProductCategory.Field = fieldProductCategory;
              ctypeProduct.FieldLinks.Add(fieldLinkProductCategory);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkProductColor = new FieldLinkCreationInformation();
              fieldLinkProductColor.Field = fieldProductColor;
              ctypeProduct.FieldLinks.Add(fieldLinkProductColor);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkMinimumAge = new FieldLinkCreationInformation();
              fieldLinkMinimumAge.Field = fieldMinimumAge;
              ctypeProduct.FieldLinks.Add(fieldLinkMinimumAge);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkMaximumAge = new FieldLinkCreationInformation();
              fieldLinkMaximumAge.Field = fieldMaximumAge;
              ctypeProduct.FieldLinks.Add(fieldLinkMaximumAge);
              ctypeProduct.Update(true);
              clientContext.ExecuteQuery();

              Console.WriteLine("Create Product Proposal content type");
              ctypeProductProposal = CreateContentType("Product Proposal", "0x0101");
              clientContext.Load(ctypeProductProposal);
              clientContext.ExecuteQuery();

              Console.WriteLine("Create Product Proposal folder in _cts folder");
              ListItemCreationInformation folder = new ListItemCreationInformation();
              site.RootFolder.Folders.Add("_cts/Product Proposal");
              clientContext.ExecuteQuery();

              Console.WriteLine("Update doc template file for content type");
              FileCreationInformation newFile = new FileCreationInformation();
              newFile.Content = System.IO.File.ReadAllBytes(studentFolder + @"Modules\DocumentLibraries\Lab\DocumentTemplates\WingtipProductProposal.dotx");
              newFile.Url = @"_cts/Product Proposal/WingtipProductProposal.dotx";
              newFile.Overwrite = true;
              Microsoft.SharePoint.Client.File uploadFile = site.RootFolder.Files.Add(newFile);
              clientContext.Load(uploadFile);
              clientContext.ExecuteQuery();

              Console.WriteLine("Assign doc template url to content type");
              ctypeProductProposal.DocumentTemplate =  siteUrl +  @"/_cts/Product Proposal/WingtipProductProposal.dotx";
              ctypeProductProposal.Update(true);
              clientContext.ExecuteQuery();
        }

        static void CreateProductContentType()
        {
            Console.WriteLine("Creating Product content type...");
              ctypeProduct = CreateContentType("Product", "0x01");

              // add site columns
              FieldLinkCreationInformation fieldLinkProductCode = new FieldLinkCreationInformation();
              fieldLinkProductCode.Field = fieldProductCode;
              ctypeProduct.FieldLinks.Add(fieldLinkProductCode);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkProductDescription = new FieldLinkCreationInformation();
              fieldLinkProductDescription.Field = fieldProductDescription;
              ctypeProduct.FieldLinks.Add(fieldLinkProductDescription);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkProductListPrice = new FieldLinkCreationInformation();
              fieldLinkProductListPrice.Field = fieldProductListPrice;
              ctypeProduct.FieldLinks.Add(fieldLinkProductListPrice);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkProductColor = new FieldLinkCreationInformation();
              fieldLinkProductColor.Field = fieldProductColor;
              ctypeProduct.FieldLinks.Add(fieldLinkProductColor);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkMinimumAge = new FieldLinkCreationInformation();
              fieldLinkMinimumAge.Field = fieldMinimumAge;
              ctypeProduct.FieldLinks.Add(fieldLinkMinimumAge);
              ctypeProduct.Update(true);

              FieldLinkCreationInformation fieldLinkMaximumAge = new FieldLinkCreationInformation();
              fieldLinkMaximumAge.Field = fieldMaximumAge;
              ctypeProduct.FieldLinks.Add(fieldLinkMaximumAge);
              ctypeProduct.Update(true);
              clientContext.ExecuteQuery();
        }

        private void DeployContentTypeWorkflowAssociationDefinition(object modelHost, ContentType contentType, WorkflowAssociationDefinition definition)
        {
            var context = contentType.Context;
            var web = (modelHost as ModelHostContext).Web;

            var existingWorkflowAssotiation = FindExistringWorkflowAssotiation(modelHost, definition);

            InvokeOnModelEvent(this, new ModelEventArgs
            {
                CurrentModelNode = null,
                Model = null,
                EventType = ModelEventType.OnProvisioning,
                Object = existingWorkflowAssotiation,
                ObjectType = typeof(WorkflowAssociation),
                ObjectDefinition = definition,
                ModelHost = modelHost
            });

            if (existingWorkflowAssotiation == null
                ||
                (existingWorkflowAssotiation.ServerObjectIsNull.HasValue &&
                 existingWorkflowAssotiation.ServerObjectIsNull.Value))
            {
                var workflowTemplate = GetWorkflowTemplate(modelHost, definition);

                if (workflowTemplate == null ||
                    (workflowTemplate.ServerObjectIsNull.HasValue && workflowTemplate.ServerObjectIsNull.Value))
                {
                    throw new SPMeta2Exception(
                        string.Format("Cannot find workflow template by definition:[{0}]", definition));
                }

                var historyList = web.QueryAndGetListByTitle(definition.HistoryListTitle);
                var taskList = web.QueryAndGetListByTitle(definition.TaskListTitle);

                var newWorkflowAssotiation = contentType.WorkflowAssociations.Add(new WorkflowAssociationCreationInformation
                {
                    Name = definition.Name,
                    Template = workflowTemplate,
                    HistoryList = historyList,
                    TaskList = taskList
                });

                MapProperties(definition, newWorkflowAssotiation);

                InvokeOnModelEvent(this, new ModelEventArgs
                {
                    CurrentModelNode = null,
                    Model = null,
                    EventType = ModelEventType.OnProvisioned,
                    Object = newWorkflowAssotiation,
                    ObjectType = typeof(WorkflowAssociation),
                    ObjectDefinition = definition,
                    ModelHost = modelHost
                });

                contentType.Update(true);
                context.ExecuteQueryWithTrace();
            }
            else
            {
                MapProperties(definition, existingWorkflowAssotiation);

                InvokeOnModelEvent(this, new ModelEventArgs
                {
                    CurrentModelNode = null,
                    Model = null,
                    EventType = ModelEventType.OnProvisioned,
                    Object = existingWorkflowAssotiation,
                    ObjectType = typeof(WorkflowAssociation),
                    ObjectDefinition = definition,
                    ModelHost = modelHost
                });

                // no update
                // gives weird null ref exception

                // Enhance WorkflowAssociationDefinition - add more tests on updatability #871
                // https://github.com/SubPointSolutions/spmeta2/issues/871

                //existingWorkflowAssotiation.Update();

                contentType.Update(true);
                context.ExecuteQueryWithTrace();
            }
        }

        private void RemoveFieldFromContentType(FieldCollection webFields, string fieldNameToRemove,
            ContentType contentType)
        {
            // Need to load content type fields every iteration because fields are added to the collection
            Field webField = webFields.GetByInternalNameOrTitle(fieldNameToRemove);
            FieldLinkCollection contentTypeFields = contentType.FieldLinks;
            ClientContext.Load(contentTypeFields);
            ClientContext.Load(webField);
            ClientContext.ExecuteQuery();

            var fieldLink =
                contentTypeFields.FirstOrDefault(
                    existingFieldName => existingFieldName.Name == fieldNameToRemove);
            if (fieldLink != null)
            {
                fieldLink.DeleteObject();
            }
            contentType.Update(true);
            ClientContext.ExecuteQuery();
        }

        private void AddOrUpdateFieldOfContentType(ShContentType configContentType, FieldCollection webFields,
            string fieldName,
            ContentType contentType)
        {
            // Need to load content type fields every iteration because fields are added to the collection
            Field webField = webFields.GetByInternalNameOrTitle(fieldName);
            FieldLinkCollection contentTypeFields = contentType.FieldLinks;
            ClientContext.Load(contentTypeFields);
            ClientContext.Load(webField);
            ClientContext.ExecuteQuery();

            var fieldLink = contentTypeFields.FirstOrDefault(existingFieldName => existingFieldName.Name == fieldName);
            if (fieldLink == null)
            {
                var link = new FieldLinkCreationInformation {Field = webField};
                fieldLink = contentType.FieldLinks.Add(link);
            }

            fieldLink.Required = configContentType.RequiredFields.Contains(fieldName);
            fieldLink.Hidden = configContentType.HiddenFields.Contains(fieldName);

            contentType.Update(true);
            ClientContext.ExecuteQuery();
        }

 /// <summary>
 /// Method to add columns to Content Type
 /// </summary>
 /// <param name="web">Object of site</param>
 /// <param name="siteColumns">List of site columns</param>
 /// <param name="finalObj">Content type to which columns are to be added</param>
 /// <returns>Success or Failure</returns>
 private static bool AddColumnsToContentType(Web web, List<string> siteColumns, ContentType finalObj)
 {
     try
     {
         FieldCollection fieldCol = web.Fields;
         foreach (string columns in siteColumns)
         {
             bool isColumnExists = (null != finalObj.Fields.Where(field => field.Title.Equals(columns, StringComparison.OrdinalIgnoreCase)).FirstOrDefault()) ? true : false;
             if (!isColumnExists)
             {
                 Field customDoc = fieldCol.GetByTitle(columns);
                 FieldLinkCreationInformation fieldCreationInformation = new FieldLinkCreationInformation();
                 fieldCreationInformation.Field = customDoc;
                 finalObj.FieldLinks.Add(fieldCreationInformation);
             }
         }
         finalObj.Update(true);
         return true;
     }
     catch (Exception exception)
     {
         ErrorLogger.LogErrorToTextFile(errorFilePath, "Message: " + exception.Message + "\nStacktrace: " + exception.StackTrace);
         return false;
     }
 }

        /// <summary>
        /// Add existed site columns to
        /// target content type
        /// </summary>
        public static void BindFieldsToContentType(ClientContext clientContext, ContentType contentType, string[] filedNames)
        {
            var fields = clientContext.Web.Fields;

            foreach (string fieldName in filedNames)
            {
                var field = fields.GetByInternalNameOrTitle(fieldName);
                clientContext.Load(field);
                clientContext.ExecuteQuery();

                contentType.FieldLinks.Add(new FieldLinkCreationInformation
                {
                    Field = field
                });
                contentType.Update(true);
                clientContext.ExecuteQuery();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="web"></param>
        /// <param name="contentType"></param>
        /// <param name="field"></param>
        /// <param name="required"></param>
        /// <param name="hidden"></param>
        public static void AddFieldToContentType(this Web web, ContentType contentType, Field field, bool required = false, bool hidden = false)
        {
            FieldLinkCreationInformation fldInfo = new FieldLinkCreationInformation();
            fldInfo.Field = field;
            contentType.FieldLinks.Add(fldInfo);
            contentType.Update(true);
            web.Context.ExecuteQuery();

            web.Context.Load(field);
            web.Context.ExecuteQuery();

            if (required || hidden)
            {
                //Update FieldLink
                FieldLink flink = contentType.FieldLinks.GetById(field.Id);
                flink.Required = required;
                flink.Hidden = hidden;
                contentType.Update(true);
                web.Context.ExecuteQuery();
            }
        }

 /// <summary>
 /// Add columns to content type.
 /// </summary>
 /// <param name="web">Object of site</param>
 /// <param name="siteColumns">List of site columns</param>
 /// <param name="finalObj">Content type to which columns are to be added</param>        
 internal static void AddColumnsToContentType(Microsoft.SharePoint.Client.Web web, List<string> siteColumns, ContentType finalObj)
 {
     try
     {
         FieldCollection fieldCol = web.Fields;
         foreach (string columns in siteColumns)
         {
             Field customDoc = (from fld in fieldCol
                                where fld.Title == columns && fld.TypeAsString == ServiceConstantStrings.OneDriveSiteColumnType
                                select fld).FirstOrDefault();
             FieldLinkCreationInformation fieldLinkCreationInfo = new FieldLinkCreationInformation();
             fieldLinkCreationInfo.Field = customDoc;
             finalObj.FieldLinks.Add(fieldLinkCreationInfo);
         }
         finalObj.Update(true);
     }
     catch (Exception exception)
     {
         Logger.LogError(exception, MethodBase.GetCurrentMethod().DeclaringType.Name, MethodBase.GetCurrentMethod().Name, ServiceConstantStrings.LogTableName);
     }
 }

        static void CreateResearchContentTypes()
        {
            Console.WriteLine("Creating Product Proposal content type...");
              ctypeProductProposal = CreateContentType("Product Proposal", "0x0101");

              ListItemCreationInformation folder = new ListItemCreationInformation();
              site.RootFolder.Folders.Add("_cts/Product Proposal");
              clientContext.ExecuteQuery();

              FileCreationInformation newFile = new FileCreationInformation();
              newFile.Content = Properties.Resources.WingtipProductProposal_dotx;
              newFile.Url = @"_cts/Product Proposal/WingtipProductProposal.dotx";
              newFile.Overwrite = true;
              Microsoft.SharePoint.Client.File uploadFile = site.RootFolder.Files.Add(newFile);
              clientContext.Load(uploadFile);
              clientContext.ExecuteQuery();

              ctypeProductProposal.DocumentTemplate = siteUrl + @"/_cts/Product Proposal/WingtipProductProposal.dotx";
              ctypeProductProposal.Update(true);
              clientContext.ExecuteQuery();

              Console.WriteLine("Creating Product Plan Status Report content type...");
              ctypeProductPlanStatusReport = CreateContentType("Product Plan Status Report", "0x0101");

              folder = new ListItemCreationInformation();
              site.RootFolder.Folders.Add("_cts/Product Plan Status Report");
              clientContext.ExecuteQuery();

              newFile = new FileCreationInformation();
              newFile.Content = Properties.Resources.WingtipProductPlanStatusReport_dotx;
              newFile.Url = @"_cts/Product Plan Status Report/WingtipProductPlanStatusReport.dotx";
              newFile.Overwrite = true;
              uploadFile = site.RootFolder.Files.Add(newFile);
              clientContext.Load(uploadFile);
              clientContext.ExecuteQuery();

              ctypeProductPlanStatusReport.DocumentTemplate = siteUrl + @"/_cts/Product Plan Status Report/WingtipProductPlanStatusReport.dotx";
              ctypeProductPlanStatusReport.Update(true);
              clientContext.ExecuteQuery();

              Console.WriteLine("Creating Product Plan Document Set content type...");
              ctypeProductPlanDocucmentSet = CreateContentType("Product Plan Document Set", ctypeIdDocumentSet);
              clientContext.ExecuteQuery();

              //// copy files
              FileCreationInformation infoDefaultFile1 = new FileCreationInformation();
              infoDefaultFile1.Content = Properties.Resources.Product_Design_Specification_docx;
              infoDefaultFile1.Url = siteUrl + @"_cts/Product Plan Document Set/Product Design Specification.docx";
              infoDefaultFile1.Overwrite = true;
              uploadFile = site.RootFolder.Files.Add(infoDefaultFile1);
              clientContext.ExecuteQuery();

              FileCreationInformation infoDefaultFile2 = new FileCreationInformation();
              infoDefaultFile2.Content = Properties.Resources.Product_Plan_Schedule_xlsx;
              infoDefaultFile2.Url = siteUrl + @"_cts/Product Plan Document Set/Product Plan Schedule.xlsx";
              infoDefaultFile2.Overwrite = true;
              Microsoft.SharePoint.Client.File uploadFile2 = site.RootFolder.Files.Add(infoDefaultFile2);
              clientContext.ExecuteQuery();

              clientContext.Load(ctypeProductPlanDocucmentSet, ctype => ctype.SchemaXmlWithResourceTokens);
              clientContext.ExecuteQuery();

              XElement elementCTypeSchema = XElement.Parse(ctypeProductPlanDocucmentSet.SchemaXmlWithResourceTokens);

              // add default documents
              XElement elementDefaultDocuments = elementCTypeSchema.Descendants().Single(node => (node.Name == "XmlDocument") &&  (node.FirstAttribute.ToString() == @"NamespaceURI=""http://schemas.microsoft.com/office/documentsets/defaultdocuments"""));
              string xmlDefaultDocuments = @"<dd:DefaultDocuments xmlns:dd='http://schemas.microsoft.com/office/documentsets/defaultdocuments' AddSetName='True' LastModified='01/01/0001'><DefaultDocument name='/Product Design Specification.docx' idContentType='0x0101' /><DefaultDocument name='/Product Plan Schedule.xlsx' idContentType='0x0101' /></dd:DefaultDocuments>";
              elementDefaultDocuments.Value = ConvertToBase64EncodedString(xmlDefaultDocuments);

              // add allowed content types
              XElement elementAllowedContentTypes = elementCTypeSchema.Descendants().Single(node => (node.Name == "XmlDocument") && (node.FirstAttribute.ToString() == @"NamespaceURI=""http://schemas.microsoft.com/office/documentsets/allowedcontenttypes"""));
              string xmlAllowedContentTypes = @"<act:AllowedContentTypes xmlns:act='http://schemas.microsoft.com/office/documentsets/allowedcontenttypes' LastModified='01/01/0001'><AllowedContentType id='0x0101'/><AllowedContentType id='@ctypeTypeIdProductPlanStatusReport'/></act:AllowedContentTypes>";
              clientContext.Load(ctypeProductPlanStatusReport, ct => ct.Id);
              clientContext.ExecuteQuery();
              xmlAllowedContentTypes = xmlAllowedContentTypes.Replace("@ctypeTypeIdProductPlanStatusReport", ctypeProductPlanStatusReport.Id.StringValue);
              elementAllowedContentTypes.Value = ConvertToBase64EncodedString(xmlAllowedContentTypes);

              string xmlSharedFields = @"<sf:SharedFields xmlns:sf='http://schemas.microsoft.com/office/documentsets/sharedfields' LastModified='01/01/0001'><SharedField id='@idProposedProductCode' /></sf:SharedFields>";

              string xmlWelcomePageFields = @"<wpf:WelcomePageFields xmlns:wpf='http://schemas.microsoft.com/office/documentsets/welcomepagefields' LastModified='01/01/0001'><WelcomePageField id='idProposedProductCode' /><WelcomePageField id='idEstimatedCompletionDate' /></wpf:WelcomePageFields>";

              // save the edited schema back into the site
              ctypeProductPlanDocucmentSet.SchemaXmlWithResourceTokens = elementCTypeSchema.ToString(SaveOptions.DisableFormatting);
              ctypeProductPlanDocucmentSet.Update(true);
              clientContext.ExecuteQuery();
        }