CSLA .NET (Como funciona para desenvolvedores)

O que é CSLA .NET?

Rocky Lhotka criou o framework de código aberto CSLA .NET (Component-based Scalable Logical Architecture) para ajudar programadores a construir aplicações comerciais confiáveis, expansíveis e gerenciáveis ​​para a plataforma .NET . Promove uma clara divisão de responsabilidades, enfatizando o uso de objetos de negócio que contêm toda a lógica de negócio, critérios de validação e verificações de autorização. A capacidade do CSLA de suportar um design em n camadas e abstrair a lógica de acesso a dados melhora a capacidade de manutenção e escalabilidade, permitindo que a lógica de negócios seja implementada em várias camadas.

Além de oferecer suporte a objetos móveis, também pode ser usado com diversas tecnologias de interface do usuário, incluindo Windows Forms, WPF, ASP.NET MVC e Blazor, para permitir um processamento rico no lado do cliente e eficiente no lado do servidor de formulários da web. O desenvolvimento de aplicações empresariais responsivas, eficazes e consistentes é facilitado por essa flexibilidade, que garante a reutilização confiável da lógica de negócios em diversas camadas de apresentação.

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!");
        }
    }
}

Imports System
Imports Csla.Configuration
Imports Microsoft.Extensions.DependencyInjection

Namespace CslaDemo
    Class Program
        Shared Sub Main(ByVal args As String())
            ' Initialize CSLA .NET
            Dim applicationContext As ApplicationContext = New ApplicationContext()
            ' Use dependency injection if needed (for ASP.NET Core or other frameworks)
            Dim services As New ServiceCollection()
            services.AddCsla()
            Dim provider = services.BuildServiceProvider()
            applicationContext = provider.GetService(Of ApplicationContext)()
            Console.WriteLine("CSLA .NET is configured and ready to use!")
        End Sub
    End Class
End Namespace

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

Imports Csla
Namespace CslaDemo
	<Serializable>
	Public Class Person
		Inherits BusinessBase(Of Person)

		Public Shared ReadOnly IdProperty As PropertyInfo(Of Integer) = RegisterProperty(Of Integer)(Function(c) c.Id)
		Public Property Id() As Integer
			Get
				Return GetProperty(IdProperty)
			End Get
			Set(ByVal value As Integer)
				SetProperty(IdProperty, value)
			End Set
		End Property
		Public Shared ReadOnly NameProperty As PropertyInfo(Of String) = RegisterProperty(Of String)(Function(c) c.Name)
		Public Property Name() As String
			Get
				Return GetProperty(NameProperty)
			End Get
			Set(ByVal value As String)
				SetProperty(NameProperty, value)
			End Set
		End Property
		Protected Overrides Sub AddBusinessRules()
			' Add validation rules
			BusinessRules.AddRule(New Csla.Rules.CommonRules.Required(NameProperty))
		End Sub
		' Data access methods
		<Fetch>
		Private Sub DataPortal_Fetch(ByVal id As Integer)
			' Simulate data fetch
			Me.Id = id
			Name = "John Doe"
		End Sub
		<Create>
		Private Sub DataPortal_Create()
			' Initialize default values
			Id = -1
			Name = "New Person"
		End Sub
	End Class
End Namespace

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

Imports System
Imports Csla
Imports Microsoft.Extensions.DependencyInjection
Namespace CslaDemo
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			' Initialize CSLA .NET
			Dim services = New ServiceCollection()
			services.AddCsla()
			Dim provider = services.BuildServiceProvider()
			Dim applicationContext = provider.GetService(Of ApplicationContext)()
			Dim db = provider.GetRequiredService(Of IDataPortal(Of Person))()
			' Create a new person
			Dim newPerson = db.Create()
			Console.WriteLine($"New Person: {newPerson.Name}")
			' Fetch an existing person
			Dim existingPerson = db.Fetch(1)
			Console.WriteLine($"Fetched Person: {existingPerson.Name}")
		End Sub
	End Class
End Namespace

Começando

Para começar a usar CSLA e IronPDF em um projeto C#, você precisa primeiro configurar seu projeto, usar o CSLA para construir objetos de negócios e o IronPDF para criar PDFs. Segue um guia detalhado de como fazer isso.

Install-Package IronPdf

Inicialize o CSLA .NET e gere um PDF com o IronPDF.

Utilize o objeto de negócios Person que criamos anteriormente e inicialize o CSLA .NET Framework no seu arquivo Program.cs. Em seguida, use o IronPDF para criar um 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}");
        }
    }
}

Imports Csla
Imports IronPdf
Imports Microsoft.Extensions.DependencyInjection
Imports System
Imports System.Text
Namespace CslaIronPdfDemo
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			' Setup dependency injection
			Dim services = New ServiceCollection()
			services.AddCsla()
			Dim provider = services.BuildServiceProvider()
			Dim applicationContext = provider.GetRequiredService(Of ApplicationContext)()
			Dim db = provider.GetRequiredService(Of IDataPortal(Of Person))()
			' Create a new person
			Dim newPerson = db.Create()
			' Display the new person
			Console.WriteLine($"New Person: {newPerson.Name}")
			' Fetch an existing person
			Dim existingPerson = db.Fetch(1)
			' Display the fetched person
			Console.WriteLine($"Fetched Person: {existingPerson.Name}")
			' Generate PDF
			Dim 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
			Dim Renderer = New HtmlToPdf()
			Dim pdfDocument = Renderer.RenderHtmlAsPdf(htmlContent.ToString())
			' Save PDF
			Dim outputPath = "PersonDetails.pdf"
			pdfDocument.SaveAs(outputPath)
			Console.WriteLine($"PDF generated and saved to {outputPath}")
		End Sub
	End Class
End Namespace

O exemplo oferecido mostra como criar, validar e gerar PDFs a partir de objetos de negócios usando um aplicativo de console .NET 6 que combina CSLA .NET com IronPDF. A instalação dos pacotes IronPDF e CSLA .NET necessários, utilizando o NuGet, é o primeiro passo para configurar o projeto. O BusinessBase da CSLA é usado para descrever a localização principal do seu objeto de negócios, Pessoa.

Ele engloba características como Nome e ID e inclui regras de negócio para validar essas propriedades. A implementação de métodos de fábrica e métodos de acesso a dados cuida da geração de objetos e da recuperação de dados. A injeção de dependência é usada para inicializar o contexto da aplicação CSLA no arquivo Program.cs. O código então mostra como usar as funções DataPortal do CSLA para criar um novo objeto Pessoa e recuperar um existente.

Por fim, utilizando o recurso HtmlToPdf do IronPDF, as informações em HTML, incluindo os dados da pessoa, são criadas e convertidas em um PDF para conversão de HTML para PDF , demonstrando um método útil para criar relatórios comerciais em formato PDF. Este exemplo demonstra como a geração de documentos em uma aplicação .NET pode ser perfeitamente integrada ao gerenciamento de dados e à lógica de negócios.

Conclusão

Em resumo, a integração do IronPDF e do CSLA .NET em uma aplicação C# demonstra a excelente sinergia entre eles para gerenciar a lógica de negócios e produzir documentos de alta qualidade. O CSLA .NET oferece uma estrutura robusta para gerenciar o acesso a dados, estabelecer e aplicar regras de negócios e garantir a consistência dos objetos de negócios. Essa estrutura melhora a manutenção do código e simplifica a lógica de negócios complexa.

Além disso, o IronPDF oferece uma interface fácil de usar para criar e modificar documentos PDF, possibilitando a criação de relatórios abrangentes com formatação diretamente a partir dos dados do aplicativo. A combinação dessas tecnologias permite que os desenvolvedores criem aplicativos empresariais complexos que produzem documentos de alta qualidade, atendendo aos requisitos de negócios, otimizando fluxos de trabalho e aumentando os níveis de produtividade.

Seu conjunto de ferramentas para desenvolvimento .NET está completo com o IronPDF e as opções de licenciamento da Iron Software , que combinam os sistemas e o pacote extremamente versáteis da Iron Software com seu suporte principal para fornecer mais aplicativos e recursos online, juntamente com um desenvolvimento mais eficiente, por um preço inicial de $799.

Os desenvolvedores podem decidir mais facilmente qual modelo representa a melhor prática se as opções de licença forem específicas para o projeto e fáceis de entender. Graças a essas vantagens, os desenvolvedores agora podem lidar com uma variedade de problemas de maneira simples, eficiente e perfeitamente integrada.