C# FieldList.Add方法代码示例

        public void FakeItemAddMultipleFieldShouldReturnField(FieldList fieldList, string fieldValue)
        {
            var fieldIdOne = ID.NewID;
            var fieldIdTwo = ID.NewID;
            fieldList.Add(fieldIdOne, fieldValue);
            fieldList.Add(fieldIdTwo, fieldValue);
            var fake = new FakeItem(fieldList);

            fake.Fields.Should().HaveCount(2);
        }

 public void FakeItemAddFieldShouldReturnField(FieldList fieldList,string fieldValue)
 {
     var fieldId = ID.NewID;
     fieldList.Add(fieldId,fieldValue);
     var fake = new FakeItem(fieldList);
     fake[fieldId].ShouldBeEquivalentTo(fieldValue);
 }

		public ColumnInfo( ObjectMap objectMap, string[] columnNames )
		{
			this.columnNames = columnNames;
			columnComboHashCode = ObjectConstructor.GetFieldComboHashCode( columnNames );
			fields = new FieldList();
			for( int i = 0; i < columnNames.Length; i++ )
			{
				string columnName = columnNames[ i ];
				FieldMap fm = objectMap.GetFieldMapFromColumn( columnName );
				if( fm == null )
				{
					// check for column names with table name prefixes
					int pos = columnName.IndexOf( '.' );
					if( pos > 0 )
					{
						columnName = columnName.Substring( pos + 1, columnName.Length - pos - 1 );
						fm = objectMap.GetFieldMapFromColumn( columnName );
						if( fm != null )
						{
							columnNames[ i ] = columnName;
						}
					}
					if( fm == null ) // no corresponding member could be found - assume column is calculated
					{
						columnCalculatedMask |= 1 << i;
					}
				}
				fields.Add( fm ); // intentionally add null entries to preserve column order 
			}
		}

 public Resolve(string name, params string[] shows)
 {
     Name = name;
     Show = new FieldList();
     foreach (var show in shows) {
         Show.Add(show);
     }
 }

        public void FakeItemGetFieldFromIdShoudlReturnFieldValue(string fieldValue, FieldList fieldList)
        {
            var fieldId = ID.NewID;

            fieldList.Add(fieldId, fieldValue);
            var fake = new FakeItem(fieldList);

            fake[fieldId].ShouldAllBeEquivalentTo(fieldValue);
        }

		public override FieldList GetItemFields(ItemDefinition item, VersionUri version, CallContext context)
		{
			Assert.ArgumentNotNull(item, "item");
			Assert.ArgumentNotNull(version, "version");
			Assert.ArgumentNotNull(context, "context");

			var action = ControllerAction.GetControllerAction(ParentId, item.ID);
			if (action == null)
			{
				return base.GetItemFields(item, version, context);
			}

			FieldList list = new FieldList();
			var template = context.DataManager.Database.GetTemplate(BaseTemplateId);
			list.Add(template.GetField("Namespace").ID, typeof(MvcActionLoader).Namespace);
			list.Add(template.GetField("Tag").ID, typeof(MvcActionLoader).Name);
			list.Add(template.GetField("TagPrefix").ID, "mvc");
			list.Add(template.GetField("Assembly").ID, typeof(MvcActionLoader).Assembly.GetName().Name);
			list.Add(FieldIDs.Icon, Themes.MapTheme("SoftwareV2/16x16/element_selection.png"));
			return list;
		}

        public void FieldAddingLinkFieldWithLinkFromOneItemToAnotherTargetItemShouldReturnLinkedToItem()
        {
            var linkedToItem = new FakeItem();
            var fakeLinkField = new FakeInternalLinkField(linkedToItem);

            var fieldId = ID.NewID;
            var fieldCollection = new FieldList();
            fieldCollection.Add(fieldId,fakeLinkField.ToString());

            var itemToLinkFrom = new FakeItem(fieldCollection);

            var sitecoreLinkField = (LinkField) itemToLinkFrom.Fields[fieldId];

            sitecoreLinkField.TargetItem.ID.ShouldBeEquivalentTo(linkedToItem.ID);
        }

        public static Item CreateFakeItem(Dictionary<Guid, string> fields, ID templateId, Database database, string name = "ItemName")
        {
            var id = new ID(Guid.NewGuid());
            var language = Language.Current;
            var version = Sitecore.Data.Version.Latest;

            var itemDefinition = new ItemDefinition(id, name, templateId, ID.Null);
            var fieldList = new FieldList();

            if (fields != null)
            {
                foreach (var fieldId in fields.Keys)
                {
                    fieldList.Add(new ID(fieldId), fields[fieldId]);
                }
            }

            var itemData = new ItemData(itemDefinition, language, version, fieldList);
            var item = new Item(id, itemData, database);
            return item;
        }

        public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
        {
            var fields = new FieldList();

            if (itemDefinition == ItemDefinition.Empty)
            {
                return fields;
            }

            var database = GetDatabase(context);
            var syncItem = database.GetItem(itemDefinition.ID.ToString(), versionUri.Language.Name);

            if (syncItem == null)
            {
                return fields;
            }

            foreach (var syncField in syncItem.SharedFields)
            {
                fields.Add(ID.Parse(syncField.FieldID), syncField.FieldValue);
            }

            var syncVersion = syncItem.GetLatestVersions().Where(v => v.Language.Equals(versionUri.Language.Name, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

            if (syncVersion == null)
            {
                return fields;
            }

            foreach (var syncField in syncVersion.Fields)
            {
                fields.Add(ID.Parse(syncField.FieldID), syncField.FieldValue);
            }

            return fields;
        }

    public override TypeNode VisitTypeReference(TypeNode type){ //TODO: break up this method
      if (type == null) return null;
      TypeNodeList pars = this.pars;
      TypeNodeList args = this.args;
      switch (type.NodeType){
        case NodeType.ArrayType:
          ArrayType arrType = (ArrayType)type;
          TypeNode elemType = this.VisitTypeReference(arrType.ElementType);
          if (elemType == arrType.ElementType || elemType == null) return arrType;
          if (arrType.IsSzArray()) return elemType.GetArrayType(1);
          return elemType.GetArrayType(arrType.Rank, arrType.Sizes, arrType.LowerBounds);
#if !MinimalReader
        case NodeType.DelegateNode:{
          FunctionType ftype = type as FunctionType;
          if (ftype == null) goto default;
          TypeNode referringType = ftype.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(ftype.DeclaringType);
          return FunctionType.For(this.VisitTypeReference(ftype.ReturnType), this.VisitParameterList(ftype.Parameters), referringType);}
#endif
        case NodeType.Pointer:
          Pointer pType = (Pointer)type;
          elemType = this.VisitTypeReference(pType.ElementType);
          if (elemType == pType.ElementType || elemType == null) return pType;
          return elemType.GetPointerType();
        case NodeType.Reference:
          Reference rType = (Reference)type;
          elemType = this.VisitTypeReference(rType.ElementType);
          if (elemType == rType.ElementType || elemType == null) return rType;
          return elemType.GetReferenceType();
#if ExtendedRuntime
        case NodeType.TupleType:{
          TupleType tType = (TupleType)type;
          bool reconstruct = false;
          MemberList members = tType.Members;
          int n = members == null ? 0 : members.Count;
          FieldList fields = new FieldList(n);
          for (int i = 0; i < n; i++){
            //^ assert members != null;
            Field f = members[i] as Field;
            if (f == null) continue;
            f = (Field)f.Clone();
            fields.Add(f);
            TypeNode oft = f.Type;
            TypeNode ft = f.Type = this.VisitTypeReference(f.Type);
            if (ft != oft) reconstruct = true;
          }
          if (!reconstruct) return tType;
          TypeNode referringType = tType.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(tType.DeclaringType);
          return TupleType.For(fields, referringType);}
        case NodeType.TypeIntersection:{
          TypeIntersection tIntersect = (TypeIntersection)type;
          TypeNode referringType = tIntersect.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(tIntersect.DeclaringType);
          return TypeIntersection.For(this.VisitTypeReferenceList(tIntersect.Types), referringType);}
        case NodeType.TypeUnion:{
          TypeUnion tUnion = (TypeUnion)type;
          TypeNode referringType = tUnion.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(tUnion.DeclaringType);
          TypeNodeList types = this.VisitTypeReferenceList(tUnion.Types);
          if (referringType == null || types == null) { Debug.Fail(""); return null; }
          return TypeUnion.For(types, referringType);}
#endif
#if !MinimalReader        
        case NodeType.ArrayTypeExpression:
          ArrayTypeExpression aExpr = (ArrayTypeExpression)type;
          aExpr.ElementType = this.VisitTypeReference(aExpr.ElementType);
          return aExpr;
        case NodeType.BoxedTypeExpression:
          BoxedTypeExpression bExpr = (BoxedTypeExpression)type;
          bExpr.ElementType = this.VisitTypeReference(bExpr.ElementType);
          return bExpr;
        case NodeType.ClassExpression:{
          ClassExpression cExpr = (ClassExpression)type;
          cExpr.Expression = this.VisitTypeExpression(cExpr.Expression);
          Literal lit = cExpr.Expression as Literal; //Could happen if the expression is a template parameter
          if (lit != null) return lit.Value as TypeNode;
          cExpr.TemplateArguments = this.VisitTypeReferenceList(cExpr.TemplateArguments);
          return cExpr;}
#endif
        case NodeType.ClassParameter:
        case NodeType.TypeParameter:
          int key = type.UniqueKey;
          var mappedTarget = this.forwarding[key] as TypeNode;
          if (mappedTarget != null) return mappedTarget;
          for (int i = 0, n = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; i < n && i < m; i++){
            //^ assert pars != null && args != null;
            TypeNode tp = pars[i];
            if (tp == null) continue;
            if (tp.UniqueKey == key) return args[i];
#if false
            if (tp.Name.UniqueIdKey == type.Name.UniqueIdKey && (tp is ClassParameter && type is TypeParameter)) {
              //This shouldn't really happen, but in practice it does. Hack past it.
              Debug.Assert(false);
              return args[i];
            }
#endif
          }
          return type;
#if ExtendedRuntime
        case NodeType.ConstrainedType:{
          ConstrainedType conType = (ConstrainedType)type;
          TypeNode referringType = conType.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(conType.DeclaringType);
          TypeNode underlyingType = this.VisitTypeReference(conType.UnderlyingType);
//.........这里部分代码省略.........

    protected void AddFieldsFromTemplate(FieldList allFields, DbItem fakeItem, DbTemplate fakeTemplate, Language language, Version version)
    {
      var sourceItem = this.GetSourceItem(fakeItem);

      foreach (var templateField in fakeTemplate.Fields)
      {
        var fieldId = templateField.ID;

        var itemField = this.FindItemDbField(fakeItem, templateField);
        if (itemField == null)
        {
          continue;
        }

        var value = itemField.GetValue(language.Name, version.Number);
        if (sourceItem != null && string.IsNullOrWhiteSpace(value))
        {
          continue;
        }

        if (value != null)
        {
          allFields.Add(fieldId, value);
        }
      }

      foreach (var template in fakeTemplate.BaseIDs.Select(this.GetFakeTemplate).Where(t => t != null))
      {
        this.AddFieldsFromTemplate(allFields, fakeItem, template, language, version);
      }

      if (fakeTemplate.BaseIDs.Any() || fakeTemplate.ID == TemplateIDs.StandardTemplate)
      {
        return;
      }

      var standardTemplate = this.GetFakeTemplate(TemplateIDs.StandardTemplate);
      this.AddFieldsFromTemplate(allFields, fakeItem, standardTemplate, language, version);
    }

        private void GetFieldFields(FieldInfo info, FieldList fields){

            if (!string.IsNullOrEmpty(info.Title))
                fields.Add(TitleFieldId, info.Title);

            fields.Add(TypeFieldId, FieldInfo.GetFieldType(info.Type));

            if (!string.IsNullOrEmpty(info.Source))
                fields.Add(SourceFieldId, info.Source);

            fields.Add(TemplateFieldIDs.Shared, info.IsShared ? "1" : "0");
            fields.Add(TemplateFieldIDs.Unversioned, info.IsUnversioned ? "1" : "0");
            foreach (var fieldFieldValue in info.FieldFieldValues)
            {
                fields.Add(ID.Parse(fieldFieldValue.Key), fieldFieldValue.Value);
            }
            fields.Add(TemplateFieldIDs.Validation, info.ValidationRegularExpression ?? "");
            fields.Add(TemplateFieldIDs.ValidationText, info.ValidationErrorText ?? "");

            if (info.IsRequired)
            {
                fields.Add(QuickActionBarFieldId, IsRequiredId);
                fields.Add(ValidateButtonFieldId, IsRequiredId);
                fields.Add(ValidatorBarFieldId, IsRequiredId);
                fields.Add(WorkflowFieldId, IsRequiredId);
            }
        }

 /// <summary>
 /// Gets the standard fields.
 /// </summary>
 /// <param name="fields">The fields.</param>
 /// <param name="index">The index.</param>
 private void GetStandardFields(FieldList fields, int index)
 {
     fields.Add(FieldIDs.ReadOnly, "1");
     fields.Add(FieldIDs.Sortorder, index.ToString());
 }

        public virtual FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
        {
            // return null if not present, should return all shared fields as well as all fields in the version
            Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
            Assert.ArgumentNotNull(versionUri, "versionUri");

            if (DisableSerialization || DisableTransparentSync || itemDefinition == ItemDefinition.Empty) return null;

            var item = GetTargetFromId(itemDefinition.ID);

            if (item == null) return null;

            var fields = new FieldList();

            foreach (var sharedField in item.SharedFields)
            {
                fields.Add(new ID(sharedField.FieldId), sharedField.BlobId.HasValue ? sharedField.BlobId.ToString() : sharedField.Value);
            }

            var version = item.Versions.FirstOrDefault(v => v.VersionNumber == versionUri.Version.Number && v.Language.Name == versionUri.Language.Name);

            if (version == null) return fields;

            foreach (var versionedField in version.Fields)
            {
                fields.Add(new ID(versionedField.FieldId), versionedField.BlobId.HasValue ? versionedField.BlobId.ToString() : versionedField.Value);
            }

            fields.Add(FieldIDs.UpdatedBy, TransparentSyncUpdatedByValue);
            fields.Add(FieldIDs.Revision, Guid.NewGuid().ToString());

            AddBlobsToCache(item);

            return fields;
        }

		public override FieldList GetItemFields(ItemDefinition itemDefinition, VersionUri versionUri, CallContext context)
		{
			Assert.ArgumentNotNull(itemDefinition, "itemDefinition");
			Assert.ArgumentNotNull(versionUri, "versionUri");

			if (itemDefinition == ItemDefinition.Empty) return null;

			var syncItem = SerializedDatabase.GetItem(itemDefinition.ID);

			if (syncItem == null) return null;

			var fields = new FieldList();

			foreach (var sharedField in syncItem.SharedFields)
			{
				fields.Add(sharedField.GetSitecoreId(), sharedField.FieldValue);
			}

			var syncVersion = syncItem.GetVersion(versionUri);

			if (syncVersion == null) return fields;

			foreach (var versionedField in syncVersion.Fields)
			{
				fields.Add(versionedField.GetSitecoreId(), versionedField.FieldValue);
			}

			return fields;
		}