Comment obtenir la référence de tâche actuelle?

Comment puis-je obtenir une référence à la tâche que mon code est exécuté à l'intérieur?

ISomeInterface impl = new SomeImplementation();
Task.Factory.StartNew(() => impl.MethodFromSomeInterface(), new MyState());

...

void MethodFromSomeInterface()
{
    Task currentTask = Task.GetCurrentTask();    //No such method?
    MyState state = (MyState) currentTask.AsyncState();
}

Depuis que je suis en appelant la méthode de l'interface, je ne peux pas juste passer à la tâche nouvellement créée comme un paramètre supplémentaire.

source d'informationauteur Reuven Bass

c#task-parallel-library

Puisque vous ne pouvez pas changer l'interface, ni la mise en œuvre, vous devrez le faire vous-même, par exemple, à l'aide de ThreadStaticAttribute:

static class SomeInterfaceTask
{
  [ThreadStatic]
  static Task Current { get; set; }
}

...

ISomeInterface impl = new SomeImplementation();
Task task = null;
task = Task.Factory.StartNew(() =>
{
  SomeInterfaceTask.Current = task;
  impl.MethodFromSomeInterface();
}, new MyState());

...

void MethodFromSomeInterface()
{
  Task currentTask = SomeInterfaceTask.Current;
  MyState state = (MyState) currentTask.AsyncState();
}

Ici est un "hacky" classe qui peut être utilisée pour cela.

Utilisez simplement le CurrentTask propriété afin d'obtenir le courant de l'exécution de la Tâche.

Je déconseille fortement de l'utiliser n'importe où près de la production de code!

public static class TaskGetter
{
    private static string _propertyName;
    private static Type _taskType;
    private static PropertyInfo _property;
    private static Func<Task> _getter;

    static TaskGetter()
    {
        _taskType = typeof(Task);
        _propertyName = "InternalCurrent";
        SetupGetter();
    }

    public static void SetPropertyName(string newName)
    {
        _propertyName = newName;
        SetupGetter();
    }

    public static Task CurrentTask
    {
        get
        {
            return _getter();
        }
    }

    private static void SetupGetter()
    {
        _getter = () => null;
        _property = _taskType.GetProperties(BindingFlags.Static | BindingFlags.NonPublic).Where(p => p.Name == _propertyName).FirstOrDefault();
        if (_property != null)
        {
            _getter = () =>
            {
                var val = _property.GetValue(null);
                return val == null ? null : (Task)val;
            };
        }
    }
}

L'exemple suivant montre comment il peut être atteint, la résolution de la question avec la réponse fournie par @stephen-cleary. C'est un peu compliqué, mais essentiellement, la clé est dans la TaskContext de classe ci-dessous qui utilise CallContext.LogicalSetDataCallContext.LogicalGetData et CallContext.FreeNamedDataSlot qui sont utiles pour la création de vos propres contextes. Le reste de la peluche est de répondre à l'OP question:

class Program
{
static void Main(string[] args)
{
var t1 = Task.Factory.StartNewWithContext(async () => { await DoSomething(); });
var t2 = Task.Factory.StartNewWithContext(async () => { await DoSomething(); });
Task.WaitAll(t1, t2);
}
private static async Task DoSomething()
{
var id1 = TaskContext.Current.Task.Id;
Console.WriteLine(id1);
await Task.Delay(1000);
var id2 = TaskContext.Current.Task.Id;
Console.WriteLine(id2);
Console.WriteLine(id1 == id2);
}
}
public static class TaskFactoryExtensions
{
public static Task StartNewWithContext(this TaskFactory factory, Action action)
{
Task task = null;
task = new Task(() =>
{
Debug.Assert(TaskContext.Current == null);
TaskContext.Current = new TaskContext(task);
try
{
action();
}
finally
{
TaskContext.Current = null;
}
});
task.Start();
return task;
}
public static Task StartNewWithContext(this TaskFactory factory, Func<Task> action)
{
Task<Task> task = null;
task = new Task<Task>(async () =>
{
Debug.Assert(TaskContext.Current == null);
TaskContext.Current = new TaskContext(task);
try
{
await action();
}
finally
{
TaskContext.Current = null;
}
});
task.Start();
return task.Unwrap();
}
}
public sealed class TaskContext
{
//Use your own unique key for better performance
private static readonly string contextKey = Guid.NewGuid().ToString();
public TaskContext(Task task)
{
this.Task = task;
}
public Task Task { get; private set; }
public static TaskContext Current
{
get { return (TaskContext)CallContext.LogicalGetData(contextKey); }
internal set
{
if (value == null)
{
CallContext.FreeNamedDataSlot(contextKey);
}
else
{
CallContext.LogicalSetData(contextKey, value);
}
}
}
}

Si vous pouvez utiliser .NET de 4,6 ou plus .NET Standard ou .NET de Base, ils ont résolu ce problème avec AsyncLocal.
https://docs.microsoft.com/en-gb/dotnet/api/system.threading.asynclocal-1?view=netframework-4.7.1

Si non, vous devez configurer un magasin de données quelque part avant de l'utiliser et d'y accéder via une fermeture, pas un fil ou d'une tâche. ConcurrentDictionary aidera à couvrir les erreurs que vous faites cela.

Lorsque le code attend, la tâche en cours libère le fil - à-d. les threads ne sont pas liés à des tâches, dans le modèle de programmation au moins.

Démo:

//I feel like demo code about threading needs to guarantee
//it actually has some in the first place :)
//The second number is IOCompletionPorts which would be relevant
//if we were using IO (strangely enough).
var threads = Environment.ProcessorCount * 4;
ThreadPool.SetMaxThreads(threads, threads);
ThreadPool.SetMinThreads(threads, threads);
var rand = new Random(DateTime.Now.Millisecond);
var tasks = Enumerable.Range(0, 50)
.Select(_ =>
{
//State store tied to task by being created in the same closure.
var taskState = new ConcurrentDictionary<string, object>();
//There is absolutely no need for this to be a thread-safe
//data structure in this instance but given the copy-pasta,
//I thought I'd save people some trouble.
return Task.Run(async () =>
{
taskState["ThreadId"] = Thread.CurrentThread.ManagedThreadId;
await Task.Delay(rand.Next() % 100);
return Thread.CurrentThread.ManagedThreadId == (int)taskState["ThreadId"];
});
})
.ToArray();
Task.WaitAll(tasks);
Console.WriteLine("Tasks that stayed on the same thread: " + tasks.Count(t => t.Result));
Console.WriteLine("Tasks that didn't stay on the same thread: " + tasks.Count(t => !t.Result));

Vous devez vous connecter pour publier un commentaire.