AYUDA .NET

C# WebRTC (Cómo funciona para desarrolladores)

Actualizado 6 de marzo, 2024
Compartir:

WebRTC son las siglas de Web Real-Time Communication, una tecnología que permite la comunicación directa y en tiempo real entre navegadores web y otras plataformas sin necesidad de servidores intermedios para la transferencia de datos, salvo para la configuración inicial de la conexión. Admite vídeo, audio y datos genéricos compartidos entre pares, lo que la convierte en una potente herramienta para desarrollar aplicaciones de comunicación en tiempo real.

Este tutorial presenta cómo crear una solución WebRTC utilizando C#, centrándose en el marco .NET Core, y proporciona información sobre la configuración de un servidor de señalización, la comprensión de los servidores TURN y la integración de WebRTC en su sitio web. IronPDF Aplicaciones C#.

Configuración del entorno

Para empezar a desarrollar una aplicación WebRTC en C#, necesita configurar su entorno de desarrollo. Esto implica instalar .NET Core, que es una versión multiplataforma de .NET para crear sitios web, servicios y aplicaciones de consola. Puede descargar e instalar .NET Core desde el sitio web oficial de Microsoft. Una vez instalado, puede utilizar Visual Studio, un conocido entorno de desarrollo integrado. (IDE) para el desarrollo en C#, o cualquier otro editor de su elección para escribir su código.

Creación de una nueva aplicación de consola

Empieza por crear un nuevo proyecto de aplicación de consola. Abra su terminal o interfaz de línea de comandos y desplácese al directorio en el que tiene previsto establecer su proyecto. A continuación, ejecute el siguiente comando:

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
VB   C#

Este comando crea un nuevo directorio llamado WebRTCSample con una sencilla aplicación de consola "Hello World". Navega hasta el directorio de tu proyecto y estarás listo para empezar a codificar tu aplicación WebRTC.

Comprender WebRTC y la señalización

WebRTC permite la comunicación en tiempo real, pero requiere un mecanismo para coordinar la comunicación y enviar mensajes de control, un proceso conocido como señalización. La señalización se utiliza para intercambiar metadatos sobre la sesión de comunicación, como descripciones de sesión e información candidata para establecer una conexión. Las aplicaciones C# pueden implementar la señalización a través de cualquier mecanismo de transporte de mensajes, como WebSockets o API REST.

Implementación de un servidor de señalización en .NET Core

Un servidor de señalización actúa como intermediario para intercambiar mensajes entre pares antes de que se establezca la conexión directa entre pares. Puede implementar un servidor de señalización utilizando .NET Core creando una aplicación web sencilla que gestione conexiones WebSocket.

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
VB   C#

Este fragmento de código configura una aplicación .NET Core básica con SignalR, una biblioteca para añadir funcionalidades web en tiempo real a las aplicaciones. SignalR simplifica el proceso de añadir funcionalidades web en tiempo real a las aplicaciones, por lo que es una buena opción para nuestro servidor de señalización.

Conexión de pares con WebRTC

Tras configurar el servidor de señalización, el siguiente paso es establecer una conexión de igual a igual entre clientes mediante WebRTC. Esto implica crear objetos RTCPeerConnection en cada cliente, intercambiar mensajes de oferta y respuesta, y negociar los detalles de la conexión.

Creación de la conexión entre iguales

En su aplicación C#, gestionará principalmente la parte de señalización y posiblemente interactuará con las API WebRTC a través de un navegador u otras plataformas como React Native para aplicaciones móviles. A continuación se muestra un ejemplo de cómo iniciar una conexión entre pares desde un cliente web:

const peerConnection = new RTCPeerConnection();
peerConnection.onicecandidate = event => {
  if (event.candidate) {
    sendMessage('new-ice-candidate', event.candidate);
  }
};
peerConnection.ontrack = event => {
  //  Visualizar el flujo de vídeo o audio
};
const peerConnection = new RTCPeerConnection();
peerConnection.onicecandidate = event => {
  if (event.candidate) {
    sendMessage('new-ice-candidate', event.candidate);
  }
};
peerConnection.ontrack = event => {
  //  Visualizar el flujo de vídeo o audio
};
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
VB   C#

Este fragmento de código JavaScript muestra la creación de una nueva conexión de pares, la gestión de candidatos ICE y la configuración de una llamada de retorno para mostrar los flujos multimedia entrantes.

Intercambio de oferta y respuesta

Para establecer una conexión, uno de los pares crea una oferta y el otro responde con una respuesta. Se intercambian a través del servidor de señalización implementado anteriormente.

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
VB   C#

Integración de WebRTC en aplicaciones .NET

Aunque el núcleo de la implementación de WebRTC suele gestionarse en el navegador o en otros entornos del lado del cliente, las aplicaciones .NET pueden facilitar el proceso de señalización, gestionar el control de sesiones e interactuar con otros servicios como los servidores TURN para atravesar NAT. Para aplicaciones de escritorio o del lado del servidor, bibliotecas como Pion WebRTC (una biblioteca de código abierto para Go) puede envolverse o utilizarse junto con C# para gestionar el tráfico WebRTC.

Ejecutar la aplicación

Para ejecutar su aplicación .NET Core, navegue hasta el directorio del proyecto en su terminal y ejecútelo:

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

Este comando compila y ejecuta tu aplicación, iniciando el servidor de señalización que has implementado. Sus clientes web ya pueden conectarse a este servidor para empezar a intercambiar mensajes de señalización.

Introducción a IronPDF

C# WebRTC (Cómo funciona para desarrolladores): Figura 1 - Página web de IronPDF

IronPDF es una biblioteca versátil que aporta funciones de generación y manipulación de PDF a las aplicaciones .NET, permitiendo a los desarrolladores crear, leer y editar documentos PDF mediante programación. IronPDF permite realizar una serie de tareas, como generar PDF a partir de HTML rellenar formularios, extraer texto y proteger documentos. Esto lo hace increíblemente útil para generar informes, facturas y documentos dinámicos basados en los datos del usuario o en la salida de la aplicación.

Instalación de IronPDF

Antes de poder utilizar IronPDF en su proyecto, debe añadirlo a su aplicación .NET. Esto puede hacerse utilizando NuGet Package Manager, que simplifica el proceso de gestión de bibliotecas externas en sus proyectos. Para instalar IronPDF, puede utilizar el siguiente comando en la consola del gestor de paquetes NuGet:

Install-Package IronPdf

Caso práctico: Generación de PDF de actas de reunión en una aplicación WebRTC con IronPDF

Imagine desarrollar una aplicación de comunicación en tiempo real mediante WebRTC, diseñada para reuniones en línea o aulas virtuales. Esta aplicación permite a los usuarios participar en llamadas de audio y vídeo, compartir sus pantallas y colaborar en documentos en tiempo real. Una característica valiosa de esta aplicación sería la capacidad de generar y distribuir automáticamente actas de reuniones o un resumen de la sesión, incluidos los puntos clave debatidos, las decisiones tomadas y los puntos de acción, en formato PDF. Aquí es donde IronPDF entra en juego.

Pasos de la aplicación

  1. Captura del contenido de la reunión: A lo largo de la sesión WebRTC, se captura el contenido basado en texto, como mensajes de chat, notas compartidas o elementos de acción resaltados. Este contenido puede formatearse como HTML, lo que facilita su estilización y organización. (Por ejemplo, utilizando listas para los puntos de acción y títulos para los temas clave.).
  2. Generar plantilla HTML: Al final de la sesión, el contenido capturado se formatea en una plantilla HTML. Esta plantilla incluye el título de la reunión, la fecha, los participantes y secciones estructuradas para distintos tipos de contenido (puntos de debate, decisiones, puntos de acción).
  3. Convertir HTML a PDF: Una vez concluida la reunión y preparada la plantilla HTML, se utiliza IronPDF para convertir este contenido HTML en un documento PDF. Esta conversión garantiza que el estilo y el diseño definidos en el HTML se mantengan en el PDF, lo que hace que el documento sea fácil de leer y tenga un aspecto profesional.

    He aquí un ejemplo de código PDF:

using IronPdf;
public class MeetingMinutesGenerator
{
    public static void GenerateMeetingMinutesPdf(string htmlContent, string outputPath)
    {
        //  Inicializar el conversor de HTML a PDF
        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
        };
        //  Convertir el contenido HTML en un documento PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        //  Guardar el documento PDF
        pdfDocument.SaveAs(outputPath);
        Console.WriteLine("Meeting minutes PDF generated.");
    }
}
using IronPdf;
public class MeetingMinutesGenerator
{
    public static void GenerateMeetingMinutesPdf(string htmlContent, string outputPath)
    {
        //  Inicializar el conversor de HTML a PDF
        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
        };
        //  Convertir el contenido HTML en un documento PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        //  Guardar el documento PDF
        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)
		'  Inicializar el conversor de HTML a PDF
		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
		}
		'  Convertir el contenido HTML en un documento PDF
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		'  Guardar el documento PDF
		pdfDocument.SaveAs(outputPath)
		Console.WriteLine("Meeting minutes PDF generated.")
	End Sub
End Class
VB   C#

Conclusión

C# WebRTC (Cómo funciona para desarrolladores): Figura 2 - Página de licencias de IronPDF

En este artículo, hemos explorado cómo crear una aplicación WebRTC básica utilizando C# y .NET Core. Cubrimos la configuración de su entorno de desarrollo, la creación de una nueva aplicación de consola, la implementación de un servidor de señalización y el inicio de conexiones entre pares para la comunicación en tiempo real. WebRTC abre numerosas posibilidades para las aplicaciones de comunicación en tiempo real y, con C# y .NET Core, puede crear soluciones sólidas y escalables que funcionen en distintas plataformas y dispositivos. IronPDF para el entorno de producción. Una vez que decida comprarlo, la licencia comienza a partir de $749.

< ANTERIOR
Opentelemetry C# (Cómo funciona para desarrolladores)
SIGUIENTE >
C# OAuth2 (Cómo funciona para desarrolladores)

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,661,997
Ver licencias >