预期的接口名称 - 但我不明白如何实现它

本文关键字：何实现 明白 实现 接口 | 更新日期: 2023-09-27 18:34:02

我有以下类：

public abstract class CommonEvents : DisposableObject
{
    /// <summary>
    /// Internal method for storing error messages to our event
    /// </summary>
    /// <param name="message"></param>
    /// <param name="showException"></param>
    /// <param name="exception"></param>
    public void OnError(string message, OnErrorEventsArgs.ShowExceptionLevel showException, Exception exception)
    {
        if (_onErrorEvent == null) return;
        var e = new OnErrorEventsArgs(message, showException, exception);
        _onErrorEvent(this, e);
    }
    /// <summary>
    /// Internal event handler allowing for logging of events within the class
    /// </summary>
    private EventHandler<OnErrorEventsArgs> _onErrorEvent;
    /// <summary>
    /// Public event handler allowing for accessibility outside of the class
    /// </summary>
    public event EventHandler<OnErrorEventsArgs> OnErrorEvent
    {
        add { _onErrorEvent += value; }
        remove { _onErrorEvent += value; }
    }
}

我正在尝试在我的一个项目中继承它，但是我已经在那里继承了另一个类，代码如下：

public class ItemDal : Common.Dal.BaseDal, CommonEvents
{

我收到的错误是

"常见事件"：应使用接口名称

当我研究这个时，我试图构建一个界面 - 但后来失败了，因为我没有足够的理解来完成这个。你能帮我理解这一点，或者为我指出一篇好文章的方向来帮助我做到这一点吗？

预期的接口名称 - 但我不明白如何实现它

我正在尝试在我的一个项目中继承它，但是我已经在那里继承了另一个类

这是编译器告诉你 C# 不支持多重继承的方式。如果将类放在基列表中，则其余名称必须引用接口。

仅当其中一个类直接或间接继承另一个类时，您才能继承两个类;这样，您才能继承派生最多的类，以及恰好是其基的另一个类。

C# 中的常见解决方案是从其中一个类中提取接口，嵌入实现的实例，并通过组合将接口调用转发到类中包含的实现。

在您的情况下，它看起来像这样：

interface ICommonEvents {
    void OnError(string message, OnErrorEventsArgs.ShowExceptionLevel showException, Exception exception);
    event EventHandler<OnErrorEventsArgs> OnErrorEvent {add;remove;}
}
// Keep the implementation the same
public class CommonEvents : DisposanbleObject, ICommonEvents {
    ...
}
// Here is your derived class:
public class ItemDal : Common.Dal.BaseDal, ICommonEvents {
    private readonly CommonEvents ce = ... // Initialize your common events
    void OnError(string message, OnErrorEventsArgs.ShowExceptionLevel showException, Exception exception) {
        ce.OnError(message, showException, exception);
    }
    event EventHandler<OnErrorEventsArgs> OnErrorEvent {
        add {ce.OnErrorEvent += value;}
        remove {ce.OnErrorEvent -= value;}
    }
}

在 C# 中，class只能继承另一个class（尽管该类可能继承另一个类，依此类推）。

:之后的任何class内容都必须是接口，因此编译器期望CommonEvents是一个interface，但事实并非如此。

这里有两种方法：

  1. 让Common.Dal.BaseDal继承CommonEvents（这样ItemDal将"通过"Common.Dal.BaseDal继承CommonEvents。
  2. 在 ItemDal 中使用您的一个类。因此，ItemDal可能会公开类似于该方法的成员，但它所做的只是调用包含所有逻辑的组件。这称为组合。

CommonEvents 不是一个接口，它是一个抽象类。抽象类必须继承，而接口是编译器所期望的。这是关于差异的文章。您可以将抽象类更改为接口并仅将代码放在父类中吗？喜欢这个

public interface class ICommonEvents 
{
    /// <summary>
    /// Internal method for storing error messages to our event
    /// </summary>
    /// <param name="message"></param>
    /// <param name="showException"></param>
    /// <param name="exception"></param>
    public void OnError(string message, OnErrorEventsArgs.ShowExceptionLevel showException, Exception exception);
    /// <summary>
    /// Internal event handler allowing for logging of events within the class
    /// </summary>
    private EventHandler<OnErrorEventsArgs> _onErrorEvent;
    /// <summary>
    /// Public event handler allowing for accessibility outside of the class
    /// </summary>
    public event EventHandler<OnErrorEventsArgs> OnErrorEvent;
}
public class CommonEvents : DisposableObject, ICommonEvents
{
    /// <summary>
    /// Internal method for storing error messages to our event
    /// </summary>
    /// <param name="message"></param>
    /// <param name="showException"></param>
    /// <param name="exception"></param>
    public void OnError(string message, OnErrorEventsArgs.ShowExceptionLevel showException, Exception exception)
    {
        if (_onErrorEvent == null) return;
        var e = new OnErrorEventsArgs(message, showException, exception);
        _onErrorEvent(this, e);
    }
    /// <summary>
    /// Internal event handler allowing for logging of events within the class
    /// </summary>
    private EventHandler<OnErrorEventsArgs> _onErrorEvent;
    /// <summary>
    /// Public event handler allowing for accessibility outside of the class
    /// </summary>
    public event EventHandler<OnErrorEventsArgs> OnErrorEvent
    {
        add { _onErrorEvent += value; }
        remove { _onErrorEvent += value; }
    }
}
public class ItemDal : CommonEvents
{ ...

你不能从多个类继承，你可以从类和接口继承

在 C# 中可以从多少个类继承？

接口基本上是一个合约。您将需要一个具体的类来实现合约。

你应该链接你的继承，例如B：A，C：B，或者为CommonEvents创建一个接口，如下所示：

 public interface ICommonEvents
{
    void BroadcastMessage(string text);
}
public class CommonEvents : ICommonEvents
{
    public void BroadcastMessage(string text)
    {
    }
}

现在你可以实现接口，并将具体的类 CommonEvents 作为依赖项，并将你的方法委托给它

public class ItemDal : Common.Dal.BaseDal, ICommonEvents
{
    private readonly CommonEvents _commonEvents;
    public ItemDal(CommonEvents commonEvents)
    {
        _commonEvents = commonEvents;
    }
    #region Implementation of ICommonEvents
    void ICommonEvents.BroadcastMessage(string text)
    {
        _commonEvents.BroadcastMessage(text);
    }
    #endregion
}

在这样做之前，如果你真的需要这样做，我会敦促你考虑你的设计，因为它可能违反了单一责任原则（https://en.wikipedia.org/wiki/Single_responsibility_principle）。DAL 类不应执行错误处理

相关文章：