Osiągnięcie równowagi między logiką biznesową, dostępem do danych i projektowaniem interfejsu użytkownika ma kluczowe znaczenie w obecnym scenariuszu tworzenia aplikacji korporacyjnych. Component-based Scałable Logical Architecture (CSLA) to popularny framework programistyczny, który oferuje stabilną, skalowalną architekturę do tworzenia łatwych w zarządzaniu aplikacji biznesowych, mającą na celu usprawnienie tego procesu. Kod źródłowy można uczynić bardziej przystępnym i łatwiejszym do testowania, wykorzystując CSLA .NET, aby pomóc programistom w wyraźnym oddzieleniu logiki biznesowej od dostępu do danych.

Programiści mogą wykorzystać bibliotekę IronPDF for .NET PDF Generation Library do tworzenia wysokiej jakości dokumentów PDF oraz uporządkowane podejście CSLA do zarządzania logiką biznesową poprzez połączenie CSLA .NET z IronPDF. Z tego połączenia mogą skorzystać zwłaszcza aplikacje wymagające rozbudowanej prezentacji danych, automatycznego przygotowywania dokumentów i dynamicznego generowania raportów. Dzięki temu interfejsowi firmy mogą tworzyć dopracowane dokumenty bezpośrednio ze swoich aplikacji .NET, gwarantować spójność danych i usprawniać operacje.

W tym samouczku przyjrzymy się udanej integracji CSLA z IronPDF, podkreślając przydatne funkcje i przedstawiając szczegółowy proces wdrażania tej integracji w aplikacji napisanej w języku C#. Ta integracja może znacznie zwiększyć możliwości Twojej aplikacji, czyniąc ją bardziej efektywną i wszechstronną, niezależnie od tego, czy tworzysz proste aplikacje komercyjne, czy skomplikowane rozwiązania dla Enterprise.

Czym jest CSLA .NET?

Rocky Lhotka stworzył framework open source CSLA .NET (Component-based Scałable 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.

Model obiektów biznesowych

Zapewnia jednolite stosowanie silnika reguł autoryzacji, reguł biznesowych i reguł walidacji w całej aplikacji poprzez enkapsulację logiki biznesowej w obiektach biznesowych.

Abstrakcja dostępu do danych

Umożliwia elastyczne oddzielenie logiki dostępu do danych od logiki biznesowej, co zwiększa łatwość konserwacji oraz ułatwia przełączanie się między technologiami warstwy dostępu do danych i warstwy biznesowej oraz przeprowadzanie testów.

Weryfikacja i autoryzacja

Reguły biznesowe są wdrażane i stale egzekwowane dzięki wbudowanej funkcjonalności służącej do ustanawiania i egzekwowania kontroli autoryzacji oraz reguł walidacji obiektów biznesowych, co gwarantuje, że żadna z reguł nie zostanie złamana.

Architektura wielowarstwowa

Obsługuje projekty wielowarstwowe, które poprawiają skalowalność i umożliwiają tworzenie aplikacji rozproszonych poprzez rozdzielenie logiki biznesowej na kilka warstw (takich jak klient, serwer i baza danych).

Obsługa obiektów mobilnych

Ułatwia tworzenie obiektów mobilnych, które mogą przemieszczać się między klientem a serwerem, obsługując sytuacje takie jak aplikacje typu rich client oraz efektywne przetwarzanie po stronie serwera, które wymagają obiektów biznesowych po obu stronach.

Niezależność od interfejsu użytkownika

Umożliwia wykorzystanie obiektów biznesowych z różnymi technologiami interfejsu użytkownika, ułatwiając ponowne wykorzystanie kodu i zapewniając spójność w wielu warstwach prezentacji. Technologie te obejmują Windows Forms, WPF, ASP.NET MVC i Blazor.

Programowanie asynchroniczne

Umożliwia tworzenie responsywnych aplikacji, które wykonują czasochłonne zadania bez zakłócania działania interfejsu użytkownika dzięki obsłudze modeli programowania asynchronicznego.

Deklaratywne reguły biznesowe

Ułatwia zarządzanie złożoną logiką biznesową, zapewniając deklaratywne środki definiowania reguł, które są automatycznie stosowane.

Integracja z mapowaniem obiektowo-relacyjnym (ORM)

Umożliwia płynne połączenie obiektów biznesowych i warstwy dostępu do danych z ORM, takimi jak Entity Framework.

Serializacja i możliwości mobilne

Umożliwia serializację obiektów biznesowych w kontekstach mobilnych, upraszczając tworzenie aplikacji wymagających transmisji danych przez bariery sieciowe.

Zarządzanie transakcjami

Obsługuje procesy transakcyjne, szczególnie w systemach rozproszonych obsługujących aplikacje, w celu zagwarantowania spójności i integralności danych.

Obsługa zdarzeń i powiązanie danych

Zapewniono silne wsparcie dla obsługi zdarzeń i powiązania danych; jest to szczególnie przydatne w przypadku aplikacji UI, które muszą dostarczać powiadomienia i aktualizacje w czasie rzeczywistym.

Zabezpieczenia oparte na rolach

Zawiera funkcje bezpieczeństwa oparte na rolach, które ograniczają dostęp do właściwości i obiektów biznesowych, tak aby tylko uprawnieni użytkownicy mogli wykonywać określone zadania.

Lokalizacja i globalizacja

Umożliwia tworzenie aplikacji, które mogą być używane w wielu kontekstach językowych i kulturowych, dzięki obsłudze lokalizacji i globalizacji.

Rozszerzalność

Niezwykle elastyczne i wielokrotnego użytku, umożliwiające programistom modyfikowanie i rozbudowę frameworka w celu zaspokojenia konkretnych potrzeb biznesowych.

Utwórz i skonfiguruj CSLA .NET

Skonfigurowanie projektu, zainstalowanie wymaganych pakietów i skonfigurowanie frameworka to tylko niektóre z etapów tworzenia i konfiguracji aplikacji CSLA .NET. Oto obszerny samouczek, który pomoże Ci rozpocząć pracę z CSLA .NET:

Utwórz nowy projekt Visual Studio

Za pomocą programu Visual Studio tworzenie projektu konsolowego jest proste. Skorzystaj z tych prostych kroków, aby uruchomić aplikację konsolową w środowisku Visual Studio:

Przed użyciem upewnij się, że masz zainstalowane Visual Studio na swoim komputerze.

Rozpocznij nowy projekt

Wybierz Plik, Projekt, a następnie kliknij menu Nowy.

Z poniższej listy szablonów projektów wybierz szablon "Console App" lub "Console App (.NET Core)".

Wypełnij sekcję "Nazwa", aby nadać nazwę swojemu projektowi.

Zdecyduj, gdzie chcesz zapisać projekt.

Kliknięcie przycisku "Utwórz" spowoduje otwarcie projektu aplikacji konsolowej.

Zainstaluj pakiet CSLA .NET

Następnym krokiem jest instalacja pakietów CSLA .NET NuGet. Uruchom następujące polecenia w konsoli menedżera pakietów NuGet (Narzędzia -> Menedżer pakietów NuGet -> Konsola menedżera pakietów):

Install-Package CSLA
Install-Package CSLA-Server

Install-Package CSLA
Install-Package CSLA-Server

Pakiety te zawierają komponenty po stronie serwera, a także podstawową funkcjonalność CSLA.

Skonfiguruj CSLA .NET w swoim projekcie

Dla aplikacji konsolowej zainicjuj konfigurację CSLA.NET w swoim pliku Program.cs. W pliku Startup.cs aplikacji ASP.NET Core należy to zrobić.

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

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

Utwórz obiekt biznesowy

Aby uchwycić logikę biznesową, utwórz podstawowy obiekt biznesowy. Zamierzamy stworzyć klasę Person dla tego przykładu.

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

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

Użyj obiektu biznesowego

Użyjmy teraz obiektu biznesowego Person z pliku Program.cs.

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

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

Pokaż, jak używać DataPortal do tworzenia nowej osoby i pobierania istniejącej osoby w metodzie Main. Ustal w IDataPortal.

Ta konfiguracja stanowi podstawę do wykorzystania CSLA .NET w aplikacji .NET. Jeśli wymagana jest bardziej zaawansowana logika biznesowa, dostęp do danych i kryteria walidacji, można rozszerzyć tę strategię.

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ąć.

Czym jest IronPDF?

Programy napisane w języku C# mogą korzystać z biblioteki IronPDF do generowania plików PDF w celu tworzenia, odczytywania i edytowania dokumentów PDF. Dzięki tej aplikacji programiści mogą szybko tworzyć wysokiej jakości pliki PDF gotowe do druku na podstawie treści HTML, CSS i JavaScript. Wśród kluczowych funkcji znajdują się: możliwość tworzenia nagłówków i stopek, dzielenie i łączenie plików PDF, dodawanie znaków wodnych do dokumentów oraz konwersja HTML do PDF. IronPDF jest przydatny w wielu zastosowaniach, ponieważ obsługuje zarówno platformę .NET Framework, jak i .NET Core.

Pliki PDF są łatwe w użyciu dla programistów w ich aplikacjach, ponieważ zawierają obszerną dokumentację i są łatwe do zintegrowania. IronPDF z łatwością radzi sobie ze skomplikowanymi układami i formatowaniem, zapewniając, że pliki PDF są wiernym odzwierciedleniem oryginalnego tekstu HTML.

Funkcje IronPDF

Generowanie plików PDF z HTML

Konwertuj HTML, CSS i JavaScript do formatu PDF. Obsługuje nowoczesne standardy internetowe, takie jak zapytania o media i projektowanie responsywne, dzięki czemu jest przydatny do dynamicznego ozdabiania dokumentów PDF, faktur i raportów za pomocą HTML i CSS.

Edycja plików PDF

Możliwe jest dodawanie tekstu, obrazów i innych materiałów do już istniejących plików PDF. Wyodrębnij tekst i obrazy z plików PDF. Połącz wiele plików PDF w jeden plik. Podziel pliki PDF na kilka oddzielnych dokumentów. Dodaj nagłówki, stopki, adnotacje i znaki wodne.

Konwersja plików PDF

Konwertuj pliki WORD, Excel i obrazy oraz inne typy plików do formatu PDF. Konwersja pliku PDF na obraz (PNG, JPEG itp.).

Wydajność i niezawodność

W kontekście przemysłowym pożądanymi cechami projektowymi są wysoka wydajność i niezawodność. Prawidłowo obsługuje duże zbiory dokumentów.

Zainstaluj IronPDF

Zainstaluj pakiet IronPDF, aby uzyskać narzędzia potrzebne do pracy z plikami PDF w projektach .NET.

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 CSLA .NET Framework w swoim pliku Program.cs. Następnie użyj IronPDF do stworzenia 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

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 jest używane do zainicjowania kontekstu aplikacji CSLA w pliku Program.cs. Kod następnie pokazuje, jak używać funkcji DataPortal CSLA do stworzenia nowego obiektu Person i pobrania 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 rozwoju .NET jest kompletny z opcjami licencjonowania IronPDF oraz Iron Software, które łączą niezwykle wszechstronne systemy i pakiet Iron Software z jego podstawowym wsparciem, oferując więcej aplikacji online i funkcji, wraz z bardziej efektywnym rozwojem, w cenie początkowej $999.

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.