Processando o arquivo XML (guia de programação translation from VPE for Csharp)
O compilador gera uma sequência de identificação para cada constructo no seu código que está marcado para gerar a documentação.(Para obter informações sobre como marcar seu código, consulte Recomendado Rótulos para comentários de documentação.) A sequência de caracteres ID identifica exclusivamente o constructo.Programas que processam o arquivo XML podem usar a string de ID para identificar o item de metadados/reflexão correspondente do .NET estrutura que a documentação se aplica ao.
O arquivo XML não é uma representação hierárquica de seu código; é uma lista plana que tenha uma ID gerada para cada elemento.
O compilador observa as regras a seguir quando ele gera as sequências de identificação:
Não há espaço em branco é a seqüência de caracteres.
A primeira parte da seqüência de caracteres de ID identifica o tipo de membro que está sendo identificado por meio de um único caractere seguido de dois-pontos.Os seguintes tipos de membro são usados:
Caracterer
Descrição
N
namespace
Não é possível adicionar comentários de documentação para um namespace, mas você pode fazer cref referências a elas, onde tem suporte.
T
tipo: classe, interface, struct, enum, delegado
F
campo
P
propriedade (incluindo os indexadores ou outras propriedades indexadas)
M
método (incluindo tais métodos especiais sistema autônomo construtores, operadores e assim por diante)
E
Evento
!
sequência de caracteres de erro
O restante da sequência de caracteres fornece informações sobre o erro.O compilador translation from VPE for Csharp gera informações de erro para links que não podem ser resolvidos.
A segunda parte da seqüência de caracteres é o nome totalmente qualificado do item, começando na raiz do namespace.O nome do item, seu delimitador tipos e espaço para nome separados por pontos.Se o nome do item propriamente dito tiver períodos, elas serão substituídas pelo sinal hash ('#').Presume que nenhum item tem um sinal de hash diretamente em seu nome.Por exemplo, o nome totalmente qualificado do construtor String seria "sistema.String.#ctor".
Para propriedades e métodos, se houver argumentos para o método, a lista de argumentos colocados entre parênteses segue.Se não houver nenhum argumento, nenhum parêntese estará presenteOs argumentos são separados por vírgulas.A codificação de cada argumento segue diretamente como ele é codificado em uma assinatura do .NET estrutura:
Tipos base.Tipos regulares (ELEMENT_TYPE_CLASS ou ELEMENT_TYPE_VALUETYPE) são representados sistema autônomo o nome totalmente qualificado do tipo.
Tipos intrínsecos (por exemplo, ELEMENT_TYPE_I4, ELEMENT_TYPE_OBJECT, ELEMENT_TYPE_STRING, ELEMENT_TYPE_TYPEDBYREF.e ELEMENT_TYPE_VOID) são representadas sistema autônomo o nome totalmente qualificado do tipo de total correspondente.Por exemplo, sistema.Int32 ou sistema.TypedReference.
ELEMENT_TYPE_PTR é representado sistema autônomo uma ' * ' após o tipo modificado.
ELEMENT_TYPE_BYREF é representado sistema autônomo uma '@' após o tipo modificado.
ELEMENT_TYPE_PINNED é representado sistema autônomo uma ' ^ ' após o tipo modificado.O compilador translation from VPE for Csharp nunca gera isso.
ELEMENT_TYPE_CMOD_REQ é representado sistema autônomo um ' | ' e o nome totalmente qualificado da classe modificador, seguindo o tipo modificado.O compilador translation from VPE for Csharp nunca gera isso.
ELEMENT_TYPE_CMOD_OPT é representado sistema autônomo uma '! ' e o nome totalmente qualificado da classe modificador, seguindo o tipo modificado.
ELEMENT_TYPE_SZARRAY é representado sistema autônomo "[]" após o tipo de elemento da matriz.
ELEMENT_TYPE_GENERICARRAY é representado sistema autônomo "?" após o tipo de elemento da matriz.O compilador translation from VPE for Csharp nunca gera isso.
ELEMENT_TYPE_ARRAY é representado sistema autônomo lowerbound:size,lowerbound:size] onde o número de vírgulas é a classificar - 1, e a limites inferiores e o dimensionar de cada dimensão, se conhecido, são representados no formato decimal.Se não for especificado um limite inferior ou dimensionar, simplesmente é omitido.Se o limite inferior e o dimensionar de uma determinada dimensão forem omitidos, o ': ' é omitido também.Por exemplo, é uma matriz bidimensional com 1 sistema autônomo sistema autônomo limites inferiores e tamanhos não especificados [1:, 1:].
ELEMENT_TYPE_FNPTR é representado sistema autônomo "= FUNC:type(assinatura) ", onde type é o tipo de retorno, e assinatura é argumentos do método.Se não houver nenhum argumento, os parênteses são omitidos.O compilador translation from VPE for Csharp nunca gera isso.
Os seguintes componentes de assinatura não são representados porque eles nunca são usados para diferenciação métodos sobrecarregados:
convenção de chamada
tipo de retorno
ELEMENT_TYPE_SENTINEL
Para conversão de operadores somente (op_Implicit e op_Explicit), o valor retornado do método é codificado sistema autônomo um ' ~ ' seguido do tipo de retorno, sistema autônomo codificado acima.
Para tipos genéricos, o nome do tipo será seguido por uma escala de back e, em seguida, um número que indica o número de parâmetros de tipo genérico.Por exemplo,
<member name="T:SampleClass`2"> é a marca para um tipo que é definido sistema autônomo public class SampleClass<T, U>.
Para métodos levando tipos genéricos sistema autônomo parâmetros, sistema autônomo parâmetros de tipo genérico são especificados sistema autônomo números prefaciados com tiques traseiro (por exemplo ` 0, 1 `).Cada número que representa uma notação de array baseado em zero para os parâmetros genéricos do tipo.
Exemplos
Os exemplos a seguir mostram como a ID de seqüências de caracteres para uma classe e seus membros seriam gerados:
///
///
namespace N // "N:N"
{
///
///
public unsafe class X // "T:N.X"
{
public X(){}
//----------------------------
// The result of the above is:
// "M:N.X.#ctor"
/// <param name="i"></param>
public X(int i){}
//----------------------------
// The result of the above is:
// "M:N.X.#ctor(System.Int32)"
~X(){}
//----------------------------
// The result of the above is:
// "M:N.X.Finalize", destructor's representation in metadata
public string q;
//----------------------------
// The result of the above is:
// "F:N.X.q"
/// <returns></returns>
public const double PI = 3.14;
//----------------------------
// The result of the above is:
// "F:N.X.PI"
/// <param name="s"></param>
/// <param name="y"></param>
/// <param name="z"></param>
/// <returns></returns>
public int f(){return 1;}
//----------------------------
// The result of the above is:
// "M:N.X.f"
/// <param name="array1"></param>
/// <param name="array"></param>
/// <returns></returns>
public int bb(string s, ref int y, void * z){return 1;}
//----------------------------
// The result of the above is:
// "M:N.X.bb(System.String,System.Int32@,=System.Void*)"
/// <param name="x"></param>
/// <param name="xx"></param>
/// <returns></returns>
public int gg(short[] array1, int[,] array){return 0;}
//----------------------------
// The result of the above is:
// "M:N.X.gg(System.Int16[], System.Int32[0:,0:])"
public static X operator+(X x, X xx){return x;}
//----------------------------
// The result of the above is:
// "M:N.X.op_Addition(N.X,N.X)"
public int prop {get{return 1;} set{}}
//----------------------------
// The result of the above is:
// "P:N.X.prop"
public event D d;
//----------------------------
// The result of the above is:
// "E:N.X.d"
public int this[string s]{get{return 1;}}
//----------------------------
// The result of the above is:
// "P:N.X.Item(System.String)"
public class Nested{}
//----------------------------
// The result of the above is:
// "T:N.X.Nested"
public delegate void D(int i);
//----------------------------
// The result of the above is:
// "T:N.X.D"
/// <param name="x"></param>
/// <returns></returns>
public static explicit operator int(X x){return 1;}
//----------------------------
// The result of the above is:
// "M:N.X.op_Explicit(N.X)~System.Int32"
}
}
Consulte também
Tarefas
Conceitos
Referência
/doc (processo Documentação Comments) (opções do compilador de C#)