Configure Membership c# (asp.Net) 2 Next Step.

Giusto perchè, l'applicazione del post precedente funziona... se e solo se specificate un appPool a 32 bit su IIS come mettete tutto a 64 ... sparisce la gestione integrata degli Utenti.

Ossia Scompaio le due icone di User.Net e Role.Net e sapete perchè ?
No (immaginavo) e quindi ve lo dico io.

Vi ricordate il discorso 32 bit e 64 bit ?? No?? bhe è riassumibile con se fai una cosa a 32 non è detto che vada a 64 o che la stessa configurazione regga.
L'esempio classico sono i db Driver che per un applicazione a 32 se questi sono a 64 comunicano un errore di Archittettura.

IIS non è da meno.. ossia On board sul vostro server avete uno splendido file chiamato :administration.config

C:\Windows\System32\inetsrv\config\administration.config
(file che dovrete necessariamente aprire con i diritti di amministratore se no
non ne uscite)
accedete prima a questo percorso
C:\Windows\System32\inetsrv\config
eseguite il notepad come administrator ( non il notepad++ o l'ultra edit .. il
notepad !) drag'n drop del file !


Che contiene le informazioni necessarie a far funzionare il vostro IIS.

<trustedProviders allowUntrustedProviders="false">
    <add type="System.Web.Security.SqlMembershipProvider, 
                System.Web, Version=2.0.0.0, 
                Culture=neutral, 
                PublicKeyToken=b03f5f7f11d50a3a" />
                
    <add type="System.Web.Security.SqlRoleProvider, 
                System.Web, Version=2.0.0.0, 
                Culture=neutral, 
                PublicKeyToken=b03f5f7f11d50a3a" />
                
    <add type="System.Web.Security.WindowsTokenRoleProvider, 
                System.Web, Version=2.0.0.0, 
                Culture=neutral, 
                PublicKeyToken=b03f5f7f11d50a3a" />
</trustedProviders>

E magia magia gurdate un po a che cosa fanno riferimento ??

Version=2.0.0.0 già ! e aprite il vostro web config... e guardate un attimo a
cosa fa riferimento il vostro System.Web ?? Non c'e' scritto vero ?? GIA'

Ma da Solution Explorer, selezionando le reference scopriamo che si tratta della release 4.0.0.0

E poi la botta finale... andate qui
C:\Windows\assembly\ e guardate con somma gioia che cosa state realmente caricando ...

Version=2.0.0.0 già !

Morale chi ha ragione e chi ha torto ?? Che cosa realmente stiamo usando ?? Pare che
IIS ragioni a 32, con una vecchia release della system web, e benche sia configurabile, il set up di MS non si accorge che hai un sistema a 4 processori da 64 bit con il .Net 4 installato. Altro che barre di scorrimento!!!


Fa nulla, non è grave facciamo tutte le web application con il framework 2, tanto era solido... O se no vado nella GAC e zappo la System.Web 2.0.0.0

Di contro un qualcosa si può fare senza che esploda la macchina, modificare l'attributo

<trustedProviders allowUntrustedProviders="false">

in

<trustedProviders allowUntrustedProviders="true">

A questo punto riavviate l'IIS e incrociate le dita.. vi dirà che la cosa non è sicura
che è possibile che vi sia qualche altra cosa che si inventa lui.. ma non vi preoccupate tutto andrà !

E adesso l'ultima sfida... se io il db non lo volessi in App_Data ? ( che probabilmente anche il più fesso degli hkr sa dove andarlo a cercare ?? )

Bene ci basta fare questo :

a) verificate di non aver aperto il db presente in App_Data
b) rinominate la cartella ( in quel che più vi pare )
c) cambiate i permessi se la cartella non si trova più sotto il percorso inetpub
d) modificate il vostro web config

<remove name="LocalSqlServer" />        
<add name="ApplicationServices" 
        connectionString="data source=.\SQLEXPRESS;
        Integrated Security=SSPI;
        AttachDBFilename=D:\MyData\aspnetdb.mdf;
        User Instance=true" 
        providerName="System.Data.SqlClient" />
<add name="LocalSqlServer" 
        connectionString="data source=.\SQLEXPRESS;
        Integrated Security=SSPI;
        AttachDBFilename=D:\MyData\aspnetdb.mdf;
        User Instance=true"  
        providerName="System.Data.SqlClient" />

E quindi riprendere ad usare il Tutto integrato per la gestione degli utenti.

Quando avrete finito dovrete rimettere l'appPool correto ( sempre che vi serva a 64 )
se no avete finito !

Ok non è stato facile integrare il tutto senza implementare qualcosa di nostro vero...
e pensare che per fare la form degli utenti ci vogliono 20 min... !

Tutorial Configure Membership c# (asp.Net)

Per prima cosa che cosa è Membership, microsoft ha pensato ad una struttura "preimpostata" per la gestione
integrata delle utenze, dando quindi la possibilità di gestire utenti e liveli ( che nel caso specifico prendono il nome di regole).

Questa breve guida spiega come attivare Membership per una web application.

Visual studio 2010
linguaggio c#
tipo soluzione Web application.

Aprite quindi visual studio
Create una nuova Web application
Nel mio caso l'ho chiamata TestMembership



A questo punto la nostra ide leggendo il template di soluzione ci crea una struttura non troppo differente da questa.



Al primo play otteremo una pagina ( a mio avviso discutibile ) uguale a questa.



Iniziamo con la configurazione di base: Associamo almeno un utenta alla nostra applicazione.

Dal menù project scegliere ASP.NET configuration ( se non vi appare la voce di menu accertatevi di aver selezionato la web application nel box Solution Explorer.

Ci verrà presentato il sito di configurazione per impostare utenti e ruoli per quest'applicazione.



Selezioniamo Security e quindi Create User ( formalmente sono contro i Wizard ma è una scelta mia)

A questo punto ci chiederà di immettere le credenziali dell'utente che ci serviranno per il nostro applicativo.



Ricordatevi di immettere la mail perchè è obbligatoria.

Fatto questo torniamo al pannello security e abilitiamo le regole che per default sono Disabilitate. Scegliamo quindi Create Roles e quindi premiamo add Role.



A inserimento fatto ci permetterà di gestire questo Ruolo dandoci un pannello di navigazione sugli utenti. Basta mettere il Checked all'utente che abbiamo creato in
precedenza.

A questo punto torniamo sul pannello security e selezioniamo Create Access Rules



Scegliamo la cartella Account, secliamo il ruolo Admin, selezioniamo Allow e quindi
premiamo OK.

E per il momento la prima Parte è fatta, abbiamo configurato il primo utente per
il nostro sito !

Se non abbiamo commesso troppi errori, ora ci conviene fare una pubblicazione, su ISS in modo da spostare il focus sul web server.

Quindi dal menu Build selezioniamo Publish Web



Per ottenere questa schermata vi basterà selezionare File system da li poi sceglieremo l'IIS.

Create quindi una nuova Web Application ( che volendo potrete chiamare testMembership )



Scegliete Open e quindi Publish.

Bene avete pubblicato il wostro primo sito web con Membership Attivo !

A questo punto ci spostiamo su IIS per comprendere che cosa è successo è ci ritroviamo quanto segue.




Premendo su Esplora sulla porta 80 ecco che i nostro sito parte ! Provate a immettere il vostro user e tutto dovrebbe andare.

How To: javascrpt substring subStr

In javascript è possibile prelevare porzioni di una stringa tramite il comando substring.

function Get10Char(valueFrom)
{
    if (valueFrom.length <= 10)
    {
        return valueFrom;
    }
    else
    {
        return valueFrom.substring(0,10);
    }
}

In questo esempio (semplice semplice) la funzione non fa altro che restituire i primi 10 caratteri
della stringa passata come parametro.

How To: javascript FindControl getControlById

Per poter trovare un controllo su una pagina html, in javascript si può utilizzare il selettore getElementById(string)
Questo consente a livello di documento la ricerca di un controllo che abbia per attributo Id il valore passato
in string (parametro della funzione).

Implicitamente questo vuol dire che gli Id dei controlli su una pagina Web debbano sempre essere valorizzati, e a
maggior ragione debbano essere unici !

function setTextToControl(controlId, newText)

{

    var control = document.getElementById(controlId);

    if (control != null)

    {

        control.value =newText;    

    }

    else

    {

        alert ("controllo " + controlId + " non trovato");

    }    

}

How To: DataTable To List SOLVED.

Ammetto che come sfida non sia stata della più semplici, e credo che ormai il visitatore che ieri mi ha formulato la richiesta o abbia disistito, o ci sia riuscito..

cmq il nocciolo della questione era ottenere una List T partendo da una DataTable.

A tutti gli effetti DataTable presenta una metodo di cast, ma non è di certo
quello che fa.. anzi il cast accetta solo DataRow, che di aiuto non ne offre tanto.

Quindi mi sono deciso a provare con un delegato mio che operi in tal senso, basandomi
però sul concetto di Select tuttavia mi è servito comunque avere a disposizione il
cast.

public class entity
{
    public int ID { get; set; }
    public string Name{ get; set; }
    public string Description { get; set; }
   
    public override string ToString()
    {
        return string.Format("id>{0}|name>{1}|description>{2}", 
                ID, Name, Description);
    }
}

public class entityList : List<entity>
{ 

}

class Program
{
    static void Main(string[] args)
    {
        DataTable dt = new DataTable("myEntity");
        dt.Columns.Add("id", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Description", typeof(string));

        dt.Rows.Add(new object[] { 1, "Test_1", "Test_1" });
        dt.Rows.Add(new object[] { 2, "Test_2", "Test_2" });
        dt.Rows.Add(new object[] { 3, "Test_3", "Test_3" });


        entityList el = new entityList();
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            Console.WriteLine(
                                "Id:{0} Name:{1} Description:{2}",
                                dt.Rows[i][0].ToString(),
                                dt.Rows[i][1].ToString(),
                                dt.Rows[i][2].ToString()
                                );

        }

        var output = dt.Rows.Cast<DataRow>().Select(r=>RealCast(r));

        el.AddRange(output.ToArray());


        for (int i = 0; i < el.Count; i++)
        {
            Console.WriteLine(
                                "Id:{0} Name:{1} Description:{2}",
                                el[i].ID.ToString(),
                                el[i].Name.ToString(),
                                el[i].Description.ToString()
                                );
        }

        Console.ReadLine();

    }

    private static entity RealCast(DataRow dr)
    {
        return new entity { 

                            ID=Convert.ToInt32(dr[0]), 
                            Name=dr[1].ToString(), 
                            Description=dr[2].ToString() 
        };
    }

}

Quindi i perfetto stile ecco che con un delegato

private static entity RealCast(DataRow dr)
    {
        return new entity { 

                            ID=Convert.ToInt32(dr[0]), 
                            Name=dr[1].ToString(), 
                            Description=dr[2].ToString() 
        };
    }

e una riga

var output = dt.Rows.Cast<DataRow>().Select(r=>RealCast(r));

        el.AddRange(output.ToArray());

riusciamo a convertire
una DataTable in un entity (nota).. il divertente sarà risucire a farlo con generic... e chi mi ferma più !!!

Se volete fare qualche prova di giusto per comprendere quanto rende questo codice

static void Main(string[] args)
{
    DataTable dt = new DataTable("myEntity");
    dt.Columns.Add("id", typeof(int));
    dt.Columns.Add("Name", typeof(string));
    dt.Columns.Add("Description", typeof(string));

    Console.WriteLine ("fill\r\n" +DateTime.Now.ToLongTimeString() +"." + 
                        DateTime.Now.Millisecond.ToString().PadLeft(3,'0'));

    for (int i = 0; i < 1000000; i++)
        dt.Rows.Add(new object[] { i, 
                                "Test" +i.ToString(), 
                                "Test" +i.ToString() });


    Console.WriteLine (DateTime.Now.ToLongTimeString() +"." + 
                        DateTime.Now.Millisecond.ToString().PadLeft(3,'0'));

    entityList el = new entityList();

    Console.WriteLine ("conver\r\n" +DateTime.Now.ToLongTimeString() +"." + 
                        DateTime.Now.Millisecond.ToString().PadLeft(3,'0'));

    var output = dt.Rows.Cast<DataRow>().Select(r=>RealCast(r));

    el.AddRange(output.ToArray());

    Console.WriteLine (DateTime.Now.ToLongTimeString() +"." + 
                        DateTime.Now.Millisecond.ToString().PadLeft(3,'0'));

    Console.ReadLine();

}

0,7 secondi nel mio caso ... e sono rimasto abbastanza colpito!

List.Add ( new Entity { } )

Potresti essere interessato anche come impiegare questo metodo:how to datatable to list solved


Una delle cose carine del C# è la possibilità di costruire una classe, utilizzando le sue porprietà senza necessariamente aver implementato il costruttore.

Probabilmente non è sempre utile sfruttare questa possibilità, ma per situazioni semplici potrebbe anche tornare comodo.

public class entity
{
    public int ID { get; set; }
    public string Name{ get; set; }
    public string Description { get; set; }

    public override string ToString()
    {
        return string.Format("id>{0}|name>{1}|description>{2}", 
                ID, Name, Description);
    }
}



class Program
{
    static void Main(string[] args)
    {
        List<entity> ets = new List<entity>();
        ets.Add(new entity { ID = 1, Name = "me", Description = "" });
        ets.Add(new entity { ID = 2, Name = "te", Description = "" });
        ets.Add(new entity { ID = 3, Name = "noi", Description = "" });       
    }
}

In questo semplice caso aggiungiamo 3 elmenti che come è ben visibili sono di tipo
entity, ma non implementano alcun costruttore.

How To: Use a Tuple

Ma che cosa diavolo è il Tuple ?

E' un raggruppatore, fondamentalmente serve per creare un legame fare n variabili, valori o oggetti verosimilmente anche differenti fra loro...

La comodità potrebbe essere dubbia, ma a volte potrebbe essere.

Come funziona ? questi due esempi che sembrano di contro semplici semplici
risultano anche molto esplicativi.

public class entity
{
    public int ID { get; set; }
    public string Name{ get; set; }
    public string Description { get; set; }

    public entity(int id, string name, string description)
    {
        ID = id; Name = name; Description = description;
    }

    public override string ToString()
    {
        return string.Format("id>{0}|name>{1}|description>{2}", ID, Name, Description);
    }
}



class Program
{
    static void Main(string[] args)
    {
        System.Tuple<string,string> t = Tuple.Create("PrimoItem", "SecondoItem");

        Console.WriteLine(t.Item1, t.Item2);


        System.Tuple<entity, entity> t1 = Tuple.Create(
                            new entity(0,"fabio","developer"),
                            new entity(1,"fabio","photografer"));

        Console.WriteLine(t1.Item1.ToString(), t1.Item2.ToString());
    }
}

Non credo che utilizzerò spesso il Tuple.. ma mai dire mai.

How To: DataTable To List

Questo post prosegue qui :how to datatable to list solved

Oggi ho notato che qualcuno ha fatto una ricerca sul mio sito in tal senso...

La cosa mi ha incuriosito e ho fatto una prova che però non mi ha del tutto soddisfatto, anzi cercherò più tardi di approfondire meglio la situazione.

public class entity
    {
        public int ID { get; set; }
        public string Name{ get; set; }
        public string Description { get; set; }

        public entity(int id, string name, string description)
        {
            ID = id; Name = name; Description = description;
        }
    }

    public class entityList:List<entity>
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
            DataTable dt = new DataTable("myEntity");
            dt.Columns.Add("id", typeof(int));
            dt.Columns.Add("Name", typeof(string));
            dt.Columns.Add("Description", typeof(string));
           
            dt.Rows.Add(new object[] { 1, "Test_1", "Test_1"});
            dt.Rows.Add(new object[] { 2, "Test_2", "Test_2" });
            dt.Rows.Add(new object[] { 3, "Test_3", "Test_3" });



            entityList el = new entityList();
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                Console.WriteLine(
                                    "Id:{0} Name:{1} Description:{2}", 
                                    dt.Rows[i][0].ToString(), 
                                    dt.Rows[i][1].ToString(), 
                                    dt.Rows[i][2].ToString()
                                    );

                el.Add(new entity( 
                                    (int)dt.Rows[i][0], 
                                    dt.Rows[i][1].ToString(), 
                                    dt.Rows[i][2].ToString()
                                    )
                        );
            }


            

            for (int i = 0; i < el.Count; i++)
            {
                Console.WriteLine(
                                    "Id:{0} Name:{1} Description:{2}",
                                    el[i].ID.ToString(),
                                    el[i].Name.ToString(),
                                    el[i].Description.ToString()
                                    );

            }

            Console.ReadLine();
        }

    }

Questo codice non mi convince del tutto perchè comunque devo passare tutti gli elmenti della tabella, e non credo che sia il migliore de modi... ma come
ho anticipato, troverò un sistema ... più migliore assai.

Create yuor first form XAML

Linguaggio: C#
Framework: 3.5
Visualstudio: 2008

Cerchiamo di comprendere un filo meglio che quali sono i benefici di questo nuova modalità di interpretare le finestre, e dato che le differenze rispetto alla classica presentazione sono tante direi di non lesinare... anzi!
Creiamo una nuova applicazione chiamata Tutorials_002 e come prima cosa rinominiamo la nostra finestra in Main.

Iniziamo a settare il background del tag GRID, e proviamo aggiungendo quanto vi ho già preparato :

<Grid.Background>
    <LinearGradientBrush SpreadMethod="Pad" ColorInterpolationMode="ScRgbLinearInterpolation">
        <LinearGradientBrush.GradientStops>
            <GradientStop Offset="0.00" Color="Gray" />
            <GradientStop Offset="0.70" Color="White" />
            <GradientStop Offset="0.75" Color="LightGray" />                                        
            <GradientStop Offset="0.76" Color="White" />
            <GradientStop Offset="1.00" Color="LightGray" />
        </LinearGradientBrush.GradientStops>
    </LinearGradientBrush>
</Grid.Background>

L’effetto ricorda molto ( o in parte ) quanto di più simile ad uno sfondo Web 2.0, quello che decisamente impressiona, è la rapidità con cui a design e run time esegue il refresh.
Dopo quei due o tre tentavi con gradazioni e colori dai più assurdi ai più piacevoli... per proseguire ci serve realizzare una tabella con due o tre campi su sqlExpress, già perché in questo form andremo a metterci una griglia.

CREATE TABLE [dbo].[Clients](
    [idClient] [int] IDENTITY(1,1) NOT NULL,
    [Name] [nvarchar](50) NOT NULL,
    [Description] [nvarchar](150) NULL,
    [Address] [nvarchar](250) NULL,
    [Telephone] [nvarchar](20) NULL,
    [Mail] [nvarchar](50) NULL,
CONSTRAINT [PK_Clients] PRIMARY KEY CLUSTERED 
(
    [idClient] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, 
IGNORE_DUP_KEY = OFF, 
ALLOW_ROW_LOCKS  = ON, 
ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

GO

Quindi inseriteci almeno un dato.

Tornando sul form, dato che sono un “precisetti” ho ben pensato di aggiungere almeno l’etichetta, quanto meno ho idea di quello che sto per rappresentare.
Basta aggiungere una label proprio come avevamo fatto nella prima lezione.

<Label HorizontalAlignment="Left" 
    Margin="12,4,0,0" 
    Name="label1" 
    Width="153" 
    Height="57" 
    VerticalAlignment="Top" 
    FontSize="40" 
    Foreground="White">
    Clients
</Label>

L’obbiettivo è quindi palese abbiamo creato un form che dovrà mostrarci il contenuto della tabella Clients.
Per poter far ciò ognuno di noi è libero di implementare la logica che meglio s’addice, tuttavia consiglio di seguire il tutorial in modo di arrivare allo stesso risultato.

Ciò detto creo nella soluzione la cartella Entites e all’interno di questa la cartella Clients.

Realizzo quindi la classe che mi rappresenterà l’entità

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tutorial_002.Entities.Clients
{
    public class Client
    {
        private int _idClient;
        private string _Name;
        private string _Description;
        private string _Address;
        private string _Telephone;
        private string _Mail;

        public int idClient
        {
            get { return _idClient; }
            set { _idClient = value; }
        }

        public string Name
        {
            get { return _Name; }
            set { _Name = value; }
        }

        public string Description
        {
            get { return _Description; }
            set { _Description = value; }
        }

        public string Address
        {
            get { return _Address; }
            set { _Address = value; }
        }

        public string Telephone
        {
            get { return _Telephone; }
            set { _Telephone = value; }
        }

        public string Mail
        {
            get { return _Mail; }
            set { _Mail = value; }
        }
    }
}

E per la collezione aggiungerò una nuova classe estendendo la lista generica.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Tutorial_002.Entities.Clients
{
    public class ClientList:List<Client>
    {
    }
}

Dato che la lista implementa in modo nativo tutte le funzionalità necessarie non mi serve altro.

Ora mi serve la classe che mi fornirà i dati ossia la classe che dovrà interagire con il DB. Creo quindi una nuova cartella, chiamata Providers e al suo interno creo la cartella Clients, quindi aggiungo una nuova classe chiamata ClientsDataProvider.

Va da se che la stringa di connessione dovrete modificarla, perché giustamente ognuno ha la sua istanza di db.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;

using Tutorial_002.Entities.Clients;

namespace Tutorial_002.Providers.Clients
{
    public class ClientsDataProvider
    {
        private string connection = @"Data Source=[NOMECOMPUTER]\SQLEXPRESS;"+ 
        "Initial Catalog=WPF_SampleDB;Integrated Security=True;Pooling=False";

        public ClientsDataProvider()
        { 
        
        }

        public ClientList Select()
        {
            ClientList cl = new ClientList();
            DataTable clDt = new DataTable();

            System.Data.SqlClient.SqlConnection scc = new SqlConnection(connection);
            scc.Open();
            
            System.Data.SqlClient.SqlDataAdapter sda = new 
                                        SqlDataAdapter("SELECT * FROM clients",scc);


            sda.Fill(clDt);

            for (int i = 0; i < clDt.Rows.Count; i++)
            {
                Client c = new Client();
                c.idClient =    Convert.ToInt32(clDt.Rows[i][0]);
                c.Name =        clDt.Rows[i][1].ToString();
                c.Description = clDt.Rows[i][2].ToString();
                c.Address =     clDt.Rows[i][3].ToString();
                c.Telephone =   clDt.Rows[i][4].ToString();
                c.Mail =        clDt.Rows[i][5].ToString();

                cl.Add(c);
            }

            scc.Close();
            sda = null;
            scc = null;
            return cl;
        }
    }
}

Per questo esempio il provider è proprio solo di concetto , il suo scopo è quello di leggere meramente i dati dal db.

Nel nostro Form dobbiamo aggiungere solo questo:

<ListView Margin="10,80,10,10" Name="lstClient">
    <ListView.View>
        <GridView>
            <GridView.Columns>
                <GridViewColumn Header="ID" 
                    Width="20" 
                    DisplayMemberBinding="{Binding Path=idClient}">
                  
                </GridViewColumn>
                <GridViewColumn Header="Name" 
                    Width="100" 
                    DisplayMemberBinding="{Binding Path=Name}">

                </GridViewColumn>
                <GridViewColumn Header="Description" 
                    Width="180" 
                    DisplayMemberBinding="{Binding Path=Description}">

                </GridViewColumn>
                <GridViewColumn Header="Address" 
                    Width="140" 
                    DisplayMemberBinding="{Binding Path=Address}">

                </GridViewColumn>
                <GridViewColumn Header="Telephone" 
                    Width="90" 
                    DisplayMemberBinding="{Binding Path=Telepone}">

                </GridViewColumn>
            </GridView.Columns>
        </GridView>
    </ListView.View>
</ListView>

Che è la definizione della nostra grid View.
A questo punto nel code Behind dobbiamo aggiungere...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

using Tutorial_002.Providers.Clients;

namespace Tutorial_002
{
    public partial class Main : Window
    {
        public Main()
        {

            ClientsDataProvider clDP = new ClientsDataProvider();

            InitializeComponent();


            lstClient.ItemsSource = clDP.Select();
        }

    }
}

Ed è quindi giunto il momento di compilare.

RIEPILOGO TUTORIAL 2
a) Abbiamo creato un form con uno sfondo grafico solo tramite impostazioni.
b) Abbiamo creato una tabella con uno script sql
c) Abbiamo creato un entità e la sua collezione
d) Abbiamo creato il data provider per l’entità
e) Abbiamo creato la griglia e l’abbiamo popolata con i dati dell’entità.

Conclusioni dopo queste due prime puntate.
Visto così parrebbe che xaml e wpf non siano poi così male, e che comunque diano anche qualche beneficio in fase di implementazione, abbiamo scritto poco codice, ma ufficialmente non abbiamo ancora fatto nulla, di veramente intricato.