C# WebRTC (jak to działa dla programistów)

Konfiguracja środowiska

Aby rozpocząć tworzenie aplikacji WebRTC w języku C#, należy skonfigurować środowisko programistyczne. Wymaga to zainstalowania .NET Core, czyli wieloplatformowej wersji .NET do tworzenia stron internetowych, usług i aplikacji konsolowych. Możesz pobrać i zainstalować .NET Core z oficjalnej strony Microsoftu. Po zainstalowaniu możesz używać Visual Studio, popularnego zintegrowanego środowiska programistycznego (IDE) do tworzenia w C#, albo dowolnego innego edytora, żeby pisać swój kod.

dotnet new console -n WebRTCSample

dotnet new console -n WebRTCSample

Zrozumienie WebRTC i sygnalizacji

WebRTC umożliwia komunikację w czasie rzeczywistym, ale wymaga mechanizmu koordynującego komunikację i wysyłającego komunikaty sterujące, czyli procesu znanego jako sygnalizacja. Sygnalizacja służy do wymiany metadanych dotyczących sesji komunikacyjnej, takich jak opisy sesji i informacje o kandydatach do nawiązania połączenia. Aplikacje napisane w języku C# mogą realizować sygnalizację za pośrednictwem dowolnego mechanizmu transportu komunikatów, takiego jak WebSockets lub interfejsy API REST.

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

Łączenie użytkowników za pomocą WebRTC

Po skonfigurowaniu serwera sygnalizacyjnego następnym krokiem jest nawiązanie połączenia peer-to-peer między klientami przy użyciu WebRTC. Obejmuje to tworzenie obiektów RTCPeerConnection na każdym kliencie, wymianę komunikatów ofert i odpowiedzi oraz negocjowanie szczegółów połączenia.

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

Wymiana ofert i odpowiedzi

Aby nawiązać połączenie, jeden z uczestników tworzy ofertę, a drugi odpowiada na nią. Są one wymieniane za pośrednictwem wdrożonego wcześniej serwera sygnalizacyjnego.

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

Integracja WebRTC z aplikacjami .NET

Podczas gdy podstawowa implementacja WebRTC jest zazwyczaj obsługiwana w przeglądarce lub innych środowiskach po stronie klienta, aplikacje .NET mogą ułatwiać proces sygnalizacji, zarządzać kontrolą sesji oraz współpracować z innymi usługami, takimi jak serwery TURN, w celu pokonywania ograniczeń NAT. W przypadku aplikacji desktopowych lub serwerowych biblioteki takie jak Pion WebRTC (biblioteka open source dla języka Go) mogą być opakowane lub używane w połączeniu z językiem C# do obsługi ruchu WebRTC.

dotnet run

dotnet run

Wprowadzenie do IronPDF

IronPDF to wszechstronna biblioteka, która zapewnia aplikacjom .NET możliwości generowania i manipulowania plikami PDF, umożliwiając programistom tworzenie, odczytywanie i edytowanie dokumentów PDF za pomocą kodu. IronPDF obsługuje szereg zadań, w tym generowanie plików PDF z HTML, wypełnianie formularzy, wyodrębnianie tekstu i zabezpieczanie dokumentów. Dzięki temu jest niezwykle przydatne do generowania raportów, faktur i dokumentów dynamicznych na podstawie danych użytkownika lub wyników aplikacji.

Kluczową funkcją IronPDF jest możliwość konwersji HTML do PDF z zachowaniem układów i stylów. Generuje pliki PDF na podstawie treści internetowych, dzięki czemu idealnie nadaje się do tworzenia raportów, faktur i dokumentacji. Możesz łatwo konwertować pliki HTML, adresy URL i ciągi znaków HTML do formatu 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

Install-Package IronPdf

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

Wnioski

W tym artykule omówiliśmy, jak stworzyć podstawową aplikację WebRTC przy użyciu języka C# i platformy .NET Core. Omówiliśmy konfigurację środowiska programistycznego, tworzenie nowej aplikacji konsolowej, implementację serwera sygnalizacyjnego oraz nawiązywanie połączeń peer-to-peer w celu komunikacji w czasie rzeczywistym. WebRTC otwiera wiele możliwości dla aplikacji do komunikacji w czasie rzeczywistym, a dzięki C# i .NET Core można tworzyć solidne, skalowalne rozwiązania, które działają na różnych platformach i urządzeniach. Aby uzyskać informacje na temat licencji i zakupu, odwiedź stronę licencyjną IronPDF. Po podjęciu decyzji o zakupie licencja zaczyna obowiązywać od $799.