WebRTC steht für Web Real-Time Communication, eine Technologie, die direkte, Echtzeitkommunikation zwischen Webbrowsern und anderen Plattformen ermöglicht, ohne dass für die Datenübertragung Vermittlungsserver erforderlich sind, mit Ausnahme der anfänglichen Verbindungsherstellung. Es unterstützt Video, Audio und generische Daten, die zwischen Peers ausgetauscht werden können, was es zu einem mächtigen Werkzeug für die Entwicklung von Echtzeitkommunikationsanwendungen macht.

Dieses Tutorial führt ein, wie man eine WebRTC-Lösung mit C# erstellt, wobei der Schwerpunkt auf dem .NET Core Framework liegt, und liefert Einblicke in die Einrichtung eines Signalisierungsservers, das Verständnis von TURN-Servern und die Integration von WebRTC in Ihre IronPDF C#-Anwendungen.

Einrichten Ihrer Umgebung

Um eine WebRTC-Anwendung in C# zu entwickeln, müssen Sie die Entwicklungsumgebung einrichten. Dies beinhaltet die Installation von .NET Core, einer plattformübergreifenden Version von .NET, zur Erstellung von Websites, Diensten und Konsolenanwendungen. Sie können .NET Core von der offiziellen Website von Microsoft herunterladen und installieren. Sobald installiert, können Sie Visual Studio, eine beliebte integrierte Entwicklungsumgebung (IDE) für die C#-Entwicklung, oder jeden anderen Editor Ihrer Wahl verwenden, um Ihren Code zu schreiben.

Erstellen einer neuen Konsolenanwendung

Beginnen Sie damit, ein neues Konsolenapplikationsprojekt einzurichten. Öffnen Sie Ihr Terminal oder Ihre Befehlszeilenschnittstelle und wechseln Sie in das Verzeichnis, in dem Sie Ihr Projekt einrichten möchten. Führen Sie den folgenden Befehl aus:

dotnet new console -n WebRTCSample

dotnet new console -n WebRTCSample

Dieser Befehl erstellt ein neues Verzeichnis namens WebRTCSample mit einer einfachen 'Hello World'-Konsolenanwendung. Wechseln Sie in Ihr Projektverzeichnis, und Sie sind bereit, mit dem Codieren Ihrer WebRTC-App zu beginnen.

Verständnis von WebRTC und Signalisierung

WebRTC ermöglicht Echtzeitkommunikation, benötigt jedoch einen Mechanismus zur Koordination von Kommunikation und zum Versenden von Steuerungsnachrichten, ein Prozess, der als Signalisierung bekannt ist. Die Signalisierung wird verwendet, um Metadaten über die Kommunikationssitzung auszutauschen, wie Sitzungsteilnehmerbeschreibungen und Kandidateninformationen für den Verbindungsaufbau. C#-Anwendungen können die Signalisierung über jeden Nachrichtentransportmechanismus implementieren, wie z.B. WebSockets oder REST-APIs.

Implementierung eines Signalservers in .NET Core

Ein Signalisierungsserver fungiert als Vermittler zum Austausch von Nachrichten zwischen Peers, bevor die direkte Peer-to-Peer-Verbindung hergestellt wird. Sie können einen Signalisierungsserver mit .NET Core implementieren, indem Sie eine einfache Webapplikation erstellen, die WebSocket-Verbindungen behandelt.

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

Dieser Codeausschnitt richtet eine grundlegende .NET Core-Anwendung mit SignalR ein, einer Bibliothek, die Echtzeit-Webfunktionen zu Apps hinzufügt. SignalR vereinfacht den Prozess, Echtzeit-Webfunktionalität in Anwendungen aufzunehmen, was es zu einer guten Wahl für unseren Signalisierungsserver macht.

Verbinden von Peers mit WebRTC

Nach der Einrichtung des Signalisierungsservers besteht der nächste Schritt darin, eine Peer-to-Peer-Verbindung zwischen Clients mit WebRTC zu etablieren. Dies beinhaltet das Erstellen von RTCPeerConnection-Objekten auf jedem Client, den Austausch von Angebot und Antwortnachrichten und die Aushandlung der Verbindungsdetails.

Erstellung der Peer-Verbindung

In Ihrer C#-Anwendung verwalten Sie hauptsächlich den Signalisierungsteil und interagieren möglicherweise mit WebRTC-APIs über einen Browser oder andere Plattformen wie React Native für mobile Apps. Nachfolgend ein Beispiel, wie man eine Peer-Verbindung von einem Webclient aus initiiert:

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

Dieser JavaScript-Codeausschnitt zeigt das Erstellen einer neuen Peer-Verbindung, das Verwalten von ICE-Kandidaten und das Einrichten eines Rückrufs zur Anzeige eingehender Medienströme.

Austausch von Angebot und Antwort

Um eine Verbindung herzustellen, erstellt ein Peer ein Angebot, und der andere antwortet mit einer Antwort. Diese werden über den zuvor implementierten Signalisierungsserver ausgetauscht.

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

Integration von WebRTC in .NET-Anwendungen

Während die Kernimplementierung von WebRTC typischerweise im Browser oder in anderen Client-Umgebungen erfolgt, können .NET-Anwendungen den Signalisierungsprozess erleichtern, die Sitzungssteuerung verwalten und mit anderen Diensten wie TURN-Servern für das NAT-Traversal interagieren. Für Desktop- oder serverseitige Anwendungen können Bibliotheken wie Pion WebRTC (eine Open-Source-Bibliothek für Go) ummantelt oder in Verbindung mit C# zur Handhabung von WebRTC-Verkehr genutzt werden.

Ausführen Ihrer Anwendung

Um Ihre .NET Core-Anwendung auszuführen, navigieren Sie im Terminal in das Projektverzeichnis und führen Sie aus:

dotnet run

dotnet run

Dieser Befehl kompiliert und führt Ihre Anwendung aus, indem er den implementierten Signalisierungsserver startet. Ihre Web-Clients können sich jetzt mit diesem Server verbinden, um mit dem Austausch von Signalisierungsnachrichten zu beginnen.

Einführung in IronPDF

IronPDF ist eine vielseitige Bibliothek, die PDF-Erstellungs- und Manipulationsfunktionen zu .NET-Anwendungen bringt, wodurch Entwickler PDF-Dokumente programmatisch erstellen, lesen und bearbeiten können. IronPDF unterstützt eine Reihe von Aufgaben, einschließlich der Generierung von PDFs aus HTML, dem Ausfüllen von Formularen, dem Extrahieren von Text und der Sicherung von Dokumenten. Dies macht es unglaublich nützlich für die Erstellung von Berichten, Rechnungen und dynamischen Dokumenten basierend auf Benutzerinformationen oder Applikationsausgaben.

Ein wichtiges Feature von IronPDF ist seine HTML-zu-PDF-Fähigkeit, die Layouts und Stile intakt hält. Es generiert PDFs aus Webinhalten und eignet sich perfekt für Berichte, Rechnungen und Dokumentationen. Sie können HTML-Dateien, URLs und HTML-Zeichenfolgen problemlos in PDFs umwandeln.

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

Installation von IronPDF

Bevor Sie IronPDF in Ihrem Projekt verwenden können, müssen Sie es zu Ihrer .NET-Anwendung hinzufügen. Dies kann mit dem NuGet-Paket-Manager getan werden, der den Prozess der Verwaltung externer Bibliotheken in Ihren Projekten vereinfacht. Um IronPDF zu installieren, können Sie den folgenden Befehl in der NuGet-Paket-Manager-Konsole verwenden:

Install-Package IronPdf

Benutzungsfall: Generierung von PDF-Besprechungsprotokollen in einer WebRTC-Anwendung mit IronPDF

Stellen Sie sich vor, Sie entwickeln eine Echtzeit-Kommunikationsanwendung mit WebRTC, die für Online-Meetings oder virtuelle Klassenzimmer konzipiert ist. Diese Anwendung ermöglicht es Benutzern, Audio- und Videotelefonate zu führen, ihre Bildschirme zu teilen und in Echtzeit an Dokumenten zusammenzuarbeiten. Ein wertvolles Merkmal dieser Anwendung wäre die Möglichkeit, automatisch Meetingminuten oder eine Zusammenfassung der Sitzung zu erstellen und zu verteilen, einschließlich der wichtigsten besprochenen Punkte, getroffener Entscheidungen und Aufgaben, im PDF-Format. Hier kommt IronPDF ins Spiel.

Umsetzungsschritte

1. Erfassung von Besprechungsinhalten: Während der gesamten WebRTC-Sitzung werden textbasierte Inhalte wie Chatnachrichten, geteilte Notizen oder hervorgehobene Aktionspunkte erfasst. Diese Inhalte können als HTML formatiert werden, um eine einfache Gestaltung und Organisation zu ermöglichen (z.B. unter Verwendung von Listen für Aufgaben und Überschriften für Schwerpunktthemen).
2. HTML-Vorlage generieren: Am Ende der Sitzung wird der erfasste Inhalt in eine HTML-Vorlage formatiert. Dieses Template enthält den Titel der Sitzung, das Datum, die Teilnehmer und strukturierte Abschnitte für verschiedene Inhaltstypen (Diskussionspunkte, Entscheidungen, Aufgaben).
3. HTML in PDF konvertieren: Sobald das Meeting beendet ist und die HTML-Vorlage erstellt wurde, wird IronPDF verwendet, um diesen HTML-Inhalt in ein PDF-Dokument zu konvertieren. Diese Umwandlung stellt sicher, dass das im HTML definierte Styling und Layout im PDF erhalten bleibt, was das Dokument leicht lesbar und professionell erscheinen lässt.

Hier ist ein Beispiel für einen Beispielcode für ein 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

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

Abschluss

In diesem Artikel haben wir untersucht, wie man eine grundlegende WebRTC-Anwendung mit C# und .NET Core erstellt. Wir haben die Einrichtung Ihrer Entwicklungsumgebung, das Erstellen einer neuen Konsolenanwendung, die Implementierung eines Signalisierungsservers und die Initiierung von Peer-Verbindungen für die Echtzeitkommunikation behandelt. WebRTC eröffnet zahlreiche Möglichkeiten für Echtzeitkommunikationsanwendungen, und mit C# und .NET Core können Sie robuste, skalierbare Lösungen entwickeln, die über verschiedene Plattformen und Geräte hinweg funktionieren. Für Lizenzinformationen und Kaufdetails besuchen Sie die IronPDF-Lizenzseite. Sobald Sie sich zum Kauf entschieden haben, beginnt die Lizenz ab $999.