button_custom_submit: function (t) {
    var body = t.RequestButton;
    switch (body.name) {
        case "btn_custom_use"://启用/禁用
            var dt = mzServer.selectRow();
            if (dt.ResponseMessage.Success) {
                if (dt.Stats.length < 1) {
                    $scope.view.submit.Fn.loading(t.RequestButton.name, false);
                    mzServer.Msg.error("请选择一条数据");

                    return;
                }
                debugger;
                $scope.view.submit.Fn.loading(t.RequestButton.name, false);
                var state = dt.Stats[0].a_TemplateStatus; var tip = "";
                if (state == 1) {
                    state = 0; tip = "禁用";
                } else {
                    state = 1; tip = "启用";
                }
                mzServer.confirm('确定' + tip + '吗？').result.then(function (isconfirm) {
                    debugger;
                    if (isconfirm) {
                        var data = {};
                        var Info = {};
                        Info.a_ID = dt.Stats[0].a_ID;
                        Info.a_Status = state;
                        data.ConfigType = "view";
                        data.OpType = "query";
                        data.ConfigName = "TBFreightTemplate";
                        data.RequestBody = JSON.stringify(Info);
                        data.SpecialParameter = "ForbidOrUse";
                        data.url = "gridview/LoadData";
                        mzServer.postData(data).then(
                            function (response) {
                                console.log(response);
                                if (response.data.ResponseMessage.Success) {
                                    mzServer.Msg.success(tip+"成功！");
                                    angular.element("table[for='TBFreightTemplate']").bootstrapTable('refresh');
                                } else {
                                    mzServer.Msg.error(response.data.ResponseMessage.ErrorMessage);
                                }
                            }, function (error) {
                                mzServer.Msg.error(error);
                            });

                    }
                });
            }
            else {
                $scope.view.submit.Fn.loading(t.RequestButton.name, false);
                mzServer.Msg.error(dt.ResponseMessage.ErrorMessage);
            }
            break;

        default:
            mzServer.Msg.error("无效的事件");
            break;
    }

},

• 当一个类不知道它所必须创建的对象的类时
• 当一个类希望由它的子类来指定所创建的对象时
• 当将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化时

  using System;
  
  // 定义产品接口
  public interface IProduct
  {
      void Operation();
  }
  
  // 具体产品A
  public class ConcreteProductA : IProduct
  {
      public void Operation()
      {
          Console.WriteLine("ConcreteProductA Operation");
      }
  }
  
  // 具体产品B
  public class ConcreteProductB : IProduct
  {
      public void Operation()
      {
          Console.WriteLine("ConcreteProductB Operation");
      }
  }
  
  // 简单工厂类
  public class SimpleFactory
  {
      public static IProduct CreateProduct(string type)
      {
          switch (type.ToLower())
          {
              case "a":
                  return new ConcreteProductA();
              case "b":
                  return new ConcreteProductB();
              default:
                  throw new ArgumentException("Invalid product type", nameof(type));
          }
      }
  }
  
  // 客户端代码
  class Program
  {
      static void Main()
      {
          // 使用简单工厂创建产品A
          IProduct productA = SimpleFactory.CreateProduct("A");
          productA.Operation();
  
          // 使用简单工厂创建产品B
          IProduct productB = SimpleFactory.CreateProduct("B");
          productB.Operation();
  
          try
          {
              // 尝试创建无效产品类型
              IProduct invalidProduct = SimpleFactory.CreateProduct("C");
              invalidProduct.Operation();
          }
          catch (ArgumentException ex)
          {
              Console.WriteLine($"Error: {ex.Message}");
          }
      }
  }    

工厂模式的优点

• 解耦对象的创建和使用：客户端不需要知道具体产品类的类名，只需要知道对应的参数即可。
• 可扩展性好：在增加新的产品类时，只需要修改工厂类或者扩展工厂子类，符合开闭原则。
• 便于代码维护：创建对象的逻辑集中在一个工厂类中，便于维护和修改。

工厂模式的缺点

• 工厂类职责过重：简单工厂模式中，工厂类集中了所有产品的创建逻辑，一旦不能正常工作，整个系统都会受到影响。
• 增加系统复杂度：如果产品种类过多，会导致工厂类变得庞大，增加系统的复杂度。
• 违反开闭原则：在简单工厂模式中，每当增加新的产品时，都需要修改工厂类，这违反了开闭原则。

1. 高层模块不应依赖低层模块，二者都应依赖抽象。
2. 抽象不应依赖细节，细节应依赖抽象。
   示例：

   # 反例：高层模块依赖低层模块
   class LightBulb:
       def turn_on(self):
           print("灯泡亮了")
   
   class Switch:
       def __init__(self):
           self.bulb = LightBulb()  # 直接依赖具体实现
   
   # 正例：依赖抽象
   from abc import ABC, abstractmethod
   
   class Switchable(ABC):
       @abstractmethod
       def turn_on(self):
           pass
   
   class LightBulb(Switchable):
       def turn_on(self):
           print("灯泡亮了")
   
   class Fan(Switchable):
       def turn_on(self):
           print("风扇转了")
   
   class Switch:
       def __init__(self, device: Switchable):
           self.device = device  # 依赖抽象而非具体实现

客户端不应该被迫依赖它不需要的接口。应该把庞大的接口拆分成更小、更具体的接口。

# 反例：一个大而全的接口
class Worker:
    def work(self):
        pass
    def eat(self):
        pass

class Robot(Worker):
    def work(self):
        pass
    def eat(self):
        raise NotImplementedError("机器人不需要吃饭")  # 被迫实现不需要的方法

# 正例：拆分接口
class Workable:
    def work(self):
        pass

class Eatable:
    def eat(self):
        pass

class HumanWorker(Workable, Eatable):
    pass

class RobotWorker(Workable):
    pass

1. 运费模板表

   CREATE TABLE TBFreightTemplate (
       ID uniqueidentifier NOT NULL PRIMARY KEY DEFAULT NEWID(),           -- 主键ID
       TemplateName nvarchar(100) NOT NULL,                                 -- 模板名称
       FK_TBMerchant_ID uniqueidentifier NOT NULL,                         -- 关联商户ID
       FK_TBStore_ID uniqueidentifier,                                     -- 关联门店ID
       TemplateType tinyint NOT NULL DEFAULT 1,                            -- 模板类型(1-按件数,2-按重量,3-按金额)
       DeliveryMethod tinyint NOT NULL,                                     -- 配送方式(1-快递,2-自提,3-同城配送,4-不配送)
       IsFreeShipping bit NOT NULL DEFAULT 0,                              -- 是否包邮(0-否,1-是)
       IsDefault bit NOT NULL DEFAULT 0,                                   -- 是否默认模板(0-否,1-是)
       IsAllRegion bit NOT NULL DEFAULT 1,                                 -- 是否全国配送(0-否,1-是)
       FreeShippingCondition tinyint,                                      -- 包邮条件类型(1-满件数包邮,2-满金额包邮,3-满重量包邮)
       FreeShippingValue decimal(10,2),                                    -- 包邮条件值
       ReturnValue tinyint,                                                 -- 退货运费：0：卖家承担；1：买家承担
       TemplateStatus tinyint NOT NULL DEFAULT 1,                          -- 模板状态(0-禁用,1-启用)
       CreateTime datetime NOT NULL DEFAULT GETDATE(),                 -- 创建时间
       FK_SystemUser_Create_ID uniqueidentifier,                           -- 创建人ID
       ModifyTime datetime NOT NULL DEFAULT GETDATE(),                 -- 最后更新时间
       FK_SystemUser_Modify_ID uniqueidentifier,                           -- 最后更新人ID
       IsValid bit NOT NULL DEFAULT 1,                                     -- 是否有效(0-无效,1-有效)
       IsDelete bit NOT NULL DEFAULT 0,                                    -- 是否删除(0-未删除,1-已删除)
       FK_Systemuserdepartment_Create_ID uniqueidentifier,                 -- 创建部门ID
       Sort int DEFAULT 0,                                                  -- 排序
       Memo nvarchar(500),                                                  -- 备注
   );
   
   -- 运费模板配送区域表
   CREATE TABLE TBFreightTemplateRegion (
       ID uniqueidentifier NOT NULL PRIMARY KEY DEFAULT NEWID(),           -- 主键ID
       FK_TBFreightTemplate_ID uniqueidentifier NOT NULL,                  -- 关联运费模板ID
       RegionName nvarchar(100) NOT NULL,                                  -- 配送区域名称
       ProvIds nvarchar(max),                                               -- 省份编码列表(JSON格式)
       CityIds nvarchar(max),                                               -- 城市编码列表(JSON格式) 可为空
       DistrictIds nvarchar(max),                                           -- 区县编码列表(JSON格式) 可为空
       DeliveryType tinyint NOT NULL,                                       -- 配送类型(1-配送,2-不配送)
       FirstUnit int NOT NULL DEFAULT 1,                                   -- 首件/首重/首体积
       FirstPrice decimal(10,2) NOT NULL DEFAULT 0.00,                     -- 首件/首重/首体积价格
       ContinueUnit int NOT NULL DEFAULT 1,                                -- 续件/续重/续体积
       ContinuePrice decimal(10,2) NOT NULL DEFAULT 0.00,                  -- 续件/续重/续体积价格
       FreeShippingCondition tinyint,                                      -- 区域包邮条件类型(1-满件数包邮,2-满金额包邮,3-满重量包邮)
       FreeShippingValue decimal(10,2),                                    -- 区域包邮条件值
       IsRegionFree bit NOT NULL DEFAULT 0,                                -- 该区域是否包邮(0-否,1-是)
       CreateTime datetime NOT NULL DEFAULT GETDATE(),                 -- 创建时间
       FK_SystemUser_Create_ID uniqueidentifier,                           -- 创建人ID
       ModifyTime datetime NOT NULL DEFAULT GETDATE(),                 -- 最后更新时间
       FK_SystemUser_Modify_ID uniqueidentifier,                           -- 最后更新人ID
       IsValid bit NOT NULL DEFAULT 1,                                     -- 是否有效(0-无效,1-有效)
       IsDelete bit NOT NULL DEFAULT 0,                                    -- 是否删除(0-未删除,1-已删除)
       FK_Systemuserdepartment_Create_ID uniqueidentifier,                 -- 创建部门ID
       Sort int DEFAULT 0,                                                  -- 排序
       Memo nvarchar(500),                                                  -- 备注
   );
   
   -- 运费模板计费详情表
   CREATE TABLE TBFreightTemplateDetail (
       ID uniqueidentifier NOT NULL PRIMARY KEY DEFAULT NEWID(),           -- 主键ID
       FK_TBFreightTemplateRegion_ID uniqueidentifier NOT NULL,            -- 关联运费模板区域ID
       MinValue decimal(10,3) NOT NULL,                                    -- 最小值(件数/重量/体积)
       MaxValue decimal(10,3),                                             -- 最大值(件数/重量/体积)
       Price decimal(10,2) NOT NULL,                                       -- 该区间价格
       PriceType tinyint NOT NULL,                                         -- 价格类型(1-固定价格,2-每单位价格)
       CreateTime datetime NOT NULL DEFAULT GETDATE(),                 -- 创建时间
       FK_SystemUser_Create_ID uniqueidentifier,                           -- 创建人ID
       ModifyTime datetime NOT NULL DEFAULT GETDATE(),                 -- 最后更新时间
       FK_SystemUser_Modify_ID uniqueidentifier,                           -- 最后更新人ID
       IsValid bit NOT NULL DEFAULT 1,                                     -- 是否有效(0-无效,1-有效)
       IsDelete bit NOT NULL DEFAULT 0,                                    -- 是否删除(0-未删除,1-已删除)
       FK_Systemuserdepartment_Create_ID uniqueidentifier,                 -- 创建部门ID
       Sort int DEFAULT 0,                                                  -- 排序
       Memo nvarchar(500),                                                  -- 备注
   );

  // 使用JsonConvert.SerializeObject保留中文
  var jsonSettings = new JsonSerializerSettings
  {
      StringEscapeHandling = StringEscapeHandling.Default
  };
  
  data.RequestBody = JsonConvert.SerializeObject(resultJson, jsonSettings);
  
  // 这里是关键 - 使用JsonConvert.SerializeObject来序列化整个data对象
  string postData = JsonConvert.SerializeObject(data, jsonSettings);
  
  // 使用序列化后的字符串而不是JSON.ToJSON(data)

 var content = HttpTools.PostHttpNHSHelp(url, postData, "同步答卷结果");

里氏替换原则（Liskov Substitution Principle, LSP）是面向对象设计的核心原则之一，由芭芭拉・利斯科夫（Barbara Liskov）在 1987 年提出。其核心思想是：子类对象必须能够替换掉它们的父类对象，而不影响程序的正确性。这意味着，子类应当遵循父类的契约，保持行为的一致性。

核心动机

• 继承的正确性：确保子类不会破坏父类的原有功能。
• 多态的可靠性：通过父类引用调用子类方法时，结果应符合预期。
• 降低系统风险：避免因子类行为异常导致的潜在错误。

LSP 的关键要求

1. 前置条件不能强化：子类方法的前置条件（输入参数）不能比父类更严格。
2. 后置条件不能弱化：子类方法的后置条件（返回值）必须满足父类的要求。
3. 不变式要保持：子类不能改变父类的不变量（如类的约束条件）。
4. 异常要兼容：子类抛出的异常应当与父类一致或为其子类。

C# 示例：矩形与正方形问题

违反 LSP 的经典案例

// 基类：矩形
public class Rectangle
{
    public virtual double Width { get; set; }
    public virtual double Height { get; set; }

    public double Area() => Width * Height;
}

// 子类：正方形（错误设计）
public class Square : Rectangle
{
    // 正方形的宽和高必须相等
    public override double Width
    {
        get => base.Width;
        set
        {
            base.Width = value;
            base.Height = value;
        }
    }

    public override double Height
    {
        get => base.Height;
        set
        {
            base.Height = value;
            base.Width = value;
        }
    }
}

// 抽象接口：四边形
public interface IQuadrilateral
{
    double Width { get; }
    double Height { get; }
    double Area();
}

// 矩形实现
public class Rectangle : IQuadrilateral
{
    public double Width { get; set; }
    public double Height { get; set; }
    public double Area() => Width * Height;
}

// 正方形实现
public class Square : IQuadrilateral
{
    private double _side;
    
    public double Width
    {
        get => _side;
        set => _side = value;
    }
    
    public double Height
    {
        get => _side;
        set => _side = value;
    }
    
    public double Area() => _side * _side;
}

// 正方形包含一个矩形实例
public class Square
{
    private readonly Rectangle _rectangle = new Rectangle();
    
    public double Side
    {
        get => _rectangle.Width;
        set
        {
            _rectangle.Width = value;
            _rectangle.Height = value;
        }
    }
    
    public double Area() => _rectangle.Area();
}

// 基类：银行账户
public class BankAccount
{
    protected double _balance;
    
    public virtual void Withdraw(double amount)
    {
        if (amount > _balance)
            throw new InvalidOperationException("余额不足");
        
        _balance -= amount;
    }
}

// 子类：透支账户（错误设计）
public class OverdraftAccount : BankAccount
{
    private double _overdraftLimit = 1000;
    
    // 重写取款方法，允许透支
    public override void Withdraw(double amount)
    {
        if (amount > _balance + _overdraftLimit)
            throw new InvalidOperationException("超过透支限额");
            
        _balance -= amount;
    }
}

处理器不能直接解释程序集。.NET程序集用的是另一种语言，即公共中间语言（Common Intermediate Language，CIL），或称中间语言（IL）。C#编译器将C#源代码转换成中间语言。为了将CIL代码转换成处理器能够理解的的机器码，还要完成一个额外的步骤（通常在运行时进行）。该步骤涉及C#程序执行的一个重要元素：VES(Virtual Execution System, 虚拟执行系统)。VES也称为”运行时“（runtime）。它根据需要编译CIL代码，这个过程称为即时编译或JIT编译（just-in-time compilation)。如果代码在像”运行时“这样的一个”代理“的上下文中执行，那么就称为托管代码（managed code），在”运行时“的控制下执行的过程则称为托管执行（managed execution）。之所以称为”托管“，是因为”运行时“管理着诸如内存分配、安全性、JIT编译等方面，从而控制了主要的程序行为。执行时不需要”运行时“的代码则称为本机代码（native code）或非托管代码（unmanaged code）。