Visual Studio: Comment afficher toutes les classes héritées d'une classe de base?

pour VS2012,

1. Naviguer vers le fichier dans l'explorateur de solutions
2. élargissez et sélectionnez votre classe
3. clic droit sur l'élément de classe (pas l'élément de fichier) -> types dérivés

vous n'avez pas nécessairement besoin de réflecteur pour cela - le" diagramme de classe " de Visual Studio vous permettra de trouver facilement toutes les classes dérivées pour une classe particulière aussi bien. Cliquez avec le bouton droit de la souris sur la classe dans "Vue de classe" et choisissez "Voir le diagramme de classe". Si le diagramme n'indique pas le niveau de détail que vous voulez pour la hiérarchie, faites un clic droit sur la case pour la classe dans le diagramme, et choisissez "Afficher les Classes dérivées".

N'est peut-être pas aussi direct que Resharper, mais c'est une option si vous n'avez pas R# déjà.

malheureusement, je ne suis pas certain quelles versions particulières de Visual Studio l'ont.

C'est le moins paresseux réponse (je suis juste fier de cette réponse :)

Je n'ai pas ReSharper, Je l'ai essayé avant mais je ne voulais pas l'acheter. J'ai essayé un diagramme de classe mais n'est pas pratique du tout parce que le diagramme de la hiérarchie traverse le Monde 3 fois plus et l'écran de mon ordinateur portable n'a pas la largeur infinie. Donc ma solution naturelle et facile était d'écrire du code de formes Windows pour itérer sur les types dans un assemblage et utiliser la réflexion pour ajouter noeuds à une vue d'arbre, comme suit:

veuillez supposer que vous avez une zone de texte, une vue d'arbre et d'autres choses nécessaires sur un formulaire dans lequel ce code s'exécute

//go through all the types and add them to a tree node or add a tree node or more to them as they might be parents or children of a class. if neither 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();

personne ne l'a encore mentionné, donc je vais l'ajouter.

Jetbrains dotPeek est un free.net decompiler a le pouvoir de montrer cette information facilement.

téléchargement gratuit: http://www.jetbrains.com/decompiler /

Jetbrains est la société qui fabrique Resharper.

étapes pour trouver les classes dérivées:

1. démarrage dotPeek
2. sélectionnez " Ouvrir à partir de GAC..."et d'ajouter" le Système de.Web.MVC assembly
3. sélectionnez "naviguer / aller au type" et tapez ActionResult
4. sur la déclaration de classe ActionResult , faites un clic droit et sélectionnez "symboles dérivés "
5. voilà! Chaque classe dérivée est représentée (même quelques - unes que je ne connaissais pas!)

en supposant que vous avez Resharper installé: avec curseur sur la classe/interface, clic droit-inspecter-hiérarchies

indique les sous-classes, les implémentations et les superclasses.

à partir de" mise à jour 1 de Visual Studio 2015", il vous suffit de cliquer avec le bouton droit de la souris sur le nom d'une classe dans l'éditeur de codes de classe, puis de sélectionner "passer à la mise en œuvre" dans le menu contextuel : Ctrl + F12 étant le raccourci.

voir https://blogs.msdn.microsoft.com/dotnet/2015/11/30/whats-new-in-visual-studio-update-1-for-net-managed-languages / pour plus de détails.

pour les classes Framework, j'utilise la bibliothèque MSDN. La section sur la hiérarchie des héritages va dans les deux sens. Certes pas beaucoup d'aide pour certaines bibliothèques de partie 3d, bien que.

vous pouvez également utiliser réflecteur .

chargez tous les assemblages que vous voulez qu'il Regarder, naviguer vers un type, et étendre l'élément types dérivés.

vous pouvez également le faire dans le navigateur D'objet, mais pour une raison quelconque, VS2008 ne peut le faire que dans l'une des vues .net Framework. (VS2010 Bêta 2 peut le faire dans n'importe quelle vue)

Avec l'aide de ReSharper (version 2016.1.2) Ctrl + Alt + , Cliquez sur sur la Classe de Base. Vous verrez quelque chose comme ceci:

Glisser de la classe ou de l'espace de de l'Explorateur d'Objets à Classe Digramme "151920920 de fichier".