CSLA .NET (Jak to działa dla programistów)

Czym jest CSLA .NET?

Rocky Lhotka stworzył framework open source CSLA .NET (Component-based Scalable Logical Architecture), aby pomóc programistom w tworzeniu niezawodnych, rozszerzalnych i łatwych w zarządzaniu aplikacji komercyjnych dla platformy .NET Framework. Promuje jasny podział obowiązków poprzez podkreślanie wykorzystania obiektów biznesowych, które zawierają całą logikę biznesową, kryteria walidacji oraz kontrole autoryzacji. Łatwość konserwacji i skalowalność są poprawione dzięki zdolności CSLA do obsługi projektowania wielowarstwowego i abstrakcyjnej logiki dostępu do danych, co umożliwia wdrażanie logiki biznesowej w kilku warstwach.

Oprócz obsługi obiektów mobilnych, może być również używany z różnymi technologiami interfejsu użytkownika, w tym Windows Forms, WPF, ASP.NET MVC i Blazor, aby umożliwić bogate przetwarzanie po stronie klienta i wydajne przetwarzanie formularzy internetowych po stronie serwera. Dzięki tej elastyczności, która gwarantuje, że logika biznesowa może być niezawodnie ponownie wykorzystywana w kilku warstwach prezentacji, tworzenie responsywnych, skutecznych i spójnych aplikacji na poziomie Enterprise staje się łatwiejsze.

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

Pierwsze kroki

Aby rozpocząć korzystanie z CSLA i IronPDF w projekcie C#, należy najpierw skonfigurować projekt, użyć CSLA do skonstruowania obiektów biznesowych oraz IronPDF do utworzenia plików PDF. Oto szczegółowa instrukcja, jak to osiągnąć.

Install-Package IronPdf

Zainicjuj CSLA .NET i wygeneruj plik PDF za pomocą IronPDF

Użyj obiektu biznesowego Person, który utworzyliśmy wcześniej, i zainicjuj .NET Framework CSLA w pliku Program.cs. Następnie użyj IronPDF do utworzenia pliku 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

Przedstawiony przykład pokazuje, jak tworzyć, weryfikować i generować pliki PDF z obiektów biznesowych przy użyciu aplikacji konsolowej .NET 6, która łączy CSLA.NET z IronPDF. Pierwszym krokiem w konfiguracji projektu jest zainstalowanie wymaganych pakietów IronPDF i CSLA.NET za pomocą NuGet. BusinessBase firmy CSLA służy do opisania głównego obiektu biznesowego, jakim jest osoba.

Zawiera cechy takie jak Nazwa i Identyfikator oraz reguły biznesowe służące do walidacji tych właściwości. Wdrożenie metod fabrycznych i metod dostępu do danych zajmuje się generowaniem obiektów i pobieraniem danych. Wstrzykiwanie zależności służy do inicjalizacji kontekstu aplikacji CSLA w pliku Program.cs. Kod pokazuje następnie, jak używać funkcji DataPortal biblioteki CSLA do tworzenia nowego obiektu Person oraz pobierania istniejącego.

Na koniec, korzystając z funkcji HtmlToPdf programu IronPDF, tworzone są informacje HTML, w tym dane osobowe, i przekształcane w plik PDF w ramach konwersji HTML na PDF, co stanowi przydatną metodę tworzenia raportów biznesowych w formacie PDF. Ten przykład pokazuje, w jaki sposób generowanie dokumentów w aplikacji .NET może być płynnie zintegrowane z zarządzaniem danymi i logiką biznesową.

Wnioski

Podsumowując, integracja IronPDF i CSLA .NET w aplikacji C# pokazuje, jak dobrze współpracują one ze sobą w zarządzaniu logiką biznesową i tworzeniu dopracowanych dokumentów. CSLA .NET oferuje solidny framework do zarządzania dostępem do danych, ustanawiania i egzekwowania reguł biznesowych oraz gwarantowania spójności obiektów biznesowych. Ten framework poprawia łatwość utrzymania kodu i usprawnia skomplikowaną logikę biznesową.

Ponadto IronPDF zapewnia łatwy w użyciu interfejs do tworzenia i modyfikowania dokumentów PDF, umożliwiając tworzenie kompleksowych raportów z formatowaniem bezpośrednio na podstawie danych aplikacji. Połączenie tych technologii pozwala programistom tworzyć złożone aplikacje Enterprise, które generują wysokiej jakości dokumenty, spełniając jednocześnie wymagania biznesowe, optymalizując przepływy pracy i podnosząc poziom produktywności.

Twój zestaw narzędzi do programowania w .NET uzupełniają opcje licencyjne IronPDF i Iron Software, które łączą niezwykle wszechstronne systemy i pakiety Iron Software z podstawowym wsparciem, zapewniając więcej aplikacji i funkcji online, a także bardziej wydajne programowanie, w cenie początkowej $799.

Programiści mogą łatwiej zdecydować, który model jest najlepszy, jeśli opcje licencji są dostosowane do projektu i łatwe do zrozumienia. Dzięki tym zaletom programiści mogą teraz radzić sobie z różnorodnymi problemami w prosty, wydajny i płynnie zintegrowany sposób.