Articoli

Un Chatbot per postare su dotnetumbria.org

2008-07-29T23:26:13Z

Ciao a tutti, ho ripreso una idea di Lorenzo Maiorfi, quella di "varare" (cito testualmente)
"una nuova iniziativa a livello di pubblicazione di contenuti che preveda la realizzazione di micro-post che in 4 righe riescano a dare un'idea di quello che gli stessi membri della community fanno nel loro quotidiano professionale".

Dopo un po' di ragionamento su questa allettante iniziativa mi è venuta l'idea di creare un piccolo servizio di pubblicazione dei contenuti ultraveloce.

E cosa c'è di più veloce per raccontare se stessi di una sessione con messanger ?

In moltissimi utiliziamo messanger e aprire una conversazione è veramente questione di un attimo.

Così ho creato un piccolo account dotnetumbria@live.it a cui è agganciato un ChatBot. Il suo scopo è fare da tramite per pubblicare tutto quello che viene scritto nella conversazione su un blog dedicato all'argomento "vita profesionale".

Il blog, battezzato "My dotnet life", è raggiungibile all'url http://dotnetumbria.org/blogs/dotnetlife/default.aspx e conterrà tutte le conversazioni che ognuno di voi vorrà fare con l'account dotnetumbria@live.it.
Più che di conversazioni probabilmente si tratterà di veri e propri monologhi, in quanto lo scopo del chatbot è solo quello di fare da interfaccia per la pubblicazione.

Vediamo come utilizzare il servizio:

Se non lo avete gia fatto, registratevi come utenti nel nostro sito.
Aggiungete il nuovo contatto (dotnetumbria@live.it) alla vostra lista contatti. Verrete automaticamente accettati dal chatbot, senza grosse attese.
Aprite una conversazione e scrivere qualcosa (qualsiasi cosa), il chatbot infatti non si accorge della conversazione fino a quando non inviate un messaggio
Se è la prima volta che vi collegate al contatto, vi verranno richiesti il nome utente e la password che avete scelto per utilizzare dotnetumbria. Queste informazioni vi verranno richieste una sola volta, dopodichè verranno associate al vostro contatto MSN e le successive autenticazioni saranno completamente automatiche.
Se i dati inseriti sono corretti, il Bot vi chiederà di inserire il titolo del post. In caso contrario si torna al punto 4.
Successivamente potrete iniziare a scrivere il vostro post. Non avete limiti di dimensioni, ricordate che tutto quello che scrivete verrà pubblicato con il vostro account dotnetumbria e sarà esattamente come scrivere direttamente un nuovo post dentro il blog. Attualmente non sono supportate immagini ed allegati, quindi non mandateli.
Siccome MSN è limitato nella grandezza di un singolo messaggio, i messaggi che scriverete vennanno concatenati l'un l'altro lato server. Quindi non avrete limiti di dimensioni nell'utilizzare questo servizio. Semplicemente scrivete più messaggi. Verranno pubblicati in un'unico post.
Al termine avete 2 opzioni , pubblicare il post. buttare via tutto.
Scrivendo !save (punto esclamativo compreso) pubblicherete immediatamente tutto quello che avrete scritto nel blog.
Scrivendo !delete tutto quello che avete scritto verrà dimenticato e la sessione di chat annullata.

Spero che la cosa vi piaccia. Se si, ho altri servizi in mente basati su questa tecnica.

Ciao a tutti.

Primi passi con il .NET Microframework

2008-06-25T15:49:31Z

Come accennavo in un mio precedente commento ad un post di Andrea, qualche tempo fa alcuni miei colleghi ed io ci siamo dilettati con alcuni primordiali esperimenti di “programmazione embedded” (le virgolette sono d’obbligo visto il livello davvero elementare dei nostri esperimenti); all’inizio è duro anche solamente scegliere cosa provare: il campo di applicazioni è vasto ma richiede competenze un po’ ad ampio spettro, comunque che vanno al di là delle sole conoscenze relative alla progettazione/realizzazione del software.

Abbiamo acquistato un kit di sviluppo Tahoe, ovvero una scheda equipaggiata con CPU Meridian, dotata di un display LCD, porta seriale, usb e una ridda di pin con passo un decimo di pollice per accedere facilmente alle porte I/O messe a disposizione dalla CPU stessa. Ecco la nostra scheda (noterete che è ancora marcata ‘Embedded Fusion’…)

Il passo successivo per noi è stato quello di informarci sui rudimenti dei protocolli di comunicazione I2C e SPI, supportati dal Meridian, e di procurarci i primi integrati da far interagire con la nostra scheda…

abbiamo pensato ai classici sensori di temperatura e ne abbiamo scelti alcuni che implementano il bus I2C e altri che invece dialogano via SPI e, per farci veramente del male, ce li siamo procurati in versione microscopica (con package SMD tra i più piccoli, al limite della saldabilità a mano!)… per poterli ‘cablare’ in una breadboard di dimensioni umane abbiamo comprato (o in un caso realizzato in casa, con tanto di bromografo e bagni in percloruro ferrico!) piccole Printed Board che ospitano l’integrato e offrono piazzole forate per poter saldare i classici cavetti di collegamento… ed eccovi il risultato nella sua forma migliore!

Cosa stiamo osservando? Alla scheda sono collegati: due sensori di temperatura TMP100 (I2C) e un sensore di temperatura TMP123 (SPI) di Texas Instruments, ma non solo! Abbiamo fatto piccoli esperimenti anche con un RTC DS1678 (I2C) della Maxim e, dulcis in fundo (ma ancora tutto è in stato embrionale), un ADC ADS1000 (I2C) ancora di Texas Instruments.

Al di là del layout confusionario e dei singoli componenti usati quello che abbiamo messo in opera è una semplice comunicaizone con dispositivi esterni con i due protocolli citati; il risultato? Eccovi un termometro con ben tre sensori (e altre cose di contorno)! La temperatura rilevata dai primi due (identici) è quella delle prime due righe, poi abbiamo il clock; alla quarta riga la temperatura rilevata dal sensore SPI (che ha sensibilità maggiore) e in ultima riga un dato analogico (una tensione in particolare) convertito dall’ADC

Applicazioni pratiche? Chiaramente un termostato programmabile con rilevazione della temperatura in più punti, eccetera eccetera…

Ma da un punto di vista prettamente informatico, cosa abbiamo realizzato? Per ogni dispositivo una classe driver che eredita da una opportuna classe fornita dal SDK di Embedded Fusion (una per ogni protocollo che abbiamo usato, intendo), a formare un semplice diagramma di questo tipo:

La routine principale del nostro software ‘prototipale’? A intervalli regolari chiediamo al processore di fare un giro di ‘transazioni’ di scrittura/lettura con i dispositivi esterni che abbiamo inizializzato e scriviamo i risultati sul display:

float temp_1 = Hardware.TMP100_1.Temperature;

float temp_2 = Hardware.TMP100_2.Temperature;

DateTime timestamp = Hardware.DS1678.TimeStamp;

float temp_spi=Hardware.TMP123.Temperature;

float data = Hardware.ADS1000.Data;

Dispatcher.Invoke(new TimeSpan(1000),

    new TimerCallback(delegate(object state) {

        _txt_1.TextContent = string.Concat("#1 : ",string.Concat(temp_1.ToString(), " °C"));

        _txt_2.TextContent = string.Concat("#2 : ", string.Concat(temp_2.ToString(), " °C"));

        _txt_3.TextContent = timestamp.ToString();

        _txt_4.TextContent = string.Concat("SPI : ", string.Concat(temp_spi.ToString(), " °C"));

        _txt_5.TextContent = string.Concat("Data : ", string.Concat(data.ToString(), ""));

}),

    null);

Che ne dite? Approfondiamo? Avete idee o suggerimenti? A presto, allora!

Progetto NHooligans - Parte 1 - Concetti, entità e interfacce del sistema di simulazione

2008-06-07T12:33:00Z

In considerazione della straordinaria risposta al mio post nella sezione "futuri appuntamenti" (intendo straordinariamente scarsa), provo ad addentrarmi un po' più nel concreto del sistema di simulazione che costituirà l'ambiente all'interno del quale interagiranno i vari agenti (denominati "hooligan") comandati dai programmi "contendenti".

Facendo riferimento alla terminologia utilizzata nel framework NSteer, intorno al quale verrà sviluppato il sistema di simulazione, si individuano i seguenti "attori", ciascuno con le proprie peculiarità (o, in altri termini, ciascuno caratterizzato dall'implementazione di una o più delle interfacce definite dal framework:

Un oggetto di tipo "agente" (Agent, in NSteer), descrive un'entità che vive all'interno del "mondo" (World, in NSteer). Un agente ha un "corpo" (Body, in NSteer), un sistema di "visione" (Vision, in NSteer) e un "comportamento" (Behavior, in NSteer).

Il "corpo" di un agente definisce le proprietà cinematiche dell'agente (posizione, velocità e accelerazione).

Un sistema di "visione" definisce la regione in cui un agente può "vedere" gli altri agenti o gli ostacoli presenti, tipicamente, nelle sue vicinanze.

Il "comportamento" di un agente determina, ad ogni passo della simulazione, la forza (in senso vettoriale) cui sarà sottoposto il suo "corpo".

Gli agenti sono confinati all'interno del "mondo".

Il "simulatore" (Simulator, in NSteer) determina, ad ogni passo della simulazione, la situazione cinematica (posizione, velocità e accelerazione) di tutti gli agenti presenti nel sistema.

Il sistema di simulazione implementato in NSteer definisce quattro servizi per gestire gli agenti, il mondo, gli ostacoli e la "prossimità" di un agente nei confronti degli altri rispettivamente mediante i servizi AgentService, WorldService, ObstacleService e NeighborhoodService.

Per quanto concerne la visualizzazione della simulazione NSteer definisce il concetto di Sprite, un oggetto 2D caratterizzato da attributi quali colori, visibilità, forma, ecc. e il concetto di "Scena" (Scene, in NSteer), che astrae gli aspetti legati al rendering della simulazione.

Prima che vi sloghiate la mandibola per gli sbadigli, vi incollo un'immagine relativa ad uno step della simulazione realizzata all'interno del demo che accompagna il framework NSteer.

Nello screenshot è possibile individuare una decina di agenti (i punti contornati dal cerchietto rosa, che rappresenta lo spazio occupato dall'agente) ciascuno dei quali ha un proprio "orientamento" ed un proprio "cono visivo" (rappresentato dai 3 segmenti terminati da pallini che escono dal centro dell'agente). I comportamenti di ciascun agente sono descritti dall'etichetta che compare accanto a ciascun cerchietto rosa. I comportamenti definiti all'interno del framework NSteer sono già parecchi, ma è possibile definirne di nuovi o scrivendoli da zero o utilizzando uno dei comportamenti "contenitore" già definiti in NSteer. I 3 cerchi viola rappresentano degli ostacoli circolari. Nell'immagine gli agenti al centro della finestra hanno attivato il comportamento "Seek" (ossia insegui) nei confronti del pallino verde in alto (comandato dal movimento del cursore del mouse nell'applicazione di esempio). Gli altri hanno attivato invece un comportamento composito caratterizzato dalla somma del comportamento "Confine" (ossia confina, argina) e del comportamento "Avoid" (ossia evita), rispettivamente per rimanere all'interno della regione permessa (rappresentata dal riquadro interno) e per evitare l'ostacolo che hanno accanto.

Anche se nello step di simulazione immortalato da questo screenshot non è evidente (perché in questo screenshot altri comportamenti avevano priorità), gli agenti tendono a rimanere uniti ma a non sovrapporsi grazie ad un altro comportamento: il FlockBehavior (dove flock significa "stormo").Questo comportamento ha una valenza "storica" particolare perché è proprio dalla scomposizione delle regole che guidano il comportamento di uno stormo di uccelli che Reynolds ha tratto lo spunto per il proprio lavoro. Per rendervi conto meglio di quello che Reynolds ha inventato (o forse dovrei dire "scoperto") vi consiglio di dare un'occhiata ai demo allegati, ed in particolare (premento Tab si passa da un demo al successivo) al demo "Boids".

Nel prossimo post inizieremo a dare un'occhiata a qualche snippet di codice, per poi fare chiarezza sui "lotti" di progetto disponibili per l'assegnazione a chi vorrà partecipare attivamente allo sviluppo di NHooligans.

Tutorial WPF & LINQ - Lezione 2 - Accesso al database tramite LINQ

2008-06-06T13:32:00Z

Eccoci qui con la seconda lezione!
In questa lezione vedremo come creare in automatico delle classi di accesso al database sfruttando le potenzialità di LINQ to SQL quindi vedremo come creare una listview che prelevi i dati dalla nostra tabellina e li mostri a video. Tutto questo senza scrivere una sola riga di codice !!

4. Creazione di Classi LINQ to SQL

In Visual Studio, Microsoft mette a disposizione un tipo di file (dbml) che ci consente di creare le classi in modo visuale senza complicarci troppo la vita. Quindi cliccate con il pulsante destro sul progetto nella finestra di esplorazione progetti e seguite il percorso "Add -> New Item ... " e vi apparirà una finestra come questa:
dove selezionate "LINQ to SQL Classes" quindi date un nome al vostro file considerando che tutti i riferimenti poi sfrutteranno questo nome. Io ho messo "MyLinqToSQL.dbml".

Questa operazione aggiunge tutte le dipendenze necessarie per lavorare con LINQ to SQL se controllate sulle risorse infatti dovreste avere tra gli Assembly:

System.Data.LINQ
System.Xml.LINQ

Ora trascinate la vostra tabella "TIPI" dal "Server Explorer" all'area di lavoro (dovreste infatti avere il file MyLinqToSQL.dbml aperto in modalità Design). Se avete fatto tutto bene vi apparirà la vostra tabella nell'area di lavoro. Questa tabella è la rappresentazione grafica della classe "Tipi" creata in automatico da VS.
Ora salvate il file e chiudetelo visto che per il momento non ci serve più. L'area di lavoro torna al design della finestra Window1 del progetto.

5. Creazione della LISTVIEW

Per inserire controlli in una form WPF il mio consiglio è di utilizzare Expression Blend. Aprite Expression Blend (senza chiudere il progetto VS) e caricate il progetto TestWPFLinqToSql. Vi comparirà la vostra window1. Cercate il controllo ListView nella toolbar a sinistra (probabilmente dovrete aprire l'Asset Library cliccando sul pulsante ">>" quindi cercate ListView e fateci Click, verrà aggiunto alla toolbar) quindi fate doppio click su di esso e vedrete che vi si posizionerà in alto a sinistra. impostate i margini a 0,0,0,40 così da lasciare lo spazio per i futuri bottoni.

A questo punto andate nel pannello delle proprietà (sempre di expression studio) e se non vi da problemi di refresh potete scorrerlo fino a trovare "miscellaneous" che è una sezione compattata.
Cliccate su di essa e, sempre se non avete problemi di refresh, potete scorrerla fino a trovare "View" che è anch'essa una sezione compattata, sempre cliccandoci sopra la aprite e scorrete fino a trovare la voce "columns" che invece è una collezione per cui avrete un pulsantino con "..." scritto sopra.
Cliccateci e se tutto va bene dovrebbe comparirvi il "Collection Editor" delle colonne.
Create 1 colonna (l'altra già c'è) poi selezionate la prima e impostate la Proprietà "Header" in "Codice"
Selezionate la seconda e impostate la proprietà "Header" a "Descrizione".
Ora chiudete premendo OK.
Visto che probabilmente avrete problemi di refresh anche qui, vi consiglio di chiudere la finestra di design della Window1 e riaprirla dal pannello "Project".
otterrete una cosa simile a questa:

6. Associare i dati alla ListView

Ora comincia il bello.
Premete F5 e magicamente il programma si avvierà, correggete errori se ce ne sono ma credo che non ve ne siano.
Ora chiudete l'applicazione appena eseguita e selezionate il controllo ListView facendo doppioclick su esso dal pannello "Object and TimeLine" in modo tale che vi si evidenzi in giallo.
A questo punto cliccate con il pulsante destro sul controllo nel form e scegliete la voce "BindItemSourceToData" dal menu contestuale.
Premete sul pulsante "+ CLR" che trovate nella finestra che si è appena aperta e cliccate su "MyLinqToSQLDataContext" che dovreste avere nella lista (io avevo chiamato il file delle classi linq così: MyLinqToSQL.dmbl per cui il mio datacontext si chiama MyLinqToSQLDataContext)
Premete su "OK" e il datacontext verrà aggiunto alle connessioni "Data Sources", cliccateci sopra e vi apparirà nella colonna di destra, l'elenco degli oggetti che implementano l'interfaccia IObservableCollection (e qui non sono proprio sicuro, quindi la butto là così come mi viene e prendetela con beneficio di inventario) tra cui la classe "Tipis (Array):(Table Tipi)"
Selezionatela e premete Finish.
Sembra che non sia cambiato niente ma in realtà abbiamo appena detto che il compilatore XAML deve creare un'istanza di Tipis perché la ListView la deve usare come DataSource ed abbiamo detto alla ListView di usare quell'istanza come DataSource per i suoi DataItem.
passate dalla visualizzazione Design a quella XML, il Codice XAML ora è il seguente:

Ora bisogna dire alle colonne quale valore prendere:
Qui il mio consiglio è di farlo a mano:

Purtroppo Expression Blend non ha intellisense e quello di VS si spegne proprio nel Binding per cui dovete sapere come si chiamano le colonne della tabella, le mie si chiamano TipoCodice e TipoDescrizione.
ora compilate ed eseguite premendo F5. se avete messo dei valori di prova nella tabella dovreste vederli nella listview.
Tutto questo ancora una volta senza scrivere nessuna riga di codice se non per effettuare il Binding alle colonne. spero che questa limitazione venga al piu presto sorpassata (io sto utilizzando VS2008 SP1 e Blend 2.5 March CTP).

Con questo abbiamo chiuso la Lezione 2, arrivederci alla prossima lezione dove vedremo come permettere la modifica dei valori direttamente da listview.
Vi lascio in allegato lo screenshot di quello che è venuto fuori.

Tutorial WPF & LINQ - Lezione 1 - Preparazione dell'ambiente di lavoro

2008-06-06T13:27:00Z

Come promesso eccomi qua per creare un mini-tutorial sulla creazione di una piccola applicazione WPF che legga e scriva dati in una tabella di un database SQL sfruttando LINQ.

1. Creazione del database in SQL EXPRESS

Per prima cosa occorre creare un database, io utilizzo SQL Management Studio Express per gestire i database.
posto la query per la creazione del database così come me la propone SQL Management Studio Express:

USE [master]
GO
/****** Oggetto: Database [MySampleDB] Data script: 05/22/2008 13:36:33 ******/
CREATE DATABASE [MySampleDB] ON PRIMARY
( NAME = N'MySampleDB', FILENAME = N'c:\Programmi\Microsoft SQL Server\MSSQL.1\MSSQL\DATA\MySampleDB.mdf' , SIZE = 2240KB , MAXSIZE = UNLIMITED, FILEGROWTH = 1024KB )
LOG ON
( NAME = N'MySampleDB_log', FILENAME = N'c:\Programmi\Microsoft SQL Server\MSSQL.1\MSSQL\DATA\MySampleDB_log.LDF' , SIZE = 560KB , MAXSIZE = 2048GB , FILEGROWTH = 10%)
GO
EXEC dbo.sp_dbcmptlevel @dbname=N'MySampleDB', @new_cmptlevel=90
GO
IF (1 = FULLTEXTSERVICEPROPERTY('IsFullTextInstalled'))
begin
EXEC [MySampleDB].[dbo].[sp_fulltext_database] @action = 'enable'
end
GO
ALTER DATABASE [MySampleDB] SET ANSI_NULL_DEFAULT OFF
GO
ALTER DATABASE [MySampleDB] SET ANSI_NULLS OFF
GO
ALTER DATABASE [MySampleDB] SET ANSI_PADDING OFF
GO
ALTER DATABASE [MySampleDB] SET ANSI_WARNINGS OFF
GO
ALTER DATABASE [MySampleDB] SET ARITHABORT OFF
GO
ALTER DATABASE [MySampleDB] SET AUTO_CLOSE ON
GO
ALTER DATABASE [MySampleDB] SET AUTO_CREATE_STATISTICS ON
GO
ALTER DATABASE [MySampleDB] SET AUTO_SHRINK OFF
GO
ALTER DATABASE [MySampleDB] SET AUTO_UPDATE_STATISTICS ON
GO
ALTER DATABASE [MySampleDB] SET CURSOR_CLOSE_ON_COMMIT OFF
GO
ALTER DATABASE [MySampleDB] SET CURSOR_DEFAULT GLOBAL
GO
ALTER DATABASE [MySampleDB] SET CONCAT_NULL_YIELDS_NULL OFF
GO
ALTER DATABASE [MySampleDB] SET NUMERIC_ROUNDABORT OFF
GO
ALTER DATABASE [MySampleDB] SET QUOTED_IDENTIFIER OFF
GO
ALTER DATABASE [MySampleDB] SET RECURSIVE_TRIGGERS OFF
GO
ALTER DATABASE [MySampleDB] SET ENABLE_BROKER
GO
ALTER DATABASE [MySampleDB] SET AUTO_UPDATE_STATISTICS_ASYNC OFF
GO
ALTER DATABASE [MySampleDB] SET DATE_CORRELATION_OPTIMIZATION OFF
GO
ALTER DATABASE [MySampleDB] SET TRUSTWORTHY OFF
GO
ALTER DATABASE [MySampleDB] SET ALLOW_SNAPSHOT_ISOLATION OFF
GO
ALTER DATABASE [MySampleDB] SET PARAMETERIZATION SIMPLE
GO
ALTER DATABASE [MySampleDB] SET READ_WRITE
GO
ALTER DATABASE [MySampleDB] SET RECOVERY SIMPLE
GO
ALTER DATABASE [MySampleDB] SET MULTI_USER
GO
ALTER DATABASE [MySampleDB] SET PAGE_VERIFY CHECKSUM
GO
ALTER DATABASE [MySampleDB] SET DB_CHAINING OFF

una volta creato il database è necessario creare la tabella:
anche qui posto il codice così come me lo propone SQLMSE:

USE [MySampleDB]
GO
/****** Oggetto: Table [dbo].[Tipi] Data script: 05/22/2008 13:40:07 ******/
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[Tipi](
[TipoCodice] [bigint] NOT NULL,
[TipoDescrizione] [nvarchar](100) NULL,
CONSTRAINT [PK_Tipi] PRIMARY KEY CLUSTERED
(
[TipoCodice] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

La nostra tabella sarà quindi una tabellina di 2 soli campi: TipoCodice e TipoDescrizione. la tabella si chiama Tipi

2. Creazione del un progetto con VISUAL STUDIO 2008

Apriamo ora Visual Studio 2008 e creiamo un nuovo progetto di tipo "WPF Application" e lo chiamiamo "TestWPFLinqToSql"

3. Creazione di una connessione dati in Visual Studio 2008

Dalla finestra "Server Explorer" premete il pulsante "Connect To Database" (quello con il cilindretto giallo ed il + verde) vi comparirà la finestra "Add Connection" dove andrete a selezionare il server (es. NOMEPC/SQLEXPRESS) dove avete creato il database e quindi impostate, se necessario, le credenziali e selezionate il database MySampleDB quindi date ok e vi comparirà nella finestra "Server Explorer" il vostro collegamento al database.

Ora abbiamo preparato tutto il necessario per poter lavorare. Salvate tutto il progetto e proseguite con la Lezione 2

Come scrivere un articolo

2008-06-05T22:07:02Z

Ecco a voi alcune nozioni tecniche, per chi volesse cimentarsi nella scrittura di un articolo per il nostro portale.

La seziona articoli è un blog e il suo url è http://dotnetumbria.org/blogs/articoli

Una volta aperta la pagina del blog, e dopo avere fatto login, in alto a destra trovate il link "Control Panel".

All'interno del Link è presente il comando "Write a Blog Post", che apre l'editor che vi permette la scrittura direttamente dal WEB del vostro nuovo articolo; ovviamente potete inserire allegati all'articolo e Tag di ricerca.

Se scrivete molti articoli nello stesso giorno potete decidere di pubblicarli un po' alla volta cambiando la data di pubblicazione nel Tab "Publication Settings".

Essendo il nostro un portale tecnico, abbiamo inserito un piccolo plugin che ci permette di formattare il codice in modo agevole.

Tutto il codice che volete formattare va inserito all'interno dei tag [code language=""] [/code], dove language è il linguaggio di programmazione che state utilizzando. Il plugin si occuperà di colorare le keywords e i riferimenti sintattici in modo coerente con il linguaggio scelto. I linguaggi supportati sono i più disparati e vanno dall'XML semplice al VB.Net passando per C# ed altri. Unico consiglio, se state scrivendo XAML utilizzate XML come linguaggio, e in linea generale utilizzate il tag XML per tutto quello che può essere riferito a tale standard.

Se preferite utlizzare uno strumento Offline, un'ottima scelta secondo me è Windows Live Writer.

L'url per la configurazione del blog è sempre la stessa e il login è il vostro account.

Buon lavoro a tutti.

Wpf - Animazioni (2D e 3D) con DoubleAnimation

2008-05-05T14:11:00Z

Sviluppando un progetto, mi sono trovato a dover implementare una animazione. Semplicemente, il mio oggetto 3D alla pressione di una determinata combinazione di tasti deve allontanarsi dal punto di vista dell'utente e quindi scorrere negativamente sull'asse z, ricordiamoci la regola della mano destra:

Per far questo ho creato un oggetto DoubleAnimation che non è altro che un semplice interpolatore. Basta definire pochi valori per avere un'animazione semplice ma funzionale.

[code language="xml"]

DoubleAnimation animazione= new DoubleAnimation();

...

animazione.To = -100; //valore di fine interpolazione
animazione.Duration = new Duration(TimeSpan.Parse("0:0:0.5")); //durata dell'animazione
Oggetto3D.BeginAnimation(TranslateTransform3D.OffsetZProperty, animazione); //applico l'interpolatore alla proprietà dell'oggetto 3D

[/code]

Come vedete, non ho impostato il valore di inizio interpolazione perché, come per l'altro mio post, anche qui l'interpolatore prende in automatico, come punto di partenza, il valore attuale (in questo caso la posizione attuale sull'asse Z).

Fin qui tutto ok. Quando però successivamente, in un altra parte del programma, ho tentato di cambiare ulteriormente la distanza del mio oggetto, questa volta senza animazione

[code language="xml"]

Oggetto3D.OffsetZ = -50;

[/code]

questo mi è risultato impossibile. Mettendo un breakpoint sull'assegnazione, vedevo chiaramente che l'operazione avveniva ma che, apparentemente almeno, era totalmente ignorata e che quindi la traslazione sull'asse Z del mio oggetto restava -100.

Dopo un discreto tempo passato su msdn ho trovato motivo e soluzione al mio problema.

L'interpolatore, anche se arrivato a fine "ciclo" rimane comunque attivo, continuando a impostare a -100 il valore della mia traslazione.

Per ovviare al problema, basta "scollegare" l'oggetto DoubleAnimation dalla proprietà OffsetZProperty

[code language="xml"]

Oggetto3D.BeginAnimation(TranslateTransform3D.OffsetZProperty, null);
Oggetto3D.OffsetZ = -50;

[/code]

impostando come "null" l'interpolatore addetto alla modifica della property.

Spero di essere stato d'aiuto.

Un saluto a tutta la community.

Timeline ed interpolazione con WPF

2008-04-18T16:37:00Z

Come la maggior parte di coloro che per la prima volta si avvicinano a WPF mi sono trovato a gestire le animazioni attraverso le Timeline.

Un animazione gradevole e didatticamente interessante consiste nel far ingrandire un oggetto qualsiasi (button, image, o qualsiasi altro) al passaggio del mouse.

Ottenere quest’effetto è molto semplice, basta andare a modificare i valori dei due moltiplicatori X e Y (scale orizzontale e scale verticale). Di default entrambi i valori sono impostati a 1, che è come dire 100%

Cosa significa questo: che se il nostro button (ad esempio) è alto 10 pixel, con il valore di scale Y a 1, diventa 10 x 1 = 10 pixel quindi dimensione originale. Modificando il moltiplicatore e impostandolo a 2 (200%), è banalmente ovvio che il nostro button diventerà alto 20.

Torniamo a noi. Volendo creare un animazione, che al passaggio del mouse ingrandisca il nostro oggetto raddoppiandone le dimensioni, ci basta agganciarne l’evento OnMouseEnter e, impostando nella timeline un arco di tempo a piacere (diciamo mezzo secondo) e successivamente cambiare i valori, da 1 a 2, dei campi X e Y nel campo scale del LayoutTransform .

Volendo fare l’operazione opposta, e cioè agganciando all’oggetto l’evento OnMouseLeave per far si che all’uscita del mouse, il nostro oggetto torni alle dimensioni originali, ho incontrato un problema. Ho ovviamente creato una nuova timeline, impostato lo scale a 2 del LayoutTransform per indicare, ovviamente, i valori di inizio interpolazione, e poi, a mezzo secondo di distanza nella timeline, ho impostato di nuovo i valori dello scale a 1.

[code language="xml"]

[/code]

Mandando in esecuzione l’applicazione, dopo pochissime prove, ho notato un insolito e alquanto poco gradito comportamento: facendo uscire il mouse dal mio oggetto prima del termine dell’animazione (in pratica scatenando l’evento OnMouseLeave quando il mio oggetto non era ancora completamente ingrandito), questo “scattava” alla dimensione raddoppiata per poi proseguire correttamente con la seconda animazione e quindi tornando fluidamente alle dimensioni originali.

Facendo un paio di prove ho scoperto che la cosa è di una semplicità disarmante ma, soprattutto per chi come me ha avuto già a che fare in precedenza con animazioni, timeline e interpolatori vari, non molto ovvia.

L’errore da me commesso è stato di settare lo scale a 2 per indicare i valori di inizio interpolazione per l’animazione di “restringimento”. Non impostandoli, ma impostando solo i valori di fine interpolazione, WPF fa partire l’interpolazione dai valori attuali dello scale, qualsiasi essi siano.

[code language="xml"]

[/code]

Lanciando la nostra applicazione, possiamo vedere che, l’effetto voluto è gradevole e fluido.

Sperando di avervi risparmiato quei 5 minuti di prove, saluto tutti.

Inserisci il tuo articolo !!

2008-04-11T21:29:43Z

Ogni utente registrato può inserire liberamente i propri articoli nella sezione "Articoli".
Potete scrivere l'articolo direttamente dal sito oppure utilizzare Windows Live Writer indicando il seguente url come url del blog:

http://dotnetumbria.org/blogs/articoli/

Aspettiamo numerosi vostri contenuti.

WPF Invalidate Binding

2008-04-10T14:18:49Z

Il binding di WPF è molto reattivo grazie a tutta la struttura di DependencyObjects e DependencyProperties a cui si appoggia. Per questo motivo lavorando con WPF molto spesso non ci dobbiamo preoccupare di fare un refresh dell'interfaccia utente per visualizzare i dati aggiornati.

Può capitare tuttavia di dover mettere in binding alcune sorgenti dati che non utilizzano DependencyProperties e che nella loro struttura non implementano l'interfaccia INotifyPropertyChanged . In questi rari casi accade che l'interfaccia utente non è aggiornata con i dati perchè non è in grado di capire che i dati sono stati modificati in qualche modo. Dobbiamo essere quindi noi a forzare il refresh.

Vediamo quali strumetni abbiamo a disposizione. Viene sicuramente in nostro aiuto la classe statica BindingOperations, la quale ci permette di interrogare la struttura ad oggetti dell'interfaccia utente e capire se le proprietà degli oggetti stessi sono in binding oppure no.

BindingOperations ci restituisce oggetti di tipo BindingExpression che sono di fatto il collegamento tra il target e la sorgente dati.

Possiamo utilizzare il metodo UpdateTarget per forzare la lettura dei dati ed un refresh dell'interfaccia utente.

Come facciamo tuttavia da codice a utilizzare questo metodo senza vincolare la grafica a delle strutture fisse di binding ?
Mi spiego meglio: Se utilizziamo questo metodo, dobbiamo conoscere esattamente quali sono i campi bindati per poter sollevare il binding e quindi vincoliamo lo sviluppo della parte grafica impedendo la modifica di template e di datatemplate.

Ci viene in aiuto un'altra classe molto importante: VisualTreeHelper.

Questa classe ci permette di navigare all'interno della VisualTree, ovvero all'interno degli oggetti renderizzati nell'interfaccia utente. Con un po' di reflection , e con l'aiuto di BidingOperations possiamo estrarre dalla VisualTree tutte le BindingExpressions ed invocare il metodo UpdateTarget.

Ecco il codice :

[code language="c#"]

private static void InvalidateBinding(DependencyObject objectbase)
{

// Per ogni oggetto all'interno del ramo di visualtree
for (int x = 0; x < VisualTreeHelper.GetChildrenCount(objectbase); x++)
{

// Leggo l'oggetto nodo
DependencyObject obj = VisualTreeHelper.GetChild(ww, x) as DependencyObject;

    // Se è un DependencyObject
    if (obj != null)
    {

      // Cerco tutti i fields di
      foreach (FieldInfo finfo in obj.GetType().GetFields())
      {

        // Se il field trovato è una DependencyProperty allora può essere sottoposta a binding
        if (finfo.FieldType.Equals(typeof(DependencyProperty)))
        {

          // Verifico se è sottoposta a binding
          DependencyProperty dpvalue = (DependencyProperty)finfo.GetValue(obj);
          if (BindingOperations.IsDataBound(obj, dpvalue))
          {

            // Estraggo la BindingExpression
            BindingExpression expr = BindingOperations.GetBindingExpression(obj, dpvalue);

            // Sollevo il metodo di aggiornamento del binding.
            expr.UpdateTarget();
          }

          // Se il contenuto della DependencyProperty è un DependencyObject allora devo controllare anche tutte DP dell'oggetto contenuto nella DP corrente
          DependencyObject subdpobject = obj.GetValue(dpvalue) as DependencyObject;
          if (subdpobject != null)
            if (!(subdpobject is Visual))
            {
              foreach (FieldInfo subfinfo in subdpobject.GetType().GetFields())
              {
                DependencyProperty subdpvalue = (DependencyProperty)subfinfo.GetValue(subdpobject);
                if (BindingOperations.IsDataBound(subdpobject, subdpvalue))
                {
                  BindingExpression subexpr = BindingOperations.GetBindingExpression(subdpobject, subdpvalue);
                  subexpr.UpdateTarget();
                }
              }
            }
        }
      }

      // Rendo la funzione ricorsiva in modo da esplorare tutta la VisualTree
      InvalidateBinding(obj);
    }
}
}

[/code]

ObjectDataProvider e databinding su WPF

2008-02-20T21:54:00Z

Tramite WPF è possibile istanziare in diversi modi un oggetto da utilizzare come sorgente dati per il databinding.
Nel precedente post "Ancora databinding su WPF" si è visto come (attraverso le risorse della classe Window - Window.Resources) è possibile dichiarare un oggetto come risorsa statica, e, grazie al tag x:key, qualsiasi controllo è in grado di referenziarlo come sorgente dati, permettendo all'engine di WPF di istanziare l'oggetto richiamando il suo costruttore base.

In alcuni scenari, nei quali non si vuole perdere l'approccio dichiarativo messo a disposizione da XAML, ma che richiedono comportamenti particolari, come il richiamo di costruttori specializzati o metodi con parametri dell'oggetto, WPF fornice la classe ObjectDataProvider.Questa Classe non fa altro che incapsulare la risorsa statica e fornire gli strumenti per interoperare con essa.

Riprendiamo la configurazione precedente della risorsa statica mySource che referenziava la classe mySource scritta in c#

<Window.Resources>
       <local:mySource x:Key="mySource"/>
</Window.Resources>

Per incapsulare la risorsa basta aggiungere

<Window.Resources>
         <local:mySource x:Key="mySource"/>
         <ObjectDataProvider x:Key="dataProvider"  ObjectType="{x:Type local:mySource}"/>
</Window.Resources>

Dal codice precedente si vede subito che anche l'ObjectDataProvaider è stato definito come risorsa statica, e che può essere referenziato grazie alla sua chiave dataProvider, definita attraverso il tag x:Key.
A questo punto si può effettuare il binding attraverso l'ObjectDataProvider, che si occuperà di istanziare la risorsa mySource che sta incapsulando.
L'esempio del precedente post diventa così

<ListView ItemsSource="{Binding Source={StaticResource dataProvider}}">

Da notare che l'applicazione continua a funzionare come in precedenza.
Fino ad ora non abbiamo visto nulla di interessante, infatti per vedere le potenzialità di questo oggetto dobbiamo fare qualche modifica alla nostra classe sorgente dati, aggiungendo un secondo costruttore che accetta un parametro di tipo int e un metodo che accetta anche'esso un parametro di tipo int.

public class mySource : ObservableCollection<mySourceItem>
{
    public mySource()
    {
    }
    //Nuovo costruttore che accetta un parametro int, rappresentante il numero di item da construire
    public mySource(int param)
    {
       for (int i = 0; i <= param; i++)
       {
          this.Add(new mySourceItem("Customer"+i.ToString(), "Customer"+i.ToString()+" Description"));
       }    
    }
  
    //Metodo che inizializza una nuova classe mySource con un numero di item definito dal paramtro param
    public mySource GetItems(int param)
    {
       mySource _mySourse = new mySource();
       for (int i = 0; i <= param; i++)
       {
          _mySourse.Add(new mySourceItem("Customer" + i.ToString(),
                           "Customer" + i.ToString() + " Description"));
       }
       return _mySourse;
    }
}

Benché non ha molto senso creare un metodo che realizzi una nuova istanza della stessa classe, è stato aggiunto solo per facilitare questo esempio.

Utilizzando la proprietà CostructorParameters dell' ObjectDataProvider che accetta una collezione di oggetti, possiamo stabilire quale costruttore prendere attraverso la firma dei suo parametri.

L'esempio diventa:

<Window.Resources>
        <ObjectDataProvider x:Key="dataProvider" ObjectType="{x:Type local:mySource}">
            <ObjectDataProvider.ConstructorParameters>
                <sys:Int32>4</sys:Int32>
            </ObjectDataProvider.ConstructorParameters>
        </ObjectDataProvider>
</Window.Resources>

Ogni parametro è referenziato con il suo tipo, in questo caso Int32, perciò sul nodo root di Window bisogna aggiungere il namespace dei tipi base del Framework; nota che la chiave sys è puramente arbitraria e può essere cambiata a proprio piacimento.

xmlns:sys="clr-namespace:System;assembly=mscorlib"

Se mandiamo in esecuzione il programma si noterà che il nostro ListView è costituito da quattro Item, proprio perché ha utilizzato il costruttore custom, seguendo la sequenza dei parametri, passandogli il numero 4.

Analogamente l'ObjectDataProvider ci fornisce la possibilità di chiamare un metodo della classe che incapsula al suo interno , utilizzando la proprietà MethodName e passandogli i propri parametri grazie alla proprietà MethodParameters che accetta una collezione di oggetti.
L'esempio precedente diventa

<Window.Resources>
        <ObjectDataProvider x:Key="dataProvider" ObjectType="{x:Type local:mySource}" MethodName="GetItems">
            <ObjectDataProvider.MethodParameters>
               <sys:Int32>4</sys:Int32>
            </ObjectDataProvider.MethodParameters>
        </ObjectDataProvider>
</Window.Resources>

Potete scaricare la soluzione d'esempio realizzata con Visual Studio 2008 :
ODPDemo.zip