C# 扩展接口实现作为一个参数来委托，它采用基本接口

Question

我有一个扩展了其他接口的接口，如下所示：

interface IBase
{
  int Id { get; set; }
  string Name { get; set; }
}

interface IExtended : IBase
{
  bool IsChecked { get; set; }
}

然后我使用基接口作为委托函数中的参数，它也是类构造函数的参数，如下所示：

public class SomeClass
{
  private IBase _model;
  private Func<IBase, string> _handler;

  public SomeClass(IBase model, Func<IBase, string> handler)
  {
    _model = model;
    _handler = handler;
  }

  public string ExecuteHandler()
  {
    return _handler(model);
  }
}

接口实现：

public class BaseImplementation : IBase
{
  int Id { get; set; }
  string Name { get; set; }

  public BaseImplementation(int id, string name)
  {
    Id = id;
    Name = name;
  }
}

public class ExtendedImplementation : IExtended
{
  int Id { get; set; }
  string Name { get; set; }
  bool IsChecked { get; set; }

  public BaseImplementation(int id, string name, bool isChecked)
  {
    Id = id;
    Name = name;
    IsChecked = isChecked;
  }
}

预期用途：

BaseImplemetation baseModel = new BaseImplementation(1, "base");
ExtendedImplemetation extendedModel = new ExtendedImplementation(2, "extended", true);

SomeClass someClass1 = new SomeClass(baseModel, (IBase arg) => {
  Console.Write("Remember, " + arg.name + ", YOLO!");
});

SomeClass someClass2 = new SomeClass(extendedModel, (IExtended arg) => {
  Console.Write(arg.name + ", YOLO! You're " + (arg.IsChecked) ? "checked!" : "not checked!");
});

string res1 = someClass1.ExecuteHandler();
string res2 = someClass2.ExecuteHandler();

但是那 ( 不起作用，即使 IExtended 的实现必然会实现 IBase 接口定义的所有内容。为什么会这样，我将如何绕过它并获得我想要的结果？

编辑：

我想我现在明白了。

我认为 Func<IBase, string> 等于 Func<IExtended, string> 因为 IExtended 当然实现了 IBase 所做的一切，所以应该没有问题，对吧？按照我的意愿和在我的示例中列出的实现当然可以正常工作。

但是！问题是 someClass2 不能这样构造，因为正如@Servy 提到的，委托函数可以做这样的事情：

SomeClass someClassWrong = new SomeClass(baseModel, (IExtended arg) => {
  if (arg.IsChecked) {
    // gotcha, baseModel doesn't have IsChecked property!
  }
});

编辑 2：

感谢大家的帮助，很抱歉不断编辑并给出我想要的错误示例：D

Answer 1

但这不起作用，即使IExtended 的实现必然会实现IBase 接口定义的所有内容。为什么会这样，我将如何绕过它并获得我想要的结果？

当SomeClass 调用该委托时它实际上可能不会传递IExtended 实例。允许提供 any IBase 实例作为参数，所以如果它提供了一个 不 实现 IExtended 的实例，那么您希望您的代表做什么?

如果SomeClass总是要传递一个IExtended 实例，然后相应地修改它在其构造函数中接受的委托，以便调用者始终知道他们得到了一个IExtended实例作为参数。

Answer 2

您可以简单地定义一个知道IBase 确实是IExtended 的委托：

SomeClass someClass = new SomeClass((IBase arg) => { (arg as IExtended).DoSomethingOnlyExtendedKnowsAbout(); });

这可能是不安全的，但如果你能以某种方式强制传递给特定 lamda 的 arg 将始终是 IExtended，那么就没有害处。您还可以在 lambda 本身中提供一种安全机制，并在调用堆栈中相应地对其进行管理：

SomeClass someClass = new SomeClass((IBase arg) => { (arg as IExtended)?.DoSomethingOnlyExtendedKnowsAbout(); });

Answer 3

我没有看到问题。根据您拥有的代码，以下内容按预期工作：

public class SomeClass
{
    public SomeClass(Func<IBase, string> handlerFcn)
    {
        // something gets done
        this.Handler=handlerFcn;
    }
    public Func<IBase, string> Handler { get; set; }
}

public static class Program
{
    static void Main(string[] args)
    {
        var s1 = new SomeClass((x) => x.SomeMethod());
        var xt = new ExtendedClass();
        var result = s1.Handler(xt);
        // result = "yolo extended edition!"
    }
}

我认为您试图在 lambda 定义中使用具体类 ExtendedClass，除非您使用 define it as a closure，否则这将不起作用。