Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
O .NET é independente de linguagem. Isso significa que, como desenvolvedor, você pode desenvolver em uma das muitas linguagens direcionadas a implementações do .NET, como C#, F#e Visual Basic. Você pode acessar os tipos e membros de bibliotecas de classes desenvolvidas para implementações do .NET sem precisar saber o idioma no qual foram originalmente escritos e sem precisar seguir nenhuma das convenções do idioma original. Se você for um desenvolvedor de componentes, seu componente poderá ser acessado por qualquer aplicativo .NET, independentemente de sua linguagem.
Observação
Esta primeira parte deste artigo discute a criação de componentes independentes de linguagem, ou seja, componentes que podem ser consumidos por aplicativos que são escritos em qualquer idioma. Você também pode criar um único componente ou aplicativo com base no código-fonte escrito em vários idiomas; consulte Interoperabilidade entre idiomas na segunda parte deste artigo.
Para interagir totalmente com outros objetos escritos em qualquer idioma, os objetos devem expor aos chamadores apenas os recursos comuns a todos os idiomas. Esse conjunto comum de recursos é definido pela CLS ( Common Language Specification ), que é um conjunto de regras que se aplicam a assemblies gerados. A Especificação de Linguagem Comum é definida na Partição I, cláusulas 7 a 11 do Padrão ECMA-335: Common Language Infrastructure.
Se o componente estiver em conformidade com a Especificação de Linguagem Comum, ele terá a garantia de ser compatível com CLS e poderá ser acessado do código em assemblies escritos em qualquer linguagem de programação que dê suporte ao CLS. Você pode determinar se o componente está em conformidade com a Especificação de Linguagem Comum em tempo de compilação aplicando o atributo CLSCompliantAttribute ao código-fonte. Para obter mais informações, consulte o atributo CLSCompliantAttribute.
Regras de conformidade do CLS
Esta seção discute as regras para criar um componente compatível com CLS. Para obter uma lista completa de regras, consulte Partição I, Cláusula 11 do Padrão ECMA-335: Common Language Infrastructure.
Observação
A Especificação de Linguagem Comum discute cada regra de conformidade com CLS, pois se aplica aos consumidores (desenvolvedores que acessam programaticamente um componente compatível com CLS), estruturas (desenvolvedores que estão usando um compilador de linguagem para criar bibliotecas compatíveis com CLS) e extensores (desenvolvedores que estão criando uma ferramenta como um compilador de linguagem ou um analisador de código que cria componentes compatíveis com CLS). Este artigo se concentra nas regras à medida que se aplicam às estruturas. Observe, porém, que algumas das regras que se aplicam aos extensores também podem se aplicar a assemblies criados usando Reflection.Emit.
Para criar um componente que seja independente de linguagem, você só precisa aplicar as regras de conformidade com CLS à interface pública do componente. Sua implementação privada não precisa estar em conformidade com a especificação.
Importante
As regras de conformidade com CLS se aplicam apenas à interface pública de um componente, não à sua implementação privada.
Por exemplo, inteiros sem sinal diferentes de Byte não são compatíveis com CLS. Como a Person
classe no exemplo a seguir expõe uma Age
propriedade do tipo UInt16, o código a seguir exibe um aviso do compilador.
using System;
[assembly: CLSCompliant(true)]
public class Person
{
private UInt16 personAge = 0;
public UInt16 Age
{ get { return personAge; } }
}
// The attempt to compile the example displays the following compiler warning:
// Public1.cs(10,18): warning CS3003: Type of 'Person.Age' is not CLS-compliant
<Assembly: CLSCompliant(True)>
Public Class Person
Private personAge As UInt16
Public ReadOnly Property Age As UInt16
Get
Return personAge
End Get
End Property
End Class
' The attempt to compile the example displays the following compiler warning:
' Public1.vb(9) : warning BC40027: Return type of function 'Age' is not CLS-compliant.
'
' Public ReadOnly Property Age As UInt16
' ~~~
É possível tornar a classe Person
em conformidade com CLS alternado o tipo de propriedade Age
de UInt16 para Int16, que é um inteiro com sinal 16 bits em conformidade com CLS. Você não precisa alterar o tipo do campo privado personAge
.
using System;
[assembly: CLSCompliant(true)]
public class Person
{
private Int16 personAge = 0;
public Int16 Age
{ get { return personAge; } }
}
<Assembly: CLSCompliant(True)>
Public Class Person
Private personAge As UInt16
Public ReadOnly Property Age As Int16
Get
Return CType(personAge, Int16)
End Get
End Property
End Class
A interface pública de uma biblioteca consiste no seguinte:
Definições de classes públicas.
Definições dos membros públicos de classes públicas e definições de membros acessíveis a classes derivadas (ou seja, membros protegidos).
Parâmetros e tipos de retorno de métodos públicos de classes públicas, parâmetros e tipos de retorno de métodos acessíveis a classes derivadas.
As regras de conformidade com CLS estão listadas na tabela a seguir. O texto das regras é obtido verbatim do ECMA-335 Standard: Common Language Infrastructure, que é Copyright 2012 pela Ecma International. Informações mais detalhadas sobre essas regras são encontradas nas seções a seguir.
Categoria | Veja | Regra | Número da regra |
---|---|---|---|
Acessibilidade | Acessibilidade de membros | A acessibilidade não deverá ser alterada ao substituir métodos herdados, exceto na substituição de um método herdado de um assembly diferente com acessibilidade family-or-assembly . Nesse caso, a substituição deverá ter a acessibilidade family . |
10 |
Acessibilidade | Acessibilidade de membros | A visibilidade e a acessibilidade de tipos e membros devem ser de modo que os tipos na assinatura de qualquer membro sejam visíveis e acessíveis sempre que o próprio membro estiver visível e acessível. Por exemplo, um método público que é visível fora de sua assemblagem não deve ter um argumento cujo tipo é visível apenas dentro da assemblagem. A visibilidade e a acessibilidade dos tipos que compõem um tipo genérico instanciado usado na assinatura de qualquer membro devem estar visíveis e acessíveis sempre que o próprio membro estiver visível e acessível. Por exemplo, um tipo genérico instanciado presente na assinatura de um membro visível fora do assembly não deverá ter um argumento genérico cujo tipo seja visível somente dentro do assembly. | 12 |
matrizes | Matrizes | As matrizes devem ter elementos com um tipo compatível com CLS e todas as dimensões da matriz devem ter limites inferiores de zero. Somente o fato de que um item é uma matriz e o tipo de elemento da matriz devem ser necessários para distinguir entre sobrecargas. Quando a sobrecarga é baseada em dois ou mais tipos de matriz, os tipos de elemento deverão ser chamados de tipos. | 16 |
Atributos | Atributos | Os atributos devem ser do tipo System.Attributeou de um tipo herdado dele. | 41 |
Atributos | Atributos | O CLS permite apenas um subconjunto das codificações de atributos personalizados. Os únicos tipos que devem aparecer nessas codificações são (consulte Partição IV): System.Type, , System.String, System.Char, System.Boolean, System.Byte, System.Int16, System.Int32, System.Int64, , System.Singlee System.Doublequalquer tipo de enumeração com base em um tipo inteiro de base compatível com CLS. | 34 |
Atributos | Atributos | O CLS não permite modificadores obrigatórios publicamente visíveis (modreq consulte Partição II), mas permite modificadores opcionais (modopt consulte Partição II) que ele não entende. |
35 |
Construtores | Construtores | Um construtor de objetos deve chamar algum construtor de instância de sua classe base antes que qualquer acesso ocorra aos dados de instância herdados. (Isso não se aplica aos tipos de valor, que não precisam ter construtores.) | 21 |
Construtores | Construtores | Um construtor de objeto não deve ser chamado, exceto como parte da criação de um objeto, e um objeto não deve ser inicializado duas vezes. | 22 |
Enumerações | Enumerações | O tipo subjacente de um enum deverá ser um tipo de inteiro CLS interno, o nome do campo deverá ser "value__", e esse campo deverá ser marcado como RTSpecialName . |
7 |
Enumerações | Enumerações | Há dois tipos diferentes de enums, indicados pela presença ou pela ausência do atributo personalizado System.FlagsAttribute (consulte a Biblioteca da Partição IV). Um representa valores inteiros nomeados; o outro representa sinalizadores de bit nomeados que podem ser combinados para gerar um valor sem nome. O valor de um enum não está limitado aos valores especificados. |
oito |
Enumerações | Enumerações | Campos estáticos literais de uma enumeração devem ter o tipo da própria enumeração. | 9 |
Eventos | Eventos | Os métodos que implementam um evento devem ser marcados SpecialName nos metadados. |
29 |
Eventos | Eventos | A acessibilidade de um evento e de seus acessadores deve ser idêntica. | 30 |
Eventos | Eventos | Os métodos add e remove de um evento deverão estar presentes ou ausentes. |
31 |
Eventos | Eventos | Os métodos add e remove de um evento devem cada um aceitar um parâmetro cujo tipo define o tipo do parâmetro do evento e que deve derivar de System.Delegate. |
32 |
Eventos | Eventos | Os eventos devem seguir um padrão de nomenclatura específico. O atributo SpecialName referenciado na regra CLS 29 deve ser ignorado em comparações de nome apropriadas e deve seguir as regras do identificador. | 33 |
Exceções | Exceções | Os objetos que são lançados devem ser do tipo System.Exception ou um tipo herdado dele. No entanto, métodos compatíveis com CLS não são necessários para bloquear a propagação de outros tipos de exceções. | 40 |
Geral | Regras de conformidade do CLS | As regras CLS só se aplicam a essas partes de um tipo acessíveis ou visíveis fora do assembly de definição. | 1 |
Geral | Regras de conformidade do CLS | Membros de tipos sem conformidade com CLS não deverão ser marcados como em conformidade com CLS. | 2 |
Genéricos | Tipos e membros genéricos | Os tipos aninhados devem ter pelo menos tantos parâmetros genéricos quanto o tipo delimitante. Os parâmetros genéricos em um tipo aninhado correspondem, por posição, aos parâmetros genéricos no tipo delimitador. | 42 |
Genéricos | Tipos e membros genéricos | O nome de um tipo genérico deve codificar o número de parâmetros de tipo declarados no tipo não aninhado ou recém-introduzidos ao tipo, se aninhados, de acordo com as regras definidas acima. | 43 |
Genéricos | Tipos e membros genéricos | Um tipo genérico deve reimplantar restrições suficientes para garantir que quaisquer restrições no tipo base ou interfaces sejam atendidas pelas restrições de tipo genérico. | 44 |
Genéricos | Tipos e membros genéricos | Os tipos usados como restrições em parâmetros genéricos devem ser compatíveis com CLS. | 45 |
Genéricos | Tipos e membros genéricos | A visibilidade e a acessibilidade de membros (incluindo tipos aninhados) em um tipo genérico instanciado deverão ser consideradas no escopo da instanciação específica, em vez da declaração de tipo genérico como um todo. Partindo desse pressuposto, as regras de visibilidade e acessibilidade da regra CLS 12 ainda se aplicam. | 46 |
Genéricos | Tipos e membros genéricos | Para cada método genérico abstrato ou virtual, deve haver uma implementação concreta padrão (não abstrata). | 47 |
Interfaces | Interfaces | As interfaces compatíveis com CLS não devem exigir a definição de métodos não compatíveis com CLS para implementá-los. | 18 |
Interfaces | Interfaces | As interfaces compatíveis com CLS não devem definir métodos estáticos nem definir campos. | 19 |
Membros | Membros de tipo em geral | Campos e métodos estáticos globais não são compatíveis com CLS. | 36 |
Membros | -- | O valor de uma estática literal é especificado usando metadados de inicialização de campo. Um literal compatível com CLS deve ter um valor especificado nos metadados de inicialização de campo que seja exatamente do mesmo tipo que o literal (ou do tipo subjacente, se esse literal for um enum ). |
13 |
Membros | Membros de tipo em geral | A restrição vararg não faz parte do CLS e a única convenção de chamada com suporte do CLS é a convenção de chamada gerenciada padrão. | 15 |
Convenções de nomenclatura | Convenções de nomenclatura | As assembléias seguirão o Anexo 7 do Relatório Técnico 15 do padrão Unicode 3.0, que rege o conjunto de caracteres permitidos para iniciar e ser incluído em identificadores, disponível online em Formulários de Normalização Unicode. Os identificadores devem estar no formato canônico definido pelo Formulário de Normalização Unicode C. Para fins de CLS, dois identificadores serão os mesmos se seus mapeamentos em letras minúsculas (conforme especificado pelos mapeamentos em letras minúsculas sem diferenciação de localidade Unicode e um para um) forem os mesmos. Ou seja, para dois identificadores serem considerados diferentes na CLS, eles deverão ser diferentes além de apenas maiúsculas e minúsculas. No entanto, para substituir uma definição herdada, a CLI requer que a codificação precisa da declaração original seja usada. | 4 |
Sobrecarga | Convenções de nomenclatura | Todos os nomes introduzidos em um escopo compatível com CLS deverão ser independentes e distintos do tipo, exceto quando os nomes forem idênticos e resolvidos por meio da sobrecarga. Ou seja, enquanto o CTS permite que um único tipo use o mesmo nome para um método e um campo, o CLS não. | 5 |
Sobrecarga | Convenções de nomenclatura | Campos e tipos aninhados deverão ser diferenciados apenas por comparação de identificador, mesmo que o CTS permita que assinaturas diferentes sejam distinguidas. Métodos, propriedades e eventos que têm o mesmo nome (por comparação de identificador) devem diferir por mais do que apenas o tipo de retorno, exceto conforme especificado na Regra CLS 39 | 6 |
Sobrecarga | Sobrecargas | Somente propriedades e métodos podem ser sobrecarregados. | 37 |
Sobrecarga | Sobrecargas | Propriedades e métodos podem ser sobrecarregados com base apenas no número e tipos de seus parâmetros, exceto os operadores de conversão nomeados op_Implicit e op_Explicit , que também podem ser sobrecarregados com base em seu tipo de retorno. |
38 |
Sobrecarga | -- | Se dois ou mais métodos em conformidade com CLS declarados em um tipo tiverem o mesmo nome e, para um conjunto específico de instanciações de tipo, eles tiverem o mesmo parâmetro e tipos de retorno, todos esses métodos serão semanticamente equivalentes nessas instanciações de tipo. | 48 |
Propriedades | Propriedades | Os métodos que implementam os métodos getter e setter de uma propriedade devem ser marcados SpecialName nos metadados. |
24 |
Propriedades | Propriedades | Os acessadores de uma propriedade deverão ser todos estáticos, virtuais ou de instância. | 26 |
Propriedades | Propriedades | O tipo de uma propriedade deverá ser o tipo de retorno do getter e o tipo do último argumento do setter. Os tipos dos parâmetros da propriedade deverão ser os tipos dos parâmetros do getter e os tipos de todos os parâmetros, menos o parâmetro final do setter. Todos esses tipos deverão ser compatíveis com CLS e não deverão ser ponteiros gerenciados (ou seja, não deverão ser passados por referência). | 27 |
Propriedades | Propriedades | As propriedades devem seguir um padrão de nomenclatura específico. O SpecialName atributo referenciado na regra CLS 24 deve ser ignorado em comparações de nome apropriadas e deve seguir as regras de identificador. Uma propriedade deve ter um método getter, um método setter ou ambos. |
28 |
Conversão de tipos | Conversão de tipo | Se op_Implicit ou op_Explicit for fornecido, um meio alternativo de coerção deverá ser fornecido. | 39 |
Tipos | Tipos e assinaturas de membro de tipo | Tipos de valor demarcado não estão em conformidade com CLS. | 3 |
Tipos | Tipos e assinaturas de membro de tipo | Todos os tipos exibidos em uma assinatura deverão ser compatíveis com CLS. Todos os tipos que compõem um tipo genérico instanciado devem ser compatíveis com CLS. | 11 |
Tipos | Tipos e assinaturas de membro de tipo | Referências com tipo não são compatíveis com CLS. | 14 |
Tipos | Tipos e assinaturas de membro de tipo | Tipos de ponteiro não gerenciados não são compatíveis com CLS. | 17 |
Tipos | Tipos e assinaturas de membro de tipo | Classes, tipos de valor e interfaces compatíveis com CLS não devem exigir a implementação de membros não compatíveis com CLS | 20 |
Tipos | Tipos e assinaturas de membro de tipo | System.Object é compatível com CLS. Qualquer outra classe compatível com CLS deverá herdar de uma classe compatível com CLS. | vinte e três |
Indexar para subseções:
- Tipos e assinaturas de membro de tipo
- Convenções de nomenclatura
- Conversão de tipo
- Matrizes
- Interfaces
- Enumerações
- Membros de tipo em geral
- Acessibilidade de membros
- Tipos e membros genéricos
- Construtores
- Propriedades
- Eventos
- Sobrecargas
- Exceções
- Atributos
Tipos e assinaturas de membro de tipo
O tipo System.Object é compatível com CLS e é o tipo base de todos os tipos de objeto no sistema de tipos .NET. A herança no .NET é implícita (por exemplo, a classe String herda implicitamente da Object
classe) ou explícita (por exemplo, a classe CultureNotFoundException herda explicitamente da classe ArgumentException , que herda explicitamente da classe Exception . Para que um tipo derivado seja compatível com CLS, seu tipo base também deve ser compatível com CLS.
O exemplo a seguir mostra um tipo derivado cujo tipo base não é compatível com CLS. Ele define uma classe base Counter
que usa um inteiro de 32 bits sem sinal como um contador. Como a classe fornece funcionalidade de contador ao encapsular um inteiro sem sinal, ela é marcada como não compatível com a CLS. Como resultado, uma classe NonZeroCounter
derivada também não é compatível com CLS.
using System;
[assembly: CLSCompliant(true)]
[CLSCompliant(false)]
public class Counter
{
UInt32 ctr;
public Counter()
{
ctr = 0;
}
protected Counter(UInt32 ctr)
{
this.ctr = ctr;
}
public override string ToString()
{
return String.Format("{0}). ", ctr);
}
public UInt32 Value
{
get { return ctr; }
}
public void Increment()
{
ctr += (uint) 1;
}
}
public class NonZeroCounter : Counter
{
public NonZeroCounter(int startIndex) : this((uint) startIndex)
{
}
private NonZeroCounter(UInt32 startIndex) : base(startIndex)
{
}
}
// Compilation produces a compiler warning like the following:
// Type3.cs(37,14): warning CS3009: 'NonZeroCounter': base type 'Counter' is not
// CLS-compliant
// Type3.cs(7,14): (Location of symbol related to previous warning)
<Assembly: CLSCompliant(True)>
<CLSCompliant(False)> _
Public Class Counter
Dim ctr As UInt32
Public Sub New
ctr = 0
End Sub
Protected Sub New(ctr As UInt32)
ctr = ctr
End Sub
Public Overrides Function ToString() As String
Return String.Format("{0}). ", ctr)
End Function
Public ReadOnly Property Value As UInt32
Get
Return ctr
End Get
End Property
Public Sub Increment()
ctr += CType(1, UInt32)
End Sub
End Class
Public Class NonZeroCounter : Inherits Counter
Public Sub New(startIndex As Integer)
MyClass.New(CType(startIndex, UInt32))
End Sub
Private Sub New(startIndex As UInt32)
MyBase.New(CType(startIndex, UInt32))
End Sub
End Class
' Compilation produces a compiler warning like the following:
' Type3.vb(34) : warning BC40026: 'NonZeroCounter' is not CLS-compliant
' because it derives from 'Counter', which is not CLS-compliant.
'
' Public Class NonZeroCounter : Inherits Counter
' ~~~~~~~~~~~~~~
Todos os tipos que aparecem em assinaturas de membro, incluindo o tipo de retorno de um método ou um tipo de propriedade, devem ser compatíveis com CLS. Além disso, para tipos genéricos:
Todos os tipos que compõem um tipo genérico instanciado devem ser compatíveis com CLS.
Todos os tipos usados como restrições em parâmetros genéricos devem ser compatíveis com CLS.
O sistema de tipos comuns do .NET inclui muitos tipos internos que têm suporte diretamente pelo common language runtime e são especialmente codificados nos metadados de um assembly. Desses tipos intrínsecos, os tipos listados na tabela a seguir são compatíveis com CLS.
Tipo em conformidade com CLS | Descrição |
---|---|
de bytes | Inteiro sem sinal de 8 bits |
Int16 | Inteiro com sinal de 16 bits |
Int32 | Inteiro com sinal de 32 bits |
Int64 | Inteiro com sinal de 64 bits |
Metade | Valor de ponto flutuante de meia precisão |
Individual | Valor do ponto flutuante de precisão simples |
Duplo | Valor de ponto flutuante de precisão dupla |
Booleano | tipo de valor verdadeiro ou falso |
Queimar | Unidade de código codificada em UTF-16 |
Decimal | Número decimal de ponto não flutuante |
IntPtr | Ponteiro ou identificador de um tamanho definido por plataforma |
Corda | Coleção de zero, um ou mais objetos Char |
Os tipos intrínsecos listados na tabela a seguir não são compatíveis com CLS.
Tipo não compatível | Descrição | Alternativa em conformidade com CLS |
---|---|---|
SByte | Tipo de dado inteiro assinado de 8 bits | Int16 |
UInt16 | Inteiro sem sinal de 16 bits | Int32 |
UInt32 | Número inteiro sem sinal de 32 bits | Int64 |
UInt64 | Inteiro sem sinal de 64 bits | Int64 (pode estourar), BigInteger ou Double |
UIntPtr | Ponteiro ou identificador sem sinal | IntPtr |
A Biblioteca de Classes do .NET ou qualquer outra biblioteca de classes pode incluir outros tipos que não são compatíveis com CLS, por exemplo:
Tipos de valor demarcado. O exemplo de C# a seguir cria uma classe que tem uma propriedade pública do tipo
int*
chamadaValue
. Como umint*
é um tipo de valor em caixa, o compilador o sinaliza como não compatível com CLS.using System; [assembly:CLSCompliant(true)] public unsafe class TestClass { private int* val; public TestClass(int number) { val = (int*) number; } public int* Value { get { return val; } } } // The compiler generates the following output when compiling this example: // warning CS3003: Type of 'TestClass.Value' is not CLS-compliant
Referências tipadas, que são construções especiais que contêm uma referência a um objeto e uma referência a um tipo. As referências tipadas são representadas no .NET pela TypedReference classe.
Se um tipo não estiver em conformidade com CLS, você deverá aplicar o atributo CLSCompliantAttribute com um valor isCompliant
de false
a ele. Para obter mais informações, consulte a seção de atributo CLSCompliantAttribute .
O exemplo a seguir ilustra o problema da conformidade com o CLS em uma assinatura de método e na instanciação de um tipo genérico. Ele define uma InvoiceItem
classe com uma propriedade do tipo UInt32, uma propriedade do tipo Nullable<UInt32>
e um construtor com parâmetros de tipo UInt32 e Nullable<UInt32>
. Você recebe quatro avisos do compilador ao tentar compilar este exemplo.
using System;
[assembly: CLSCompliant(true)]
public class InvoiceItem
{
private uint invId = 0;
private uint itemId = 0;
private Nullable<uint> qty;
public InvoiceItem(uint sku, Nullable<uint> quantity)
{
itemId = sku;
qty = quantity;
}
public Nullable<uint> Quantity
{
get { return qty; }
set { qty = value; }
}
public uint InvoiceId
{
get { return invId; }
set { invId = value; }
}
}
// The attempt to compile the example displays the following output:
// Type1.cs(13,23): warning CS3001: Argument type 'uint' is not CLS-compliant
// Type1.cs(13,33): warning CS3001: Argument type 'uint?' is not CLS-compliant
// Type1.cs(19,26): warning CS3003: Type of 'InvoiceItem.Quantity' is not CLS-compliant
// Type1.cs(25,16): warning CS3003: Type of 'InvoiceItem.InvoiceId' is not CLS-compliant
<Assembly: CLSCompliant(True)>
Public Class InvoiceItem
Private invId As UInteger = 0
Private itemId As UInteger = 0
Private qty AS Nullable(Of UInteger)
Public Sub New(sku As UInteger, quantity As Nullable(Of UInteger))
itemId = sku
qty = quantity
End Sub
Public Property Quantity As Nullable(Of UInteger)
Get
Return qty
End Get
Set
qty = value
End Set
End Property
Public Property InvoiceId As UInteger
Get
Return invId
End Get
Set
invId = value
End Set
End Property
End Class
' The attempt to compile the example displays output similar to the following:
' Type1.vb(13) : warning BC40028: Type of parameter 'sku' is not CLS-compliant.
'
' Public Sub New(sku As UInteger, quantity As Nullable(Of UInteger))
' ~~~
' Type1.vb(13) : warning BC40041: Type 'UInteger' is not CLS-compliant.
'
' Public Sub New(sku As UInteger, quantity As Nullable(Of UInteger))
' ~~~~~~~~
' Type1.vb(18) : warning BC40041: Type 'UInteger' is not CLS-compliant.
'
' Public Property Quantity As Nullable(Of UInteger)
' ~~~~~~~~
' Type1.vb(27) : warning BC40027: Return type of function 'InvoiceId' is not CLS-compliant.
'
' Public Property InvoiceId As UInteger
' ~~~~~~~~~
Para eliminar os avisos do compilador, substitua os tipos não compatíveis com CLS na InvoiceItem
interface pública por tipos em conformidade:
using System;
[assembly: CLSCompliant(true)]
public class InvoiceItem
{
private uint invId = 0;
private uint itemId = 0;
private Nullable<int> qty;
public InvoiceItem(int sku, Nullable<int> quantity)
{
if (sku <= 0)
throw new ArgumentOutOfRangeException("The item number is zero or negative.");
itemId = (uint) sku;
qty = quantity;
}
public Nullable<int> Quantity
{
get { return qty; }
set { qty = value; }
}
public int InvoiceId
{
get { return (int) invId; }
set {
if (value <= 0)
throw new ArgumentOutOfRangeException("The invoice number is zero or negative.");
invId = (uint) value; }
}
}
<Assembly: CLSCompliant(True)>
Public Class InvoiceItem
Private invId As UInteger = 0
Private itemId As UInteger = 0
Private qty AS Nullable(Of Integer)
Public Sub New(sku As Integer, quantity As Nullable(Of Integer))
If sku <= 0 Then
Throw New ArgumentOutOfRangeException("The item number is zero or negative.")
End If
itemId = CUInt(sku)
qty = quantity
End Sub
Public Property Quantity As Nullable(Of Integer)
Get
Return qty
End Get
Set
qty = value
End Set
End Property
Public Property InvoiceId As Integer
Get
Return CInt(invId)
End Get
Set
invId = CUInt(value)
End Set
End Property
End Class
Além dos tipos específicos listados, algumas categorias de tipos não são compatíveis com CLS. Entre eles estão tipos de ponteiro não gerenciados e tipos de ponteiro de função. O exemplo a seguir gera um aviso de compilador porque usa um ponteiro para um inteiro para criar uma matriz de inteiros.
using System;
[assembly: CLSCompliant(true)]
public class ArrayHelper
{
unsafe public static Array CreateInstance(Type type, int* ptr, int items)
{
Array arr = Array.CreateInstance(type, items);
int* addr = ptr;
for (int ctr = 0; ctr < items; ctr++) {
int value = *addr;
arr.SetValue(value, ctr);
addr++;
}
return arr;
}
}
// The attempt to compile this example displays the following output:
// UnmanagedPtr1.cs(8,57): warning CS3001: Argument type 'int*' is not CLS-compliant
Para classes abstratas compatíveis com CLS (ou seja, classes marcadas como abstract
em C# ou como MustInherit
no Visual Basic), todos os membros da classe também devem ser compatíveis com CLS.
Convenções de nomenclatura
Como algumas linguagens de programação não diferenciam maiúsculas de minúsculas, os identificadores (como nomes de namespaces, tipos e membros) devem se diferenciar além de maiúsculas e minúsculas. Dois identificadores serão considerados equivalentes se seus mapeamentos em letras minúsculas forem os mesmos. O exemplo de C# a seguir define duas classes Person
públicas e person
. Como elas diferem apenas por caso, o compilador C# os sinaliza como não compatíveis com CLS.
using System;
[assembly: CLSCompliant(true)]
public class Person : person
{
}
public class person
{
}
// Compilation produces a compiler warning like the following:
// Naming1.cs(11,14): warning CS3005: Identifier 'person' differing
// only in case is not CLS-compliant
// Naming1.cs(6,14): (Location of symbol related to previous warning)
Identificadores de linguagem de programação, como nomes de namespaces, tipos e membros, devem estar em conformidade com o Padrão Unicode. Isso significa que:
O primeiro caractere de um identificador pode ser qualquer letra maiúscula Unicode, letra minúscula, letra capital, letra modificadora, outra letra ou uma letra que represente um número. Para obter informações sobre categorias de caracteres Unicode, consulte a System.Globalization.UnicodeCategory enumeração.
Os caracteres subsequentes podem ser de qualquer uma das categorias como o primeiro caractere e também podem incluir marcas sem espaçamento, marcas que combinam espaçamento, números decimais, pontuações de conector e códigos de formatação.
Antes de comparar identificadores, você deve filtrar códigos de formatação e converter os identificadores no Formulário de Normalização Unicode C, pois um único caractere pode ser representado por várias unidades de código codificadas em UTF-16. As sequências de caracteres que produzem as mesmas unidades de código no Formulário de Normalização Unicode C não são compatíveis com CLS. O exemplo a seguir define uma propriedade chamada Å
, que consiste no caractere ANGSTROM SIGN (U+212B) e uma segunda propriedade chamada Å
, que consiste no caractere LATIN CAPITAL LETTER A WITH RING ABOVE (U+00C5). Os compiladores C# e Visual Basic sinalizam o código-fonte como não compatível com CLS.
public class Size
{
private double a1;
private double a2;
public double Å
{
get { return a1; }
set { a1 = value; }
}
public double Å
{
get { return a2; }
set { a2 = value; }
}
}
// Compilation produces a compiler warning like the following:
// Naming2a.cs(16,18): warning CS3005: Identifier 'Size.Å' differing only in case is not
// CLS-compliant
// Naming2a.cs(10,18): (Location of symbol related to previous warning)
// Naming2a.cs(18,8): warning CS3005: Identifier 'Size.Å.get' differing only in case is not
// CLS-compliant
// Naming2a.cs(12,8): (Location of symbol related to previous warning)
// Naming2a.cs(19,8): warning CS3005: Identifier 'Size.Å.set' differing only in case is not
// CLS-compliant
// Naming2a.cs(13,8): (Location of symbol related to previous warning)
<Assembly: CLSCompliant(True)>
Public Class Size
Private a1 As Double
Private a2 As Double
Public Property Å As Double
Get
Return a1
End Get
Set
a1 = value
End Set
End Property
Public Property Å As Double
Get
Return a2
End Get
Set
a2 = value
End Set
End Property
End Class
' Compilation produces a compiler warning like the following:
' Naming1.vb(9) : error BC30269: 'Public Property Å As Double' has multiple definitions
' with identical signatures.
'
' Public Property Å As Double
' ~
Os nomes de membro em um escopo específico (como os namespaces em um assembly, os tipos em um namespace ou os membros em um tipo) devem ser exclusivos, exceto os nomes resolvidos por meio de sobrecarga. Esse requisito é mais rigoroso do que o do sistema de tipos comuns, o que permite que vários membros em um escopo tenham nomes idênticos, desde que sejam tipos diferentes de membros (por exemplo, um é um método e outro é um campo). Em particular, para membros de tipo:
Campos e tipos aninhados são diferenciados apenas por nome.
Métodos, propriedades e eventos que têm o mesmo nome devem diferir em mais do que apenas o tipo de retorno.
O exemplo a seguir ilustra o requisito de que os nomes de membro devem ser exclusivos em seu escopo. Ele define uma classe nomeada Converter
que inclui quatro membros chamados Conversion
. Três são métodos e um é uma propriedade. O método que inclui um Int64 parâmetro é nomeado exclusivamente, mas os dois métodos com um Int32 parâmetro não são, porque o valor retornado não é considerado uma parte da assinatura de um membro. A Conversion
propriedade também viola esse requisito, pois as propriedades não podem ter o mesmo nome que métodos sobrecarregados.
using System;
[assembly: CLSCompliant(true)]
public class Converter
{
public double Conversion(int number)
{
return (double) number;
}
public float Conversion(int number)
{
return (float) number;
}
public double Conversion(long number)
{
return (double) number;
}
public bool Conversion
{
get { return true; }
}
}
// Compilation produces a compiler error like the following:
// Naming3.cs(13,17): error CS0111: Type 'Converter' already defines a member called
// 'Conversion' with the same parameter types
// Naming3.cs(8,18): (Location of symbol related to previous error)
// Naming3.cs(23,16): error CS0102: The type 'Converter' already contains a definition for
// 'Conversion'
// Naming3.cs(8,18): (Location of symbol related to previous error)
<Assembly: CLSCompliant(True)>
Public Class Converter
Public Function Conversion(number As Integer) As Double
Return CDbl(number)
End Function
Public Function Conversion(number As Integer) As Single
Return CSng(number)
End Function
Public Function Conversion(number As Long) As Double
Return CDbl(number)
End Function
Public ReadOnly Property Conversion As Boolean
Get
Return True
End Get
End Property
End Class
' Compilation produces a compiler error like the following:
' Naming3.vb(8) : error BC30301: 'Public Function Conversion(number As Integer) As Double'
' and 'Public Function Conversion(number As Integer) As Single' cannot
' overload each other because they differ only by return types.
'
' Public Function Conversion(number As Integer) As Double
' ~~~~~~~~~~
' Naming3.vb(20) : error BC30260: 'Conversion' is already declared as 'Public Function
' Conversion(number As Integer) As Single' in this class.
'
' Public ReadOnly Property Conversion As Boolean
' ~~~~~~~~~~
Idiomas individuais incluem palavras-chave exclusivas, portanto, os idiomas direcionados ao common language runtime também devem fornecer algum mecanismo para referenciar identificadores (como nomes de tipo) que coincidem com palavras-chave. Por exemplo, case
é uma palavra-chave no C# e no Visual Basic. No entanto, o exemplo do Visual Basic a seguir pode remover a ambiguidade de uma classe chamada case
da palavra-chave case
, usando chaves de abertura e fechamento. Caso contrário, o exemplo produziria a mensagem de erro, "Palavra-chave não é válida como um identificador" e falha ao compilar.
Public Class [case]
Private _id As Guid
Private name As String
Public Sub New(name As String)
_id = Guid.NewGuid()
Me.name = name
End Sub
Public ReadOnly Property ClientName As String
Get
Return name
End Get
End Property
End Class
O exemplo de C# a seguir é capaz de instanciar a case
classe usando o @
símbolo para desambiguar o identificador da palavra-chave do idioma. Sem ele, o compilador C# exibiria duas mensagens de erro, "Tipo esperado" e "Termo de expressão inválido 'case'".
using System;
public class Example
{
public static void Main()
{
@case c = new @case("John");
Console.WriteLine(c.ClientName);
}
}
Conversão de tipos
A Especificação de Linguagem Comum define dois operadores de conversão:
op_Implicit
, que é usado para ampliar conversões que não resultam em perda de dados ou precisão. Por exemplo, a Decimal estrutura inclui um operador sobrecarregadoop_Implicit
para converter valores de tipos integrais e de Char para valores Decimal.op_Explicit
, que é usado para restringir conversões que podem resultar em perda de magnitude (um valor é convertido em um valor que tem um intervalo menor) ou precisão. Por exemplo, a Decimal estrutura inclui um operador sobrecarregadoop_Explicit
para converter valores Double e Single em Decimal e converter valores Decimal em valores integrais: Double, Single, e Char.
No entanto, nem todos os idiomas dão suporte à sobrecarga do operador ou à definição de operadores personalizados. Se você optar por implementar esses operadores de conversão, também deverá fornecer uma maneira alternativa de executar a conversão. Recomendamos que você forneça From
Xxx e To
Xxx métodos.
O exemplo a seguir define conversões implícitas e explícitas compatíveis com CLS. Ele cria uma classe UDouble
que representa um número de ponto flutuante de precisão dupla, sem sinal. Ele fornece conversões implícitas de UDouble
para Double e conversões explícitas de UDouble
para Single, de Double para UDouble
, e de Single para UDouble
. Ele também define um ToDouble
método como uma alternativa ao operador de conversão implícita e aos ToSingle
métodos , FromDouble
e FromSingle
métodos como alternativas aos operadores de conversão explícitos.
using System;
public struct UDouble
{
private double number;
public UDouble(double value)
{
if (value < 0)
throw new InvalidCastException("A negative value cannot be converted to a UDouble.");
number = value;
}
public UDouble(float value)
{
if (value < 0)
throw new InvalidCastException("A negative value cannot be converted to a UDouble.");
number = value;
}
public static readonly UDouble MinValue = (UDouble) 0.0;
public static readonly UDouble MaxValue = (UDouble) Double.MaxValue;
public static explicit operator Double(UDouble value)
{
return value.number;
}
public static implicit operator Single(UDouble value)
{
if (value.number > (double) Single.MaxValue)
throw new InvalidCastException("A UDouble value is out of range of the Single type.");
return (float) value.number;
}
public static explicit operator UDouble(double value)
{
if (value < 0)
throw new InvalidCastException("A negative value cannot be converted to a UDouble.");
return new UDouble(value);
}
public static implicit operator UDouble(float value)
{
if (value < 0)
throw new InvalidCastException("A negative value cannot be converted to a UDouble.");
return new UDouble(value);
}
public static Double ToDouble(UDouble value)
{
return (Double) value;
}
public static float ToSingle(UDouble value)
{
return (float) value;
}
public static UDouble FromDouble(double value)
{
return new UDouble(value);
}
public static UDouble FromSingle(float value)
{
return new UDouble(value);
}
}
Public Structure UDouble
Private number As Double
Public Sub New(value As Double)
If value < 0 Then
Throw New InvalidCastException("A negative value cannot be converted to a UDouble.")
End If
number = value
End Sub
Public Sub New(value As Single)
If value < 0 Then
Throw New InvalidCastException("A negative value cannot be converted to a UDouble.")
End If
number = value
End Sub
Public Shared ReadOnly MinValue As UDouble = CType(0.0, UDouble)
Public Shared ReadOnly MaxValue As UDouble = Double.MaxValue
Public Shared Widening Operator CType(value As UDouble) As Double
Return value.number
End Operator
Public Shared Narrowing Operator CType(value As UDouble) As Single
If value.number > CDbl(Single.MaxValue) Then
Throw New InvalidCastException("A UDouble value is out of range of the Single type.")
End If
Return CSng(value.number)
End Operator
Public Shared Narrowing Operator CType(value As Double) As UDouble
If value < 0 Then
Throw New InvalidCastException("A negative value cannot be converted to a UDouble.")
End If
Return New UDouble(value)
End Operator
Public Shared Narrowing Operator CType(value As Single) As UDouble
If value < 0 Then
Throw New InvalidCastException("A negative value cannot be converted to a UDouble.")
End If
Return New UDouble(value)
End Operator
Public Shared Function ToDouble(value As UDouble) As Double
Return CType(value, Double)
End Function
Public Shared Function ToSingle(value As UDouble) As Single
Return CType(value, Single)
End Function
Public Shared Function FromDouble(value As Double) As UDouble
Return New UDouble(value)
End Function
Public Shared Function FromSingle(value As Single) As UDouble
Return New UDouble(value)
End Function
End Structure
matrizes
As matrizes compatíveis com CLS estão em conformidade com as seguintes regras:
Todas as dimensões de uma matriz devem ter um limite inferior de zero. O exemplo a seguir cria uma matriz não compatível com CLS com um limite inferior de um. Apesar da presença do CLSCompliantAttribute atributo, o compilador não detecta que a matriz retornada pelo
Numbers.GetTenPrimes
método não é compatível com CLS.[assembly: CLSCompliant(true)] public class Numbers { public static Array GetTenPrimes() { Array arr = Array.CreateInstance(typeof(Int32), new int[] {10}, new int[] {1}); arr.SetValue(1, 1); arr.SetValue(2, 2); arr.SetValue(3, 3); arr.SetValue(5, 4); arr.SetValue(7, 5); arr.SetValue(11, 6); arr.SetValue(13, 7); arr.SetValue(17, 8); arr.SetValue(19, 9); arr.SetValue(23, 10); return arr; } }
<Assembly: CLSCompliant(True)> Public Class Numbers Public Shared Function GetTenPrimes() As Array Dim arr As Array = Array.CreateInstance(GetType(Int32), {10}, {1}) arr.SetValue(1, 1) arr.SetValue(2, 2) arr.SetValue(3, 3) arr.SetValue(5, 4) arr.SetValue(7, 5) arr.SetValue(11, 6) arr.SetValue(13, 7) arr.SetValue(17, 8) arr.SetValue(19, 9) arr.SetValue(23, 10) Return arr End Function End Class
Todos os elementos da matriz devem ser de tipos compatíveis com CLS. O exemplo a seguir define dois métodos que retornam matrizes não compatíveis com CLS. O primeiro retorna uma matriz de UInt32 valores. O segundo retorna uma Object matriz que inclui Int32 e UInt32 valores. Embora o compilador identifique a primeira matriz como não compatível devido ao seu UInt32 tipo, ele não reconhece que a segunda matriz inclui elementos não compatíveis com CLS.
using System; [assembly: CLSCompliant(true)] public class Numbers { public static UInt32[] GetTenPrimes() { uint[] arr = { 1u, 2u, 3u, 5u, 7u, 11u, 13u, 17u, 19u }; return arr; } public static Object[] GetFivePrimes() { Object[] arr = { 1, 2, 3, 5u, 7u }; return arr; } } // Compilation produces a compiler warning like the following: // Array2.cs(8,27): warning CS3002: Return type of 'Numbers.GetTenPrimes()' is not // CLS-compliant
<Assembly: CLSCompliant(True)> Public Class Numbers Public Shared Function GetTenPrimes() As UInt32() Return {1ui, 2ui, 3ui, 5ui, 7ui, 11ui, 13ui, 17ui, 19ui} End Function Public Shared Function GetFivePrimes() As Object() Dim arr() As Object = {1, 2, 3, 5ui, 7ui} Return arr End Function End Class ' Compilation produces a compiler warning like the following: ' warning BC40027: Return type of function 'GetTenPrimes' is not CLS-compliant. ' ' Public Shared Function GetTenPrimes() As UInt32() ' ~~~~~~~~~~~~
A resolução de sobrecarga para métodos que têm parâmetros de matriz baseia-se no fato de que eles são matrizes e em seu tipo de elemento. Por esse motivo, a definição a seguir de um método sobrecarregado
GetSquares
é compatível com CLS.using System; using System.Numerics; [assembly: CLSCompliant(true)] public class Numbers { public static byte[] GetSquares(byte[] numbers) { byte[] numbersOut = new byte[numbers.Length]; for (int ctr = 0; ctr < numbers.Length; ctr++) { int square = ((int) numbers[ctr]) * ((int) numbers[ctr]); if (square <= Byte.MaxValue) numbersOut[ctr] = (byte) square; // If there's an overflow, assign MaxValue to the corresponding // element. else numbersOut[ctr] = Byte.MaxValue; } return numbersOut; } public static BigInteger[] GetSquares(BigInteger[] numbers) { BigInteger[] numbersOut = new BigInteger[numbers.Length]; for (int ctr = 0; ctr < numbers.Length; ctr++) numbersOut[ctr] = numbers[ctr] * numbers[ctr]; return numbersOut; } }
Imports System.Numerics <Assembly: CLSCompliant(True)> Public Module Numbers Public Function GetSquares(numbers As Byte()) As Byte() Dim numbersOut(numbers.Length - 1) As Byte For ctr As Integer = 0 To numbers.Length - 1 Dim square As Integer = (CInt(numbers(ctr)) * CInt(numbers(ctr))) If square <= Byte.MaxValue Then numbersOut(ctr) = CByte(square) ' If there's an overflow, assign MaxValue to the corresponding ' element. Else numbersOut(ctr) = Byte.MaxValue End If Next Return numbersOut End Function Public Function GetSquares(numbers As BigInteger()) As BigInteger() Dim numbersOut(numbers.Length - 1) As BigInteger For ctr As Integer = 0 To numbers.Length - 1 numbersOut(ctr) = numbers(ctr) * numbers(ctr) Next Return numbersOut End Function End Module
Interfaces
Interfaces compatíveis com CLS podem definir propriedades, eventos e métodos virtuais (métodos sem implementação). Uma interface compatível com CLS não pode ter nenhuma das seguintes opções:
Métodos estáticos ou campos estáticos. Os compiladores C# e Visual Basic gerarão erros do compilador se você definir um membro estático em uma interface.
Campos. Os compiladores C# e Visual Basic gerarão erros do compilador se você definir um campo em uma interface.
Métodos que não são compatíveis com CLS. Por exemplo, a definição de interface a seguir inclui um método,
INumber.GetUnsigned
que é marcado como não compatível com CLS. Este exemplo gera um aviso do compilador.using System; [assembly:CLSCompliant(true)] public interface INumber { int Length(); [CLSCompliant(false)] ulong GetUnsigned(); } // Attempting to compile the example displays output like the following: // Interface2.cs(8,32): warning CS3010: 'INumber.GetUnsigned()': CLS-compliant interfaces // must have only CLS-compliant members
<Assembly: CLSCompliant(True)> Public Interface INumber Function Length As Integer <CLSCompliant(False)> Function GetUnsigned As ULong End Interface ' Attempting to compile the example displays output like the following: ' Interface2.vb(9) : warning BC40033: Non CLS-compliant 'function' is not allowed in a ' CLS-compliant interface. ' ' <CLSCompliant(False)> Function GetUnsigned As ULong ' ~~~~~~~~~~~
Devido a essa regra, os tipos compatíveis com CLS não são necessários para implementar membros não compatíveis com CLS. Se uma estrutura compatível com CLS expor uma classe que implementa uma interface não compatível com CLS, ela também deverá fornecer implementações concretas de todos os membros não compatíveis com CLS.
Os compiladores de linguagem compatíveis com CLS também devem permitir que uma classe forneça implementações separadas de membros que tenham o mesmo nome e assinatura em várias interfaces. O C# e o Visual Basic dão suporte a implementações de interface explícitas para fornecer diferentes implementações de métodos nomeados de forma idêntica. O Visual Basic também dá suporte à Implements
palavra-chave, que permite designar explicitamente qual interface e membro um membro específico implementa. O exemplo a seguir ilustra esse cenário definindo uma classe Temperature
que implementa as interfaces ICelsius
e IFahrenheit
como implementações de interface explícitas.
using System;
[assembly: CLSCompliant(true)]
public interface IFahrenheit
{
decimal GetTemperature();
}
public interface ICelsius
{
decimal GetTemperature();
}
public class Temperature : ICelsius, IFahrenheit
{
private decimal _value;
public Temperature(decimal value)
{
// We assume that this is the Celsius value.
_value = value;
}
decimal IFahrenheit.GetTemperature()
{
return _value * 9 / 5 + 32;
}
decimal ICelsius.GetTemperature()
{
return _value;
}
}
public class Example
{
public static void Main()
{
Temperature temp = new Temperature(100.0m);
ICelsius cTemp = temp;
IFahrenheit fTemp = temp;
Console.WriteLine($"Temperature in Celsius: {cTemp.GetTemperature()} degrees");
Console.WriteLine($"Temperature in Fahrenheit: {fTemp.GetTemperature()} degrees");
}
}
// The example displays the following output:
// Temperature in Celsius: 100.0 degrees
// Temperature in Fahrenheit: 212.0 degrees
<Assembly: CLSCompliant(True)>
Public Interface IFahrenheit
Function GetTemperature() As Decimal
End Interface
Public Interface ICelsius
Function GetTemperature() As Decimal
End Interface
Public Class Temperature : Implements ICelsius, IFahrenheit
Private _value As Decimal
Public Sub New(value As Decimal)
' We assume that this is the Celsius value.
_value = value
End Sub
Public Function GetFahrenheit() As Decimal _
Implements IFahrenheit.GetTemperature
Return _value * 9 / 5 + 32
End Function
Public Function GetCelsius() As Decimal _
Implements ICelsius.GetTemperature
Return _value
End Function
End Class
Module Example
Public Sub Main()
Dim temp As New Temperature(100.0d)
Console.WriteLine("Temperature in Celsius: {0} degrees",
temp.GetCelsius())
Console.WriteLine("Temperature in Fahrenheit: {0} degrees",
temp.GetFahrenheit())
End Sub
End Module
' The example displays the following output:
' Temperature in Celsius: 100.0 degrees
' Temperature in Fahrenheit: 212.0 degrees
Enumerações
As enumerações compatíveis com CLS devem seguir estas regras:
O tipo subjacente da enumeração deve ser um inteiro intrínseco em conformidade com CLS (Byte, , Int16Int32ou Int64). Por exemplo, o código a seguir tenta definir uma enumeração cujo tipo subjacente é UInt32 e gera um aviso do compilador.
using System; [assembly: CLSCompliant(true)] public enum Size : uint { Unspecified = 0, XSmall = 1, Small = 2, Medium = 3, Large = 4, XLarge = 5 }; public class Clothing { public string Name; public string Type; public string Size; } // The attempt to compile the example displays a compiler warning like the following: // Enum3.cs(6,13): warning CS3009: 'Size': base type 'uint' is not CLS-compliant
<Assembly: CLSCompliant(True)> Public Enum Size As UInt32 Unspecified = 0 XSmall = 1 Small = 2 Medium = 3 Large = 4 XLarge = 5 End Enum Public Class Clothing Public Name As String Public Type As String Public Size As Size End Class ' The attempt to compile the example displays a compiler warning like the following: ' Enum3.vb(6) : warning BC40032: Underlying type 'UInt32' of Enum is not CLS-compliant. ' ' Public Enum Size As UInt32 ' ~~~~
Um tipo de enumeração deve ter um único campo de instância nomeado
Value__
que esteja marcado com o FieldAttributes.RTSpecialName atributo. Isso permite que você referencie o valor do campo implicitamente.Uma enumeração inclui campos estáticos literais cujos tipos correspondem ao tipo da enumeração em si. Por exemplo, se você definir uma
State
enumeração com valores deState.On
eState.Off
,State.On
eState.Off
são ambos campos literais estáticos cujo tipo éState
.Há dois tipos de enumerações:
Uma enumeração que representa um conjunto de valores inteiros mutuamente exclusivos e nomeados. Esse tipo de enumeração é indicado pela ausência do System.FlagsAttribute atributo personalizado.
Uma enumeração que representa um conjunto de sinalizadores de bits que podem ser combinados para gerar um valor sem nome. Esse tipo de enumeração é indicado pela presença do System.FlagsAttribute atributo personalizado.
Para obter mais informações, consulte a documentação da Enum estrutura.
O valor de uma enumeração não está limitado ao intervalo de seus valores especificados. Em outras palavras, o intervalo de valores em uma enumeração é o intervalo de seu valor subjacente. Você pode usar o Enum.IsDefined método para determinar se um valor especificado é um membro de uma enumeração.
Tipos de membros em geral
A Especificação de Linguagem Comum requer que todos os campos e métodos sejam acessados como membros de uma determinada classe. Portanto, os campos e métodos estáticos globais (ou seja, campos estáticos ou métodos definidos além de um tipo) não são compatíveis com CLS. Se você tentar incluir um campo ou método global no código-fonte, os compiladores C# e Visual Basic gerarão um erro do compilador.
A Especificação de Linguagem Comum dá suporte apenas à convenção de chamada gerenciada padrão. Ele não dá suporte a convenções e métodos de chamada não gerenciados com listas de argumentos variáveis marcadas com a varargs
palavra-chave. Para listas de argumentos variáveis compatíveis com a convenção de chamada gerenciada padrão, use o ParamArrayAttribute atributo ou a implementação do idioma individual, como a params
palavra-chave em C# e a ParamArray
palavra-chave no Visual Basic.
Acessibilidade de membro
A substituição de um membro herdado não pode alterar a acessibilidade desse membro. Por exemplo, um método público em uma classe base não pode ser substituído por um método privado em uma classe derivada. Há uma exceção: um membro protected internal
(em C#) ou Protected Friend
(em Visual Basic) em um assembly que é substituído por um tipo em um assembly diferente. Nesse caso, a acessibilidade da substituição é Protected
.
O exemplo a seguir ilustra o erro gerado quando o atributo CLSCompliantAttribute é definido como true
, e Human
, que é uma classe derivada de Animal
, tenta alterar a acessibilidade da Species
propriedade de pública para privada. O exemplo será compilado com êxito se sua acessibilidade for alterada para pública.
using System;
[assembly: CLSCompliant(true)]
public class Animal
{
private string _species;
public Animal(string species)
{
_species = species;
}
public virtual string Species
{
get { return _species; }
}
public override string ToString()
{
return _species;
}
}
public class Human : Animal
{
private string _name;
public Human(string name) : base("Homo Sapiens")
{
_name = name;
}
public string Name
{
get { return _name; }
}
private override string Species
{
get { return base.Species; }
}
public override string ToString()
{
return _name;
}
}
public class Example
{
public static void Main()
{
Human p = new Human("John");
Console.WriteLine(p.Species);
Console.WriteLine(p.ToString());
}
}
// The example displays the following output:
// error CS0621: 'Human.Species': virtual or abstract members cannot be private
<Assembly: CLSCompliant(True)>
Public Class Animal
Private _species As String
Public Sub New(species As String)
_species = species
End Sub
Public Overridable ReadOnly Property Species As String
Get
Return _species
End Get
End Property
Public Overrides Function ToString() As String
Return _species
End Function
End Class
Public Class Human : Inherits Animal
Private _name As String
Public Sub New(name As String)
MyBase.New("Homo Sapiens")
_name = name
End Sub
Public ReadOnly Property Name As String
Get
Return _name
End Get
End Property
Private Overrides ReadOnly Property Species As String
Get
Return MyBase.Species
End Get
End Property
Public Overrides Function ToString() As String
Return _name
End Function
End Class
Public Module Example
Public Sub Main()
Dim p As New Human("John")
Console.WriteLine(p.Species)
Console.WriteLine(p.ToString())
End Sub
End Module
' The example displays the following output:
' 'Private Overrides ReadOnly Property Species As String' cannot override
' 'Public Overridable ReadOnly Property Species As String' because
' they have different access levels.
'
' Private Overrides ReadOnly Property Species As String
Os tipos na assinatura de um membro devem estar acessíveis sempre que esse membro estiver acessível. Por exemplo, isso significa que um membro público não pode incluir um parâmetro cujo tipo é privado, protegido ou interno. O exemplo a seguir ilustra o erro do compilador que resulta quando um StringWrapper
construtor de classe expõe um valor de enumeração interno StringOperationType
que determina como um valor de cadeia de caracteres deve ser encapsulado.
using System;
using System.Text;
public class StringWrapper
{
string internalString;
StringBuilder internalSB = null;
bool useSB = false;
public StringWrapper(StringOperationType type)
{
if (type == StringOperationType.Normal) {
useSB = false;
}
else {
useSB = true;
internalSB = new StringBuilder();
}
}
// The remaining source code...
}
internal enum StringOperationType { Normal, Dynamic }
// The attempt to compile the example displays the following output:
// error CS0051: Inconsistent accessibility: parameter type
// 'StringOperationType' is less accessible than method
// 'StringWrapper.StringWrapper(StringOperationType)'
Imports System.Text
<Assembly: CLSCompliant(True)>
Public Class StringWrapper
Dim internalString As String
Dim internalSB As StringBuilder = Nothing
Dim useSB As Boolean = False
Public Sub New(type As StringOperationType)
If type = StringOperationType.Normal Then
useSB = False
Else
internalSB = New StringBuilder()
useSB = True
End If
End Sub
' The remaining source code...
End Class
Friend Enum StringOperationType As Integer
Normal = 0
Dynamic = 1
End Enum
' The attempt to compile the example displays the following output:
' error BC30909: 'type' cannot expose type 'StringOperationType'
' outside the project through class 'StringWrapper'.
'
' Public Sub New(type As StringOperationType)
' ~~~~~~~~~~~~~~~~~~~
Tipos e membros genéricos
Tipos aninhados sempre têm pelo menos o mesmo número de parâmetros genéricos do tipo delimitador. Elas correspondem por posição aos parâmetros genéricos no tipo delimitante. O tipo genérico também pode incluir novos parâmetros genéricos.
A relação entre os parâmetros de tipo genérico de um tipo de contenção e seus tipos aninhados pode ser ocultada pela sintaxe de linguagens individuais. No exemplo a seguir, um tipo genérico Outer<T>
contém duas classes aninhadas, Inner1A
e Inner1B<U>
. As chamadas para o método ToString
, que cada classe herda de Object.ToString(), mostram que cada classe aninhada inclui os parâmetros de tipo da classe que a contém.
using System;
[assembly:CLSCompliant(true)]
public class Outer<T>
{
T value;
public Outer(T value)
{
this.value = value;
}
public class Inner1A : Outer<T>
{
public Inner1A(T value) : base(value)
{ }
}
public class Inner1B<U> : Outer<T>
{
U value2;
public Inner1B(T value1, U value2) : base(value1)
{
this.value2 = value2;
}
}
}
public class Example
{
public static void Main()
{
var inst1 = new Outer<String>("This");
Console.WriteLine(inst1);
var inst2 = new Outer<String>.Inner1A("Another");
Console.WriteLine(inst2);
var inst3 = new Outer<String>.Inner1B<int>("That", 2);
Console.WriteLine(inst3);
}
}
// The example displays the following output:
// Outer`1[System.String]
// Outer`1+Inner1A[System.String]
// Outer`1+Inner1B`1[System.String,System.Int32]
<Assembly: CLSCompliant(True)>
Public Class Outer(Of T)
Dim value As T
Public Sub New(value As T)
Me.value = value
End Sub
Public Class Inner1A : Inherits Outer(Of T)
Public Sub New(value As T)
MyBase.New(value)
End Sub
End Class
Public Class Inner1B(Of U) : Inherits Outer(Of T)
Dim value2 As U
Public Sub New(value1 As T, value2 As U)
MyBase.New(value1)
Me.value2 = value2
End Sub
End Class
End Class
Public Module Example
Public Sub Main()
Dim inst1 As New Outer(Of String)("This")
Console.WriteLine(inst1)
Dim inst2 As New Outer(Of String).Inner1A("Another")
Console.WriteLine(inst2)
Dim inst3 As New Outer(Of String).Inner1B(Of Integer)("That", 2)
Console.WriteLine(inst3)
End Sub
End Module
' The example displays the following output:
' Outer`1[System.String]
' Outer`1+Inner1A[System.String]
' Outer`1+Inner1B`1[System.String,System.Int32]
Nomes de tipo genéricos são codificados na forma nome`n, onde nome é o nome do tipo, '`' é um literal de caractere e n é o número de parâmetros declarados no tipo ou, para tipos genéricos aninhados, o número de novos parâmetros de tipo introduzidos. Essa codificação de nomes de tipos genéricos é principalmente de interesse para desenvolvedores que usam reflection para acessar tipos genéricos compatíveis com CLS em uma biblioteca.
Se as restrições forem aplicadas a um tipo genérico, todos os tipos usados como restrições também deverão ser compatíveis com CLS. O exemplo a seguir define uma classe nomeada BaseClass
que não é compatível com CLS e uma classe genérica nomeada BaseCollection
cujo parâmetro de tipo deve derivar.BaseClass
Mas como BaseClass
não é compatível com CLS, o compilador emite um aviso.
using System;
[assembly:CLSCompliant(true)]
[CLSCompliant(false)] public class BaseClass
{}
public class BaseCollection<T> where T : BaseClass
{}
// Attempting to compile the example displays the following output:
// warning CS3024: Constraint type 'BaseClass' is not CLS-compliant
<Assembly: CLSCompliant(True)>
<CLSCompliant(False)> Public Class BaseClass
End Class
Public Class BaseCollection(Of T As BaseClass)
End Class
' Attempting to compile the example displays the following output:
' warning BC40040: Generic parameter constraint type 'BaseClass' is not
' CLS-compliant.
'
' Public Class BaseCollection(Of T As BaseClass)
' ~~~~~~~~~
Se um tipo genérico for derivado de um tipo base genérico, ele deverá reimplantar quaisquer restrições para garantir que as restrições no tipo base também sejam atendidas. O exemplo a seguir define um Number<T>
que pode representar qualquer tipo numérico. Ele também define uma FloatingPoint<T>
classe que representa um valor de ponto flutuante. No entanto, o código-fonte não é compilado, porque ele não aplica a restrição Number<T>
(esse T deve ser um tipo de valor) a FloatingPoint<T>
.
using System;
[assembly:CLSCompliant(true)]
public class Number<T> where T : struct
{
// use Double as the underlying type, since its range is a superset of
// the ranges of all numeric types except BigInteger.
protected double number;
public Number(T value)
{
try {
this.number = Convert.ToDouble(value);
}
catch (OverflowException e) {
throw new ArgumentException("value is too large.", e);
}
catch (InvalidCastException e) {
throw new ArgumentException("The value parameter is not numeric.", e);
}
}
public T Add(T value)
{
return (T) Convert.ChangeType(number + Convert.ToDouble(value), typeof(T));
}
public T Subtract(T value)
{
return (T) Convert.ChangeType(number - Convert.ToDouble(value), typeof(T));
}
}
public class FloatingPoint<T> : Number<T>
{
public FloatingPoint(T number) : base(number)
{
if (typeof(float) == number.GetType() ||
typeof(double) == number.GetType() ||
typeof(decimal) == number.GetType())
this.number = Convert.ToDouble(number);
else
throw new ArgumentException("The number parameter is not a floating-point number.");
}
}
// The attempt to compile the example displays the following output:
// error CS0453: The type 'T' must be a non-nullable value type in
// order to use it as parameter 'T' in the generic type or method 'Number<T>'
<Assembly: CLSCompliant(True)>
Public Class Number(Of T As Structure)
' Use Double as the underlying type, since its range is a superset of
' the ranges of all numeric types except BigInteger.
Protected number As Double
Public Sub New(value As T)
Try
Me.number = Convert.ToDouble(value)
Catch e As OverflowException
Throw New ArgumentException("value is too large.", e)
Catch e As InvalidCastException
Throw New ArgumentException("The value parameter is not numeric.", e)
End Try
End Sub
Public Function Add(value As T) As T
Return CType(Convert.ChangeType(number + Convert.ToDouble(value), GetType(T)), T)
End Function
Public Function Subtract(value As T) As T
Return CType(Convert.ChangeType(number - Convert.ToDouble(value), GetType(T)), T)
End Function
End Class
Public Class FloatingPoint(Of T) : Inherits Number(Of T)
Public Sub New(number As T)
MyBase.New(number)
If TypeOf number Is Single Or
TypeOf number Is Double Or
TypeOf number Is Decimal Then
Me.number = Convert.ToDouble(number)
Else
throw new ArgumentException("The number parameter is not a floating-point number.")
End If
End Sub
End Class
' The attempt to compile the example displays the following output:
' error BC32105: Type argument 'T' does not satisfy the 'Structure'
' constraint for type parameter 'T'.
'
' Public Class FloatingPoint(Of T) : Inherits Number(Of T)
' ~
O exemplo será compilado com êxito se a restrição for adicionada à FloatingPoint<T>
classe.
using System;
[assembly:CLSCompliant(true)]
public class Number<T> where T : struct
{
// use Double as the underlying type, since its range is a superset of
// the ranges of all numeric types except BigInteger.
protected double number;
public Number(T value)
{
try {
this.number = Convert.ToDouble(value);
}
catch (OverflowException e) {
throw new ArgumentException("value is too large.", e);
}
catch (InvalidCastException e) {
throw new ArgumentException("The value parameter is not numeric.", e);
}
}
public T Add(T value)
{
return (T) Convert.ChangeType(number + Convert.ToDouble(value), typeof(T));
}
public T Subtract(T value)
{
return (T) Convert.ChangeType(number - Convert.ToDouble(value), typeof(T));
}
}
public class FloatingPoint<T> : Number<T> where T : struct
{
public FloatingPoint(T number) : base(number)
{
if (typeof(float) == number.GetType() ||
typeof(double) == number.GetType() ||
typeof(decimal) == number.GetType())
this.number = Convert.ToDouble(number);
else
throw new ArgumentException("The number parameter is not a floating-point number.");
}
}
<Assembly: CLSCompliant(True)>
Public Class Number(Of T As Structure)
' Use Double as the underlying type, since its range is a superset of
' the ranges of all numeric types except BigInteger.
Protected number As Double
Public Sub New(value As T)
Try
Me.number = Convert.ToDouble(value)
Catch e As OverflowException
Throw New ArgumentException("value is too large.", e)
Catch e As InvalidCastException
Throw New ArgumentException("The value parameter is not numeric.", e)
End Try
End Sub
Public Function Add(value As T) As T
Return CType(Convert.ChangeType(number + Convert.ToDouble(value), GetType(T)), T)
End Function
Public Function Subtract(value As T) As T
Return CType(Convert.ChangeType(number - Convert.ToDouble(value), GetType(T)), T)
End Function
End Class
Public Class FloatingPoint(Of T As Structure) : Inherits Number(Of T)
Public Sub New(number As T)
MyBase.New(number)
If TypeOf number Is Single Or
TypeOf number Is Double Or
TypeOf number Is Decimal Then
Me.number = Convert.ToDouble(number)
Else
throw new ArgumentException("The number parameter is not a floating-point number.")
End If
End Sub
End Class
A Common Language Specification impõe um modelo por instanciação conservador para tipos aninhados e membros protegidos. Tipos genéricos abertos não podem expor campos ou membros cujas assinaturas contenham uma instanciação específica de um tipo genérico protegido aninhado. Tipos não genéricos que estendam uma instanciação específica de uma interface ou classe base genérica não podem expor campos ou membros com assinaturas que contenham uma instanciação diferente de um tipo genérico aninhado e protegido.
O exemplo a seguir define um tipo genérico ( C1<T>
ou C1(Of T)
no Visual Basic) e uma classe C1<T>.N
protegida (ou C1(Of T).N
no Visual Basic).
C1<T>
tem dois métodos e M1
M2
. No entanto, M1
não é compatível com CLS porque tenta retornar um C1<int>.N
objeto (ou C1(Of Integer).N
) de C1<T> (ou C1(Of T)
). Uma segunda classe, C2
derivada de C1<long>
(ou C1(Of Long)
). Ele tem dois métodos, M3
e M4
.
M3
não é compatível com CLS porque tenta retornar um C1<int>.N
objeto (ou C1(Of Integer).N
) de uma subclasse de C1<long>
. Os compiladores de linguagem podem ser ainda mais restritivos. Neste exemplo, o Visual Basic exibe um erro quando tenta compilar M4
.
using System;
[assembly:CLSCompliant(true)]
public class C1<T>
{
protected class N { }
protected void M1(C1<int>.N n) { } // Not CLS-compliant - C1<int>.N not
// accessible from within C1<T> in all
// languages
protected void M2(C1<T>.N n) { } // CLS-compliant – C1<T>.N accessible
// inside C1<T>
}
public class C2 : C1<long>
{
protected void M3(C1<int>.N n) { } // Not CLS-compliant – C1<int>.N is not
// accessible in C2 (extends C1<long>)
protected void M4(C1<long>.N n) { } // CLS-compliant, C1<long>.N is
// accessible in C2 (extends C1<long>)
}
// Attempting to compile the example displays output like the following:
// Generics4.cs(9,22): warning CS3001: Argument type 'C1<int>.N' is not CLS-compliant
// Generics4.cs(18,22): warning CS3001: Argument type 'C1<int>.N' is not CLS-compliant
<Assembly: CLSCompliant(True)>
Public Class C1(Of T)
Protected Class N
End Class
Protected Sub M1(n As C1(Of Integer).N) ' Not CLS-compliant - C1<int>.N not
' accessible from within C1(Of T) in all
End Sub ' languages
Protected Sub M2(n As C1(Of T).N) ' CLS-compliant – C1(Of T).N accessible
End Sub ' inside C1(Of T)
End Class
Public Class C2 : Inherits C1(Of Long)
Protected Sub M3(n As C1(Of Integer).N) ' Not CLS-compliant – C1(Of Integer).N is not
End Sub ' accessible in C2 (extends C1(Of Long))
Protected Sub M4(n As C1(Of Long).N)
End Sub
End Class
' Attempting to compile the example displays output like the following:
' error BC30508: 'n' cannot expose type 'C1(Of Integer).N' in namespace
' '<Default>' through class 'C1'.
'
' Protected Sub M1(n As C1(Of Integer).N) ' Not CLS-compliant - C1<int>.N not
' ~~~~~~~~~~~~~~~~
' error BC30389: 'C1(Of T).N' is not accessible in this context because
' it is 'Protected'.
'
' Protected Sub M3(n As C1(Of Integer).N) ' Not CLS-compliant - C1(Of Integer).N is not
'
' ~~~~~~~~~~~~~~~~
'
' error BC30389: 'C1(Of T).N' is not accessible in this context because it is 'Protected'.
'
' Protected Sub M4(n As C1(Of Long).N)
' ~~~~~~~~~~~~~
Construtores
Construtores em classes e estruturas compatíveis com CLS devem seguir estas regras:
Um construtor de uma classe derivada deve chamar o construtor de instância de sua classe base antes de acessar dados de instância herdados. Esse requisito existe porque os construtores de classe base não são herdados por suas classes derivadas. Essa regra não se aplica a estruturas que não dão suporte à herança direta.
Normalmente, os compiladores impõem essa regra independentemente da conformidade com CLS, como mostra o exemplo a seguir. Ele cria uma
Doctor
classe derivada de umaPerson
classe, mas aDoctor
classe não chama oPerson
construtor de classe para inicializar campos de instância herdados.using System; [assembly: CLSCompliant(true)] public class Person { private string fName, lName, _id; public Person(string firstName, string lastName, string id) { if (String.IsNullOrEmpty(firstName + lastName)) throw new ArgumentNullException("Either a first name or a last name must be provided."); fName = firstName; lName = lastName; _id = id; } public string FirstName { get { return fName; } } public string LastName { get { return lName; } } public string Id { get { return _id; } } public override string ToString() { return String.Format("{0}{1}{2}", fName, String.IsNullOrEmpty(fName) ? "" : " ", lName); } } public class Doctor : Person { public Doctor(string firstName, string lastName, string id) { } public override string ToString() { return "Dr. " + base.ToString(); } } // Attempting to compile the example displays output like the following: // ctor1.cs(45,11): error CS1729: 'Person' does not contain a constructor that takes 0 // arguments // ctor1.cs(10,11): (Location of symbol related to previous error)
<Assembly: CLSCompliant(True)> Public Class Person Private fName, lName, _id As String Public Sub New(firstName As String, lastName As String, id As String) If String.IsNullOrEmpty(firstName + lastName) Then Throw New ArgumentNullException("Either a first name or a last name must be provided.") End If fName = firstName lName = lastName _id = id End Sub Public ReadOnly Property FirstName As String Get Return fName End Get End Property Public ReadOnly Property LastName As String Get Return lName End Get End Property Public ReadOnly Property Id As String Get Return _id End Get End Property Public Overrides Function ToString() As String Return String.Format("{0}{1}{2}", fName, If(String.IsNullOrEmpty(fName), "", " "), lName) End Function End Class Public Class Doctor : Inherits Person Public Sub New(firstName As String, lastName As String, id As String) End Sub Public Overrides Function ToString() As String Return "Dr. " + MyBase.ToString() End Function End Class ' Attempting to compile the example displays output like the following: ' Ctor1.vb(46) : error BC30148: First statement of this 'Sub New' must be a call ' to 'MyBase.New' or 'MyClass.New' because base class 'Person' of 'Doctor' does ' not have an accessible 'Sub New' that can be called with no arguments. ' ' Public Sub New() ' ~~~
Um construtor de objeto não pode ser chamado, exceto para criar um objeto. Além disso, um objeto não pode ser inicializado duas vezes. Por exemplo, isso significa que Object.MemberwiseClone e métodos de desserialização não podem chamar construtores.
Propriedades
As propriedades em tipos compatíveis com CLS devem seguir estas regras:
Uma propriedade deve ter um setter, um getter ou ambos. Em um assembly, eles são implementados como métodos especiais, o que significa que eles aparecerão como métodos separados (o getter é nomeado
get_
nome de propriedade e o setter éset_
nome de propriedade) marcados comoSpecialName
nos metadados do assembly. Os compiladores C# e Visual Basic impõem essa regra automaticamente sem a necessidade de aplicar o CLSCompliantAttribute atributo.Um tipo de propriedade é o tipo de retorno do getter da propriedade e o último argumento do setter. Esses tipos devem ser compatíveis com CLS e os argumentos não podem ser atribuídos à propriedade por referência (ou seja, não podem ser ponteiros gerenciados).
Se uma propriedade tiver um getter e um setter, ambos deverão ser virtuais, estáticos ou instâncias. Os compiladores C# e Visual Basic impõem automaticamente essa regra por meio de sua sintaxe de definição de propriedade.
Eventos
Um evento é definido por seu nome e seu tipo. O tipo de evento é um delegado que é usado para indicar o evento. Por exemplo, o AppDomain.AssemblyResolve evento é do tipo ResolveEventHandler. Além do evento em si, três métodos com nomes baseados no nome do evento fornecem a implementação do evento e são marcados como SpecialName
nos metadados do assembly:
Um método para adicionar um manipulador de eventos, chamado
add_
EventName. Por exemplo, o método de assinatura de evento para o AppDomain.AssemblyResolve evento é nomeadoadd_AssemblyResolve
.Um método para remover um manipulador de eventos, chamado
remove_
EventName. Por exemplo, o método de remoção do AppDomain.AssemblyResolve evento é nomeadoremove_AssemblyResolve
.Um método para indicar que o evento ocorreu, chamado
raise_
EventName.
Observação
A maioria das regras da Especificação de Linguagem Comum sobre eventos são implementadas por compiladores de linguagem e são transparentes para desenvolvedores de componentes.
Os métodos para adicionar, remover e elevar o evento devem ter a mesma acessibilidade. Eles também devem ser estáticos, de instância ou virtuais. Os métodos para adicionar e remover um evento têm um parâmetro cujo tipo é o tipo de delegado de evento. Os métodos add e remove devem estar presentes ou ambos estar ausentes.
O exemplo a seguir define uma classe compatível com CLS chamada Temperature
que gera um TemperatureChanged
evento se a alteração na temperatura entre duas leituras for igual ou exceder um valor limite. A Temperature
classe define explicitamente um raise_TemperatureChanged
método para que ele possa executar seletivamente manipuladores de eventos.
using System;
using System.Collections;
using System.Collections.Generic;
[assembly: CLSCompliant(true)]
public class TemperatureChangedEventArgs : EventArgs
{
private Decimal originalTemp;
private Decimal newTemp;
private DateTimeOffset when;
public TemperatureChangedEventArgs(Decimal original, Decimal @new, DateTimeOffset time)
{
originalTemp = original;
newTemp = @new;
when = time;
}
public Decimal OldTemperature
{
get { return originalTemp; }
}
public Decimal CurrentTemperature
{
get { return newTemp; }
}
public DateTimeOffset Time
{
get { return when; }
}
}
public delegate void TemperatureChanged(Object sender, TemperatureChangedEventArgs e);
public class Temperature
{
private struct TemperatureInfo
{
public Decimal Temperature;
public DateTimeOffset Recorded;
}
public event TemperatureChanged TemperatureChanged;
private Decimal previous;
private Decimal current;
private Decimal tolerance;
private List<TemperatureInfo> tis = new List<TemperatureInfo>();
public Temperature(Decimal temperature, Decimal tolerance)
{
current = temperature;
TemperatureInfo ti = new TemperatureInfo();
ti.Temperature = temperature;
tis.Add(ti);
ti.Recorded = DateTimeOffset.UtcNow;
this.tolerance = tolerance;
}
public Decimal CurrentTemperature
{
get { return current; }
set {
TemperatureInfo ti = new TemperatureInfo();
ti.Temperature = value;
ti.Recorded = DateTimeOffset.UtcNow;
previous = current;
current = value;
if (Math.Abs(current - previous) >= tolerance)
raise_TemperatureChanged(new TemperatureChangedEventArgs(previous, current, ti.Recorded));
}
}
public void raise_TemperatureChanged(TemperatureChangedEventArgs eventArgs)
{
if (TemperatureChanged == null)
return;
foreach (TemperatureChanged d in TemperatureChanged.GetInvocationList()) {
if (d.Method.Name.Contains("Duplicate"))
Console.WriteLine("Duplicate event handler; event handler not executed.");
else
d.Invoke(this, eventArgs);
}
}
}
public class Example
{
public Temperature temp;
public static void Main()
{
Example ex = new Example();
}
public Example()
{
temp = new Temperature(65, 3);
temp.TemperatureChanged += this.TemperatureNotification;
RecordTemperatures();
Example ex = new Example(temp);
ex.RecordTemperatures();
}
public Example(Temperature t)
{
temp = t;
RecordTemperatures();
}
public void RecordTemperatures()
{
temp.TemperatureChanged += this.DuplicateTemperatureNotification;
temp.CurrentTemperature = 66;
temp.CurrentTemperature = 63;
}
internal void TemperatureNotification(Object sender, TemperatureChangedEventArgs e)
{
Console.WriteLine($"Notification 1: The temperature changed from {e.OldTemperature} to {e.CurrentTemperature}");
}
public void DuplicateTemperatureNotification(Object sender, TemperatureChangedEventArgs e)
{
Console.WriteLine($"Notification 2: The temperature changed from {e.OldTemperature} to {e.CurrentTemperature}");
}
}
Imports System.Collections
Imports System.Collections.Generic
<Assembly: CLSCompliant(True)>
Public Class TemperatureChangedEventArgs : Inherits EventArgs
Private originalTemp As Decimal
Private newTemp As Decimal
Private [when] As DateTimeOffset
Public Sub New(original As Decimal, [new] As Decimal, [time] As DateTimeOffset)
originalTemp = original
newTemp = [new]
[when] = [time]
End Sub
Public ReadOnly Property OldTemperature As Decimal
Get
Return originalTemp
End Get
End Property
Public ReadOnly Property CurrentTemperature As Decimal
Get
Return newTemp
End Get
End Property
Public ReadOnly Property [Time] As DateTimeOffset
Get
Return [when]
End Get
End Property
End Class
Public Delegate Sub TemperatureChanged(sender As Object, e As TemperatureChangedEventArgs)
Public Class Temperature
Private Structure TemperatureInfo
Dim Temperature As Decimal
Dim Recorded As DateTimeOffset
End Structure
Public Event TemperatureChanged As TemperatureChanged
Private previous As Decimal
Private current As Decimal
Private tolerance As Decimal
Private tis As New List(Of TemperatureInfo)
Public Sub New(temperature As Decimal, tolerance As Decimal)
current = temperature
Dim ti As New TemperatureInfo()
ti.Temperature = temperature
ti.Recorded = DateTimeOffset.UtcNow
tis.Add(ti)
Me.tolerance = tolerance
End Sub
Public Property CurrentTemperature As Decimal
Get
Return current
End Get
Set
Dim ti As New TemperatureInfo
ti.Temperature = value
ti.Recorded = DateTimeOffset.UtcNow
previous = current
current = value
If Math.Abs(current - previous) >= tolerance Then
raise_TemperatureChanged(New TemperatureChangedEventArgs(previous, current, ti.Recorded))
End If
End Set
End Property
Public Sub raise_TemperatureChanged(eventArgs As TemperatureChangedEventArgs)
If TemperatureChangedEvent Is Nothing Then Exit Sub
Dim ListenerList() As System.Delegate = TemperatureChangedEvent.GetInvocationList()
For Each d As TemperatureChanged In TemperatureChangedEvent.GetInvocationList()
If d.Method.Name.Contains("Duplicate") Then
Console.WriteLine("Duplicate event handler; event handler not executed.")
Else
d.Invoke(Me, eventArgs)
End If
Next
End Sub
End Class
Public Class Example
Public WithEvents temp As Temperature
Public Shared Sub Main()
Dim ex As New Example()
End Sub
Public Sub New()
temp = New Temperature(65, 3)
RecordTemperatures()
Dim ex As New Example(temp)
ex.RecordTemperatures()
End Sub
Public Sub New(t As Temperature)
temp = t
RecordTemperatures()
End Sub
Public Sub RecordTemperatures()
temp.CurrentTemperature = 66
temp.CurrentTemperature = 63
End Sub
Friend Shared Sub TemperatureNotification(sender As Object, e As TemperatureChangedEventArgs) _
Handles temp.TemperatureChanged
Console.WriteLine("Notification 1: The temperature changed from {0} to {1}", e.OldTemperature, e.CurrentTemperature)
End Sub
Friend Shared Sub DuplicateTemperatureNotification(sender As Object, e As TemperatureChangedEventArgs) _
Handles temp.TemperatureChanged
Console.WriteLine("Notification 2: The temperature changed from {0} to {1}", e.OldTemperature, e.CurrentTemperature)
End Sub
End Class
Sobrecargas
A Especificação de Linguagem Comum impõe os seguintes requisitos aos membros sobrecarregados:
Os membros podem ser sobrecarregados com base no número de parâmetros e no tipo de qualquer parâmetro. Convenção de chamada, tipo de retorno, modificadores personalizados aplicados ao método ou ao seu parâmetro e se os parâmetros são passados por valor ou por referência não são considerados ao diferenciar entre sobrecargas. Para obter um exemplo, consulte o código para o requisito de que os nomes devem ser exclusivos dentro de um escopo na seção Convenções de nomenclatura .
Somente propriedades e métodos podem ser sobrecarregados. Campos e eventos não podem ser sobrecarregados.
Métodos genéricos podem ser sobrecarregados com base no número de seus parâmetros genéricos.
Observação
Os operadores op_Explicit
e op_Implicit
são exceções à regra de que o valor retornado não se considera parte de uma assinatura de método para resolução de sobrecarga. Esses dois operadores podem ser sobrecarregados com base em seus parâmetros e em seu valor retornado.
Exceções
Objetos de exceção devem derivar de System.Exception ou de outro tipo derivado de System.Exception. O exemplo a seguir ilustra o erro do compilador que resulta quando uma classe personalizada nomeada ErrorClass
é usada para tratamento de exceções.
using System;
[assembly: CLSCompliant(true)]
public class ErrorClass
{
string msg;
public ErrorClass(string errorMessage)
{
msg = errorMessage;
}
public string Message
{
get { return msg; }
}
}
public static class StringUtilities
{
public static string[] SplitString(this string value, int index)
{
if (index < 0 | index > value.Length) {
ErrorClass badIndex = new ErrorClass("The index is not within the string.");
throw badIndex;
}
string[] retVal = { value.Substring(0, index - 1),
value.Substring(index) };
return retVal;
}
}
// Compilation produces a compiler error like the following:
// Exceptions1.cs(26,16): error CS0155: The type caught or thrown must be derived from
// System.Exception
Imports System.Runtime.CompilerServices
<Assembly: CLSCompliant(True)>
Public Class ErrorClass
Dim msg As String
Public Sub New(errorMessage As String)
msg = errorMessage
End Sub
Public ReadOnly Property Message As String
Get
Return msg
End Get
End Property
End Class
Public Module StringUtilities
<Extension()> Public Function SplitString(value As String, index As Integer) As String()
If index < 0 Or index > value.Length Then
Dim BadIndex As New ErrorClass("The index is not within the string.")
Throw BadIndex
End If
Dim retVal() As String = {value.Substring(0, index - 1),
value.Substring(index)}
Return retVal
End Function
End Module
' Compilation produces a compiler error like the following:
' Exceptions1.vb(27) : error BC30665: 'Throw' operand must derive from 'System.Exception'.
'
' Throw BadIndex
' ~~~~~~~~~~~~~~
Para corrigir esse erro, a ErrorClass
classe deve herdar de System.Exception. Além disso, a propriedade Message
deve ser substituída. O exemplo a seguir corrige esses erros para definir uma ErrorClass
classe compatível com CLS.
using System;
[assembly: CLSCompliant(true)]
public class ErrorClass : Exception
{
string msg;
public ErrorClass(string errorMessage)
{
msg = errorMessage;
}
public override string Message
{
get { return msg; }
}
}
public static class StringUtilities
{
public static string[] SplitString(this string value, int index)
{
if (index < 0 | index > value.Length) {
ErrorClass badIndex = new ErrorClass("The index is not within the string.");
throw badIndex;
}
string[] retVal = { value.Substring(0, index - 1),
value.Substring(index) };
return retVal;
}
}
Imports System.Runtime.CompilerServices
<Assembly: CLSCompliant(True)>
Public Class ErrorClass : Inherits Exception
Dim msg As String
Public Sub New(errorMessage As String)
msg = errorMessage
End Sub
Public Overrides ReadOnly Property Message As String
Get
Return msg
End Get
End Property
End Class
Public Module StringUtilities
<Extension()> Public Function SplitString(value As String, index As Integer) As String()
If index < 0 Or index > value.Length Then
Dim BadIndex As New ErrorClass("The index is not within the string.")
Throw BadIndex
End If
Dim retVal() As String = {value.Substring(0, index - 1),
value.Substring(index)}
Return retVal
End Function
End Module
Atributos
Em assemblies .NET, os atributos personalizados fornecem um mecanismo extensível para armazenar atributos personalizados e recuperar metadados sobre objetos de programação, como assemblies, tipos, membros e parâmetros de método. Atributos personalizados devem derivar de System.Attribute ou de um tipo derivado de System.Attribute
.
O exemplo a seguir viola essa regra. Ele define uma NumericAttribute
classe que não deriva de System.Attribute. Um erro do compilador resulta somente quando o atributo não compatível com CLS é aplicado, não quando a classe é definida.
using System;
[assembly: CLSCompliant(true)]
[AttributeUsageAttribute(AttributeTargets.Class | AttributeTargets.Struct)]
public class NumericAttribute
{
private bool _isNumeric;
public NumericAttribute(bool isNumeric)
{
_isNumeric = isNumeric;
}
public bool IsNumeric
{
get { return _isNumeric; }
}
}
[Numeric(true)] public struct UDouble
{
double Value;
}
// Compilation produces a compiler error like the following:
// Attribute1.cs(22,2): error CS0616: 'NumericAttribute' is not an attribute class
// Attribute1.cs(7,14): (Location of symbol related to previous error)
<Assembly: CLSCompliant(True)>
<AttributeUsageAttribute(AttributeTargets.Class Or AttributeTargets.Struct)> _
Public Class NumericAttribute
Private _isNumeric As Boolean
Public Sub New(isNumeric As Boolean)
_isNumeric = isNumeric
End Sub
Public ReadOnly Property IsNumeric As Boolean
Get
Return _isNumeric
End Get
End Property
End Class
<Numeric(True)> Public Structure UDouble
Dim Value As Double
End Structure
' Compilation produces a compiler error like the following:
' error BC31504: 'NumericAttribute' cannot be used as an attribute because it
' does not inherit from 'System.Attribute'.
'
' <Numeric(True)> Public Structure UDouble
' ~~~~~~~~~~~~~
O construtor ou as propriedades de um atributo compatível com CLS podem expor apenas os seguintes tipos:
O exemplo a seguir define uma DescriptionAttribute
classe derivada de Attribute. O construtor de classe tem um parâmetro de tipo Descriptor
, portanto, a classe não é compatível com CLS. O compilador C# emite um aviso, mas é compilado com êxito, enquanto o compilador do Visual Basic não emite um aviso ou um erro.
using System;
[assembly:CLSCompliantAttribute(true)]
public enum DescriptorType { type, member };
public class Descriptor
{
public DescriptorType Type;
public String Description;
}
[AttributeUsage(AttributeTargets.All)]
public class DescriptionAttribute : Attribute
{
private Descriptor desc;
public DescriptionAttribute(Descriptor d)
{
desc = d;
}
public Descriptor Descriptor
{ get { return desc; } }
}
// Attempting to compile the example displays output like the following:
// warning CS3015: 'DescriptionAttribute' has no accessible
// constructors which use only CLS-compliant types
<Assembly: CLSCompliantAttribute(True)>
Public Enum DescriptorType As Integer
Type = 0
Member = 1
End Enum
Public Class Descriptor
Public Type As DescriptorType
Public Description As String
End Class
<AttributeUsage(AttributeTargets.All)> _
Public Class DescriptionAttribute : Inherits Attribute
Private desc As Descriptor
Public Sub New(d As Descriptor)
desc = d
End Sub
Public ReadOnly Property Descriptor As Descriptor
Get
Return desc
End Get
End Property
End Class
O atributo CLSCompliantAttribute
O atributo CLSCompliantAttribute é usado para indicar se um elemento de programa está em conformidade com a Especificação de Linguagem Comum. O CLSCompliantAttribute(Boolean) construtor inclui um único parâmetro necessário, isCompliant, que indica se o elemento de programa é compatível com CLS.
No tempo de compilação, o compilador detecta os elementos não compatíveis que provavelmente são compatíveis com CLS e emite um aviso. O compilador não emite avisos para tipos ou membros declarados explicitamente como não compatíveis.
Os desenvolvedores de componentes podem usar o CLSCompliantAttribute
atributo de duas maneiras:
Para definir as partes da interface pública expostas por um componente compatível com CLS e as partes que não são compatíveis com CLS. Quando o atributo é usado para marcar elementos de programa específicos como compatíveis com CLS, seu uso garante que esses elementos estejam acessíveis de todas as linguagens e ferramentas direcionadas ao .NET.
Para garantir que a interface pública da biblioteca de componentes exponha apenas os elementos do programa compatíveis com CLS. Se os elementos não estiverem em conformidade com CLS, os compiladores geralmente emitirão um aviso.
Aviso
Em alguns casos, os compiladores de idioma impõem regras em conformidade com CLS, independentemente de o CLSCompliantAttribute
atributo ser usado. Por exemplo, definir um membro estático em uma interface viola uma regra CLS. Nesse sentido, se você definir um static
membro (em C#) ou Shared
(no Visual Basic) em uma interface, os compiladores C# e Visual Basic exibirão uma mensagem de erro e não compilarão o aplicativo.
O CLSCompliantAttribute atributo é marcado com um AttributeUsageAttribute atributo que tem um valor de AttributeTargets.All. Esse valor permite que você aplique o CLSCompliantAttribute atributo a qualquer elemento de programa, incluindo assemblies, módulos, tipos (classes, estruturas, enumerações, interfaces e delegados), membros do tipo (construtores, métodos, propriedades, campos e eventos), parâmetros, parâmetros genéricos e valores de retorno. No entanto, na prática, você deve aplicar o atributo somente a assemblies, tipos e membros de tipo. Caso contrário, os compiladores ignorarão o atributo e continuarão gerando avisos do compilador sempre que encontrarem um parâmetro não compatível, um parâmetro genérico ou um valor retornado na interface pública da biblioteca.
O valor do CLSCompliantAttribute atributo é herdado por elementos de programa contidos. Por exemplo, se um assembly for marcado como compatível com CLS, seus tipos também serão compatíveis com CLS. Se um tipo for marcado como em conformidade com CLS, seus membros e tipos aninhados também tem conformidade com CLS.
Você pode substituir explicitamente a conformidade herdada aplicando o CLSCompliantAttribute atributo a um elemento de programa contido. Por exemplo, é possível usar o atributo CLSCompliantAttribute com um valor isCompliant
de false
para definir um tipo não compatível em um assembly compatível, e é possível usar o atributo com um valor isCompliant
de true
para definir um tipo compatível em um assembly não compatível. Você também pode definir membros não compatíveis em um tipo compatível. No entanto, um tipo não compatível não pode ter membros compatíveis. Portanto, você não pode usar o atributo com um valor isCompliant
de true
para substituir a herança de um tipo não compatível.
Ao desenvolver componentes, você sempre deve usar o atributo CLSCompliantAttribute para indicar se o assembly, seus tipos e membros são compatíveis com CLS.
Para criar componentes compatíveis com CLS:
Use CLSCompliantAttribute para marcar o assembly como em conformidade com CLS.
Marque qualquer tipo exposto publicamente no assembly que não esteja em conformidade com CLS como não em conformidade.
Marque qualquer membro publicamente exposto em tipos compatíveis com CLS como não compatíveis.
Forneça uma alternativa compatível com CLS para membros não compatíveis com CLS.
Se você tiver marcado com êxito todos os seus tipos e membros não compatíveis, o compilador não deverá emitir nenhum aviso de não conformidade. No entanto, você deve indicar quais membros não são compatíveis com CLS e listar suas alternativas compatíveis com CLS na documentação do produto.
O exemplo a seguir usa o CLSCompliantAttribute atributo para definir um assembly compatível com CLS e um tipo, CharacterUtilities
que tem dois membros não compatíveis com CLS. Como ambos os membros são marcados com o CLSCompliant(false)
atributo, o compilador não produz avisos. A classe também fornece uma alternativa compatível com CLS para ambos os métodos. Normalmente, apenas adicionaríamos duas sobrecargas ao ToUTF16
método para fornecer alternativas compatíveis com CLS. No entanto, como os métodos não podem ser sobrecarregados com base no valor retornado, os nomes dos métodos em conformidade com CLS são diferentes dos nomes dos métodos não compatíveis.
using System;
using System.Text;
[assembly:CLSCompliant(true)]
public class CharacterUtilities
{
[CLSCompliant(false)] public static ushort ToUTF16(String s)
{
s = s.Normalize(NormalizationForm.FormC);
return Convert.ToUInt16(s[0]);
}
[CLSCompliant(false)] public static ushort ToUTF16(Char ch)
{
return Convert.ToUInt16(ch);
}
// CLS-compliant alternative for ToUTF16(String).
public static int ToUTF16CodeUnit(String s)
{
s = s.Normalize(NormalizationForm.FormC);
return (int) Convert.ToUInt16(s[0]);
}
// CLS-compliant alternative for ToUTF16(Char).
public static int ToUTF16CodeUnit(Char ch)
{
return Convert.ToInt32(ch);
}
public bool HasMultipleRepresentations(String s)
{
String s1 = s.Normalize(NormalizationForm.FormC);
return s.Equals(s1);
}
public int GetUnicodeCodePoint(Char ch)
{
if (Char.IsSurrogate(ch))
throw new ArgumentException("ch cannot be a high or low surrogate.");
return Char.ConvertToUtf32(ch.ToString(), 0);
}
public int GetUnicodeCodePoint(Char[] chars)
{
if (chars.Length > 2)
throw new ArgumentException("The array has too many characters.");
if (chars.Length == 2) {
if (! Char.IsSurrogatePair(chars[0], chars[1]))
throw new ArgumentException("The array must contain a low and a high surrogate.");
else
return Char.ConvertToUtf32(chars[0], chars[1]);
}
else {
return Char.ConvertToUtf32(chars.ToString(), 0);
}
}
}
Imports System.Text
<Assembly: CLSCompliant(True)>
Public Class CharacterUtilities
<CLSCompliant(False)> Public Shared Function ToUTF16(s As String) As UShort
s = s.Normalize(NormalizationForm.FormC)
Return Convert.ToUInt16(s(0))
End Function
<CLSCompliant(False)> Public Shared Function ToUTF16(ch As Char) As UShort
Return Convert.ToUInt16(ch)
End Function
' CLS-compliant alternative for ToUTF16(String).
Public Shared Function ToUTF16CodeUnit(s As String) As Integer
s = s.Normalize(NormalizationForm.FormC)
Return CInt(Convert.ToInt16(s(0)))
End Function
' CLS-compliant alternative for ToUTF16(Char).
Public Shared Function ToUTF16CodeUnit(ch As Char) As Integer
Return Convert.ToInt32(ch)
End Function
Public Function HasMultipleRepresentations(s As String) As Boolean
Dim s1 As String = s.Normalize(NormalizationForm.FormC)
Return s.Equals(s1)
End Function
Public Function GetUnicodeCodePoint(ch As Char) As Integer
If Char.IsSurrogate(ch) Then
Throw New ArgumentException("ch cannot be a high or low surrogate.")
End If
Return Char.ConvertToUtf32(ch.ToString(), 0)
End Function
Public Function GetUnicodeCodePoint(chars() As Char) As Integer
If chars.Length > 2 Then
Throw New ArgumentException("The array has too many characters.")
End If
If chars.Length = 2 Then
If Not Char.IsSurrogatePair(chars(0), chars(1)) Then
Throw New ArgumentException("The array must contain a low and a high surrogate.")
Else
Return Char.ConvertToUtf32(chars(0), chars(1))
End If
Else
Return Char.ConvertToUtf32(chars.ToString(), 0)
End If
End Function
End Class
Se você estiver desenvolvendo um aplicativo em vez de uma biblioteca (ou seja, se você não estiver expondo tipos ou membros que podem ser consumidos por outros desenvolvedores de aplicativos), a conformidade CLS dos elementos do programa que seu aplicativo consome é de interesse apenas se a sua linguagem de programação não der suporte a eles. Nesse caso, o compilador de idiomas gerará um erro quando você tentar usar um elemento não compatível com CLS.
Interoperabilidade entre idiomas
A independência da linguagem tem alguns significados possíveis. Um significado envolve consumir de forma integrada tipos de dados escritos em um idioma por um aplicativo desenvolvido em outro idioma. Um segundo significado, que é o foco deste artigo, envolve a combinação de código escrito em vários idiomas em um único assembly .NET.
O exemplo a seguir ilustra a interoperabilidade entre idiomas criando uma biblioteca de classes chamada Utilities.dll que inclui duas classes NumericLib
e StringLib
. A NumericLib
classe é escrita em C#e a StringLib
classe é escrita no Visual Basic. Aqui está o código-fonte para StringUtil.vb
, que inclui um único membro, ToTitleCase
em sua StringLib
classe.
Imports System.Collections.Generic
Imports System.Runtime.CompilerServices
Public Module StringLib
Private exclusions As List(Of String)
Sub New()
Dim words() As String = {"a", "an", "and", "of", "the"}
exclusions = New List(Of String)
exclusions.AddRange(words)
End Sub
<Extension()> _
Public Function ToTitleCase(title As String) As String
Dim words() As String = title.Split()
Dim result As String = String.Empty
For ctr As Integer = 0 To words.Length - 1
Dim word As String = words(ctr)
If ctr = 0 OrElse Not exclusions.Contains(word.ToLower()) Then
result += word.Substring(0, 1).ToUpper() + _
word.Substring(1).ToLower()
Else
result += word.ToLower()
End If
If ctr <= words.Length - 1 Then
result += " "
End If
Next
Return result
End Function
End Module
Aqui está o código-fonte para NumberUtil.cs, que define uma NumericLib
classe que tem dois membros IsEven
e NearZero
.
using System;
public static class NumericLib
{
public static bool IsEven(this IConvertible number)
{
if (number is Byte ||
number is SByte ||
number is Int16 ||
number is UInt16 ||
number is Int32 ||
number is UInt32 ||
number is Int64)
return Convert.ToInt64(number) % 2 == 0;
else if (number is UInt64)
return ((ulong) number) % 2 == 0;
else
throw new NotSupportedException("IsEven called for a non-integer value.");
}
public static bool NearZero(double number)
{
return Math.Abs(number) < .00001;
}
}
Para empacotar as duas classes em um único assembly, você deve compilá-las em módulos. Para compilar o arquivo de código-fonte do Visual Basic em um módulo, use este comando:
vbc /t:module StringUtil.vb
Para obter mais informações sobre a sintaxe de linha de comando do compilador do Visual Basic, consulte Compilar na Linha de Comando.
Para compilar o arquivo de código-fonte C# em um módulo, use este comando:
csc /t:module NumberUtil.cs
Então você usa as Opções do vinculador para compilar os dois módulos em um assembly:
link numberutil.netmodule stringutil.netmodule /out:UtilityLib.dll /dll
O exemplo a seguir então chama os métodos NumericLib.NearZero
e StringLib.ToTitleCase
. O código do Visual Basic e o código C# são capazes de acessar os métodos em ambas as classes.
using System;
public class Example
{
public static void Main()
{
Double dbl = 0.0 - Double.Epsilon;
Console.WriteLine(NumericLib.NearZero(dbl));
string s = "war and peace";
Console.WriteLine(s.ToTitleCase());
}
}
// The example displays the following output:
// True
// War and Peace
Module Example
Public Sub Main()
Dim dbl As Double = 0.0 - Double.Epsilon
Console.WriteLine(NumericLib.NearZero(dbl))
Dim s As String = "war and peace"
Console.WriteLine(s.ToTitleCase())
End Sub
End Module
' The example displays the following output:
' True
' War and Peace
Para compilar o código do Visual Basic, use este comando:
vbc example.vb /r:UtilityLib.dll
Para compilar com C#, altere o nome do compilador de vbc
para csc
, e altere a extensão de arquivo de .vb para .cs:
csc example.cs /r:UtilityLib.dll