Dynamisch type gebruiken

Het dynamic type is een statisch type, maar een object van het type dynamic omzeilt statische typecontrole. In de meeste gevallen werkt het alsof het type objectheeft. De compiler gaat ervan uit dat een element elke dynamic bewerking ondersteunt. Daarom hoeft u niet te bepalen of het object de waarde krijgt van een COM-API, van een dynamische taal zoals IronPython, van het HTML Document Object Model (DOM), van weerspiegeling of ergens anders in het programma. Als de code echter niet geldig is, worden fouten tijdens de runtime weergegeven.

Als de instantiemethode exampleMethod1 in de volgende code bijvoorbeeld slechts één parameter heeft, herkent de compiler dat de eerste aanroep van de methode ec.exampleMethod1(10, 4), niet geldig is omdat deze twee argumenten bevat. De aanroep veroorzaakt een compilerfout. De compiler controleert de tweede aanroep van de methode niet, dynamic_ec.exampleMethod1(10, 4)omdat het type dynamic_ec is dynamic. Daarom wordt er geen compilerfout gerapporteerd. De fout ontsnapt echter niet voor onbepaalde tijd. Deze wordt weergegeven tijdens runtime en veroorzaakt een runtime-uitzondering.

static void Main(string[] args)
{
    ExampleClass ec = new ExampleClass();
    // The following call to exampleMethod1 causes a compiler error
    // if exampleMethod1 has only one parameter. Uncomment the line
    // to see the error.
    //ec.exampleMethod1(10, 4);

    dynamic dynamic_ec = new ExampleClass();
    // The following line is not identified as an error by the
    // compiler, but it causes a run-time exception.
    dynamic_ec.exampleMethod1(10, 4);

    // The following calls also do not cause compiler errors, whether
    // appropriate methods exist or not.
    dynamic_ec.someMethod("some argument", 7, null);
    dynamic_ec.nonexistentMethod();
}

class ExampleClass
{
    public ExampleClass() { }
    public ExampleClass(int v) { }

    public void exampleMethod1(int i) { }

    public void exampleMethod2(string str) { }
}

De rol van de compiler in deze voorbeelden is het samenvoegen van informatie over wat elke instructie voorstelt voor het object of de dynamic expressie. De runtime onderzoekt de opgeslagen informatie en een instructie die ongeldig is, veroorzaakt een runtime-uitzondering.

Het resultaat van de meeste dynamische bewerkingen is zelf dynamic. Als u bijvoorbeeld de muiswijzer op het gebruik van testSum in het volgende voorbeeld plaatst, geeft IntelliSense het type (lokale variabele) dynamische testSom weer.

dynamic d = 1;
var testSum = d + 3;
// Rest the mouse pointer over testSum in the following statement.
System.Console.WriteLine(testSum);

Bewerkingen waarin het resultaat niet dynamic is opgenomen:

• Conversies van dynamic naar een ander type.
• Constructor-aanroepen die argumenten van het type dynamicbevatten.

Het type in testInstance de volgende declaratie is ExampleClassbijvoorbeeld , niet dynamic:

var testInstance = new ExampleClass(d);

Conversies

Conversies tussen dynamische objecten en andere typen zijn eenvoudig. Met conversies kan de ontwikkelaar schakelen tussen dynamisch en niet-dynamisch gedrag.

U kunt een van deze dynamic opties impliciet converteren, zoals wordt weergegeven in de volgende voorbeelden.

dynamic d1 = 7;
dynamic d2 = "a string";
dynamic d3 = System.DateTime.Today;
dynamic d4 = System.Diagnostics.Process.GetProcesses();

Omgekeerd kunt u elke impliciete conversie dynamisch toepassen op elke expressie van het type dynamic.

int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;

Overbelastingsresolutie met argumenten van het type dynamisch

Overbelastingsresolutie treedt op tijdens runtime in plaats van tijdens het compileren als een of meer van de argumenten in een methode-aanroep het type dynamichebben, of als de ontvanger van de methode-aanroep van het type dynamicis. Als in het volgende voorbeeld de enige toegankelijke exampleMethod2 methode een tekenreeksargument gebruikt, veroorzaakt verzenden d1 als het argument geen compilerfout veroorzaakt, maar veroorzaakt dit wel een runtime-uitzondering. Overbelastingsresolutie mislukt tijdens runtime omdat het runtimetype d1 is inten exampleMethod2 een tekenreeks vereist.

// Valid.
ec.exampleMethod2("a string");

// The following statement does not cause a compiler error, even though ec is not
// dynamic. A run-time exception is raised because the run-time type of d1 is int.
ec.exampleMethod2(d1);
// The following statement does cause a compiler error.
//ec.exampleMethod2(7);

Dynamische taalruntime

De DYNAMIC Language Runtime (DLR) biedt de infrastructuur die het dynamic type in C# ondersteunt, en ook de implementatie van dynamische programmeertalen zoals IronPython en IronRuby. Zie Het overzicht van Dynamic Language Runtime voor meer informatie over de DLR.

COM-interoperabiliteit

Veel COM-methoden maken variatie in argumenttypen en retourtype mogelijk door de typen aan te wijzen als object. COM-interoperabiliteit vereist expliciete cast van de waarden om te coördineren met sterk getypte variabelen in C#. Als u compileert met behulp van de optie EmbedInteropTypes (C#-compileropties), kunt u met de introductie van het dynamic type de exemplaren van object COM-handtekeningen behandelen alsof ze van het type dynamicwaren, en zo veel van de cast-conversie te voorkomen. Zie voor meer informatie over het gebruik van het dynamic type met COM-objecten het artikel over het openen van Office-interop-objecten met behulp van C#-functies.

Verwante artikelen

Title	Beschrijving
Dynamische	Beschrijft het gebruik van het dynamic trefwoord.
Overzicht van Dynamic Language Runtime	Biedt een overzicht van de DLR, een runtime-omgeving waarmee een set services voor dynamische talen wordt toegevoegd aan de COMMON Language Runtime (CLR).
Overzicht: Dynamische objecten maken en gebruiken	Bevat stapsgewijze instructies voor het maken van een aangepast dynamisch object en voor het maken van een project dat toegang heeft tot een IronPython bibliotheek.