CSLA .NET (Cómo Funciona para Desarrolladores)

¿Qué es CSLA .NET?

Rocky Lhotka creó el marco CSLA .NET de código abierto (Arquitectura Lógica Escalable Basada en Componentes) para ayudar a los programadores a construir aplicaciones comerciales confiables, escalables y gestionables para la plataforma .NET. Promueve una clara división de responsabilidades al enfatizar el uso de objetos de negocio que contienen toda la lógica empresarial, criterios de validación y verificaciones de autorización. La mantenibilidad y escalabilidad se mejoran gracias a la capacidad de CSLA para apoyar diseños n-tier y abstractar la lógica de acceso a datos, lo que permite desplegar la lógica empresarial a través de varias capas.

Además de apoyar objetos móviles, puede usarse con una variedad de tecnologías de UI, incluidos Windows Forms, WPF, ASP.NET MVC y Blazor, para habilitar un procesamiento enriquecido del cliente y eficiente en el servidor de formularios web. El desarrollo de aplicaciones de nivel empresarial receptivas, efectivas y consistentes se hace más fácil gracias a esta flexibilidad, que garantiza que la lógica empresarial pueda reutilizarse de forma fiable a través de varias capas de presentación.

Install-Package CSLA
Install-Package CSLA-Server

Install-Package CSLA
Install-Package CSLA-Server

using System;
using Csla.Configuration;
namespace CslaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize CSLA .NET
            var applicationContext = new ApplicationContext();
            // Use dependency injection if needed (for ASP.NET Core or other frameworks)
            var services = new ServiceCollection();
            services.AddCsla();
            var provider = services.BuildServiceProvider();
            applicationContext = provider.GetService<ApplicationContext>();
            Console.WriteLine("CSLA .NET is configured and ready to use!");
        }
    }
}

using System;
using Csla.Configuration;
namespace CslaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize CSLA .NET
            var applicationContext = new ApplicationContext();
            // Use dependency injection if needed (for ASP.NET Core or other frameworks)
            var services = new ServiceCollection();
            services.AddCsla();
            var provider = services.BuildServiceProvider();
            applicationContext = provider.GetService<ApplicationContext>();
            Console.WriteLine("CSLA .NET is configured and ready to use!");
        }
    }
}

using Csla;
namespace CslaDemo
{
    [Serializable]
    public class Person : BusinessBase<Person>
    {
        public static readonly PropertyInfo<int> IdProperty = RegisterProperty<int>(c => c.Id);
        public int Id
        {
            get => GetProperty(IdProperty);
            set => SetProperty(IdProperty, value);
        }
        public static readonly PropertyInfo<string> NameProperty = RegisterProperty<string>(c => c.Name);
        public string Name
        {
            get => GetProperty(NameProperty);
            set => SetProperty(NameProperty, value);
        }
        protected override void AddBusinessRules()
        {
            // Add validation rules
            BusinessRules.AddRule(new Csla.Rules.CommonRules.Required(NameProperty));
        }
        // Data access methods
        [Fetch]
        private void DataPortal_Fetch(int id)
        {
            // Simulate data fetch
            Id = id;
            Name = "John Doe";
        }
        [Create]
        private void DataPortal_Create()
        {
            // Initialize default values
            Id = -1;
            Name = "New Person";
        }
    }
}

using Csla;
namespace CslaDemo
{
    [Serializable]
    public class Person : BusinessBase<Person>
    {
        public static readonly PropertyInfo<int> IdProperty = RegisterProperty<int>(c => c.Id);
        public int Id
        {
            get => GetProperty(IdProperty);
            set => SetProperty(IdProperty, value);
        }
        public static readonly PropertyInfo<string> NameProperty = RegisterProperty<string>(c => c.Name);
        public string Name
        {
            get => GetProperty(NameProperty);
            set => SetProperty(NameProperty, value);
        }
        protected override void AddBusinessRules()
        {
            // Add validation rules
            BusinessRules.AddRule(new Csla.Rules.CommonRules.Required(NameProperty));
        }
        // Data access methods
        [Fetch]
        private void DataPortal_Fetch(int id)
        {
            // Simulate data fetch
            Id = id;
            Name = "John Doe";
        }
        [Create]
        private void DataPortal_Create()
        {
            // Initialize default values
            Id = -1;
            Name = "New Person";
        }
    }
}

using System;
using Csla;
using Microsoft.Extensions.DependencyInjection;
namespace CslaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize CSLA .NET
            var services = new ServiceCollection();
            services.AddCsla();
            var provider = services.BuildServiceProvider();
            var applicationContext = provider.GetService<ApplicationContext>();
            var db = provider.GetRequiredService<IDataPortal<Person>>();
            // Create a new person
            var newPerson = db.Create();
            Console.WriteLine($"New Person: {newPerson.Name}");
            // Fetch an existing person
            var existingPerson = db.Fetch(1);
            Console.WriteLine($"Fetched Person: {existingPerson.Name}");
        }
    }
}

using System;
using Csla;
using Microsoft.Extensions.DependencyInjection;
namespace CslaDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Initialize CSLA .NET
            var services = new ServiceCollection();
            services.AddCsla();
            var provider = services.BuildServiceProvider();
            var applicationContext = provider.GetService<ApplicationContext>();
            var db = provider.GetRequiredService<IDataPortal<Person>>();
            // Create a new person
            var newPerson = db.Create();
            Console.WriteLine($"New Person: {newPerson.Name}");
            // Fetch an existing person
            var existingPerson = db.Fetch(1);
            Console.WriteLine($"Fetched Person: {existingPerson.Name}");
        }
    }
}

Empezando

Primero debe configurar su proyecto, usar CSLA para construir objetos de negocio y IronPDF para crear PDFs para comenzar a usar CSLA e IronPDF en un proyecto C#. Aquí hay una guía detallada para lograr esto.

Install-Package IronPdf

Iniciar CSLA .NET y generar un PDF con IronPDF

Use el objeto de negocio Persona que creamos anteriormente e inicie el marco CSLA .NET en su archivo Program.cs. A continuación, use IronPDF para crear un PDF.

using Csla;
using IronPdf;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Text;
namespace CslaIronPdfDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Setup dependency injection
            var services = new ServiceCollection();
            services.AddCsla();
            var provider = services.BuildServiceProvider();
            var applicationContext = provider.GetRequiredService<ApplicationContext>();
            var db = provider.GetRequiredService<IDataPortal<Person>>();
            // Create a new person
            var newPerson = db.Create();
            // Display the new person
            Console.WriteLine($"New Person: {newPerson.Name}");
            // Fetch an existing person
            var existingPerson = db.Fetch(1);
            // Display the fetched person
            Console.WriteLine($"Fetched Person: {existingPerson.Name}");
            // Generate PDF
            var htmlContent = new StringBuilder();
            htmlContent.Append("<h1>Person Details</h1>");
            htmlContent.Append($"<p><strong>New Person:</strong> {newPerson.Name}</p>");
            htmlContent.Append($"<p><strong>Fetched Person:</strong> {existingPerson.Name}</p>");
            // Create PDF
            var Renderer = new HtmlToPdf();
            var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent.ToString());
            // Save PDF
            var outputPath = "PersonDetails.pdf";
            pdfDocument.SaveAs(outputPath);
            Console.WriteLine($"PDF generated and saved to {outputPath}");
        }
    }
}

using Csla;
using IronPdf;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Text;
namespace CslaIronPdfDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Setup dependency injection
            var services = new ServiceCollection();
            services.AddCsla();
            var provider = services.BuildServiceProvider();
            var applicationContext = provider.GetRequiredService<ApplicationContext>();
            var db = provider.GetRequiredService<IDataPortal<Person>>();
            // Create a new person
            var newPerson = db.Create();
            // Display the new person
            Console.WriteLine($"New Person: {newPerson.Name}");
            // Fetch an existing person
            var existingPerson = db.Fetch(1);
            // Display the fetched person
            Console.WriteLine($"Fetched Person: {existingPerson.Name}");
            // Generate PDF
            var htmlContent = new StringBuilder();
            htmlContent.Append("<h1>Person Details</h1>");
            htmlContent.Append($"<p><strong>New Person:</strong> {newPerson.Name}</p>");
            htmlContent.Append($"<p><strong>Fetched Person:</strong> {existingPerson.Name}</p>");
            // Create PDF
            var Renderer = new HtmlToPdf();
            var pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent.ToString());
            // Save PDF
            var outputPath = "PersonDetails.pdf";
            pdfDocument.SaveAs(outputPath);
            Console.WriteLine($"PDF generated and saved to {outputPath}");
        }
    }
}

El ejemplo proporcionado muestra cómo crear, validar y generar PDFs a partir de objetos de negocio utilizando una aplicación de consola .NET 6 que combina CSLA.NET con IronPDF. La instalación de los paquetes necesarios de IronPDF y CSLA.NET utilizando NuGet es el primer paso en la configuración del proyecto. El BusinessBase de CSLA se utiliza para describir el hogar primario de su objeto de negocio, Persona.

Encapsula características como Nombre e ID e incluye reglas de negocio para validar estas propiedades. La implementación de métodos de fábrica y métodos de acceso a datos se encarga de la generación de objetos y la recuperación de datos. La inyección de dependencias se utiliza para iniciar el contexto de la aplicación CSLA en el archivo Program.cs. Luego, el código muestra cómo usar las funciones de DataPortal de CSLA para crear un nuevo objeto Persona y recuperar uno existente.

Por último, utilizando la función HtmlToPdf de IronPDF, se crea información HTML, incluidos los detalles de la persona, y se convierte en un PDF para conversión de HTML a PDF, demostrando un método útil de crear informes empresariales en un formato PDF. Este ejemplo demuestra cómo la generación de documentos en una aplicación .NET puede integrarse sin problemas con la gestión de datos y la lógica de negocio.

Conclusión

En resumen, la integración de IronPDF y CSLA .NET en una aplicación C# muestra qué tan bien funcionan juntos para gestionar la lógica de negocio y producir documentos pulidos. CSLA .NET ofrece un marco sólido para gestionar el acceso a datos, establecer y hacer cumplir reglas de negocio y garantizar la consistencia de los objetos de negocio. Este marco mejora la mantenibilidad del código y simplifica la lógica de negocio intrincada.

Además, IronPDF proporciona una interfaz fácil de usar para crear y modificar documentos PDF, haciendo posible crear informes completos con formateo directamente desde los datos de la aplicación. La combinación de estas tecnologías permite a los desarrolladores crear aplicaciones empresariales complejas que producen salidas de documentos de alta calidad mientras cumplen con requisitos empresariales, optimizan flujos de trabajo y aumentan los niveles de productividad.

Su conjunto de herramientas para el desarrollo .NET se completa con las opciones de licenciamiento de IronPDF e Iron Software que combinan los sistemas y suite extremadamente versátiles de Iron Software con su soporte básico para proporcionar más aplicaciones y características en línea, junto con un desarrollo más eficiente, por un precio inicial de $799.

Los desarrolladores pueden decidir más fácilmente cuál modelo es la mejor práctica si las opciones de licencia son específicas para el proyecto y fáciles de entender. Los desarrolladores ahora pueden manejar una variedad de problemas de una manera sencilla, eficiente y perfectamente conectada gracias a estas ventajas.