0

我有这种情况

public class Base
{
    public Basedef def;
}

public class A : Base
{
}

public class B : A
{
    public int GetBar()
    {
        return def.bar;
    }
}


public class BaseDef
{
}

public class ADef : BaseDef
{
    public int foo;
}

public class BDef : ADef
{
    public int bar;
}

如您所见，方法 B:GetBar() 中存在错误，因为 def 无法访问 bar，但是如果您使...

public int GetBar()
{
    return (def as BDef).bar;
}

应该可以工作，但我想避免强制转换，如何使用在基类中创建的引用从定义中获取属性而不使用强制转换？

为什么要避免强制转换？，因为容易出现运行时错误并且更容易引入错误，我想要类型安全的编码。

我想要做什么

public class Factory
{
    public static Base<BaseDef> Create(BaseDef d)
    {
        if(d is BDef)
            return new B(); //Error, can not convert B to Base<BaseDef>
    }
}

public class Program
{
    B instance = Factory.Create(new BDef()); //Error, can not convert to Base<BaseDef> to B
}

我正在寻找一个优雅的解决方案

再见！

4

4 回答 4

2

为了有一个优雅的、无强制转换的解决方案，编译器需要知道它def是BDefin GetBar()。这是一种方法，我认为它适用于您的情况：

public class Base<T> where T : BaseDef
{
    public T def { get; set; }
}

public class A<T> : Base<T> where T : ADef
{
    public int GetFoo()
    {
        return def.foo; // this works, too
    }
}

public class B : A<BDef>
{
    public int GetBar()
    {
        return def.bar;
    }
}

（顺便说一句，您应该使用公共属性，而不是公共字段。请参阅老实说，公共变量和公共属性访问器之间有什么区别？出于某些原因。）

更新：您的Factory方法可能看起来像其中之一：

public static Base<T> Create<T>(T d) where T : BaseDef
{
    if(typeof(T) == typeof(BDef))
        return (Base<T>)(object)new B();
    else
        return null;
}
public static T Create<T, U>(U d) where T : Base<U> where U : BaseDef
{
    T result;
    if (typeof(T) == typeof(B))
        result = (T)(object)new B();
    else
        throw new NotImplementedException();
    result.def = d;
    return result;
}
public static T CreateAlternate<T, U>(U d) where T : Base<U>, new() where U : BaseDef
{
    return new T { def = d };
}

像这样使用：

void Main()
{
    Factory.Create(new BDef());
    Factory.Create<B, BDef>(new BDef());
    Factory.CreateAlternate<B, BDef>(new BDef());
}

我喜欢最后一个，因为没有强制转换，只要new()约束不是问题，或者第一个如果简洁的调用代码非常有价值（因为可以推断出泛型）。

于 2013-09-13T19:06:59.530 回答
1

使用演员表做这件事不是类型安全的，因为你试图做的基本上不是类型安全的。

您有一个类 A 和一个类 B，它们是 Base 的子类，并且 Base 具有对 BaseDef 的引用。BaseDef 可能是 ADef 或 BDef，你不知道是哪一个，当然不是来自告诉 B 的任何内容。

但是，如果您使用泛型，您可以向 B 提供它需要知道其 BaseDef 引用实际上是 BDef 的信息。

public class Base<T> where T : BaseDef
{
    public T def;
}

public class A<T> : Base<T> where T : ADef
{
}

public class B : A<BDef>
{
    public int GetBar()
    {
        return def.bar;
    }
}
于 2013-09-13T19:09:36.150 回答
1

为什么要避免强制转换？，因为容易出现运行时错误并且更容易引入错误，我想要类型安全的编码。

我不明白为什么 cast 容易出错，如果你不知道会发生什么RuntimeType，def我会说你的设计是错误的。

在我看来，您应该知道它的运行时类型。

有解决方法

解决方法 1：

public int GetBar()
{
    if (def is BDef)
        return ((BDef)def).bar;

    return 0;//some default value
}

解决方法2： 引入一个enum说法who am I。

public enum DefType
{
    BaseDef = 0,
    ADef =1,
    BDef =2
}

public class BaseDef
{
    public virtual DefType MyType
    {   
        get{ return  DefType.BaseDef; }
    }
}

public class ADef
{
    public override DefType MyType
    {   
        get{ return  DefType.ADef; }
    }
}

然后像这样使用它

switch(def.MyType)
{
    case DefType.ADef:
    {
        (ADef).foo;//you know who is this here right?
    }
    ...
}
于 2013-09-13T19:09:56.683 回答
0

将Basedef 设为抽象类并在其上添加抽象属性是否有意义？

于 2013-09-13T19:04:52.947 回答