关于c#:如何在不进行转换的情况下引用具有不同类型的父变量?

How to reference parent variable with a different type without casting?

我有这种情况

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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的权限,但是如果您使…

1
2
3
4
public int GetBar()
{
    return (def as BDef).bar;
}

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

为什么要避免演员阵容?,因为很容易出现运行时错误并且更容易引入错误,所以我需要类型安全的编码。

我想做的

1
2
3
4
5
6
7
8
9
10
11
12
13
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
}

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

再见!


为了有一个优雅的、无强制转换的解决方案,编译器需要知道defGetBar()中的BDef。这是一种方法,我认为这对您的情况很有效:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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方法可能如下所示:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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 };
}

用途:

1
2
3
4
5
6
void Main()
{
    Factory.Create(new BDef());
    Factory.Create<B, BDef>(new BDef());
    Factory.CreateAlternate<B, BDef>(new BDef());
}

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