Visual Studio: come posso mostrare tutte le classi ereditate da una classe base?

In Visual Studio, come posso mostrare tutte le classi ereditate da una classe base?

Ad esempio , in ASP.NET MVC ci sono diversi tipi di " ActionResult " e tutti ereditano / implementano la classe base ActionResult.

A meno che tu non lo sappia Viewe non sia un tipo Jsonvalido ActionResult, non è possibile trovare facilmente queste informazioni.

Per favore, dimostrami che mi sbaglio.

C'è qualcosa nel browser degli oggetti che lo rende facile da scoprire?

Sono anche pronto per suggerimenti di strumenti al di fuori di Visual Studio per scoprire queste informazioni su varie classi. Ad esempio: c'è qualcosa in Resharper che mi aiuterà?

Certo, Resharper può farlo. E altro ancora.

Basta fare clic destro sul nome del tipo in qualsiasi luogo e scegliere "Vai a ereditario" nel menu di scelta rapida. "Go To Inheritor" può anche essere applicato al metodo per navigare verso le sostituzioni e le implementazioni di un metodo di interfaccia. Per un'interfaccia è possibile chiamare nuovamente "Trova utenti avanzati", fare clic con il pulsante destro del mouse) dove trovare tutte le estensioni e le implementazioni. Per i tipi derivati ​​da un tipo. E la mia funzione preferita: fai clic tenendo premuto il controllo su qualsiasi tipo / metodo per passare alla relativa dichiarazione.

Penso che sia uno strumento indispensabile per gli sviluppatori .net.

In Resharper 9.2, su qualsiasi tipo di codice sorgente, fare clic con il tasto destro del mouse su "Trova utilizzo avanzato", selezionare Trova = "Derivato" e Ambito = "Soluzioni e librerie".
Ad esempio, per trovare tutti gli eredi (sia nella libreria che nel codice) di una classe di base in una DLL inclusa di qualsiasi fornitore, dichiarare una variabile nel codice con quella classe di base. Quindi fare clic con il tasto destro del mouse sul nome della classe di base appena digitato.

Per VS2012,

1. Passare al file in Esplora soluzioni
2. Espandi e seleziona la tua classe
3. Fare clic con il tasto destro del mouse sull'elemento della classe (non sull'elemento del file) -> Tipi derivati

Non è necessario necessariamente Reflector per questo - la vista "Class Diagram" di Visual Studio ti consentirà di trovare facilmente anche tutte le classi derivate per una determinata classe. Fai clic con il tasto destro del mouse sulla classe in "Visualizzazione classe" e scegli "Visualizza diagramma di classe". Se il diagramma non mostra il livello di dettaglio desiderato per la gerarchia, fai clic con il pulsante destro del mouse sulla casella per la classe nel diagramma e scegli "Mostra classi derivate".

Potrebbe non essere diretto come Resharper, ma è un'opzione se non hai già R #.

Sfortunatamente, non sono sicuro di quali versioni particolari di Visual Studio ce l'hanno.

Questa è la risposta meno pigra (sono solo orgoglioso di questa risposta :)

Non ho ReSharper, l'ho provato prima ma non volevo acquistarlo. Ho provato un diagramma di classe ma non è affatto pratico perché il diagramma gerarchico attraversa il mondo 3 volte e lo schermo del mio laptop non ha una larghezza infinita. Quindi la mia soluzione naturale e semplice era scrivere del codice di Windows Form per scorrere i tipi in un assembly e usare la riflessione per aggiungere nodi a una vista ad albero, come segue:

supponiamo di avere una casella di testo, una vista ad albero e altre cose necessarie in un modulo in cui viene eseguito questo codice

//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 partire da "Visual Studio 2015 Update 1" puoi semplicemente fare clic con il pulsante destro del mouse sul nome di una classe nell'editor del codice di classe e quindi selezionare "Vai all'implementazione" dal menu contestuale: con Ctrl + F12 come scorciatoia.

Vedi https://blogs.msdn.microsoft.com/dotnet/2015/11/30/whats-new-in-visual-studio-update-1-for-net-managed-languages/ per maggiori dettagli.

Nessuno lo ha ancora menzionato, quindi lo aggiungerò.
Jetbrains dotPeek è un decompilatore .NET gratuito che ha il potere di mostrare facilmente queste informazioni.

Download gratuito: http://www.jetbrains.com/decompiler/

Jetbrains è la società che produce Resharper.

Passaggi per trovare le classi derivate:

1. Avvia dotPeek
2. Selezionare "Apri da GAC ​​..." e aggiungere l'assembly System.Web.MVC
3. Seleziona "Naviga / Vai a digitare" e digita ActionResult
4. Nella ActionResultdichiarazione di classe, fare clic con il tasto destro e selezionare "Simboli derivati"
5. Ecco! Viene mostrata ogni singola classe derivata (anche alcune che non conoscevo!)

Supponendo di avere Resharper installato: con il cursore sulla classe / interfaccia, fare clic con il tasto destro - Ispeziona - Gerarchie

Questo mostra sottoclassi, implementazioni e superclassi.

In Visual Studio Class View vai alla classe che ti interessa e trova le sue classi base e derivata

Puoi anche usare Reflector .

Caricare tutti gli assiemi in cui si desidera guardare, passare a un tipo ed espandere l'elemento Tipi derivati.

Puoi anche farlo nel Browser degli oggetti, ma per qualche ragione VS2008 può farlo solo in una delle viste .Net Framework. (VS2010 Beta 2 può farlo in qualsiasi vista)

Per le classi Framework, utilizzo la libreria MSDN. La sezione Gerarchia ereditaria va in entrambe le direzioni. Certo, non c'è molto aiuto per alcune librerie di feste 3d, però.

Con l'aiuto di ReSharper (versione 2016.1.2) solo Ctrl+ Alt+ Clicksulla classe base. Vedrai qualcosa del genere:

Trascina la classe o lo spazio dei nomi da Esplora oggetti nel file Digram di classe .

Come ottenere un bel diagramma di classe per le classi .net integrate?

seleziona il tipo e fai clic con il pulsante destro del mouse per vedere qualcosa --- mostra sulla mappa del codice - opzione selezionala genera il form di immagine per coloro che ereditano questo tipo di immagine molto bella come il formato di file .dgml fornisce molte più informazioni sul tipo

Come opzione per coloro che usano Visual Assist, puoi anche premere Maiusc + ALT + G (mentre il cursore è sul nome della classe) per visualizzare il menu di scelta rapida "Vai a correlati" e se ci sono classi derivate otterrai un sottomenu per quello che li elenca tutti fuori e mostra persino le strutture ereditarie tra quelle classi derivate.

Basta codificarlo.

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

se hai effettuato l'upgrade a VS2012 puoi utilizzare la "Mappa codici".
Fai clic con il tasto destro del mouse sul tipo di cui desideri visualizzare la gerarchia ereditaria e scegli "Aggiungi alla mappa del codice". Quindi nella vista della mappa del codice è possibile espandere i nodi e fare clic con il tasto destro del mouse per scegliere "Mostra classi derivate / base". Sfortunatamente non funziona per le classi fornite da .NET.

Per Visual Studio 2012 ( senza ReSharper )

1. In Esplora soluzioni fare clic con il pulsante destro del mouse sulla classe (di cui si desidera visualizzare le classi derivate).
2. Nel diagramma delle classi, fai clic con il pulsante destro del mouse sulla classe e seleziona "Mostra classi derivate".

Aggiornamento 2020:

È possibile utilizzare le mappe dei codici di Visual Studio che funzionano abbastanza bene.

È sufficiente fare clic destro sulla classe e passare a:
Code Map> Show Related Items on Code Map>Show All Derived Types

Nota:

• Questa funzione è disponibile solo sull'edizione Enterprise di Visual Studio e, in caso contrario , puoi scaricarla gratuitamente scaricando la versione di anteprima aziendale da qui .
• Oppure potresti semplicemente chiedere a chiunque del tuo team di condividere la mappa del codice con questa funzione se ha quell'edizione.

PS Vale davvero la pena conservare la versione Enterprise (o almeno la versione di anteprima) nella tua macchina, in quanto ha un sacco di strumenti davvero utili che non sono inclusi nelle altre edizioni.

Un modo molto semplice per farlo è cercare : Classnamenella finestra "Trova e sostituisci" (CTRL + F) e utilizzare l'opzione "Trova opzioni / Trova parola intera". Troverai solo le classi ereditate.