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

Dans Visual Studio, comment afficher toutes les classes héritées d'une classe de base?

Par exemple , dans ASP.NET MVC, il existe plusieurs types « ActionResult » - et ils héritent tous de / implémentent la classe de base ActionResult.

Il semble qu'à moins que vous ne le «sachiez» simplement Viewet que vous Jsonsoyez des ActionResulttypes valides , il n'y a aucun moyen de trouver facilement ces informations.

Veuillez me prouver le contraire.

Y a-t-il quelque chose dans le navigateur d'objets qui rend cela facile à découvrir?

Je suis même prêt à recevoir des suggestions d'outils en dehors de Visual Studio pour découvrir ces informations sur différentes classes. Par exemple: y a-t-il quelque chose dans Resharper qui m'aidera?

Bien sûr, Resharper peut le faire. Et beaucoup plus.

Faites un clic droit sur le nom du type à n'importe quel endroit et choisissez "Aller à l'héritier" dans le menu contextuel. "Go To Inheritor" peut également être appliqué à la méthode de navigation vers les remplacements et les implémentations d'une méthode d'interface. Pour une interface, vous pouvez appeler à nouveau "Find Usages Advanced", juste un clic droit) où trouver toutes les extensions et implémentations. Pour un type - types dérivés. Et ma fonctionnalité préférée - cliquez en maintenant la touche Contrôle sur n'importe quel type / méthode pour accéder à sa déclaration.

Je pense que c'est un outil indispensable pour les développeurs .net.

Dans Resharper 9.2, sur tout type de code source, rt-cliquez sur "Find Usage Advanced", sélectionnez Find = "Derived" et Scope = "Solutions and Libraries".
Par exemple, pour rechercher tous les héritiers (à la fois dans la bibliothèque et dans votre code) d'une classe de base dans une DLL incluse de n'importe quel fournisseur, déclarez une variable dans votre code avec cette classe de base. Cliquez ensuite avec le bouton droit sur ce nom de classe de base que vous venez de saisir.

Pour VS2012,

1. Accédez au fichier dans l'explorateur de solutions
2. Développez et sélectionnez votre classe
3. Cliquez avec le bouton 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 Reflector pour cela - la vue «Diagramme de classes» de Visual Studio vous permettra également de trouver facilement toutes les classes dérivées pour une classe particulière. Cliquez avec le bouton droit sur la classe dans "Vue de classe" et choisissez "Afficher le diagramme de classe". Si le diagramme n'indique pas le niveau de détail souhaité pour la hiérarchie, cliquez avec le bouton droit de la souris sur la case de la classe dans le diagramme et choisissez "Afficher les classes dérivées".

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

Malheureusement, je ne suis pas certain des versions particulières de Visual Studio.

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

Je n'ai pas ReSharper, je l'ai déjà essayé mais je ne voulais pas l'acheter. J'ai essayé un diagramme de classes mais ce n'est pas pratique du tout car le diagramme hiérarchique couvre le monde 3 fois et l'écran de mon ordinateur portable n'a pas une largeur infinie. Ma solution naturelle et simple a donc été d'écrire du code Windows Forms pour parcourir les types dans un assembly et d'utiliser la réflexion pour ajouter des nœuds à une arborescence, comme suit:

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

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

À partir de 'Visual Studio 2015 Update 1', vous pouvez simplement cliquer avec le bouton droit de la souris sur un nom de classe dans l'éditeur de code de classe, puis sélectionner 'Aller à l'implémentation' dans le menu contextuel: avec 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.

Personne ne l'a encore mentionné, alors je vais l'ajouter.
Jetbrains dotPeek est un décompilateur .NET gratuit qui a le pouvoir d'afficher ces informations facilement.

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

Jetbrains est la société qui fabrique Resharper.

Étapes pour trouver des classes dérivées:

1. Démarrez dotPeek
2. Sélectionnez 'Ouvrir à partir du GAC ...' et ajoutez l'assembly System.Web.MVC
3. Sélectionnez "Naviguer / Aller pour taper" et tapez ActionResult
4. Sur la ActionResultdéclaration de classe, cliquez avec le bouton droit de la souris et sélectionnez 'Symboles dérivés'
5. Voila! Chaque classe dérivée est affichée (même quelques-unes que je ne connaissais pas!)

En supposant que Resharper est installé: avec le curseur sur la classe / interface, faites un clic droit - Inspecter - Hiérarchies

Cela montre les sous-classes, les implémentations et les superclasses.

Dans Visual Studio Class View, accédez à la classe qui vous intéresse et trouvez sa base et ses classes dérivées

Vous pouvez également utiliser Reflector .

Chargez tous les assemblys dans lesquels vous souhaitez qu'il recherche, accédez à un type et développez l'élément Types dérivés.

Vous pouvez également le faire dans l'Explorateur d'objets, mais pour une raison quelconque, VS2008 ne peut le faire que dans l'une des vues .Net Framework. (VS2010 Beta 2 peut le faire dans n'importe quelle vue)

Pour les classes Framework, j'utilise la bibliothèque MSDN. La section Hiérarchie d'héritage va dans les deux sens. Certes, cela n'aide pas beaucoup pour certaines bibliothèques 3D Party.

Avec l'aide de ReSharper (version 2016.1.2) juste Ctrl+ Alt+ Clicksur la classe de base. Vous verrez quelque chose comme ceci:

Faites glisser la classe ou l'espace de noms de l' Explorateur d'objets vers le fichier Class Digram .

Comment obtenir un joli diagramme de classes pour les classes .net intégrées?

sélectionnez le type et faites un clic droit voir quelque chose --- afficher sur la carte de code --option sélectionnez-le générer le format d'image pour ceux qui héritent de ce type comme très belle image au format de fichier .dgml cela donne beaucoup plus d'informations sur le type

En tant qu'option pour ceux qui utilisent Visual Assist, vous pouvez également appuyer sur Maj + ALT + G (pendant que le curseur est sur le nom de la classe) pour faire apparaître le menu contextuel "Aller à Associé", et s'il existe des classes dérivées, vous obtiendrez un sous-menu pour cela, cela les répertorie tous et montre même les structures d'héritage parmi ces classes dérivées.

Codez-le simplement.

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 vous avez mis à niveau vers VS2012, vous pouvez utiliser le "Code Map".
Cliquez avec le bouton droit de la souris sur le type dont vous souhaitez afficher la hiérarchie d'héritage et choisissez "Ajouter à la carte de code". Ensuite, dans la vue de la carte de code, vous pouvez développer les nœuds et faire un clic droit pour choisir "Afficher les classes dérivées / de base". Malheureusement, cela ne fonctionne pas pour les classes fournies par .NET.

Pour Visual Studio 2012 ( sans ReSharper )

1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur la classe (dont vous voulez voir les classes dérivées).
2. Dans le diagramme de classes, faites un clic droit sur la classe et sélectionnez «Afficher les classes dérivées».

Mise à jour 2020:

Vous pouvez utiliser les cartes de code de Visual Studio qui fonctionnent assez bien.

Il suffit de faire un clic droit sur la classe et à naviguer:
Code Map> Show Related Items on Code Map>Show All Derived Types

Remarque:

• Cette fonctionnalité est disponible uniquement sur l'édition Entreprise de Visual Studio, et si vous ne l' avez pas , vous pouvez l'obtenir gratuitement en téléchargeant la version Enterprise Preview à partir d' ici .
• Ou vous pouvez simplement demander à n'importe qui de votre équipe de partager la carte de code avec cette fonctionnalité s'ils ont cette édition.

PS Cela vaut vraiment la peine de conserver la version Enterprise (ou du moins la version Preview de celle-ci) sur votre machine, car elle dispose d'un tas d' outils vraiment utiles qui ne sont pas inclus dans les autres éditions.

Une manière très simple de le faire est de rechercher : Classnamedans la fenêtre «Rechercher et remplacer» (CTRL + F) et d'utiliser l'option «Rechercher les options / Faire correspondre le mot entier». Vous ne trouverez que les classes héritées.