Créer hiérarchique de la structure de la classe , en boucle par le biais de la table de données, puis ajouter le parent et l'enfant et le retour de l'objet

Je veux créer une structure de classe qui peuvent représenter les suivantes heirarchichal de la structure des objets de même type

-Parent1
- - Child1 
- - - ChildA of Child1
- - - ChildB of Child1
- - Child2 
- - - ChildA of Child2
- - - ChildB of Child2
- Parent2

La datatable lignes ont un ID, ParentID, le nom et le niveau de

niveau est O pour les Parents, de 1 pour Enfant de 1 , 2 pour les Enfanta et ainsi de suite

Je suis en mesure de retourner les données de la DB à une table, mais je suis en difficulté après que
toute aide sur la création de la structure de la classe et puis le remplissage de l'objet serait grandement apprécié

Quels sont vos types de ici - sont Enfant1 et Enfant2 différents?
Comment est cette hiérarchie représentée dans votre dataTable ? Pouvez-vous fournir et par l'exemple ?
Les Parents et les enfants sont tous de même type

OriginalL'auteur cWilk | 2012-05-01

c#hierarchy

Voici un exemple sur la façon de le faire à l'aide de LINQ. D'abord un sampe datatable. Je suppose que les éléments ont un parent ID de 0.

var dataTable = new DataTable();
dataTable.Columns.Add("Id", typeof(Int32));
dataTable.Columns.Add("ParentId", typeof(Int32));
dataTable.Columns.Add("Name", typeof(String));
dataTable.Rows.Add(new Object[] { 1, 0, "A" });
dataTable.Rows.Add(new Object[] { 2, 1, "B" });
dataTable.Rows.Add(new Object[] { 3, 1, "C" });
dataTable.Rows.Add(new Object[] { 4, 0, "D" });
dataTable.Rows.Add(new Object[] { 5, 4, "E" });

D'une classe pour représenter chaque élément de données:

class Item {

  public Int32 Id { get; set; }

  public String Name { get; set; }

  public IEnumerable<Item> Children { get; set; }

}

Une fonction pour obtenir les enfants d'un élément spécifique:

IEnumerable<DataRow> GetChildren(DataTable dataTable, Int32 parentId) {
  return dataTable
    .Rows
    .Cast<DataRow>()
    .Where(row => row.Field<Int32>("ParentId") == parentId);
}

Une fonction pour créer un article, y compris l'enfant de la collection. Cette fonction de manière récursive en bas de la hiérarchie:

Item CreateItem(DataTable dataTable, DataRow row) {
  var id = row.Field<Int32>("Id");
  var name = row.Field<String>("Name");
  var children = GetChildren(dataTable, id)
    .Select(r => CreateItem(dataTable, r))
    .ToList();
  return new Item { Id = id, Name = name, Children = children };
}

Une fonction permettant d'obtenir des lignes de haut-niveau des éléments:

IEnumerable<DataRow> GetTopLevelRows(DataTable dataTable) {
  return dataTable
    .Rows
    .Cast<DataRow>()
    .Where(row => row.Field<Int32>("ParentId") == 0);
}

Mettant tous ensemble:

var items = GetTopLevelRows(dataTable)
  .Select(row => CreateItem(dataTable, row))
  .ToList();

oups , je suis en fait en utilisant un ensemble de données , est-ce que changer les choses grandement ?
Un DataSet contient un Tables collection. Choisissez la table qui contient les données.
ya, je l'ai compris et utilisé - le retour du jeu de résultats.Tables[0] pour obtenir ma table
Merci Martin, c'était d'une grande aide

OriginalL'auteur Martin Liversage

2

Donné les informations ci-dessus vous pouvez le faire avec une seule classe.
```
public class MyItem
{
  public IList<MyItem> ChildItems{get;set;}
}
```
Ici, vous avez reçu un objet qui peut contenir une collection de son propre type comme des enfants, et ainsi, les enfants peuvent contenir des collections de MyItem trop de sous des enfants.

De considérer les éléments suivants:
```
var parentItem = new MyItem()
var childItem = new MyItem();
var childChildItem = new MyItem();

childItem.ChildItems.Add(childChildItem);
parentItem.ChildItems.Add(childItem);
```
Il ya de meilleurs moyens de code de l'ajout d'éléments, mais ce il la décompose assez logiquement pour le concept d'être clair.

OriginalL'auteur Jamie Dixon

Voici mon approche.

Commencer avec les données définies dans la question:

var dataTable = new DataTable();
dataTable.Columns.Add("Id", typeof(int));
dataTable.Columns.Add("ParentId", typeof(int));
dataTable.Columns.Add("Name", typeof(String));
dataTable.Rows.Add(new Object[] { 1, 0, "Parent1" });
dataTable.Rows.Add(new Object[] { 2, 1, "Child1" });
dataTable.Rows.Add(new Object[] { 3, 2, "ChildA of Child1" });
dataTable.Rows.Add(new Object[] { 4, 2, "ChildB of Child1" });
dataTable.Rows.Add(new Object[] { 5, 1, "Child2" });
dataTable.Rows.Add(new Object[] { 6, 5, "ChildA of Child2" });
dataTable.Rows.Add(new Object[] { 7, 5, "ChildB of Child2" });  
dataTable.Rows.Add(new Object[] { 8, 0, "Parent2" });

Puis il suffit de faire ceci:

var lookup = dataTable.Rows.Cast<DataRow>().ToLookup(x => x.Field<int>("ParentId"));

Func<int, Item[]> build = null;
build = n =>
    lookup[n]
        .Select(dr => new Item()
            {
                Id = dr.Field<int>("Id"),
                Name = dr.Field<string>("Name"),
                Children = build(dr.Field<int>("Id")),
            })
            .ToArray();

var items = build(0);

Qui donne:

Créer hiérarchique de la structure de la classe , en boucle par le biais de la table de données, puis ajouter le parent et l'enfant et le retour de l'objet

OriginalL'auteur Enigmativity

Vous devez vous connecter pour publier un commentaire.