Alessandro Del Sole's Blog

{ A programming space about Microsoft® .NET® }
posts - 1909, comments - 2047, trackbacks - 352

My Links

News

Your host

This is me! Questo spazio è dedicato a Microsoft® .NET®, di cui sono molto appassionato :-)

Cookie e Privacy

Disabilita cookie ShinyStat

Microsoft MVP

My MVP Profile

Microsoft Certified Professional

Microsoft Specialist

Xamarin Certified Mobile Developer

Il mio libro su VB 2015!

Pre-ordina il mio libro su VB 2015 Pre-ordina il mio libro "Visual Basic 2015 Unleashed". Clicca sulla copertina per informazioni!

Il mio libro su WPF 4.5.1!

Clicca sulla copertina per informazioni! E' uscito il mio libro "Programmare con WPF 4.5.1". Clicca sulla copertina per informazioni!

These postings are provided 'AS IS' for entertainment purposes only with absolutely no warranty expressed or implied and confer no rights.
If you're not an Italian user, please visit my English blog

Le vostre visite

I'm a VB!

Guarda la mia intervista a Seattle

Follow me on Twitter!

Altri spazi

GitHub
I miei progetti open-source su GitHub

Article Categories

Archives

Post Categories

Image Galleries

Privacy Policy

Approfondimento post-Community Tour: interoperabilità coi linguaggi dinamici per VB e C#

Nella mia sessione relativa alle novità di Visual Studio 2010 e dei linguaggi .NET all'evento di lancio di Visual Studio 2010 del 14 maggio scorso a Roma, per motivi di tempo non sono riuscito a illustrare l'ultimo argomento che avevo preparato, ossia l'interoperabilità di VB e C# coi linguaggi dinamici. Questo post, quindi, ha lo scopo di illustrare l'argomento (già trattato in passato con riferimento alla Beta 1 di Dev10 in questo articolo).

Se volete una traccia da seguire, vi ricordo che il materiale (slide e codice) della sessione è scaricabile da qui.

Visual Basic 2010 e C# 4 offrono il supporto al Dynamic Language Runtime, una nuova infrastruttura che consente, mediante late-binding, l'interoperabilità tra linguaggi di programmazione 'statici' come Visual Basic o C# e linguaggi 'dinamici', come IronPython per .NET che espongono, tra l'altro, funzionalità di scripting.

Grazie al DLR, quindi, è possibile fare uso di codice di un linguaggio dinamico all'interno del codice Visual Basic (o C#, ma nelle mie demo uso VB :-)). Facciamo un esempio, prendendo in considerazione l'attuale versione di IronPython per .NET, implementazione del linguaggio Python realizzata da Microsoft e scaricabile dal sito CodePlex, la comunità per progetti open-source. IronPython, oltre ad una serie di documenti esplicativi, è distribuito con diversi file di codice di esempio. Ovviamente in questa sede non ci interessa introdurre IronPython, né imparare a utilizzarlo; piuttosto ci interessa capire come sia possibile utilizzarne il codice per futuri approfondimenti. Dopo aver scaricato e installato IronPython.NET, possiamo predisporre una piccola dimostrazione. Eseguiamo quindi i seguenti passaggi:

  1. creare un nuovo progetto per la Console;
  2. aggiungere un riferimento agli assembly IronPython.dll, IronPython.Modules.dll, Microsoft.Scripting.dll, tutti locati nella cartella di installazione di IronPython.
  3. aggiungere al progetto un file di codice Python da utilizzare nella nostra applicazione. Utilizzando il comando Project|Add existing item, andiamo a reperire il file chiamato First.py all'interno della cartella di installazione di IronPython. Questo file di codice Python definisce alcuni semplicissimi metodi e, come il nome lascia intendere, ha lo scopo di introdurre il linguaggio.
  4. Una volta aggiunto al progetto il file .py, dobbiamo impostarne la proprietà Build Action su Copy Always all'interno della Finestra delle Proprietà.

Fatto questo, almeno da un punto di vista VB, dobbiamo necessariamente impostare Option Strict su Off, poiché, come accennato all'inizio, questo tipo di lavoro si fa sfruttando il late-binding, tecnica non consentita da Option Strict On. Quindi aggiungiamo alcune direttive Imports, che ci permettono di abbreviare il richiamo ad alcune classi:

Imports IronPython
Imports IronPython.Hosting
Imports Microsoft.Scripting.Hosting

Il file First.py espone un metodo chiamato Sum, che restituisce il risultato della somma di due numeri. Quindi ipotizziamo di voler fare uso di questo metodo per mostrare il risultato di un'addizione. In primo luogo, iniziamo con lo scrivere il seguente codice:

  Sub Main()

    'Tramite ScriptRuntime ottiene l'hosting di Python
    Dim py As ScriptRuntime = Python.CreateRuntime

    'late-binding: il metodo UseFile legge il contenuto
    'del file di codice Python
    Dim test As Object = py.UseFile("first.py")

Tramite l'oggetto py di tipo ScriptRuntime possiamo ottenere l'istanza del runtime Python. Py espone un metodo chiamato UseFile, che ci permette di specificare quale file di codice Python vogliamo utilizzare, nel nostro caso quello chiamato first.py. Il risultato della lettura è assegnato all'oggetto test che ci consente di utilizzare i membri definiti nel codice Python. Ad esempio, possiamo ottenere il risultato desiderato in questo modo:

    'invoca il metodo Add definito nel file Python
    'e assegna il risultato
    Dim sum As Object = test.add(2, 4)

    'mostra il risultato convertito da Object a Int32
    Console.WriteLine(CInt(sum))
    Console.ReadLine()

  End Sub

Se avviamo l'applicazione, otterremo il risultato corretto della somma dei numeri 2 e 4. Chiaramente, il Dynamic Language Runtime non funziona solo con IronPython ma anche con altri linguaggi, come ad esempio IronRuby, altra implementazione .NET creata da Microsoft.

Alessandro

Print | posted on lunedì 24 maggio 2010 17:36 | Filed Under [ .NET Framework Visual Basic C# Visual Studio 2010 ]

Powered by:
Powered By Subtext Powered By ASP.NET