Fils et délégués - Je ne comprends pas complètement leurs relations

Multi-threading est très complexe. Vous êtes à couper et coller le code sans même apprendre quoi que ce soit sur les aspects les plus fondamentaux de filetage - comment faire pour démarrer un thread. Coller quelque chose sur le web dans une INTERFACE utilisateur pour fixer ou modifier un contrôle, c'est une chose. C'est un genre complètement différent de processus. Vous avez besoin d'étudier le sujet, écrire votre propre code, et de comprendre exactement comment il fonctionne, sinon vous êtes juste de gaspiller votre temps avec cela.

Un délégué est l' .NET version sécurisée de type pointeur de fonction. Tous les threads besoin d'un point d'entrée pour lancer l'exécution. Par définition, lorsqu'un thread principal est créée, elle s'exécute toujours Main() comme point d'entrée. Tout les threads supplémentaires vous créez aurez besoin d'un définies explicitement point d'entrée - un pointeur vers la fonction de l'endroit où ils devraient commencer l'exécution. Donc threads toujours besoin d'un délégué.

Délégués sont souvent utilisés dans les enfiler pour d'autres fins, trop, surtout pour les rappels. Si vous voulez un thread pour signaler certaines informations telles que l'état d'achèvement, une possibilité est de créer une fonction de rappel qui le thread peut utiliser. À nouveau le fil a besoin d'un pointeur pour être en mesure d'exécuter le rappel de sorte que les délégués sont utilisés pour cela. Contrairement à un point d'entrée de ces options sont facultatives, mais le concept est le même.

La relation entre les threads les délégués et les threads secondaires ne peut pas simplement appeler des méthodes comme la principale application thread, donc un pointeur de fonction est nécessaire, au lieu de délégués et d'agir comme des pointeurs de fonction.

Vous ne voyez pas le délégué et que vous n'avez pas à en créer un, parce que le cadre est fait pour vous, dans le Fil de constructeur. Vous pouvez passer dans la méthode que vous souhaitez utiliser pour démarrer le thread, et le code de la structure crée un délégué qui pointe vers cette méthode pour vous. Si vous souhaitez utiliser un callback, vous devez créer un délégué de vous-même.

Voici le code sans les expressions lambda. SomeClass a quelques de transformation qui prend du temps et est fait sur les threads d'arrière-plan. Pour aider à cela la SomeThreadTask a été créé, et il contient le code processus et tout le thread doit l'exécuter. Un second délégué est utilisé pour un rappel lorsque le thread est terminé.

Code réel serait plus compliqué, et d'une véritable classe ne devriez jamais avoir à savoir comment créer des threads, etc donc, vous auriez du gestionnaire d'objets.

//Create a delegate for our callback function.
public delegate void SomeThreadTaskCompleted(string taskId, bool isError);
public class SomeClass
{
private void DoBackgroundWork()
{
//Create a ThreadTask object.
SomeThreadTask threadTask = new SomeThreadTask();
//Create a task id.  Quick and dirty here to keep it simple.  
//Read about threading and task identifiers to learn 
//various ways people commonly do this for production code.
threadTask.TaskId = "MyTask" + DateTime.Now.Ticks.ToString();
//Set the thread up with a callback function pointer.
threadTask.CompletedCallback = 
new SomeThreadTaskCompleted(SomeThreadTaskCompletedCallback);
//Create a thread.  We only need to specify the entry point function.
//Framework creates the actual delegate for thread with this entry point.
Thread thread = new Thread(threadTask.ExecuteThreadTask);
//Do something with our thread and threadTask object instances just created
//so we could cancel the thread etc.  Can be as simple as stick 'em in a bag
//or may need a complex manager, just depends.
//GO!
thread.Start();
//Go do something else.  When task finishes we will get a callback.
}
///<summary>
///Method that receives callbacks from threads upon completion.
///</summary>
///<param name="taskId"></param>
///<param name="isError"></param>
public void SomeThreadTaskCompletedCallback(string taskId, bool isError)
{
//Do post background work here.
//Cleanup the thread and task object references, etc.
}
}
///<summary>
///ThreadTask defines the work a thread needs to do and also provides any data 
///required along with callback pointers etc.
///Populate a new ThreadTask instance with any data the thread needs 
///then start the thread to execute the task.
///</summary>
internal class SomeThreadTask
{
private string _taskId;
private SomeThreadTaskCompleted _completedCallback;
///<summary>
///Get. Set simple identifier that allows main thread to identify this task.
///</summary>
internal string TaskId
{
get { return _taskId; }
set { _taskId = value; }
}
///<summary>
///Get, Set instance of a delegate used to notify the main thread when done.
///</summary>
internal SomeThreadTaskCompleted CompletedCallback
{
get { return _completedCallback; }
set { _completedCallback = value; }
}
///<summary>
///Thread entry point function.
///</summary>
internal void ExecuteThreadTask()
{
//Often a good idea to tell the main thread if there was an error
bool isError = false;
//Thread begins execution here.
//You would start some kind of long task here 
//such as image processing, file parsing, complex query, etc.
//Thread execution eventually returns to this function when complete.
//Execute callback to tell main thread this task is done.
_completedCallback.Invoke(_taskId, isError);
}
}
}