dotnetify.NET (Cómo funciona para los desarrolladores)

Introducción

DotNetify es un framework de código abierto hecho con .NET y Blazor que está pensado para crear aplicaciones web en tiempo real en una plataforma .NET. Utilizar la potencia de SignalR para interacciones en tiempo real entre el cliente y el servidor facilita la construcción de aplicaciones web dinámicas e interactivas. DotNetify es un modelo de programación que sincroniza las vistas del lado del cliente conscripting del lado del servidor de datos, lo que permite a los desarrolladores diseñar rápida y fácilmente interfaces en línea ricas, con capacidad de respuesta y eficaces.

A la inversa,Biblioteca de generación de PDF IronPDF es un potente paquete .NET que facilita la creación, edición y manipulación de documentos PDF mediante programación. Es una gran opción para crear documentos dinámicos basados en datos, como informes, facturas y formularios, ya que proporciona una API intuitiva para transformar texto HTML en PDF.

La interactividad web en tiempo real y las potentes capacidades de producción de PDF se combinan en una aplicación C# mediante la integración de DotNetify con IronPDF. Las aplicaciones que exigen la visualización de datos en tiempo real y la capacidad de crear y distribuir dinámicamente documentos PDF basados en los datos más recientes encontrarán esta integración especialmente útil. Los desarrolladores pueden diseñar aplicaciones en línea extensas e interactivas que aborden requisitos empresariales complicados y mejoren las experiencias de los usuarios mediante la generación y distribución de documentos sin problemas aprovechando la versátil generación de PDF de IronPDF y la sincronización de datos en tiempo real de DotNetify.

¿Qué es DotNetify?

DotNetify es un marco de trabajo de código abierto creado para facilitar la creación de aplicaciones web interactivas en tiempo real con .NET y Blazor. Los desarrolladores pueden crear interfaces de usuario dinámicas y con capacidad de respuesta que se sincronicen con los datos del lado del servidor sin esfuerzo utilizando SignalR, que facilita la comunicación en tiempo real entre el cliente y el servidor. DotNetify es un enfoque de programación reactiva que simplifica la creación de aplicaciones en línea complicadas con poco código al abstraer las dificultades de la vinculación de datos en tiempo real y el manejo de eventos.

Para garantizar que la interfaz de usuario representa siempre el estado de la aplicación, DotNetify permite a los desarrolladores construir modelos de vista en el servidor que propagan inmediatamente los cambios al cliente. Este marco permite flexibilidad a la hora de seleccionar la tecnología del lado del cliente, ya que admite tanto front-ends clásicos de JavaScript como front-ends de Blazor. Es perfecto para aplicaciones que necesitan actualizaciones en tiempo real, como cuadros de mando, herramientas de colaboración y flujos de datos en directo, por su facilidad de uso y eficacia.

La gestión en tiempo real de interacciones complejas y flujos de datos de DotNetify mejora enormemente la experiencia del usuario al permitir una sincronización de datos fluida y una respuesta inmediata. En definitiva, DotNetify es una solución útil para los desarrolladores .NET que desean crear aplicaciones en línea reactivas, vanguardistas y en tiempo real de forma rápida y eficaz.

Características de DotNetify

Una serie de características proporcionadas por DotNetify en C# facilitan la creación de aplicaciones en línea interactivas y en tiempo real. Características importantes consisten en:

Comunicación en tiempo real: DotNetify utiliza SignalR para facilitar la comunicación bidireccional en tiempo real entre el cliente y el servidor, lo que permite interfaces de usuario interactivas y actualizaciones rápidas.

Modelo de programación reactiva: Ofrece un método de programación reactiva en el que las vistas del lado del cliente y los modelos de vista del lado del servidor se sincronizan automáticamente para mantener la interfaz de usuario actualizada con la información más reciente.

Modelos de vista del lado del servidor: Esto permite a los desarrolladores crear modelos de vista del lado del servidor a los que pueden vincularse los componentes del lado del cliente, lo que simplifica la gestión del estado y el flujo de datos dentro de la aplicación.

Compatible con Blazor y JavaScript: Admite tanto front-ends clásicos de JavaScript como front-ends de Blazor, lo que permite a los desarrolladores seleccionar la tecnología del lado del cliente que mejor se adapte a sus necesidades.

Facilidad de integración: La funcionalidad en tiempo real puede añadirse fácilmente a proyectos nuevos o existentes gracias a su perfecta integración con las aplicaciones .NET existentes. También se integra bien con marcos de componentes de interfaz de usuario front-end como WebSockets para crear un componente web y funciona con proyectos que utilizan software como React Native, Vue y Blazor.

Escalabilidad: DotNetify, que se basa en SignalR, hereda sus características de escalabilidad, lo que permite a las aplicaciones gestionar eficazmente un elevado número de conexiones simultáneas.

Arquitectura MVVM: Admite el Modelo-Vista-Vista-Modelo(MVVM) que contribuye a la división de responsabilidades y a una organización del código limpia y fácil de mantener.

Gestión de eventos: Reduce la cantidad de código repetitivo necesario para gestionar las interacciones de la interfaz de usuario y los cambios de estado mediante la racionalización de la gestión de eventos y la vinculación de datos.

Extensible y Personalizable: Ofrece puntos de extensibilidad y ganchos para permitir la personalización del comportamiento y la integración necesaria con otras librerías o frameworks.

Fuerte infraestructura: La infraestructura de DotNetify ofrece un mecanismo de enrutamiento dinámico que es capaz de ser definido enteramente en el back-end, que es capaz de enrutamiento anidado, autenticación basada en token, y más.

**DotNetify es un proyecto de código abierto que se beneficia de la participación y las contribuciones de la comunidad, lo que garantiza actualizaciones y mejoras continuas.

Crear y configurar DotNetify C#

Para crear un proyecto sencillo y empezar a configurar DotNetify en una aplicación en línea de C#, siga estos pasos. Este tutorial te mostrará cómo utilizar ASP.NET Core y Blazor para montar un servidor y un cliente básicos de DotNetify.

Configurar un nuevo proyecto de servidor ASP.NET Core Blazor

• Abra Visual Studio: Inicie Visual Studio y comience un nuevo proyecto.
• Crear una Blazor Server App: Haga clic en "Siguiente" después de seleccionar la plantilla Blazor Server App de las plantillas de proyecto.
• Configure su proyecto: Dé un nombre a su proyecto(como "DotNetifyWebApp") y realice los cambios de configuración necesarios. Pulse "Crear"

Instalar DotNetify mediante NuGet

• Gestionar paquetes NuGet: Vaya a "Gestionar paquetes NuGet" desde el Explorador de soluciones haciendo clic con el botón derecho en su proyecto.
• Busca DotNetify: Instala los paquetes DotNetify y DotNetify.Blazor.

Configurar DotNetify

Para configurar DotNetify, abra Startup.cs y utilice los métodos ConfigureServices y Configure.

using DotNetify;
using DotNetify.Blazor;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
        services.AddServerSideBlazor();
        services.AddSignalR();
        services.AddDotNetify();
    }
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }
        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapBlazorHub();
            endpoints.MapFallbackToPage("/_Host");
            endpoints.MapHub<DotNetifyHub>("/dotnetify");
        });
    }
}

using DotNetify;
using DotNetify.Blazor;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
        services.AddServerSideBlazor();
        services.AddSignalR();
        services.AddDotNetify();
    }
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }
        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapBlazorHub();
            endpoints.MapFallbackToPage("/_Host");
            endpoints.MapHub<DotNetifyHub>("/dotnetify");
        });
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Crear un ViewModel

Cree un nuevo archivo de clase en su proyecto(HelloWorldViewModel.cs, por ejemplo) y diseñar un ViewModel básico.

using DotNetify;
public class HelloWorldViewModel : BaseVM
{
    public string Greetings => "Hello, World!";
}

using DotNetify;
public class HelloWorldViewModel : BaseVM
{
    public string Greetings => "Hello, World!";
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Registrar ViewModel

Antes de registrar el ViewModel, abra Program.cs.

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }
    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            })
            .ConfigureServices(services =>
            {
                services.AddTransient<HelloWorldViewModel>();
            });
}

using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }
    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            })
            .ConfigureServices(services =>
            {
                services.AddTransient<HelloWorldViewModel>();
            });
}

Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting
Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		CreateHostBuilder(args).Build().Run()
	End Sub
	Public Shared Function CreateHostBuilder(ByVal args() As String) As IHostBuilder
		Return Host.CreateDefaultBuilder(args).ConfigureWebHostDefaults(Sub(webBuilder)
				webBuilder.UseStartup(Of Startup)()
		End Sub).ConfigureServices(Sub(services)
				services.AddTransient(Of HelloWorldViewModel)()
		End Sub})
	End Function

Crear componente Blazor

En su proyecto, añada un nuevo componente Blazor(como HelloWorld.razor) y conectarlo al ViewModel.

@page "/"
@using DotNetify
@using DotNetify.Blazor
@inject IDotNetifyService DotNetify
<h3>@greetings</h3>
@code {
    private string greetings;
    protected override async Task OnInitializedAsync()
    {
        var vm = await DotNetify.ConnectAsync<HelloWorldViewModel>(this);
        greetings = vm.Greetings;
    }
}

@page "/"
@using DotNetify
@using DotNetify.Blazor
@inject IDotNetifyService DotNetify
<h3>@greetings</h3>
@code {
    private string greetings;
    protected override async Task OnInitializedAsync()
    {
        var vm = await DotNetify.ConnectAsync<HelloWorldViewModel>(this);
        greetings = vm.Greetings;
    }
}

'INSTANT VB TODO TASK: The following line could not be converted:
page "/" [using] DotNetify [using] DotNetify.Blazor inject IDotNetifyService DotNetify (Of h3) greetings</h3> code
If True Then
	private String greetings
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	protected override async Task OnInitializedAsync()
'	{
'		var vm = await DotNetify.ConnectAsync<HelloWorldViewModel>(Me);
'		greetings = vm.Greetings;
'	}
End If

Configura la aplicación para utilizar DotNetify, Blazor, Razor Pages y SignalR. Además, configura los puntos finales y el enrutamiento de DotNetify y Blazor. Describe un ViewModel básico con un atributo que devuelve un mensaje de saludo. El HelloWorldViewModel se registra como un servicio temporal. Componente de Blazor que establece una conexión con el HelloWorldViewModel, obtiene el texto de bienvenida, y lo pone en la pantalla.

Primeros pasos

Debe crear un proyecto .NET e incorporar ambas bibliotecas a su aplicación para poder utilizar DotNetify e IronPDF. Aquí tienes un tutorial paso a paso para ponerte manos a la obra:

¿Qué es IronPDF?

La biblioteca .NET con más funcionesBiblioteca PDF IronPDF permite a los programas en C# producir, leer y editar documentos PDF. Con este programa, los desarrolladores pueden convertir rápidamente información HTML, CSS y JavaScript en PDF de alta calidad listos para imprimir. Entre las tareas más cruciales están añadir encabezados y pies de página, dividir y combinar PDF, añadir marcas de agua a los documentos y convertir HTML a PDF.

IronPDF es útil para diversas aplicaciones porque es compatible tanto con .NET Framework como con .NET Core. Por su sencillez de uso y riqueza de información, los PDF permiten a los desarrolladores integrarlos fácilmente en sus productos. Dado que IronPDF puede manejar diseños y formatos de datos complejos, los PDF que genera como salida son bastante similares al texto HTML original del cliente. IronPDF también es compatible con aplicaciones multiplataforma como Windows, web y entornos móviles.

Características de IronPDF

Generación de PDF a partir de HTML

Convierte JavaScript, HTML y CSS a PDF. IronPDF es compatible con media queries y responsive design, dos estándares web contemporáneos. Su compatibilidad con los modernos estándares web es útil para decorar dinámicamente facturas, informes y documentos PDF con HTML y CSS.

Edición de PDF

A los PDF preexistentes se les puede añadir texto, imágenes y otros contenidos. Los desarrolladores pueden utilizar IronPDF para extraer texto e imágenes de archivos PDF, combinar numerosos PDF en un solo archivo, dividir archivos PDF en varios documentos independientes e incluir marcas de agua, anotaciones, encabezados y pies de página.

Conversión de PDF

Convierte varios formatos de archivo, incluidos Word, Excel y archivos de imagen, a formato PDF. IronPDF también admite la conversión de PDF a imágenes(PNG, JPEG, etc.).

**Rendimiento y fiabilidad

El alto rendimiento y la fiabilidad son cualidades de diseño deseadas en los entornos industriales. Con IronPDF, los desarrolladores pueden gestionar grandes conjuntos de documentos con facilidad.

Instalar IronPDF

Para obtener las herramientas que necesita para trabajar con archivos PDF en proyectos .NET, instale el paquete IronPDF.

dotnet add package IronPdf

dotnet add package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf

Integrar DotNetify con IronPDF

Configurar DotNetify

Configuración de inicio: Abre Startup.cs y utiliza los métodos ConfigureServices y Configure para configurar DotNetify.

using DotNetify;
using DotNetify.Blazor;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
        services.AddServerSideBlazor();
        services.AddSignalR();
        services.AddDotNetify();
    }
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }
        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapBlazorHub();
            endpoints.MapFallbackToPage("/_Host");
            endpoints.MapHub<DotNetifyHub>("/dotnetify");
        });
    }
}

using DotNetify;
using DotNetify.Blazor;
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddRazorPages();
        services.AddServerSideBlazor();
        services.AddSignalR();
        services.AddDotNetify();
    }
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Error");
            app.UseHsts();
        }
        app.UseHttpsRedirection();
        app.UseStaticFiles();
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapBlazorHub();
            endpoints.MapFallbackToPage("/_Host");
            endpoints.MapHub<DotNetifyHub>("/dotnetify");
        });
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Crear un modelo de vista

En su proyecto, añada un nuevo archivo de clase(como PdfViewModel.cs) y crear un ViewModel que producirá un PDF.

using DotNetify;
using IronPdf;
public class PdfViewModel : BaseVM
{
    public string PdfUrl { get; set; }
    public void GeneratePdf()
    {
        var Renderer = new ChromePdfRenderer();
        var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
        var OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf";
        PdfDocument.SaveAs(OutputPath);
        PdfUrl = "/PdfFiles/HelloWorld.pdf";
        Changed(nameof(PdfUrl));
    }
}

using DotNetify;
using IronPdf;
public class PdfViewModel : BaseVM
{
    public string PdfUrl { get; set; }
    public void GeneratePdf()
    {
        var Renderer = new ChromePdfRenderer();
        var PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>");
        var OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf";
        PdfDocument.SaveAs(OutputPath);
        PdfUrl = "/PdfFiles/HelloWorld.pdf";
        Changed(nameof(PdfUrl));
    }
}

Imports DotNetify
Imports IronPdf
Public Class PdfViewModel
	Inherits BaseVM

	Public Property PdfUrl() As String
	Public Sub GeneratePdf()
		Dim Renderer = New ChromePdfRenderer()
		Dim PdfDocument = Renderer.RenderHtmlAsPdf("<h1>Hello World!</h1>")
		Dim OutputPath = "wwwroot/PdfFiles/HelloWorld.pdf"
		PdfDocument.SaveAs(OutputPath)
		PdfUrl = "/PdfFiles/HelloWorld.pdf"
		Changed(NameOf(PdfUrl))
	End Sub
End Class

Añade un nuevo componente Blazor a tu proyecto(como GeneratePdf.razor) y vincularlo al ViewModel para crear un componente Blazor.

@page "/"
@using DotNetify
@using DotNetify.Blazor
@inject IDotNetifyService DotNetify
<PageTitle>Generate PDF</PageTitle>
<h3>Generate PDF</h3>
<button @onclick="GeneratePdf">Generate PDF</button>
@if (!string.IsNullOrEmpty(pdfUrl))
{
    <a href="@pdfUrl" target="_blank">Download PDF</a>
}
@code {
    private string pdfUrl;
    protected override async Task OnInitializedAsync()
    {
        var vm = await DotNetify.ConnectAsync<PdfViewModel>(this);
        pdfUrl = vm.PdfUrl;
        vm.PropertyChanged += (sender, args) =>
        {
            if (args.PropertyName == nameof(vm.PdfUrl))
            {
                pdfUrl = vm.PdfUrl;
                StateHasChanged();
            }
        };
    }
    private void GeneratePdf()
    {
        DotNetify.CallMethod("GeneratePdf");
    }
}

@page "/"
@using DotNetify
@using DotNetify.Blazor
@inject IDotNetifyService DotNetify
<PageTitle>Generate PDF</PageTitle>
<h3>Generate PDF</h3>
<button @onclick="GeneratePdf">Generate PDF</button>
@if (!string.IsNullOrEmpty(pdfUrl))
{
    <a href="@pdfUrl" target="_blank">Download PDF</a>
}
@code {
    private string pdfUrl;
    protected override async Task OnInitializedAsync()
    {
        var vm = await DotNetify.ConnectAsync<PdfViewModel>(this);
        pdfUrl = vm.PdfUrl;
        vm.PropertyChanged += (sender, args) =>
        {
            if (args.PropertyName == nameof(vm.PdfUrl))
            {
                pdfUrl = vm.PdfUrl;
                StateHasChanged();
            }
        };
    }
    private void GeneratePdf()
    {
        DotNetify.CallMethod("GeneratePdf");
    }
}

'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@page "/" @using DotNetify @using DotNetify.Blazor @inject IDotNetifyService DotNetify (Of PageTitle) Generate PDF</PageTitle> (Of h3) Generate PDF</h3> <button @onclick="GeneratePdf"> Generate PDF</button> @if(!string.IsNullOrEmpty(pdfUrl))
'{
'	<a href="@pdfUrl" target="_blank"> Download PDF</a>
'}
code
If True Then
	private String pdfUrl
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	protected override async Task OnInitializedAsync()
'	{
'		var vm = await DotNetify.ConnectAsync<PdfViewModel>(Me);
'		pdfUrl = vm.PdfUrl;
'		vm.PropertyChanged += (sender, args) =>
'		{
'			if (args.PropertyName == nameof(vm.PdfUrl))
'			{
'				pdfUrl = vm.PdfUrl;
'				StateHasChanged();
'			}
'		};
'	}
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	private void GeneratePdf()
'	{
'		DotNetify.CallMethod("GeneratePdf");
'	}
End If

El manejo de datos en tiempo real y la producción dinámica de PDF son posibles gracias a la integración de DotNetify e IronPDF en una aplicación C# ASP.NET Core Blazor. Para habilitar Blazor del lado del servidor y las funciones en tiempo real, el primer paso en la configuración es configurar el proyecto en Startup.cs, donde se registran los servicios para Razor Pages, Blazor Server, SignalR y DotNetify.

La lógica de generación de PDF de IronPDF se define en el ViewModel PdfViewModel.cs. Bastan unas pocas líneas de código para generar el archivo PDF. Una de sus características es la función GeneratePdf, que toma información HTML y la convierte en PDF. Almacena el archivo en el servidor y actualiza la propiedad PdfUrl para que el cliente sepa dónde está el nuevo archivo. Este ViewModel se comunica con el componente GeneratePdf.razor Blazor.

Para que el cliente pueda llamar a la función GeneratePdf y reaccionar a los cambios de propiedades, se conecta a PdfViewModel a través de IDotNetifyService y se vincula a sus propiedades. El componente invoca el método del ViewModel cuando el usuario pulsa el botón "Generar PDF",creación del PDF y actualizando dinámicamente la URL de descarga. Con esta configuración, la aplicación web ofrece una experiencia de usuario receptiva y atractiva al integrar las potentes funciones de generación de documentos de IronPDF con la sincronización de datos en tiempo real de DotNetify.

Conclusión

La sincronización de datos en tiempo real y la producción dinámica de PDF se combinan en una aplicación C# ASP.NET Core Blazor mediante la integración de DotNetify con IronPDF. Las aplicaciones interactivas y con capacidad de respuesta son posibles gracias a DotNetify, que permite una comunicación fluida entre los componentes Blazor del lado del cliente y los ViewModels del lado del servidor. Esto se mejora con IronPDF, que ofrece potentes herramientas para crear y modificar PDF directamente desde la lógica del lado del servidor. Con la ayuda de esta potente mezcla, los desarrolladores podrán crear aplicaciones capaces de crear y enviar documentos únicos, así como actualizaciones en tiempo real.

Esta integración aprovecha al máximo el tratamiento de datos en tiempo real y las tecnologías de generación de documentos para mejorar la experiencia del usuario, ya sea para la elaboración de informes, la facturación o cualquier otra operación relacionada con los documentos. Los desarrolladores pueden configurar y utilizar estas herramientas de forma rápida y sencilla siguiendo los procedimientos indicados, lo que abre un mundo de posibilidades para el desarrollo de aplicaciones web contemporáneas.

Puede utilizar OCR, escaneado de códigos de barras, producción de PDF, conexión a Excel y mucho más con IronPDF yHerramientas para desarrolladores de IronSoftware para desarrolladores que deseen probar su amplio conjunto de funciones.

Siempre que se especifiquen detalladamente las alternativas de licencia relacionadas con el proyecto, a los promotores les resultará más fácil elegir el mejor modelo. Las ventajas mencionadas facilitan la aplicación oportuna, coordinada y eficaz de soluciones por parte de los desarrolladores para una gran variedad de problemas.