Le meilleur moyen de convertir une Liste<Object> ObservableCollection<Object>

J'ai List<Object> où la Objet a beaucoup de childs List<Object> autour de 4 à 6 niveaux.

Maintenant, j'ai de la lier à WPF TreeView... 🙁

Qui la meilleure façon de le convertir en ObservableCollection<Object> est?

Pourquoi ne pas juste faire ObservableCollection<object> en premier lieu? Lorsque vous travaillez avec WPF, il est important d'obtenir les données de la couche de droit, et si jamais vous êtes l'affichage d'une liste que vous pouvez modifier dans l'INTERFACE utilisateur, vous devez toujours utiliser une ObservableCollection au lieu d'un List
Correct. La première place est RIA Services. Je ne sais pas si c'est possible de le faire...

OriginalL'auteur Terminador | 2012-01-30

  1. 4

    Une partie de la réponse est l'utilisation de Réactifs Extensions (Rx). Vous pouvez l'obtenir à partir d'NuGet et il est développé par Microsoft. Avec l'aide de vous pouvez simplement dire: myListCollection.ToObservable();

    Si votre enfant collections sont toujours dans un nœud du même nom, vous pouvez utiliser une while(item.Collection != null || item.Collection.Count == 0) et de mettre le ToObservable() à l'intérieur de la boucle

    C'est un overkill

    OriginalL'auteur Mharlin

  2. 18

    En supposant que vous voulez dire ObservableCollection<T>, si vous vouliez le List directement à la ObservableCollection comme-est, il suffit d'utiliser le constructeur:

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

    Maintenant, si vous êtes désireux de vous détendre chacun de ceux-ci, vous aurez besoin de faire un peu de travail pour les réunir en un seul ObservableCollection<T>.

    Si j'ai créé une classe publique appelée Computer et ont un public string Name getter / setter à l'intérieur de mon OC, et puis j'ai une List<string> lstComputers, il me dit que je cannot convert from 'System.Collections.Generic.List<string>' to 'System.Collections.Generic.List<MyProject.MainWindow.Computer>'.
    En fait j'ai trouvé comment le faire. Vous ne pouvez pas être incompatibles types.

    OriginalL'auteur James Michael Hare

  3. 3

    En supposant que vous avez une classe de nœud défini comme suit:

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

    Vous pouvez utiliser la récursivité pour convertir List<Node> collections, à n'importe quel niveau de profondeur:

    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);
}
    Il est très utile! Merci!!!!
    Si j'ai créé une classe publique appelée Computer et ont un public string Name getter / setter à l'intérieur de mon OC, et puis j'ai une List<string> lstComputers, il me dit que je cannot convert from 'System.Collections.Generic.List<string>' to 'System.Collections.Generic.List<MyProject.MainWindow.Comput‌​er>'
    En fait j'ai trouvé comment le faire. Vous ne pouvez pas être incompatibles types.

    OriginalL'auteur Douglas

  4. 1

    Je suppose que vous parlez d'une ObservableCollection. Pour répondre simplement, vous pouvez utiliser le ctor:

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

    Cependant, je pense qu'il y a un certain travail reste à faire en termes d'organisation de vos informations de façon hiérarchique.

    Do u pense que cela fonctionnera pour tous les childs Liste<Object>?
    Liste<Object> n'est pas une commune de l'utilisation des génériques. Commencer par un examen des génériques ici: stackoverflow.com/questions/155260/...
    En plus, ici, c'est un bon billet de blog que je viens de googlé que les détails de la liaison de données hiérarchiques à un WPF TreeView: mattlong.com.au/?p=37

    OriginalL'auteur Chris Trombley

  5. 1

    Voulez-vous dire ObservableCollection? Si vous souhaitez que l'enfant niveau Lists pour être observable aussi, alors vous aurez besoin de parcourir l'arbre et modifier des éléments comme nécessaire ou ajouter chaque élément séparément pour commencer.

    OriginalL'auteur Miserable Variable

  6. 1

    Vous ne pouvez pas faire toute les solutions énumérées ici jusqu'à ce que votre types sont les mêmes! Si votre liste ou ICollection ou IEnumerable est de type string, par exemple, mais votre ObservableCollection doit être de type Nodes ou Computers ou quelque chose d'autre, vous devez obtenir la Liste de ce type, d'abord! J'ai perdu beaucoup de temps sur ces autres faux, simplifiée des "solutions" qui ne sont PAS des solutions parce qu'ils n'expliquent pas ce ou de prendre ce facteur en compte.

    Dire que c'est votre ObservableCollection:

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

    Assez standard, à droite? Vous seriez probablement jusqu'à la fin du remplacement Computer avec un certain nombre de choses dans un certain nombre de projets.

    Si vous obtenez alors une liste de noms d'ordinateur dans un List<string> appelé lstComputers, vous NE pouvez pas juste de les convertir à l'aide de:

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

    Il va dire à vos types sont incompatibles et ne peuvent être convertis à partir de l'une à l'autre parce que vous essayez de pousser un List<string> dans un ObservableCollection<Computer>. Cheville carrée dans un trou rond.

    Au lieu de cela, dans votre fonction pour obtenir les noms d'ordinateur, vous devez les ajouter tous les "spéciaux" comme:

    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 });
            }
        }
    } 
}

    Seulement parce que nous avons utilisé cette ligne lstComputers.Add(new Computer() { Name = computer.Name }); et sont de retour à la List<Computer> et pas List<string> pouvons-nous maintenant nous mettre dans notre ObservableCollection<Computer>.

    Si vous avez manqué le bateau et ne peut pas faire comme ça depuis le début, ce fil parle de d'autres façons que vous pourriez être en mesure de faire votre conversion:
    la conversion d'une liste d'objets à partir d'un type à l'autre en utilisant la lambda expression

    Donc, une fois que vous l'avez dans un List<Computer>, alors seulement vous pouvez le faire:

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

    OriginalL'auteur vapcguy