Лучший способ конвертировать List <Object> в ObservableCollection <Object>

Ответ 1

Одна часть ответа - использовать Reactive Extensions (Rx). Вы можете получить его от NuGet и разработали Microsoft. С его помощью вы можете просто сказать: myListCollection.ToObservable();

Если ваши дочерние коллекции всегда находятся в node с тем же именем, вы можете использовать while(item.Collection != null || item.Collection.Count == 0) и поместить ToObservable() в цикл

Ответ 2

Предполагая, что вы имеете в виду ObservableCollection<T>, если вы хотите, чтобы List был непосредственно с ObservableCollection as-is, просто используйте конструктор:

var oc = new ObservableCollection<Object>(yourListOfObject);

Теперь, если вы хотите раскрутить каждый из них, вам нужно будет сделать некоторую работу, чтобы свернуть их в один ObservableCollection<T>.

Ответ 3

Предполагая, что у вас есть класс node, определенный следующим образом:

public class Node
{
    public ICollection<Node> Children { get; set; }
}

Вы можете использовать рекурсию для преобразования коллекций List<Node> на любом уровне глубины:

public static ObservableCollection<Node> ToObservableRecursive(ICollection<Node> nodes)
{
    foreach (Node node in nodes)
        if (node.Children != null)
            node.Children = ToObservableRecursive(node.Children);

    return new ObservableCollection<Node>(nodes);
}

Ответ 4

Я предполагаю, что вы говорите об ObservableCollection. Чтобы просто ответить, вы можете использовать ctor:

List<Object> myList = GetList();
new ObservableCollection<Object>(myList);

Однако, я думаю, что есть некоторая работа, которую нужно выполнить с точки зрения организации вашей информации иерархически.

Ответ 5

Вы имеете в виду ObservableCollection? Если вы хотите, чтобы дочерний уровень Lists можно было наблюдать также, вам нужно будет пересекать дерево и изменять элементы по мере необходимости или добавлять каждый элемент отдельно для начала.

Ответ 6

Вы не можете выполнять какие-либо решения, перечисленные здесь, пока ваши типы не будут одинаковыми! Например, если ваш список или ICollection или IEnumerable имеет тип string, но ваш ObservableCollection должен иметь тип Nodes или Computers или что-то еще, вы должны сначала получить Список в этот тип! Я потратил столько времени на эти другие фиктивные, упрощенные "решения", которые НЕ являются решениями, потому что они не объясняют это или не учитывают этот фактор.

Скажите, что это ваш ObservableCollection:

public class Computer
{
    public string Name { get; set; }
}

Довольно стандартный, не так ли? Вероятно, вы, возможно, замените Computer на любое количество объектов в любом количестве проектов.

Если вы затем получите список имен компьютеров в List<string> под названием lstComputers, вы НЕ МОЖЕТЕ просто преобразовать это, используя:

var oc = new ObservableCollection<Computer>(lstComputers);

Он скажет, что ваши типы несовместимы и не могут быть преобразованы из одного в другой, потому что вы пытаетесь перетащить List<string> в ObservableCollection<Computer>. Квадратная привязка в круглом отверстии.

Вместо этого в вашей функции для получения имен компьютеров вы должны добавить их все "специальные":

public static List<Computer> NetworkComputers()
{
    List<Computer> lstComputers = new List<Computer>();
    DirectoryEntry root = new DirectoryEntry("WinNT:");
    foreach (DirectoryEntry computers in root.Children)
    {
        foreach (DirectoryEntry computer in computers.Children)
        {
            if (computer.Name != "Schema" && computer.SchemaClassName == "Computer")
            {
                lstComputers.Add(new Computer() { Name = computer.Name });
            }
        }
    } 
}

Только потому, что мы использовали эту строку lstComputers.Add(new Computer() { Name = computer.Name }); и возвращаем List<Computer>, а не List<string>, можем ли мы теперь поместить ее в наш ObservableCollection<Computer>.

Если вы пропустили лодку и не можете сделать это с самого начала, в этой ветке рассказывается о других способах, которые вы могли бы сделать: преобразовать список объектов из одного типа в другой с помощью выражения лямбда

Итак, как только вы получите его в List<Computer>, только тогда вы можете сделать:

List<Computer> lstComputers = NetworkComputers();
var oc = new ObservableCollection<Computer>(lstComputers);