C# 4.0 introduce un nou tip: dinamic, care este un tip static, dar o instanță de obiect de acest tip poate ocoli procesul de verificare statică a tipurilor. În majoritatea cazurilor, tipul funcționează ca o clasă de obiect. La compilare, o instanță a unei clase dinamice suportă orice operațiune, așa că nu este nevoie să vă faceți griji dacă obiectul este preluat dintr-un API COM, dintr-un limbaj dinamic precum IronPython, din DOM-ul HTML, din reflexie sau din altă parte a programului. Totuși, dacă codul face ceva invalid, eroarea este detectată la rulare.
De exemplu, exemplul de metodă exampleMethod1 din următorul fragment de cod are un singur parametru, iar compilatorul poate identifica că este invalid când apelează ec.exampleMethod1(10,4) la compilare; Aceasta este o eroare de compilare. Al doilea apel dynamic_ec.exampleMethod1(10,4) nu este verificat pentru tipurile statice. Prin urmare, compilatorul nu raportează erori de compilare. Totuși, insecta nu se ascunde pentru totdeauna; Va fi detectat la timp de rulare și va declanșa o excepție la runtime.
static void Main(string[] args){
ExampleClass ec = noua ExampleClass();
dinamic dynamic_ec = noua ExampleClass();
dynamic_ec.exampleMethod1(10, 4);
dynamic_ec.someMethod("un anumit argument", 7, nul);
dynamic_ec.nonexistentMethod();
}
clasă ExempluClasă {
public ExampleClass() { }
public ExampleClass(int v) { }
public void exampleMethod1(int i) { }
public void exampleMethod2(string str) { }
}
Iată un exemplu de folosire dinamică pentru a chema IronPython:
folosind IronPython.Hosting;
folosind Microsoft.scrip{filtering}ting. Găzduire;
Console.WriteLine("Încărcare random.py...");
scrip{filter}tRuntime py = Python.CreateRuntime();
dinamic aleatoriu = py. UseFile("random.py");
Console.WriteLine("random.py încărcat!");
elemente var = Enumerabil. Interval(1, 7). ToArray();
pentru (int s = 0; s < 10000; s++) {
random.shuffle(obiecte);
Console.Write("Sequence {0}: ", s);
foreach (int i în elemente) {
Console.Write("{0} ", i);
}
Console.WriteLine();
}
Pentru obiecte sau expresii cu dinamică de tip, rolul compilatorului este să încapsuleze acțiunile pe care fiecare expresie este așteptată să le efectueze, iar la momentul execuției să verifice informațiile stocate, iar orice instrucțiuni invalide vor declanșa o excepție la runtime.
Tipul de rezultat al majorității operațiilor dinamice este, de asemenea, dinamic. De exemplu, dacă treci cursorul cu mouse-ul peste testSum în exemplul următor, promptul inteligent va afișa un testSum dinamic (variabilă locală).
dinamic d = 1;
var testSum = d + 3;
Trece cursorul peste testSum-ul de mai jos.
System.Console.WriteLine(testSum);
Conversia tipului
Tranziția între instanțe de tip Dynamic și alte tipuri de instanțe este simplă, iar dezvoltatorii pot comuta cu ușurință între comportamente dinamice și non-dinamice. Orice instanță poate fi convertită implicit într-o instanță de tip dinamic, vezi următorul exemplu:
dinamic d1 = 7;
dinamic d2 = "o coardă";
dinamic d3 = System.DateTime.Today;
dinamic d4 = System.Diagnostics.Process.GetProcesses();
În schimb, o conversie implicită poate fi aplicată dinamic oricărei expresii de tip dinamic.
Și invers, orice expresie a dinamicii de tip poate fi convertită implicit în alte tipuri.
int i = d1;
string str = d2;
DateTime dt = d3;
System.Diagnostics.Process[] procs = d4;
Problema suprasarcinii cu parametrii dinamici de tip în metodă
Dacă o metodă este numită "
DLR în timp de execuție dinamic pentru limbaj
Runtime-ul dinamic al limbajului este . NET Framework 4 Beta 1 este un nou set de API-uri care oferă suport pentru tipuri dinamice în C# și implementează, de asemenea, limbaje de programare dinamice precum IronPython și IronRuby.
Interoperabilitatea COM
C# 4.0 include mai multe funcționalități care îmbunătățesc interoperabilitatea cu interfețele tradiționale ale API-ului COM, cum ar fi automatizarea Office. Tipurile dinamice, parametrii denumiți și parametrii opționali fac, de asemenea, parte din îmbunătățire.
Multe metode COM permit ca parametrii și valorile de returnare să fie de tip obiect, astfel încât pentru limbaje puternic tipate precum C#, este necesară multă conversie forțată a tipurilor. Totuși, în C# 4.0, dacă adaugi opțiunea /link la compilare, tipul dinamic are un efect nou: face ca tipul obiectului (tip de parametru sau tip return) din metoda interfeței COM să fie considerat dinamic, evitând astfel conversia mare de tip. De exemplu, următoarea afirmație contrastează acest lucru.
Nu se folosește dinamic.
((Excel.Range)excel. Celule[1, 1]). Value2 = "Nume";
Excel.Range = (Excel.Range)excel. Celule[1, 1];
A fost una dinamică.
Excel. Celule[1, 1]. Valoare = "Nume";
Excel. Interval = excel. Celule[1, 1]; |
Postat pe 07.07.2016 10:23:00
|
|
|
