C# 即使只有一个动作参数就足够了，也要使用事件？

在我的场景中，我有一个类，它会时不时地为我做一些工作，偶尔会对它做出一些动作。行动的实际内容将由外部提供。我认为重要的是要提到，只有一个来自外部的实例告诉这个类必须做什么

我已经实现了如下内容：

public class DelegatePublisher
{
    private Action<byte[], int, int> onCompleted;

    public DelegatePublisher(Action<byte[], int, int> onCompleted)
    {
        this.onCompleted = onCompleted;
    }

    public void Invoke(byte[] buffer, int index, int count)
    {
        onCompleted.Invoke(buffer, index, count);
    }
}

public class EventPublisher
{
    public EventHandler<EventPublisherEventArgs> OnCompleted;

    public void Invoke(byte[] buffer, int index, int count)
    {
        var handler = OnCompleted;
        if (handler != null)
        {
            handler(this, new EventPublisherEventArgs(buffer, index, count));
        }
    }
}

public class Example
{
    public void Test()
    {
        var byEvent = new EventPublisher();
        byEvent.OnCompleted += onEvent;
    }

    private void onEvent(object sender, EventPublisherEventArgs e)
    {
        // do stuff
    }
}

一旦调用

Invoke

，将调用操作。（为了这个简单的例子，我特意省略了所有的

null

检查）

这就像预期的一样，我对这个解决方案很满意。然而，人们一直告诉我应该使用

事件

。我告诉他们，我只需要调用一个

操作

，代码做得非常好。经过长时间的讨论，代码如下所示：

public class DelegatePublisher
{
    private Action<byte[], int, int> onCompleted;

    public DelegatePublisher(Action<byte[], int, int> onCompleted)
    {
        this.onCompleted = onCompleted;
    }

    public void Invoke(byte[] buffer, int index, int count)
    {
        onCompleted.Invoke(buffer, index, count);
    }
}

public class EventPublisher
{
    public EventHandler<EventPublisherEventArgs> OnCompleted;

    public void Invoke(byte[] buffer, int index, int count)
    {
        var handler = OnCompleted;
        if (handler != null)
        {
            handler(this, new EventPublisherEventArgs(buffer, index, count));
        }
    }
}

public class Example
{
    public void Test()
    {
        var byEvent = new EventPublisher();
        byEvent.OnCompleted += onEvent;
    }

    private void onEvent(object sender, EventPublisherEventArgs e)
    {
        // do stuff
    }
}

我的。。。“调用”代码现在看起来像这样：

public class DelegatePublisher
{
    private Action<byte[], int, int> onCompleted;

    public DelegatePublisher(Action<byte[], int, int> onCompleted)
    {
        this.onCompleted = onCompleted;
    }

    public void Invoke(byte[] buffer, int index, int count)
    {
        onCompleted.Invoke(buffer, index, count);
    }
}

public class EventPublisher
{
    public EventHandler<EventPublisherEventArgs> OnCompleted;

    public void Invoke(byte[] buffer, int index, int count)
    {
        var handler = OnCompleted;
        if (handler != null)
        {
            handler(this, new EventPublisherEventArgs(buffer, index, count));
        }
    }
}

public class Example
{
    public void Test()
    {
        var byEvent = new EventPublisher();
        byEvent.OnCompleted += onEvent;
    }

    private void onEvent(object sender, EventPublisherEventArgs e)
    {
        // do stuff
    }
}

作为一个

事件来做实际上有什么好处吗？或者反过来说：使用
操作的方式是否有问题

通过使用
Events
我所能知道的是，我需要更多的代码，有一个额外的抽象层，可能连接多个（不需要）回调，并且需要一个额外的类来保存三个参数。我看到的唯一好处是我遵循一个共同的模式。然而，我已经看到了很多将动作作为参数传递的代码，甚至在BCL中，这可能也可以通过事件来解决

作为一项活动进行到底有什么好处

虽然我非常固执己见，但我会努力表达我的观点

我看不到任何直接的好处。这通常取决于你需要什么。事件只是围绕委托的包装，它们添加了另一个抽象级别（如您所说）

你一定要用吗？不，我认为您的工作代码示例没有问题。不要因为“人们认为他们更好”而使用某些模式。跟随它们，因为你已经看到了使用它们的明显好处。在这种情况下，我看不到任何附加值