Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. C# WebRTC
.NET AIDE

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

Curtis Chau
Curtis Chau
Mis à jour:

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
SHELL

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(ByVal services As IServiceCollection)
		services.AddCors(Function(options) options.AddDefaultPolicy(Function(builder) builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader()))
		services.AddSignalR()
	End Sub

	' Configures the HTTP request pipeline.
	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
$vbLabelText   $csharpLabel

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
};
JAVASCRIPT

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);
}
JAVASCRIPT

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
SHELL

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

C# WebRTC (Comment cela fonctionne pour les développeurs): Figure 1 - Page web de 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
$vbLabelText   $csharpLabel

Installer IronPDF

Avant de pouvoir utiliser IronPDF dans votre projet, vous devez l'ajouter à votre application .NET. Cela peut être fait en utilisant 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 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. Capturer le 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 mises en avant sont capturés. 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. Convertir HTML en PDF : Une fois la réunion conclue 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
$vbLabelText   $csharpLabel

Conclusion

C# WebRTC (Comment cela fonctionne pour les développeurs): Figure 2 - Page de licence IronPDF

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 $799.

Questions Fréquemment Posées

Quels sont les avantages d'utiliser WebRTC avec C# et .NET Core ?

WebRTC couplé avec C# et .NET Core permet aux développeurs de créer des applications de communication en temps réel qui tirent parti des fonctionnalités puissantes de WebRTC et de l'environnement de programmation C#. Cette combinaison prend en charge le transfert de données direct entre pairs et peut être intégrée avec des bibliothèques .NET comme IronPDF pour des fonctionnalités supplémentaires.

Comment puis-je configurer un environnement de développement pour WebRTC en C# ?

Pour configurer un environnement de développement pour WebRTC en C#, vous devez installer le SDK .NET Core depuis le site officiel de Microsoft. Utilisez un IDE tel que Visual Studio pour gérer et écrire votre code efficacement. Cette configuration vous permettra de créer des applications console et d'intégrer les fonctionnalités WebRTC.

Quel rôle joue un serveur de signalisation dans une application WebRTC ?

Un serveur de signalisation est crucial dans une application WebRTC car il facilite l'échange de messages de contrôle et de métadonnées entre pairs pour établir une connexion. Il aide à négocier les descriptions de session et les informations de candidat avant qu'une connexion directe peer-to-peer ne soit établie.

Comment puis-je créer un serveur de signalisation en utilisant .NET Core ?

Vous pouvez créer un serveur de signalisation en utilisant .NET Core en développant une simple application web qui gère les connexions WebSocket. L'utilisation de SignalR, une bibliothèque qui ajoute des fonctionnalités web en temps réel, peut simplifier le processus de mise en œuvre du serveur de signalisation.

Comment IronPDF peut-il être utilisé pour générer des PDF dans les applications WebRTC ?

IronPDF peut être intégré dans les applications WebRTC pour générer des PDF à partir de contenu HTML. Cela est particulièrement utile pour créer des documents comme des comptes rendus de réunion ou des résumés de session, améliorant ainsi la fonctionnalité des applications de communication en temps réel.

Quelles étapes sont impliquées dans l'établissement d'une connexion peer-to-peer en WebRTC ?

Établir une connexion peer-to-peer en WebRTC implique de créer des objets RTCPeerConnection, d'échanger des messages d'offre et de réponse, et de négocier les détails de la connexion en utilisant des candidats ICE. Ce processus est essentiel pour permettre une communication directe entre pairs.

Comment les serveurs TURN facilitent-ils les connexions WebRTC ?

Les serveurs TURN assistent à la mise en œuvre des connexions WebRTC en relayant les médias entre pairs lorsque la connexion directe n'est pas possible, en particulier dans les environnements réseau restrictifs. Cela garantit la connectivité même dans des situations où la traversée NAT est requise.

Le HTML peut-il être converti en PDF dans les applications .NET ?

Oui, le HTML peut être converti en PDF dans les applications .NET en utilisant des bibliothèques comme IronPDF. Des méthodes telles que RenderHtmlAsPdf peuvent être utilisées pour convertir du contenu HTML en un document PDF tout en conservant le style et la mise en page d'origine.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit