Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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 .NET Framework 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#.
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.
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
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.
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.
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
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.
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.
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 => {
// 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
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.
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
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.
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
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.
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 HTMLrellenar 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.
Una característica clave de IronPDF es su De HTML a PDF manteniendo intactos sus diseños y estilos. Genera archivos PDF a partir de contenido web, por lo que es perfecto para informes, facturas y documentación. Puede convertir fácilmente archivos HTML, URL y cadenas 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
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
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.
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)
{
// 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
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.
9 productos API .NET para sus documentos de oficina