public abstract class PartBase : Space    {        #region 基本属性        /// <summary>        /// 是否复合板        /// </summary>        public bool IsCladPart { get; set; }        /// <summary>        /// 基层密度(kg/L)        /// </summary>        public double BaseDensity { get; set; }        /// <summary>        /// 复层密度(kg/L)        /// </summary>        public double CladDensity { get; set; }        /// <summary>        /// 基层材料        /// </summary>        public string BaseMaterial { get; set; }        /// <summary>        /// 复层材料        /// </summary>        public string CladMaterial { get; set; }        /// <summary>        /// 零件类型        /// </summary>        public PartType PartType { get; set; }        #endregion 基本属性        #region 控件属性        public TextBox TbBaseDensity { get; set; }        public TextBox TbCladDensity { get; set; }        public TextBox TbBaseMaterial { get; set; }        public TextBox TbCladMaterial { get; set; }        public CheckBox CbxIsCladPart { get; set; }        #endregion 控件属性        #region 控件事件，由于是抽象类，需要在继承类中实现其事件        public virtual void TbDensity_Validating(object sender, CancelEventArgs e)        {            "未实现【密度】的虚方法！".showAlert();        }        public virtual void TbCladMaterial_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            "未实现【复层材料】的虚方法！".showAlert();        }        public virtual void TbBaseMaterial_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            "未实现【基层材料】的虚方法！".showAlert();        }        public virtual void CbxIsCladPlate_CheckedChanged(object sender, EventArgs e)        {            "未实现【是否复合板】的虚方法！".showAlert();        }        #endregion 控件事件，由于是抽象类，需要在继承类中实现其事件        public PartBase()        {        }        /// <summary>        /// 继承腔体类中的属性值        /// 并且设置下一级类中的属性值        /// </summary>        /// <param name="v"></param>        /// <param name="s"></param>        public PartBase(Vessel v, Space s)                : base(v, s)        {        }    }

    public class ShellBase : PartBase    {        #region 公用属性        /// <summary>        /// 壳体名义厚度        /// </summary>        protected string zShellTn;        /// <summary>        /// 壳体名义厚度        /// </summary>        public string ShellTn        {            get            {                return zShellTn;            }            set            {                zShellTn = value;                if (IsCladPart)                {                    if (value.Contains("+"))                    {                        TnBase = double.Parse(value.Split(‘+‘)[0]);                        TnClad = double.Parse(value.Split(‘+‘)[1]);                        Tn = TnBase + TnClad;                    }                    else                    {                    }                }                else if (!string.IsNullOrEmpty(value))                {                    if (value.Contains("+"))                    {                    }                    else                    {                        double tn = 0;                        double.TryParse(value, out tn);                        Tn = tn;                    }                }            }        }        /// <summary>        /// 壳体公称厚度        /// </summary>        public double Tn { get; set; }        /// <summary>        /// 是否为外径基准        /// </summary>        public bool IsBasedOnOD { get; set; }        /// <summary>        /// 壳体公称直径        /// </summary>        public double ShellDn { get; set; }        /// <summary>        /// 基层厚度        /// </summary>        public double TnBase { get; set; }        /// <summary>        /// 复层板厚        /// </summary>        public double TnClad { get; set; }        /// <summary>        /// 当前类的一个实例，用于记录验证时的值，重要，它是一个传值桥梁        /// </summary>        public ShellBase Shell { get; set; }        #endregion 公用属性        #region 几何属性        /// <summary>        /// 体积        /// </summary>        public double Volume { get; set; }        /// <summary>        /// 内表面积        /// </summary>        public double InnerArea { get; set; }        /// <summary>        /// 外表面积        /// </summary>        public double OuterArea { get; set; }        /// <summary>        /// 质量        /// </summary>        public double Mass { get; set; }        #endregion 几何属性        #region 控件属性        public CheckBox CbxIsBasedOnOD { get; set; }        public TextBox TbShellDn { get; set; }        public TextBox TbShellTn { get; set; }        public Label LblVolume { get; set; }        public Label LblMass { get; set; }        public Label LblInnerArea { get; set; }        public Label LblOutterArea { get; set; }        #endregion 控件属性        #region 控件事件        private void TbShellTn_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            if (TbShellTn.Text == "")            {                ErrShow.Clear();                return;            }            if (IsCladPart)            {                List<double> lst = TbShellTn.getCladPlateThickness();                Shell.ShellTn = TbShellTn.Text;                if (lst.Count > 1)                {                    Shell.TnBase = lst[0];                    Shell.TnClad = lst[1];                    Shell.Tn = TnBase + TnClad;                    ErrShow.Clear();                }                else                {                    ErrShow.SetError(TbShellTn, "请按复合板的厚度【50+4.5】的格式填写！");                    e.Cancel = true;                }            }            else            {                Shell.TnBase = TbShellTn.getNumber();                Shell.Tn = TnBase;                Shell.ShellTn = TbShellTn.Text;                ErrShow.Clear();            }        }        private void TbShellDn_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            if (TbShellDn.Text == "")            {                ErrShow.Clear();                return;            }            double dn = 0;            double.TryParse(TbShellDn.Text, out dn);            if (dn > 20)            {                Shell.ShellDn = dn;                ErrShow.Clear();            }            else            {                ErrShow.SetError(TbShellDn, "输入的数据有误！");                e.Cancel = true;            }        }        private void CbxIsBasedOnOD_CheckedChanged(object sender, EventArgs e)        {            Shell.IsBasedOnOD = CbxIsBasedOnOD.Checked;        }        /// <summary>        /// 重写抽象类中的方法        /// </summary>        /// <param name="sender"></param>        /// <param name="e"></param>        public override void CbxIsCladPlate_CheckedChanged(object sender, EventArgs e)        {            Shell.IsCladPart = CbxIsCladPart.Checked;        }        public override void TbDensity_Validating(object sender, CancelEventArgs e)        {            TextBox tb = (TextBox)sender;            if (tb.Text == "")            {                if (tb == TbBaseDensity)                {                    Shell.BaseDensity = 0;                }                else                {                    Shell.CladDensity = 0;                }                ErrShow.Clear();                return;            }            double midu = 0;            double.TryParse(tb.Text, out midu);            if (midu > 1 && midu < 30)            {                if (tb == TbBaseDensity)                {                    Shell.BaseDensity = midu;                }                else                {                    Shell.CladDensity = midu;                }                ErrShow.Clear();            }            else            {                ErrShow.SetError(tb, "密度输入有问题！");                e.Cancel = true;            }        }        public override void TbCladMaterial_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            Shell.CladMaterial = TbCladMaterial.Text;        }        public override void TbBaseMaterial_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            Shell.BaseMaterial = TbBaseMaterial.Text;        }        #endregion 控件事件        public ShellBase()        {        }        public ShellBase(Vessel V, Space S)                : base(V, S)        {        }        /// <summary>        /// 继承腔体类中的属性值        /// 并且设置下一级类中的属性值        /// </summary>        /// <param name="V"></param>        /// <param name="S"></param>        public ShellBase(Vessel V, Space S, ShellBase SB)                : base(V, S)        {            //传值            Shell = SB;            #region 控件赋值            //PartBase            if (SB.CbxIsCladPart != null)            {                CbxIsCladPart = SB.CbxIsCladPart;            }            if (SB.TbBaseDensity != null)            {                TbBaseDensity = SB.TbBaseDensity;            }            if (SB.TbCladDensity != null)            {                TbCladDensity = SB.TbCladDensity;            }            if (SB.TbBaseMaterial != null)            {                TbBaseMaterial = SB.TbBaseMaterial;            }            if (SB.TbCladMaterial != null)            {                TbCladMaterial = SB.TbCladMaterial;            }            //ShellBase            if (SB.CbxIsBasedOnOD != null)            {                CbxIsBasedOnOD = SB.CbxIsBasedOnOD;            }            if (SB.TbShellDn != null)            {                TbShellDn = SB.TbShellDn;            }            if (SB.TbShellTn != null)            {                TbShellTn = SB.TbShellTn;            }            #endregion 控件赋值            #region 属性传值            IsBasedOnOD = SB.IsBasedOnOD;            ShellDn = SB.ShellDn;            Tn = SB.Tn;            ShellTn = SB.ShellTn;            TnBase = SB.TnBase;            TnClad = SB.TnClad;            #endregion 属性传值            #region 通过将SB赋值给本类中属性Shell，用Shell来接收控件验证时得到的参数值，然后传值到下一个继承者            //赋值是从抽象类中来的            IsCladPart = SB.IsCladPart;            BaseDensity = SB.BaseDensity;            CladDensity = SB.CladDensity;            BaseMaterial = SB.BaseMaterial;            CladMaterial = SB.CladMaterial;            #endregion 通过将SB赋值给本类中属性Shell，用Shell来接收控件验证时得到的参数值，然后传值到下一个继承者        }        /// <summary>        /// 在底层使用时进行调用，必须在控件赋值后进行使用，否则无效        /// </summary>        public void ShellSetting()        {            #region 上一个抽象类中的控件            if (TbBaseDensity != null)            {                TbBaseDensity.Validating -= TbDensity_Validating;                TbBaseDensity.Validating += TbDensity_Validating;            }            if (TbCladDensity != null)            {                TbCladDensity.Validating -= TbDensity_Validating;                TbCladDensity.Validating += TbDensity_Validating;            }            if (TbBaseMaterial != null)            {                TbBaseMaterial.Validating -= TbBaseMaterial_Validating;                TbBaseMaterial.Validating += TbBaseMaterial_Validating;            }            if (TbCladMaterial != null)            {                TbCladMaterial.Validating -= TbCladMaterial_Validating;                TbCladMaterial.Validating += TbCladMaterial_Validating;            }            if (CbxIsCladPart != null)            {                CbxIsCladPart.CheckedChanged -= CbxIsCladPlate_CheckedChanged;                CbxIsCladPart.CheckedChanged += CbxIsCladPlate_CheckedChanged;            }            #endregion 上一个抽象类中的控件            #region 本类中的控件            if (TbShellDn != null)            {                TbShellDn.Validating -= TbShellDn_Validating;                TbShellDn.Validating += TbShellDn_Validating;            }            if (TbShellTn != null)            {                TbShellTn.Validating -= TbShellTn_Validating;                TbShellTn.Validating += TbShellTn_Validating;            }            if (CbxIsBasedOnOD != null)            {                CbxIsBasedOnOD.CheckedChanged -= CbxIsBasedOnOD_CheckedChanged;                CbxIsBasedOnOD.CheckedChanged += CbxIsBasedOnOD_CheckedChanged;            }            #endregion 本类中的控件        }    }

    public class HeadBase : ShellBase    {        #region 属性设置        /// <summary>        /// 封头类型        /// </summary>        protected HeadType zHeadType;        /// <summary>        /// 封头类型        /// </summary>        public HeadType HeadType        {            get            {                return zHeadType;            }            set            {                zHeadType = value;            }        }        /// <summary>        /// 封头最小厚度        /// </summary>        protected double ztmin;        /// <summary>        /// 封头最小厚度        /// </summary>        public double tmin        {            get            {                return ztmin;            }            set            {                ztmin = value;            }        }        /// <summary>        /// 封头标准,程序中直接设置        /// </summary>        protected string zHeadStandard;        /// <summary>        /// 封头标准,程序中直接设置        /// </summary>        public string HeadStandard        {            get            {                return zHeadStandard;            }            set            {                zHeadStandard = value;            }        }        /// <summary>        /// 封头直边        /// </summary>        protected double zh;        /// <summary>        /// 封头直边        /// </summary>        public double h        {            get            {                return zh;            }            set            {                zh = value;            }        }        #endregion        #region 控件属性        public TextBox TbTmin { get; set; }        public TextBox TbHeadStandard { get; set; }        public TextBox Tbh { get; set; }        #endregion 控件属性        #region 控件事件        /// <summary>        /// 在下一级的实例中执行数据验证        /// </summary>        public void HeadSetting()        {            if (Tbh != null)            {                Tbh.Validating += Tbh_Validating;            }            if (TbTmin != null)            {                TbTmin.Validating += TbTmin_Validating;            }            if (TbHeadStandard != null)            {                TbHeadStandard.Validating += TbHeadStandard_Validating;            }        }        private void TbHeadStandard_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            HeadStandard = TbHeadStandard.Text;        }        private void TbTmin_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            if (TbTmin.Text == "")            {                ErrShow.Clear();                return;            }            double val = 0;            double.TryParse(TbTmin.Text, out val);            if (val <= 0)            {                ErrShow.SetError(TbTmin, "封头最小厚度应大于0");                e.Cancel = true;            }            else if (Tn > 0)            {                if (val > Tn)                {                    ErrShow.SetError(TbTmin, "封头最小厚度应小于公称厚度");                    e.Cancel = true;                }                else                {                    tmin = val;                    ErrShow.Clear();                }            }            else            {                tmin = val;                ErrShow.Clear();            }        }        private void Tbh_Validating(object sender, System.ComponentModel.CancelEventArgs e)        {            if (Tbh.Text == "")            {                ErrShow.Clear();                return;            }            double val = 0;            double.TryParse(Tbh.Text, out val);            if (val < 25)            {                ErrShow.SetError(Tbh, "封头直边应大于等于25mm");                e.Cancel = true;            }            else            {                h = val;                ErrShow.Clear();            }        }        #endregion 控件事件        public HeadBase()        {        }        /// <summary>        ///         /// </summary>        /// <param name="V"></param>        /// <param name="S"></param>        /// <param name="SB"></param>        public HeadBase(Vessel V, Space S, ShellBase SB)            : base(V, S, SB)        {        }        /// <summary>        /// 继承容器类中的属性值        /// 继承腔体类中的属性值        /// 并且设置下一级类中的属性值        /// </summary>        /// <param name="V"></param>        /// <param name="S"></param>        /// <param name="HB"></param>        public HeadBase(Vessel V, Space S, ShellBase SB, HeadBase HB)            : base(V, S, SB)        {            #region 控件继承            if (HB.Tbh!=null)            {                Tbh = HB.Tbh;            }            if (HB.TbTmin != null)            {                TbTmin = HB.TbTmin;            }            if (HB.TbHeadStandard != null)            {                TbHeadStandard = HB.TbHeadStandard;            }            #endregion 控件继承            #region 属性传值            h = HB.h;            tmin = HB.tmin;            HeadStandard = HB.HeadStandard;            #endregion 属性传值        }        #region 锥形封头公用函数        public double wConeInArea(double Di, double Dis, double ang)        {            double angH = ang.DegreeToRadian();            double L = (Di / 2 - Dis / 2) / angH.SinH();            return ((Math.PI * L * (Di / 2 + Dis / 2)) * 1e-6).Round(2);        }        public double xConeVolume(double Di, double h1, double Dis, double h2, double R, double r, double ang, double tn)        {            double angH = ang.DegreeToRadian();            double a = angH.SinH() / 4;            double b = (angH.SinH() * angH.CosH() + angH) / 2 - angH.SinH();            double c = 2 * angH.SinH() - Math.Pow(angH.SinH(), 3) / 3 - angH.SinH() * angH.CosH() - angH;            double d = Math.PI * (a * Di * Di * R + b * Di * R * R + c * Math.Pow(R, 3));            double e = (Math.Pow(Di - 2 * R * (1 - angH.CosH()), 3) - Math.Pow(Dis + 2 * (1 - angH.CosH()) * (r + tn), 3)) * Math.PI / (24 * Math.Tan(angH));            double f = Math.PI * (a * Dis * Dis * (r + tn) - b * Dis * Math.Pow(r + tn, 2) + c * Math.Pow(r + tn, 3));            double g = Math.PI * Di * Di * h1 / 4;            double i = Math.PI * Dis * Dis * h2 / 4;            return ((d + e + f + g + i) * 1e-9).Round(3);        }        #endregion 锥形封头公用函数    }

    public partial class Test1 : Form    {        Vessel V = null;        Space S = null;        ShellBase SB = null;        HeadBase HB = null;        HeadEllipseBase HEB = null;        public Test1()        {            InitializeComponent();        }        private void Test1_Load(object sender, EventArgs e)        {            V = new Vessel();            V.ErrShow = errShow;            S = new Space(V);            SB = new ShellBase(V, S);            //凡是抽象类中的属性必须在其继承的类的实例中赋值才可以用            #region 控件赋值            SB.TbBaseDensity = tbBaseDensity;            SB.TbCladDensity = tbCladDensity;            SB.TbBaseMaterial = tbBaseMaterial;            SB.TbCladMaterial = tbCladMaterial;            SB.CbxIsCladPart = cbxIsCladPart;            //ShellBase            //而当前类的属性则也直接在其实例中进行赋值            SB.CbxIsBasedOnOD = cbxIsBasedOnOd;            SB.TbShellDn = tbDn;            SB.TbShellTn = tbTn;            #endregion 控件赋值            #region 直接赋值测试            //SB.BaseDensity = 8;            ////SB.CladDensity = 7;            //SB.BaseMaterial = "SA-516 70";            ////SB.CladMaterial = "SA-240 316L";            //SB.IsCladPart = false;            //SB.IsBasedOnOD = true;            //SB.ShellDn = 1000;            //SB.ShellTn = "10";            #endregion 直接赋值测试            //HeadBase            HB = new HeadBase(V, S, SB);            #region 控件赋值            HB.TbTmin = tbTmin;            HB.TbHeadStandard = tbStandard;            HB.Tbh = tbh;            #endregion 控件赋值            #region 直接赋值测试            //HB.tmin = 8;            //HB.HeadStandard = "GB/T 25198-2012";            //HB.h = 25;            #endregion 直接赋值测试            HB.ShellSetting();            HB.HeadSetting();        }        private void button2_Click(object sender, EventArgs e)        {            this.Close();        }        private void btnCal_Click(object sender, EventArgs e)        {            HEB = new HeadEllipseBase(V, S, SB, HB);            HEB.LblVolume = lblVolumne;            HEB.LblMass = lblMass;            HEB.LblInnerArea = lblInnerArea;            HEB.LblOutterArea = lblOutArea;            HEB.Cal();            HEB.SetResult();        }    }