Para exibir o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto em inglês em uma janela popup, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

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.


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í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.

Contribuições da comunidade

Mostrar: