- \n
- Google.Apis.Oauth2.v2<\/b>: Ermöglicht die Authentifizierung für den Zugriff auf die YouTube-Daten<\/li>\n
- Google.Apis.YouTube.V3<\/b>: Ermöglicht den Zugriff auf die YouTube-Daten.<\/li>\n<\/ul>\n
Wenn wir nach der Installation zum Bereich Installiert<\/b> wechseln, sollte dieser wie in Bild 1 aussehen.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2022_02\/pic_316_001.png\")
<\/p>\nBild 1: Die für die Lösung benötigten NuGet-Pakete<\/span><\/b><\/p>\n
Programmierung der Authentifizierung<\/h2>\n
Ziel der nachfolgend beschriebenen Authentifizierung ist es, ein Objekt des Typs YouTubeService <\/b>zu erhalten, mit dem wir auf die Daten des YouTube-Kanals des Benutzers zugreifen können, in dessen Kontext wir uns anmelden. Diese Klasse (siehe Listing 1) bezeichnen wir mit Authentication und sie enthält nur eine Funktion namens AuthenticateOAuth<\/b>. Diese Funktion liefert nach erfolgreicher Authentifizierung das gewünschte YouTubeService<\/b>-Objekt zurück.<\/p>\n
Imports System.IO\r\nImports System.Threading\r\nImports Google.Apis.Auth.OAuth2\r\nImports Google.Apis.Services\r\nImports Google.Apis.YouTube.v3\r\nPublic Class<\/span> Authentication\r\n Public <\/span>Shared Function AuthenticateOAuth() As <\/span>YouTubeService\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(\"client_secrets.json\", 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 Return objYouTubeService\r\n End Function\r\nEnd Class<\/span><\/pre>\nListing 1: Klasse zur Authentifizierung eines Google-Accounts<\/span><\/b><\/p>\n
Die Frage ist nur: Woher bekommen wir die für die Authentifizierung notwendigen Daten? Dazu gehören zwei verschiedene Sätze von Informationen:<\/p>\n
- \n
- Die Daten für die App, mit der wir uns anmelden wollen und <\/li>\n
- die Daten für den Benutzer, in dessen Kontext die Anmeldung erfolgen soll.<\/li>\n<\/ul>\n
Die Daten für die App haben wir im ersten Teil der Artikelreihe mit dem Titel YouTube-Kanal mit VB.NET verwalten, Teil 1 <\/b>(www.vbentwickler.de\/315<\/b>) von unserem Google-Entwicklerkonto als JSON-Datei heruntergeladen und unter dem Namen client_secrets.json <\/b>gespeichert. Den zweiten Satz von Daten, die Daten des Benutzers, geben wir bei der eigentlichen Authentifizierung an. Zunächst benötigen wir nur die Daten aus der Datei client_secrets.json<\/b>. Der Einfachheit halber platzieren wir diese in dem Verzeichnis, in dem beim Debuggen der Anwendung auch die dabei erstellte .exe<\/b>-Datei landet. Dabei handelt es sich um den Ordner \\bin\\Debug\\net5.0-windows <\/b>unterhalb unseres Projektordners.<\/p>\n
Die Funktion AuthenticateOAuth <\/b>liest diese Datei in ein FileStream<\/b>-Objekt ein und übergibt die enthaltenen Daten als ersten Parameter der AuthorizeAsync<\/b>-Methode der Klasse GoogleWebAuthroizationBroker<\/b>. Daneben werden weitere Parameter übergeben. Der zweite lautet {YouTubeService.Scope.Youtube} <\/b>und legt fest, auf welchen Bereich sich die Authentifizierung bezieht. Danach erstellen wir ein neues Objekt des Typs YouTubeService <\/b>und übergeben diesem das UserCredential<\/b>-Objekt als Initialisierer. Danach gibt die Funktion das neue YouTubeService<\/b>-Objekt als Ergebnis zurück.<\/p>\n
Alle vorhandenen Videos auflisten<\/h2>\n
Als ersten Anwendungsfall wollen wir alle Videos eines Kanals ermitteln. Der Seite MainWindow.xaml <\/b>fügen wir dazu eine Schaltfläche wie die folgende hinzu:<\/p>\n
<Button x:Name=\"btnAlleVideos\" Click=\"btnAlleVideos_Click\">Alle Videos<\/Button><\/pre>\n
In der dadurch aufgerufenen Prozedur wollen wir eine Liste von Video-Elementen mit den wichtigsten Eigenschaften eines Videos füllen. Um diese Eigenschaften zu erfassen, wollen wir eine entsprechende Klasse verwenden.<\/p>\n
Diese Klasse fügen wir hinzu, indem wir im Projektmappen-Explorer mit der rechten Maustaste auf den Namen des Projekts klicken (in diesem Fall YouTubeAPIV3<\/b>) und dann den Kontextmenüeintrag Hinzufügen|Klasse… <\/b>betätigen. Im folgenden Dialog geben wir einfach den Namen der Klasse an, in diesem Fall MyVideo.vb<\/b>, und klicken dann auf Hinzufügen<\/b>.<\/p>\n
Anschließend füllen wir die Klasse mit dem folgenden Code:<\/p>\n
Public Class<\/span> MyVideo\r\n Public <\/span>Property ID As String<\/span>\r\n Public <\/span>Property Title As String<\/span>\r\n Public <\/span>Property Description As String<\/span>\r\n Public <\/span>Property Thumbnail As String<\/span>\r\n Public <\/span>Property PublishedAt As Date<\/span>\r\nEnd Class<\/span><\/pre>\nWer bisher Klassen nur mit VBA oder VB6 programmiert hat: Unter VB.NET ist die explizite Angabe von Property Get<\/b>-\/Let<\/b>-\/Set<\/b>-Prozeduren nicht notwendig, die hier vorliegende abkürzende Definition reicht für schreib- und lesbare Eigenschaften aus.<\/p>\n
Mit der oben definierten Schaltfläche lösen wir eine Prozedur aus, die ein List<\/b>-Objekt zum Aufnehmen der Videos erstellt. Den Typ der aufzunehmenden Elemente geben wir in Klammern an (Of MyVideo<\/b>). Damit rufen wir eine Funktion namens GetAllVideos <\/b>auf. Dieser übergeben wir die ID des Kanals, den wir untersuchen wollen. Wo bekommen wir den her? Dazu rufen wir die folgende Seite im Browser auf:<\/p>\n
https:\/\/www.youtube.com\/account_advanced<\/pre>\n
Die Kanal-ID befindet sich dort unter der Nutzer-ID. (siehe Bild 2) Für den Standardkanal können wir die ID auch aus den Buchstaben UC <\/b>und der Nutzer-ID zusammensetzen.<\/p>\n
![\"Abfragen](\"..\/fileadmin\/_temp_\/2022_02\/pic_316_002.png\")
<\/p>\nBild 2: Abfragen der Kanal-ID<\/span><\/b><\/p>\n
Nach dem Aufruf der Funktion GetAllVideos <\/b>ist die Liste objVideos <\/b>gefüllt und wir können diese über die Laufvariable objVideo <\/b>in einer For Each<\/b>-Schleife durchlaufen und ihre Eigenschaften ausgeben:<\/p>\n
Private Sub <\/span>btnAlleVideos_Click(sender As Object<\/span>, e As <\/span>RoutedEventArgs)\r\n Dim <\/span>objVideos As <\/span>List(Of MyVideo)\r\n Dim <\/span>objVideo As <\/span>MyVideo\r\n Dim <\/span>strChannelID As String<\/span>\r\n strChannelID = \"UCxxxxxxxxxxxxxxxxxxxx\"\r\n objVideos = GetAllVideos(strChannelID)\r\n For Each objVideo In objVideos\r\n Debug.Print<\/span>(objVideo.ID)\r\n Debug.Print<\/span>(objVideo.Title)\r\n Debug.Print<\/span>(objVideo.Description)\r\n Debug.Print<\/span>(objVideo.PublishedAt)\r\n Debug.Print<\/span>(objVideo.Thumbnail)\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nDas Ergebnis finden wir schließlich im Direktbereich von Visual Studio vor (siehe Bild 3). Wie wir hier sehen, ist die Beschreibung immer an einer bestimmten Stelle abgeschnitten und endet mit drei Punkten (…<\/b>). Die Auflistung und auch andere API-Funktionen wie etwa die Suchfunktion liefern immer nur die gekürzte Form. Um den vollständigen Beschreibungstext zu ermitteln, benötigen wir den Abruf der Video-Informationen selbst. Wie das gelingt, schauen wir uns weiter unten an – nun wollen wir erst einmal den Abruf der Videoliste genauer betrachten.<\/p>\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2022_02\/pic_316_003.png\")
<\/p>\nBild 3: Ausgabe der Video-Eigenschaften im Direktbereich von Visual Studio<\/span><\/b><\/p>\n
Die Funktion GetAllVideos<\/h2>\n
Die Funktion zum Ermitteln aller Videos eines Kanals erwartet die Angabe der Kanal-ID als Parameter (siehe Listing 2).<\/p>\n
Private Function <\/span>GetAllVideos(strChannelID As String<\/span>) As <\/span>List(Of MyVideo)\r\n Dim <\/span>objYouTubeService As <\/span>YouTubeService\r\n Dim <\/span>objVideolistRequest As <\/span>SearchResource.ListRequest\r\n Dim <\/span>objVideolistResponse As <\/span>SearchListResponse\r\n Dim <\/span>objSearchResult As <\/span>SearchResult\r\n Dim <\/span>objVideo As <\/span>MyVideo\r\n Dim <\/span>objVideos As <\/span>List(Of MyVideo)\r\n Dim <\/span>strNextPageToken As String<\/span> = \"\"\r\n objYouTubeService = Authentication.AuthenticateOAuth\r\n objVideos = New<\/span> List(Of MyVideo)\r\n Do While<\/span> Not<\/span> strNextPageToken Is Nothing\r\n objVideolistRequest = objYouTubeService.Search.List(\"snippet\")\r\n With<\/span> objVideolistRequest\r\n .ChannelId = strChannelID\r\n .Type = \"video\"\r\n .MaxResults = 50\r\n .PageToken = strNextPageToken\r\n End With<\/span>\r\n objVideolistResponse = objVideolistRequest.Execute\r\n For Each objSearchResult In objVideolistResponse.Items\r\n objVideo = New<\/span> MyVideo\r\n With<\/span> objVideo\r\n .ID = objSearchResult.Id.VideoId\r\n .Title = objSearchResult.Snippet.Title\r\n .Description = objSearchResult.Snippet.Description\r\n .Thumbnail = objSearchResult.Snippet.Thumbnails.Default__.Url\r\n .PublishedAt = objSearchResult.Snippet.PublishedAt\r\n End With<\/span>\r\n objVideos.Add(objVideo)\r\n Next<\/span> objSearchResult\r\n strNextPageToken = objVideolistResponse.NextPageToken\r\n Loop<\/span>\r\n Return objVideos\r\nEnd Function<\/span><\/pre>\nMöchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\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
- Google.Apis.YouTube.V3<\/b>: Ermöglicht den Zugriff auf die YouTube-Daten.<\/li>\n<\/ul>\n