Visual Studio: Como mostro todas as classes herdadas de uma classe base?

No Visual Studio, como mostro todas as classes herdadas de uma classe base?

Por exemplo , no ASP.NET MVC, existem vários tipos de ' ActionResult ' - e todos eles herdam / implementam a classe base ActionResult.

Parece que, a menos que você "saiba" isso Viewe Jsonsão ActionResulttipos válidos , não há como descobrir facilmente essas informações.

Por favor, prove que estou errado.

Existe algo no navegador de objetos que facilita a descoberta?

Estou pronto para sugestões de ferramentas fora do Visual Studio para descobrir essas informações sobre várias classes. Por exemplo: existe algo no Resharper que me ajudará?

Claro, o Resharper pode fazer isso. E muito mais.

Apenas clique com o botão direito do mouse no nome do tipo em qualquer lugar e escolha "Ir para o herdador" no menu de contexto. "Go To Inheritor" também pode ser aplicado ao método de navegação para substituições e às implementações de um método de interface. Para uma interface, você pode chamar "Encontrar usos avançados" novamente, apenas clicar com o botão direito do mouse) onde encontrar todas as extensões e implementações. Para um tipo derivado de tipo. E meu recurso favorito - clique mantendo pressionada a tecla Control em qualquer tipo / método para navegar até sua declaração.

Eu acho que é uma ferramenta indispensável para desenvolvedores .net.

No Resharper 9.2, em qualquer tipo de código-fonte, clique com a tecla rt em "Localizar Uso Avançado", selecione Localizar = "Derivado" e Escopo = "Soluções e Bibliotecas".
Por exemplo, para localizar todos os herdeiros (na biblioteca e no seu código) de alguma classe base em uma DLL incluída de qualquer fornecedor, declare uma variável no seu código com essa classe base. Em seguida, clique com o botão direito do mouse no nome da classe base que você acabou de digitar.

Para o VS2012,

1. Navegue para o arquivo no Solution Explorer
2. Expanda e selecione sua turma
3. Clique com o botão direito do mouse no item da classe (não no item do arquivo) -> Tipos Derivados

Você não precisa necessariamente do Reflector para isso - a exibição "Diagrama de classe" do Visual Studio também permitirá que você encontre facilmente todas as classes derivadas de uma classe específica. Clique com o botão direito do mouse na turma em "Class View" e escolha "View Class Diagram". Se o diagrama não mostrar o nível de detalhe que você deseja para a hierarquia, clique com o botão direito do mouse na caixa da classe no diagrama e escolha "Mostrar Classes Derivadas".

Pode não ser tão direto quanto o Resharper, mas é uma opção se você ainda não possui o R #.

Infelizmente, não tenho certeza de quais versões específicas do Visual Studio o possuem.

Esta é a resposta menos preguiçosa (só me orgulho desta resposta :)

Não tenho ReSharper, tentei antes, mas não queria comprá-lo. Eu tentei um diagrama de classes, mas não é prático, porque o diagrama da hierarquia abrange o mundo três vezes e a tela do meu laptop não tem largura infinita. Portanto, minha solução natural e fácil foi escrever um código do Windows Forms para iterar os tipos em uma montagem e usar a reflexão para adicionar nós a uma exibição em árvore, da seguinte maneira:

suponha que você tenha uma caixa de texto, uma exibição em árvore e outras coisas necessárias em um formulário no qual esse código é executado

//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 do 'Visual Studio 2015 Update 1', você pode simplesmente clicar com o botão direito do mouse no nome de uma classe no editor de código de classe e selecionar 'Ir para implementação "no menu de contexto: com Ctrl + F12 como atalho.

Consulte https://blogs.msdn.microsoft.com/dotnet/2015/11/30/whats-new-in-visual-studio-update-1-for-net-managed-languages/ para obter mais detalhes.

Ninguém mencionou isso ainda, então eu vou adicioná-lo.
O Jetbrains dotPeek é um descompilador .NET gratuito que pode mostrar essas informações facilmente.

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

Jetbrains é a empresa que fabrica o Resharper.

Etapas para encontrar classes derivadas:

1. Inicie o dotPeek
2. Selecione 'Abrir no GAC ...' e adicione o assembly System.Web.MVC
3. Selecione 'Navegar / Ir para digitar' e digite ActionResult
4. Na ActionResultdeclaração de classe, clique com o botão direito do mouse e selecione 'Símbolos derivados'
5. Voila! Cada classe derivada é exibida (mesmo algumas que eu não conhecia!)

Supondo que você tenha o Resharper instalado: com o cursor na classe / interface, clique com o botão direito do mouse - Inspecionar - Hierarquias

Isso mostra subclasses, implementações e superclasses.

No Visual Studio Class View, navegue para a classe que você está interessado e encontre suas classes base e derivada

Você também pode usar o Refletor .

Carregue todos os conjuntos que deseja que ele procure, navegue para um tipo e expanda o item Tipos Derivados.

Você também pode fazer isso no Pesquisador de objetos, mas por algum motivo o VS2008 pode fazê-lo apenas em uma das visualizações do .Net Framework. (O VS2010 Beta 2 pode fazê-lo em qualquer vista)

Para as classes do Framework, eu uso a Biblioteca MSDN. A seção Hierarquia de herança vai nas duas direções. É certo que não há muita ajuda para algumas bibliotecas de festas em 3D.

Com a ajuda do ReSharper (versão 2016.1.2), basta Ctrl+ Alt+ Clickna classe base. Você verá algo assim:

Arraste a classe ou espaço para nome do Object Explorer para o arquivo Digram da classe .

Como obter um bom diagrama de classes para classes .net internas?

selecione o tipo e clique com o botão direito do mouse para ver algo --- mostrar no mapa de código - opção selecione gerar o formato da imagem para aqueles que herdam esse tipo de imagem tão bonita quanto o formato de arquivo .dgml, fornece muito mais informações sobre o tipo

Como opção para aqueles que usam o Visual Assist, você também pode pressionar Shift + ALT + G (enquanto o cursor estiver no nome da classe) para abrir o menu de contexto "Ir para Relacionado" e, se houver classes derivadas, você obterá um submenu por isso, que lista todos eles e até mostra estruturas de herança entre essas classes derivadas.

Apenas codifique.

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 você atualizou para o VS2012, pode usar o "Mapa de Código".
Clique com o botão direito do mouse no tipo que você deseja visualizar na hierarquia de herança e escolha "Adicionar ao mapa de código". Em seguida, na visualização do mapa de código, você pode expandir os nós e clicar com o botão direito do mouse para escolher "Mostrar classes derivadas / base". Infelizmente, ele não funciona para as classes fornecidas pelo .NET.

Para Visual Studio 2012 ( sem ReSharper )

1. No Gerenciador de Soluções, clique com o botão direito do mouse na classe (cujas classes derivadas você deseja ver).
2. No diagrama de classes, clique com o botão direito do mouse na classe e selecione 'Mostrar classes derivadas'.

Atualização 2020:

Você pode usar o Code Maps do Visual Studio, que funciona muito bem.

Simplesmente clique direito sobre a classe e navegue até:
Code Map> Show Related Items on Code Map>Show All Derived Types

Nota:

• Esse recurso está disponível apenas na edição Enterprise do Visual Studio e, se você não tiver , poderá obtê-lo gratuitamente fazendo o download da versão Enterprise Preview aqui .
• Ou você pode simplesmente pedir a alguém da sua equipe que compartilhe o mapa de códigos com esse recurso se tiver essa edição.

PS: Vale a pena manter a versão Enterprise (ou pelo menos a versão Preview) em sua máquina, pois possui várias ferramentas realmente úteis que não estão incluídas nas outras edições.

Uma maneira muito simples de fazer isso é procurar : Classnamena "Localizar e Substituir Janela" (CTRL + F) e usar a opção "Encontrar Opções / Corresponder à Palavra Inteira". Você encontrará apenas as classes herdadas.