2

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

我有一个类C继承了两个接口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为Aor B，然后DoStuff调用Aor 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我知道为什么会抛出异常，这当然是因为它无法将结果正确绑定ConvertToDoStuffInterface到任何类型，并且我假设需要某种类型的转换。

这是dynamic用法的代码。

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

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

不过我的问题是，如果没有更好的方法可以使用泛型来实现这一点，或者dynamic，我将如何进行从dynamicto的转换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");
    }
}
4

3 回答 3

2

您可以使用这两种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()并不是那么糟糕。

于 2015-08-27T13:04:44.833 回答
1

我同意强制转换可能是最干净的（假设您无法修复接口中的名称冲突），但另一种方法是创建两个实例方法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");
    }

    public void DoStuffAsA() { ((A)this).DoStuff(); }
    public void DoStuffAsB() { ((B)this).DoStuff(); }
}

至少它给了你编译时的安全性dynamic，反射和泛型没有。

于 2015-08-27T13:18:45.650 回答
1

要完全按照您的意愿进行行为，您可以使用反射：

class C : A, B
{
    void B.DoStuff()
    {
        Console.WriteLine("B");
    }

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

    public void DoStuff<T>() 
    {
        var mi = typeof(T).GetMethod("DoStuff");
        mi.Invoke(this, new object[] { });
    }
}

然后调用：

        var c = new C();
        c.DoStuff<A>();
        c.DoStuff<B>();
        Console.ReadLine();

按预期工作。显然，如果“DoStuff”方法存在等等，您必须在 DoStuff 方法中进行适当的验证。

但是 - 我不知道用例 - 但对我来说，这似乎不是那么明显，为什么这比铸造更适合你。

于 2015-08-27T13:09:37.097 回答