Building tree structure based on flat objects
You could use the AddRange combined with the Except method inside of Build:

public static List&lt;ArchiveTreeEntry&gt; Build(List&lt;ArchiveDefinition&gt; entries)
{
    List&lt;ArchiveTreeEntry&gt; rootArchiveTreeEntries = new List&lt;ArchiveTreeEntry&gt;();

    if (entries != null &amp;&amp; entries.Count &gt; 0)
    {
        List&lt;ArchiveDefinition&gt; rootEntries = GetRootEntries(entries);

        entries = rootArchiveTreeEntried.AddRange(rootEntries.Select(definition=&gt; new ArchiveTreeEntry(definition)).Except(entries);

        foreach (ArchiveTreeEntry parent in rootArchiveTreeEntries)
        {
            FillChildren(parent, entries);
        }
    }
    return rootArchiveTreeEntries;
}

You have made the public method static, which in this case is probably fine but it does make it harder to unit test dependencies. I envisage the class being consumed, like this:

in app

var builder = new ArchiveBuilder();  
builder.Build(entities);

That said, the private methods are fine as static methods because the are an implementation detail.
The private methods can return/accept IEnumerable&lt;&gt; instead of List&lt;&gt;
From there, you could then re-write the method above to be:

public static List&lt;ArchiveTreeEntry&gt; Build(List&lt;ArchiveDefinition&gt; entries)
{
    List&lt;ArchiveTreeEntry&gt; rootArchiveTreeEntries = new List&lt;ArchiveTreeEntry&gt;();

    if (entries != null &amp;&amp; entries.Count &gt; 0)
    {
        entries = rootArchiveTreeEntried.AddRange(GetRootEntries(entries).Select(entry =&gt; new ArchiveTreeEntry(definition)).Except(entries);

        foreach (ArchiveTreeEntry parent in rootArchiveTreeEntries)
        {
            FillChildren(parent, entries);
        }
    }
    return rootArchiveTreeEntries;
}


So here is the completely re-written class: 

public class ArchiveBuilder
{
    public IEnumerable&lt;ArchiveTreeEntry&gt; Build(IEnumerable&lt;ArchiveDefinition&gt; entries)
    {
        IEnumerable&lt;ArchiveTreeEntry&gt; rootArchiveTreeEntries = new List&lt;ArchiveTreeEntry&gt;();

        if (entries != null &amp;&amp; entries.Count &gt; 0)
        {
            entries = rootArchiveTreeEntried.AddRange(GetRootEntries(entries).Select(entry =&gt; new ArchiveTreeEntry(definition)).Except(entries);

            foreach (ArchiveTreeEntry parent in rootArchiveTreeEntries)
            {
                FillChildren(parent, entries);
            }
        }
        return rootArchiveTreeEntries;
    }

    private static void FillChildren(ArchiveTreeEntry parent,
                                 IEnumerable&lt;ArchiveDefinition&gt; entries)
    {
        if (entries.Count &gt; 0)
        {
            IEnumerable&lt;ArchiveDefinition&gt; children = GetChildren(entries, parent.Id);

            if (children.Count &gt; 0)
            {
                RemoveChildren(entries, parent.Id);

                foreach (ArchiveDefinition child in children)
                {
                    ArchiveTreeEntry treeEntryChild = new ArchiveTreeEntry(child);
                    parent.AddChild(treeEntryChild);
                    FillChildren(treeEntryChild, entries);
                }
            }
        }
    }

    private static IEnumerable&lt;ArchiveDefinition&gt; GetRootEntries(IEnumerable&lt;ArchiveDefinition&gt; entries)
    {
        return entries.FindAll(e =&gt; e.TypeOfArchive == ArchiveType.Archive);
    }

    private static IEnumerable&lt;ArchiveDefinition&gt; GetChildren(IEnumerable&lt;ArchiveDefinition&gt; entries, string parentID)
    {
        return entries.FindAll(e =&gt; e.ParentId == parentID);
    }

    private static void RemoveChildren(IEnumerable&lt;ArchiveDefinition&gt; entries, string parentID)
    {
        entries.RemoveAll(e =&gt; e.ParentId == parentID);
    }
}



NB: I haven't compiled the class or tested it, so it might not work out the box.