Escondiendo la complejidad de los tipos genericos

En mi ultimpo post les mostre un uso un tanto raro de los tipos genericos, Ayende dice que no puede leer ese codigo y nos da una alternativa; yo estoy de acuerdo, el codigo es feo, pero aun hay esperanza!

Aqui esta el codigo equivalente a la primera seccion (aun estoy usando tipos genericos, aunque parezca que no es asi), donde queriamos guardar una lista de nombres de archivos:

ListaArchivos listaArchivos = CargarListaArchivos();
ListarArchivos(listaArchivos);

Luego tenemos los genericos bidimensionales, para guardar el nombre del folder y la lista de archivos:

FoldersConArchivos foldersConArchivos = CargarFoldersConArchivos();
foreach (ParFoldersConArchivos kv in foldersConArchivos) {
    Console.WriteLine(string.Format("  Folder: [{0}]", kv.Key));
    ListarArchivos(kv.Value);
}

Finalmente donde guardamos el nombre de la computadora, con los folders, con los archivos que contiene:

ArchivosEnComputadoras archivosEnComputadoras = CargarArchivosEnComputadoras();
foreach (ParComputadorasConFolders kv in archivosEnComputadoras) {
    Console.WriteLine(string.Format("Computer: [{0}]", kv.Key));
    foreach (ParFoldersConArchivos kv1 in kv.Value) {
        Console.WriteLine(string.Format("  Folder: [{0}]", kv1.Key));
        ListarArchivos(kv1.Value);
    }
}

Y mi ultimo ejemplo ahora se veria asi:

ArchivosEnComputadoras archivosEnComputadoras = new ArchivosEnComputadoras();

En vez de esto:

Dictionary<string, Dictionary<string, List<string>>> archivosEnComputadoras = 
new Dictionary<string, Dictionary<string, List<string>>>();

Ahora, si el codigo es equivalente y aun estoy usando tipos genericos, que hice?

Estoy usando genericos con alias (sip, tambien me invente este termino J) los cuales me dan nombres mucho mas amigables que los genericos, en vez de la sintaxis de los genericos multidimensionales.

Aqui estan las declaraciones de los genericos con alias:

using System.Collections.Generic;
using ParFoldersConArchivos = KeyValuePair<string, List<string>>;
using ParComputadorasConFolders = KeyValuePair<string, Dictionary<string, List<string>>>;

using ListaArchivos = List<string>;
using FoldersConArchivos = Dictionary<string, List<string>>;
using ArchivosEnComputadoras = Dictionary<string, Dictionary<string, List<string>>>;

Esto nos da lo mejor de dos mundos, puedes tener tipos complejos de genericos y a la vez mantener tu codigo limpio.

Pones todo lo feo en un lugar nadamas y con eso ya puedes usar nombres mas amigables que se ven como nombres de clases normales, ademas esto tambien hace tu codigo muy extensible, ya que potencialmente podrias cambiar la definicion de los tipos (y aun reemplazarlos por clases) sin quebrar el codigo.

En mi siguiente post les mostrare otra tecnica para lograr el mismo efecto, y algunas ventajas/desventajas de dicho metodo, luego subire todo el codigo fuente en un archivo .zip para que lo puedan bajar todo junto.

salu2