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

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

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 Person-Geschäftsobjekt, das wir zuvor erstellt haben, und initialisieren Sie das CSLA .NET Framework in Ihrer Program.cs-Datei. Verwenden Sie anschließend IronPDF, um ein PDF zu erstellen.

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

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. Dependency Injection wird verwendet, um den CSLA-Anwendungskontext in der Program.cs-Datei zu initialisieren. Der Code zeigt dann, wie DataPortal-Funktionen von CSLA verwendet werden, um ein neues Person-Objekt zu erstellen und ein bestehendes 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.

Ihr Werkzeugkasten für .NET-Entwicklung wird mit den Lizenzierungsoptionen von IronPDF und Iron Software vervollständigt, die die extrem vielseitigen Systeme und die Suite von Iron Software mit ihrem Kernsupport kombinieren, um mehr Webanwendungen und Funktionen sowie effizientere Entwicklung zu einem Einstiegspreis von $799 zu bieten.

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.