// 业务对象定义
public class Customer : BusinessBase<Customer>
{
    public static readonly PropertyInfo<int> IdProperty =
        RegisterProperty<int>(c => c.Id);

    public static readonly PropertyInfo<string> NameProperty =
        RegisterProperty<string>(c => c.Name);

    public int Id
    {
        get => GetProperty(IdProperty);
        private set => SetProperty(IdProperty, value);
    }

    public string Name
    {
        get => GetProperty(NameProperty);
        set => SetProperty(NameProperty, value);
    }

    // 工厂方法
    public static Customer CreateCustomer()
    {
        return DataPortal.Create<Customer>();
    }

    public static Customer GetCustomer(int id)
    {
        return DataPortal.Fetch<Customer>(id);
    }

    // DataPortal 方法 - 在服务器端执行
    private void DataPortal_Fetch(int id)
    {
        using (var ctx = DbContextManager<DatabaseContext>.GetManager())
        {
            var data = ctx.DataContext.Customers.Single(c => c.Id == id);
            using (BypassPropertyChecks)  // 绕过属性检查
            {
                LoadProperty(IdProperty, data.Id);
                LoadProperty(NameProperty, data.Name);
            }
        }
    }

    protected override void AddBusinessRules()
    {
        base.AddBusinessRules();

        // 验证规则
        BusinessRules.AddRule(new RequiredRule(NameProperty));
        BusinessRules.AddRule(new MaxLengthRule(NameProperty, 100));

        // 业务规则
        BusinessRules.AddRule(new CustomerAgeRule());

        // 授权规则
        BusinessRules.AddRule(
            new AuthorizationRule(
                AuthorizationActions.WriteProperty,
                NameProperty,
                "AdminRole"
            )
        );
    }
}

// 使用示例
var customer = Customer.GetCustomer(1);
customer.Name = "新名称";
customer.Save();  // 自动调用 DataPortal_Update

// 默认行为：通过配置文件统一切换代理
// app.config/web.config
<configuration>
  <appSettings>
    <!-- 切换到本地代理 -->
    <add key="CslaDataPortalProxy" value="Local" />

    <!-- 或切换到 HTTP 代理 -->
    <add key="CslaDataPortalProxy" value="HttpProxy" />

    <!-- 或切换到 WCF 代理 -->
    <add key="CslaDataPortalProxy" value="WcfProxy" />
  </appSettings>
</configuration>

// 实现 IDataPortalProxyFactory 接口
public class CustomProxyFactory : IDataPortalProxyFactory
{
    public IDataPortalProxy CreateProxy(Type objectType)
    {
        // 根据业务对象类型动态选择代理
        if (objectType.Namespace.StartsWith("MyApp.LocalOnly"))
        {
            // 本地对象使用直接数据库访问
            return new LocalProxy();
        }

        if (objectType.Namespace.StartsWith("MyApp.Remote"))
        {
            // 远程对象通过 HTTP 调用应用服务器
            return new HttpProxy();
        }

        if (objectType == typeof(SensitiveData))
        {
            // 敏感数据使用专用安全通道
            return new SecureWcfProxy();
        }

        // 默认代理
        return new HttpProxy();
    }
}

// 配置自定义代理工厂
<configuration>
  <appSettings>
    <add key="CslaDataPortalProxyFactory"
         value="MyApp.CustomProxyFactory, MyApp" />
  </appSettings>
</configuration>

public class Customer : BusinessBase<Customer>
{
    protected override void AddBusinessRules()
    {
        // 必填规则
        BusinessRules.AddRule(new RequiredRule(NameProperty));

        // 长度规则
        BusinessRules.AddRule(new MaxLengthRule(NameProperty, 100));

        // 正则表达式规则
        BusinessRules.AddRule(new RegExRule(EmailProperty,
            @"^[^@\w-\.]+@[\w-\.]+$"));

        // 数值范围规则
        BusinessRules.AddRule(new MinValueRule(AgeProperty, 18));

        // 自定义验证规则
        BusinessRules.AddRule(new CustomerEmailUniqueRule());
    }
}

// 自定义规则示例
public class CustomerEmailUniqueRule : BusinessRule
{
    public CustomerEmailUniqueRule()
        : base(Customer.EmailProperty)
    {
        InputProperties = new List<IPropertyInfo>
        {
            Customer.EmailProperty
        };
        AffectedProperties.Add(Customer.EmailProperty);
        PrimaryProperty = Customer.EmailProperty;
    }

    protected override void Execute(IRuleContext context)
    {
        var email = context.InputPropertyValues[Customer.EmailProperty];

        // 检查邮箱是否已存在
        var exists = _customerRepository.EmailExists(email.ToString());

        if (exists)
        {
            context.AddErrorResult("邮箱已被使用");
        }
    }
}

public class Order : BusinessBase<Order>
{
    protected override void AddBusinessRules()
    {
        // 订单金额范围规则
        BusinessRules.AddRule(
            CommonRules.BetweenValue(OrderAmountProperty, 0.01m, 999999m)
        );

        // 折扣规则
        BusinessRules.AddRule(new OrderDiscountRule());

        // 库存检查规则
        BusinessRules.AddRule(new InventoryCheckRule());
    }
}

// 自定义业务规则
public class OrderDiscountRule : BusinessRule
{
    public OrderDiscountRule()
        : base(Order.OrderAmountProperty, Order.OrderDateProperty)
    {
        InputProperties = new List<IPropertyInfo>
        {
            Order.OrderAmountProperty,
            Order.OrderDateProperty
        };
    }

    protected override void Execute(IRuleContext context)
    {
        var amount = context.InputPropertyValues[Order.OrderAmountProperty] as decimal?;
        var date = context.InputPropertyValues[Order.OrderDateProperty] as DateTime?;

        // 周末折扣
        if (date.Value.DayOfWeek == DayOfWeek.Saturday)
        {
            context.AddOutValue(Order.DiscountPercentProperty, 0.9m);
        }

        // 节假日双倍积分
        if (IsHoliday(date.Value))
        {
            context.AddOutValue(Order.PointsProperty, amount * 2);
        }
    }
}

public class SensitiveData : BusinessBase<SensitiveData>
{
    protected override void AddBusinessRules()
    {
        // 属性级授权
        BusinessRules.AddRule(
            new AuthorizationRule(
                AuthorizationActions.ReadProperty,
                CreditCardNumberProperty,
                "FinanceRole"
            )
        );

        // 方法级授权
        BusinessRules.AddRule(
            new AuthorizationRule(
                AuthorizationActions.ExecuteMethod,
                DeleteCustomerMethod,
                "AdminRole"
            )
        );

        // 角色继承
        BusinessRules.AddRule(
            new IsInRoleAuthorizationRule(
                "ManagerRole",
                "SupervisorRole"
            )
        );
    }

    public bool CanReadProperty(string propertyName)
    {
        return BusinessRules.CheckRules(
            AuthorizationActions.ReadProperty,
            propertyName
        );
    }
}

public class Customer
{
    // 创建新对象
    public static Customer CreateCustomer()
    {
        return DataPortal.Create<Customer>();
    }

    // 获取现有对象
    public static Customer GetCustomer(int id)
    {
        return DataPortal.Fetch<Customer>(id);
    }

    // 删除对象
    public static void DeleteCustomer(int id)
    {
        DataPortal.Delete<Customer>(id);
    }
}

public void ProcessOrder(Order order)
{
    using (var scope = new UnitOfWorkScope())
    {
        order.Save();      // 保存订单

        // 批量保存订单项
        foreach (var item in order.Items)
        {
            item.Save();
        }

        scope.Complete();  // 提交事务
    }
}

public class Customer : BusinessBase<Customer>
{
    public static readonly PropertyInfo<string> NameProperty =
        RegisterProperty<string>(c => c.Name);

    public string Name
    {
        get => GetProperty(NameProperty);
        set => SetProperty(NameProperty, value);  // 自动触发 PropertyChanged
    }

    // 属性变更事件（自动继承自 BusinessBase）
    // public event PropertyChangedEventHandler PropertyChanged;
}

public interface IDataPortalProxy
{
    TResult Fetch<T>(Criteria criteria);
}

// 具体策略实现
public class HttpProxy : IDataPortalProxy
{
    public TResult Fetch<T>(Criteria criteria)
    {
        // HTTP 实现
    }
}

public class WcfProxy : IDataPortalProxy
{
    public TResult Fetch<T>(Criteria criteria)
    {
        // WCF 实现
    }
}

// 运行时通过配置选择策略

public class Customer : BusinessBase<Customer>
{
    // 可序列化状态
    public int Id { get; private set; }
    public string Name { get; set; }

    // 验证和授权规则随对象移动
    // 无需单独的 DTO 层
}

[Serializable]
public class Order : BusinessBase<Order>
{
    public static readonly PropertyInfo<int> IdProperty =
        RegisterProperty<int>(c => c.Id);

    public static readonly PropertyInfo<string> CustomerNameProperty =
        RegisterProperty<string>(c => c.CustomerName);

    public static readonly PropertyInfo<decimal> AmountProperty =
        RegisterProperty<decimal>(c => c.Amount);

    public static readonly PropertyInfo<DateTime> OrderDateProperty =
        RegisterProperty<DateTime>(c => c.OrderDate);

    public static readonly PropertyInfo<List<OrderLine>> LinesProperty =
        RegisterProperty<List<OrderLine>>(c => c.Lines);

    public int Id
    {
        get => GetProperty(IdProperty);
        private set => SetProperty(IdProperty, value);
    }

    public string CustomerName
    {
        get => GetProperty(CustomerNameProperty);
        set => SetProperty(CustomerNameProperty, value);
    }

    public decimal Amount
    {
        get => GetProperty(AmountProperty);
        set => SetProperty(AmountProperty, value);
    }

    public DateTime OrderDate
    {
        get => GetProperty(OrderDateProperty);
        set => SetProperty(OrderDateProperty, value);
    }

    public List<OrderLine> Lines
    {
        get => GetProperty(LinesProperty);
        set => SetProperty(LinesProperty, value);
    }

    // 工厂方法
    public static Order CreateOrder()
    {
        return DataPortal.Create<Order>();
    }

    public static Order GetOrder(int id)
    {
        return DataPortal.Fetch<Order>(id);
    }

    // DataPortal_Insert
    private void DataPortal_Insert()
    {
        using (var ctx = DbContextManager<DatabaseContext>.GetManager())
        {
            var order = new OrderEntity
            {
                CustomerName = this.CustomerName,
                Amount = this.Amount,
                OrderDate = this.OrderDate
            };

            ctx.DataContext.Orders.Add(order);
            ctx.DataContext.SaveChanges();

            // 获取数据库生成的 ID
            using (BypassPropertyChecks)
            {
                IdProperty.LoadValue(order.Id);
            }
        }

        // 插入订单项
        foreach (var line in Lines)
        {
            line.Save();
        }
    }

    // 业务规则
    protected override void AddBusinessRules()
    {
        base.AddBusinessRules();

        // 验证规则
        BusinessRules.AddRule(new RequiredRule(CustomerNameProperty));
        BusinessRules.AddRule(new RequiredRule(AmountProperty));
        BusinessRules.AddRule(new MinValueRule(AmountProperty, 0.01m));

        // 业务规则
        BusinessRules.AddRule(new OrderAmountRule());
        BusinessRules.AddRule(new OrderDateRule());

        // 授权规则
        BusinessRules.AddRule(
            new AuthorizationRule(
                AuthorizationActions.CreateObject,
                typeof(Order),
                "SalesRole"
            )
        );
    }
}

// 订单金额业务规则
public class OrderAmountRule : BusinessRule
{
    public OrderAmountRule()
        : base(Order.AmountProperty)
    {
        InputProperties = new List<IPropertyInfo>
        {
            Order.AmountProperty,
            Order.CustomerNameProperty
        };
    }

    protected override void Execute(IRuleContext context)
    {
        var amount = context.InputPropertyValues[Order.AmountProperty] as decimal?;

        // 白金客户最低订单金额
        if (IsVipCustomer(context))
        {
            context.AddErrorResult("VIP客户最低订单金额为 1000 元");
        }

        // 普通客户限制
        if (amount < 10)
        {
            context.AddErrorResult("订单金额不能小于 10 元");
        }
    }
}

// 客户端代码 - 完全不知道服务器端实现
var customer = Customer.GetCustomer(123);
customer.Name = "新名字";
customer.Save();  // 可能运行在客户端，也可能运行在服务器端

// 部署模型通过配置切换，代码零修改