C# Anonyme Fil avec Lambda Syntaxe

En général je reçois de C#lambda de la syntaxe. Cependant, l'anonyme fil de la syntaxe n'est pas complètement clair pour moi. Quelqu'un peut-il expliquer ce qu'est un thread de création de ce genre est en train de faire? Veuillez être aussi précis que possible, j'aimerais avoir une sorte d'étape-par-étape sur la magie qui fait ce travail.

(new Thread(() => {
        DoLongRunningWork();
        MessageBox.Show("Long Running Work Finished!");
    })).Start();

La partie que je ne comprends pas, c'est la Thread(() => ...

Lorsque j'utilise cette syntaxe, il semble comme je l'ai supprimer beaucoup de la limite d'une traditionnelle ThreadStart tels que les invoquer sur une méthode qui n'a pas de paramètres.

Merci pour votre aide!

il crée un nouvel objet thread en passant d'une méthode anonyme (délégué), et la démarre. C'est tout. La création de méthodes anonymes est essentiellement un moyen de transmettre un bloc de code en tant que délégué paramètre

InformationsquelleAutor jocull | 2011-07-31

c#lambda multithreading

36

() => ... signifie simplement que l'expression lambda ne prend pas de paramètres. Votre exemple est équivalente à la suivante:
```
void worker()
{
    DoLongRunningWork();
    MessageBox.Show("Long Running Work Finished!");
}

//...

new Thread(worker).Start();
```
La { ... } dans le lambda vous permettent d'utiliser plusieurs instructions dans le corps de lambda, où normalement vous auriez du être autorisées seulement une expression.

Ce:
```
() => 1 + 2
```
Est équivalent à:
```
() => { return (1 + 2); }
```
- Cette partie fait sens pour moi, mais je peux aussi faire quelque chose comme ceci: new Thread(() => _Transaction_Finalize_Worker(transId, machine, info, newConfigPath)).Start(); - pourquoi ne puis-je maintenant passer de tous ces paramètres?
- Parce que les expressions lambda peut capturer des variables à partir de leur surface extérieure de la portée. Jetez un oeil à des fermetures: en.wikipedia.org/wiki/Closure_(computer_science)
- fermetures, yo: en.wikipedia.org/wiki/Closure_%28computer_science%29
- Je suppose que c'est la partie la plus déroutante. Je ne comprends pas comment le lambda soudainement donne accès à l'extérieur de la portée des variables. Est-il rien de plus à lui que "c'est juste la façon dont il est"?
- C'est une fonctionnalité qui permet de programmer en plus expressif, et de manière fonctionnelle. Vous n'avez pas à utiliser les lambdas que les fermetures si vous ne le souhaitez pas, mais qu'ils ne viennent à portée de main de temps à autre.
- Donc après recherche sur le PHP exemples de fermetures... je suis essentiellement la création d'un nouveau délégué de la méthode à la volée avec un lamda et chaud-chargement des paramètres que je veux?
- Yep, c'est précisément ce que les lambdas sont - méthodes. Bien sûr, il y a quelques astuces dans le compilateur C# qui vous permet de partager des variables locales à la lambda, mais elles sont seulement en inline méthodes qui sont extraites par le compilateur.
- J'ai essayé de décrire comment les lambdas sont de travail en C# dans ma réponse.
InformationsquelleAutor anonymous coward
10

Qu'il y a des réponses avant de me lancer, je vais écrire sur la façon dont d'autres paramètres dans le lambda.

Bref, cette chose qu'on appelle fermeture. Permet de disséquer votre exemple avec new Thread(() => _Transaction_Finalize_Worker(transId, machine, info, newConfigPath)).Start(); en morceaux.

Pour la fermeture il y a une différence entre la classe des " champs et des variables locales. Ainsi, supposons que transId est champ de la classe (donc accessible par le biais de this.transId) et d'autres sont des variables locales.

Derrière les scènes si lambda utilisé dans une classe, le compilateur crée une classe imbriquée avec le nom ineffable, permet de le nom il X pour des raisons de simplicité, et met toutes les variables locales de là. Aussi il écrit lambda il y, de sorte qu'il devient normal de la méthode. Puis compilateur écrit de votre méthode de sorte qu'il crée X à un certain point et remplace l'accès à machine, info et newConfigPath avec x.machine, x.info et x.newConfigPath respectivement. Aussi X reçoit référence à this, de sorte que la lambda-méthode pourrait accès transId via parentRef.transId.

Bien, il est extrêmement simplifié, mais proche de la réalité.

UPD:
```
class A
{
    private int b;

    private int Call(int m, int n)
    {
        return m + n;
    }

    private void Method()
    {
        int a = 5;
        a += 5;
        Func<int> lambda = () => Call(a, b);
        Console.WriteLine(lambda());
    }

    #region compiler rewrites Method to RewrittenMethod and adds nested class X
    private class X
    {
        private readonly A _parentRef;
        public int a;

        public X(A parentRef)
        {
            _parentRef = parentRef;
        }

        public int Lambda()
        {
            return _parentRef.Call(a, _parentRef.b);
        }
    }

    private void RewrittenMethod()
    {
        X x = new X(this);
        x.a += 5;
        Console.WriteLine(x.Lambda());
    }
    #endregion
}
```
- Merci, je crois que je comprends ce qui se passe maintenant - beaucoup de anonyme de type magique!
InformationsquelleAutor Ivan Danilov
6

C'est de manière anonyme afin de créer un thread en C# qui vient de démarrer le thread (parce que vous êtes à l'aide de la méthode Start();)
Suivant 2 méthodes sont équivalentes. Si vous avez besoin de Thread variable pour faire quelque chose (par exemple bloquer le thread appelant en appelant thread0.join()), puis servez-vous de la 2e.
```
new Thread(() =>
{
    Console.WriteLine("Anonymous Thread job goes here...");
}).Start();

var thread0=  new Thread(() =>
{
    Console.WriteLine("Named Thread job goes here...");
});
thread0.Start();
```
Maintenant la méthode de Fil de la partie. Si vous voyez le Fil de la déclaration, nous avons le suivant (j'ai omis les 3 autres).
```
public Thread(ThreadStart start);
```
Thread prend un délégué en tant que paramètre. Déléguer est une référence à une méthode. Fil prend un paramètre qui est un délégué. ThreadStart est déclarée comme telle.
```
public delegate void ThreadStart();
```
Cela signifie que vous pouvez passer n'importe quel méthode de Thread qui retourne void et cela ne prend pas de paramètres. Donc les exemples suivants sont équivalents.
```
ThreadStart del = new ThreadStart(ThreadMethod);
var thread3 = new Thread(del);
thread3.Start();

ThreadStart del2 = ThreadMethod;
var thread4 = new Thread(del2);
thread4.Start();

var thread5 = new Thread(ThreadMethod);
thread5.Start();

//This must be separate method
public static void ThreadMethod()
{
    Console.WriteLine("ThreadMethod doing important job...");
}
```
Maintenant, nous pensons que ThreadMethod méthode est faire peu de travail, nous pouvons le faire à locale et anonyme. Donc, nous n'avons pas besoin de la ThreadMethod méthode à tous.
```
    new Thread( delegate () 
    {
        Console.WriteLine("Anonymous method Thread job goes here...");
    }).Start();
```
Vous voir après délégué à la dernière accolades est l'équivalent de notre ThreadMethod(). Vous pouvez raccourcir le code précédent en introduisant Lambda déclaration (Voir MSDN). C'est juste que vous utilisez et de voir comment il a été terminé comme suit.
```
new Thread( () =>
{
    Console.WriteLine("Lambda statements for thread goes here...");
}).Start();
```
InformationsquelleAutor RotatingWheel

Vous devez vous connecter pour publier un commentaire.