CSLA .NET（开发人员如何使用）

创建和配置 CSLA .NET 应用程序涉及设置您的项目、安装所需的软件包以及配置框架等几个步骤。 这是一个全面的入门教程，以帮助您开始使用 CSLA .NET：

创建新的 Visual Studio 项目

使用Visual Studio，创建一个控制台项目很简单。 使用以下简便步骤即可在Visual Studio环境中启动控制台应用程序：

在使用之前，请确保您已在计算机上安装了Visual Studio。

启动新项目

选择文件、项目，然后点击新建菜单。

从下面的项目模板参考列表中选择"控制台应用程序"或"控制台应用程序（.NET Core）"模板。

请填写"名称"部分以命名您的项目。

决定存储项目的位置。

点击"创建"将打开控制台应用项目。

安装 CSLA .NET 软件包

接下来安装 CSLA .NET 的 NuGet 软件包。 在 NuGet 包管理器控制台（工具 -> NuGet 包管理器 -> 包管理器控制台）中启动以下命令：

Install-Package CSLA
Install-Package CSLA-Server

Install-Package CSLA
Install-Package CSLA-Server

这些软件包包含服务器端组件以及基本的 CSLA 功能。

在您的项目中配置 CSLA .NET

对于控制台应用程序，在您的Program.cs文件中初始化CSLA.NET配置。在ASP.NET Core应用程序的Startup.cs文件中，也会进行此操作。

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

创建一个业务对象

为了捕获您的业务逻辑，创建一个基本业务对象。 我们将为此示例创建一个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 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";
        }
    }
}

使用业务对象

现在让我们使用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}");
        }
    }
}

展示如何使用 DataPortal 在主方法中创建一个新人物并获取现有的人物 在 IDataPortal 中建立。

此配置为在 .NET 应用程序中利用 CSLA .NET 提供了一个基本框架。 如果需要更复杂的业务逻辑、数据访问和验证标准，您可以在此基础上进行扩展。