C# ContentItem.GetChildren方法代码示例

        public override ItemList GetItemsInZone(ContentItem parentItem, string zoneName)
        {
            if(zoneName.EndsWith("None"))
                return new ItemList();
            if (zoneName.EndsWith("All"))
                return parentItem.GetChildren(new DelegateFilter(ci => ci.ZoneName != null));

            return parentItem.GetChildren(zoneName);
        }

        public override System.Collections.Generic.IEnumerable<ContentItem> GetParts(ContentItem belowParentItem, string inZoneNamed, string filteredForInterface)
        {
            if(inZoneNamed.EndsWith("None"))
                return new ItemList();
            if (inZoneNamed.EndsWith("All"))
                return belowParentItem.GetChildren(new DelegateFilter(ci => ci.ZoneName != null));

            return belowParentItem.GetChildren(inZoneNamed);
        }

 protected virtual IEnumerable<ContentItem> GetChildren(ContentItem currentItem)
 {
     IEnumerable<ContentItem> children = currentItem.GetChildren();
     if (Filter != null)
         children = Filter(children);
     return children;
 }

    private static N2.Collections.ItemList GetChildren(ContentItem parentItem)
    {
        N2.Collections.ItemFilter trashFilter = new N2.Collections.TypeFilter(true, typeof(N2.Edit.Trash.TrashContainerItem));
        N2.Collections.ItemFilter folderFilter = new N2.Collections.TypeFilter(true, typeof(FolderItem));
        N2.Collections.ItemFilter imageFilter = new N2.Collections.TypeFilter(true, typeof(ImageItem));

        return parentItem.GetChildren(trashFilter, folderFilter, imageFilter);
    }

 protected void AddReferencesRecursive(ContentItem current, ItemList referrers)
 {
     referrers.AddRange(Find.Items.Where.Detail().Eq(Item).Select());
     foreach (ContentItem child in current.GetChildren())
     {
         AddReferencesRecursive(child, referrers);
     }
 }

		protected void AddReferencesRecursive(ContentItem current, ItemList referrers)
		{
			referrers.AddRange(Content.Search.Repository.Find(Parameter.Equal(null, Item).Detail()));
				//Find.Items.Where.Detail().Eq(Item).Select());
			foreach (ContentItem child in current.GetChildren())
			{
				AddReferencesRecursive(child, referrers);
			}
		}

		public override void UpdateEditor(ContentItem item, Control editor)
		{
			TextBox tb = (TextBox)editor;
			tb.Text = string.Empty;
			foreach (ContentItem child in item.GetChildren())
			{
				tb.Text += child.Title + Environment.NewLine;
			}
		}

 /// <summary>Gets the children of the given item for the given user interface.</summary>
 /// <param name="parent">The item whose children to get.</param>
 /// <param name="userInterface">The interface where the children are displayed.</param>
 /// <returns>An enumeration of the children.</returns>
 public virtual IEnumerable<ContentItem> GetChildren(ContentItem parent, string userInterface)
 {
     foreach (var child in parent.GetChildren(new AccessFilter(WebContext.User, Security)))
     {
         yield return child;
     }
     if (Interfaces.Managing == userInterface)
     {
         foreach (var child in NodeFactory.GetChildren(parent.Path))
         {
             yield return child;
         }
     }
 }

 private static IEnumerable GetFiles(ContentItem contentItem, FileType fileType)
 {
     IEnumerable<ContentItem> files = contentItem.GetChildren().Pages().Published().Authorized(Operations.Read);
     switch (fileType)
     {
         case FileType.Image :
             files = files.Where(f => f is FileSystem.Images.Image);
             break;
     }
     return files.Select(ci => new
         {
             name = ci.Title,
             url = GetUrl(fileType, ci),
             imageUrl = GetImageUrl(ci)
         });
 }

 /// <summary>Returns true when an item has children.</summary>
 /// <param name="filter">The filter to apply.</param>
 /// <param name="parent">The item whose childrens existence is to be determined.</param>
 /// <returns>True when there are children.</returns>
 public virtual bool HasChildren(ContentItem parent, ItemFilter filter)
 {
     return parent.GetChildren(filter).Count > 0;
 }

 /// <summary>
 /// Builds up the entire site tree recursively, adding items to the list
 /// </summary>
 /// <param name="list">This should be an empty list</param>
 /// <param name="parent">This should be called using the root item</param>
 private void RecurseTree(IList<ContentItem> list, ContentItem parent)
 {
     // TODO: add caching?
     foreach (var item in parent.GetChildren())
     {
         if (item.Visible && item.IsPage) // TODO make this a setting
         {
             list.Add(item);
             RecurseTree(list, item);
         }
     }
 }

        private void ApplyRulesRecursive(ContentItem item, IEnumerable<string> allowedOperations)
        {
            // Only apply the rules if the current user has permission to administer this item.
            if (Engine.SecurityManager.IsAuthorized(item, User, Operations.Administer))
                ApplyRules(item, allowedOperations);

            // Apply recursively.
            ContentItem[] children = item.GetChildren().ToArray();
            foreach (ContentItem child in children)
                ApplyRulesRecursive(child, allowedOperations);
        }

 /// <summary>
 /// Builds up the entire site tree recursively, adding items to the list
 /// </summary>
 /// <param name="list">This should be an empty list</param>
 /// <param name="parent">This should be called using the root item</param>
 private static void RecurseTree(IList<ContentItem> list, ContentItem parent)
 {
     // TODO: add caching?
     foreach (var item in parent.GetChildren().Visible().Pages())
     {
         list.Add(item);
         RecurseTree(list, item);
     }
 }

		private static IEnumerable<StartPage> GetTranslations(ContentItem currentPage)
		{
			return currentPage.GetChildren().OfType<StartPage>();
		}

 protected void AddReferencesRecursive(ContentItem current, List<ContentItem> referrers)
 {
     referrers.AddRange(Context.Finder.QueryItems().Where(ci => ci.Details.OfType<LinkProperty>().Any(ld => ld.LinkedItem == current)));
     foreach (ContentItem child in current.GetChildren())
         AddReferencesRecursive(child, referrers);
 }