.NET Types Explorer

Fornece informações detalhadas de tipos de projetos .NET, incluindo exploração de assemblies, reflexão de tipos e integração com NuGet para agentes de codificação de IA.

GitHub

Experimente este MCPPatrocinado

Documentação

.NET Types Explorer MCP Server

Um servidor Model Context Protocol (MCP) que fornece informações detalhadas de tipos de projetos .NET para agentes de codificação de IA.

Visão Geral

O servidor .NET Types Explorer MCP é uma ferramenta poderosa projetada para ajudar agentes de codificação de IA a entender e trabalhar com codebases .NET. Ele fornece uma maneira estruturada de explorar assemblies, namespaces e tipos em projetos .NET, facilitando para agentes de IA gerar sugestões de código precisas e sensíveis ao contexto.

O servidor usa reflexão para extrair informações detalhadas de tipos de assemblies .NET compilados, incluindo classes, interfaces, métodos, propriedades, campos e eventos. Essas informações são então disponibilizadas por meio de um conjunto de ferramentas que podem ser usadas por agentes de IA para explorar o codebase de forma sistemática.

Contribuindo

Contribuições são bem-vindas! Sinta-se à vontade para enviar um Pull Request.

Recursos

Exploração de Assemblies: Recupera uma lista de todos os assemblies referenciados por um projeto .NET
Exploração de Namespaces: Descobre todos os namespaces dentro de assemblies especificados
Exploração de Tipos: Obtém informações detalhadas sobre tipos dentro de namespaces especificados, incluindo:
- Nomes completos de tipos com parâmetros genéricos
  - Interfaces implementadas
  - Construtores com parâmetros
  - Métodos com tipos de retorno e parâmetros
  - Propriedades com tipos e acessadores
  - Campos com tipos e modificadores
  - Eventos com tipos de manipulador
Pesquisa de Pacotes NuGet: Pesquisa pacotes NuGet em nuget.org com filtragem e paginação
Informações de Versão de Pacotes NuGet: Recupera histórico de versões e informações de dependência para pacotes NuGet específicos
Resolução de Assemblies Configurável: Resolve assemblies a partir da saída de build, cache global de pacotes NuGet (somente restauração, sem necessidade de build) ou tenta automaticamente ambos
Filtragem: Aplica filtros curinga para restringir os resultados
Paginação: Lida com grandes conjuntos de resultados com paginação integrada

Roadmap

Adicionar integração NuGet para fornecer informações sobre versões reais de pacotes
Migrar para o SDK oficial do Model Context Protocol em C# (modelcontextprotocol/csharp-sdk)
Suporte a múltiplas fontes de pacotes NuGet (feeds personalizados/privados)
Adicionar recursos de construção de grafo de dependências
Melhorar o cenário de múltiplos projetos

Pré-requisitos

SDK .NET 10.0 ou posterior
Um projeto .NET que você deseja explorar

Configuração

Fontes de Pacotes NuGet

O servidor suporta consultar múltiplas fontes de pacotes NuGet simultaneamente. Configure fontes personalizadas em appsettings.json:

{
  "Tools": {
    "DefaultPageSize": 20,
    "IntendResponse": false,
    "NuGetSources": [
      {
        "Name": "nuget.org",
        "Url": "https://api.nuget.org/v3/index.json",
        "Enabled": true
      },
      {
        "Name": "MyPrivateFeed",
        "Url": "https://my-company.com/nuget/v3/index.json",
        "Enabled": true
      },
      {
        "Name": "dotnet-core (MyGet)",
        "Url": "https://dotnet.myget.org/F/dotnet-core/api/v3/index.json",
        "Enabled": true,
        "Comment": "Example: MyGet public feed for .NET Core preview packages"
      }
    ]
  }
}

Opções de Configuração:

Nome: Nome amigável para a fonte de pacotes
Url: URL completa para o endpoint da API v3 do NuGet (deve terminar com /v3/index.json)
Habilitado: Defina como false para desabilitar temporariamente uma fonte sem removê-la

Comportamento:

Todas as fontes habilitadas são consultadas em paralelo para melhor desempenho
Os resultados são automaticamente deduplicados por ID e versão do pacote
Se uma fonte falhar, o servidor continua com as fontes restantes
Comportamento padrão da fonte: nuget.org é adicionado SOMENTE se nenhuma fonte estiver configurada em appsettings.json

Prioridade de Fontes e Deduplicação:

Quando o mesmo pacote é encontrado em múltiplas fontes, o servidor usa uma estratégia baseada em prioridade:

A prioridade é determinada pela ordem: Fontes listadas primeiro na configuração têm maior prioridade
Resultados determinísticos: A primeira fonte na lista sempre tem precedência para pacotes duplicados
Consultas paralelas: Apesar da execução paralela, os resultados são processados em ordem de prioridade
Consistência de metadados: Os metadados do pacote (descrição, contagem de downloads, etc.) sempre vêm da fonte de maior prioridade que contém esse pacote

Exemplo:

{
  "NuGetSources": [
    { "Name": "Internal", "Url": "https://internal.company.com/nuget/v3/index.json", "Enabled": true },
    { "Name": "nuget.org", "Url": "https://api.nuget.org/v3/index.json", "Enabled": true }
  ]
}

Nesta configuração, se um pacote existir em ambas as fontes, as informações de "Internal" serão usadas.

Modo de Resolução de Assemblies

O servidor suporta diferentes estratégias para localizar assemblies de pacotes. Configure isso em appsettings.json:

{
  "Tools": {
    "AssemblyResolutionMode": "NuGetCache"
  }
}

Modo	Comportamento
`BuildOutput`	Padrão. Resolve assemblies do diretório de saída de build (ex.: `bin/Debug/net10.0/`). Requer um build completo.
`NuGetCache`	Resolve assemblies diretamente do cache global de pacotes NuGet. Requer apenas `dotnet restore`, sem necessidade de build. Tipos de projeto são ignorados de forma graciosa.
`Auto`	Tenta a saída de build primeiro, recorrendo ao cache NuGet se o assembly não for encontrado na saída de build.

O modo NuGetCache é particularmente útil quando você precisa principalmente explorar APIs de pacotes de terceiros sem esperar por um ciclo completo de build. O caminho da pasta de pacotes globais é lido de project.assets.json automaticamente.

Instalação

Opção 1: Instalação Nativa

Clone o repositório
Compile o projeto:
```
dotnet build -c Release
```
Publique o projeto:
```
dotnet publish -c Release -r <runtime-identifier> --self-contained false
```
Substitua <runtime-identifier> pela sua plataforma de destino (ex.: win-x64, linux-x64, osx-x64).

Opção 2: Docker

O servidor está disponível como um contêiner Docker, proporcionando melhor isolamento e implantação mais fácil:

Baixe a imagem do Docker Hub:

docker pull vrogozhin/dotnet-types-explorer-mcp:latest

Ou compile localmente:

git clone https://github.com/V0v1kkk/DotNetMetadataMcpServer.git
cd DotNetMetadataMcpServer
docker build -t dotnet-types-explorer-mcp .

Execute o contêiner:

docker run --rm -i \
  -v /path/to/your/dotnet/projects:/workspace \
  vrogozhin/dotnet-types-explorer-mcp:latest

Benefícios da implantação com Docker:

Não é necessário instalar o SDK .NET na sua máquina
Ambiente isolado previne conflitos
Comportamento consistente em diferentes sistemas operacionais
Inclui MSBuild e todas as dependências necessárias
Atualizações fáceis ao baixar a imagem mais recente

Configuração

Configuração Nativa

Para usar o servidor .NET Types Explorer MCP com um agente de IA, você precisa configurá-lo no seu arquivo de configurações MCP. Aqui está um exemplo de configuração:

{
  "mcpServers": {
    "dotnet-types-explorer": {
      "command": "/path/to/DotNetMetadataMcpServer",
      "args": [ "--homeEnvVariable", "/home/user" ],
      "disabled": false,
      "alwaysAllow": [],
      "timeout": 300
    }
  }
}

Substitua /path/to/DotNetMetadataMcpServer pelo caminho real para o executável publicado e /home/user pelo seu diretório pessoal.

Configuração Docker

Para implantação com Docker, configure seu cliente MCP da seguinte forma:

{
  "mcpServers": {
    "dotnet-types-explorer": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-v",
        "/path/to/your/dotnet/projects:/workspace",
        "vrogozhin/dotnet-types-explorer-mcp:latest"
      ],
      "disabled": false,
      "alwaysAllow": [],
      "timeout": 300
    }
  }
}

Substitua /path/to/your/dotnet/projects pelo diretório que contém seus projetos .NET. O contêiner terá acesso a todos os projetos neste diretório.

Limitações Importantes

O requisito de build depende do modo de resolução. No modo BuildOutput (padrão), o projeto deve ser compilado antes da varredura. No modo NuGetCache, apenas dotnet restore é necessário — o servidor resolve assemblies de pacotes diretamente do cache global de pacotes NuGet. Tipos específicos do projeto só estão disponíveis quando o projeto foi compilado.
A ferramenta não segue referências para outros projetos. Ela apenas inspeciona o projeto especificado e suas dependências NuGet. Se você precisar analisar múltiplos projetos, precisará escanear cada um separadamente.

Como as saídas do projeto são localizadas

Ao escanear um projeto, o servidor precisa do caminho do assembly compilado. MsBuildHelper avalia o projeto e tenta localizar o assembly de saída testando configurações nesta ordem:

a configuração solicitada (por padrão Debug), depois
Release e, se ainda não for encontrado,
volta a verificar Debug novamente como padrão seguro.

A primeira saída existente vence. Se nenhuma saída for encontrada, um caminho padrão razoável é assumido e um aviso é registrado. Isso faz com que execuções locais (geralmente Debug) e execuções de CI (geralmente Release) se comportem de forma consistente. Certifique-se de compilar o projeto em uma dessas configurações antes de escanear.

Uso

O servidor fornece cinco ferramentas principais que podem ser usadas por agentes de IA:

ReferencedAssembliesExplorer: Recupera assemblies referenciados de um projeto .NET
NamespacesExplorer: Recupera namespaces de assemblies especificados
NamespaceTypes: Recupera tipos de namespaces especificados
NuGetPackageSearch: Pesquisa pacotes NuGet em nuget.org com filtragem e paginação
NuGetPackageVersions: Recupera histórico de versões e informações de dependência para pacotes NuGet específicos

Esta ferramenta foi testada com a extensão Roo Code para Visual Studio, um assistente de codificação de IA que suporta o Model Context Protocol. Você pode encontrar mais informações sobre o Roo Code no GitHub.

É possível usar o arquivo .clinerules para instruir seu assistente de codificação a usar o servidor MCP.

Instruções para Assistentes de Codificação de IA

Se você trabalha com projetos .NET que têm referências a pacotes NuGet e precisa escrever código usando esses pacotes, você deve explorar a API desses pacotes sistematicamente usando o servidor MCP Dotnet Type Explorer. Isso é especialmente importante quando você não está familiarizado com a API do pacote ou quando a documentação é limitada.

Ao trabalhar com um projeto .NET:

Primeiro, certifique-se de que o projeto está compilado. Esta ferramenta depende de assemblies compilados para extrair informações de tipos.
Comece recuperando todos os assemblies referenciados pelo arquivo do projeto usando a ferramenta ReferencedAssembliesExplorer. Isso fornece uma lista de todos os assemblies disponíveis.
Concentre-se em bibliotecas de terceiros e pacotes NuGet, não nos tipos da Base Class Library (BCL) como System.* ou Microsoft.* que são bem documentados em outros lugares.
Depois de identificar os assemblies relevantes, use a ferramenta NamespacesExplorer para descobrir os namespaces dentro desses assemblies. Isso ajuda a entender como a biblioteca está organizada.
Após identificar os namespaces relevantes, use a ferramenta NamespaceTypes para recuperar informações detalhadas sobre os tipos dentro dos namespaces de seu interesse. Isso inclui métodos, propriedades, campos, eventos e mais.
Use filtragem apenas quando estiver sobrecarregado pela quantidade de dados ou quando souber exatamente o que está procurando.
Se precisar encontrar pacotes NuGet específicos ou explorar suas versões e dependências, use a ferramenta NuGetPackageSearch para pesquisar pacotes por nome ou palavras-chave.
Quando precisar de informações detalhadas sobre um pacote NuGet específico, incluindo seu histórico de versões e dependências, use a ferramenta NuGetPackageVersions. Isso é particularmente útil quando você precisa entender requisitos de compatibilidade ou cadeias de dependência.
Use os recursos de filtragem das ferramentas NuGet para restringir resultados ao pesquisar versões específicas ou pacotes com padrões de nomenclatura particulares.

Lembre-se de que esta ferramenta apenas inspeciona o projeto especificado e suas dependências NuGet. Ela não segue referências para outros projetos na solução. Se você precisar analisar múltiplos projetos, precisará escanear cada um separadamente.

Essa abordagem de cima para baixo (assemblies → namespaces → tipos) é a maneira mais eficiente de explorar e entender bibliotecas .NET quando você precisa escrever código que as utiliza. É particularmente valiosa para bibliotecas de terceiros onde a API pode não ser imediatamente óbvia ou bem documentada. As ferramentas NuGet complementam essa abordagem fornecendo acesso direto às informações dos pacotes sem exigir que os pacotes já estejam referenciados no projeto.

Como Funciona

O servidor usa o seguinte processo para extrair informações de tipos:

Avaliação do Projeto: Usa MSBuild para avaliar o arquivo do projeto e encontrar o assembly compilado
Carregamento de Assemblies: Carrega o assembly compilado e suas dependências
Reflexão de Tipos: Usa reflexão para extrair informações detalhadas sobre tipos
Filtragem e Paginação: Aplica filtros e paginação aos resultados
Formatação da Resposta: Formata os resultados como JSON e os retorna ao cliente

Referência da API

ReferencedAssembliesExplorer

Recupera assemblies referenciados com base em filtros e paginação.

Esquema de Entrada:

{
  "type": "object",
  "properties": {
    "ProjectFileAbsolutePath": {
      "type": "string"
    },
    "PageNumber": {
      "type": "integer"
    },
    "FullTextFiltersWithWildCardSupport": {
      "type": "array",
      "items": {
        "type": [
          "string",
          "null"
        ]
      }
    }
  },
  "required": [
    "ProjectFileAbsolutePath"
  ]
}

Resposta:

{
  "AssemblyNames": ["Assembly1", "Assembly2", ...],
  "CurrentPage": 1,
  "AvailablePages": [1, 2, ...]
}

NamespacesExplorer

Recupera namespaces de assemblies especificados com suporte a filtros e paginação.

Esquema de Entrada:

{
  "type": "object",
  "properties": {
    "ProjectFileAbsolutePath": {
      "type": "string"
    },
    "AssemblyNames": {
      "type": "array",
      "items": {
        "type": [
          "string",
          "null"
        ]
      }
    },
    "PageNumber": {
      "type": "integer"
    },
    "FullTextFiltersWithWildCardSupport": {
      "type": "array",
      "items": {
        "type": [
          "string",
          "null"
        ]
      }
    }
  },
  "required": [
    "ProjectFileAbsolutePath"
  ]
}

Resposta:

{
  "Namespaces": ["Namespace1", "Namespace2", ...],
  "CurrentPage": 1,
  "AvailablePages": [1, 2, ...]
}

NamespaceTypes

Recupera tipos de namespaces especificados com suporte a filtros e paginação.

Esquema de Entrada:

{
  "type": "object",
  "properties": {
    "ProjectFileAbsolutePath": {
      "type": "string"
    },
    "Namespaces": {
      "type": "array",
      "items": {
        "type": [
          "string",
          "null"
        ]
      }
    },
    "PageNumber": {
      "type": "integer"
    },
    "FullTextFiltersWithWildCardSupport": {
      "type": "array",
      "items": {
        "type": [
          "string",
          "null"
        ]
      }
    }
  },
  "required": [
    "ProjectFileAbsolutePath"
  ]
}

Resposta:

{
  "TypeData": [
    {
      "FullName": "Namespace.TypeName",
      "Implements": ["Interface1", "Interface2", ...],
      "Constructors": ["(param1, param2)", ...],
      "Methods": ["ReturnType MethodName(param1, param2)", ...],
      "Properties": ["PropertyType PropertyName { get; set; }", ...],
      "Fields": ["FieldType FieldName", ...],
      "Events": ["event EventHandlerType EventName", ...]
    },
    ...
  ],
  "CurrentPage": 1,
  "AvailablePages": [1, 2, ...]
}

NuGetPackageSearch

Pesquisa pacotes NuGet em nuget.org com suporte a filtragem e paginação.

Esquema de Entrada:

{
  "type": "object",
  "properties": {
    "SearchQuery": {
      "type": "string"
    },
    "IncludePrerelease": {
      "type": "boolean"
    },
    "PageNumber": {
      "type": "integer"
    },
    "FullTextFiltersWithWildCardSupport": {
      "type": "array",
      "items": {
        "type": [
          "string",
          "null"
        ]
      }
    }
  },
  "required": [
    "SearchQuery"
  ]
}

Resposta:

{
  "Packages": [
    {
      "Id": "Newtonsoft.Json",
      "Version": "13.0.3",
      "Description": "Json.NET is a popular high-performance JSON framework for .NET",
      "Authors": "James Newton-King",
      "DownloadCount": 1000000,
      "Published": "2023-03-08T00:00:00Z"
    },
    ...
  ],
  "CurrentPage": 1,
  "AvailablePages": [1, 2, ...]
}

NuGetPackageVersions

Recupera o histórico de versões e informações de dependência para um pacote NuGet específico.

Esquema de Entrada:

{
  "type": "object",
  "properties": {
    "PackageId": {
      "type": "string"
    },
    "IncludePrerelease": {
      "type": "boolean"
    },
    "PageNumber": {
      "type": "integer"
    },
    "FullTextFiltersWithWildCardSupport": {
      "type": "array",
      "items": {
        "type": [
          "string",
          "null"
        ]
      }
    }
  },
  "required": [
    "PackageId"
  ]
}

Resposta:

{
  "PackageId": "Newtonsoft.Json",
  "Versions": [
    {
      "Id": "Newtonsoft.Json",
      "Version": "13.0.3",
      "Description": "Json.NET is a popular high-performance JSON framework for .NET",
      "Authors": "James Newton-King",
      "DownloadCount": 1000000,
      "Published": "2023-03-08T00:00:00Z",
      "DependencyGroups": [
        {
          "TargetFramework": ".NETStandard2.0",
          "Dependencies": [
            {
              "Id": "System.Text.Json",
              "VersionRange": "6.0.0"
            }
          ]
        }
      ]
    },
    ...
  ],
  "CurrentPage": 1,
  "AvailablePages": [1, 2, ...]
}

Cenário de Exemplo de Uso

Aqui está um exemplo de como um agente de IA pode usar o servidor MCP .NET Types Explorer para explorar uma API de framework de UI:

Recuperar Assemblies com Filtragem:

{
  "ProjectFileAbsolutePath": "/home/user/Projects/MyApp/MyApp.csproj",
  "PageNumber": 1,
  "FullTextFiltersWithWildCardSupport": ["Avalonia*"]
}

Resposta:

{
  "AssemblyNames": [
    "Avalonia",
    "Avalonia.Controls.ColorPicker",
    "Avalonia.Controls.DataGrid",
    "Avalonia.Desktop",
    "Avalonia.Diagnostics",
    "Avalonia.Fonts.Inter",
    "Avalonia.FreeDesktop",
    "Avalonia.Native",
    "Avalonia.ReactiveUI",
    "Avalonia.Remote.Protocol"
  ],
  "CurrentPage": 1,
  "AvailablePages": [1, 2]
}

Recuperar Namespaces com Filtragem Direcionada:

{
  "ProjectFileAbsolutePath": "/home/user/Projects/MyApp/MyApp.csproj",
  "AssemblyNames": ["Avalonia"],
  "PageNumber": 1,
  "FullTextFiltersWithWildCardSupport": ["*Media*", "*Image*"]
}

Resposta:

{
  "Namespaces": [
    "Avalonia.Media",
    "Avalonia.Media.Transformation",
    "Avalonia.Media.TextFormatting",
    "Avalonia.Media.TextFormatting.Unicode",
    "Avalonia.Media.Immutable",
    "Avalonia.Media.Imaging",
    "Avalonia.Media.Fonts"
  ],
  "CurrentPage": 1,
  "AvailablePages": [1]
}

Recuperar Tipos de um Namespace Específico:

{
  "ProjectFileAbsolutePath": "/home/user/Projects/MyApp/MyApp.csproj",
  "Namespaces": ["Avalonia.Media.Imaging"],
  "PageNumber": 1,
  "FullTextFiltersWithWildCardSupport": []
}

Resposta (parcial):

{
  "TypeData": [
    {
      "FullName": "Avalonia.Media.Imaging.Bitmap",
      "Implements": [
        "IBitmap",
        "IImage",
        "IDisposable",
        "IImageBrushSource"
      ],
      "Constructors": [
        "(String fileName)",
        "(Stream stream)",
        "(PixelFormat format, AlphaFormat alphaFormat, IntPtr data, PixelSize size, Vector dpi, Int32 stride)"
      ],
      "Methods": [
        "static Avalonia.Media.Imaging.Bitmap DecodeToWidth(System.IO.Stream stream, System.Int32 width, Avalonia.Media.Imaging.BitmapInterpolationMode? interpolationMode = null)",
        "static Avalonia.Media.Imaging.Bitmap DecodeToHeight(System.IO.Stream stream, System.Int32 height, Avalonia.Media.Imaging.BitmapInterpolationMode? interpolationMode = null)",
        "Avalonia.Media.Imaging.Bitmap CreateScaledBitmap(Avalonia.PixelSize destinationSize, Avalonia.Media.Imaging.BitmapInterpolationMode? interpolationMode = null)",
        "virtual System.Void Dispose()"
      ],
      "Properties": [
        "virtual Avalonia.Vector Dpi { get; }",
        "virtual Avalonia.Size Size { get; }",
        "virtual Avalonia.PixelSize PixelSize { get; }"
      ]
    }
  ],
  "CurrentPage": 1,
  "AvailablePages": [1, 2]
}

Aplicar Filtros Específicos para Encontrar Tipos Relacionados:

{
  "ProjectFileAbsolutePath": "/home/user/Projects/MyApp/MyApp.csproj",
  "Namespaces": ["Avalonia.Platform"],
  "PageNumber": 1,
  "FullTextFiltersWithWildCardSupport": ["*Framebuffer*", "*Pixel*"]
}

Resposta:

{
  "TypeData": [
    {
      "FullName": "Avalonia.Platform.ILockedFramebuffer",
      "Implements": ["IDisposable"],
      "Methods": [
        "abstract System.IntPtr get_Address()",
        "abstract Avalonia.PixelSize get_Size()",
        "abstract System.Int32 get_RowBytes()",
        "abstract Avalonia.Vector get_Dpi()",
        "abstract Avalonia.Platform.PixelFormat get_Format()"
      ],
      "Properties": [
        "abstract System.IntPtr Address { get; }",
        "abstract Avalonia.PixelSize Size { get; }",
        "abstract System.Int32 RowBytes { get; }",
        "abstract Avalonia.Vector Dpi { get; }",
        "abstract Avalonia.Platform.PixelFormat Format { get; }"
      ]
    }
  ],
  "CurrentPage": 1,
  "AvailablePages": [1]
}

Exemplos de Pacotes NuGet

Aqui estão exemplos de como um agente de IA pode usar as ferramentas NuGet para explorar informações de pacotes:

Pesquisar Pacotes NuGet:

{
  "SearchQuery": "EntityFrameworkCore",
  "IncludePrerelease": false,
  "PageNumber": 1,
  "FullTextFiltersWithWildCardSupport": []
}

Resposta:

{
  "Packages": [
    {
      "Id": "Microsoft.EntityFrameworkCore",
      "Version": "7.0.0",
      "Description": "Entity Framework Core is a lightweight and extensible version of the popular Entity Framework data access technology.",
      "Authors": "Microsoft",
      "DownloadCount": 42000000,
      "Published": "2022-11-08T00:00:00Z"
    },
    {
      "Id": "Microsoft.EntityFrameworkCore.SqlServer",
      "Version": "7.0.0",
      "Description": "Microsoft SQL Server database provider for Entity Framework Core.",
      "Authors": "Microsoft",
      "DownloadCount": 38000000,
      "Published": "2022-11-08T00:00:00Z"
    }
  ],
  "CurrentPage": 1,
  "AvailablePages": [1, 2, 3, 4, 5]
}

Pesquisar com Filtragem:

{
  "SearchQuery": "Json",
  "IncludePrerelease": false,
  "PageNumber": 1,
  "FullTextFiltersWithWildCardSupport": ["Newtonsoft*"]
}

Resposta:

{
  "Packages": [
    {
      "Id": "Newtonsoft.Json",
      "Version": "13.0.3",
      "Description": "Json.NET is a popular high-performance JSON framework for .NET",
      "Authors": "James Newton-King",
      "DownloadCount": 1250000000,
      "Published": "2023-03-08T00:00:00Z"
    },
    {
      "Id": "Newtonsoft.Json.Bson",
      "Version": "1.0.2",
      "Description": "Json.NET BSON adds support for reading and writing BSON",
      "Authors": "James Newton-King",
      "DownloadCount": 120000000,
      "Published": "2020-01-01T00:00:00Z"
    }
  ],
  "CurrentPage": 1,
  "AvailablePages": [1]
}

Obter Informações de Versão do Pacote:

{
  "PackageId": "Newtonsoft.Json",
  "IncludePrerelease": false,
  "PageNumber": 1,
  "FullTextFiltersWithWildCardSupport": []
}

Resposta:

{
  "PackageId": "Newtonsoft.Json",
  "Versions": [
    {
      "Id": "Newtonsoft.Json",
      "Version": "13.0.3",
      "Description": "Json.NET is a popular high-performance JSON framework for .NET",
      "Authors": "James Newton-King",
      "DownloadCount": 1250000000,
      "Published": "2023-03-08T00:00:00Z",
      "DependencyGroups": [
        {
          "TargetFramework": ".NETStandard2.0",
          "Dependencies": []
        },
        {
          "TargetFramework": ".NETFramework4.5",
          "Dependencies": []
        }
      ]
    },
    {
      "Id": "Newtonsoft.Json",
      "Version": "13.0.2",
      "Description": "Json.NET is a popular high-performance JSON framework for .NET",
      "Authors": "James Newton-King",
      "DownloadCount": 980000000,
      "Published": "2022-11-24T00:00:00Z",
      "DependencyGroups": [
        {
          "TargetFramework": ".NETStandard2.0",
          "Dependencies": []
        },
        {
          "TargetFramework": ".NETFramework4.5",
          "Dependencies": []
        }
      ]
    }
  ],
  "CurrentPage": 1,
  "AvailablePages": [1, 2, 3, 4, 5]
}

Obter Versão Específica do Pacote com Filtragem:

{
  "PackageId": "Microsoft.EntityFrameworkCore",
  "IncludePrerelease": false,
  "PageNumber": 1,
  "FullTextFiltersWithWildCardSupport": ["7.0.0"]
}

Resposta:

{
  "PackageId": "Microsoft.EntityFrameworkCore",
  "Versions": [
    {
      "Id": "Microsoft.EntityFrameworkCore",
      "Version": "7.0.0",
      "Description": "Entity Framework Core is a lightweight and extensible version of the popular Entity Framework data access technology.",
      "Authors": "Microsoft",
      "DownloadCount": 42000000,
      "Published": "2022-11-08T00:00:00Z",
      "DependencyGroups": [
        {
          "TargetFramework": "net6.0",
          "Dependencies": [
            {
              "Id": "Microsoft.Extensions.Caching.Memory",
              "VersionRange": "7.0.0"
            },
            {
              "Id": "Microsoft.Extensions.DependencyInjection",
              "VersionRange": "7.0.0"
            },
            {
              "Id": "Microsoft.Extensions.Logging",
              "VersionRange": "7.0.0"
            }
          ]
        }
      ]
    }
  ],
  "CurrentPage": 1,
  "AvailablePages": [1]
}