webentwicklung-frage-antwort-db.com.de

Wann sollte man dynamisches Schlüsselwort in c # 4.0 verwenden?

Wann sollte man ein dynamisches Schlüsselwort in c # 4.0 verwenden? ....... Ein gutes Beispiel mit einem dynamischen Schlüsselwort in c # 4.0, das seine Verwendung erklärt .... 

50
Chendur Pandian

Dynamic sollte nur verwendet werden wenn es nicht verwendet wird, ist es schmerzhaft . Wie in MS Office-Bibliotheken. In allen anderen Fällen sollte dies vermieden werden, da die Überprüfung der Kompilierart von Vorteil ist. Im Folgenden wird die gute Situation der Verwendung von Dynamik beschrieben.

  1. Aufrufen der Javascript-Methode von Silverlight.
  2. COM-Interop.
  3. Vielleicht lesen Sie Xml, Json, ohne eigene Klassen zu erstellen. 
35
Amitabh

Wie wäre es damit? Etwas, nach dem ich gesucht habe und habe mich gefragt, warum es so schwer ist, ohne 'Dynamik' auszukommen.

interface ISomeData {}
class SomeActualData : ISomeData {}
class SomeOtherData : ISomeData {}

interface ISomeInterface
{
    void DoSomething(ISomeData data);
}

class SomeImplementation : ISomeInterface
{
    public void DoSomething(ISomeData data)
    {
        dynamic specificData = data;
        HandleThis( specificData );
    }
    private void HandleThis(SomeActualData data)
    { /* ... */ }
    private void HandleThis(SomeOtherData data)
    { /* ... */ }

}

Sie müssen möglicherweise nur nach der Laufzeitausnahme fangen und wie gewünscht vorgehen, wenn Sie keine überladene Methode haben, die den konkreten Typ übernimmt.

Das Äquivalent der Nichtverwendung von dynamic ist:

    public void DoSomething(ISomeData data)
    {
        if(data is SomeActualData)
          HandleThis( (SomeActualData) data);
        else if(data is SomeOtherData)
          HandleThis( (SomeOtherData) data);
        ...
        else
         throw new SomeRuntimeException();
    }
11
user2415376

Wie in hier dynamics beschrieben, kann die Verwendung von schlecht entworfenen externen Bibliotheken einfacher gemacht werden: Microsoft bietet das Beispiel der Microsoft.Office.Interop.Excel Assembly . Und mit dynamic können Sie viel Ärger vermeiden. explizites Gießen bei Verwendung dieser Baugruppe.

Im Gegensatz zu @ user2415376 ist es definitiv keine Möglichkeit, mit Interfaces umzugehen, da Polymorphism bereits seit den ersten Tagen der Sprache implementiert wurde!
Sie können verwenden

  ISomeData specificData = data;

anstatt 

dynamic specificData = data;

Außerdem wird sichergestellt, dass Sie nicht stattdessen einen falschen Typ von Datenobjekt übergeben.

4
Ashkan Sirous

Überprüfe diesen Blogbeitrag der über dynamische Schlüsselwörter in c # spricht. Hier ist der Gist:

Das dynamische Schlüsselwort ist in der Tat mächtig. Es ist unersetzbar, wenn es mit dynamischen Sprachen verwendet wird. Es kann jedoch auch für schwierige Situationen beim Entwerfen von Code verwendet werden, bei dem ein statisch typisiertes Objekt dies nicht tut.

Betrachten Sie die Nachteile:

  1. Es gibt keine Typprüfung während der Kompilierungszeit. Dies bedeutet, dass Sie ein Risiko eingehen, es sei denn, Sie haben zu 100% Vertrauen in Ihre Unit-Tests (Husten).

  2. Das dynamische Schlüsselwort verwendet aufgrund des zusätzlichen Laufzeit-Overheads mehr CPU-Zyklen als Ihr altmodischer statisch typisierter Code. Wenn die Leistung für Ihr Projekt wichtig ist (normalerweise), verwenden Sie keine dynamischen Funktionen.

  3. Häufige Fehler sind die Rückgabe von anonymen Typen, die in das dynamische Schlüsselwort in öffentlichen Methoden eingeschlossen sind. Anonyme Typen sind spezifisch für eine Assembly. Wenn Sie sie in Assembly (über die öffentlichen Methoden) zurückgeben, wird ein Fehler ausgegeben. Auch wenn dies beim einfachen Testen der Fall ist, verfügen Sie jetzt über eine öffentliche Methode, die Sie nur von bestimmten Stellen aus verwenden können .

  4. Es ist ein rutschiger Abhang, unerfahrene Entwickler, die darauf aus sind, etwas Neues zu schreiben, und versuchen, mehr Klassen zu vermeiden (dies ist nicht notwendigerweise auf unerfahrene Personen beschränkt). Sie werden immer mehr Dynamik verwenden, wenn sie es im Code sehen. Normalerweise würde ich Code schreiben Analyseprüfung für dynamisch/in Codeüberprüfung hinzufügen.

3
Sumit Maingi

Es ist definitiv eine schlechte Idee, in allen Fällen, in denen sie verwendet werden kann, Dynamik zu verwenden. Dies ist darauf zurückzuführen, dass Ihre Programme die Vorteile der Überprüfung der Kompilierungszeit verlieren und auch viel langsamer sind.

1
Happy

Ich möchte einen Auszug aus dem Code-Projektbeitrag kopieren, der Folgendes definiert:

Warum dynamisch?

In der statisch typisierten Welt gibt Dynamics Entwicklern eine Menge Seil sich aufhängen. Bei Objekten, deren Typen .__ sein können. Zum Zeitpunkt des Kompilierens bekannt, sollten Sie das dynamische Schlüsselwort überhaupt vermeiden. Kosten. Ich habe vorhin gesagt, dass meine erste Reaktion negativ war. meine Meinung geändert? Um Margret Attwood zu zitieren, ist der Kontext alles. Wann statisch tippen macht dynamisch keinen sinn. Wenn du bist Bei einem unbekannten oder dynamischen Typ ist es häufig notwendig, mit ihm durch Reflexion kommunizieren. Reflektierender Code ist nicht leicht zu __. lesen und hat alle Fallstricke des dynamischen Typs oben. In diesem Kontext macht Dynamik sehr viel Sinn. [Mehr]

Einige der Merkmale des dynamischen Schlüsselworts sind:

  1. Dynamically typed - Dies bedeutet, dass der Typ der deklarierten Variablen vom Compiler zur Laufzeit festgelegt wurde.
  2. Zum Zeitpunkt der Deklaration ist keine Initialisierung erforderlich.

z.B.,

dynamic str; 

str=”I am a string”; //Works fine and compiles

str=2; //Works fine and compiles
  1. Fehler werden zur Laufzeit abgefangen 

  2. Intellisense ist nicht verfügbar, da der Typ und die zugehörigen Methoden und Eigenschaften nur zur Laufzeit bekannt sein können. [ https://www.codeproject.com/Tips/460614/Differenz-zwischen-var-und-dynamik-in-Csharp]

Hier ist ein neuer Fall, in dem die Verwendung von dynamic eine unkomplizierte Lösung war.

Ich hatte etwas Code von VB6 in C # portiert. Dieser portierte Code musste noch über COM-Interop mit anderen Methoden an VB6-Objekten aufgerufen werden.

Die Klassen, die aufgerufen werden mussten, sahen so aus:

class A
{
    void Foo() {...}
}

class B
{
    void Foo() {...}
}

(d. h., so sahen die VB6-Klassen in C # über das COM-Interop aus; speziell der COM-Callable-Wrapper, der automatisch generiert wurde).

Da A und B unabhängig voneinander sind, können Sie nicht untereinander wechseln, und sie haben keine gemeinsame Basisklasse (COM unterstützt nicht, dass AFAIK und VB6 dies sicherlich nicht getan haben. siehe unten). 

Der ursprünglich portierte VB6-Code tat dies:

' Obj must be either an A or a B 
Sub Bar(Obj As Object) 
    Call Obj.Foo()
End Sub

In VB6 können Sie jetzt Dinge als Object übergeben und die Laufzeit wird feststellen, ob diese Objekte die Methode Foo() haben oder nicht. In C # wäre eine wörtliche Übersetzung jedoch:

// Obj must be either an A or a B 
void Bar(object Obj) 
{
    Obj.Foo();
}

Was nicht funktioniert. Es wird nicht kompiliert, da object keine Methode mit dem Namen "Foo" hat und C # als typensicher dies nicht zulässt.

Das einfache "Update" bestand also darin, dynamic wie folgt zu verwenden:

// Obj must be either an A or a B 
void Bar(dynamic Obj) 
{
    Obj.Foo();
}

Dies verschiebt die Typensicherheit bis zur Laufzeit, aber vorausgesetzt, Sie haben es richtig gemacht, funktioniert einwandfrei.

Ich würde das nicht für einen neuen Kodex befürworten, aber in dieser Situation (die ich aus anderen Antworten hier nicht ungewöhnlich finde) war es wertvoll.

Alternativen in Betracht gezogen:

  • Verwenden von Reflektion, um Foo () aufzurufen. Wahrscheinlich würde es funktionieren, aber mehr Aufwand und weniger lesbar.

  • Das Ändern der VB6-Bibliothek stand hier nicht zur Debatte, aber vielleicht gibt es einen Ansatz, A und B in Bezug auf eine gemeinsame Schnittstelle zu definieren, die von VB6 und COM unterstützt wird. Die Verwendung von Dynamik war jedoch viel einfacher.


Hinweis: Dies stellt sich wahrscheinlich als temporäre Lösung heraus. Wenn der verbleibende VB6-Code schließlich portiert wird, kann eine geeignete Klassenstruktur verwendet werden, und die Überprüfung der statischen Kompilierungszeit würde die Verwendung von dynamic ersetzen. Ich gebe zu, dass eine solche hoffnungsvolle Zukunft mich mit diesem Ansatz, der ein gewisses Wartungsrisiko haben könnte, angenehmer machte.

0
DaveInCaz