Dans ce billet de blog en deux parties, nous verrons comment mettre en place une simple application ASP.NET Core capable d’analyser des tweets pour détecter la langue de l’auteur, ainsi que le sentiment exprimé au travers des écrits de ce dernier.
Il s’agit de la démo que j’avais faite pour une de mes présentations sur les services cognitifs d’Azure. J’ai eu un peu de disponibilité ces derniers jours et je me suis lancé dans l’écriture de ce billet de blog pour offrir un guide pas à pas pour mettre en place une solution similaire et jouer un peu avec TextAnalytics API.
Outils utilisés :
Visual Studio 2019 : Environnement de développement permettant de développer différents types d'applications (Windows, Web, Android, iOS, Cloud, etc.), en utilisant de nombreux langages de programmation, dont C#, VB.NET, C++, JavaScript et bien plus. L’édition communautaire est disponible gratuitement en téléchargement sur la page suivante : https://visualstudio.microsoft.com/fr/downloads/
ASP.NET Core : plateforme de développement Web open source. Nous allons utiliser le modèle de projet Razor Page et le langage C#.
Azure Text Analyctis API : service cognitif de traitement en langage naturel de texte brut. Ce service inclut la détection de la langue de l’utilisateur, la détection des mots-clés, la détection d’entités et l’analyse des sentiments.
Pour utiliser Text Analytics, vous devez disposer d’un compte Microsoft Azure. Vous pouvez en créer un gratuitement si vous n’en disposez pas d’un.
TwwtinviAPI : Tweetinvi est une bibliothèque intuitive .NET permettant d'accéder à l'API REST de Twitter. Il s'agit d'une bibliothèque de classes .NETCore et Portable, pouvant être utilisée pour le développement sur Windows, Windows RT, Windows Phone, Mono, Xamarin Android et Xamarin iOS.
Création du projet
Pour commencer, vous devez créer une nouvelle application ASP.NET Core Razor Pages en utilisant Visual Studio 2019.
541646
Installation de l’API Twitter
Une fois l’application créée, procédez à l’installation de l’API Tweetinvi en utilisant le gestionnaire de packages NuGet :
541650
Une fois l’API installé, nous devons procéder à la configuration de celle-ci afin de nous connecter à Twitter.
La plateforme Twitter expose un EndPoint public qui peut être utilisé par les développeurs pour interagir avec cette dernière. Le EndPoint permet notamment de consulter les données publiées sur Twitter, publié du contenu sur Twitter, etc. Tweetinvi simplifié l’accès à cette API.
Avant toute utilisation de Twitter dans une application, vous devez disposer un compte développeur sur Twitter : https://developer.twitter.com/
Ensuite, vous devez créer une application depuis le portail développeur de Twitter.
541654
L’application Twitter est en quelque sorte une passerelle entre votre application et la plateforme Twitter. Elle fournit des informations que vous allez utiliser dans votre application pour notamment vous authentifier auprès de Twitter.
Une fois l’application créée, vous trouverez dans l’onglet Key and tokens les informations que vous avez besoin pour authentifier votre application :
541658
Revenez dans Visual Studio, ouvrez le fichier de configuration appsettings.json de votre application et ajoutez les informations suivantes :
"Twitter": {
"ConsumerKey": "",
"ConsumerSecret": "",
"AccesToken": "",
"AccesTokenSecret": ""
}
Chaque propriété doit être remplacée avec la valeur correspondante dans l’application Twitter.
Mise en place du service de recherche des tweets
Une fois la configuration nécessaire pour se connecter à l’API Twitter mise en place, nous allons créer un service qui permettra d’effectuer des recherches sur Twitter à partir d’un Tag.
Vous allez dans un premier temps créer un dossier Services, ensuite une interface ITwwtsSearch :
public interface ITweetsSearch
{
IList
}
Vous devez créer la classe TweetsSearch qui doit être l’implémentation de l’interface ITweetsSearch :
public class TweetsSearch : ITweetsSearch
{
///
/// Journalisation
///
private readonly ILogger
///
/// Configuration
///
private readonly IConfiguration _config;
///
/// Initialisation d’une nouvelle instance de la classe TweetsSearch
///
/// Requis pour la journalisation
/// Requis pour l'accès aux informations de configuration
public TweetsSearch(ILogger
{
_config = config;
_logger = logger;
}
///
/// Méthode pour obtenir les tweets Twitter en fonction du Tag
///
/// Paramètre utilisé pour filtrer les tweets
///
public IList
{
}
}
Les paramètres de type ILogger, et IConfiguration, doivent être passés au constructeur. Ils seront utilisés respectivement pour la journalisation et lire les informations d’authentification à Twitter dans le fichier de configuration (appSettings.json).
Dans la méthode GetTweets, la première chose à faire sera d’utiliser la méthode statique SetUserCredentials de la classe Auth offerte par l’API Tweetinvi pour nous authentifier. Cette classe prend en paramètre le ConsumerKey, ConsumerSecret, AccesToken et AccesTokenSecret :
Auth.SetUserCredentials(_config.GetValue
_config.GetValue
Ensuite, nous devons définir nos paramètres de recherche en utilisant la méthode statique CreateTweetSearchParameter(string query) de la classe Search. Nous allons limiter le nombre de résultat à 50 :
var searchParameter = Search.CreateTweetSearchParameter("#"+tag);
searchParameter.MaximumNumberOfResults = 50;
Pour finir, il faudra effectuer la recherche en utilisant la méthode SearchTweets et en passant en nos paramètres de recherche.
//Recherche des Tweets
var tweets = Search.SearchTweets(searchParameter);
Le code complet de classe TweetsSearch est le suivant :
///
/// Service pour la recherche sur Twitter
///
public class TweetsSearch : ITweetsSearch
{
///
/// Journalisation
///
private readonly ILogger
///
/// Configuration
///
private readonly IConfiguration _config;
///
/// Initialisation d’une nouvelle instance de la classe TweetsSearch
///
/// Requis pour la journalisation
/// Requis pour l'accès aux informations de configuration
public TweetsSearch(ILogger
{
_config = config;
_logger = logger;
}
///
/// Méthode pour obtenir les tweets Twitter en fonction du Tag
///
/// Paramètre utilisé pour filtrer les tweets
///
public IList
{
//Authentification de l'application
Auth.SetUserCredentials(_config.GetValue
_config.GetValue
//Journalisation
_logger.LogInformation(
"TweetsSearch.GetTweets called. tag: {TAG}",
tag);
//Initialisation des paramètres de recherches
var searchParameter = Search.CreateTweetSearchParameter("#"+tag);
searchParameter.MaximumNumberOfResults = 50;
//Recherche des Tweets
var tweets = Search.SearchTweets(searchParameter);
return tweets!=null && tweets.Any() ? tweets.Select(x => x.FullText).ToList() : new List
}
}
Pour finir avec la création de ce service, nous allons modifier la méthode ConfigureServices du fichier Startup.cs pour ajouter la classe TweetsSearch au conteneur d’IoC de ASP.NET Core :
services.AddTransient
Appel du service
Pour commencer, vous devez modifier la classe IndexModel dans le fichier Index.cshtml.cs. Les propriétés suivantes doivent être créées :
///
/// Liste des Tweets
///
public IList
///
/// Paramètre de recherche
///
[StringLength(50)]
public string Tag { get; set; }
///
/// Recherche avec Twitter
///
private readonly ITweetsSearch _tweetsSearch;
Le constructeur de cette classe doit être modifié pour injecter le service ITweetsSearch :
///
/// Initialisation d’une nouvelle instance de la classe PageModel
///
/// Requis pour injecter le service ITweetsSearch
public IndexModel(ITweetsSearch tweetsSearch)
{
_tweetsSearch = tweetsSearch;
}
Dans la méthode OnGet, vous devez initialiser la propriété Tweets :
///
/// Méthode appelée lors d'une requête Get
///
public void OnGet()
{
Tweets = new List
}
Cette méthode est appelée à chaque chargement de la page (Requête Get).
Vous devez ensuite créer la méthode OnPost, qui est appelée lorsque l’utilisateur transmet les informations du formulaire de recherche :
///
/// Méthode appelée lors d'une requête Post
///
public void OnPost()
{
Tweets = _tweetsSearch.GetTweets(Tag);
}
Mise à jour de la vue
Éditez maintenant le fichier Index.cshtml et remplacez son contenu par le code suivant :
@page
@model IndexModel
@{
ViewData["Title"] = "Home page";
}
Tweets
ID
Text
Language
Score
@foreach (var item in Model.Tweets)
{
@Html.DisplayFor(modelItem => item)
}
Exécutez l’application et vous obtiendrez le résultat suivant pour une recherche donnée.
541663
Dans le prochain billet, nous verrons comment utiliser l'API TextAnalytics pour analyser les Tweets obtenus de Twitter.
Soutenez le club developpez.com en souscrivant un abonnement pour que nous puissions continuer à vous proposer des publications.