Hierarchische Daten in Linq - Optionen und Leistung

Ich würde eine view und einen zugehörigen Tisch-basierte Funktion, die basierend auf den Allgemeinen Tabellenausdruck. Mein Grund für dieses ist, dass, während Sie könnte implementieren die Logik der Anwendung auf die Seite, das würde auch die übermittlung der Zwischenergebnisse über den Draht für die Berechnung in der Anwendung. Mit der DBML-designer die Ansicht, übersetzt in eine Tabelle Person. Sie können dann verknüpfen Sie die Funktion mit der Tabelle Person und die Methode aufrufen, erstellt am DataContext abgeleitet Objekte des Typs durch den view definiert sind. Mit der Tisch-basierte Funktion erlaubt die Abfrage-engine, um Ihr Parameter zu berücksichtigen bei der Konstruktion das Ergebnis eher als das anwenden einer Bedingung auf die Ergebnismenge durch den view definiert sind, nach der Tat.

CREATE TABLE [dbo].[hierarchical_table](
    [id] [int] IDENTITY(1,1) NOT NULL,
    [parent_id] [int] NULL,
    [data] [varchar](255) NOT NULL,
 CONSTRAINT [PK_hierarchical_table] PRIMARY KEY CLUSTERED 
(
    [id] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

CREATE VIEW [dbo].[vw_recursive_view]
AS
WITH hierarchy_cte(id, parent_id, data, lvl) AS
(SELECT     id, parent_id, data, 0 AS lvl
      FROM         dbo.hierarchical_table
      WHERE     (parent_id IS NULL)
      UNION ALL
      SELECT     t1.id, t1.parent_id, t1.data, h.lvl + 1 AS lvl
      FROM         dbo.hierarchical_table AS t1 INNER JOIN
                            hierarchy_cte AS h ON t1.parent_id = h.id)
SELECT     id, parent_id, data, lvl
FROM         hierarchy_cte AS result


CREATE FUNCTION [dbo].[fn_tree_for_parent] 
(
    @parent int
)
RETURNS 
@result TABLE 
(
    id int not null,
    parent_id int,
    data varchar(255) not null,
    lvl int not null
)
AS
BEGIN
    WITH hierarchy_cte(id, parent_id, data, lvl) AS
   (SELECT     id, parent_id, data, 0 AS lvl
        FROM         dbo.hierarchical_table
        WHERE     (id = @parent OR (parent_id IS NULL AND @parent IS NULL))
        UNION ALL
        SELECT     t1.id, t1.parent_id, t1.data, h.lvl + 1 AS lvl
        FROM         dbo.hierarchical_table AS t1 INNER JOIN
            hierarchy_cte AS h ON t1.parent_id = h.id)
    INSERT INTO @result
    SELECT     id, parent_id, data, lvl
    FROM         hierarchy_cte AS result
RETURN 
END

ALTER TABLE [dbo].[hierarchical_table]  WITH CHECK ADD  CONSTRAINT [FK_hierarchical_table_hierarchical_table] FOREIGN KEY([parent_id])
REFERENCES [dbo].[hierarchical_table] ([id])

ALTER TABLE [dbo].[hierarchical_table] CHECK CONSTRAINT [FK_hierarchical_table_hierarchical_table]

Verwenden, Sie würde so etwas machen-vorausgesetzt, einige vernünftige Namensschema:

using (DataContext dc = new HierarchicalDataContext())
{
    HierarchicalTableEntity h = (from e in dc.HierarchicalTableEntities
                                 select e).First();
    var query = dc.FnTreeForParent( h.ID );
    foreach (HierarchicalTableViewEntity entity in query) {
        ...process the tree node...
    }
}

Ich bin überrascht, niemand erwähnt hat, eine alternative Datenbank-design - bei der Hierarchie reduziert werden muss aus mehreren Ebenen und abgerufen werden, mit hoher Leistung (nicht so bedenkt, Speicherplatz) ist es besser, auf eine andere Person-2-Person-Tabelle zu verfolgen, Hierarchie statt parent_id Ansatz.

Wird es erlauben, nicht nur single-Eltern-Beziehungen, sondern auch multi-parent-Beziehungen, Ebene Indikationen und verschiedene Arten von Beziehungen:

CREATE TABLE Person (
  Id INTEGER,
  Name TEXT
);

CREATE TABLE PersonInPerson (
  PersonId INTEGER NOT NULL,
  InPersonId INTEGER NOT NULL,
  Level INTEGER,
  RelationKind VARCHAR(1)
);

Diese Erweiterung Methode könnte möglicherweise geändert werden, um IQueryable. Ich habe es erfolgreich in der Vergangenheit auf eine Sammlung von Objekten. Es kann funktionieren, für Ihr Szenario.

public static IEnumerable<T> ByHierarchy<T>(
 this IEnumerable<T> source, Func<T, bool> startWith, Func<T, T, bool> connectBy)
{
  if (source == null)
   throw new ArgumentNullException("source");

  if (startWith == null)
   throw new ArgumentNullException("startWith");

  if (connectBy == null)
   throw new ArgumentNullException("connectBy");

  foreach (T root in source.Where(startWith))
  {
   yield return root;
   foreach (T child in source.ByHierarchy(c => connectBy(root, c), connectBy))
   {
    yield return child;
   }
 }
}

Hier ist, wie ich es nannte:

comments.ByHierarchy(comment => comment.ParentNum == parentNum, 
 (parent, child) => child.ParentNum == parent.CommentNum && includeChildren)

Dieser code ist eine verbesserte, ein bug-Fix-version des code gefunden hier.

Ich habe diesen Ansatz aus Rob Conery s blog (überprüfen Sie rund um Pt. 6 für diesen code, auch auf codeplex) und ich Liebe es zu benutzen. Dies könnte refashioned Unterstützung für mehrere "sub" - Ebenen.

var categories = from c in db.Categories
                 select new Category
                 {
                     CategoryID = c.CategoryID,
                     ParentCategoryID = c.ParentCategoryID,
                     SubCategories = new List<Category>(
                                      from sc in db.Categories
                                      where sc.ParentCategoryID == c.CategoryID
                                      select new Category {
                                        CategoryID = sc.CategoryID, 
                                        ParentProductID = sc.ParentProductID
                                        }
                                      )
                             };

Lesen Sie bitte den folgenden link.

http://support.microsoft.com/default.aspx?scid=kb;en-us;q248915