Functions whose parameters are implicitly supplied

Question

Callback functions are able to accept some parameters, but they are not explicitly declared when calling the function.

How does this actually work? What is going on that allows us to pass a function as a parameter to another function, and implicitly include a parameter in there?

For example:

Javascript

$.get('somefile.php', {func : 'getUserNames'}).done(function(data){
    if(data)
       console.log(data); // '{"0" : "billy", "1" : "bobby"}'
    // This is a js ajax call to a php file. 
    // How exactly am I retrieving "data" ?
}, 'json');

C#

private void BeginReadingData(){
    NetworkStream stream = tcpClient.GetStream();
    stream.BeginRead(buffer, 0, bufferSize, MyCallBack, tcpClient);
}

private void MyCallBack(IAsyncResult ar){
    // Now I can operate on 'ar'
    // why and how? 
}

This is something I understand how to use, just not how to explain or correctly describe the process.

Answer 1

What do you call a callback function that accepts some parameters, but they are not explicitly declared when calling the function?

I'm not sure. In certain cases an object's method may be considered to have the object itself as an implicit parameter.

But there are no function calls with implicit parameters your examples. With a callback, you don't pass the result of calling the function, you pass the function itself.

stream.BeginRead(buffer, 0, bufferSize,
    MyCallBack, /* <- Not a function call, just a reference to a function. */
    tcpClient);

The function that you gave the callback, in these cases $.get and stream.BeginRead will call the callback function you gave them, and explicitly give it the parameters that it should take.

So what you're missing here is the definition of stream.BeginRead has something like:

public virtual ISyncResult BeginRead(
        byte[] buffer,
        int offset,
        int count,
        AsyncCallback callback,
        Object state
    ) {
    /* stuff */

    callback(ar); /* <-- called with explicit parameter */

    /* more stuff */
}

Answer 2

What do you call a callback function that accepts some parameters, but they are not explicitly declared when calling the function?

I'm not sure what you're talking about.

function(data) explicitly declares a parameter named data for the anonymous function.

private void MyCallBack(IAsyncResult ar) explicitly declares a parameter named ar with the type IAsyncResult for the function named MyCallback.

They both make that identifier available to the body of the function, and the compiler/interpreter knows to translate that identifier resolution to "access the first argument of this function".

Answer 3

In C#, the callbacks are mere delegates. Delegates wrap your callback method inside a object and that object is passed as a parameter. So, whenever you are passing a callback function, lets say an event handler, that event handler is wrapped in a delegate object. Now when the proper time of invocation comes, the corresponding element, in your example, the 'NetworkStream' object checks whether any callback is registered. If found (in your case - 'MyCallback' is registered), it then invokes the registered callback.

In JavaScript, by design, methods are nothing but objects itself. so, whenever you are passing a callback function, you are passing a object. As JavaScript does compile, it does not check the signature of the callback you are passing. If it has the proper signature (e.g. - having proper number of parameters) the callback will receive all the values, if the signature is mismatched, your callback will miss the result values.