Me esta rompiendo la cabeza!!!

Hola,
si lo he entendido bien, tienes unos grupos, y algunos tienen unos 'grupos
padre'. Imagino q habrá unos grupos q no tienen padres (los abuelos de todos
XD). Yo tuve una cosa parecida con usuarios y grupos... unos grupos puedes
pertenecer a otro y así...
Bien, la cosa es como quieres cogerlos. Es decir, por lo visto quieres hacer
un SP que te los de ordenados. Pero vayamos viendo las posibilidades. Puedes
cogerlos todos, con un simple select * que te los da tal cual y luego
ordenarlos por programa... haciendo búsquedas y tal. De todas formas el SP
lo mejor que te lo podrá dar es agruparlos de alguna forma. Es decir, será,
al fin y al cabo, una select solo q la estructura la puedes poner tú de
alguna forma.
Por ejemplo puedes hacer un select * from grupos order by IdGrupoParent. Así
todos los grupos del mismo padre estarán seguidos, y quizás te podría ayudar
o optimizar algo el algoritmo de ordenación y agrupamiento. Ahora bien, los
q no tienen padres q tendrán en ese campo? 0, null?? habrá q tener eso en
cuenta... para saber si al odenarlos los pondrá al principio o al final. Así
ya sabes como te devolverá la consulta.
Creo q en el SP es la forma de hacerlo. Luego si los agrupar o hacer alguna
otra cosa eso tú mismo... pero como idea creo q se coge
Ahora bien, la tarea de agruparlos en el código es lo q importa.
Por suerte un grupo solo puede ser hijo de otro. Eso lo simplifica algo...
Pero aún así pueden haber estrucutras de varios hijos, del tipo:

*grupo1
-*grupo1.2.1
*grupo1.2.1.1
*grupo2
etc--

Yo haría lo siguiente, muy cutre ahora pero quizás te pueda servir como
idea... La consulta la meto en un dataset, por ejemplo. Lo q yo hacía en
realidad era crearme una clase CGrupo con los tres campos y los metía en un
Array. Si usas DataSet puedes hacer subconsultas, pero ya de rendimiento no
sé q será mejor. Eso como quieras. Luego he de hacer una función para
rellenar el árbol. Esa función, o algoritmo, como resultado crea un TreeNode
que lo introduce en el árbol, y ese TreeNode puede q sea nulo si ese grupo
no tienes padre... creo q ya me estoy liando tb yo... a ver... Algo así:
suponiendo q lo hao con un array de clases CGrupo, y que IdPadre es un int y
q un 0 (cero) indica q no tiene padre. La cosa es, por cda grupo, se crea su
TreeNode, se busca el TreeNode de su padre, y se le cuelga:

-
int padre=0; // es el primero por lo q vamos a suponer q al menos hay uno
sin padre
TreeNode tn=null; //es el treenode q servirá de padre para colgar los
hijos... creo q esta frase no ha salido muy lúcida...
Foreach (CGrupo g in grupos) //grupos es el array
{
int pAct=0;//padre del grupo actual. si es el mismo del anterior no lo
vamos a buscar, ya lo tenemos en tn, por q esta ordenado de la consulta...
if (pAct!=padre)
{
//Se busca el nodopadre y se guarda en tn
tn=; //ya se tiene guardado
}
//Se crea el nodo de este grupo:
TreeNode tnHijo=..; //Con la descripcion o como quieras
//Se añade al padre, no recuerdo como era pero ma o meno...
tn.Nodes.Add(tnHijo);
}



Creo q así estaría más o menos???? Joe, ya ni sé pq ha venido un colega a
hablar y me ha cortado el hilo en mitad del rollo... Miralo a ver si te
sirve de algo..
Espero q te sea de ayuda
Suerte
Un saludo