public bool GetBoolValue(FieldCollection fc, string fieldName, bool defaultValue)
        {
            if (!IsEmptyStrField(fc, fieldName))
                return fc[fieldName].GetValueAsBool();

            return defaultValue;
        }

        protected virtual IEnumerable<Field> GetTypedFields(ClientContext context, FieldCollection items)
        {
            context.Load(items);
            context.ExecuteQueryWithTrace();

            return items.ToArray();
        }

        protected override IEnumerable<Field> GetTypedFields(ClientContext context, FieldCollection items)
        {
            var typedFields = context.LoadQuery(items.Where(i => i.FieldTypeKind == FieldType.User));
            context.ExecuteQueryWithTrace();

            return typedFields;
        }

        protected override IEnumerable<Field> GetTypedFields(ClientContext context, FieldCollection items)
        {
            var typedFields = context.LoadQuery(items.Where(i => i.TypeAsString == BuiltInPublishingFieldTypes.HTML));
            context.ExecuteQueryWithTrace();

            return typedFields;
        }

 /// <summary>
 /// 自动读数据库载入数据的构造函数
 /// </summary>
 /// <param name="tablename">表名</param>
 /// <param name="db">操作数据类</param>
 /// <param name="IsLoadDt">是否从数据库载入数据到类中</param>
 /// <param name="fields">Field集合</param>
 public DataOperation_Complex(string DefConnID, string DefTableID, FieldCollection fc)
 {
     _dbConn_fc_Dir = new Dictionary<string, Dictionary<string, FieldCollection>>();
     _fields = fc.Clone();
     defaultConnID = DefConnID;
     defaultTableID = DefTableID;
     decompose(_fields);
 }

 public bool Validate(FieldCollection sourceCollection, FieldCollection targetCollection, TokenParser tokenParser)
 {
     Dictionary<string, string[]> parserSettings = new Dictionary<string, string[]>();
     parserSettings.Add("SchemaXml", new string[] { "~sitecollection", "~site", "{sitecollectiontermstoreid}", "{termsetid}" });
     bool isFieldMatch = ValidateObjectsXML(sourceCollection, targetCollection, "SchemaXml", new List<string> { "ID" }, tokenParser, parserSettings);
     Console.WriteLine("-- Field validation " + isFieldMatch);
     return isFieldMatch;
 }

 public static void RegisterWAPMessage(FieldCollection fc)
 {
     if (fc == null)
         return;
     if(MessageDict.ContainsKey(GetWAPMessageID(fc)))
         return;
     MessageDict.Add(GetWAPMessageID(fc), fc);
 }

        public DateTime GetDateTimeValue(FieldCollection fc, string fieldName, DateTime defaultValue)
        {
            if (!IsEmptyStrField(fc, fieldName))
                //if (fc[fieldName].AllowModify)
                    return fc[fieldName].GetValueAsDateTime();

            return defaultValue;
        }

        public decimal GetDecimalValue(FieldCollection fc, string fieldName, decimal defaultValue)
        {
            if (!IsEmptyStrField(fc, fieldName))
                //if (fc[fieldName].AllowModify)
                    return fc[fieldName].GetValueAsDecimal();

            return defaultValue;
        }

 public void Add(FieldCollection fcp)
 {
     FieldCollection tmpfc = fcp.Clone();
     decompose(tmpfc);
     if (isLoadDT)
     {
         _fields = tmpfc;
     }
 }

 private static void AppendFieldInfo(StringBuilder sb, FieldCollection fields, string header, Func<Field, bool> predicate)
 {
   sb.AppendLine(string.Empty);
   sb.AppendLine(header);
   foreach (var field in fields.Where(predicate))
   {
     sb.AppendLine(string.Format("\"{0}\":\"{1}\"", field.Name, field.Value));
   }
 }

 public static UInt32 GetWAPMessageID(FieldCollection fc)
 {
     if(fc!=null)
     {
         var fcFormat = new FieldCollectionFormat();
         if(!fcFormat.IsEmptyStrField(fc,"MessageID"))
             return (UInt32)fc["MessageID"].GetValueAsInt();
     }
     return 0;
 }

        protected override IEnumerable<Field> GetTypedFields(ClientContext context, FieldCollection items)
        {
            var typedFields = context.LoadQuery(
                items.Where(i => i.FieldTypeKind == FieldType.Number)
                     .IncludeWithDefaultProperties());

            context.ExecuteQueryWithTrace();

            return typedFields;
        }

 public static string GetClassName(FieldCollection fc)
 {
     if (fc != null)
     {
         var fcFormat = new FieldCollectionFormat();
         if (!fcFormat.IsEmptyStrField(fc, "ClassName"))
             return fc["ClassName"].GetValueAsString();
     }
     return "";
 }

 public static string GetExceptionDescription(FieldCollection fc)
 {
     if (fc != null)
     {
         var fcFormat = new FieldCollectionFormat();
         if (!fcFormat.IsEmptyStrField(fc, "ExceptionDescription"))
             return fc["ExceptionDescription"].GetValueAsString();
     }
     return "";
 }

        public FieldCollection fillFcField(FieldCollection fc, string fieldName,object objValue)
        {
            if (IsExistField(fc, fieldName))
            {
                fc[fieldName].AllowModify = true;
                fc[fieldName].Value = objValue;
            }

            return fc;
        }

 public ItemDefinition(Guid id, Guid templateId, string name, string path, Language language, bool hasVersion, FieldCollection fields)
 {
     Id = id;
     TemplateId = templateId;
     Name = name;
     Key = name.ToLowerInvariant();
     Path = path;
     Language = language;
     HasVersion = hasVersion;
     Fields = fields;
 }

        protected virtual void AddFieldsIncludedBySection(FieldCollection fieldCol, List<Field> includedFields, GetRenderingPropertiesArgs args)
        {
            var sectionsParam = args.ClientParameters["sections"];
            if (string.IsNullOrEmpty(sectionsParam))
            {
                return;
            }

            var sectionNames = sectionsParam.Split(new[] { '|' }).Where(name => !string.IsNullOrWhiteSpace(name)).ToList();
            var fields = fieldCol.Where(f => sectionNames.Contains(f.Section));
            includedFields.AddRange(fields);
        }

        public bool ValidateSiteFields(FieldCollection sElements, FieldCollection tElements, TokenParser sParser, TokenParser tParser)
        {
            List<Localization> sColl = LoadFields(sElements);
            List<Localization> tColl = LoadFields(tElements);

            if (sColl.Count > 0)
            {
                if (!Validatelocalization(sColl, tColl, sParser, tParser)) { return false; }
            }

            return true;
        }

        public FieldCollection fillDateTimeFcField(FieldCollection fc, string fieldName, object objValue)
        {
            if (IsExistField(fc, fieldName))
            {
                fc[fieldName].AllowModify = true;

                if ((DateTime)objValue == new DateTime())
                    fc[fieldName].Value = null;
                else
                    fc[fieldName].Value = objValue;
            }

            return fc;
        }