Follow Me!

Contenuti

Support Me!

dynamic: usi ed abusi

Ho sempre “sponsorizzato” pochissimo (=se non mai) l’utilizzo dei dynamic scrivendo codice in C#. Non mi piacciono. Non e’ un segreto e non faccio fatica ad ammetterlo. Il punto che -come in ogni cosa- tutto si trasforma ed anche l’odio piu’ sfrenato puo’ diventare un sentimento di amore sotto necessita’. Volete sapere cosa e’ successo nello specifico?

dynamic

Prima di mostrare il caso pratico in cui ho abusato dei dynamic voglio riportarvi la loro definizione direttamente da Visual Studio:

dynamic - represents an object whose operations will be resolved at runtime

In soldoni cosa significa? Il dynamic non e’ una novita’ recente. A dirla tutta risale alla versione di C# 4.

Tornando al codice come possiamo usarlo?

1
dynamic pippo = ...

Ora a “pippo” potrete assegnare QUALSIASI valore ed usarlo via codice. Il tutto verra’ risolto a runtime.

caso pratico

La scorsa settimana stavo scrivendo un tool di conversione per passare dei dati da SQL Server a CosmosDB. Siccome il tool -una volta finita l’esportazione- andra’ a morire, non ho voluto “sbattermi” a creare una serie infinita di DTO per mappare i dati.

Ora vediamo l’esempio pratico. Il codice e’ lo stesso usato, salvo i “dettagli” legati al nome di tabelle e campi.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
using (var connection = new SqlConnection(_configuration.SQLServerDB))
{
	connection.Open();

    // TestCase - One
	var items = await connection.QueryAsync<dynamic>("SELECT DISTINCT ItemKey, ItemValue FROM ItemTable");

     // TestCase - Two
	items = await connection.QueryAsync<dynamic>("SELECT FirstName, LastName FROM ItemTable2");

    // TestCase - Three
	items = await connection.QueryAsync<dynamic>("SELECT Email, CellPhone FROM ItemTable3");
}

Quale sara’ la tipologia di items secondo voi? Analizzando il suo vero valore scopriremo quanto segue:

1
IEnumerable<dynamic> items

Ora -poniamoci la domanda- come ottengo i valori presenti all’interno di items?

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
foreach(var item in items)
{

    // TestCase - One
	var itemKey = item.ItemKey;
    var itemValue = item.ItemValue;

    // TestCase - Two
    var itemFirstName = item.FirstName;
    var itemLastName = item.LastName;

    // TestCase - Three
    var itemEmail = item.Email;
    var itemCellPhone = item.CellPhone;
}

ATTENZIONE: Ho creato tre TestCase e nel foreach appena scritto li ho messi uno dopo l’altro. L’ho fatto per comodita’ di scrittura del codice. Tenete conto che per leggere i dati corretti dovrete eseguire il TestCase in maniera corretta (query & foreach)

dynamic: i contro

Vi ricordate quando ho scritto in apertura?

dynamic - represents an object whose operations will be resolved at runtime

Cosa succede se dovessi scrivere una proprieta’ non valida?

1
2
3
4
foreach(var item in items)
{
	var fakeValue = item.BlaBlaBla;
}

Uno dei problemi del dynamic e’ il non ricevere errori di compilazione. Come mai? Tutto verra’ risolto a runtime!

Prima di chiudere vi segnalo un altro difetto per cui usare i dynamic corrisponde al male: il codice diventa LENTO rispetto ad un DTO tipizzato. Si, ho appena detto che l’acqua bollente … scotta! Il fatto che non sempre viene considerato scrivendo codice.