Visual Studio: ¿Cómo muestro todas las clases heredadas de una clase base?

En Visual Studio, ¿cómo muestro todas las clases heredadas de una clase base?

Por ejemplo , en ASP.NET MVC hay varios tipos de ' ActionResult ', y todos heredan / implementan la clase base ActionResult.

Parece que a menos que solo 'sepa' eso Viewy Jsonsean ActionResulttipos válidos , no hay forma de que pueda encontrar fácilmente esta información.

Por favor, demuéstrame que estoy equivocado.

¿Hay algo en el navegador de objetos que lo haga fácil de encontrar?

Incluso tengo sugerencias de herramientas fuera de Visual Studio para descubrir esta información sobre varias clases. Por ejemplo: ¿hay algo en Resharper que me ayude?

Claro, Resharper puede hacer esto. Y mucho más.

Simplemente haga clic derecho en el nombre del tipo en cualquier lugar y elija "Ir al heredero" en el menú contextual. "Ir al heredero" también se puede aplicar al método para navegar a las anulaciones y las implementaciones de un método de interfaz. Para una interfaz, puede volver a llamar "Buscar usos avanzados", simplemente haga clic con el botón derecho) donde encontrará todas las extensiones e implementaciones. Para un tipo derivado de tipos. Y mi característica favorita: haga clic y mantenga presionado Control en cualquier tipo / método para navegar a su declaración.

Creo que es una herramienta imprescindible para los desarrolladores de .net.

En Resharper 9.2, en cualquier tipo de código fuente, haga clic en "Buscar uso avanzado", seleccione Buscar = "Derivado" y Alcance = "Soluciones y bibliotecas".
Por ejemplo, para encontrar todos los herederos (tanto en la biblioteca como en su código) de alguna clase base en una DLL incluida de cualquier proveedor, declare una variable en su código con esa clase base. Luego haga clic derecho en el nombre de la clase base que acaba de escribir.

Para VS2012,

1. Navega hasta el archivo en el explorador de soluciones
2. Expande y selecciona tu clase
3. Haga clic con el botón derecho en el elemento de la clase (no en el elemento del archivo) -> Tipos derivados

No necesariamente necesita Reflector para esto: la vista "Diagrama de clase" de Visual Studio le permitirá encontrar fácilmente todas las clases derivadas para una clase en particular. Haga clic derecho en la clase en "Vista de clase" y elija "Ver diagrama de clase". Si el diagrama no muestra el nivel de detalle que desea para la jerarquía, haga clic derecho en el cuadro de la clase en el diagrama y elija "Mostrar clases derivadas".

Puede que no sea tan directo como Resharper, pero es una opción si aún no tienes R #.

Desafortunadamente, no estoy seguro de qué versiones particulares de Visual Studio lo tienen.

Esta es la respuesta menos perezosa (estoy orgulloso de esta respuesta :)

No tengo ReSharper, lo probé antes pero no quería comprarlo. Probé un diagrama de clase pero no es práctico en absoluto porque el diagrama de jerarquía abarca el mundo 3 veces y la pantalla de mi computadora portátil no tiene un ancho infinito. Entonces, mi solución natural y fácil fue escribir un código de formularios Windows Forms para iterar sobre los tipos en un ensamblaje y usar la reflexión para agregar nodos a una vista de árbol, de la siguiente manera:

suponga que tiene un cuadro de texto, una vista de árbol y otras cosas necesarias en un formulario en el que se ejecuta este código

//Go through all the types and either add them to a tree node, or add a tree
//node or more to them depending whether the type is a base or derived class.
//If neither base or derived, just add them to the dictionary so that they be
//checked in the next iterations for being a parent a child or just remain a
//root level node.

var types = typeof(TYPEOFASSEMBLY).Assembly.GetExportedTypes().ToList();
Dictionary<Type, TreeNode> typeTreeDictionary = new Dictionary<Type, TreeNode>();
foreach (var t in types)
{
    var tTreeNode = FromType(t);
    typeTreeDictionary.Add(t, tTreeNode);

    //either a parent or a child, never in between
    bool foundPlaceAsParent = false;
    bool foundPlaceAsChild = false;
    foreach (var d in typeTreeDictionary.Keys)
    {
        if (d.BaseType.Equals(t))
        {
            //t is parent to d
            foundPlaceAsParent = true;
            tTreeNode.Nodes.Add(typeTreeDictionary[d]);
            //typeTreeDictionary.Remove(d);
        }
        else if (t.BaseType.Equals(d))
        {
            //t is child to d
            foundPlaceAsChild = true;
            typeTreeDictionary[d].Nodes.Add(tTreeNode);
        }
    }

    if (!foundPlaceAsParent && !foundPlaceAsChild)
    {
        //classHierarchyTreeView.Nodes.Add(tn);
    }
}

foreach (var t in typeTreeDictionary.Keys)
{
    if (typeTreeDictionary[t].Level == 0)
    {
        classHierarchyTreeView.Nodes.Add(typeTreeDictionary[t]);
    }
}

StringBuilder sb = new StringBuilder();
foreach (TreeNode t in classHierarchyTreeView.Nodes)
{
    sb.Append(GetStringRepresentation(t, 0));
}
textBox2.Text = sb.ToString();

A partir de 'Visual Studio 2015 Update 1', simplemente puede hacer clic con el botón derecho en el nombre de una clase en el editor de código de clase y luego seleccionar 'Ir a implementación' en el menú contextual: con Ctrl + F12 como acceso directo.

Consulte https://blogs.msdn.microsoft.com/dotnet/2015/11/30/whats-new-in-visual-studio-update-1-for-net-managed-languages/ para obtener más detalles.

Nadie ha mencionado esto todavía, así que lo agregaré.
Jetbrains dotPeek es un descompilador .NET gratuito que tiene el poder de mostrar esta información fácilmente.

Descarga gratuita: http://www.jetbrains.com/decompiler/

Jetbrains es la compañía que fabrica Resharper.

Pasos para encontrar clases derivadas:

1. Poner en marcha dotPeek
2. Seleccione 'Abrir desde GAC ...' y agregue el ensamblado System.Web.MVC
3. Seleccione 'Navegar / Ir a escribir' y escriba ActionResult
4. En la ActionResultdeclaración de clase, haga clic derecho y seleccione 'Símbolos derivados'
5. Voila! Se muestran todas las clases derivadas (¡incluso algunas que no conocía!)

Asumiendo que tiene instalado Resharper : con el cursor en la clase / interfaz, haga clic derecho - Inspeccionar - Jerarquías

Esto muestra subclases, implementaciones y superclases.

En Visual Studio Class View navegue a la clase que le interesa y encuentre sus clases base y derivadas

También puedes usar Reflector .

Cargue todos los ensamblajes en los que desea que se vea, navegue hasta un tipo y expanda el elemento Tipos derivados.

También puede hacerlo en el Explorador de objetos, pero por alguna razón VS2008 solo puede hacerlo en una de las vistas de .Net Framework. (VS2010 Beta 2 puede hacerlo en cualquier vista)

Para las clases de Framework, uso la Biblioteca MSDN. La sección Jerarquía de herencia va en ambas direcciones. Sin embargo, no es de mucha ayuda para algunas bibliotecas de fiestas en 3D.

Con la ayuda de ReSharper (versión 2016.1.2) solo Ctrl+ Alt+ Clicken la Clase Base. Verás algo como esto:

Arrastre la clase o el espacio de nombres desde Object Explorer al archivo Class Digram .

¿Cómo obtener un buen diagrama de clase para las clases .net integradas?

seleccione el tipo y haga clic con el botón derecho para ver algo --- mostrar en el mapa de código --opción seleccionarlo generar la imagen para aquellos que heredan este tipo de imagen tan bonita como el formato de archivo .dgml, da mucha más información sobre el tipo

Como opción para aquellos que usan Visual Assist, también puede presionar Shift + ALT + G (mientras el cursor está en el nombre de la clase) para que aparezca el menú contextual "Ir a relacionado", y si hay clases derivadas obtendrá un submenú para eso que los enumera a todos e incluso muestra estructuras de herencia entre esas clases derivadas.

Solo codifícalo.

Assembly asm = Assembly.LoadFrom(PATH_TO_PROJECT_OUTPUT);

var types = from t in asm.GetTypes()
            where t.BaseType != null && t.BaseType.ToString() == "System.Web.UI.Page"
            // if you want to add reference - where typeof (System.Web.UI.Page).Equals(t.BaseType) 
            select t;

foreach (var type in types)
{
    Console.WriteLine(type);
}

si actualizó a VS2012, puede usar el "Mapa de códigos".
Haga clic derecho sobre el tipo del que desea ver la jerarquía de herencia y elija "Agregar al mapa de código". Luego, en la vista de mapa de código, puede expandir los nodos y hacer clic derecho para elegir "Mostrar clases derivadas / base". Lamentablemente, no funciona para las clases proporcionadas por .NET.

Para Visual Studio 2012 ( sin ReSharper )

1. En el Explorador de soluciones, haga clic con el botón derecho en la clase (cuyas clases derivadas desea ver).
2. En el diagrama de clase, haga clic derecho en la clase y seleccione 'Mostrar clases derivadas'.

Actualización 2020:

Puede usar los mapas de código de Visual Studio que funcionan bastante bien.

Simplemente haga clic derecho en la clase y vaya a:
Code Map> Show Related Items on Code Map>Show All Derived Types

Nota:

• Esta función solo está disponible en la edición Enterprise de Visual Studio, y si no la tiene , puede obtenerla de forma gratuita descargando la versión Enterprise Preview desde aquí .
• O puede pedirle a cualquiera de su equipo que comparta el mapa de códigos con esta función si tienen esa edición.

PD: Realmente vale la pena mantener la versión Enterprise (o al menos la versión Preview) en su máquina, ya que tiene muchas herramientas realmente útiles que no están incluidas en las otras ediciones.

Una forma muy simple de hacer esto es buscar : Classnameen la ventana "Buscar y reemplazar" (CTRL + F) y usar la opción "Buscar opciones / Hacer coincidir palabra completa". Encontrará solo las clases heredadas.