C# 从基类中抛弃

我知道铸造不是天生的坏做法，但在这种情况下是坏的吗

我有下面的类层次结构，最后还有演员阵容

    public class A<T>
    {
        public A(string name, T value)
        {
            Name = name;
            Value = value;
        }

        public string Name { get; }
        public T Value { get; }
    }

    public class B : A<double>
    {
        public B(string name, double value, string expression)
            : base(name, value)
        {
            Expression = expression;
        }

        public string Expression { get; }
    }

    public class C
    {
        public C(A<double> a)
        {
            _a = a;
        }

        public string Name { get { return _a.Name; } }
        public double Value { get { return _a.Value; } }
        protected A<double> _a;
    }

    public class D : C
    {
        public D(B b) : base(b)
        {
        }

        public string Expression { get { return ((B)_a).Expression; } }
    }

公共A类
{
公共A（字符串名称，T值）
{
名称=名称；
价值=价值；
}
公共字符串名称{get；}
公共T值{get；}
}
B级：A级
{
公共B（字符串名称、双值、字符串表达式）
：base（名称、值）
{
表达式=表达式；
}
公共字符串表达式{get；}
}
公共C类
{
公共图书馆C（A）
{
_a=a；
}
公共字符串名称{get{return}a.Name；}
公共双值{get{return}a.Value；}
受保护的A_A；
}
D类：C类
{
公共D（B）：基地（B）
{
}
公共字符串表达式{get{return（（B）_a）.Expression；}
}

所涉行：

---

公共字符串表达式{get{return（（B）_a）.Expression；}是的，这是一种不好的做法；就像所有的悲观情绪一样（有时是必须的，但这并不意味着它是好的）

以下代码将生成运行时异常：

A<double> myA = new A<double>("Test", 1.0d);
D test = new D(myA);
var boom = test.Expression; //InvalidCastException

A myA=新A（“测试”，1.0d）；
D试验=新的D（myA）；
var-boom=test.Expression//无效例外

---

而另一种结构甚至不会编译。例如，将

D

修改为采用

B

而不是

a

是，这是一种不好的做法；就像所有的悲观情绪一样（有时是必须的，但这并不意味着它是好的）

以下代码将生成运行时异常：

A<double> myA = new A<double>("Test", 1.0d);
D test = new D(myA);
var boom = test.Expression; //InvalidCastException

A myA=新A（“测试”，1.0d）；
D试验=新的D（myA）；
var-boom=test.Expression//无效例外

---

而另一种结构甚至不会编译。例如，修改

D

以采用

B

而不是

a

尝试此操作，使C类成为通用类

public class C<T> where T : A<double>
{
    public C(T thing)
    {
        _thing = thing;
    }
    protected T _thing;
}

公共C类，其中T:A
{
公共C（T事物）
{
_事物=事物；
}
受保护的东西；
}

那么D可以是C的一个实例，其泛型参数为B

public D : C<B>
{
    Public string Expression { get {return _thing.Expression;}}
}

公共D:C { 公共字符串表达式{get{return}thing.Expression；} }

---

我正在打电话，请原谅。任何格式或打字问题

试试这个，让C类成为通用类

public class C<T> where T : A<double>
{
    public C(T thing)
    {
        _thing = thing;
    }
    protected T _thing;
}

公共C类，其中T:A
{
公共C（T事物）
{
_事物=事物；
}
受保护的东西；
}

那么D可以是C的一个实例，其泛型参数为B

public D : C<B>
{
    Public string Expression { get {return _thing.Expression;}}
}

公共D:C { 公共字符串表达式{get{return}thing.Expression；} }

---

我在打电话，所以请原谅。任何格式或打字问题

你的D构造函数可以引用B的一个实例，并将其传递给基构造函数，因为B是a的一个子类，所以我说sAlso你实际上没有问过一个问题…@Dave问题隐藏在第一句话中：“这是一个糟糕的做法吗？”，这里的坏习惯是一个非私有的字段用属性或方法封装它你的D构造函数可以取B的一个实例并将其传递给基构造函数，因为B是a的一个子类，所以说sAlso你实际上没有问过问题…@Dave问题隐藏在第一句话中：“这是坏习惯吗”依我看，这里不好的做法是一个非私有的字段用属性或方法封装它这使它在我看来看起来更好但是通过你对代码的编辑，我想说这对强制转换很好，你的ctor确保强制转换成功这使它在我看来看起来更好但是通过你对代码的编辑，我得说演员们都很好，你的经纪人确保演员们成功