Was ist der Unterschied zwischen dem direkten Aufruf eines Delegates mit DynamicInvoke und der Verwendung von DynamicInvokeImpl?

Den docs für beide DynamicInvoke und DynamicInvokeImpl sagen:

Dynamisch aufgerufen (late-bound)
Methode vertreten, die von der aktuellen
delegieren.

Merke ich, dass DynamicInvoke und DynamicInvokeImpl nehmen Sie ein array von Objekten, anstatt eine bestimmte Liste von Argumenten (die die spät gebundene Teil ich vermute). Aber ist das der einzige Unterschied? Und was ist der Unterschied zwischen DynamicInvoke und DynamicInvokeImpl.

InformationsquelleAutor der Frage Jason Baker | 2009-05-31

c#delegates

Den wichtigsten Unterschied zwischen dem Aufruf direkt (die kurzer hand für Invoke(...)) und mit DynamicInvoke ist Leistung, eine um mehr als den Faktor *700 von meiner Maßnahme (unten).

Mit der direkt - /Invoke Ansatz, die Argumente sind bereits validiert, die über die Signatur der Methode, und der code bereits vorhanden ist, gehen diese in der Methode direkt (ich würde sagen, "IL", aber ich scheine zu erinnern, dass die Laufzeitumgebung stellt diese direkt ohne anderen IL). Mit DynamicInvoke es braucht, um zu überprüfen, Sie aus dem array per reflection (d.h. sind Sie alle für dieses Gespräch; Sie brauchen, unboxing, etc.); dies ist langsam (wenn Sie es in einer engen Schleife) und sollte vermieden werden, wo möglich.

Beispiel; die Ergebnisse der ersten (ich erhöhte die LOOP zählen von der vorherigen Bearbeiten, zu geben, einen vernünftigen Vergleich):

Direct: 53ms
Invoke: 53ms
DynamicInvoke (re-use args): 37728ms
DynamicInvoke (per-cal args): 39911ms

Mit code:

static void DoesNothing(int a, string b, float? c) { }
static void Main() {
    Action<int, string, float?> method = DoesNothing;

    int a = 23;
    string b = "abc";
    float? c = null;
    const int LOOP = 5000000;

    Stopwatch watch = Stopwatch.StartNew();
    for (int i = 0; i < LOOP; i++) {
        method(a, b, c);
    }
    watch.Stop();
    Console.WriteLine("Direct: " + watch.ElapsedMilliseconds + "ms");

    watch = Stopwatch.StartNew();
    for (int i = 0; i < LOOP; i++) {
        method.Invoke(a, b, c);
    }
    watch.Stop();
    Console.WriteLine("Invoke: " + watch.ElapsedMilliseconds + "ms");

    object[] args = new object[] { a, b, c };
    watch = Stopwatch.StartNew();
    for (int i = 0; i < LOOP; i++) {
        method.DynamicInvoke(args);
    }
    watch.Stop();
    Console.WriteLine("DynamicInvoke (re-use args): "
         + watch.ElapsedMilliseconds + "ms");

    watch = Stopwatch.StartNew();
    for (int i = 0; i < LOOP; i++) {
        method.DynamicInvoke(a,b,c);
    }
    watch.Stop();
    Console.WriteLine("DynamicInvoke (per-cal args): "
         + watch.ElapsedMilliseconds + "ms");
}

InformationsquelleAutor der Antwort Marc Gravell

Zufällig habe ich gefunden, ein weiterer Unterschied.

Wenn Invoke wirft eine exception kann abgefangen werden, indem die erwartete exception-Typ.
Allerdings DynamicInvoke wirft einen TargetInvokationException. Hier eine kleine demo:

using System;
using System.Collections.Generic;

namespace DynamicInvokeVsInvoke
{
   public class StrategiesProvider
   {
      private readonly Dictionary<StrategyTypes, Action> strategies;

      public StrategiesProvider()
      {
         strategies = new Dictionary<StrategyTypes, Action>
                      {
                         {StrategyTypes.NoWay, () => { throw new NotSupportedException(); }}
                         //more strategies...
                      };
      }

      public void CallStrategyWithDynamicInvoke(StrategyTypes strategyType)
      {
         strategies[strategyType].DynamicInvoke();
      }

      public void CallStrategyWithInvoke(StrategyTypes strategyType)
      {
         strategies[strategyType].Invoke();
      }
   }

   public enum StrategyTypes
   {
      NoWay = 0,
      ThisWay,
      ThatWay
   }
}

Während der zweite test wird grün, die ersten Gesichter ein TargetInvokationException.

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using SharpTestsEx;

namespace DynamicInvokeVsInvoke.Tests
{
   [TestClass]
   public class DynamicInvokeVsInvokeTests
   {
      [TestMethod]
      public void Call_strategy_with_dynamic_invoke_can_be_catched()
      {
         bool catched = false;
         try
         {
            new StrategiesProvider().CallStrategyWithDynamicInvoke(StrategyTypes.NoWay);
         }
         catch(NotSupportedException exc)
         {
            /* Fails because the NotSupportedException is wrapped
             * inside a TargetInvokationException! */
            catched = true;
         }
         catched.Should().Be(true);
      }

      [TestMethod]
      public void Call_strategy_with_invoke_can_be_catched()
      {
         bool catched = false;
         try
         {
            new StrategiesProvider().CallStrategyWithInvoke(StrategyTypes.NoWay);
         }
         catch(NotSupportedException exc)
         {
            catched = true;
         }
         catched.Should().Be(true);
      }
   }
}

InformationsquelleAutor der Antwort Rainer Hilmer

9

Eigentlich gibt es keinen funktionalen Unterschied zwischen den beiden. wenn Sie die pull-up-die Umsetzung in den Reflektor, werden Sie feststellen, dass DynamicInvoke nur Anrufe DynamicInvokeImpl mit den gleichen Argumenten. Keine zusätzliche Validierung abgeschlossen ist, und es ist eine nicht-virtuelle Methode, so gibt es keine chance, sein Verhalten zu ändern, indem eine abgeleitete Klasse. DynamicInvokeImpl ist eine virtuelle Methode, wo alle die eigentliche Arbeit ist getan.

InformationsquelleAutor der Antwort JaredPar

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.