Why is state parameter an object in various APIs?

[marcinjahn]

A few methods that require delegates as one of their params also accept state parameter. Examples:

• https://learn.microsoft.com/en-us/dotnet/api/system.threading.tasks.taskfactory.startnew?view=net-9.0#system-threading-tasks-taskfactory-startnew(system-action((system-object))-system-object-system-threading-cancellationtoken-system-threading-tasks-taskcreationoptions-system-threading-tasks-taskscheduler)
• https://learn.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.http.httpresponse.onstarting?view=aspnetcore-9.0#microsoft-aspnetcore-http-httpresponse-onstarting(system-func((system-object-system-threading-tasks-task))-system-object)

One of the advantages of these overloads that contain state is the fact that they might help with avoiding allocations with closures. However, the fact that they're of type object makes it impossible to avoid allocation when the thing being provided is not a reference type.
Why aren't those overloads generic, allowing anything to be provided as state?

For example, wouldn't it be beneficial for OnStarting to have the following shape:

OnStarting<T> (Func<T,System.Threading.Tasks.Task> callback, T state);

?

[huoyaoyuan]

It can avoid allocating additional closure object over existing state objects. For asynchronous calls, an allocation is unavoidable. In many cases, there is already an object holding enough information.
Making the delegate method an instance method of the object is not always applicable.

[jilles-sg]

Many of these APIs including HttpResponse.OnStarting and CancellationToken.Register work with multiple callbacks per object. It is easy to add an object state field to a type next to the field containing the delegate, even if the containing type is a struct or is pooled. However, a generic T state would have to be stored in a generic class or struct which would need to be cast to a non-generic class or interface type, incurring an allocation for each callback added.

For example, here is an HttpResponse.OnStarting implementation that stores the given callback and state in a struct: https://github.com/dotnet/aspnetcore/blob/81a2bab8704d87d324039b42eb1bab0d977f25b8/src/Servers/Kestrel/Core/src/Internal/Http/HttpProtocol.cs#L793 . If the Stack has sufficient capacity (such as from a previous request), adding a callback is allocation-free.

This does not explain why TaskFactory.StartNew does not have generic states, since Task or Task<T> could be inherited from to hold a generic state. Perhaps the idea there is that it is not worth it (considering the overhead in scheduling operations), and asynchronous operations tend to have something of class type to manage them.

By the way, using the state parameter can save an allocation even if a tuple or other value type has to be boxed, since a lambda capturing a variable will result in one allocation for a DisplayClass object to hold the variable and another for the delegate. With the state parameter there is just the box to hold the state since the non-capturing lambda is shared.

[teo-tsirpanis]

You can use this if you want to launch a stateful function in a background thread. The TState value will not be boxed but stored alongside the returned task object.

static async Task<T> TaskRun<T, TState>(Func<TState, T> f, TState state)
{
    await Task.Yield();
    return f(state);
}