.NET World

Il .NET Framework è composto da un altissimo numero di classi. Vi siete mai chiesti quante ne conoscete e quante ne avete usate? Non sto dicendo nulla di nuovo se vi dico che questo numero dipende per la maggior parte dal tipo di lavoro che fate, dal tipo di clienti che avete e dall’ambito nel quale siete più o meno costretti a sviluppare i vostri applicativi.

I numeri raccontati in questo post danno una visione di insieme. Grazie a Lorenzo che me l’ha trovato! I tipi definiti nel .NET Framework 1.0 erano ben 3.581; nella versione 2.0 erano il doppio (7419); nell’ultima 3.5 i tipi sono diventati 11.417.

Ma ci sono classi che utilizzate solo se sviluppate solo su Windows Mobile, altre che utilizzate solo se create siti in ASP.Net, altre che usate solo se accedete ai database con ADO.Net, altre ancora che usate solo se lavorate con XML, altre se scrivete applicazioni in più localizzazioni, altre se dovete creare o utilizzare web-services. Potrei probabilmente andare avanti all’infinito.

Ma ci sono altrettante classi che invece sono trasversali rispetto a quello che programmate. D’altronde il namespace System lo usiamo tutti, no? Indipendentemente da quello che facciamo, Linq potrebbe fare al caso nostro. Namespace del framework come System.Security, System.Diagnostics, System.Collection, System.Reflection, System.Threading, System.IO e System.Net sono talmente “generiche” (e fondamentali) che dovremmo comunque esserne a conoscenza, sia che sviluppiamo applicazioni Windows Forms, WPF, portali Web o su mobile. Perciò…fino a che punto possiamo dire…

Ditemi quali classi usate e vi dirò chi siete?

Technorati Tags: .NET Framework Programming

Send to Kindle

Come requisito, leggetevi prima l’articolo su MSDN pubblicato dal nostro amico Giancarlo “Janky” Sudano su Linq to SQL. Se avete voglia e se volete partire rapidamente con questo ORM, potete dare un’occhiata all’ottimo tutorial del mio omonimo Igor: l’avevo letto quando era stato messo on-line, ma l’ho ripreso ieri quando ho voluto ripercorrere i passaggi sul mio piccolo progetto che io chiamo “campo di battaglia” per studiare le nuove tecnologie ed i nuovi framework ai quali sono interessato.

Ieri sera ho mappato il mio domain-model su un database SQL Server 2005 Express Edition. Il domain-model contiene classi come Player, Team, Match, MatchResolver. In passato – chi di voi è attento se lo ricorderà – ho parlato di HockeyPlayer: qui si parla sempre di sport. Non chiedetemi perchè! 🙂

Arrivo al dunque.

La classe System.Data.Linq.DataContext espone un metodo GetTable che ritorna l’istanza di ITable relativa al tipo di oggetto passato in input al metodo stesso. Ecco un piccolo esempio:

1 public void SaveObject(T oggetto)
2 {
3     if (!init) initialize();
4 
5     ITable table = session.GetTable(oggetto.GetType());
6     table.InsertOnSubmit(oggetto);
7     session.SubmitChanges();
8 }

Il metodo SaveObject qui sopra fa parte di una classe del mio Data Access Layer. Prende in input un’istanza di un oggetto che vogliamo salvare su database attraverso Linq to SQL. Il tipo dell’oggetto è espresso tramite T, dal momento che il metodo fa parte di una classe generica, che impone che T derivi da BaseEntity, classe base di tutte le classi del mio domain-model.

Alla riga 5 otteniamo un riferimento alla tabella nella quale deve essere salvato l’oggetto: per farlo facciamo una chiamata a GetTable passandogli il tipo dell’oggetto. L’engine di Linq to SQL ottiene queste informazioni dal files di mappings. Alla riga 6 aggiungiamo l’oggetto con la chiamata ad InsertOnSubmit(), e alla riga 7 rendiamo effettivi i cambiamenti su database. Più facile di così!

Technorati Tags: .NET Framework Linq

Send to Kindle

Questa mattina ho corretto ed uploadato l’ultima versione del VivendoByte WPF Technorati Tags, il plug-in per Windows Live Writer di cui avevo già parlato in passato.

Usandolo avevo scoperto un piccolo bug. Come sapete, potete indicare i tags con cui taggare un post in due modi:

1. o scegliendolo dalla lista di tags scaricata dal servizio WCF di Technorati
2. o scrivendoli a mano nel caso in cui dovete indicare nuovi tags non ancora usati

Se non selezionavate nulla dalla lista ma i tags li scrivavate solo a mano nella TextBox, non potevate mai chiudere la finestra, perchè il controllo che avevo messo sul pulsante Ok si ostinava a dirvi: “Dovete selezionare uno o più tags dalla lista!“. Adesso questa cosa è sistemata.

Poi ho fatto dei miglioramenti in termini di layout della finestra ed altre piccole cosucce. Ho sistemato ad esempio il video del logo VivendoByte che vi “intrattiene” mentre il servizio Web di Technorati fa il suo dovere in background. Adesso il video è un po’ più veloce e mi sembra che trasmetta più azione e dinamismo. Parole grosse.

Il download è disponibile qui in formato ZIP (124Kb) e su CodePlex.

Technorati Tags: windows live writer Plugin wpf technorati

Send to Kindle

Non fraintendete! Quando vengo preso dalla frenesia dello sviluppatore, non sento più i rumori circostanti, in compenso borbotto a bassa voce (dove bassa è relativo), batto veloce sulla tastiera, ma in certi momenti uso anche il mouse. Quando la finestra di Visual Studio si riempie di troppi files aperti, ho sempre la voglia di chiuderli tutti, sfruttando la voce di menù Windows –> Close All Documents.

La voce sotto resetta l’IDE secondo le impostazioni di default. Non è un posto un po’ pericoloso? Se per sbaglio ci cliccate sopra, VS vi chiede la conferma (per fortuna), ma io ho pensato fosse una conferma dovuta al fatto che stava per essere chiuso un file non salvato e quindi ho cliccato YES senza pensarci troppo. Morale: ieri sera a casa mi sono ritrovato l’IDE di Visual Studio così come Microsoft l’ha fatto, cioè nudo e crudo.

Possiamo risolvere facilmente: non usiamo più il mouse per chiudere tutte le finestre, ma usiamo una combinazione di tasti. Andiamo su Tools –> Options. Andiamo sotto Envinronment –> Keyboard. Dalla ListBox etichettata come Show commands containing cerchiamo la voce Window.CloseAllDocuments ed associamo uno shortcut a nostro piacimento.

Io ho messo un bel CTRL + F8 (che mi ricorda il CTRL + F4 che chiude un solo file)!

Technorati Tags: Interface visualstudio ide

Send to Kindle

Riprendo il tema sollevato dal collega di mio fratello, Michele, in un suo recente post. Michele scrive una semplice riga in uno pseudo-SQL che recita così:

GRANT SELECT ON tblCustomer TO user WHEN tblCustomer.City = “Milan”

Cioè, dare ad un utente il permesso di fare una SELECT su una tabella solo quando il valore di una colonna di quella tabella assume un determinato valore. Nell’esempio qui sopra, l’utente “user” può fare una SELECT sulla tabella “tblCustomer” solo quando ricerca all’interno della città “Milan”.

Non so, qualcosa non mi torna. Non discuto sulla capacità di SQL Server 2008 di poter applicare questo tipo di sicurezza – non lo so e per adesso non lo voglio sapere. Quello che metto in discussione è che mi sembra di inserire nel database una logica applicativa che lì non dovrebbe stare.

Prendo la voce di Michele e la amplifico sul mio blog. Voi cosa ne dite?

Technorati Tags: SQL Server sql

Send to Kindle

Giusto ieri sera ho ricevuto la copia di marzo di MSDN Magazine, come al solito con l’indirizzo sbagliato. Secondo me, non bisognerebbe prendersela con le Poste quando consegnano in ritardo: bisognerebbe premiarle quando riescono comunque a consegnarti qualcosa nonostante l’indirizzo sia completamente errato. Vabbè, questa è un’altra storia…

Dicevo, il mio abbonamento scade a Maggio 2008. L’abbonamento annuale costa $.60,00 tondi tondi.

Con il cambio attuale il tutto equivarrebbe ad Euro 38 per 12 numeri all’anno.
Il tutto equivarebbe alla fin fine a Euro 3,16 per ciascun numero.

Direi che ne vale proprio la pena, a patto però di essere interessati agli argomenti trattati sulla rivista.

Technorati Tags: msdn magazine euro dollar

Send to Kindle

Tutti i sabato mattina, quando sono ancora rintronato per il venerdì sera, vedo sempre su Rai Tre la trasmissione TV Talk, che trovo molto interessante perchè diversi personaggi discutono di televisione. Personaggi che la televisione la fanno, la producono, la organizzano e la studiano. Mi sono affezionato al professor Simonelli, a Cinzia Bancone, ed Erica Brenna, al conduttore e così via. TV Talk fa parte del circuito RAI Educational diretta da Giovanni Minoli, il che per me equivale a qualità e competenza. Tra le molte cose di cui si parla particolare attenzione viene posta sui palinsesti televisivi: come mai una certa trasmissione viene messa in onda alle 11 e non alle 12? come mai la conduttrice è Milly Carlucci e non un’altra? come mai il festival di Sanremo viene visto dai 30enni e non dai 60enni? C’è un’analista molto brava, la Erika Brenna di cui sopra che, armata di software dedicato, studia ed analizza gli ascolti delle trasmissioni e trae determinate conclusioni.

Una delle cose più interessanti che saltano fuori è che i canali televisivi RAI e Mediaset predispongono i loro palinsesti televisivi in modo tale da coprire tutte le fasce d’età, tutti i gradi di scolarizzazione (dalla scuola elementare ai laureati), tutte le fasce orarie, ed ottimizzando ovviamente la messa in onda degli spot pubblicitari. Ad esempio, sarebbe assurdo che Italia 1 facesse solo cartoni animati, perchè così facendo verrebbe guardato solo da studenti. Sarebbe assurdo che Rai 3 facesse solo documentari storici, perchè così facendo verrebbe guardato solo da gente interessata a quel tipo di argomenti. Capita a volte che una emittente televisiva metta in onda su due reti differenti due diverse tramissioni che attirano lo stesso tipo di pubblico: concorrenza in casa, praticamente. Le due trasmissioni si sovrappongono, si rubano gli ascoltatori a vicenda, salta fuori che per esempio i 30enni vorrebbero guardare due programmi mentre i 60anni si stanno annoiando, e così via. Ovviamente questa è una situazione da evitare il più possibile, e la gente che sistema i palinsesti fa proprio questo lavoro.

Credo che questa situazione anomala accada in qualche caso anche per i siti Web. Per esempio, mi sapete dire la differenza sostanziale tra FolderShare o SkyDrive??? Ok, ci saranno pure differenze, ma non sarebbe meglio farne uno ma completo? Ambedue permettono di mettere on-line files, chi più chi meno, tutti e due permettono di condividerli con altri, o di mantenerli disponibli in forma privata. Tutti e due sono accessibili tramite un account Windows Live. L’unica vera differenza consiste nel fatto che FolderShare permette di sincronizzare un folder locale sul PC con i folder in rete (con un’utility installata sul PC), mentre l’altro no. Capisco se uno fosse di Google e l’altro di Yahoo, oppure uno di AOL e l’altro di Netscape…ma qui si parla di Microsoft!

Dal punto di vista meramente commerciale, o pubblicitario, secondo me vengono messi in piedi due sistemi analoghi, vicini nel tempo, con lo stesso obiettivo, molto simili fra loro, ma con nomi diversi. Tra l’altro, lo stesso risultato lo possiamo facilmente ottenere con un hosting Sharepoint come WH4L e Groove (di Office 2007), cosa che personalmente faccio da mesi: ma qui si tratta di prodotti a pagamento.

Per dovere di cronaca, ecco i link ai due siti di cui ho parlato:
https://www.foldershare.com/
http://skydrive.live.com

Mah, certe cose non le capisco! Ditemi cosa mi è sfuggito, vi prego, e cancellerò questo post.

Technorati Tags: windows live sharing SkyDrive FolderShare

Send to Kindle

Un’altra modalità con cui è possibile esportare un’immagine da Expression Design è quello di generare un file XAML contenente al suo interno un ResourceDictionary. Lo scopo è quello di avere un file XAML che potete riutilizzare in più progetti. Oppure all’interno dello stesso progetto potete far riferimento alla stessa immagine, perchè questa viene inserita fra le risorse globali definite all’interno della stessa applicazione. Vediamo in pratica come fare.

Esportare un progetto Expression Design in un file XAML
Apriamo Expression Design, poi apriamo il file .design che contiene il nostro progetto. Andiamo sotto il menù File e poi clicchiamo sulla voce Export. Dopo aver scelto la locazione ed il file del file XAML da generare, appare una dialog box che ci permette di impostare alcuni valori:

In questa dialog box, attiviamo l’option button relativa a Resource dictionary. La cosa interessante è che possiamo decidere come deve essere esportato il contenuto del nostro progetto:

1. Document: significa che il ResourceDictionary conterrà un solo oggetto relativo al documento nella sua interessa. Il mio logo VivendoByte di cui vi ho parlato l’altra volta viene esportato in un unico oggetto DrawingBrush con x:Key =”VivendoByteLogo_design”.
2. Layers: se nel progetto avete definito più layers, nel ResourceDictionary vengono inseriti tanti oggetti quanti sono i layers, ciascuno con un sua Key per poterli referenziare singolarmente
3. Objects: nel ResourceDictionary vengono inseriti tanti oggetti quanti ne compaiono nel progetto. Anche in questo caso, ogni oggetto ha una propria Key univoca

Nel mio caso, ho deciso di esportare il tutto come unico Document. Lo XAML in forma abbreviata appare più o meno così:

<?xml version="1.0" encoding="utf-8"?>
<ResourceDictionary
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <DrawingBrush x:Key="VivendoByteLogo_design">
        <DrawingBrush.Drawing>
            <DrawingGroup>
                <DrawingGroup.Children>
                ...
                ...
                ...
                </DrawingGroup.Children>
            </DrawingGroup>
        </DrawingBrush.Drawing>
    </DrawingBrush>
</ResourceDictionary>

All’interno del blocco <DrawingGroup.Children></DrawingGroup.Children> vengono inseriti tutti gli elementi necessari per disegnare in formato vettoriale l’immagine grafica disegnata con Expression Design.

Lo scopo di tutto questo è quello di importare il ResourceDictionary all’interno di un progetto Expression Blend, in modo tale da poter inserire l’immagine – in questo caso il mio logo – nelle Window del progetto. Possiamo farlo senza mettere mano al codice XAML? Certo che sì: questa volta Blend non crasha e fa tutto come si deve. Come? Stiamo per scoprirlo.

Importiamo in un progetto Expression Blend il ResourceDictionary

Apriamo Expression Blend, poi apriamo o creiamo il progetto sul quale vogliamo lavorare. Poi clicchiamo con il destro sul nome del progetto e clicchiamo sulla voce Add Existing Item e andiamo a selezionare il file XAML che abbiamo creato al passaggio precedente. Questa operazione fa essenzialmente due cose fondamentali:

1. aggiunge il file XAML al progetto Blend: banale
2. modifica automaticamente il file App.xaml, aggiungendo fra le risorse disponibili globalmente nell’applicazione il ResourceDictionary appena aggiunto al progetto. Il file App.xaml appare come segue:

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="StudioConIlLibro.App" StartupUri="Window3.xaml">
    <Application.Resources>
        <!-- Resources scoped at the Application level should be defined here. -->
        <ResourceDictionary>
            <ResourceDictionary.MergedDictionaries>
                <ResourceDictionary Source="VivendoByteLogo.xaml"/>
            </ResourceDictionary.MergedDictionaries>
        </ResourceDictionary>
    </Application.Resources>
</Application>

A questo punto, la faccenda è abbastanza semplice. Basta aprire una Window, o crearne una nuova, per vedere fra le risorse diverse cose interessanti. Se espandiamo il nodo relativo al file App.xaml, Blend ci dice che abbiamo definito un collegamento al file VivendoByteLogo.xaml. Se espandiamo quest’ultimo invece, appare la nostra immagine: Blend ci dice qual’è la sua Key, e ci fa vedere l’anteprima dell’immagine. Possiamo regolarne alcune proprietà, come il Tile Mode e lo Stretch.

Per inserire l’immagine su una Window è sufficiente farne un bel drag’n’drop. Dipendentemente dall’oggetto sul quale rilasciate il pulsante, Blend vi chiede a quale proprietà volete associare il DrawingBrush. Questa è davvero una cosa carina, funzionale e intuitiva da usare. Per esempio, se trascinate l’immagine su un semplice Button, potete selezionare Background, BorderBrush, Foreground o OpacityMack. Potete inoltre decidere se creare da zero un nuovo oggetto Rectangle fillato al suo interno con l’immagine vettoriale. Lo XAML generato è banale ed efficiente:

<Rectangle
   HorizontalAlignment="Left" Width="100"
   Fill="{DynamicResource VivendoByteLogo_design}"
   Stroke="#FF000000"/>

Questo è l’esempio di un oggetto Rectangle. Se avessimo deciso di usare l’immagine su un Button la proprietà bindata sarebbe stata ad esempio Background e così via.

Technorati Tags: blend wpf XAML resources

Send to Kindle

Se dovete creare grafica vettoriale complessa potete usare Expression Design, un altro strumento della famiglia Expression. Questo software permette di disegnare grafica vettoriale in 2D: rettangoli, circonferenze, testo, ellissi, disegno a mano libera, etc. etc. Il tutto sfruttando le potenzialità di WPF, quindi effetti grafici come gradienti, drop shadows, emboss, mosaic e chi ne ha più ne metta.

Per esempio, oggi pomeriggio, prima di andare in ospedale, ho ridisegnato il logo VivendoByte che qualche mese avevo creato con Corel Draw 12 proprio con Expression Design. Ecco qual’è il vantaggio: potete esportare l’immagine vettoriale che avete creato in codice XAML, e quindi importabile per esempio in Expression Blend.

Ecco qui sotto uno screensho del logo visto con Kaxaml:

Nella parte superiore si vede il logo, nella parte inferiore il codice XAML corrispondente. L’esportazione da Expression Design è piuttosto semplice: basta andare sul menù File e poi cliccare su Export. Appare una dialog box dove potete settare alcune impostazioni:

Potete decidere se esportare in un Canvas, in un ResourceDictionary oppure in formato Silverlight (che si occupa di eliminare tutti i componenti non supportati, per esempio il BitmapEffect che ho impostato per l’ombra azzurrina che si vede nella scritta “vivendoByte.net” nello screenshot di prima. Mentre giocate con gli option button, date un’occhiata all’anteprima che vedete sulla sinistra, perchè è piuttosto fedele al risultato finale. Dopo aver impostato il tutto, fate click sul pulsante Export ed il gioco è fatto: avete ottenuto uno XAML da importare dove volete voi.

Se siete scrupolosi, date un’occhiata allo XAML con lo strumento che preferite. Io ho usato Kaxaml perchè è veloce, rapido e…non crasha. Vi accorgerete che l’ “intelligenza” applicata da Expression Design è scarsa. Ma non potrebbe essere altrimenti: un software è pur sempre un software. Ma siccome noi siamo umani, possiamo ottimizzare moltissimo lo XAML.

Per esempio, il logo VivendoByte è formato tra le altre cose da 5 semicerchi, tutti colorati con un gradiente che va da un azzurro (#FF75C5F0) al bianco (#FFFFFFFF). Nello XAML il gradiente è espresso con un blocco come questo:

1 <LinearGradientBrush StartPoint="0.5,-0.140754" EndPoint="0.5,1.61357">
2     <LinearGradientBrush.GradientStops>
3         <GradientStop Color="#FF75C5F0" Offset="0"/>
4         <GradientStop Color="#FFFFFFFF" Offset="1"/>
5     </LinearGradientBrush.GradientStops>
6 </LinearGradientBrush>

Queste 6 linee di codice XAML sono ripetute per 5 volte, una per ciascun semicerchio. A mano, possiamo inserire questo LinearGradientBrush in una risorsa del Canvas, dandogli ovviamente un nome tramite x:Key.

1 <Canvas.Resources>
2     <LinearGradientBrush x:Key="Arco" StartPoint="0.5,-0.140754" EndPoint="0.5,1.61357">
3         <LinearGradientBrush.GradientStops>
4             <GradientStop Color="#FF75C5F0" Offset="0"/>
5             <GradientStop Color="#FFFFFFFF" Offset="1"/>
6         </LinearGradientBrush.GradientStops>
7     </LinearGradientBrush>
8 </Canvas.Resources>

A questo punto, troviamo nello XAML la definizione dei 5 semicerchi, fatta con oggetti di tipo Path. La cambiamo da così:

<Path x:Name="Path_17" Width="64.5164" Height="34.749" Canvas.Left="175.463" Canvas.Top="84.1736" Stretch="Fill" StrokeThickness="5" StrokeLineJoin="Round" Stroke="#FFFF7D00" Data="F1 M 177.963,116.423C 177.963,99.9927 191.287,86.6736 207.722,86.6736C 224.157,86.6736 237.48,99.9927 237.48,116.423">
    <Path.Fill>
        <LinearGradientBrush StartPoint="0.5,-0.140754" EndPoint="0.5,1.61357">
            <LinearGradientBrush.GradientStops>
                <GradientStop Color="#FF75C5F0" Offset="0"/>
                <GradientStop Color="#FFFFFFFF" Offset="1"/>
            </LinearGradientBrush.GradientStops>
        </LinearGradientBrush>
    </Path.Fill>
</Path>

a così:

<Path x:Name="Path_17" Fill="{StaticResource Arco}" Width="64.5164" Height="34.749" Canvas.Left="175.463" Canvas.Top="84.1736" Stretch="Fill" StrokeThickness="5" StrokeLineJoin="Round" Stroke="#FFFF7D00" Data="F1 M 177.963,116.423C 177.963,99.9927 191.287,86.6736 207.722,86.6736C 224.157,86.6736 237.48,99.9927 237.48,116.423" />

La proprietà Fill fa riferimento alla risorsa denominata Arco. Il codice è molto più compatto ed efficiente; ma il vero vantaggio è che quel tipo di gradiente è definito una volta sola, all’inizio fra le risorse del Canvas, e quindi se volessimo cambiarlo dovremmo farlo in un punto solo. Lo svantaggio è che se dovessimo riesportare da Expression Design l’immagine vettoriale, dovremmo riottimizzare lo XAML, quindi…fatelo solo quando siete sicuri di aver finito!!!

Technorati Tags: XAML wpf Expression Design

Send to Kindle

Ingredienti:

• .NET Framework 3.0 minimo installato e funzionante
• Expression Blend 2 December Preview
• una Window
• un video supportato da WPF da visualizzare
• un’immagine temporanea (maggiori dettagli dopo)

Cominciamo con il dire che la difficoltà della ricetta è alta, anche solo per il fatto che Blend ha il maledetto vizio di crashare un po’ troppo. Si vede che siamo ancora in CTP con questo prodotto. Ricordatevi di premere CTRL+S ad ogni minima modifica, così potete eventualmente riprendere nel punto in cui vi siete interrotti.

Dunque, l’idea è quella di usare esclusivamente l’IDE di Blend per posizionare sullo schermo un video qualsiasi e di renderizzarlo su un piano 3D, che potete ruotare a piacimento sui tre assi XYZ. Come vedremo fra poco, l’IDE non arriva ancora a fare tutto, perciò ad un certo punto dovremo entrare nello XAML per fare qualche modifica a mano.

Cominciamo con il posizionare su una Window vuota uno StackPanel con Width=Auto, Height=Auto, HorizontalAlignment=Center e VerticalAlignment=Center, Orientation=Vertical. Così facendo, qualsiasi controllo noi andremo ad aggiungere allo StackPanel si posizionerà al centro della Window, ben in vista.

Andiamo nel tab Project, clicchiamo con il destro sul file immagine (non il video!) e selezioniamo Insert.

L’immagine, di qualsiasi cosa si tratti, compare nella artboard di Expression Blend. Nello XAML viene aggiunto un tag Image. Se dovesse essere troppo grande, è sufficiente regolare Width e Height per farcela entrare nella Window. Selezioniamo l’immagine sulla artboard, poi andiamo sul menù Tools e poi clicchiamo su Make Image 3D. Questa operazione fa una cosa importantissima: crea nello XAML una struttura complessa composta principalmente da un oggetto Viewport3D, e al cui interno vengono definiti oggetti come Camera, GeometryModel3D, DiffuseMaterial, AmbientLight, etc. La morale è che viene definito l’aspetto che deve assumere l’immagine sul piano 3D: orientamento sui tre assi, illuminazione della scena, punto di vista, distanza dell’osservatore, ampiezza del campo visivo, etc. etc. Tutte queste informazioni vengono combinate dal runtime di WPF per renderizzare l’immagine, sia quando l’applicazione è in esecuzione, sia quando siamo in design-time dentro Blend. Sta di fatto che possiamo selezionare dalla toolbox lo strumento Camera Orbit per traslare/ruotare/zoomare l’immagine.

Ma siamo arrivati ad un punto cruciale. Noi vogliamo renderizzare un video, e non un’immagine. Qui dobbiamo entrare nello XAML per due motivi:

• non sono riuscito ad usare l’IDE per impostare la proprietà Brush del DiffuseMaterial
• ad un certo punto, credevo di esserci riuscito: dal pannello Object and Timeline, esplodete il path Viewport3D/ModelContainer/Content/Model. Da qui, andate nella finestra delle Proprietà. Potete accedere alla proprietà Material. Sorpresa: appare una finestra incompleta, flottante, nella quale è impossibile lavorare in modo decente.
• Blend crasha
• Blend crasha

Alla fine mi sono arreso: sono andato nello XAML e ho impostato a mano il video invece dell’immagine. Andate nello XAML e cercate questo codice:

<GeometryModel3D.Material>
    <DiffuseMaterial>
        <DiffuseMaterial.Brush>
            <ImageBrush Stretch="Fill" ImageSource="Imagesigor_rapper_small.jpg"/>
        </DiffuseMaterial.Brush>
    </DiffuseMaterial>
</GeometryModel3D.Material>

E’ sufficiente sostituire l’oggetto ImageBrush con un oggetto VisualBrush, che questa volta deve puntare al file video che ci interessa:

<GeometryModel3D.Material>
    <DiffuseMaterial>
        <DiffuseMaterial.Brush>
            <VisualBrush>
                <VisualBrush.Visual>
                    <MediaElement Source="Videos/DotNetMarche02.avi" />
                </VisualBrush.Visual>
            </VisualBrush>
        </DiffuseMaterial.Brush>
    </DiffuseMaterial>
</GeometryModel3D.Material>

Salvate lo XAML, ritornare nella visualizzazione Design e vedrete il primo frame del video che appare nello stesso punto dove prima c’era l’immagine. Se prima avevate utilizzate lo strumento Camera Orbiter per manipolare l’oggetto sul piano 3D, vedrete lo stesso effetto applicato al video.

Se compilare ed eseguite il progetto, vedrete partire il video automaticamente.

Technorati Tags: blend Video wpf XAML

Send to Kindle