![\"Erstellen](\"..\/fileadmin\/_temp_\/2022_02\/pic_317_001.png\")
<\/p>\nIn der Artikelreihe “YouTube-Kanal mit VB.NET verwalten” haben wir Methoden vorgestellt, mit denen wir die Videos eines YouTube-Kanals auslesen und mit denen wir neue Videos hochladen oder die Eigenschaften bestehender Videos anpassen können. Diese Methoden wollen wir nun in einer DLL zusammenfassen, die wir in eine Office-Anwendung wie Excel oder Access einbinden können, um von dort aus beispielsweise Titel und Beschreibungstexte lesen und schreiben zu können. Im vorliegenden Artikel zeigen wir daher, wie wir die bereits beschriebenen Funktionen in einem neuen Projekt verwenden und daraus die gewünschte DLL erstellen. In einem weiteren Artikel zeigen wir dann, wie Du von Excel aus die Daten der Videos eines Kanals in eine Excel-Tabelle einlesen kannst.<\/b><\/p>\nProjekt für die COM-DLL erstellen<\/h2>\n
Wenn wir eine COM-DLL erstellen wollen, auf die wir von Office-Anwendungen aus per VBA zugreifen können, wählen wir beim Erstellen eines neuen Projekts in Visual Studio den Typ Klassenbibliothek (.NET Framework) – Ein Projekt zum Erstellen einer Klassenbibliothek (.dll) <\/b>und nicht Klassenbibliothek – Ein Projekt zum Erstellen einer Klassenbibliothek für .NET Standard oder .NET Core <\/b>aus (siehe Bild 1). Mit letzterer können wir aktuell keine COM-DLLs erstellen.<\/p>\n
<\/p>\n
Bild 1: Erstellen eines neuen Projekts<\/span><\/b><\/p>\n Im nächsten Schritt wählen wir den Speicherort aus und geben als Projektnamen YouTubeAPIV3 <\/b>an. Als Zielframework wählen wir .NET Core 3.1 <\/b>aus. Das neue Projekt erwartet uns dann in Visual Studio mit einer leeren Klasse namens Class1.vb<\/b>.<\/p>\n Für den Zugriff auf die YouTube-API v3 benötigen wir zwei NuGet-Pakete. Um diese hinzuzufügen, öffnen wir mit Projekt|NuGet-Pakete verwalten… <\/b>den NuGet<\/b>-Bereich. Im Bereich Durchsuchen <\/b>suchen wir nach den beiden Paketen Google.Apis.YouTube.v3 <\/b>und Google.Apis.Oauth2.v2 <\/b>und installieren diese.<\/p>\n Damit die Klasse später als COM-DLL verwendet werden kann, nehmen wir nun einige Einstellungen in den Projekteigenschaften vor. Dazu öffnen wir die Projekteigenschaften mit einem Rechtsklick auf das Projekt im Projektmappen-Explorer und anschließender Auswahl des Eintrags Eigenschaften <\/b>aus dem nun erscheinenden Kontextmenü.<\/p>\n Die erste Einstellung finden wir, wenn wir im Bereich Anwendung <\/b>auf die Schaltfläche Assemblyinformationen…<\/b> klicken. Das öffnet den Dialog Assemblyinformationen<\/b>, wo wir prüfen, ob die Option Assembly COM-sichtbar machen <\/b>aktiviert ist und holen dies gegebenenfalls nach (siehe Bild 2).<\/p>\n Bild 2: Aktivieren von Assembly COM-sichtbar machen<\/span><\/b><\/p>\n Danach klicken wir links auf Kompilieren<\/b>, um den entsprechenden Bereich einzublenden. Hier finden wir unten die Eigenschaft Für COM-Interop registrieren<\/b>, die wir aktivieren (siehe Bild 3).<\/p>\n Bild 3: Aktivieren von Für COM-Interop registrieren<\/span><\/b><\/p>\n Für den Zugriff auf die YouTube API v3 benötigen wir eine Authentifizierung, die wir mit der im Artikel YouTube-Kanal mit VB.NET verwalten, Teil 2 <\/b>(www.vbentwickler.de\/316<\/b>) vorgestellten Klasse realisieren. Dazu fügen wir die dort beschriebene Klasse Authentication.vb <\/b>in unser neues Projekt ein. Damit wir diese von einem VBA-Projekt aus nutzen können, sind jedoch einige Anpassungen nötig. Die erste ist eine tatsächliche Funktionserweiterung. Wir möchten das dabei gewonnene Token für den Zugriff auf die YouTube-API nämlich auch separat abrufen können, um gegebenenfalls einmal von einem VBA-Projekt aus direkt auf die YouTube-API zugreifen zu können.<\/p>\n Für den Betrieb als COM-DLL sind überdies noch weitere Änderungen nötig. Als Erstes benötigen wir einen Verweis auf den folgenden Namespace in jeder Klasse, die wir von VBA aus initialisieren und nutzen wollen:<\/p>\n Dies ermöglicht es uns, die zu veröffentlichenden Klassen so auszuzeichnen, dass wir von außen auf diese zugreifen können. <\/p>\n Wenn wir eine Klasse einfach nach außen hin veröffentlichen, dann können wir beispielsweise von VBA aus immer noch auf einige .NET-Standard-Eigenschaften und -Methoden der Klasse zugreifen wie GetHashCode<\/b>, GetType <\/b>oder ToString<\/b>. Wir wollen jedoch nur die von uns dafür vorgesehenen Eigenschaften und Methoden anbieten. Dazu müssen wir eine Schnittstelle erstellen, die wir dann in Form der eigentlichen Klasse implementieren.<\/p>\n Unsere Klasse Authentication.vb <\/b>soll zwei Funktionen veröffentlichen: Die erste liefert das YouTubeService<\/b>-Element und die zweite soll den beim Erstellen des YouTubeService<\/b>-Elements generierten Token liefern und heißt Token<\/b>. Die Schnittstelle statten wir daher genau mit der Definition dieser beiden Funktionen aus:<\/p>\n Wie Du siehst, zeichnen wir diese Schnittstelle mit der Annotation InterFaceType <\/b>aus, der wir den Wert ComInterfaceType.InterfaceIsDual <\/b>zuweisen. Was dies bedeutet, schauen wir uns in einem anderen Beitrag im Detail an.<\/p>\n Die Klasse Authenticate<\/b>, die wir in der gleichen Datei wie die Schnittstelle IAuthenticate <\/b>speichern (Authenticate.vb<\/b>), findest Du in Listing 1. Diese Klasse kennzeichnen wir ebenfalls mit der Annotation ClassInterface<\/b>. Für diese legen wir jedoch den Wert ClassInterfaceType.None <\/b>fest. Das sorgt dafür, dass diese Klasse nicht öffentlich ist. Das ist kein Problem, denn ihre Elemente werden ja über die öffentliche Schnittstelle IAuthenticate <\/b>veröffentlicht.<\/p>\n Listing 1: Definition der Klasse Authenticate.vb<\/span><\/b><\/p>\n Außerdem müssen wir für diese Klasse den Zusatz Implements IAuthenticate<\/b> hinzufügen, damit diese die Schnittstelle implementiert. Für die einzelnen Elemente der Schnittstelle, die wir implementieren, müssen wir ebenfalls jeweils einen Zusatz zur ersten Zeile hinzufügen. Dieser enthält zusätzlich noch den Namen des Elements, das implementiert wird – für die Funktion AuthenticateOAuth <\/b>lautet der Zusatz beispielsweise Implements IAuthentication.AuthenticateOAuth<\/b>.<\/p>\n Im Vergleich zu der Version der Funktion AuthenticateOAuth<\/b>, die wir im Artikel YouTube-Kanal mit VB.NET verwalten, Teil 2 <\/b>(www.vbentwickler.de\/316<\/b>) vorgestellt haben, haben wir hier noch einen Parameter hinzugefügt. Wir wollen die Handhabung der Datei client_secrets.json<\/b>, welche die Authentifizierungsdaten der App enthält, etwas ändern. Ihr Speicherort soll nicht fest im Code verdrahtet sein, sondern wir wollen diesen flexibel als Parameter übergeben. So können wir diese Datei beispielsweise auch im gleichen Verzeichnis wie die aufrufende Anwendung – beispielsweise eine Access- oder Excel-Anwendung – speichern. Wie Du die Datei client_secrets.json <\/b>erhältst, lernst Du im Artikel YouTube-Kanal mit VB.NET verwalten, Teil 1 <\/b>(www.vbentwickler.de\/315<\/b>).<\/p>\n Den Pfad zu dieser Datei übergeben wir der Funktion AuthenticateOAuth <\/b>als Parameter und nutzen diesen dann innerhalb der Funktion zum Einlesen der benötigten Daten aus der Datei.<\/p>\n In AuthenticateOAuth <\/b>haben wir außerdem eine Zeile hinzugefügt, welche den Wert der Eigenschaft AccessToken <\/b>aus dem verwendeten UserCredential<\/b>-Objekt in die lokale Variable _Token <\/b>schreibt. Diesen kann die aufrufende Instanz über die Funktion Token abrufen.<\/p>\n Die Klasse mit den Funktionen für den Zugriff auf die Daten eines YouTube-Channels haben wir YouTubeChannel <\/b>genannt. Sie enthält im Wesentlichen die Elemente, die wir im Artikel YouTube-Kanal mit VB.NET verwalten, Teil 2 <\/b>(www.vbentwickler.de\/316<\/b>) erläutert haben. Daher gehen wir hier nicht mehr im Detail auf die enthaltenen Anweisungen ein, sondern nur noch auf die notwendigen Anpassungen für die Verwendung in einer COM-DLL.<\/p>\n Genau wie für die Klasse Authenticate<\/b> erstellen wir auch für die Klasse YouTubeChannel<\/b> eine Schnittstelle. Diese sieht wie in Listing 2 aus. Auch in der Klassendatei YouTubeChannel.vb <\/b>fügen wir oben einen Verweis auf den Namespace System.Runtime.InteropServices <\/b>ein, damit wir die Annotationen für die Veröffentlichungen der Klasse definieren können.<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>NuGet-Pakete hinzufügen<\/h2>\n
Vorbereitungen für die COM-DLL<\/h2>\n
![\"Aktivieren](\"..\/fileadmin\/_temp_\/2022_02\/pic_317_003.png\")
<\/p>\n![\"Aktivieren](\"..\/fileadmin\/_temp_\/2022_02\/pic_317_002.png\")
<\/p>\nKlasse mit der Funktion zur Authentifizierung<\/h2>\n
Imports System.Runtime.InteropServices<\/pre>\n
Schnittstelle für die Authentifizierungsklasse<\/h2>\n
<InterfaceType(ComInterfaceType.InterfaceIsDual)>\r\nPublic <\/span>Interface IAuthentication\r\n Function AuthenticateOAuth(strPathClientSecrets _\r\n As String<\/span>) As <\/span>YouTubeService\r\n Function Token() As String<\/span>\r\nEnd Interface<\/pre>\n<ClassInterface(ClassInterfaceType.None)>\r\nPublic Class<\/span> Authentication\r\n Implements IAuthentication\r\n Private <\/span>_Token As String<\/span>\r\n Public <\/span>Function AuthenticateOAuth(strPathClientSecrets As String<\/span>) As <\/span>YouTubeService _\r\n Implements IAuthentication.AuthenticateOAuth\r\n Dim <\/span>objYouTubeService As <\/span>Google.Apis.YouTube.v3.YouTubeService\r\n Dim <\/span>objUserCredential As <\/span>UserCredential\r\n Dim <\/span>objStream As <\/span>FileStream\r\n objStream = New<\/span> FileStream(strPathClientSecrets, FileMode.Open, FileAccess.Read)\r\n objUserCredential = GoogleWebAuthorizationBroker.AuthorizeAsync(\r\n GoogleClientSecrets.FromStream(objStream).Secrets,\r\n {YouTubeService.Scope.Youtube},\r\n \"user\",\r\n CancellationToken.None).Result\r\n objYouTubeService = New<\/span> YouTubeService(New<\/span> BaseClientService.Initializer() With<\/span> {\r\n .HttpClientInitializer = objUserCredential\r\n })\r\n _Token = objUserCredential.Token.AccessToken.ToString\r\n Return objYouTubeService\r\n End Function\r\n Public <\/span>Function Token() As String<\/span> Implements IAuthentication.Token\r\n Return _Token\r\n End Function\r\nEnd Class<\/span><\/pre>\nDie Klasse YouTubeChannel<\/h2>\n
Imports System.Runtime.InteropServices\r\n<InterfaceType(ComInterfaceType.InterfaceIsDual)>\r\nPublic <\/span>Interface IYouTubeChannel\r\n Function GetAllVideos(strChannelID As String<\/span>) As <\/span>Collection\r\n Sub AddPlaylist(strPlaylist As String<\/span>, strDescription As String<\/span>)\r\n Sub UploadVideo(strVideoPath As String<\/span>, strTitle As String<\/span>, strDescription As String<\/span>, _\r\n Optional<\/span> strThumbnail As String<\/span> = \"\")\r\n Sub UploadThumbnail(strThumbnail As String<\/span>, strVideoID As String<\/span>)\r\n Function GetVideo(strID As String<\/span>) As <\/span>MyVideo\r\n Sub UpdateVideo(strID As String<\/span>, Optional<\/span> strTitle As String<\/span> = \"\", Optional<\/span> strDescription As String<\/span> = \"\", _\r\n Optional<\/span> strThumbnail As String<\/span> = \"\")\r\n Property PathClientSecrets As String<\/span>\r\nEnd Interface<\/pre>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t