Visual C#.it

Gestalt mette Ruby, Python e XAML nel browser

Antonio Cangiano — Thu, 23 Jul 2009 02:19:38 +0000

JavaScript è senza dubbio il linguaggio di programmazione più comune per lo sviluppo client-side di siti web. Grazie a Gestalt, una libreria open source, sarà ora possibile utilizzare anche linguaggi dinamici come Ruby e Python (e persino XAML). Dietro le quinte Gestalt sfrutta il Dynamic Language Runtime (DLR) di Silverlight, IronRuby e IronPython (le implementazioni .NET di Ruby e Python).

E l’innovazione apportata dai MIX Online Labs non è limitata a Windows. La libreria può essere infatti usata anche su sistemi Linux/Mac OS X, grazie all’implementazione open source di Silverlight, chiamata Moonlight.

Per i più curiosi, questo è l’Hello, World! in Ruby:



  
  



 id="say_hello" type="button" value="Say, Hello!" />

E in Python:



  
  



 id="say_hello">Say, Hello!

Non perdetevi anche la lista di esempi per vedere di cosa è capace questa libreria. Personalmente dubito che sostituirà JavaScript per la magigor parte degli sviluppatori, anche solo nel mondo .NET, ma apre certamente delle prospettive interessanti. Voi cosa ne pensate?

Condivi questo articolo:

Microsoft rilascia Silverlight 3

Antonio Cangiano — Tue, 21 Jul 2009 16:33:07 +0000

Dopo due anni dal primo rilascio, Microsoft ha finalmente rilasciato la versione finale di Silverlight 3. Questa edizione include una serie di miglioramenti e novità, sufficienti a far preoccupare Adobe. In particolare spiccano il migliorato supporto per codec audio e video, risoluzioni HD, il 3D e l’accelerazione hardware, e l’abilità di far girare le applicazioni in modo offline, al di fuori del browser, in maniera analoga all’accopiata Adobe Flex/Air.

Per iniziare a studiare l’argomento, ecco alcuni link utili:

Le novità di Silverlight 3.
I QuickStart di Silverlight 3.
Una serie di nuovi video su Silverlight 3.
E per finire, la pagina ufficiale del “getting started“.

Condivi questo articolo:

CsharpRepl: la shell interattiva per C#

Antonio Cangiano — Thu, 11 Sep 2008 15:50:47 +0000

Chi programma con linguaggi tipici del mondo Open Source, come Perl, Python, Ruby o Lisp, è abituato da anni ad utilizzare una shell interattiva per provare espressioni ed istruzioni al volo prima di inserirle all’interno di programmi più corposi. Nel caso di Python, il comando è python, mentre nel caso della versione ufficiale di Ruby è irb. Ad esempio, questa potrebbe essere una sessione in Ruby da parte di un principiante:

C:\>irb
>> my_string = "visualcsharp.it"
=> "visualcsharp.it"
>> my_string[0,12]
=> "visualcsharp"
>>

Questo tipo di shell non fa altro che leggere, valutare le espressioni, stamparne il risultato e poi cominciare da capo. Gli anglofoni direbbero che si tratta del cosiddetto read-eval-print loop (REPL).

C# è sempre stato un linguaggio più statico e rigido rispetto ai linguaggi sopracitati, e la mancanza di una funzione eval vera e propria ha fatto sì che per anni i programmatori C# non potessero avvalersi di uno strumento così utile come la shell interattiva. Gli sviluppatori del progetto Mono, port cross-platform del .NET framework, hanno deciso di cambiare lo status quo nella comunità C# introducendo CsharpRepl, un tool che mancava davvero dalla cassetta degli attrezzi dei dotnettari. Il tutto è possibile grazie ad un’opportuna modifica al compilatore, per fargli eseguire il codice generato invece di salvarlo in un file. Con CsharpRepl, sarà ora possibile eseguire snippet di codice senza dover compilare ed eseguire l’intero progetto:

csharp> using System.IO;
csharp> from f in Directory.GetFiles ("/etc")
      >   let fi = new FileInfo (f)
      >   where fi.LastWriteTime > DateTime.Now-TimeSpan.FromDays(7) select f;
{ "/etc/adjtime", "/etc/asound.state", "/etc/mtab", "/etc/printcap", "/etc/resolv.conf" }
csharp>

La pagina del tool ha maggiori informazioni su come installare e usare il comando csharp (che richiede Mono 2.2).

Condivi questo articolo:

Copia/Incolla in DataGridView

Emanuele Origgi — Sat, 10 May 2008 08:28:55 +0000

Spesso quando si sceglie di usare il controllo DataGridView è perchè non si vuole solo una rappresentazione tabellare dei dati, ma soprattutto perchè si voglione sfruttare funzioni che l’utente medio ritiene tipiche delle tabelle.

Una di queste funzioni è sicuramente il copia/incolla di interi record, funzione che non è presente nella classe DataGridView.

Ma questo non vuol dire che non si possa implementare!

Prima di tutto dobbiamo impostare la proprietà ClipboardCopyMode del DataGridView:

this.dataGridView.ClipboardCopyMode = DataGridViewClipboardCopyMode.EnableWithoutHeaderText;

L’enumerazione DataGridViewClipboardCopyMode contiene quattro valori: con EnableWithoutHeaderText è possibile copiare negli Appunti i valori di testo delle celle selezionate. Il testo dell’intestazione non viene incluso.

Andiamo ora a implementare i metodi Copia e Incolla.
Il metodo Copia è semplicissimo:

private void Copia()
{
    Clipboard.SetDataObject(this.dataGridView.GetClipboardContent());
}

Con questo codice viene copiato nella Clipboard, attraverso il metodo static Clipboard.SetDataObject, i dati che tornano dal metodo GetClipboardContent() della classe DataGridView. Dati che vengono formattati in base al valore della proprietà ClipboardCopyMode.

Purtroppo il metodo Incolla non è così immediato:

        private void Incolla()
        {
            char[] rowSplitter = { '\r', '\n' };
            char[] columnsSplitter = { '\t' };
            string[] campi;
            //Ottengo le informazioni contenute negli appunti
            string appunti = Clipboard.GetText();
            //Divido gli appunti in righe
            string[] righe = appunti.Split(rowSplitter, StringSplitOptions.RemoveEmptyEntries); 

            foreach (string str in righe)
            {
                //Divido la stringa in campi e aggiungo la riga del DataGridView
                campi = str.Split(columnsSplitter);
                if (campi.Length == 2)
                {
                    this.bindingSource.AddNew();
                    DataRowView rowView =
                            (DataRowView)this.bindingSource.Current; 

                    if (campi[3] == String.Empty)
                        rowView[5] = DBNull.Value;
                    else
                        rowView[5] = int.Parse(campi[3]); 

                    if (campi[4] == String.Empty)
                        rowView[4] = DBNull.Value;
                    else
                        rowView[4] = int.Parse(campi[4]);
                }
            }
        }

Il procedimento è però abbastanza semplice: prima di tutto otteniamo i dati presenti nella Clipboard attraverso il metodo statico Clipboard.GetText(). Quindi i dati così ottenuti vengono divisi prima in righe, splittandoli sui valori ‘\r’ ‘\n’, e in seguito vengono splittati in colonne (\t). I dati così ottenuti vengono inseriti nel controllo DataGridView.

A questo punto resta da implementare solo il ContextMenu che conterrà i menu Copia e Incolla con i rispettivi eventi Click che richiamano i metodi Copia e Incolla.

Per fare questo si deve prima aggiungere un ContextMenu al progetto e poi associarlo al controllo DataGridView intercettando l’evento RowContextMenuStripNeeded del DataGridView stesso:

        private void dataGridView_RowContextMenuStripNeeded(object sender, DataGridViewRowContextMenuStripNeededEventArgs e)
        {
            e.ContextMenuStrip = this.contextMenuCopiaIncolla;
        }

Praticamente, ogni volta che si preme col tasto destro sul DataGridView, viene generato l’evento RowContextMenuStripNeeded che imposta la proprietà e.ContextMenuStrip sul contextMenu che contiene i menu Copia e Incolla.

Questo codice è solo un esempio. Il metodo Incolla si può adattare in base alle esigenze: per esempio si può valorizzare la chiave primaria se presente, oppure si può decidere di includere nella ClipBoard anche l’intestazione delle colonne e quindi incollare tutto in Excel.

Condivi questo articolo:

Presentazione di John Lam circa IronRuby e DLR

Antonio Cangiano — Fri, 25 Apr 2008 03:31:32 +0000

IronRuby è un’implementazione, ancora incompleta, di Ruby 1.8 per la piattaforma .NET. Il progetto si basa sul cosiddetto Dynamic Language Runtime (DLR), creato appositamente per agevolare lo sviluppo di linguaggi dinamici come Ruby e Python, nel contesto di .NET.

Durante l’evento ALT.NET Open Spaces in Seattle, John Lam, leader del team di sviluppo di IronRuby, ha aggiornato la comunità circa lo stato del progetto e aggiunto molti dettagli tecnici riguardanti l’architettura del DLR.

Per gli interessati che non hanno avuto modo di partecipare, è finalmente online il video della presentazione (in inglese).

Condivi questo articolo:

101 esempi di LINQ

Antonio Cangiano — Tue, 22 Apr 2008 14:25:50 +0000

LINQ, particolarmente LINQ to Objects, segna la svolta funzionale di C# 3.0 e del framework .NET 3.5. L’utilizzo di LINQ non è obbligatorio per il programmatore .NET, ma il guadagno in termini di espressività la rendono decisamente una scelta raccomandata.

Per coloro che non lo hanno ancora visto, Microsoft ha da tempo pubblicato 101 esempi pratici per l’utilizzo di LINQ. Il sito è quello internazionale, per cui in inglese, ma gli esempi sono sostanzialmente snippet di codice, per cui del tutto comprensibili anche per i lettori meno angolofoni.

Condivi questo articolo:

C# 3.0: Extension Methods

Emanuele Origgi — Wed, 20 Feb 2008 21:13:02 +0000

Gli Extension Methods permettono di aggiungere metodi a tipi già definiti, senza creare un nuovo tipo derivato. Questo vale sia per le classi del Framework sia ovviamente per le classi da noi create e sono una forma molto speciale di metodi statici, che vengono però chiamati come se fossero a tutti gli effetti dei metodi di istanza.

Un esempio potrebbe essere quello di “estendere” la classe String, aggiungendo un nostro metodo ContaVocali.

namespace Extensions
{
    static class StringExtension
    {
        /// 
        /// Conta quante vocali sono presenti.
        ///

C# 3.0: Implicitly typed local variables

Emanuele Origgi — Tue, 12 Feb 2008 20:57:04 +0000

Una delle nuove funzionalità di C# 3.0 sono le Implicitly typed local variables, dove il tipo della variabile viene dedotto dal compilatore in fase di compilazione del codice in IL.
Per usare le variabili implicite si deve usare la parola chiave var:

var  i = 5;
var s = “ciao”;
var numeri = new int[] {1, 2, 3};
var conn = new OleDbConnection();

Nonostante sembri il contrario il codice sopra è fortemente tipizzato, perché, come ho già detto, il tipo viene scelto dal compilatore.
Se infatti in Visual Studio si posiziona il cursore sulla parola var, l’IntelliSense ci indica il tipo effettivo della variabile.
Proprio per questo il tipo della variabile non può “variare”:

var i = 5;
i = “Ciao” //Errore: Impossibile convertire in modo implicito il tipo String in int
var i = null; //Errore

Per poter usare le Implicitly typed local variables si devono seguire delle semplici regole:

Ovviamente, come dice il nome, non possono essere variabili globali ma solo locali;
La dichiarazione deve includere un inizializzatore. Per esempio il seguente codice darebbe errore:
```
var i; //Errore 
```

L’inizializzatore deve essere un’espressione. Non può essere un oggetto

OleDbConnection conn;
OleDbConnection conn2 = new OleDbConnection();
var c = conn; //Errore
var c2 = conn2; //GIUSTO

Le variabili implicite non accettano valori null

L’utilizzo di var diventa comodissimo nei cicli foreach. Per esempio:

int[] numeri = {1,2, 3};
foreach(var n in numeri)
	//fai qualcosa

Un’ultima osservazione: in C# 3.0 questo codice

            int var = 5;
            var k = var;

funziona perfettamente!

Condivi questo articolo:

C# 3.0: Object Initializers

Emanuele Origgi — Wed, 06 Feb 2008 18:21:58 +0000

Gli object initializers permettono di impostare le proprietà pubbliche di una classe con una sintassi molto semplice e veloce.
Supponiamo di avere una classa Cliente con queste proprietà pubbliche(ho utilizzato le automatic properties):

public string Nome  { get; set; }
public string Cognome{ get; set;}
public string CodiceFiscale{ get; set;}

Dobbiamo adesso impostare queste proprietà: in C# 2.0 avremmo fatto così:

Cliente cliente = new Cliente();
cliente.Cognome = "Cognome";
cliente.Nome = "Nome";
cliente.CodiceFiscale = "CodiceFiscale";

Ora con C# 3.0 possiamo utilizzare gli object initializers:

Cliente cliente = new Cliente()
      { Nome = "nome", Cognome = "cognome", CodiceFiscale = "codiceFiscale" };

Come potete vedere le proprietà si impostano mentre si istanzia la classe. Questa sintassi, oltre ad essere più veloce(considerate che c’è anche il supporto dell’IntelliSense), è anche più facile da leggere.

Inoltre, in C# 3.0, gli oggetti che implementano l’interfaccia IEnumerable hanno un metodo pubblico Add che permette di usare i collection initializer. Ecco un esempio con la struttura Point

List Square = new List
{
    new Point { X=0, Y=5 },
    new Point { X=5, Y=5 },
    new Point { X=5, Y=0 },
    new Point { X=0, Y=0 }
};

Gli object initializers, come le automatic properties, sono “zucchero sintattico” che permettono però di scrivere codice meno verboso e quindi più facile da leggere.

Condivi questo articolo:

C# 3.0: Automatic Properties

Emanuele Origgi — Sat, 02 Feb 2008 14:17:29 +0000

Questo è il primo di una serie di articoli dedicati al nuovo C# 3.0.

Iniziamo da un argomento leggero e facile, ma utile in certi contesti.
Il nuovo compilatore di C#, presente in Visual Studio 2008, introduce le Automatic Properties, ovvero una forma abbreviata delle proprietà.

Capita spesso di scrivere classi che contengono molti campi privati con le rispettive proprietà. Per esempio:

public class Cliente
{
   private string nome;
   private string cognome;
   private DateTime dataDiNascita;
   public string Nome
   {
     get { return this.nome; }
     set { this.nome = value; }
   }
   public string Cognome
   {
     get { return this.cognome; }
     set { this.cognome = value; }
   }
   public DateTime DataDiNascita
   {
     get { return this.dataDiNascita; }
     set { this.dataDiNascita = value; }
  }
  //ecc
}

Questo codice è lungo e noioso da scrivere.
Attraverso le Automatic Proprties di C# 3.0 il codice diventa così:

public class Cliente
{
   public string Nome
   {
     get;
     private set; // notate il modificatore private
   }
public string Cognome{ get; set;}
public DateTime DataDiNascita{ get; set;}
//ecc
}

Si evita quindi di dichiarare i campi privati: a crearli ci penserà il compilatore al momento della compilazione in codice IL.
Questo tipo di sintassi ha però dei limiti: non può essere usata quando nei modificatori get e set è presente della logica.

Per esempio in questo caso non si possono usare le Automatic Properties:

public string Password
{
   get { return this.password; } //Questo è solo un esempio
   set
   {
     if (value.Length > 6)
       this.password = value;
   }
}

Condivi questo articolo: