in

dotNet Umbria

Il primo User Group in Umbria sul mondo .Net

Paolo Possanzini

  • [OT] TS: MS .NET Framework 3.5, ADO .NET Application Development --> Passed

     Anche io mi sto dilettando con gli esami in Beta. E proprio questa sera ho saputo di aver passato il 70-561 : TS: MS .NET Framework 3.5, ADO .NET Application Development

    Geeked

  • Uno snippet per le DependencyProperty su WPF

    Mi capita molto spesso di creare DependencyProperty per i miei oggetti da utilizzare con WPF.
    Nello snippet base devo sostituire continuamente UIPropertyMetadata con FrameworkElementMetadata, quindi ho deciso di farmi uno snippet gia modificato.

    Ve lo allego.
    Potete richiamarlo con propdpf

    Per installarlo è sufficiente copiare il file nella cartella
    C:\Program Files\Microsoft Visual Studio 9.0\VC#\Snippets\1033\NetFX30\

  • WPF - VS 2008 {Community} Launch - Il Codice della demo

    In allegato a questo Post trovate il codice della demo della sessione su WPF utilizzata durante l'evento dell'8 Aprile.


     

  • WPF: Costruiamo un RSS Reader passo 4 (ListView)

    Riprendiamo la nostra serie di articoli per la costruzione dell'RSS Reader in WPF. Questa è la volta della definizione della ListView.

    Iniziamo a creare 2 wrapper che nascondono gli oggetti COM a WPF.
    Incorriamo in questo modo in meno problematiche di Binding.

    Ecco i due Wrapper

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.Feeds.Interop;
    using System.Collections;

    namespace WpfRssReader
    {
      public class myFeed
      {
        private IFeed _currentFeed;

        public string Copyright
        {
          get { return _currentFeed.Copyright; }
        }

        public string Description
        {
          get { return _currentFeed.Description; }
        }

        public string Image
        {
          get { return _currentFeed.Image; }
        }

        public myFeedItem[] Items
        {
          get
          {
            List<myFeedItem> _items = new List<myFeedItem>();
            foreach (IFeedItem item in (IEnumerable)_currentFeed.Items)
            {
              _items.Add(new myFeedItem() { CurrentFeedItem = item });
            }
            return _items.ToArray();
          }
        }

        public DateTime PubDate
        {
          get { return _currentFeed.PubDate; }
        }

        public string Title
        {
          get { return _currentFeed.Title; }
        }

        public string Url
        {
          get { return _currentFeed.Url; }
        }

        public IFeed CurrentFeed
        {
          get { return _currentFeed; }
          set
          {
            _currentFeed = value;
          }
        }

      }
    }

     

     

     

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.Feeds.Interop;

    namespace WpfRssReader
    {
      public class myFeedItem : IFeedItem
      {
        private IFeedItem _currentFeedItem;

        public IFeedItem CurrentFeedItem
        {
          get { return _currentFeedItem; }
          set { _currentFeedItem = value; }
        }

        public string Author
        {
          get { return _currentFeedItem.Author; }
        }

        public string Comments
        {
          get { return _currentFeedItem.Comments; }
        }

        public string Description
        {
          get { return _currentFeedItem.Description; }
        }

        public string DownloadUrl
        {
          get { return _currentFeedItem.DownloadUrl; }
        }

        public object Enclosure
        {
          get { return _currentFeedItem.Enclosure; }
        }

        public string Guid
        {
          get { return _currentFeedItem.Guid; }
        }

        public bool IsRead
        {
          get
          {
            return _currentFeedItem.IsRead;
          }
          set
          {
            _currentFeedItem.IsRead = value;
          }
        }

        public DateTime LastDownloadTime
        {
          get { return _currentFeedItem.LastDownloadTime; }
        }

        public string Link
        {
          get { return _currentFeedItem.Link; }
        }

        public int LocalId
        {
          get { return _currentFeedItem.LocalId; }
        }

        public DateTime Modified
        {
          get { return _currentFeedItem.Modified; }
        }

        public object Parent
        {
          get { return _currentFeedItem.Parent; }
        }

        public DateTime PubDate
        {
          get { return _currentFeedItem.PubDate; }
        }

        public string Title
        {
          get { return _currentFeedItem.Title; }
        }


        public void Delete()
        {
          _currentFeedItem.Delete();
        }

        public string Xml(FEEDS_XML_INCLUDE_FLAGS includeFlags)
        {
          return _currentFeedItem.Xml(includeFlags);
        }


      }
    }

     

     

    Una volta preparate le classi dobbiamo apportare una piccolissima correzione al codice che inserisce il feed all'interno del TAG degli oggetti della TreeView in modo da utilizzare le nuove classi al posto degli oggetti COM che ci restituisce il FeedFolder.

     

    [code language="c#"]

     

    foreach (IFeed feed in ((IFeedsEnum)feedfolder.Feeds))
      {
        TreeViewItem tvi = new TreeViewItem()
        {
          Header = feed.Name,
          Tag = new myFeed() { CurrentFeed = feed }                                        // <<<-------- Riga modificata.
        };

        // Esegue il download asincrono degli items presenti nel feed
        ThreadPool.QueueUserWorkItem(delegate

     

    [/code]

     

    A questo punto facciamo una piccola modifica anche allo xaml ed inseriamo il DataTemplate per la visualizzazione dei feed.

     

    [code language="XML"]

     

    <ListView Width="Auto" Height="Auto" BorderThickness="0,0,0,0"
              ItemsSource="{Binding Path=SelectedItem.Tag.Items, ElementName=tvFeedsFolders, Mode=OneWay}" IsSynchronizedWithCurrentItem="True">    
        <ListView.ItemTemplate>
            <DataTemplate>
                <Grid
                    Width="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type ListView}}, Path=Width}">
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="1*" />
                    </Grid.ColumnDefinitions>
                    <Grid.RowDefinitions>
                        <RowDefinition Height="3*" />
                        <RowDefinition Height="1*" />
                    </Grid.RowDefinitions>
                    <Rectangle Margin="0" Grid.RowSpan="2"  RadiusX="3" RadiusY="3" />
                    <TextBlock Text="{Binding Path=Title}"
                               FontFamily="Calibri"
                               FontSize="16"
                               FontWeight="Bold"
                               Grid.Column="0" Grid.Row="0"/>
                    <WrapPanel Grid.Column="0" Grid.Row="1">
                        <TextBlock Text="{Binding Path=PubDate}" FontStyle="Italic" />
                        <TextBlock Text="  " />
                        <TextBlock Text="{Binding Path=Author}" FontWeight="Bold"/>
                    </WrapPanel>
                </Grid>
            </DataTemplate>
        </ListView.ItemTemplate>
    </ListView>

     

    [/code]

     

    Aggiungiamo in fine un elemento Frame che ci permetterà di visualizzazre il contenuto HTML dei posts.

    [code language="XML"]

    <Border
        DataContext="{Binding Path=SelectedItem, ElementName=lvDetails}"
        Margin="3,3,0,0" Grid.Column="1" Grid.Row="2" BorderBrush="#FF222222" BorderThickness="1,1,1,1" CornerRadius="4,4,4,4" Padding="4,4,4,4">
        <Frame Source="{Binding Path=Link}" NavigationUIVisibility="Hidden"></Frame>
    </Border>

    [/code]

    In allegato a questo post trovate il progetto completo con le parti sviluppate fino a questo punto.

    Nei post futuri vedremo compe personalizzare il layout di quest'applicazione con Blend e come applicare alcuni Effetti che WPF ci permette di realizzare.
    Buon divertimento.

  • WPF: Costruiamo un RSS Reader passo 3 (TreeView)

    Inseriamo la TreeView che conterrà la struttura ad albero dei feed sottoscritti.

    [code language="XML"]

    <Window
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:rssreader ="clr-namespace:WpfRssReader"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2006" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d"
        x:Class="WpfRssReader.MainForm"
        Title="Heros RSS Reader" Height="600" Width="800">

        <Grid Width="Auto" Height="Auto">
            <Grid.RowDefinitions>
                <RowDefinition Height="55"/>
                <RowDefinition Height="*"/>
            </Grid.RowDefinitions>

            <Grid Grid.Row="1" Grid.RowSpan="1">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition/>
                    <ColumnDefinition Width="3*"/>
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition Height="96"/>
                    <RowDefinition Height="0.3*"/>
                    <RowDefinition Height="0.6*"/>
                </Grid.RowDefinitions>

                <!-- Inseriamo la TreeView che conterrà i Feeds Sottoscritti -->
                <Border Grid.Row="1" Grid.RowSpan="2" BorderBrush="#FF000000" BorderThickness="1,1,1,1" CornerRadius="4,4,4,4" Padding="4,4,4,4">
                    <TreeView Width="Auto" Height="Auto" BorderThickness="0,0,0,0" Name="tvFeedsFolders" />
                </Border>

            </Grid>
            <Rectangle Fill="#FF000000" Stroke="#FF000000" StrokeThickness="0" RadiusX="0" RadiusY="0" HorizontalAlignment="Stretch" Margin="0,0,0,0" Width="Auto"/>
            <TextBlock Margin="24,8,16,8" FontFamily="Segoe UI" FontSize="24" Foreground="#FFD5D5D5" Text="Heros {Community} RSS Reader" TextWrapping="Wrap"/>
        </Grid>
    </Window>

    [/code]

    Inseriamo un oggetto di ObjectDataProvider per preparare il Binding.
    Utilizziamo il metodo GetFeedSubTree dell'oggetto di tipo FeedHelper per popolare la TreeView

    [code language="XML"]

    <Window.Resources>
        <ObjectDataProvider x:Key="FeedTreeDS" ObjectType="{x:Type rssreader:FeedHelper}" MethodName="GetFeedSubTree" />
    </Window.Resources>

    [/code]

    A questo punto andiamo ad inserire il binding all'interno dell'oggetto TreeView

    [code language="XML"]

    <TreeView
                        ItemsSource="{Binding Source={StaticResource FeedTreeDS}}"
                        Width="Auto"
                        Height="Auto"
                        BorderThickness="0,0,0,0" Name="tvFeedsFolders" />

    [/code]

    Inseriamo subito anche un'altro Grid che con i controlli necessari a sottoscrivere i feeds, per adesso inseriamo solo due textbox, una per il nome che vogliamo dare al feed ed una per l'uri
    Posizioniamo questo nuovo Grid nella prima cella in alto a sinistra.

    [code language="XML"]

    <Grid Margin="0,0,0,0">
            <Rectangle Fill="#FFFFFFFF" Stroke="#FF000000" RadiusX="4" RadiusY="4" Margin="0,0,0,0"/>
            <TextBox Text="&lt;url&gt;" TextWrapping="Wrap" Margin="8,36,8,0" VerticalAlignment="Top" Name="txtUrl" />
            <TextBox Height="24" Text="&lt;nome&gt;" TextWrapping="Wrap" Margin="8,8,8,0" VerticalAlignment="Top" Name="txtNome" />
            <Button d:LayoutOverrides="Height" x:Name="btnSubscribe" Height="28" Content="Sottoscrivi" Click="btnSubscribe_Click" HorizontalAlignment="Right" Margin="0,0,8,8" VerticalAlignment="Bottom" Width="76"/>
        </Grid>

    [/code]

    Scriviamo il codice necessario a gestire l'evento Click del bottone che abbiamo inserito.
    Il metodo dovrà controllare qual'è il folder selezionato nella Treeview ed inserire la sottoscrizione all'interno di quel folder.
    Poi dovrà invocare il metodo FeedHelper.SubscribeFeed

    [code language="C#"]

    private void btnSubscribe_Click(object sender, RoutedEventArgs e)
    {
      TreeViewItem tvi = tvFeedsFolders.SelectedItem as TreeViewItem;
      if (tvi != null)
      {
        IFeedFolder folder = null;

        folder = tvi.Tag as IFeedFolder;
        if (folder == null)
        {
          IFeed feed = tvi.Tag as IFeed;
          if (feed != null)
          {
            folder = feed.Parent as IFeedFolder;
          }
        }

        if (folder == null)
          folder = new FeedsManagerClass().RootFolder as IFeedFolder;

        FeedHelper.SubscribeFeed(folder, txtUrl.Text, txtNome.Text);
      }
    }

    [/code]

    Ecco il risultato del lavoro svolto fino a questo momento

    image

  • WPF: Costruiamo un RSS Reader passo 2 (L'interfaccia utente)

    Come secondo passo iniziano a creare l'interfaccia utente.

    Creiamo un nuovo Windows Forms e lo chiamiamo MainForm.xaml. Ci spostiamo sul file App.xaml e impostiamo StartupUri a MainForm.xaml.
    Vediamo come creare la nostra UI. La mia idea iniziale è quella di creare un menù in alto e dividere il resto della UI in due colonne. Quella di sinistra come colonna di controllo, il resto come area di lettura dei feeds.

    [code language="XML"]

    <Window
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:rssreader ="clr-namespace:WpfRssReader"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2006" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d"
        x:Class="WpfRssReader.MainForm"
        Title="Heros RSS Reader" Height="600" Width="800">
        <Grid Width="Auto" Height="Auto">
            <Grid.RowDefinitions>
                <RowDefinition Height="55"/>
                <RowDefinition Height="*"/>
            </Grid.RowDefinitions>

            <Rectangle Fill="#FF000000" Stroke="#FF000000" StrokeThickness="0" RadiusX="0" RadiusY="0" HorizontalAlignment="Stretch" Margin="0,0,0,0" Width="Auto"/>
            <TextBlock Margin="24,8,16,8" FontFamily="Segoe UI" FontSize="24" Foreground="#FFD5D5D5" Text="Heros {Community} RSS Reader" TextWrapping="Wrap"/>
        </Grid>
    </Window>

    [/code]

    Ho già inserito nella struttura, lo spazio dei nomi dell'applicazione e l'ho chiamata "rssreader".
    Dividiamo inoltre il form in due righe, una ad altezza fissa e una ad altezza variabile attraverso i due tag RowDefinition . Inserisco due oggetti per dare al form un leggero stile "Heros".

    Inseriamo all'interno del form un nuovo Grid che utilizzeremo come area per il posizionamento dei controlli.
    Dividiamo il Grid in righe e colonne. Dimensioniamo le colonne con un rapporto 1 a 3 utilizzando la notazione "*" e creiamo 3 righe.
    Una ad altezza fissa e due riproporzionabili.

    [code language="XML" ]

    <Window
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:rssreader ="clr-namespace:WpfRssReader"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2006" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d"
        x:Class="WpfRssReader.MainForm"
        Title="Heros RSS Reader" Height="600" Width="800">
        <Grid Width="Auto" Height="Auto">
            <Grid.RowDefinitions>
                <RowDefinition Height="55"/>
                <RowDefinition Height="*"/>
            </Grid.RowDefinitions>

            <Grid Grid.Row="1" Grid.RowSpan="1">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition/>
                    <ColumnDefinition Width="3*"/>
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition Height="100"/>
                    <RowDefinition Height="0.3*"/>
                    <RowDefinition Height="0.6*"/>
                </Grid.RowDefinitions>
            </Grid>

            <Rectangle Fill="#FF000000" Stroke="#FF000000" StrokeThickness="0" RadiusX="0" RadiusY="0" HorizontalAlignment="Stretch" Margin="0,0,0,0" Width="Auto"/>
            <TextBlock Margin="24,8,16,8" FontFamily="Segoe UI" FontSize="24" Foreground="#FFD5D5D5" Text="Heros {Community} RSS Reader" TextWrapping="Wrap"/>
        </Grid>
    </Window>

    [/code]

    Questo è il risultato del lavoro fino a questo momento.

    image

  • WPF: Costruiamo un RSS Reader passo 1 (utilizzare Microsoft.Feeds.dll)

    Questo vuole essere il primo di una serie di articoli dedicati alla scrittura di applicazioni complete, dalla A alla Z sviluppate con il Framework 3.5, ponendo particolare attenzione al layer di presentazione attraverso WPF. Come primo esercizio creiamo un RSS reader.

    Microsoft ci mette a disposizione una libreria COM per la lettura dei Feed. La utilizzeremo in questo progetto.

    Iniziamo.

    Creiamo la nostra applicazione con VS2008 e scegliamo WPF Application come tipo di progetto.
    Per prima cosa aggiungiamo la reference alla Microsoft.Feeds.dll che possiamo trovare tra i componenti COM.

    Creiamo una classe che ci permetta di gestire in modo agevole i feeds. Chiameremo questa classe FeedHelper

    [code language="C#"]

    public static class FeedHelper
      {

        /// <summary>
        /// Get The subtree for RootFolder folder
        /// </summary>
        /// <param name="feedfolder"></param>
        /// <returns></returns>
        [Description("Get The subtree for each folder")]
        public static TreeViewItem[] GetFeedSubTree()
        {
          return GetFeedSubTree((IFeedFolder)(new FeedsManagerClass().RootFolder));
        }

        /// <summary>
        /// Get The subtree for each folder
        /// </summary>
        /// <param name="feedfolder"></param>
        /// <returns></returns>
        [Description("Get The subtree for each folder")]
        public static TreeViewItem[] GetFeedSubTree(IFeedFolder feedfolder)
        {
          try
          {

            // Creiamo una lista di nodi per questo folder
            List<TreeViewItem> result = new List<TreeViewItem>();
            foreach (IFeedFolder folder in ((IFeedsEnum)feedfolder.Subfolders))
            {
              TreeViewItem tvi = new TreeViewItem()
              {
                Header = folder.Name,
                Tag = folder,
                ItemsSource = GetFeedSubTree(folder)
              };
              result.Add(tvi);
            }

            // Creiamo i nodi anche per i feed gia scaricati.
            if (feedfolder.Feeds != null)
            {
              foreach (IFeed feed in ((IFeedsEnum)feedfolder.Feeds))
              {
                TreeViewItem tvi = new TreeViewItem()
                {
                  Header = feed.Name,
                  Tag = feed
                };

                // Esegue il download asincrono degli items presenti nel feed
                ThreadPool.QueueUserWorkItem(delegate
                {
                  try
                  {
                    feed.Download();
                  }
                  catch (Exception ex)
                  {
                    Debug.WriteLine(ex.Message);
                  }
                }, null);
                result.Add(tvi);
              }
            }

            return result.ToArray();
          }
          catch (Exception ex)
          {
            Debug.WriteLine(ex.Message);
          }
          return null;
        }

        /// <summary>
        /// Create a Feed in a foder
        /// </summary>
        /// <param name="folder"></param>
        /// <param name="uri"></param>
        /// <param name="name"></param>
        public static void SubscribeFeed(IFeedFolder folder, string uri, string name)
        {
          folder.CreateFeed(name, uri);
        }
      }

    [/code]

    Estenderemo questa classe se necessario in seguito. Per adesso ci basta porre attenzione sui due overloads GetFeedSubTree In questi due metodi viene creato in modo ricorsivo l'albero che descrive i feed sottoscritti eseguendo anche il download dei feed da ogni sottoscrizione. Da notare che non abbiamo bisogno di creare una struttura di storage dei feeds sottoscritti e scaricati. La libreria Microsoft.Feeds si occuperà di tutto per conto nostro.

  • WPF Performance Tuning

    Ho trovato un link utile a chi si diletta nello sviluppo di applicazioni WPF.
    Sono riportati tutti gli oggetti WPF che inficiano in qualche modo le performance della nostra applicazione.

    Sono riportati anche suggerimenti per migliorare le performances.

    http://blogs.msdn.com/wpfsdk/archive/2007/01/15/maximizing-wpf-3d-performance-on-tier-2-hardware.aspx

    Vi riporto inoltre il link ai tools di profiling delle performances.

    http://msdn2.microsoft.com/en-us/library/aa969767.aspx

    Un link per migliorare le nostre animazioni

    http://msdn2.microsoft.com/en-us/library/bb613592.aspx

    Un link che ci spiega come funziona il Tier della struttura grafica.

    http://msdn2.microsoft.com/en-us/library/ms742196.aspx

    Ed infine un link per risolvere i problemi dovuti all'interazione con la scheda grafica

    http://msdn2.microsoft.com/en-us/library/aa970912.aspx

  • C# ReaderWriterLock

    In .Net quando dobbiamo creare applicazioni multithread siamo soliti utilizzare l'istruzione lock per sincronizzare l'accesso alle risorse condivise.
    Questo potrebbe non essere l'approccio più corretto se si eseguono molte letture e poche scritture perchè costringiamo i vari thread ad accedere alla risorsa anche in lettura uno alla volta.

    La classe ReaderWriterLock ci aiuta a inserire i lock solo quando necessari e permette accessi multipli in lettura e accessi singoli in scrittura.
    Vi rimando ad MSDN per una trattazione dell'argomento più dettagliata.

    http://msdn2.microsoft.com/en-us/library/system.threading.readerwriterlock.aspx

    http://msdn2.microsoft.com/en-us/magazine/cc163846.aspx

  • JET4 + .Net + x64 ....

    Mi sono trovato ad utilizzare JET4 con .Net e x64...

    Diciamo che c'è qualche piccolo problema. Nelle macchine x64 infatti non esiste una versione a 64bit per i drivers JET4 (Per Itanium c'è una versione specifica)
    Quindi le nostre applicazioni compilate e ottimizzate per x64 dal compilatore JIT di .Net, non avranno a disposizione tali drivers.

    Se non potete fare altrimenti, dovete necessariamente utilizzare la versione a 32bit che è comunque presente nella macchina, ma dobbiamo forzare il compilatore a generare codice x86 e non x64 perdendo tutti i vantaggi dell'architettura x64 per la nostra applicazione. Per fare questo andiamo nelle configurazioni avanzate del progetto e spostiamo la Target CPU da Any a x86.

    Buona fortuna.

  • Esplodere le gerarchie con Linq to SQL

    Utilizzando Linq to Sql mi sono reso conto di quanto sia facile ed immediato scrivere codice che intergra all'interno della sintassi di Linq delle chiamate a metodi.
    Una delle attività che affronto spesso, è scrivere metodi ricorsivi per manipolare le gerarchie. Con Linq è tutto molto più facile eseguire questa attività da codice, possiamo infatti creare una funzione ricorsiva inserendo all'interno di Linq la chiamata alla funzione che stiamo scrivendo.

    Nell'esempio che vi propongo esplodiamo l'organigramma definito nella tabella Employes del database AdventureWorks.

    Vediamo subito il codice.

    [code language="C#"]

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;

    namespace WindowsFormsApplication1
    {
      public partial class Form1 : Form
      {
        /// <summary>
        /// Costruttore del form
        /// </summary>
        public Form1()
        {
          InitializeComponent();

          // Chiamata al metodo per generare la struttura ad albero.
          this.treeView1.Nodes.AddRange(this.GetNodes(0));
        }

        /// <summary>
        /// Metodo per generare la struttura ad albero con Linq
        /// </summary>
        /// <param name="managerid"> Id del manager. 0 se si vuole ottenere ottenere l'albero a partire dal General Manager</param>
        /// <returns></returns>
        private TreeNode[] GetNodes(int managerid)
        {

          // DataContext definito con Linq
          DbDataContext db = new DbDataContext();

          var result = from empl in db.Employees    // Tabella Employees
                             join cont in db.Contacts on  // Join con la tabella Contacts per ricavare il nome degli impiegati
                                    empl.ContactID equals cont.ContactID
                            where (managerid == 0 && empl.ManagerID == null) ||      // Verifico se devo cercare il General Manager
                                                empl.ManagerID == managerid                       // Where per ottenere i rami figli del manager passato
                            let node = new TreeNode(empl.EmployeeID.ToString() + " " + cont.LastName,  // Utilizzo Let per generare una
                                                                                                  // variabile all'interno della query che contiene
                                                                                                  // direttamente il TreeNode da inseride nella TreeView
                                              GetNodes(empl.EmployeeID))        // Il TreeNode accetta un array di childs.
                                                                                // Inseriamo una chiamata al metodo che stiamo scrivendo per rendere la
                                                                                // funzione ricorsiva.
                       select node;                                             // Limitiamo la select all'elenco di nodi del ramo corrente.

          return result.ToArray();    // Trasformiamo il tutto in un array di TreeNodes
        }

      }
    }

     

    [/code]

     

    Ecco il risultato
    TreeForm

     

    Allego il progetto VS2008. Per farlo funzionare vi serve il DB AdventureWorks che potete scaricare dal sito Microsoft.

  • Una query expression in Linq veramente lunga ed interessante

    Vi riporto un link ad un post che potete trovare anche nei link della StartPage di VisualStudio. Sono rimasto senza parole.

    http://blogs.msdn.com/lukeh/archive/2007/10/01/taking-linq-to-objects-to-extremes-a-fully-linqified-raytracer.aspx

  • Nuova area dedicata a Sql Server

    Vi segnalo una nuova area dedicata a Tips e Best Practices per SQL Server 2005.

    http://dotnetumbria.org/blogs/sql_tips_practices/

     

    Buona lettura.

  • Utilizzare Trigger DDL per tenere allineati i database remoti

    In alcune applicazioni è spesso necessario creare database locali che si sincronizzano in qualche modo con il database presente su un server. Esempio tipico di applicazioni di questo tipo è Outlook, dove è necessario avere una copia dei dati locali in modo da poter lavorare in un ambiente parzialmente connesso. In scenari di questo tipo, specialmente nella fase di sviluppo e test dell'applicazione, ci può essere l'esigenza di modificare il database, e quindi di replicare tali modifiche a tutti i client insieme all'aggiornamento delle procedure di accesso ai dati. Tenere traccia delle modifiche effettuate e creare procedure di allineamento delle strutture, senza creare problemi ai dati presenti nei db remoti, è a volte una operazione lunga e che richiede parecchi test. I Trigger DDL ci vengono sicuramente in aiuto in scenari di questo tipo.

    Un Trigger DDL è un particolare tipo di trigger di SQL Server 2005 in grado di intercettare tutte le operazioni DDL (Data Definition Language) e che quindi modificano la struttura della base dati.
    Un buon esempio di un trigger di questo tipo è presente all'interno del database AdventureWorks. In pratica ogni operazione di Create, Alter, Drop, etc. di qualsiasi struttura del DB può essere intercettata e memorizzata in un'apposita tabella.

    Durante il deployment delle nostre applicazioni, potremo integrare il setup con una routine che riesegue sul DB client tutte le query DDL effettuate sul server in modo da rendere le strutture dei due DB assolutamente uguali.
    Ecco come avviene la creazione di un trigger DDL

     

    [code language="sql"]

    CREATE TRIGGER myDDLTrigger ON DATABASE
    FOR DDL_DATABASE_LEVEL_EVENTS AS
    BEGIN
        SET NOCOUNT ON;

    END

    [/code]

     

    La clausola FOR DDL_DATABASE_LEVEL_EVENTS  indica che è richiesta l'intercettazione di TUTTI gli eventi DDL che si verificano all'interno del database in cui il trigger si trova.
    Possiamo sostituire questa clausola con l'elenco degli eventi che intendiamo intercettare. Per avere una idea del tipo di eventi che possono essere intercettati con questo tipo di trigger è sufficiente eseguire questa query all'interno di un Database di  SQL Server 2005

     

    [code language="sql"]


    select type_desc from sys.trigger_events WHERE type >20

    [/code]

     

    Una volta intercettato l'evento all'interno del trigger otteniamo una struttura XML che descrive esattamente il tipo di operazione che è stata effettuata, con tanto di query eseguita per effettuarla.
    Possiamo salvare il dato in formato xml oppure navigare nel documento con XQuery ed esaminarne il contenuto.

    [code language="sql"]

    CREATE TRIGGER myDDLTrigger ON DATABASE
    FOR DDL_DATABASE_LEVEL_EVENTS AS
    BEGIN
        SET NOCOUNT ON;

        DECLARE @data XML;
        SET @data = EVENTDATA();  -- La variabile @data contiene la struttura xml con il dettaglio delle modifiche effettuate.

    END

    [/code]

    A questo punto possiamo creare una tabellina in cui memorizzare i valori ottenuti.

    [code language="sql"]

    CREATE TABLE myDbLog
    (
      Id  uniqueidentifier,
      operationdate datetime,
      operation xml
    ) ON [Primary]
    GO

    CREATE TRIGGER myDDLTrigger ON DATABASE
    FOR DDL_DATABASE_LEVEL_EVENTS AS
    BEGIN
        SET NOCOUNT ON;

        DECLARE @data XML;
        SET @data = EVENTDATA();  -- La variabile @data contiene la struttura xml con il dettaglio delle modifiche effettuate.

        INSERT INTO myDbLog
        VALUES (newid(), getdate(), @data)

    END
    GO

    [/code]


    Ovviamente possiamo rendere più ricca la nostra tabella esponendo già come campi, i dati presenti all'interno della struttura xml.

  • Controllo per la visualizzazioni di Grafici 3D in WPF. (Preparazione dell'usercontrol)

    Il nostro controllo per la visualizazione di grafici 3D, dovra essere inserito dentro il ViewPort3D, quindi dovrà ereditare ModelVisual3D


    [code language="c#"]

    /// Autore: Paolo Possanzini
    /// WebSite: http://www.teamdev.it
    /// email: paolo@teamdev.it
    public class WpfChart : ModelVisual3D, ISupportInitialize
    {

    ....

    }

    [/code]

     

    Da notare che il nostro controllo implementerà anche ISupportInitialize, questo ci permette di capire quando stato inizializzato oppure quando è in fase di inizializzazione.
    A questo punto possiamo iniziare ad inserire all'interno del nostro controllo. I grafici saranno visualizzati a partire da una sorgente dati, quindi mettiamo a disposizione dello sviluppatore una proprietà per agganciare la sorgente dati al nostro controllo.

    [code language="c#"]

    /// Autore: Paolo Possanzini
    /// WebSite: http://www.teamdev.it
    /// email: paolo@teamdev.it
    public class WpfChart : ModelVisual3D, ISupportInitialize
    {


    private static DependencyProperty ItemsSourceProperty = DependencyProperty.Register("ItemsSource", typeof(IEnumerable), typeof(WpfChart));
    private static DependencyProperty ItemTemplateProperty = DependencyProperty.Register("ItemTemplate", typeof(DataTemplate), typeof(WpfChart));

    public IEnumerable ItemsSource
    {
      get { return base.GetValue(ItemsSourceProperty) as IEnumerable; }
      set
      {
        if (value == null)
          base.ClearValue(ItemsSourceProperty);
        else
          base.SetValue(ItemsSourceProperty, value);
        RefreshBars();
      }
    }

    ....

    }

    [/code]

    Ci servono anche altre proprietà che implementeremo in modo analogo, le proprietà che ci servono sono : ItemTemplate, Transform, ItemTemplateName.
    ItemTemplate ed ItemTemplateName ci servono per implementare una struttura simile agli ItemTemplate presenti nelle ListView.

    A questo punto siamo pronti per iniziare a preoccuparci di cosa visualizzare all'interno del nostro controllo.

More Posts Next page »
dotNet Umbria 2007-2008
Powered by Community Server (Commercial Edition), by Telligent Systems