C# WebRTC (Comment ça marche pour les développeurs)

WebRTC est l'acronyme de Web Real-Time Communication, une technologie qui permet une communication directe et en temps réel entre les navigateurs web et d'autres plates-formes sans nécessiter de serveurs intermédiaires pour le transfert de données, à l'exception de l'établissement de la connexion initiale. Elle prend en charge la vidéo, l'audio et les données génériques à partager entre pairs, ce qui en fait un outil puissant pour le développement d'applications de communication en temps réel.

Ce tutoriel présente la création d'une solution WebRTC à l'aide de C#, en mettant l'accent sur le framework .NET Core, et donne un aperçu de la configuration d'un serveur de signalisation, de la compréhension des serveurs TURN et de l'intégration de WebRTC dans votre.. IronPDF Applications C#.

Mise en place de l'environnement

Pour commencer à développer une application WebRTC en C#, vous devez configurer votre environnement de développement. Il s'agit d'installer .NET Core, qui est une version multiplateforme de .NET permettant de créer des sites web, des services et des apps pour consoles. Vous pouvez télécharger et installer .NET Core à partir du site officiel de Microsoft. Une fois installé, vous pouvez utiliser Visual Studio, un environnement de développement intégré très répandu (L'IDE) pour le développement C#, ou tout autre éditeur de votre choix pour écrire votre code.

Création d'une nouvelle application console

Commencez par créer un nouveau projet d'application console. Ouvrez votre terminal ou votre interface de ligne de commande et placez-vous dans le répertoire où vous prévoyez d'établir votre projet. Ensuite, exécutez la commande ci-dessous :

dotnet new console -n WebRTCSample

dotnet new console -n WebRTCSample

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet New console -n WebRTCSample

Cette commande crée un nouveau répertoire nommé WebRTCSample avec une simple application console "Hello World". Naviguez dans le répertoire de votre projet et vous êtes prêt à commencer à coder votre application WebRTC.

Comprendre WebRTC et la signalisation

WebRTC permet une communication en temps réel, mais nécessite un mécanisme pour coordonner la communication et envoyer des messages de contrôle, un processus connu sous le nom de signalisation. La signalisation est utilisée pour échanger des métadonnées sur la session de communication, telles que des descriptions de session et des informations sur les candidats à l'établissement d'une connexion. Les applications C# peuvent mettre en œuvre la signalisation via n'importe quel mécanisme de transport de messages, comme les WebSockets ou les API REST.

Mise en œuvre d'un serveur de signalisation dans .NET Core

Un serveur de signalisation sert d'intermédiaire pour l'échange de messages entre pairs avant l'établissement d'une connexion directe d'égal à égal. Vous pouvez mettre en œuvre un serveur de signalisation à l'aide de .NET Core en créant une simple application web qui gère les connexions WebSocket.

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options => options.AddDefaultPolicy(
            builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()));
        services.AddSignalR();
    }
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseCors();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapHub<SignalingHub>("/signal");
        });
    }
}

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options => options.AddDefaultPolicy(
            builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()));
        services.AddSignalR();
    }
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        app.UseCors();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapHub<SignalingHub>("/signal");
        });
    }
}

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting
Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		services.AddCors(Function(options) options.AddDefaultPolicy(Function(builder) builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()))
		services.AddSignalR()
	End Sub
	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		If env.IsDevelopment() Then
			app.UseDeveloperExceptionPage()
		End If
		app.UseCors()
		app.UseRouting()
		app.UseEndpoints(Sub(endpoints)
			endpoints.MapHub(Of SignalingHub)("/signal")
		End Sub)
	End Sub
End Class

Cet extrait de code configure une application .NET Core de base avec SignalR, une bibliothèque permettant d'ajouter des fonctionnalités web en temps réel aux applications. SignalR simplifie le processus d'ajout de fonctionnalités web en temps réel aux applications, ce qui en fait un bon choix pour notre serveur de signalisation.

Connecter des pairs avec WebRTC

Après avoir configuré le serveur de signalisation, l'étape suivante consiste à établir une connexion d'égal à égal entre les clients à l'aide de WebRTC. Cela implique la création d'objets RTCPeerConnection sur chaque client, l'échange de messages d'offre et de réponse, et la négociation des détails de la connexion.

Créer le lien avec les pairs

Dans votre application C#, vous allez principalement gérer la partie signalisation et éventuellement interagir avec les API WebRTC via un navigateur ou d'autres plateformes comme React Native pour les applications mobiles. Vous trouverez ci-dessous un exemple de la manière d'initier une connexion entre pairs à partir d'un client web :

const peerConnection = new RTCPeerConnection();
peerConnection.onicecandidate = event => {
  if (event.candidate) {
    sendMessage('new-ice-candidate', event.candidate);
  }
};
peerConnection.ontrack = event => {
  // Display the video or audio stream
};

const peerConnection = new RTCPeerConnection();
peerConnection.onicecandidate = event => {
  if (event.candidate) {
    sendMessage('new-ice-candidate', event.candidate);
  }
};
peerConnection.ontrack = event => {
  // Display the video or audio stream
};

Private const peerConnection = New RTCPeerConnection()
'INSTANT VB TODO TASK: VB does not allow assigning to events in the event declaration:
onicecandidate = event => Implements peerConnection.onicecandidate
  If event.candidate Then
	sendMessage( 'New-ice-candidate', event.candidate);
  End If
	RaiseEvent(ByVal sender As Object, ByVal e As EventArgs)
	End RaiseEvent
End Event
'INSTANT VB TODO TASK: VB does not allow assigning to events in the event declaration:
'INSTANT VB TODO TASK: Lambda expressions and anonymous methods are not converted by Instant VB if local variables of the outer method are referenced within the anonymous method:
ontrack = event => Implements peerConnection.ontrack

Cet extrait de code JavaScript illustre la création d'une nouvelle connexion entre pairs, la gestion des candidats ICE et la mise en place d'un rappel pour afficher les flux de médias entrants.

Échange d'une offre et d'une réponse

Pour établir une connexion, un pair fait une offre et l'autre y répond. Ils sont échangés par l'intermédiaire du serveur de signalisation mis en place précédemment.

async function createOffer() {
  const offer = await peerConnection.createOffer();
  await peerConnection.setLocalDescription(offer);
  sendMessage('offer', offer);
}
async function createAnswer(offer) {
  await peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
  const answer = await peerConnection.createAnswer();
  await peerConnection.setLocalDescription(answer);
  sendMessage('answer', answer);
}

async function createOffer() {
  const offer = await peerConnection.createOffer();
  await peerConnection.setLocalDescription(offer);
  sendMessage('offer', offer);
}
async function createAnswer(offer) {
  await peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
  const answer = await peerConnection.createAnswer();
  await peerConnection.setLocalDescription(answer);
  sendMessage('answer', answer);
}

Async Function createOffer() As [function]
  const offer = Await peerConnection.createOffer()
  Await peerConnection.setLocalDescription(offer)
  sendMessage( 'offer', offer);
End Function
Async Function createAnswer(ByVal As offer) As [function]
  Await peerConnection.setRemoteDescription(New RTCSessionDescription(offer))
  const answer = Await peerConnection.createAnswer()
  Await peerConnection.setLocalDescription(answer)
  sendMessage( 'answer', answer);
End Function

Intégrer WebRTC dans les applications .NET

Alors que la mise en œuvre principale de WebRTC est généralement gérée dans le navigateur ou d'autres environnements côté client, les applications .NET peuvent faciliter le processus de signalisation, gérer le contrôle de session et interagir avec d'autres services tels que les serveurs TURN pour la traversée NAT. Pour les applications de bureau ou côté serveur, des bibliothèques comme Pion WebRTC (une bibliothèque open-source pour Go) peut être intégré ou utilisé en conjonction avec C# pour gérer le trafic WebRTC.

Exécution de l'application

Pour exécuter votre application .NET Core, accédez au répertoire du projet dans votre terminal et exécutez :

dotnet run

dotnet run

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet run

Cette commande compile et exécute votre application, en démarrant le serveur de signalisation que vous avez mis en place. Vos clients web peuvent maintenant se connecter à ce serveur pour commencer à échanger des messages de signalisation.

Introduction à IronPDF

IronPDF est une bibliothèque polyvalente qui apporte aux applications .NET des capacités de génération et de manipulation de fichiers PDF, permettant aux développeurs de créer, de lire et de modifier des documents PDF par programme. IronPDF prend en charge toute une série de tâches, notamment la génération de PDF à partir de HTMLil s'agit notamment de remplir des formulaires, d'extraire du texte et de sécuriser des documents. Il est donc extrêmement utile pour générer des rapports, des factures et des documents dynamiques sur la base des données de l'utilisateur ou des résultats de l'application.

L'une des principales caractéristiques d'IronPDF est son HTML à PDF en conservant vos mises en page et vos styles intacts. Il génère des PDF à partir de contenus web, ce qui le rend idéal pour les rapports, les factures et la documentation. Vous pouvez convertir facilement des fichiers HTML, des URL et des chaînes HTML en PDF.

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;
class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()
		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Installation d'IronPDF

Avant de pouvoir utiliser IronPDF dans votre projet, vous devez l'ajouter à votre application .NET. Pour ce faire, vous pouvez utiliser le gestionnaire de paquets NuGet, qui simplifie le processus de gestion des bibliothèques externes dans vos projets. Pour installer IronPDF, vous pouvez utiliser la commande suivante dans la console du gestionnaire de paquets NuGet :

Install-Package IronPdf

Cas d'utilisation : Générer un procès-verbal de réunion en PDF dans une application WebRTC avec IronPDF

Imaginez que vous développiez une application de communication en temps réel utilisant WebRTC, conçue pour des réunions en ligne ou des classes virtuelles. Cette application permet aux utilisateurs de participer à des appels audio et vidéo, de partager leurs écrans et de collaborer sur des documents en temps réel. Une fonctionnalité intéressante de cette application serait la possibilité de générer et de distribuer automatiquement le procès-verbal de la réunion ou un résumé de la session, y compris les points clés discutés, les décisions prises et les actions à entreprendre, au format PDF. C'est là qu'IronPDF entre en jeu.

Étapes de la mise en œuvre

1. Capture du contenu de la réunion : Tout au long de la session WebRTC, le contenu textuel tel que les messages de chat, les notes partagées ou les actions surlignées est capturé. Ce contenu peut être formaté en HTML, ce qui permet de le styliser et de l'organiser facilement (par exemple, en utilisant des listes pour les actions à entreprendre et des titres pour les sujets clés).
2. Générer un modèle HTML : À la fin de la session, le contenu capturé est formaté dans un modèle HTML. Ce modèle comprend le titre de la réunion, la date, les participants et des sections structurées pour différents types de contenu (points de discussion, décisions, mesures à prendre).

3. Convertir HTML en PDF : Une fois la réunion terminée et le modèle HTML préparé, IronPDF est utilisé pour convertir ce contenu HTML en document PDF. Cette conversion garantit que le style et la mise en page définis dans le HTML sont conservés dans le PDF, ce qui rend le document facile à lire et d'aspect professionnel.

   Voici un exemple de code PDF :

using IronPdf;
public class MeetingMinutesGenerator
{
    public static void GenerateMeetingMinutesPdf(string htmlContent, string outputPath)
    {
        // Initialize the HTML to PDF converter
        var renderer = new HtmlToPdf();
        renderer.PrintOptions.MarginTop = 40;
        renderer.PrintOptions.MarginBottom = 40;
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
        {
            CenterText = "{pdf-title}",
            DrawDividerLine = true,
            FontSize = 12
        };
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
        {
            LeftText = "{date} {time}",
            RightText = "Page {page} of {total-pages}",
            DrawDividerLine = true,
            FontSize = 12
        };
        // Convert the HTML content to a PDF document
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF document
        pdfDocument.SaveAs(outputPath);
        Console.WriteLine("Meeting minutes PDF generated.");
    }
}

using IronPdf;
public class MeetingMinutesGenerator
{
    public static void GenerateMeetingMinutesPdf(string htmlContent, string outputPath)
    {
        // Initialize the HTML to PDF converter
        var renderer = new HtmlToPdf();
        renderer.PrintOptions.MarginTop = 40;
        renderer.PrintOptions.MarginBottom = 40;
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
        {
            CenterText = "{pdf-title}",
            DrawDividerLine = true,
            FontSize = 12
        };
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter()
        {
            LeftText = "{date} {time}",
            RightText = "Page {page} of {total-pages}",
            DrawDividerLine = true,
            FontSize = 12
        };
        // Convert the HTML content to a PDF document
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the PDF document
        pdfDocument.SaveAs(outputPath);
        Console.WriteLine("Meeting minutes PDF generated.");
    }
}

Imports IronPdf
Public Class MeetingMinutesGenerator
	Public Shared Sub GenerateMeetingMinutesPdf(ByVal htmlContent As String, ByVal outputPath As String)
		' Initialize the HTML to PDF converter
		Dim renderer = New HtmlToPdf()
		renderer.PrintOptions.MarginTop = 40
		renderer.PrintOptions.MarginBottom = 40
		renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
			.CenterText = "{pdf-title}",
			.DrawDividerLine = True,
			.FontSize = 12
		}
		renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
			.LeftText = "{date} {time}",
			.RightText = "Page {page} of {total-pages}",
			.DrawDividerLine = True,
			.FontSize = 12
		}
		' Convert the HTML content to a PDF document
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the PDF document
		pdfDocument.SaveAs(outputPath)
		Console.WriteLine("Meeting minutes PDF generated.")
	End Sub
End Class

Conclusion

Dans cet article, nous avons exploré comment créer une application WebRTC de base à l'aide de C# et de .NET Core. Nous avons abordé la configuration de votre environnement de développement, la création d'une nouvelle application console, la mise en œuvre d'un serveur de signalisation et l'établissement de connexions entre pairs pour une communication en temps réel. WebRTC ouvre de nombreuses possibilités pour les applications de communication en temps réel, et avec C# et .NET Core, vous pouvez construire des solutions robustes et évolutives qui fonctionnent sur différentes plateformes et appareils. IronPDF pour l'environnement de production. Une fois que vous avez décidé de l'acheter, la licence commence à partir de $749.