CSLA .NET (Funktionsweise für Entwickler)

Was ist CSLA .NET?

Rocky Lhotka hat das Open-Source-Framework CSLA .NET (Komponentenbasierte skalierbare logische Architektur) erstellt, um Programmierern zu helfen, zuverlässige, erweiterbare und verwaltbare kommerzielle Anwendungen für die .NET-Plattform zu erstellen. Es fördert eine klare Aufgabentrennung, indem es die Verwendung von Geschäftsobjekten betont, die die gesamte Geschäftslogik, Validierungskriterien und Autorisierungsprüfungen enthalten. Die Wartbarkeit und Skalierbarkeit werden durch die Fähigkeit von CSLA verbessert, N-Tier-Design zu unterstützen und Datenzugriffslogik zu abstrahieren, was es ermöglicht, Geschäftslogik über mehrere Schichten bereitzustellen.

Zusätzlich zur Unterstützung mobiler Objekte kann es auch mit einer Vielzahl von UI-Technologien wie Windows Forms, WPF, ASP.NET MVC und Blazor verwendet werden, um eine reichhaltige Client- und effiziente Serverseitenverarbeitung von Webformularen zu ermöglichen. Diese Flexibilität erleichtert die Entwicklung von reaktionsfähigen, effektiven und konsistenten Anwendungen auf Unternehmensebene, die gewährleisten, dass Geschäftslogik zuverlässig über mehrere Präsentationsebenen hinweg wiederverwendet werden kann.

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

Einstieg

Um CSLA und IronPDF in einem C#-Projekt zu verwenden, müssen Sie zuerst Ihr Projekt einrichten, CSLA verwenden, um Geschäftsobjekte zu erstellen, und IronPDF, um PDFs zu erstellen. Hier ist eine detaillierte Anleitung, um dies zu erreichen.

Install-Package IronPdf

Initialisierung von CSLA .NET und Generierung von PDF mit IronPDF

Verwenden Sie das zuvor erstellte Geschäftsobjekt Person und initialisieren Sie das CSLA .NET Framework in Ihrer Datei Program.cs. Erstellen Sie anschließend mit IronPDF eine PDF-Datei.

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

Das angebotene Beispiel zeigt, wie PDFs aus Geschäftsobjekten erstellt, validiert und generiert werden, indem eine .NET 6-Konsolenanwendung, die CSLA.NET mit IronPDF verbindet, genutzt wird. Der erste Schritt beim Einrichten des Projekts besteht darin, die erforderlichen IronPDF- und CSLA.NET-Pakete über NuGet zu installieren. CSLAs BusinessBase wird verwendet, um den primären Speicherort für Ihr Geschäftsobjekt, Person, zu beschreiben.

Es umfasst Eigenschaften wie Name und ID und enthält Geschäftsregeln, um diese Eigenschaften zu validieren. Die Implementierung von Fabrikationsmethoden und Datenzugriffsmethoden kümmert sich um die Objekterstellung und Datenabfrage. Die Abhängigkeitsinjektion wird verwendet, um den CSLA-Anwendungskontext in der Datei Program.cs zu initialisieren. Der Code zeigt anschließend, wie die DataPortal-Funktionen von CSLA verwendet werden, um ein neues Person-Objekt zu erstellen und ein vorhandenes abzurufen.

Letztlich wird mithilfe der HtmlToPdf-Funktion von IronPDF HTML-Informationen, einschließlich der Details der Person, erstellt und in ein PDF für HTML-zu-PDF-Konvertierung umgewandelt, wodurch eine nützliche Methode zur Erstellung von Geschäftsberichten im PDF-Format gezeigt wird. Dieses Beispiel zeigt, wie die Dokumentenerstellung in einer .NET-Anwendung nahtlos mit Datenmanagement und Geschäftslogik integriert werden kann.

Abschluss

Zusammenfassend zeigt die Integration von IronPDF und CSLA .NET in einer C#-Anwendung, wie gut sie zusammenarbeiten, um Geschäftslogik zu verwalten und polierte Dokumente zu erstellen. Ein starkes Framework für das Management von Datenzugriff, das Aufstellen und Durchsetzen von Geschäftsregeln, und die Gewährleistung der Konsistenz von Geschäftsobjekten wird von CSLA .NET geboten. Dieses Framework verbessert die Wartbarkeit des Codes und vereinfacht komplexe Geschäftslogik.

Zusätzlich bietet IronPDF eine einfach zu bedienende Schnittstelle zum Erstellen und Bearbeiten von PDF-Dokumenten, was die Erstellung umfassender Berichte mit Formatierung direkt aus den Daten der Anwendung ermöglicht. Durch die Kombination dieser Technologien können Entwickler komplexe Unternehmensanwendungen erstellen, die hochwertige Dokumentenausgaben erzeugen, während sie Geschäftsforderungen einhalten, Workflows optimieren und Produktivitätsstufen erhöhen.

Mit IronPDF und den Lizenzoptionen von Iron Software , die die äußerst vielseitigen Systeme und die Suite von Iron Software mit dem Kernsupport kombinieren, wird Ihr Toolset für die .NET -Entwicklung komplettiert. So erhalten Sie mehr Online-Apps und Funktionen sowie eine effizientere Entwicklung – und das zu einem Startpreis von $999.

Entwickler können leichter entscheiden, welches Modell die beste Praxis ist, wenn Lizenzoptionen projektspezifisch und leicht verständlich sind. Dank dieser Vorteile können Entwickler eine Vielzahl von Problemen auf einfache, effiziente und nahtlos vernetzte Weise bewältigen.