Comment Définir Le Compteur À L'Intérieur De Parallèle.Foreach Et Arrêter Cette Boucle Dans Un Nombre Spécifique

Comment Puis-Je Définir Le Compteur À L'Intérieur De Parallèle.Foreach Et Arrêter Ce Butin Dans Un Certain Nombre?
J'ai posé cette Question parce que le compteur à l'intérieur de Parallèle.ForEach ne fonctionne pas dans une action.
veuillez voir ce petit exemple :

static void Main(string[] args)
{
    int Count_Step = -1;
    string[] lines = new string[] 
    { 
        "0",
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        "10",
        "11",
        "12",
        "13",
        "14",
        "15",
        "16",
        "17",
        "18",
        "19"
    };

    List<string> list_lines = new List<string>(lines);

    ParallelOptions parallelOptions = new ParallelOptions();
    parallelOptions.MaxDegreeOfParallelism = 3;

    Parallel.ForEach(list_lines, parallelOptions, (line, state, index) =>
    {
        if (Count_Step == 10)
            state.Stop();
        Count_Step++;
        Console.WriteLine(index + " : " + line + " : " + Count_Step);
        //Thread.Sleep(5000);
    });

    Console.ReadLine();
}

je veux de 10 lignes en sortie, pas plus!
comment puis-je le faire?

merci d'avance

Par butin, voulez-vous dire en boucle?
désolé, j'ai corrigé 🙂
Voulez-vous traiter seulement les 10 premiers éléments de la liste en parallèle, ou vous voulez seulement de traiter toutes les 10 éléments en parallèle puis arrêter après avoir fait 10?
10 éléments en parallèle puis arrêter après avoir fait 10

OriginalL'auteur SilverLight | 2012-09-25

  1. 11

    Si vous voulez seulement de la sortie 10 lignes ce faire, au lieu de cela,

    static void Main(string[] args)
{
    var lines = new List<string> 
    { 
        "0",
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        ...
    };

    var parallelOptions = new ParallelOptions
        {        
            MaxDegreeOfParallelism = 3
        };

    Parallel.ForEach(lines.Take(10), parallelOptions, (line, index) =>
    {
        Console.WriteLine("{0} : {1}", index, line);
        ////Thread.Sleep(5000);
    });

    Console.ReadLine();
}

    sinon

    static void Main(string[] args)
{
    var lines = new List<string> 
    { 
        "0",
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        ...
    };

    var parallelOptions = new ParallelOptions
        {        
            MaxDegreeOfParallelism = 3
        };

    Parallel.For(0, 9, parallelOptions, i =>
    {
        Console.WriteLine("{0} : {1}", i, lines[i]);
        ////Thread.Sleep(5000);
    });

    Console.ReadLine();
}

    ou même

    static void Main(string[] args)
{
    var lines = new List<string> 
    { 
        "0",
        "1",
        "2",
        "3",
        "4",
        "5",
        "6",
        "7",
        "8",
        "9",
        ...
    };

    Enumerable.Range(0, 10).AsParallel().WithDegreeOfParallelism(3).ForAll(i =>
    {
        Console.WriteLine("{0} : {1}", i, lines[i]);
        ////Thread.Sleep(5000);
    }

    Console.ReadLine();
}

    Si vous voulez vraiment que votre parallèle itérations pour la mise à jour de la valeur en dehors de la boucle, alors vous aurez besoin pour s'assurer que toutes les mises à jour et les lectures de l'évolution de la variable sont thread-safe.

    Si vous êtes incrémenter un nombre entier, vous pourriez faire comme ça.

    var stepCount = 0;

Enumerable.Range(0, 10).AsParallel().WithDegreeOfParallelism(3).ForAll(i =>
    {
        var thisCount = Interlocked.Increment(ref stepCount);
        Console.WriteLine("{0} : {1} : {2}", i, lines[i], thisCount);
        ////Thread.Sleep(5000);
    }

Console.ReadLine();

    Cependant, la sortie de thisCount n'est pas garaunteed être contigus dans la fenêtre de la console, il pourrait y avoir un fil de basculer entre les deux lignes.

    Si vous voulez faire quelque chose de plus sophistiqué, comme l'annulation de la transformation en cours de route, vous devriez jeter un oeil à BlockingCollection.

    on ne peut pas changer ce tableau 🙂 c'est juste un exemple comme je l'ai dit dans mon Q. je le veux pour d'autres situations.
    comment à ce sujet.
    merci pour le modifier. mais je vais obtenir que 9 Nombre à l'intérieur(dans une autre situation) -> ce que je peux faire à ce sujet?
    ou même que
    Je ne comprends pas, que voulez-vous dire par "9", faites-vous référence à Count_Step?

    OriginalL'auteur Jodrell

  2. 4

    Essayer Parallel.For()

    En parallèle.Pour La Méthode

    OriginalL'auteur dbking