InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute InternalsVisibleToAttribute Class

Definizione

Specifica che i tipi che sono in genere visibili solo all'interno dall'assembly corrente possono essere visualizzati da un assembly specificato.Specifies that types that are ordinarily visible only within the current assembly are visible to a specified assembly.

public ref class InternalsVisibleToAttribute sealed : Attribute
[System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple=true, Inherited=false)]
public sealed class InternalsVisibleToAttribute : Attribute
type InternalsVisibleToAttribute = class
    inherit Attribute
Public NotInheritable Class InternalsVisibleToAttribute
Inherits Attribute
Ereditarietà
InternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttributeInternalsVisibleToAttribute
Attributi

Esempi

Assembly firmatiSigned assemblies

L'esempio seguente usa il InternalsVisibleToAttribute attributi per rendere un' internal metodo denominato AppendDirectorySeparator in un assembly firmato visibile a un altro assembly firmato.The following example uses the InternalsVisibleToAttribute attribute to make an internal method named AppendDirectorySeparator in a signed assembly visible to another signed assembly. Definisce un FileUtilities classe che include un interno AppendDirectorySeparator (metodo).It defines a FileUtilities class that includes an internal AppendDirectorySeparator method. Il InternalsVisibleToAttribute attributo è applicato all'assembly che contiene il FileUtilities classe.The InternalsVisibleToAttribute attribute is applied to the assembly that contains the FileUtilities class. L'attributo consente a un assembly denominato Friend1 per accedere a questo membro interno.The attribute allows an assembly named Friend1 to access this internal member.

//
// The source code should be saved in a file named Example1.cs. It 
// can be compiled at the command line as follows:
//
//    csc /t:library /keyfile:<snkfilename> Assembly1.cs
//
// The public key of the Friend1 file should be changed to the full
// public key stored in your strong-named key file.
//
using System;
using System.IO;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Friend1, PublicKey=002400000480000094" + 
                              "0000000602000000240000525341310004000" +
                              "001000100bf8c25fcd44838d87e245ab35bf7" +
                              "3ba2615707feea295709559b3de903fb95a93" +
                              "3d2729967c3184a97d7b84c7547cd87e435b5" +
                              "6bdf8621bcb62b59c00c88bd83aa62c4fcdd4" +
                              "712da72eec2533dc00f8529c3a0bbb4103282" +
                              "f0d894d5f34e9f0103c473dce9f4b457a5dee" +
                              "fd8f920d8681ed6dfcb0a81e96bd9b176525a" +
                              "26e0b3")]

public class FileUtilities
{
   internal static string AppendDirectorySeparator(string dir)
   {
      if (! dir.Trim().EndsWith(Path.DirectorySeparatorChar.ToString()))
         return dir.Trim() + Path.DirectorySeparatorChar;
      else
         return dir;
   }
}
'
' The source code should be saved in a file named Example1.cs. It 
' can be compiled at the command line as follows:
'
'    vbc Assembly1.vb /t:library /keyfile:<snkfilename> 
'
' The public key of the Friend1 file should be changed to the full
' public key stored in your strong-named key file.
'
Imports System.IO
Imports System.Runtime.CompilerServices

<Assembly:InternalsVisibleTo("Friend1, PublicKey=002400000480000094" + _
                             "0000000602000000240000525341310004000" + _
                             "001000100bf8c25fcd44838d87e245ab35bf7" + _
                             "3ba2615707feea295709559b3de903fb95a93" + _
                             "3d2729967c3184a97d7b84c7547cd87e435b5" + _
                             "6bdf8621bcb62b59c00c88bd83aa62c4fcdd4" + _
                             "712da72eec2533dc00f8529c3a0bbb4103282" + _
                             "f0d894d5f34e9f0103c473dce9f4b457a5dee" + _
                             "fd8f920d8681ed6dfcb0a81e96bd9b176525a" + _
                             "26e0b3")>

Public Class FileUtilities
   Friend Shared Function AppendDirectorySeparator(dir As String) As String
      If Not dir.Trim().EndsWith(Path.DirectorySeparatorChar) Then
         Return dir.Trim() + Path.DirectorySeparatorChar
      Else
         Return dir
      End If   
   End Function
End Class

Se l'esempio seguente viene compilato in un assembly con nome sicuro denominato Friend1, il Example.Main metodo nella Friend1 potere chiamare correttamente il FileUtilities.AppendDirectorySeparator metodo, anche se il metodo è interno al Assembly1 assembly.If the following example is compiled into a strong-named assembly named Friend1, the Example.Main method in Friend1 can successfully call the FileUtilities.AppendDirectorySeparator method, although the method is internal to the Assembly1 assembly. Si noti che se esegue la compilazione nel linguaggio c# dalla riga di comando, è necessario usare il /out opzione del compilatore per garantire che il nome dell'assembly friend è disponibile quando il compilatore associa a riferimenti esterni.Note that if you are compiling in C# from the command line, you must use the /out compiler switch to ensure that the name of the friend assembly is available when the compiler binds to external references.

//
// The assembly that exposes its internal types to this assembly should be
// named Assembly1.dll.
//
// The public key of this assembly should correspond to the public key
// specified in the class constructor of the InternalsVisibleTo attribute in the
// Assembly1 assembly.
//
#using <Assembly1.dll> as_friend

using namespace System;

void main()
{
   String^ dir = L"C:\\Program Files";
   dir = FileUtilities::AppendDirectorySeparator(dir);
   Console::WriteLine(dir);
}
// The example displays the following output:
//       C:\Program Files\
//
// The source code should be saved in a file named Friend1.cs. It 
// can be compiled at the command line as follows:
//
//    csc /r:Assembly1.dll /keyfile:<snkfilename> /out:Friend1.dll Friend1.cs
//
// The public key of the Friend1 assembly should correspond to the public key
// specified in the class constructor of the InternalsVisibleTo attribute in the
// Assembly1 assembly.
//
using System;

public class Example
{
   public static void Main()
   {
      string dir = @"C:\Program Files";
      dir = FileUtilities.AppendDirectorySeparator(dir);
      Console.WriteLine(dir);
   }
}
// The example displays the following output:
//       C:\Program Files\
'
' The source code should be saved in a file named Friend1.vb. It 
' can be compiled at the command line as follows:
'
'    vbc Friend1.vb /r:Assembly1.dll /keyfile:<snkfilename> 
'
' The public key of the Friend1 assembly should correspond to the public key
' specified in the class constructor of the InternalsVisibleTo attribute in the
' Assembly1 assembly.
'
Module Example
   Public Sub Main()
      Dim dir As String = "C:\Program Files"
      dir = FileUtilities.AppendDirectorySeparator(dir)
      Console.WriteLine(dir)
   End Sub
End Module
' The example displays the following output:
'       C:\Program Files\

Assembly non firmatiUnsigned assemblies

L'esempio seguente usa il InternalsVisibleToAttribute attributi per rendere un internal unsigned di membro di un assembly non firmato visibile a un altro assembly.The following example uses the InternalsVisibleToAttribute attribute to make an internal member of an unsigned assembly visible to another unsigned assembly. L'attributo assicura che il internal StringLib.IsFirstLetterUpperCase metodo in un assembly denominato UtilityLib è visibile al codice in un assembly denominato Friend2.The attribute ensures that the internal StringLib.IsFirstLetterUpperCase method in an assembly named UtilityLib is visible to the code in an assembly named Friend2. Di seguito è riportato il codice sorgente per UtilityLib.dll:The following is the source code for UtilityLib.dll:

using System;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleToAttribute("Friend2")]

namespace Utilities.StringUtilities
{
   public class StringLib
   {
      internal static bool IsFirstLetterUpperCase(String s)
      {
         string first = s.Substring(0, 1);
         return first == first.ToUpper();
      }
   }
}

Imports System.Runtime.CompilerServices

<assembly: InternalsVisibleTo("Friend2")>

Namespace Utilities.StringUtilities
   Public Class StringLib
      Friend Shared Function IsFirstLetterUpperCase(s As String) As Boolean
         Dim first As String = s.Substring(0, 1)
         Return first = first.ToUpper()
      End Function
   End Class
End Namespace

Nell'esempio seguente fornisce il codice sorgente per il Friend2 assembly.The following example provides the source code for the Friend2 assembly. Si noti che se esegue la compilazione nel linguaggio c# dalla riga di comando, è necessario usare il /out opzione del compilatore per garantire che il nome dell'assembly friend è disponibile quando il compilatore associa a riferimenti esterni.Note that if you are compiling in C# from the command line, you must use the /out compiler switch to ensure that the name of the friend assembly is available when the compiler binds to external references.

#using <UtilityLib.dll> as_friend

using namespace System;
using namespace Utilities::StringUtilities;

void main()
{
   String^ s = "The Sign of the Four";
   Console::WriteLine(StringLib::IsFirstLetterUpperCase(s));
}
using System;
using Utilities.StringUtilities;

public class Example
{
   public static void Main()
   {
      String s = "The Sign of the Four";
      Console.WriteLine(StringLib.IsFirstLetterUpperCase(s));
   }
}
Imports Utilities.StringUtilities

Module Example
   Public Sub Main()
      Dim s As String = "The Sign of the Four"
      Console.WriteLine(StringLib.IsFirstLetterUpperCase(s))
   End Sub
End Module

Commenti

In genere, i tipi e membri con internal oppure private protected ambito (in C#) e Friend e Private Protected ambito (in Visual Basic) sono visibili solo nell'assembly in cui sono definiti.Ordinarily, types and members with internal or private protected scope (in C#) and Friend and Private Protected scope (in Visual Basic) are visible only in the assembly in which they are defined. Il InternalsVisibleToAttribute attributo li rende visibile anche ai tipi in un assembly specificato, che è noto come un assembly friend.The InternalsVisibleToAttribute attribute makes them also visible to the types in a specified assembly, which is known as a friend assembly. Ciò si applica solo ai internal (Friend in Visual Basic) o private protected(Private Protected in Visual Basic), solo i metodi, ma non private quelle.This only applies to internal (Friend in VB) or private protected(Private Protected in VB) methods only, but not private ones.

L'attributo viene applicato a livello di assembly.The attribute is applied at the assembly level. Ciò significa che può essere incluso all'inizio del file del codice sorgente, o può essere incluso nel file AssemblyInfo in un progetto di Visual Studio.This means that it can be included at the beginning of a source code file, or it can be included in the AssemblyInfo file in a Visual Studio project. È possibile usare l'attributo per specificare un solo assembly friend che possono accedere i tipi e membri interni dell'assembly corrente.You can use the attribute to specify a single friend assembly that can access the internal types and members of the current assembly. È possibile definire più assembly friend in due modi.You can define multiple friend assemblies in two ways. Possono essere visualizzati come singoli attributi a livello di assembly, come illustrato nell'esempio seguente.They can appear as individual assembly-level attributes, as the following example illustrates.

[assembly:InternalsVisibleTo("Friend1a")]
[assembly:InternalsVisibleTo("Friend1b")]
<assembly:InternalsVisibleTo("Friend1a")>
<assembly:InternalsVisibleTo("Friend1b")>

Possono apparire anche con separato InternalsVisibleToAttribute tag, ma un singolo assembly (parola chiave), come illustrato nell'esempio seguente viene illustrato.They can also appear with separate InternalsVisibleToAttribute tags but a single assembly keyword, as the following example illustrates.

[assembly:InternalsVisibleTo("Friend2a"), 
          InternalsVisibleTo("Friend2b")]
<Assembly:InternalsVisibleTo("Friend2a"), _
 Assembly:InternalsVisibleTo("Friend2b")>

Assembly friend è identificato dal InternalsVisibleToAttribute costruttore.The friend assembly is identified by the InternalsVisibleToAttribute constructor. L'assembly corrente e l'assembly friend devono essere entrambi non firmati o entrambi gli assembly devono essere firmati con un nome sicuro.Both the current assembly and the friend assembly must be unsigned, or both assemblies must be signed with a strong name.

Se entrambi gli assembly non firmati, la assemblyName argomento costituito dal nome dell'assembly friend specificato senza estensione di nome file o percorso di directory.If both assemblies are unsigned, the assemblyName argument consists of the name of the friend assembly, specified without a directory path or file name extension.

Se entrambi gli assembly vengono firmati con un nome sicuro nome, l'argomento di InternalsVisibleToAttribute costruttore deve essere costituito il nome dell'assembly senza la relativa directory file o percorso nome estensione, insieme a chiave pubblica completa (e non il relativo token di chiave pubblica).If both assemblies are signed with a strong name, the argument to the InternalsVisibleToAttribute constructor must consist of the name of the assembly without its directory path or file name extension, along with the full public key (and not its public key token). Per ottenere la chiave pubblica completa di un assembly con nome sicuro, vedere la ottenere la chiave pubblica completa sezione più avanti in questo articolo.To get the full public key of a strong-named assembly, see the Getting the full public key section later in this article. Per altre informazioni sull'uso InternalsVisibleToAttribute con assembly con nome sicuro, vedere il InternalsVisibleToAttribute costruttore.For more information about using InternalsVisibleToAttribute with strong-named assemblies, see the InternalsVisibleToAttribute constructor.

Non includere valori per il CultureInfo, Version, o ProcessorArchitecture campo nell'argomento; i compilatori Visual Basic, c# e C++ trattarlo come un errore del compilatore.Do not include values for the CultureInfo, Version, or ProcessorArchitecture field in the argument; the Visual Basic, C#, and C++ compilers treat this as a compiler error. Se si usa un compilatore che non viene considerato un errore (ad esempio la Assembler IL (ILAsm.exe)) e gli assembly sono sicuro, un MethodAccessException eccezione al primo accesso assembly friend specificato il assembly che contiene il InternalsVisibleToAttribute attributo.If you use a compiler that does not treat it as an error (such as the IL Assembler (ILAsm.exe)) and the assemblies are strong-named, a MethodAccessException exception is thrown the first time the specified friend assembly accesses the assembly that contains the InternalsVisibleToAttribute attribute.

Per altre informazioni su come usare questo attributo, vedere gli argomenti seguenti:For more information about how to use this attribute, see the following topics:

Ottenere la chiave pubblica completaGetting the full public key

È possibile usare la strumento nome sicuro (Sn.exe) per recuperare la chiave pubblica completa da un file chiave con nome sicuro (snk).You can use the Strong Name Tool (Sn.exe) to retrieve the full public key from a strong-named key (.snk) file. A tale scopo, attenersi alla procedura seguente:To do this, you perform the following steps:

  1. Estrarre la chiave pubblica dal file di chiave assembly con nome sicuro in un file separato:Extract the public key from the strong-named key file to a separate file:

    Sn -p snk_file outfileSn -p snk_file outfile

  2. Visualizzare la chiave pubblica completa nella console:Display the full public key to the console:

    *Sn - tp***FileOutSn -tp outfile

  3. Copiare e incollare il valore della chiave pubblico completa nel codice sorgente.Copy and paste the full public key value into your source code.

La compilazione dell'assembly friend con c#Compiling the friend assembly with C#

Se si usa il compilatore c# per compilare l'assembly friend, è necessario specificare esplicitamente il nome del file di output (.exe o DLL) usando il /out opzione del compilatore.If you use the C# compiler to compile the friend assembly, you must explicitly specify the name of the output file (.exe or .dll) by using the /out compiler option. Il compilatore non ha infatti ancora generato il nome dell'assembly in fase di compilazione quando crea l'associazione a riferimenti esterni.This is required because the compiler has not yet generated the name for the assembly it is building at the time it is binding to external references. Il /out l'opzione del compilatore è facoltativa per il compilatore Visual Basic e il corrispondente -out o -o opzione del compilatore non deve essere usata durante la compilazione di tipo friend gli assembly con il F# compilatore.The /out compiler option is optional for the Visual Basic compiler, and the corresponding -out or -o compiler option should not be used when compiling friend assemblies with the F# compiler.

La compilazione dell'assembly friend con C++Compiling the friend assembly with C++

In C++, per rendere i membri interni abilitati per il InternalsVisibleToAttribute attributo accessibile a un assembly friend, è necessario usare il as_friend attributo della direttiva di C++.In C++, in order to make the internal members enabled by the InternalsVisibleToAttribute attribute accessible to a friend assembly, you must use the as_friend attribute in the C++ directive. Per altre informazioni, vedere gli assembly Friend (C++).For more information, see Friend Assemblies (C++).

Costruttori

InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String) InternalsVisibleToAttribute(String)

Inizializza una nuova istanza della classe InternalsVisibleToAttribute con il nome dell'assembly Friend specificato.Initializes a new instance of the InternalsVisibleToAttribute class with the name of the specified friend assembly.

Proprietà

AllInternalsVisible AllInternalsVisible AllInternalsVisible AllInternalsVisible

Questa proprietà non è implementata.This property is not implemented.

AssemblyName AssemblyName AssemblyName AssemblyName

Ottiene il nome dell'assembly Friend al quale vengono resi visibili tutti i tipi e i membri dei tipi contrassegnati con la parola chiave internal.Gets the name of the friend assembly to which all types and type members that are marked with the internal keyword are to be made visible.

TypeId TypeId TypeId TypeId

Quando è implementata in una classe derivata, ottiene un identificatore univoco della classe Attribute.When implemented in a derived class, gets a unique identifier for this Attribute.

(Inherited from Attribute)

Metodi

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value that indicates whether this instance is equal to a specified object.

(Inherited from Attribute)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Restituisce il codice hash per l'istanza.Returns the hash code for this instance.

(Inherited from Attribute)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute() IsDefaultAttribute()

In caso di override in una classe derivata, indica se il valore di questa istanza è il valore predefinito per la classe derivata.When overridden in a derived class, indicates whether the value of this instance is the default value for the derived class.

(Inherited from Attribute)
Match(Object) Match(Object) Match(Object) Match(Object)

Quando è sottoposto a override in una classe derivata, restituisce un valore che indica se questa istanza equivale a un oggetto specificato.When overridden in a derived class, returns a value that indicates whether this instance equals a specified object.

(Inherited from Attribute)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Implementazioni dell'interfaccia esplicita

_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr) _Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un set corrispondente di ID dispatch.Maps a set of names to a corresponding set of dispatch identifiers.

(Inherited from Attribute)
_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr) _Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sul tipo relative a un oggetto, che possono essere usate per ottenere informazioni sul tipo relative a un'interfaccia.Retrieves the type information for an object, which can be used to get the type information for an interface.

(Inherited from Attribute)
_Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32) _Attribute.GetTypeInfoCount(UInt32)

Recupera il numero delle interfacce di informazioni sul tipo fornite da un oggetto (0 o 1).Retrieves the number of type information interfaces that an object provides (either 0 or 1).

(Inherited from Attribute)
_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr) _Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso a proprietà e metodi esposti da un oggetto.Provides access to properties and methods exposed by an object.

(Inherited from Attribute)

Si applica a