Como criar assemblies amigáveis não assinados (C# e Visual Basic)

Este exemplo mostra como usar friend assemblies com módulos (assemblies) que não estejam assinados.

Para criar um assembly e um assembly do amigo no Visual Studio

1. Abra um prompt de comando Visual Studio.

2. Crie um arquivo de Visual Basic ou C# chamado friend_signed_A. que contém o código a seguir. O código usa a InternalsVisibleToAttribute atributo para declarar o friend_signed_B como um assembly de amigo.

   ' friend_unsigned_A.vb 
   ' Compile with:  
   ' Vbc /target:library friend_unsigned_A.vb 
   Imports System.Runtime.CompilerServices
   Imports System
   
   <Assembly: InternalsVisibleTo("friend_unsigned_B")> 
   
   ' Friend type. 
   Friend Class Class1
       Public Sub Test()
           Console.WriteLine("Class1.Test")
       End Sub 
   End Class 
   
   ' Public type with Friend member. 
   Public Class Class2
       Friend Sub Test()
           Console.WriteLine("Class2.Test")
       End Sub 
   End Class
   

   // friend_unsigned_A.cs 
   // Compile with:  
   // csc /target:library friend_unsigned_A.cs 
   using System.Runtime.CompilerServices;
   using System;
   
   [assembly: InternalsVisibleTo("friend_unsigned_B")]
   
   // Type is internal by default. 
   class Class1
   {
       public void Test()
       {
           Console.WriteLine("Class1.Test");
       }
   }
   
   // Public type with internal member. 
   public class Class2
   {
       internal void Test()
       {
           Console.WriteLine("Class2.Test");
       }
   }
   

3. Compile e assinar friend_signed_A usando o comando a seguir.

   Vbc /target:library friend_unsigned_A.vb
   

   csc /target:library friend_unsigned_A.cs
   

4. Crie um arquivo de Visual Basic ou C# chamado friend_unsigned_B que contém o código a seguir. Como friend_unsigned_A Especifica o friend_unsigned_B como um assembly de amigo, o código de friend_unsigned_B pode acessar Friend (Visual Basic) ou internal (C#) de tipos e membros da friend_unsigned_A.

   ' friend_unsigned_B.vb 
   ' Compile with:  
   ' Vbc /r:friend_unsigned_A.dll friend_unsigned_B.vb 
   Module Module1
       Sub Main()
           ' Access a Friend type. 
           Dim inst1 As New Class1()
           inst1.Test()
   
           Dim inst2 As New Class2()
           ' Access a Friend member of a public type.
           inst2.Test()
   
           System.Console.ReadLine()
       End Sub 
   End Module
   

   // friend_unsigned_B.cs 
   // Compile with:  
   // csc /r:friend_unsigned_A.dll /out:friend_unsigned_B.exe friend_unsigned_B.cs 
   public class Program
   {
       static void Main()
       {
           // Access an internal type.
           Class1 inst1 = new Class1();
           inst1.Test();
   
           Class2 inst2 = new Class2();
           // Access an internal member of a public type.
           inst2.Test();
   
           System.Console.ReadLine();
       }
   }
   

5. Compile friend_signed_B usando o comando a seguir.

   Vbc /r:friend_unsigned_A.dll friend_unsigned_B.vb
   

   csc /r:friend_unsigned_A.dll /out:friend_unsigned_B.exe friend_unsigned_B.cs
   

   O nome do assembly gerado pelo compilador deve coincidir com o nome de assembly amigável que é passado para o InternalsVisibleToAttribute atributo. Você pode definir explicitamente o assembly usando o /out opção de compilador.

   No C#, você deve especificar explicitamente o nome do assembly de saída (. exe ou. dll), usando o /out opção de compilador. Visual Basic, isso é opcional. Para obter mais informações, consulte /out (Visual Basic) e /out (opções do compilador C#).

6. Execute o arquivo friend_signed_B.exe.

   O programa imprime duas seqüências de caracteres: "Class1.Test" e "Class2.Test".

Segurança

Há semelhanças entre o atributo InternalsVisibleToAttribute e a classe StrongNameIdentityPermission. A principal diferença é que StrongNameIdentityPermission pode exigir permissões de segurança para executar uma determinada seção de código, ao passo que o InternalsVisibleToAttribute atributo controla a visibilidade de Friend (Visual Basic) ou internal (C#) de tipos e membros.

Consulte também

Tarefas

Como criar assemblies amigáveis assinados (C# e Visual Basic)

Referência

InternalsVisibleToAttribute

Conceitos

Assemblies e o cache de assemblies global (C# e Visual Basic)

Assemblies amigáveis (C# e Visual Basic)

Guia de Programação em C#

Outros recursos

Guia de programação do Visual Basic