Données hiérarchiques dans Linq - options et performances

Je voudrais configurer une vue et une table de base de la fonction basée sur la CTE. Mon raisonnement est que, alors que vous pourriez mettre en œuvre la logique de l'application, cela reviendrait à envoyer les données intermédiaires sur le fil pour le calcul de l'application. À l'aide de la DBML designer, la vue se traduit par un Tableau de l'entité. Vous pouvez ensuite associer la fonction avec la Table de l'entité et invoquer la méthode créée sur le DataContext de dériver des objets du type défini par la vue. À l'aide de la table de fonction permet au moteur de requête de prendre vos paramètres en compte lors de la construction de l'ensemble de résultats, plutôt que d'appliquer une condition sur le résultat défini par la vue après le fait.

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]

Pour l'utiliser, il ferait quelque chose comme, en supposant que certaines raisonnable schéma de nommage:

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...
}
}

Je suis surpris que personne n'a fait allusion à un autre conception de base de données - lors de la hiérarchie doit être aplatie à partir de plusieurs niveaux et extrait avec de haute performance (pas si l'on considère l'espace de stockage), il est préférable d'utiliser une autre entité-2-table d'entité pour suivre la hiérarchie, au lieu de parent_id approche.

Il permettra non seulement unique parent de relations mais aussi multi parent des relations, des indications de niveaux et différents types de relations:

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

Cette méthode d'extension pourrait être modifié pour utiliser IQueryable. Je l'ai utilisé avec succès dans le passé sur une collection d'objets. Il peut travailler pour votre scénario.

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

Voici comment je l'ai appelé:

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

Ce code est améliorée, bug de la version corrigée du code de ici.

J'ai eu cette démarche de Rob Conery blog (vérifiez autour de Pt. 6 de ce code, également sur codeplex) et j'aime l'utiliser. Cela pourrait être amendée pour prendre en charge plusieurs "sous" les niveaux.

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

Veuillez lire le lien suivant.

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