C# WebRTC (Wie es für Entwickler funktioniert)

WebRTC steht für Web Real-Time Communication, eine Technologie, die eine direkte Echtzeitkommunikation zwischen Webbrowsern und anderen Plattformen ermöglicht, ohne dass für die Datenübertragung - mit Ausnahme des anfänglichen Verbindungsaufbaus - Zwischenserver erforderlich sind. Sie unterstützt Video-, Audio- und allgemeine Daten, die zwischen Peers ausgetauscht werden können, und ist damit ein leistungsfähiges Werkzeug für die Entwicklung von Echtzeitkommunikationsanwendungen.

Dieses Tutorial führt in die Erstellung einer WebRTC-Lösung mit C# ein, wobei der Schwerpunkt auf dem .NET Core-Framework liegt, und bietet 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 mit der Entwicklung einer WebRTC-Anwendung in C# zu beginnen, müssen Sie Ihre Entwicklungsumgebung einrichten. Dies beinhaltet die Installation von .NET Core, einer plattformübergreifenden Version von .NET für die Erstellung von Websites, Diensten und Konsolenanwendungen. Sie können .NET Core von der offiziellen Website von Microsoft herunterladen und installieren. Nach der Installation können Sie Visual Studio verwenden, eine beliebte integrierte Entwicklungsumgebung (IDE) für die C#-Entwicklung, oder einen anderen Editor Ihrer Wahl, um Ihren Code zu schreiben.

Erstellen einer neuen Konsolenanwendung

Beginnen Sie mit dem Einrichten eines neuen Konsolenanwendungsprojekts. Öffnen Sie Ihr Terminal oder Ihre Befehlszeilenschnittstelle und wechseln Sie in das Verzeichnis, in dem Sie Ihr Projekt erstellen möchten. Führen Sie dann den folgenden Befehl aus:

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

Dieser Befehl erstellt ein neues Verzeichnis mit dem Namen WebRTCSample mit einer einfachen "Hello World"-Konsolenanwendung. Navigieren Sie in Ihr Projektverzeichnis, und schon können Sie mit der Codierung Ihrer WebRTC-Anwendung beginnen.

Verstehen von WebRTC und Signalisierung

WebRTC ermöglicht die Kommunikation in Echtzeit, erfordert aber einen Mechanismus zur Koordinierung der Kommunikation und zum Senden von Kontrollnachrichten, einen Prozess, der als Signalisierung bezeichnet wird. Die Signalisierung dient dem Austausch von Metadaten über die Kommunikationssitzung, z. B. Sitzungsbeschreibungen und Kandidateninformationen für den Aufbau einer Verbindung. C#-Anwendungen können die Signalisierung über einen beliebigen Nachrichtentransportmechanismus implementieren, z. B. WebSockets oder REST-APIs.

Implementieren eines Signalservers in .NET Core

Ein Signalisierungsserver dient als Vermittler für den 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 Webanwendung erstellen, die WebSocket-Verbindungen verarbeitet.

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

Dieses Code-Snippet richtet eine einfache .NET Core-Anwendung mit SignalR ein, einer Bibliothek zum Hinzufügen von Echtzeit-Webfunktionen zu Anwendungen. SignalR vereinfacht den Prozess des Hinzufügens von Echtzeit-Webfunktionen zu Anwendungen und ist daher eine gute Wahl für unseren Signalisierungsserver.

Verbinden von Peers mit WebRTC

Nach dem Einrichten des Signalisierungsservers besteht der nächste Schritt darin, eine Peer-to-Peer-Verbindung zwischen den Clients über WebRTC herzustellen. Dazu müssen auf jedem Client RTCPeerConnection-Objekte erstellt, Angebots- und Antwortnachrichten ausgetauscht und die Verbindungsdetails ausgehandelt werden.

Erstellen der Peer-Verbindung

In Ihrer C#-Anwendung werden Sie hauptsächlich den Signalisierungsteil verwalten und möglicherweise mit WebRTC-APIs über einen Browser oder andere Plattformen wie React Native für mobile Anwendungen interagieren. Im Folgenden finden Sie ein Beispiel dafür, wie Sie eine Peer-Verbindung von einem Web-Client aus initiieren:

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

Dieser JavaScript-Codeausschnitt veranschaulicht die Erstellung einer neuen Peer-Verbindung, die Behandlung von ICE-Kandidaten und die Einrichtung eines Callbacks zur Anzeige eingehender Medienströme.

Austausch von Angebot und Antwort

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

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

Integration von WebRTC in .NET-Anwendungen

Während die WebRTC-Kernimplementierung in der Regel im Browser oder in anderen clientseitigen Umgebungen erfolgt, können .NET-Anwendungen den Signalisierungsprozess erleichtern, die Sitzungssteuerung verwalten und mit anderen Diensten wie TURN-Servern für NAT-Traversal interagieren. Für Desktop- oder serverseitige Anwendungen sind Bibliotheken wie Pion WebRTC (eine Open-Source-Bibliothek für Go) kann für die Abwicklung des WebRTC-Verkehrs mit C# verpackt oder zusammen mit C# verwendet werden.

Ausführen Ihrer Anwendung

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

dotnet run

dotnet run

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

Dieser Befehl kompiliert und führt Ihre Anwendung aus und startet den von Ihnen implementierten Signalisierungsserver. Ihre Web-Clients können nun eine Verbindung zu diesem Server herstellen und mit dem Austausch von Signalisierungsnachrichten beginnen.

Einführung in IronPDF

IronPDF ist eine vielseitige Bibliothek, die PDF-Erzeugungs- und -Bearbeitungsfunktionen für .NET-Anwendungen bereitstellt und es Entwicklern ermöglicht, PDF-Dokumente programmatisch zu erstellen, zu lesen und zu bearbeiten. IronPDF unterstützt eine Reihe von Aufgaben, einschließlich der Erzeugung von PDFs aus HTML, Ausfüllen von Formularen, Extrahieren von Text und Sichern von Dokumenten. Dies macht es unglaublich nützlich für die Erstellung von Berichten, Rechnungen und dynamischen Dokumenten auf der Grundlage von Benutzerdaten oder Anwendungsausgaben.

Ein Hauptmerkmal von IronPDF ist seine HTML zu PDF fähigkeit, wobei Ihre Layouts und Stile intakt bleiben. Es generiert PDFs aus Webinhalten und eignet sich damit hervorragend für Berichte, Rechnungen und Dokumentationen. Sie können HTML-Dateien, URLs und HTML-Strings 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

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 Package Manager geschehen, der die Verwaltung externer Bibliotheken in Ihren Projekten vereinfacht. Um IronPDF zu installieren, können Sie den folgenden Befehl in der NuGet Package Manager Console verwenden:

Install-Package IronPdf

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

Stellen Sie sich die Entwicklung einer Echtzeit-Kommunikationsanwendung mit WebRTC vor, die für Online-Meetings oder virtuelle Klassenzimmer konzipiert ist. Mit dieser Anwendung können Benutzer Audio- und Videoanrufe tätigen, ihre Bildschirme gemeinsam nutzen und gemeinsam an Dokumenten in Echtzeit arbeiten. Ein wertvolles Merkmal dieser Anwendung wäre die Möglichkeit, automatisch Sitzungsprotokolle oder eine Zusammenfassung der Sitzung, einschließlich der wichtigsten besprochenen Punkte, getroffenen Entscheidungen und Aktionspunkte, im PDF-Format zu erstellen und zu verteilen. An dieser Stelle kommt IronPDF ins Spiel.

Schritte zur Umsetzung

1. Erfassung von Meeting-Inhalten: Während der gesamten WebRTC-Sitzung werden textbasierte Inhalte wie Chat-Nachrichten, gemeinsame Notizen oder hervorgehobene Aktionspunkte erfasst. Dieser Inhalt kann als HTML formatiert werden, was eine einfache Gestaltung und Organisation ermöglicht (z. B. Verwendung von Listen für Aktionspunkte und Überschriften für wichtige Themen).

2. HTML-Vorlage generieren: Am Ende der Sitzung wird der erfasste Inhalt in eine HTML-Vorlage formatiert. Diese Vorlage enthält den Titel der Besprechung, das Datum, die Teilnehmer und strukturierte Abschnitte für verschiedene Arten von Inhalten (diskussionspunkte, Beschlüsse, Aktionspunkte).

3. HTML in PDF konvertieren: Sobald die Besprechung beendet und die HTML-Vorlage vorbereitet ist, wird IronPDF verwendet, um diesen HTML-Inhalt in ein PDF-Dokument zu konvertieren. Durch diese Konvertierung wird sichergestellt, dass das im HTML-Dokument definierte Styling und Layout im PDF-Dokument beibehalten wird, so dass das Dokument leicht zu lesen ist und ein professionelles Aussehen hat.

   Hier ist ein Beispiel für einen PDF-Code:

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

Schlussfolgerung

In diesem Artikel haben wir untersucht, wie man eine grundlegende WebRTC-Anwendung mit C# und .NET Core erstellt. Wir haben uns mit der Einrichtung Ihrer Entwicklungsumgebung, der Erstellung einer neuen Konsolenanwendung, der Implementierung eines Signalisierungsservers und der Initiierung von Peer-Verbindungen für die Echtzeitkommunikation beschäftigt. WebRTC eröffnet zahlreiche Möglichkeiten für Echtzeit-Kommunikationsanwendungen, und mit C# und .NET Core können Sie robuste, skalierbare Lösungen erstellen, die auf verschiedenen Plattformen und Geräten funktionieren. IronPDF für die Produktionsumgebung. Sobald Sie sich für den Kauf entscheiden, beginnt die Lizenz bei $749.