Ich realisiere Parallel.Invoke mit await Task.Run , gibt es Nachteile oder Unterschiede?

Hallo,

     public static async void Start_myMethod1_asyncron()
    {
        await Task.Run(() => {
            myMethod1();
        });
    }
    public static async void Start_myMethod2_asyncron()
    {
        await Task.Run(() => {
            myMethod2();
        });
    }

    public static void Main(string[] args)
    {

        Start_myMethod1_asyncron();
        Start_myMethod2_asyncron();

        //difference?

        Parallel.Invoke(myMethod1, myMethod2); 

    }

Tun Start_myMethod1_asyncron() und Start_myMethod2_asyncron() zusammen das Gleiche wie Parallel.Invoke(myMethod1, myMethod2)?
Kann ich asyncron()-Methoden verwenden, um Parallelität zu realisieren?

Der Unterschied ist, dass Parallel.Invoke auf den Abschluss der Operationen wartet.
Deine Methoden werden hier direkt durchlaufen und übersprungen, da du keinen Task zurück gibst (async void).
Auch wenn ein await ausgeführt wird, wird die eigentliche Methode weiterlaufen.
Welchen Sinn hat dein Konstrukt überhaupt?

Nachtrag:
Schau dir für parallele Verarbeitungen mal die Parallel Klasse und Tasks im allgemeinen mal genauer an.
Je nach Anwendungsfall kannst du diese schon für parallele Verarbeitungen nutzen.
Die Frage wäre aber in welcher Form?
Wenn du z.B. Listen parallel abarbeiten musst, dann nutz die Methoden aus Parallel.For/ForEach
Wenn du einfach stumpf Methoden aufrufen willst, die auch keinen Rückgabewert/Parameter haben, kannst du das mit Parallel.Invoke machen.
Je nachdem was du machst, kannst du auch auf die .NET Api asynchron zugreifen und entsprechend deinen Code optimieren.

T-Virus

Hallo Sebrahi,

Ergänzung / Hinweis:

Parallel.Invoke auf den Abschluss der Operationen wartet.

Und zwar derart dass der aufrufende Thread (z.B. der Main-Thread) blockiert od. für eine Operation der auszuführenden verwendet wird.
Daher ist auf [FAQ] Warum blockiert mein GUI? zu achten.

Würde der Code wie folgt geschrieben sein

public static async Task Start_myMethod1_asyncron()
{
    await Task.Run(() => {
        myMethod1();
    });
}
public static async Task Start_myMethod2_asyncron()
{
    await Task.Run(() => {
        myMethod2();
    });
}

public static async Task Main(string[] args)
{

    await Task.WhenAll(Start_myMethod1_asyncron(), Start_myMethod2_asyncron());

    //difference?

    Parallel.Invoke(myMethod1, myMethod2);

}

so wird zwar per Task.WhenAll auf das Ende der Ausführungen asynchron gewartet (await), aber während dieser Zeit ist der aufrufende Thread (hier: Main-Thread) "frei" und könnte andere Aufgaben erledigten.
Beim Parallel.Invoke ist das wie erwähnt nicht möglich.

Das soll jetzt nicht heißen dass Parallel.Invoke eher schlecht ist, sondern je nach konkreter Aufgabe kann es sogar sehr nützlich sein.

Wenn du einfach stumpf Methoden aufrufen willst, die auch keinen Rückgabewert/Parameter haben, kannst du das mit Parallel.Invoke machen.

Parallel Linq (PLinq) ist eine weitere Option die ganz passend sein kann.

mfG Gü