c# - 显式接口(interface)和通用/动态类型转换

Question

在陈述我的问题之前，让我提供一些关于我正在尝试做的事情的背景信息，因为也许有更好的方法来实现它。

我上课了C其中继承了两个接口(interface)A和 B .

public interface A
{
    void DoStuff();
}

public interface B
{
    void DoStuff();
}

C 为 DoStuff 实现了两个不同的主体.

void A.DoStuff()
{
    Console.WriteLine("A");
}

void B.DoStuff()
{
    Console.WriteLine("B");
}

我当然知道DoStuff可以像下面这样调用。

var c = new C();
var a = (A)c;
a.DoStuff();
var b = (B)c;
b.DoStuff();

不过我想做的是避免转换 C到 A或 B然后调用DoStuff在 A或 B .

所以我认为我可以实现一个通用方法来为我做这件事，所以我首先尝试这样做。

public void DoStuff<T>()
{
    var i = (T)this;
    i.DoStuff();
}

当然，考虑到您可以转换 this，那是行不通的至 T它会导致编译器错误，所以我的下一步是尝试创建一个静态方法来传递 this 的实例。然后在那里进行转换。

private static To ConvertToDoStuffInterface<From, To>(From from)
{
    return (To)from;
}

我没想到会奏效，但值得一试。如我所料，它会导致编译器错误，因为 From无法显式转换为 To .

我最后的选择是使用 dynamic关键字，当然它顺利通过 ConvertToDoStuffInterface , 但是一旦我尝试调用 DoStuff它抛出 RuntimeBinderException我有点怀疑它可能会。我知道为什么会抛出异常，这当然是因为它无法正确绑定(bind) ConvertToDoStuffInterface 的结果。任何类型，我假设需要某种类型的转换。

这是 dynamic 的代码用法。

private static dynamic ConvertToDoStuffInterface<T>(dynamic from)
{
    return (T)from;
}

public void DoStuff<T>()
{
    var i = ConvertToDoStuffInterface<T>(this);
    i.DoStuff();
}

但我的问题是，是否没有更好的方法使用泛型或 dynamic 来实现此目的？ ，我将如何从 dynamic 进行转换？至 T ？有没有一种方法可以检查传递的类型是否为 DoStuff<T>有一个方法 DoStuff然后允许我最初的尝试？

澄清我想要做的事情是这样的

var c = new C();
c.DoStuff<A>(); // Calls A.DoStuff()
c.DoStuff<B>(); // Calls B.DoStuff()

这是我的 C实现。

public class C : A, B
{        
    public void DoStuff<T>()
    {
        // ... DoStuff<T> implementation here ...
    }

    void A.DoStuff()
    {
        Console.WriteLine("A");
    }

    void B.DoStuff()
    {
        Console.WriteLine("B");
    }
}

Answer 1

您可以使用这两个InvokeAs扩展方法

public static void InvokeAs<T>(this object obj, Action<T> action)
{
    action((T) obj);
}

public static TResult InvokeAs<T, TResult>(this object obj, Func<T, TResult> func)
{
    return func((T) obj);
}

然后像这样使用:

var c = new C();

c.InvokeAs<A>(x => x.DoStuff());
c.InvokeAs<B>(x => x.DoStuff());

但正如评论中指出的那样，((B) c).DoStuff() 并没有那么糟糕。