Escrevendo código compatível com CLS
Compatibilidade com CLS (Common Language Specification) geralmente se refere à afirmação de que as regras e restrições CLS estão sendo seguidas.Entretanto, o conceito tem um significado mais específico dependendo se você estiver descrevendo código compatível com CLS ou ferramentas de desenvolvimento compatíveis com CLS, tal como um compilador.Ferramentas compatíveis com CLS podem ajudar a escrever código compatível com CLS.
Código compatível com CLS
Se você deseja que seu código seja compatível com CLS, você deve expor funcionalidades de um jeito que seja compatível com CLS nos seguintes locais:
Definições de suas classes públicas.
Definições de membros públicos de classes públicas, e de membros acessíveis às classes derivadas de classes (acesso por família).
Parâmetros e tipos de retorno de métodos públicos de classes públicas, e de métodos acessíveis às classes derivadas.
Os recursos que você usa nas definições de suas classes privadas, nas definições de métodos privados em classes públicas e em variáveis locais não precisam seguir as regras CLS.Você também pode usar os recursos de linguagem que você desejar no código que implementa sua classe e ainda ter um componente compatível com CLS.
.gif "Observação") Observação: |
|---|
Matrizes denteadas — ou seja, matrizes de matrizes — são compatíveis com CLS.No .NET estrutura versão 1.0, o compilador translation from VPE for Csharp por engano relata que não são . |
Você pode marcar assemblies, módulos, tipos, e membros como compatíveis com CLS ou incompatíveis com CLS usando o CLSCompliantAttribute.Todos os assemblies que devem ser compatíveis com CLS devem ser marcados como tal.Um assembly que não está marcado como compatível com CLS é considerado como sendo imcompatível com CLS.Assume-se que se nenhum atributo CLS for aplicado a um tipo, esse tipo tem a mesma compatibilidade com CLS que o assembly em que o tipo é definido.Da mesma forma, se nenhum atributo CLS for aplicado a um membro, considera-se que o membro tem a mesma compatibilidade com CLS do tipo que o define.Não é possível marcar um elemento de programa como compatível com CLS se seu elemento delimitador não estiver marcado como compatível com CLS.O exemplo no final deste tópico ilustra o uso do CLSCompliantAttribute.
Assemblies, módulos e tipos pode ser compatíveis com CLS mesmo que algumas partes do assembly, módulo, ou tipo não sejam compatíveis com CLS, desde que duas condições sejam atendidas:
Se o elemento estiver marcado como compatível com CLS, as partes que não são compatíveis com CLS devem ser marcadas usando o CLSCompliantAttribute com seu argumento definido como false.
Um membro comparável alternativo compatível com CLS deve ser fornecido para cada membro que não é compatível com CLS.
Se você criar uma biblioteca de classes compatível com CLS, sua biblioteca terá uma garantia de interoperabilidade com uma grande variedade de linguagens de programação; portanto, a biblioteca tem mais probabilidade de ter uma base cliente maior do que uma versão que seja imcompatível com CLS.
O .NET Framework fornece uma biblioteca de classes compatível com CLS.Para obter mais informações sobre este biblioteca de classes, consulte Referência à Biblioteca Classe do .NET Framework.
Ferramentas compatíveis com CLS
As linguagens que almejam o ambiente de tempo de execução concordaram em oferecer suporte a recursos CLS e seguem as regras CLS direcionadas para compiladores.Estes compiladores de linguagens simplificam a compatibilidade com CLS, tornando os tipos de dados e recursos CLS disponíveis para criar componentes.Os níveis de compatibilidade com CLS entre compiladores e outras ferramentas são descritos da seguinte maneira:
Ferramentas consumidoras compatíveis com CLS.
Ferramentas consumidoras são linguagens que habilitam os desenvolvedores a acessarem todos os recursos fornecidos pelas bibliotecas compatíveis com CLS.Os desenvolvedores usando estas linguagens talvez não possam estender bibliotecas compatíveis com CLS, criando novos tipos, mas eles podem usar qualquer tipo definido por uma biblioteca compatível.Este nível de compatibilidade pode ser útil quando você deseja acessar uma biblioteca de classes do .NET Framework, mas não precisa criar novos objetos consumíveis por outras pessoas, tal como quando você está usando Web Forms em uma página ASP.NET ou criando uma interface de usuário Windows Forms.
Ferramentas de extensão compatíveis com CLS.
Ferramentas de extensão são linguagens que permitem que os desenvolvedores usem e estendam tipos definidos em bibliotecas compatíveis com CLS.Os desenvolvedores podem usar tipos existentes e definir novos tipos.Ferramentas de extensão devem seguir todas sistema autônomo regras que sistema autônomo ferramentas consumidoras devem seguir, bem sistema autônomo algumas regras adicionais, que são descritas na especificação para o Common linguagem Infrastructure, partição I - Architecture, disponível a partir de Microsoft Developer rede (MSDN) Site da Web.
Quando você cria seus próprios componentes compatíveis com CLS, é útil usar uma ferramenta compatível com CLS.Escrever componentes compatíveis com CLS sem este suporte é mais difícil porque sem ele talvez você não tenha acesso a todos os recursos CLS que deseja usar.
Alguns compiladores de linguagens compatíveis com CLS, como os compiladores C# ou Visual Basic, permitem que você especifique que você pretende que seu código seja compatível com CLS.Estes compiladores podem verificar por compatibilidade com CLS e permite que você saiba quando seu código usa uma funcionalidade que não é aceita pelo CLS.Os compiladores C# e Visual Basic permitem que você marque um elemento de programa como compatível com CLS, o que fará com que o compilador gere um erro em tempo de compilação se o código for incompatível com CLS.Por exemplo, o código a seguir gera um aviso do compilador.
<Assembly: CLSCompliant(True)>
<CLSCompliant(True)> Public Class MyCompliantClass
Public Sub ChangeValue(value As UInt32)
End Sub
Public Shared Sub Main()
Dim i As Integer = 2
Console.WriteLine(i)
End Sub
End Class
using System;
// Assembly marked as compliant.
[assembly: CLSCompliant(true)]
// Class marked as compliant.
[CLSCompliant(true)]
public class MyCompliantClass {
// ChangeValue exposes UInt32, which is not in CLS.
// A compile-time warning results.
public void ChangeValue(UInt32 value){ }
public static void Main( ) {
int i = 2;
Console.WriteLine(i);
}
}
Esse código gera o seguinte aviso C#:
warning CS3001: Argument type 'uint' is not CLS-compliant
Ou o seguinte aviso Visual Basic:
warning BC40028: Type of parameter 'value' is not CLS-compliant.
Para remover o aviso, você pode indicar que ChangeValue não é compatível, como mostrado no exemplo a seguir.
' Assembly marked as compliant.
<Assembly: CLSCompliant(True)>
' Class marked as compliant.
<CLSCompliant(True)> Public Class MyCompliantClass
' Method marked as not compliant.
<CLSCompliant(False)> Public Sub ChangeValue(value As UInt32)
End Sub
Public Shared Sub Main()
Dim i As Integer = 2
Console.WriteLine(i)
End Sub
End Class
using System;
// Assembly marked as compliant.
[assembly: CLSCompliantAttribute(true)]
// Class marked as compliant.
[CLSCompliantAttribute(true)]
public class MyCompliantClass {
// Method marked as not compliant.
[CLSCompliantAttribute(false)]
public void ChangeValue(UInt32 value){ }
public static void Main( ) {
int i = 2;
Console.WriteLine(i);
}
}
Esse código não produz nenhum aviso do compilador.A saída é 2.
Para obter mais informações sobre como especificar a compatibilidade com CLS de seu código, consulte a documentação para o compilador da linguagem que você estiver usando.
Consulte também
Conceitos
Visão geral da interoperabilidade de linguagem