Générer des URL du site dans la base de données

Question

Énoncé du problème:

URL sont stockées dans une base de données, par exemple:

home/page1 
gallery/image1 
info/IT/contact 
home/page2 
home/page3 
gallery/image2 
info/IT/map 

et ainsi de suite.

Je voudrais organiser les URLs ci-dessus dans une arborescence comme indiqué ci-dessous (chaque élément sera un lien URL). Le résultat final serait une simple liste HTML (plus une sous-liste (s))

ainsi:

home   gallery   info 
    page1   image1   IT 
    page2   image2   contact 
    page3       map 

langage de programmation est C#, la plate-forme est asp.net

EDIT 1:

Dans l'exemple ci-dessus, nous nous retrouvons avec Trois Listes car dans notre exemple il y a trois groupes principaux, par exemple: home, gallery, info.

Naturellement, cela peut changer, l'algorithme doit être en mesure de construire en quelque sorte les listes récursive ..

Answer 1

ok, l'a fait:

abord créé une classe:

public class Node 
{ 
    private string _Parent = string.Empty; 
    private string _Child = string.Empty; 
    private bool _IsRoot = false; 

    public string Parent 
    { 
     set { _Parent = value; } 
     get { return _Parent; } 
    } 

    public string Child 
    { 
     set { _Child = value; } 
     get { return _Child; } 
    } 

    public Node(string PChild, string PParent) 
    { 
     _Parent = PParent; 
     _Child = PChild; 
    } 

    public bool IsRoot 
    { 
     set { _IsRoot = value; } 
     get { return _IsRoot; } 
    } 
} 

alors généré le SiteMap, en transformant les chaînes urls directement comme suit:

private static string MakeTree() 
    { 
     List<Node> __myTree = new List<Node>(); 

     List<string> urlRecords = new List<string>(); 
     urlRecords.Add("home/image1"); 
     urlRecords.Add("home/image2"); 
     urlRecords.Add("IT/contact/map"); 
     urlRecords.Add("IT/contact/address"); 
     urlRecords.Add("IT/jobs"); 

     __myTree = ExtractNode(urlRecords); 

     List<string> __roots = new List<string>(); 

     foreach(Node itm in __myTree) 
     { 
      if (itm.IsRoot) 
      { 
       __roots.Add(itm.Child.ToString()); 
      } 
     } 

     string __trees = string.Empty; 

     foreach (string roots in __roots) 
     { 
      __trees += GetChildren(roots, __myTree) + "<hr/>"; 
     } 


     return __trees; 
    } 

    private static string GetChildren(string PRoot, List<Node> PList) 
    { 
     string __res = string.Empty; 
     int __Idx = 0; 

     foreach (Node x in PList) 
     { 
      if (x.Parent.Equals(PRoot)) 
      { 
       __Idx += 1; 
      } 
     } 

     if (__Idx > 0) 
     { 
      string RootHeader = string.Empty; 

      foreach (Node x in PList) 
      { 
       if (x.IsRoot & PRoot == x.Child) 
       { 
        RootHeader = x.Child; 
       } 
      } 

      __res += RootHeader+ "<ul>\n"; 

      foreach (Node itm in PList) 
      { 
       if (itm.Parent.Equals(PRoot)) 
       { 
        __res += string.Format("<ul><li>{0}{1}</li></ul>\n", itm.Child, GetChildren(itm.Child, PList)); 
       } 
      } 
      __res += "</ul>\n"; 
      return __res; 
     } 
     return string.Empty; 
    } 

    private static List<Node> ExtractNode(List<string> Urls) 
    { 
     List<Node> __NodeList = new List<Node>(); 

     foreach (string itm in Urls) 
     { 
      string[] __arr = itm.Split('/'); 
      int __idx = -1; 

      foreach (string node in __arr) 
      { 
       __idx += 1; 
       if (__idx == 0) 
       { 
        Node __node = new Node(node, ""); 
        if (!__NodeList.Exists(x => x.Child == __node.Child & x.Parent == __node.Parent)) 
        { 
         __node.IsRoot = true; 
         __NodeList.Add(__node);  
        } 
       } 
       else 
       { 
        Node __node = new Node(node, __arr[__idx - 1].ToString()); 
        { 
         if (!__NodeList.Exists (x => x.Child == __node.Child & x.Parent == __node.Parent)) 
         { 
          __NodeList.Add(__node); 
         } 
        } 
       } 
      } 
     } 
     return __NodeList; 
    } 

de toute façon il ' s pas optimisé, je suis sûr que je peux le nettoyer beaucoup ..

Answer 2

Eh bien, le tri de ces chaînes ont besoin de beaucoup de travail, je l'ai fait quelque chose de similaire à votre condition.I souhaite partager la stratégie avec vous.

Tout d'abord, (si vous pouvez changer la conception de vos tables en effet)
Créer une URL de table comme ci-dessous

---------------- 
| URL Table | 
---------------- 
| ID   | 
| ParentID | 
| Page  | 
|..extra info..| 
---------------- 

Il est une mise en œuvre de la catégorie et sous-catégorie dans la même table.In de manière similaire , vous pouvez insérer contiens beaucoup de pages et par exemple subpage.For,

------------------------------------- 
| ID | ParentID | Page  | ... 
------------------------------------ 
| 0 |  null  | Home  | 
| 1 |  null  | Gallery | 
| 2 |  null  | Info  | 
| 3 |  0  | Page1 | 
| 4 |  0  | Page2 | 
| 5 |  0  | Page3 | ... 
| 6 |  1  | Image1 | 
| 7 |  1  | Image2 | 
| 8 |  2  |  IT  | 
| 9 |  8  | contact | 
| 1 |  8  |  map  | 
------------------------------------- ... 

quand ParentID est nulle alors son plus haut niveau
quand ParentID est et ID alors son sous-niveau de tout niveau est sur cet ID et ainsi de suite ...

De côté C#, vous savez les premières pages où est des parentid nulles.
Vous pouvez apporter des sous-pages d'eux par ID sélectionnés des pages supérieures. C'est un travail ADO.NET.

Hope this helps
Myra