C＃代表，为什么我们需要它们？

Question

I am trying to understand "callback pattern". Every answer says that this is done with delegates (which I know them). But the codes on the answers are something like that:

public delegate void Callback(string result);

public void Test()
{
    CallBack callback = CallbackFunction; 
    DoWork(callback);
}

public void DoWork(CallBack callback)
{
    callback("Hello world");
}

public void CallbackFunction(string result)
{
    Console.WriteLine(result);
}

I really don't understand, why we need delegate for this? We can do this in this way too?

public void Test()
{
    DoWork();
}

public void DoWork()
{
    CallbackFunction("Hello world");
}

public void CallbackFunction(string result)
{
    Console.WriteLine(result);
}

Besides that, for example in Java, a callback means a real "return" to the main program's "particular function" after an event. But when we use delegates, isn't this just calling another method?

How can we make a callback that finally calls an OnFail() method on fail, and OnSuccess() method on success. I am really confused. Can somebody help me to understand this?

Answer 1

A delegate safely encapsulates a method, a kind of a template to a function in its signature. Sometimes it is easy to think it is a pointer to a function.

In your sample, the CallbackFunction can be setted to Callback because both in its definition takes just a string argument.

You could use Action and Func instead of delegate . The difference between them is that an Action does not return something and Func does. For sample:

public void Test(Action success, Action<Exception> error)
{
    try
    {
        // perform some task
        success();
    }
    catch (Exception ex)
    {
        error(ex);
    }
}

And use it:

Test(() => { Console.WriteLine("Success"); },
     (ex) => { Console.WriteLine($"Error: {ex.Message}"); });

the generic option of an Action is the type of the arguments you can pas to this method. On the sample, Exception is a argument which is passed to error Action . The same is valid for a Func<> but the last type of a Func is the result type.

Answer 2

Why do we need delegates?

Because in many programs, you need the ability to abstract the concept of a method. One reason is events, another is a set of methods like this:

public void DoWork(Action completeCallback)
{
    ... //Do Stuff
    completeCallback();
}

public void FirstMainMethod()
{
     DoWork(() => Console.WriteLine("First callback");
}

public void SecondMainMethod()
{
     DoWork(() => Console.WriteLine("Second callback");
}

In other words, different parts of my code need to have a different method run on completion, so I pass it in (I can't use a direct call). The delegate abstraction allows this. Also note that the idea of a "completion" callback in .NET is pretty silly, you almost never need it. You will use delegates for this general idea all the time though.

How can we make a callback that finally calls an OnFail() method on fail, and OnSuccess() method on success?

You can do this pretty easily. You can even make a somewhat generic one (not sure if you would ever want to mind you, but the following code works):

public void SuccessFailHelper(Func<bool> work, Action success, Action failure)
{
   if (work())
      success();
   else
      failure();
}