Share via

Walkthrough: Typen insluiten uit beheerde assembly's in Visual Studio

  • Artikel

Als u typegegevens uit een beheerde assembly met een sterke naam insluit, kunt u losjes typen koppelen in een toepassing om versie-onafhankelijkheid te bereiken. Dat wil dat uw programma kan worden geschreven om typen uit elke versie van een beheerde bibliotheek te gebruiken zonder dat u voor elke nieuwe versie opnieuw hoeft te worden gecompileerd.

Type insluiten wordt vaak gebruikt met COM-interoperabiliteit, zoals een toepassing die gebruikmaakt van automatiseringsobjecten van Microsoft Office. Als u informatie over het insluittype insluit, kan dezelfde build van een programma werken met verschillende versies van Microsoft Office op verschillende computers. U kunt echter ook type embedding gebruiken met volledig beheerde oplossingen.

Nadat u de openbare interfaces hebt opgegeven die kunnen worden ingesloten, maakt u runtimeklassen waarmee deze interfaces worden geïmplementeerd. Een clientprogramma kan de typegegevens voor de interfaces tijdens het ontwerp insluiten door te verwijzen naar de assembly die de openbare interfaces bevat en de Embed Interop Types eigenschap van de verwijzing in te stellen op True. Het clientprogramma kan vervolgens exemplaren laden van de runtime-objecten die als deze interfaces zijn getypt. Dit komt overeen met het gebruik van de opdrachtregelcomppilatie en het verwijzen naar de assembly met behulp van de optie EmbedInteropTypes compiler.

Als u een nieuwe versie van uw runtime-assembly met een sterke naam maakt, hoeft het clientprogramma niet opnieuw te worden gecompileerd. Het clientprogramma blijft de versie van de runtime-assembly gebruiken die beschikbaar is, met behulp van de ingesloten typegegevens voor de openbare interfaces.

In deze handleiding doet u het volgende:

  1. Maak een assembly met een sterke naam met een openbare interface die typegegevens bevat die kunnen worden ingesloten.
  2. Maak een runtime-assembly met een sterke naam die de openbare interface implementeert.
  3. Maak een clientprogramma dat de typegegevens van de openbare interface insluit en een exemplaar van de klasse maakt vanuit de runtime-assembly.
  4. Wijzig en herbouw de runtime-assembly.
  5. Voer het clientprogramma uit om te zien dat de nieuwe versie van de runtime-assembly wordt gebruikt zonder dat deze opnieuw hoeft te worden gecompileerd.

Notitie

In de volgende instructies kunnen op uw computer verschillende namen of locaties worden weergegeven voor sommige elementen van de gebruikersinterface van Visual Studio. De Visual Studio-editie die u hebt en de instellingen die u gebruikt, bepalen deze elementen. Zie De IDE aanpassen voor meer informatie.

Voorwaarden en beperkingen

U kunt typegegevens van een assembly insluiten onder de volgende voorwaarden:

  • De assembly maakt ten minste één openbare interface beschikbaar.
  • De ingesloten interfaces worden voorzien van ComImport kenmerken en Guid kenmerken met unieke GUID's.
  • De assembly is voorzien van aantekeningen met het ImportedFromTypeLib kenmerk of het PrimaryInteropAssembly kenmerk en een kenmerk op assemblyniveau Guid . De Visual C#- en Visual Basic-projectsjablonen bevatten standaard een kenmerk op assemblyniveau Guid .

Omdat de primaire functie van het insluiten van typen het ondersteunen van COM-interoperabiliteitsassembly's is, gelden de volgende beperkingen wanneer u typegegevens insluit in een volledig beheerde oplossing:

  • Alleen kenmerken die specifiek zijn voor COM-interoperabiliteit worden ingesloten. Andere kenmerken worden genegeerd.
  • Als een type algemene parameters gebruikt en het type van de algemene parameter een ingesloten type is, kan dat type niet worden gebruikt voor een assemblygrens. Voorbeelden van het overschrijden van een assemblygrens zijn het aanroepen van een methode uit een andere assembly of het afleiden van een type dat is gedefinieerd in een andere assembly.
  • Constanten worden niet ingesloten.
  • De System.Collections.Generic.Dictionary<TKey,TValue> klasse biedt geen ondersteuning voor een ingesloten type als sleutel. U kunt uw eigen woordenlijsttype implementeren om een ingesloten type als sleutel te ondersteunen.

Een interface maken

De eerste stap is het maken van de interfaceassembly voor type-equivalentie.

  1. Selecteer in Visual Studio Bestand>Nieuw>Project.

  2. Typ in het dialoogvenster Een nieuw project makenklassenbibliotheek in het vak Sjablonen zoeken . Selecteer de sjabloon C# of Visual Basic Class Library (.NET Framework) in de lijst en selecteer vervolgens Volgende.

  3. Typ in het dialoogvenster Uw nieuwe project configureren onder ProjectnaamTypeEquivalenceInterface en selecteer vervolgens Maken. Het nieuwe project wordt gemaakt.

  4. Klik in Solution Explorer met de rechtermuisknop op het bestand Class1.cs of Class1.vb, selecteer Naam wijzigen en wijzig de naam van het bestand van Class1 in ISampleInterface. Reageren Ja op de prompt om de naam van de klasse ook te wijzigen in ISampleInterface. Deze klasse vertegenwoordigt de openbare interface voor de klasse.

  5. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceInterfaceen selecteer eigenschappen.

  6. Selecteer Build in het linkerdeelvenster van het scherm Eigenschappen en stel het uitvoerpad in op een locatie op uw computer, zoals C:\TypeEquivalenceSample. In dit scenario gebruikt u dezelfde locatie.

  7. Selecteer Sterkenaamgevingmaken> in het linkerdeelvenster van het scherm Eigenschappen en schakel vervolgens het selectievakje De assembly ondertekenen in. Selecteer bladeren in het sleutelbestand Sterke naam.

  8. Navigeer naar het bestand key.snk dat u hebt gemaakt in het project TypeEquivalenceInterface en selecteer ok. Zie Een openbaar-persoonlijk sleutelpaar maken voor meer informatie.

  9. Open het klassebestand ISampleInterface in de code-editor en vervang de inhoud door de volgende code om de ISampleInterface interface te maken:

    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

  10. Selecteer in het menu Extra de optie Guid maken en selecteer in het dialoogvenster GUID maken de optie Registerindeling. Selecteer Kopiëren en vervolgens Afsluiten.

  11. Vervang in het Guid kenmerk van uw code de voorbeeld-GUID door de GUID die u hebt gekopieerd en verwijder de accolades ({ }).

  12. Vouw in Solution Explorer de map Properties uit en selecteer het bestand AssemblyInfo.cs of AssemblyInfo.vb. Voeg in de code-editor het volgende kenmerk toe aan het bestand:

    [assembly: ImportedFromTypeLib("")]

    <Assembly: ImportedFromTypeLib("")>

  13. Selecteer Bestand>Alles opslaan of druk op Ctrl+Shift+S om de bestanden en het project op te slaan.

  14. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceInterface en selecteer Build. Het DLL-bestand van de klassebibliotheek wordt gecompileerd en opgeslagen in het opgegeven build-uitvoerpad, bijvoorbeeld C:\TypeEquivalenceSample.

Een runtime-klasse maken

Maak vervolgens de runtimeklasse van het type equivalentie.

  1. Selecteer in Visual Studio Bestand>Nieuw>Project.

  2. Typ in het dialoogvenster Een nieuw project makenklassenbibliotheek in het vak Sjablonen zoeken . Selecteer de sjabloon C# of Visual Basic Class Library (.NET Framework) in de lijst en selecteer vervolgens Volgende.

  3. Typ in het dialoogvenster Uw nieuwe project configureren onder ProjectnaamTypeEquivalenceRuntime en selecteer vervolgens Maken. Het nieuwe project wordt gemaakt.

  4. Klik in Solution Explorer met de rechtermuisknop op het bestand Class1.cs of Class1.vb, selecteer Naam wijzigen en wijzig de naam van het bestand van Class1 in SampleClass. Reageren Ja op de prompt om de naam van de klasse ook te wijzigen in SampleClass. Met deze klasse wordt de ISampleInterface-interface geïmplementeerd.

  5. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceInterface en selecteer Eigenschappen.

  6. Selecteer Build in het linkerdeelvenster van het scherm Properties en stel vervolgens het uitvoerpad in op dezelfde locatie die u hebt gebruikt voor het project TypeEquivalenceInterface , bijvoorbeeld C:\TypeEquivalenceSample.

  7. Selecteer Sterkenaamgevingmaken> in het linkerdeelvenster van het scherm Eigenschappen en schakel vervolgens het selectievakje De assembly ondertekenen in. Selecteer bladeren in het sleutelbestand Sterke naam.

  8. Navigeer naar het bestand key.snk dat u hebt gemaakt in het project TypeEquivalenceInterface en selecteer ok. Zie Een openbaar-persoonlijk sleutelpaar maken voor meer informatie.

  9. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceRuntime en selecteerVerwijzingtoevoegen>.

  10. Selecteer bladeren in het dialoogvenster Verwijzingsbeheer en blader naar de map met het uitvoerpad. Selecteer het TypeEquivalenceInterface.dll bestand, selecteer Toevoegen en selecteer vervolgens OK.

  11. Vouw in Solution Explorer de map Verwijzingen uit en selecteer de verwijzing TypeEquivalenceInterface. Stel in het deelvenster EigenschappenSpecifieke versie in op Onwaar als dit nog niet heted.

  12. Open het klassebestand SampleClass in de code-editor en vervang de inhoud door de volgende code om de SampleClass klasse te maken:

    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

  13. Selecteer Bestand>Alles opslaan of druk op Ctrl+Shift+S om de bestanden en het project op te slaan.

  14. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceRuntime en selecteer Build. Het DLL-bestand van de klassebibliotheek wordt gecompileerd en opgeslagen in het opgegeven build-uitvoerpad.

Een clientproject maken

Maak ten slotte een clientprogramma voor type-equivalentie dat verwijst naar de interface-assembly.

  1. Selecteer in Visual Studio Bestand>Nieuw>Project.

  2. Typ console in het dialoogvenster Een nieuw project maken in het vak Zoeken naar sjablonen. Selecteer de sjabloon C# of Visual Basic Console App (.NET Framework) in de lijst en selecteer vervolgens Volgende.

  3. Typ in het dialoogvenster Uw nieuwe project configureren onder ProjectnaamTypeEquivalenceClient en selecteer vervolgens Maken. Het nieuwe project wordt gemaakt.

  4. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceClient en selecteer Eigenschappen.

  5. Selecteer Build in het linkerdeelvenster van het scherm Properties en stel vervolgens het uitvoerpad in op dezelfde locatie die u hebt gebruikt voor het project TypeEquivalenceInterface, bijvoorbeeld C:\TypeEquivalenceSample.

  6. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceClient en selecteerVerwijzingtoevoegen>.

  7. Als het TypeEquivalenceInterface.dll-bestand al wordt vermeld in het dialoogvenster Verwijzingsbeheer, selecteert u het. Als dat niet zo is, selecteert u Bladeren, bladert u naar de map met het uitvoerpad, selecteert u het TypeEquivalenceInterface.dll-bestand (niet de TypeEquivalenceRuntime.dll) en selecteert u Toevoegen. Selecteer OK.

  8. Vouw in Solution Explorer de map Verwijzingen uit en selecteer de verwijzing TypeEquivalenceInterface. Stel in het deelvenster Eigenschappeninsluiten interoperabiliteitstypen in op Waar.

  9. Open het bestand Program.cs of Module1.vb in de code-editor en vervang de inhoud door de volgende code om het clientprogramma te maken:

    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

  10. Selecteer Bestand>Alles opslaan of druk op Ctrl+Shift+S om de bestanden en het project op te slaan.

  11. Druk op Ctrl+F5 om het programma te bouwen en uit te voeren. Houd er rekening mee dat de console-uitvoer de assemblyversie 1.0.0.0 retourneert.

De interface wijzigen

Wijzig nu de interfaceassembly en wijzig de versie ervan.

  1. Selecteer in Visual Studio Bestand>openen>project/oplossing en open het project TypeEquivalenceInterface .

  2. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceInterface en selecteer Eigenschappen.

  3. Selecteer Toepassing in het linkerdeelvenster van het scherm Eigenschappen en selecteer vervolgens Assembly-informatie.

  4. Wijzig in het dialoogvenster Assembly-informatie de waarden voor assemblyversie en bestandsversie in 2.0.0.0 en selecteer OK.

  5. Open het bestand SampleInterface.cs of SampleInterface.vb en voeg de volgende regel code toe aan de ISampleInterface interface:

    DateTime GetDate();

    Function GetDate() As Date

  6. Selecteer Bestand>Alles opslaan of druk op Ctrl+Shift+S om de bestanden en het project op te slaan.

  7. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceInterface en selecteer Build. Er wordt een nieuwe versie van het DLL-bestand van de klassebibliotheek gecompileerd en opgeslagen in het build-uitvoerpad.

De runtime-klasse wijzigen

Wijzig ook de runtime-klasse en werk de versie bij.

  1. Selecteer in Visual Studio Bestand>openen>project/oplossing en open het project TypeEquivalenceRuntime .

  2. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceRuntime en selecteer Eigenschappen.

  3. Selecteer Toepassing in het linkerdeelvenster van het scherm Eigenschappen en selecteer vervolgens Assembly-informatie.

  4. Wijzig in het dialoogvenster Assembly-informatie de waarden voor assemblyversie en bestandsversie in 2.0.0.0 en selecteer OK.

  5. Open het bestand SampleClass.cs of SampleClass.vb en voeg de volgende code toe aan de SampleClass klasse:

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

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

  6. Selecteer Bestand>Alles opslaan of druk op Ctrl+Shift+S om de bestanden en het project op te slaan.

  7. Klik in Solution Explorer met de rechtermuisknop op het project TypeEquivalenceRuntime en selecteer Build. Er wordt een nieuwe versie van het DLL-bestand van de klassebibliotheek gecompileerd en opgeslagen in het build-uitvoerpad.

Het bijgewerkte clientprogramma uitvoeren

Ga naar de locatie van de build-uitvoermap en voer TypeEquivalenceClient.exeuit. De console-uitvoer weerspiegelt nu de nieuwe versie van de TypeEquivalenceRuntime assembly, 2.0.0.0, zonder dat het programma opnieuw wordt gecompileerd.

Zie ook