Genomgång: Bädda in typer från hanterade sammansättningar i Visual Studio

Artikel
04/08/2023

Om du bäddar in typinformation från en starkt namngiven hanterad sammansättning kan du lösa parkopplingstyper i ett program för att uppnå versionsberoende. Programmet kan alltså skrivas för att använda typer från valfri version av ett hanterat bibliotek utan att behöva kompileras om för varje ny version.

Inbäddning av typ används ofta med COM-interop, till exempel ett program som använder automationsobjekt från Microsoft Office. Med information om inbäddningstyper kan samma version av ett program fungera med olika versioner av Microsoft Office på olika datorer. Men du kan också använda typinbäddning med fullständigt hanterade lösningar.

När du har angett de offentliga gränssnitt som kan bäddas in skapar du körningsklasser som implementerar dessa gränssnitt. Ett klientprogram kan bädda in typinformationen för gränssnitten vid designtillfället genom att referera till sammansättningen som innehåller de offentliga gränssnitten och ange Embed Interop Types egenskapen för referensen till True. Klientprogrammet kan sedan läsa in instanser av körningsobjekten som skrivits som dessa gränssnitt. Detta motsvarar att använda kommandoradskompilatorn och referera till sammansättningen med hjälp av kompilatoralternativet EmbedInteropTypes.

Om du skapar en ny version av din starka namngivna runtime-sammansättning behöver klientprogrammet inte kompileras om. Klientprogrammet fortsätter att använda den version av körningssammansättningen som är tillgänglig för den, med hjälp av den inbäddade typinformationen för de offentliga gränssnitten.

I den här genomgången:

Skapa en stark namngiven sammansättning med ett offentligt gränssnitt som innehåller typinformation som kan bäddas in.
Skapa en kraftfull runtime-sammansättning som implementerar det offentliga gränssnittet.
Skapa ett klientprogram som bäddar in typinformationen från det offentliga gränssnittet och skapar en instans av klassen från körningssammansättningen.
Ändra och återskapa körningssammansättningen.
Kör klientprogrammet för att se att det använder den nya versionen av körningssammansättningen utan att behöva kompileras om.

Anteckning

Datorn kan visa olika namn eller platser för vissa av Visual Studio-användargränssnittselementen i följande instruktioner. Den Visual Studio-utgåva som du har och de inställningar som du använder avgör dessa element. Mer information finns i Anpassa IDE.

Villkor och begränsningar

Du kan bädda in typinformation från en sammansättning under följande villkor:

Sammansättningen exponerar minst ett offentligt gränssnitt.
De inbäddade gränssnitten kommenteras med ComImport attribut och Guid attribut med unika GUID:er.
Sammansättningen kommenteras med ImportedFromTypeLib attributet eller PrimaryInteropAssembly attributet och ett attribut på sammansättningsnivå Guid . Visual C# och Visual Basic-projektmallarna innehåller som standard ett attribut på sammansättningsnivå Guid .

Eftersom den primära funktionen av typen inbäddning är att stödja COM-interop-sammansättningar gäller följande begränsningar när du bäddar in typinformation i en fullständigt hanterad lösning:

Endast attribut som är specifika för COM-interop är inbäddade. Andra attribut ignoreras.
Om en typ använder generiska parametrar och typen av den generiska parametern är en inbäddad typ kan den typen inte användas över en sammansättningsgräns. Exempel på att korsa en sammansättningsgräns är att anropa en metod från en annan sammansättning eller härleda en typ från en typ som definierats i en annan sammansättning.
Konstanter är inte inbäddade.
Klassen System.Collections.Generic.Dictionary<TKey,TValue> stöder inte en inbäddad typ som en nyckel. Du kan implementera din egen ordlistetyp för att stödja en inbäddad typ som en nyckel.

Skapa ett gränssnitt

Det första steget är att skapa typen ekvivalensgränssnittssammansättning.

I Visual Studio väljer du Nytt>>filprojekt.
I dialogrutan Skapa ett nytt projekt skriver du klassbibliotek i rutan Sök efter mallar . Välj antingen mallen C# eller Visual Basic Class Library (.NET Framework) i listan och välj sedan Nästa.
I dialogrutan Konfigurera ditt nya projekt , under Projektnamn, skriver du TypeEquivalenceInterface och väljer sedan Skapa. Det nya projektet skapas.
I Solution Explorer högerklickar du på filen Class1.cs eller Class1.vb, väljer Byt namn och byter namn på filen från Klass1 till ISampleInterface. Svara Ja på uppmaningen om att även byta namn på klassen till ISampleInterface. Den här klassen representerar det offentliga gränssnittet för klassen.
I Solution Explorer högerklickar du på projektet TypeEquivalenceInterface och väljer sedan Egenskaper.
Välj Skapa i den vänstra rutan på skärmen Egenskaper och ange utdatasökvägen till en plats på datorn, till exempel C:\TypeEquivalenceSample. Du använder samma plats under den här genomgången.
Välj Skapa>stark namngivning i den vänstra rutan på skärmen Egenskaper och markera sedan kryssrutan Signera sammansättningen . I filen Stark namnnyckel väljer du Bläddra.
Gå till och välj filen key.snk som du skapade i TypeEquivalenceInterface-projektet och välj sedan OK. Mer information finns i Skapa ett offentligt-privat nyckelpar.

Öppna klassfilen ISampleInterface i kodredigeraren och ersätt dess innehåll med följande kod för att skapa ISampleInterface gränssnittet:

using System;
using System.Runtime.InteropServices;

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

Imports System.Runtime.InteropServices

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

På menyn Verktyg väljer du Skapa guid och i dialogrutan Skapa GUID väljer du Registerformat. Välj Kopiera och välj sedan Avsluta.
Guid I attributet för koden ersätter du exempel-GUID:t med det GUID som du kopierade och tar bort klammerparenteserna ({ }).
I Solution Explorer expanderar du mappen Egenskaper och väljer filen AssemblyInfo.cs eller AssemblyInfo.vb. Lägg till följande attribut i filen i kodredigeraren:
```
[assembly: ImportedFromTypeLib("")]
```
```
<Assembly: ImportedFromTypeLib("")>
```
Välj Spara>alla eller tryck på Ctrl+Skift+S för att spara filerna och projektet.
I Solution Explorer högerklickar du på Projektet TypeEquivalenceInterface och väljer Skapa. DLL-filen för klassbiblioteket kompileras och sparas i den angivna utdatasökvägen för bygget, till exempel C:\TypeEquivalenceSample.

Skapa en körningsklass

Skapa sedan körningsklassen type equivalence.

I Visual Studio väljer du Nytt>>filprojekt.
I dialogrutan Skapa ett nytt projekt skriver du klassbibliotek i rutan Sök efter mallar . Välj antingen mallen C# eller Visual Basic Class Library (.NET Framework) i listan och välj sedan Nästa.
I dialogrutan Konfigurera det nya projektet , under Projektnamn, skriver du TypeEquivalenceRuntime och väljer sedan Skapa. Det nya projektet skapas.
I Solution Explorer högerklickar du på filen Class1.cs eller Class1.vb, väljer Byt namn och byter namn på filen från Klass1 till SampleClass. Svara Ja på uppmaningen om att även byta namn på klassen till SampleClass. Den här klassen implementerar ISampleInterface gränssnittet.
I Solution Explorer högerklickar du på projektet TypeEquivalenceInterface och väljer Egenskaper.
Välj Skapa i det vänstra fönstret på skärmen Egenskaper och ange sedan utdatasökvägen till samma plats som du använde för TypeEquivalenceInterface-projektet , till exempel C:\TypeEquivalenceSample.
Välj Skapa>stark namngivning i den vänstra rutan på skärmen Egenskaper och markera sedan kryssrutan Signera sammansättningen . I filen Stark namnnyckel väljer du Bläddra.
Gå till och välj filen key.snk som du skapade i TypeEquivalenceInterface-projektet och välj sedan OK. Mer information finns i Skapa ett offentligt-privat nyckelpar.
I Solution Explorer högerklickar du på Projektet TypeEquivalenceRuntime och väljer Lägg till>referens.
I dialogrutan Referenshanterare väljer du Bläddra och bläddrar till mappen utdatasökväg. Välj filenTypeEquivalenceInterface.dll , välj Lägg till och välj sedan OK.
I Solution Explorer expanderar du mappen Referenser och väljer referensen TypeEquivalenceInterface. I fönstret Egenskaper anger du Specifik version till False om den inte redan är det.

Öppna exempelklassklassfilen i kodredigeraren och ersätt dess innehåll med följande kod för att skapa SampleClass klassen:

using System;
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();
        }
    }
}

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

Välj Spara>alla eller tryck på Ctrl+Skift+S för att spara filerna och projektet.
I Solution Explorer högerklickar du på TypeEquivalenceRuntime-projektet och väljer Skapa. DLL-filen för klassbiblioteket kompileras och sparas i den angivna byggutdatasökvägen.

Skapa ett klientprojekt

Slutligen skapar du ett typklientprogram som refererar till gränssnittssammansättningen.

I Visual Studio väljer du Nytt>>filprojekt.
I dialogrutan Skapa ett nytt projekt skriver du konsolen i rutan Sök efter mallar . Välj antingen mallen C# eller Visual Basic Console App (.NET Framework) i listan och välj sedan Nästa.
I dialogrutan Konfigurera ditt nya projekt , under Projektnamn, skriver du TypeEquivalenceClient och väljer sedan Skapa. Det nya projektet skapas.
I Solution Explorer högerklickar du på projektet TypeEquivalenceClient och väljer Egenskaper.
Välj Skapa i det vänstra fönstret på skärmen Egenskaper och ange sedan utdatasökvägen till samma plats som du använde för TypeEquivalenceInterface-projektet, till exempel C:\TypeEquivalenceSample.
I Solution Explorer högerklickar du på projektet TypeEquivalenceClient och väljer Lägg till>referens.
Om denTypeEquivalenceInterface.dll filen redan finns med i dialogrutan Referenshanteraren väljer du den. Annars väljer du Bläddra, bläddrar till mappen utdatasökväg, väljer filenTypeEquivalenceInterface.dll (inte TypeEquivalenceRuntime.dll) och väljer Lägg till. Välj OK.
I Solution Explorer expanderar du mappen Referenser och väljer referensen TypeEquivalenceInterface. I fönstret Egenskaper anger du Bädda in interoptyper till Sant.

Öppna filen Program.cs eller Module1.vb i kodredigeraren och ersätt innehållet med följande kod för att skapa klientprogrammet:

using System;
using System.Reflection;
using TypeEquivalenceInterface;

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();
        }
    }
}

Imports System.Reflection
Imports TypeEquivalenceInterface

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

Välj Spara>alla eller tryck på Ctrl+Skift+S för att spara filerna och projektet.
Tryck på Ctrl+F5 för att skapa och köra programmet. Observera att konsolutdata returnerar sammansättningsversion 1.0.0.0.

Ändra gränssnittet

Ändra nu gränssnittssammansättningen och ändra dess version.

I Visual Studio väljer du Fil>öppna>projekt/lösning och öppnar projektet TypeEquivalenceInterface .
I Solution Explorer högerklickar du på projektet TypeEquivalenceInterface och väljer Egenskaper.
Välj Program i den vänstra rutan på skärmen Egenskaper och välj sedan Sammansättningsinformation.
I dialogrutan Sammansättningsinformation ändrar du värdena för Sammansättningsversion och Filversion till 2.0.0.0 och väljer sedan OK.
Öppna filen SampleInterface.cs eller SampleInterface.vb och lägg till följande kodrad i ISampleInterface gränssnittet:
```
DateTime GetDate();
```
```
Function GetDate() As Date
```
Välj Spara>alla eller tryck på Ctrl+Skift+S för att spara filerna och projektet.
I Solution Explorer högerklickar du på Projektet TypeEquivalenceInterface och väljer Skapa. En ny version av DLL-filen för klassbiblioteket kompileras och sparas i byggutdatasökvägen.

Ändra körningsklassen

Ändra även körningsklassen och uppdatera dess version.

I Visual Studio väljer du Fil>öppna>projekt/lösning och öppnar projektet TypeEquivalenceRuntime .
I Solution Explorer högerklickar du på Projektet TypeEquivalenceRuntime och väljer Egenskaper.
Välj Program i den vänstra rutan på skärmen Egenskaper och välj sedan Sammansättningsinformation.
I dialogrutan Sammansättningsinformation ändrar du värdena för Sammansättningsversion och Filversion till 2.0.0.0 och väljer sedan OK.

Öppna filen SampleClass.cs eller SampleClass.vb och lägg till följande kod i SampleClass klassen:

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

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

Välj Spara>alla eller tryck på Ctrl+Skift+S för att spara filerna och projektet.
I Solution Explorer högerklickar du på TypeEquivalenceRuntime-projektet och väljer Skapa. En ny version av DLL-filen för klassbiblioteket kompileras och sparas i byggutdatasökvägen.

Kör det uppdaterade klientprogrammet

Gå till platsen för utdatamappen för bygget och kör TypeEquivalenceClient.exe. Observera att konsolutdata nu återspeglar den nya versionen av TypeEquivalenceRuntime sammansättningen , 2.0.0.0, utan att programmet kompileras om.

Dela via