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

Ce tutoriel introduit comment créer une solution WebRTC en utilisant C#, en se concentrant sur le framework .NET Core, et fournit des aperçus sur la configuration d'un serveur de signalisation, la compréhension des serveurs TURN, et l'intégration de WebRTC dans vos applications C# IronPDF.

Configuration de votre environnement

Pour commencer à développer une application WebRTC en C#, vous devez configurer votre environnement de développement. Cela implique d'installer .NET Core, qui est une version multiplateforme de .NET pour créer des sites web, des services, et des applications console. Vous pouvez télécharger et installer .NET Core depuis le site officiel de Microsoft. Une fois installé, vous pouvez utiliser Visual Studio, un environnement de développement intégré (IDE) populaire 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 configurer un nouveau projet d'application console. Ouvrez votre terminal ou interface de ligne de commande et déplacez-vous vers 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

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

Comprendre WebRTC et la signalisation

WebRTC permet la communication en temps réel, mais il 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 les descriptions de session et les informations des candidats pour établir une connexion. Les applications en C# peuvent implémenter la signalisation via n'importe quel mécanisme de transport de messages, comme WebSockets ou les API REST.

Implémenter un serveur de signalisation en .NET Core

Un serveur de signalisation agit comme l'intermédiaire pour échanger des messages entre les pairs avant que la connexion directe pair-à-pair ne soit établie. Vous pouvez implémenter un serveur de signalisation en utilisant .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
{
    // Configures services for the web application.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options => options.AddDefaultPolicy(
            builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()));
        services.AddSignalR();
    }
  
    // Configures the HTTP request pipeline.
    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
{
    // Configures services for the web application.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options => options.AddDefaultPolicy(
            builder => builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()));
        services.AddSignalR();
    }
  
    // Configures the HTTP request pipeline.
    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
    ' Configures services for the web application.
    Public Sub ConfigureServices(services As IServiceCollection)
        services.AddCors(Sub(options) options.AddDefaultPolicy(
            Sub(builder) builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()))
        services.AddSignalR()
    End Sub

    ' Configures the HTTP request pipeline.
    Public Sub Configure(app As IApplicationBuilder, 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

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Public Class Startup
    ' Configures services for the web application.
    Public Sub ConfigureServices(services As IServiceCollection)
        services.AddCors(Sub(options) options.AddDefaultPolicy(
            Sub(builder) builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()))
        services.AddSignalR()
    End Sub

    ' Configures the HTTP request pipeline.
    Public Sub Configure(app As IApplicationBuilder, 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 de base en .NET Core avec SignalR, une bibliothèque pour 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, en faisant un bon choix pour notre serveur de signalisation.

Connexion des pairs avec WebRTC

Après avoir configuré le serveur de signalisation, l'étape suivante est d'établir une connexion pair-à-pair entre les clients en utilisant WebRTC. Cela implique de créer des objets RTCPeerConnection sur chaque client, d'échanger des messages d'offre et de réponse, et de négocier les détails de la connexion.

Créer la connexion de pair

Dans votre application C#, vous gérerez principalement la partie signalisation et pourrez éventuellement interagir avec les API WebRTC via un navigateur ou d'autres plateformes comme React Native pour les applications mobiles. Voici un exemple de comment initier une connexion de pair depuis un client web:

// Create a new RTCPeerConnection instance
const peerConnection = new RTCPeerConnection();

// Listen for ICE candidates and send them to the signaling server
peerConnection.onicecandidate = event => {
  if (event.candidate) {
    sendMessage('new-ice-candidate', event.candidate);
  }
};

// Handle incoming media streams
peerConnection.ontrack = event => {
  // Display the video or audio stream
};

// Create a new RTCPeerConnection instance
const peerConnection = new RTCPeerConnection();

// Listen for ICE candidates and send them to the signaling server
peerConnection.onicecandidate = event => {
  if (event.candidate) {
    sendMessage('new-ice-candidate', event.candidate);
  }
};

// Handle incoming media streams
peerConnection.ontrack = event => {
  // Display the video or audio stream
};

Cet extrait de code JavaScript démontre la création d'une nouvelle connexion de pair, la gestion des candidats ICE, et la configuration d'un rappel pour afficher les flux multimédias entrants.

Échanger l'offre et la réponse

Pour établir une connexion, un pair crée une offre et l'autre répond avec une réponse. Celles-ci sont échangées via le serveur de signalisation implémenté précédemment.

// Create an offer for the peer connection
async function createOffer() {
  const offer = await peerConnection.createOffer();
  await peerConnection.setLocalDescription(offer);
  sendMessage('offer', offer);
}

// Create an answer after receiving an offer
async function createAnswer(offer) {
  await peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
  const answer = await peerConnection.createAnswer();
  await peerConnection.setLocalDescription(answer);
  sendMessage('answer', answer);
}

// Create an offer for the peer connection
async function createOffer() {
  const offer = await peerConnection.createOffer();
  await peerConnection.setLocalDescription(offer);
  sendMessage('offer', offer);
}

// Create an answer after receiving an offer
async function createAnswer(offer) {
  await peerConnection.setRemoteDescription(new RTCSessionDescription(offer));
  const answer = await peerConnection.createAnswer();
  await peerConnection.setLocalDescription(answer);
  sendMessage('answer', answer);
}

Intégrer WebRTC dans les applications .NET

Bien que l'implémentation principale de WebRTC soit 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 des sessions, et interagir avec d'autres services comme 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) peuvent être enveloppées ou utilisées en conjonction avec C# pour gérer le trafic WebRTC.

Exécuter Votre Application

Pour exécuter votre application .NET Core, naviguez vers le répertoire du projet dans votre terminal et exécutez :

dotnet run

dotnet run

Cette commande compile et exécute votre application, démarrant le serveur de signalisation que vous avez implémenté. 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 des capacités de génération et de manipulation de PDF aux applications .NET, permettant aux développeurs de créer, lire et éditer des documents PDF par programmation. IronPDF prend en charge une gamme de tâches, y compris la génération de PDFs à partir de HTML, le remplissage de formulaires, l'extraction de texte et la sécurisation des documents. Cela le rend incroyablement utile pour générer des rapports, des factures, et des documents dynamiques basés sur des données utilisateur ou la sortie d'applications.

Une caractéristique clé d'IronPDF est sa capacité HTML en PDF, gardant vos mises en page et styles intacts. Elle génère des PDFs à partir de contenu web, la rendant parfaite pour les rapports, factures et documentation. Vous pouvez facilement convertir 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

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

Installer IronPDF

Avant de pouvoir utiliser IronPDF dans votre projet, vous devez l'ajouter à votre application .NET. Cela peut être fait en utilisant le Package Manager 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 Package Manager NuGet :

Install-Package IronPdf

Cas d'utilisation : Générer un PDF de compte-rendu de réunion dans une application WebRTC avec IronPDF

Imaginez développer une application de communication en temps réel en utilisant WebRTC, conçue pour les réunions en ligne ou les salles de classe virtuelles. Cette application permet aux utilisateurs de participer à des appels audio et vidéo, de partager leur écran et de collaborer sur des documents en temps réel. Une fonctionnalité précieuse de cette application serait la capacité de générer et distribuer automatiquement des comptes-rendus de réunion ou un résumé de la session, y compris les points clés discutés, les décisions prises et les points d'action, au format PDF. C'est là qu'intervient IronPDF.

Étapes de l'implémentation

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 éléments d'action mis en évidence est capturé. Ce contenu peut être formaté en HTML, permettant un style et une organisation faciles (par exemple, en utilisant des listes pour les actions 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 inclut le titre de la réunion, la date, les participants, et des sections structurées pour les différents types de contenu (points de discussion, décisions, actions).
3. Conversion 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 un document PDF. Cette conversion garantit que le style et la mise en page définis dans le HTML sont conservés dans le PDF, rendant le document facile à lire et professionnel d'apparence.

Voici un exemple de code de PDF échantillon :

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

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 en utilisant C# et .NET Core. Nous avons couvert la configuration de votre environnement de développement, la création d'une nouvelle application console, l'implémentation d'un serveur de signalisation, et l'initiation de connexions de pairs pour la 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 dispositifs. Pour des informations sur les licences et l'achat, visitez la Page de licence IronPDF. Une fois que vous décidez d'acheter, la licence commence à partir de $999.