Interoperabilidade entre linguagens

A independência de linguagem tem vários significados possíveis. Um significado, discutido no artigo Independência de linguagem e componentes independentes de linguagem, envolve o consumo pleno de tipos escritos em uma linguagem de um aplicativo escrito em outra linguagem. Um segundo significado, que é o enfoque deste artigo, envolve combinar o código escrito em várias linguagens em um único assembly do .NET Framework.

O exemplo a seguir ilustra a interoperabilidade entre linguagens com a criação de uma biblioteca de classes chamada Utilities.dll que inclui duas classes, NumericLib e StringLib. A classe NumericLib é escrita em C#, e a classe StringLib é escrita em Visual Basic. Aqui está o código-fonte de StringUtil.vb, que inclui um único membro, ToTitleCase, em sua classe StringLib.

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 de NumberUtil.cs, que define uma classe NumericLib com 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 ((long) 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 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 Compilando a partir da linha de comando (Visual Basic).

Para compilar o arquivo de código-fonte do C# em um módulo, use este comando:

csc /t:module NumberUtil.cs

Para obter mais informações sobre a sintaxe de linha de comando do compilador do C#, consulte Compilação pela linha de comando com csc.exe.

Então você usa a ferramenta Link (Link.exe) para compilar os dois módulos em um assembly:

link numberutil.netmodule stringutil.netmodule /out:UtilityLib.dll /dll 

O exemplo a seguir chama os métodos NumericLib.NearZero e StringLib.ToTitleCase. Observe que o código do Visual Basic e o código do C# podem acessar os métodos em ambas as classes.

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

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

Para compilar o código do Visual Basic, use este comando:

vbc example.vb /r:UtilityLib.dll

Para compilar usando 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

Tópicos relacionados

Título	Descrição
Independência da linguagem e componentes independentes da linguagem	Explica como criar componentes de software compatíveis com CLS que podem ser consumidos por aplicativos escritos em qualquer linguagem.
Common Type System	Descreve como tipos são declarados, usados e gerenciados pelo Common Language Runtime.
Metadados e componentes autodescritivos	Explica o mecanismo do Common Language Runtime para descrever um tipo e armazenar essas informações com o próprio tipo.