Procedura dettagliata: incorporamento dei tipi da assembly gestiti (C# e Visual Basic)

Articolo
08/11/2011

Se si incorporano informazioni sui tipi da un assembly gestito con nome sicuro, è possibile creare un'associazione debole dei tipi in un'applicazione per ottenere l'indipendenza dalla versione. Ovvero, è possibile scrivere il programma in modo che utilizzi i tipi di più versioni di una libreria gestita senza doverlo ricompilare per ogni versione.

L'incorporamento dei tipi viene utilizzato di frequente con l'interoperabilità COM, ad esempio un'applicazione che utilizza oggetti di automazione di Microsoft Office. L'incorporamento di informazioni sui tipi consente alla stessa build di un programma di utilizzare versioni diverse di Microsoft Office in computer diversi. Tuttavia, è inoltre possibile utilizzare l'incorporamento dei tipi con una soluzione completamente gestita.

Le informazioni sui tipi possono essere incorporate da un assembly con le caratteristiche seguenti:

L'assembly espone almeno un'interfaccia pubblica.
Le interfacce incorporate vengono annotate con un attributo ComImport, un attributo Guid e un GUID univoco.
L'assembly viene annotato con l'attributo ImportedFromTypeLib o PrimaryInteropAssembly e con un attributo Guid a livello di assembly. Per impostazione predefinita, i modelli di progetti Visual Basic e Visual C# includono un attributo Guid a livello di assembly.

Dopo avere specificato le interfacce pubbliche che possono essere incorporate, è possibile creare classi di runtime che implementano tali interfacce. Un programma client è quindi in grado di incorporare le informazioni sui tipi per tali interfacce in fase di progettazione facendo riferimento all'assembly contenente le interfacce pubbliche e impostando la proprietà Embed Interop Types del riferimento su True. Questa operazione equivale a utilizzare il compilatore della riga di comando e a fare riferimento all'assembly utilizzando l'opzione del compilatore /link. Il programma client è quindi in grado di caricare le istanze degli oggetti di runtime tipizzati come tali interfacce. Se si crea una nuova versione dell'assembly di runtime con nome sicuro, non è necessario ricompilare il programma client con l'assembly di runtime aggiornato. Al contrario, il programma client continua a utilizzare qualsiasi versione disponibile dell'assembly di runtime, utilizzando le informazioni sui tipi incorporate per le interfacce pubbliche.

Poiché la funzione primaria dell'incorporamento di tipi è fornire supporto per l'incorporamento delle informazioni sui tipi dagli assembly di interoperabilità COM, quando si incorporano informazioni sul tipo in una soluzione completamente gestita si applicano le limitazioni riportate di seguito.

Solo gli attributi specifici di interoperabilità COM vengono incorporati; gli altri attributi vengono ignorati.
Se un tipo utilizza parametri generici e il tipo del parametro generico è un tipo incorporato, tale tipo non potrà essere utilizzato oltre il confine dell'assembly. Fra gli esempi di attraversamento del confine di un assembly sono inclusi la chiamata a un metodo da un altro assembly o la derivazione di un tipo da un tipo definito in un altro assembly.
Le costanti non vengono incorporate.
La classe System.Collections.Generic.Dictionary<TKey, TValue> non supporta un tipo incorporato come chiave. È possibile implementare un tipo di dizionario specifico per supportare un tipo incorporato come chiave.

In questa procedura dettagliata, verranno effettuate le seguenti operazioni:

Creazione di un assembly con nome sicuro che dispone di un'interfaccia pubblica contenente informazioni sui tipi che possono essere incorporate.
Creazione di un assembly di runtime con nome sicuro che implementa tale interfaccia pubblica.
Creazione di un programma client che incorpora le informazioni sui tipi dall'interfaccia pubblica e crea un'istanza della classe dall'assembly di runtime.
Modifica e ricompilazione dell'assembly di runtime.
Esecuzione del programma client per verificare che la nuova versione dell'assembly di runtime sia in uso senza dover ricompilare il programma client.

Nota

Nel computer in uso è possibile che vengano visualizzati nomi o percorsi diversi per alcuni elementi dell'interfaccia utente di Visual Studio nelle istruzioni seguenti. La versione di Visual Studio in uso e le impostazioni configurate determinano questi elementi. Per ulteriori informazioni vedere Impostazioni di Visual Studio.

Creazione di un'interfaccia

Per creare il progetto di interfaccia di equivalenza del tipo

Scegliere Nuovo dal menu File di Visual Studio, quindi fare clic su Progetto.
Nel riquadro Tipi progetto della finestra di dialogo Nuovo progetto verificare che sia selezionata la voce Finestre. Selezionare Libreria di classi nel riquadro Modelli. Nella casella Nome digitare TypeEquivalenceInterface, quindi fare clic su OK. Verrà creato il nuovo progetto.
In Esplora soluzioni fare clic con il pulsante destro del mouse sul file Class1.vb o Class1.cs e scegliere Rinomina. Rinominare il file ISampleInterface.vb o ISampleInterface.cs e premere INVIO. Rinominando il file, anche la classe verrà rinominata ISampleInterface. Questa classe rappresenterà l'interfaccia pubblica per la classe.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceInterface e scegliere Proprietà. Fare clic sulla scheda Compilazione in Visual Basic o sulla scheda Compilazione in Visual C#. Impostare il percorso di output su una posizione valida nel computer di sviluppo, ad esempio C:\TypeEquivalenceSample. Questa posizione verrà utilizzata anche in un passaggio successivo di questa procedura dettagliata.
Durante la modifica delle proprietà del progetto, fare clic sulla scheda Firma in corso. Selezionare l'opzione Firma assembly. Nell'elenco Scegli un file chiave con nome sicuro fare clic su <Nuova...>. Nella casella Nome file di chiave digitare key.snk. Deselezionare la casella di controllo Proteggi file di chiave con una password. Scegliere OK.

Aprire il file ISampleInterface.vb o ISampleInterface.cs. Aggiungere il codice seguente al file della classe ISampleInterface per creare l'interfaccia ISampleInterface.

Imports System.Runtime.InteropServices

<ComImport()>
<Guid("8DA56996-A151-4136-B474-32784559F6DF")>
Public Interface ISampleInterface
    Sub GetUserInput()
    ReadOnly Property UserInput As String


...


End Interface

using System;
using System.Runtime.InteropServices;

namespace TypeEquivalenceInterface
{
    [ComImport]
    [Guid("8DA56996-A151-4136-B474-32784559F6DF")]
    public interface ISampleInterface
    {
        void GetUserInput();
        string UserInput { get; }


...


    }
}

Scegliere Crea GUID dal menu Strumenti. Nella finestra di dialogo Crea GUID fare clic sull'opzione relativa al formato del registro, quindi su Copia. Fare clic su Esci.
Nell'attributo Guid eliminare il GUID di esempio e incollare il GUID copiato dalla finestra di dialogo Crea GUID. Rimuovere le parentesi ({}) dal GUID copiato.
Scegliere Mostra tutti i file dal menu Progetto di Visual Basic. Saltare questo passaggio se si utilizza Visual C#.
In Esplora soluzioni espandere la cartella Progetto se si utilizza Visual Basic. Espandere la cartella Proprietà se si utilizza Visual C#. Fare doppio clic sul file AssemblyInfo.vb o AssemblyInfo.cs. Aggiungere l'attributo seguente al file.
```
<Assembly: ImportedFromTypeLib("")> 
```
```
[assembly: ImportedFromTypeLib("")]
```
Salvare il file.
Salvare il progetto.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceInterface e scegliere Compila. Il file con estensione dll della libreria di classi verrà compilato e salvato nel percorso di output di compilazione specificato (ad esempio, C:\TypeEquivalenceSample).

Creazione di una classe di runtime

Per creare il progetto di runtime di equivalenza del tipo

Scegliere Nuovo dal menu File di Visual Studio, quindi fare clic su Progetto.
Nel riquadro Tipi progetto della finestra di dialogo Nuovo progetto verificare che sia selezionata la voce Finestre. Selezionare Libreria di classi nel riquadro Modelli. Nella casella Nome digitare TypeEquivalenceRuntime, quindi fare clic su OK. Verrà creato il nuovo progetto.
In Esplora soluzioni fare clic con il pulsante destro del mouse sul file Class1.vb o Class1.cs e scegliere Rinomina. Rinominare il file SampleClass.vb o SampleClass.cs e premere INVIO. Rinominando il file, anche la classe viene rinominata SampleClass. Questa classe implementerà l'interfaccia ISampleInterface.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceRuntime e scegliere Proprietà. Fare clic sulla scheda Compilazione in Visual Basic o sulla scheda Compilazione in Visual C#. Impostare il percorso di output sulla stessa posizione utilizzata nel progetto TypeEquivalenceInterface, ad esempio, C:\TypeEquivalenceSample.
Durante la modifica delle proprietà del progetto, fare clic sulla scheda Firma in corso. Selezionare l'opzione Firma assembly. Nell'elenco Scegli un file chiave con nome sicuro fare clic su <Nuova...>. Nella casella Nome file di chiave digitare key.snk. Deselezionare la casella di controllo Proteggi file di chiave con una password. Scegliere OK.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceRuntime e scegliere Aggiungi riferimento. Fare clic sulla scheda Sfoglia e passare alla cartella del percorso di output. Selezionare il file TypeEquivalenceInterface.dll e scegliere OK.
Scegliere Mostra tutti i file dal menu Progetto di Visual Basic. Saltare questo passaggio se si utilizza Visual C#.
In Esplora soluzioni espandere la cartella Riferimenti. Selezionare il riferimento TypeEquivalenceInterface. Nella finestra Proprietà del riferimento TypeEquivalenceInterface impostare la proprietà Versione specifica su False.

Aggiungere il codice seguente al file della classe SampleClass per creare la classe SampleClass.

Imports TypeEquivalenceInterface

Public Class SampleClass
    Implements ISampleInterface

    Private p_UserInput As String
    Public ReadOnly Property UserInput() As String Implements ISampleInterface.UserInput
        Get
            Return p_UserInput
        End Get
    End Property

    Public Sub GetUserInput() Implements ISampleInterface.GetUserInput
        Console.WriteLine("Please enter a value:")
        p_UserInput = Console.ReadLine()
    End Sub


...


End Class

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TypeEquivalenceInterface;

namespace TypeEquivalenceRuntime
{
    public class SampleClass : ISampleInterface
    {
        private string p_UserInput;
        public string UserInput { get { return p_UserInput; } }

        public void GetUserInput()
        {
            Console.WriteLine("Please enter a value:");
            p_UserInput = Console.ReadLine();
        }


...


    }
}

Salvare il progetto.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceRuntime e scegliere Compila. Il file con estensione dll della libreria di classi verrà compilato e salvato nel percorso di output di compilazione specificato (ad esempio, C:\TypeEquivalenceSample).

Creazione di un progetto client

Per creare il progetto client di equivalenza del tipo

Scegliere Nuovo dal menu File di Visual Studio, quindi fare clic su Progetto.
Nel riquadro Tipi progetto della finestra di dialogo Nuovo progetto verificare che sia selezionata la voce Finestre. Selezionare Applicazione console nel riquadro Modelli. Nella casella Nome digitare TypeEquivalenceClient, quindi fare clic su OK. Verrà creato il nuovo progetto.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceClient e scegliere Proprietà. Fare clic sulla scheda Compilazione in Visual Basic o sulla scheda Compilazione in Visual C#. Impostare il percorso di output sulla stessa posizione utilizzata nel progetto TypeEquivalenceInterface, ad esempio, C:\TypeEquivalenceSample.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceClient e scegliere Aggiungi riferimento. Fare clic sulla scheda Sfoglia e passare alla cartella del percorso di output. Selezionare il file TypeEquivalenceInterface.dll (non TypeEquivalenceRuntime.dll) e fare clic su OK.
Scegliere Mostra tutti i file dal menu Progetto di Visual Basic. Saltare questo passaggio se si utilizza Visual C#.
In Esplora soluzioni espandere la cartella Riferimenti. Selezionare il riferimento TypeEquivalenceInterface. Nella finestra Proprietà del riferimento TypeEquivalenceInterface impostare la proprietà Incorpora tipi di interoperabilità su True.

Aggiungere il codice seguente al file Module1.vb o Program.cs per creare il programma client.

Imports TypeEquivalenceInterface
Imports System.Reflection

Module Module1

    Sub Main()
        Dim sampleAssembly = Assembly.Load("TypeEquivalenceRuntime")
        Dim sampleClass As ISampleInterface = CType( _
            sampleAssembly.CreateInstance("TypeEquivalenceRuntime.SampleClass"), ISampleInterface)
        sampleClass.GetUserInput()
        Console.WriteLine(sampleClass.UserInput)
        Console.WriteLine(sampleAssembly.GetName().Version)
        Console.ReadLine()
    End Sub

End Module

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TypeEquivalenceInterface;
using System.Reflection;

namespace TypeEquivalenceClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Assembly sampleAssembly = Assembly.Load("TypeEquivalenceRuntime");
            ISampleInterface sampleClass = 
                (ISampleInterface)sampleAssembly.CreateInstance("TypeEquivalenceRuntime.SampleClass");
            sampleClass.GetUserInput();
            Console.WriteLine(sampleClass.UserInput);
            Console.WriteLine(sampleAssembly.GetName().Version.ToString());
            Console.ReadLine();
        }
    }
}

Premere CTRL+F5 per compilare ed eseguire il programma.

Modifica dell'interfaccia

Per modificare l'interfaccia

In Visual Studio scegliere Apri dal menu File, quindi fare clic su Progetto/Soluzione.
Nella finestra di dialogo Apri progetto fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceInterface, quindi scegliere Proprietà. Fare clic sulla scheda Applicazione. Fare clic sul pulsante Informazioni assembly. Impostare i valori Versione assembly e Versione file su 2.0.0.0.
Aprire il file ISampleInterface.vb o ISampleInterface.cs. Aggiungere la seguente riga di codice all'interfaccia ISampleInterface.
```
Function GetDate() As Date
```
```
DateTime GetDate();
```
Salvare il file.
Salvare il progetto.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceInterface e scegliere Compila. Una nuova versione del file con estensione dll della libreria di classi verrà compilato e salvato nel percorso di output di compilazione specificato (ad esempio, C:\TypeEquivalenceSample).

Modifica della classe di runtime

Per modificare la classe di runtime

In Visual Studio scegliere Apri dal menu File, quindi fare clic su Progetto/Soluzione.
Nella finestra di dialogo Apri progetto fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceRuntime e scegliere Proprietà. Fare clic sulla scheda Applicazione. Fare clic sul pulsante Informazioni assembly. Impostare i valori Versione assembly e Versione file su 2.0.0.0.

Aprire il file SampleClass.vb o SampleClass.cs. Aggiungere le righe di codice seguenti alla classe SampleClass.

Public Function GetDate() As DateTime Implements ISampleInterface.GetDate
    Return Now
End Function

public DateTime GetDate()
{
    return DateTime.Now;
}

Salvare il file.

Salvare il progetto.
Fare clic con il pulsante destro del mouse sul progetto TypeEquivalenceRuntime e scegliere Compila. Una versione aggiornata del file con estensione dll della libreria di classi verrà compilato e salvato nel percorso di output di compilazione specificato in precedenza (ad esempio, C:\TypeEquivalenceSample).
In Esplora risorse aprire la cartella del percorso di output (ad esempio, C:\TypeEquivalenceSample). Fare doppio clic su TypeEquivalenceClient.exe per eseguire il programma. Il programma rifletterà la nuova versione dell'assembly TypeEquivalenceRuntime senza essere stato ricompilato.

Vedere anche