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

Question

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

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

Sembra che a meno che non si sappia che Visualizza e Json sono tipi ActionResult validi, non è possibile trovare facilmente questa informazione fuori.

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à?

Answer 1

Certo, Resharper può farlo. E molto altro ancora.

Basta fare clic con il tasto destro del mouse sul nome del tipo in qualsiasi luogo e scegliere " Vai a ereditario " nel menu contestuale. " Vai a ereditario " può anche essere applicato al metodo per navigare verso le sostituzioni e le implementazioni di un metodo di interfaccia. Per un'interfaccia puoi chiamare " Trova usi avanzati " di nuovo, basta fare clic destro) dove trovare tutte le estensioni e 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 sua dichiarazione.

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

---

In Resharper 9.2, su qualsiasi tipo di codice sorgente, fai clic con il tasto destro del mouse " Trova utilizzo avanzato " ;, seleziona Trova = " Derivato " e Scope = " 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 fai clic con il pulsante destro del mouse sul nome della classe di base che hai appena digitato.

Answer 2

Per VS2012,

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

Answer 3

Per questo non hai necessariamente bisogno di Reflector - Diagramma di classe " di Visual Studio " view 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 " Class View " 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 lo abbiano.

Answer 4

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:

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

//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();

Answer 5

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.

Answer 6

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. Seleziona 'Apri da GAC ??...' e aggiungi il gruppo System.Web.MVC
3. Seleziona 'Naviga / Vai a digitare' e digita ActionResult
4. Nella dichiarazione di classe ActionResult , fai clic con il pulsante destro del mouse e seleziona "Simboli derivati"
5. Voila! Viene mostrata ogni singola classe derivata (anche alcune che non conoscevo!)

Answer 7

Supponendo che Resharper installato: con il cursore sulla classe / interfaccia, fare clic con il tasto destro - Ispeziona - gerarchie

Mostra sottoclassi, implementazioni e superclassi.

Answer 8

Puoi anche utilizzare Reflector .

Carica tutti gli assembly in cui vuoi che guardi, passa a un tipo ed espandi 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)

Answer 9

In Visual Studio Class View vai alla classe che ti interessa e trova la sua base e le classi derivate

Answer 10

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, tuttavia.

Answer 11

Con l'aiuto di ReSharper (versione 2016.1.2) solo Ctrl + Alt + Fai clic su nella Classe base. Vedrai qualcosa del genere:

Answer 12

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

Come ottenere una bella diagramma delle classi per le classi .net integrate?

Answer 13

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

Answer 14

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

Answer 15

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

Answer 16

Per Visual Studio 2012 ( Senza ReSharper )

1. In Esplora soluzioni fare clic con il tasto 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".

Answer 17

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

Answer 18

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