Negli ultimi anni il Poker, nella sua accezione del Texas Hold’em, è diventato il gioco più amato dagli italiani, scavalcato solo dalle scommesse, legalizzate da molto più tempo. Al momento, secondo l’istituto di ricerca Eurispes, quella del gioco d’azzardo è la terza industria del paese per volume d’affari. Il fenomeno è supportato da canali televisivi a tema e dal fenomeno del “divismo” dei giocatori più conosciuti che espongono sui loro capi di abbigliamento sponsor del poker on line.

Dal punto di vista più strettamente informatico sono interessanti alcuni progetti ospitati su code google con licenza GNU GPL che mettono a disposizione un framework e un logic engine per il il Texas Hold’em openholdembot,cspoker.

Nell’ipotesi di sviluppare un servizio RESTFull con Microsoft WCF che faccia da dealer e che possa servire come base per sviluppare un software sul poker ipotizziamo come possibile output un flusso JSON.
Creiamo una WCF Service Application chiamata PokerWcfService e cancelliamo il servizio creato di defaul per crearne uno nostro chiamato PokerService.svc. All’interfaccia IPokerService aggiungiamo un semplice metodo getCards che restituisce che prende in input il numero di giocatori

[OperationContract]
[WebInvoke(Method = "GET",
    ResponseFormat = WebMessageFormat.Json,
    BodyStyle = WebMessageBodyStyle.Bare,
    UriTemplate = "getCards/{playersNumber}")]
ResultGetCards getCards(string playersNumber);

Per implementare questo metono ho creato una classe ResultGetCards la quale al suo interno contiente una lista di oggetti di tipo PlayerHand e un oggetto ShowDown.

    /// <summary>
    /// Player hand, two cards
    /// </summary>
    public class PlayerHand
    {
        private string _firstCard;
 
        public string firstCard
        {
            get { return _firstCard; }
            set { _firstCard = value; }
        }
 
        private string _secondCard;
 
        public string secondCard
        {
            get { return _secondCard; }
            set { _secondCard = value; }
        }
    }
 
    /// <summary>
    /// ShowDown Flop
    /// </summary>
    public class ShowDown
    {
        private string _firstCardFlop;
 
        public string firstCardFlop
        {
            get { return _firstCardFlop; }
            set { _firstCardFlop = value; }
        }
 
        private string _secondCardFlop;
 
        public string secondCardFlop
        {
            get { return _secondCardFlop; }
            set { _secondCardFlop = value; }
        }
 
        private string _thirdCardFlop;
 
        public string thirdCardFlop
        {
            get { return _thirdCardFlop; }
            set { _thirdCardFlop = value; }
        }
 
        private string _turn;
 
        public string turn
        {
            get { return _turn; }
            set { _turn = value; }
        }
 
        private string _river;
 
        public string river
        {
            get { return _river; }
            set { _river = value; }
        }
    }

La classe ResultGetCards risulterebbe quindi strutturata in questo modo:

    /// <summary>
    /// getCards Output 
    /// </summary>
    public class ResultGetCards
    {
        private ShowDown _showDown;
 
        public ShowDown showDown
        {
            get { return _showDown; }
            set { _showDown = value; }
        }
 
        private List<PlayerHand> _playerHands;
 
        public List<PlayerHand> playerHands
        {
            get { return _playerHands; }
            set { _playerHands = value; }
        }
    }

Questa è la struttura dei files

Una volta creato il servizio, definito il model e strutturata la soluzione non resta che implementare il metodo getCards.

La tecnica utilizzata è quella di recuperare dall’array di stringhe card i valori per popolare il result composto dallo showdown e dalle playerCards senza ripetere mai gli stessi valori e in maniere casuale. Questo è possibile recuperando il numero necessario di valori, in base al numero di giocatori in input, dall’array che viene ogni volta ordinato in maniera casuale.
L’output finale sarà del tipo:

{"playerHands":[{"firstCard":"6H","secondCard":"QC"},{"firstCard":"1H","secondCard":"4S"},{"firstCard":"3H","secondCard":"8H"},{"firstCard":"6D","secondCard":"JC"},{"firstCard":"QH","secondCard":"3D"},{"firstCard":"2D","secondCard":"9C"},{"firstCard":"KD","secondCard":"10D"},{"firstCard":"6S","secondCard":"8D"}],"showDown":{"firstCardFlop":"5C","river":"9D","secondCardFlop":"JD","thirdCardFlop":"1S","turn":"1D"}}


Continuando quanto cominciato con la prima parte di questo tutorial implemento le altre due funzionalità fondamentali, ovvero la cancellazione e l’aggiornamento di una notizia.

Cancellazione

Come per la creazione creiamo un XDocument con li file delle news, poi individuiamo la notizia con l’attributo id corrispondete a quella che vogliamo eliminare e facciamo una Remove(). Non ci resta che salvare il file.

 XDocument newsXML = XDocument.Load(Server.MapPath("App_Data\\News.xml"));
 newsXML.XPathSelectElement("News/Notizia[@Id = '" + idNews + "']").Remove();
 newsXML.Save(Server.MapPath("App_Data\\News.xml"));

Modifica

Per la modifica utilizziamo la stessa tecnica usata per la cancellazione con l’unica differenza che non invochiamo la Remove() ma ma aggiorniamo i campi della notizia che intendiamo modificare

XDocument newsXML = XDocument.Load(Server.MapPath("App_Data\\News.xml"));
 XElement notizia= newsXML.XPathSelectElement("News/Notizia[@Id = '" + _idNews + "']");
 notizia.Element("Title").Value = "Nuovo Titolo";
 notizia.Element("Text").Value = "Nuovo testo";
 notizia.Element("Data").Value = "31/12/2010";
 notizia.Element("Evidence").Value = "False";
 newsXML.Save(Server.MapPath("App_Data\\News.xml"));

Linq è molto semplice da imparare e nel contempo molto potente. Linq dispone di quattro implementazioni: Linq to Sql, Linq to Entities, Linq to DataSets, Linq to Object e Linq to XML. In questo post cercherò di implementare un piccolo sistema di gestione delle news basato su Linq to Xml.
Partiamo dalla nostra sorgente dati, ovvero dal file XML. Esso è composto dal primo elemento “News” all’interno del quale sono contenute tutte le “Notizia”. Ogni notizia possiede un attributo identificativo “Id” che corrisponde alla data trasformata in stringa secondo la convenzione yyyyMMddhhmmss. Le notizie inoltre possiedono l’elemento “Data” che rappresenta la data dell’evento per cui è stata creata la news e un elemento “Evidence” per identificare le news più importanti.

<?xml version="1.0" encoding="utf-8"?>
<News>
  <Notizia Id="20100707102340">
    <Title>My first new</Title>
    <Text>My text,go on antferr.com</Text>
    <Data>07/07/2010</Data>
    <Evidence>True</Evidence>
  </Notizia>
  <Notizia Id="20100706102340">
    <Title>My second new</Title>
    <Text>Hello readers</Text>
    <Data>06/07/2010</Data>
    <Evidence>True</Evidence>
  </Notizia>
</News>

Fatto ciò non ci resta che creare la web application ASP.NET C#, ipotizzando di inserire il file xml nella directory App_Data e di chiamarlo semplicemente News.xml
Partiamo dal backend, cioè dalla parte amministrativa che deve implementare le funzionalità di inserimento, modifica e cancellazione delle news.

Inserimento

XDocument newsXML = XDocument.Load(Server.MapPath("App_Data\\News.xml"));
                XElement elemento = newsXML.Element("News");
                var notizia = new XElement("Notizia", new XAttribute("Id", news.Id),
                    new XElement("Title", "Il mio titolo"),
                    new XElement("Text", "Il mio testo"),
                    new XElement("Data", "10/07/2010"),
                    new XElement("Evidence", "True")
                        );
                elemento.Add(notizia);
                newsXML.Save(Server.MapPath("App_Data\\News.xml"));

Per far sì che il codice sopra funzioni correttamente è necessario aggiungere i riferimenti a System.Xml.Linq e System.Xml.XPath. Il funzionamento è molto semplice. Creiamo un oggetto di tipo XDocument all’interno del quale carichiamo il contenuto del nostro file xml, poi creiamo un oggetto di tipo XElement che conterrà il contenuto del tag . A questo punto non ci resta che creare una nuova come un nuovo XElement da aggiungere sotto il tag e salvare il file. Ovviamente il contenuto della news non dovrebbe essere cablato come in questo esempio ma derivante da input inseriti dall’amministratore.

Un po’ ovunque è sconsigliato l’acquisto di spazio web windows per l’hosting del proprio web site su Aruba. Volendo provare un progetto basato sulla Web Client Software Factory ho deciso di acquistare lo spazio su aruba. Purtroppo ho scoperto che non è possibile usare questo pattern sull’hosting in questione.
L’hosting Aruba (così come molti altri) concedono un livello di protezione di tipo medio sui loro server, cosa che rende impossibile l’esecuzione di questo pattern. Viene generata una Security Exception. Exception Details: System.Security.SecurityException: That assembly does not allow partially trusted callers.

Il problema sembrerebbe aggirabile ricompilando gli assembly aggiungendo questa riga di codice [assembly:AllowPartiallyTrustedCallers], ma il team di sviluppo del famoso patter afferma che ciò non risolve la situazione. Al momento l’unica cosa da fare è votare la issue su codeplex in modo da portare all’attenzione degli sviluppatori questa problematica.

Il sistema migliore per sfruttare a pieno la web client software factory (WCSF),  così come spiegato nella documentazione ufficiale, è utilizzare degli oggetti business. Fatto sta che in alcuni casi (per vari motivi) potrebbe risultarci utile utilizzare i DataSet e non degli business object.  La mia intenzione, durante lo sviluppo di un web application project, era quella di utilizzare i dataset precedentemente “popolati” da alcune chiamate a stored procedures sul databse. Non sapendo esattamente come muovermi restando in linea con l’architettura della WCSF ho chiesto supporto su codeplex.

Dalla discussion è emerso che il miglior modo per implementare questa soluzione è quello di creare uno o più Foundational Module con il DataSet e successivamente esporre un servizio che permetta al resto dell’applicazione di utilizzare i dati.
Un esempio ben fatto è rappresentato da questo E-Commerce Catalog.

Il 21 settembre è stata rilasciata una nuova versione della Web Client Software Factory, versione di cui non è stato rilasciato un file di installazione. Per poterla utilizzare bisogna compilare il progetto Guidance Package, cosa che a me non ha funzionato. La nuova release ha rispetto alla vecchia il vantaggio di supportare AJAX, teconologia indispensabile per le applicazioni web al giorno d’oggi. Per chi, come me, non è riuscito ad installare la nuova versione esiste una soluzione alternativa: rendere la Web Client Software Factory June 2007 “AJAX enabled“.

Per fare ciò basterà creare un nuovo progestto ASP.NET AJAX e copiare nel web config della nostra WCSF le parti mancanti rispetto al web config del progetto appena creato. Per evitare di commettere errori per questa procedura consiglio vivamnete di seguire attentamente questo video.
Ringraziamento particolare per questa dritta va ad Antonio Menna

L’ErrorProvider: questo sconosciuto! Molti programmatori non conoscono questo strumento messo a disposizione da .NET. E ancora più spesso non sanno a quale evento o strumento associarlo. Una delle tante possibilità di utilizzo è quella di associare l’errorProvider ad una bindingSource. Facciamo subito un esempio. Abbiamo una bindingSource con una dataSource popolata da alcuni record (o anche da uno solo). Il nostro scopo è quello di creare un’ “anagrafica”, cioè prevedere l’inserimento di nuovi record nel database e per far questo abbiamo trascinato sulla nostra form l’origine dati in modo da ottenere le varie textbox già “bindate“. Ipotizziamo di avere un campo di tipo intero, cosa succede se l’utente digita un testo? Essendo lo strumento (textbox in questo caso, ma vale lo stesso per tutti gli altri) collegato al bindingSource accadrà che il focus resterà bloccato sulla textbox finchè non inseriamo un intero (a meno che non cambiamo l’evento su cui si genera la validation sulla form, ma non è il notro caso). L’utente non viene avvisato in alcun mod di cosa stia accandendo, e qui entra il gioco l’errorProvider che se associato alla bindingSouce farà apparire vicino al controllo l’icona di alert con un testo che segnala l’errore! Bisogna fare molta attenzione, perchè l’errorProvider, o meglio la validazione, ci segnalerà esclusivamente l’errore di input non corretto nel campo, quindi è opportuno gestire separatamente tutti gli altri casi.

In questi giorni, sul progetto che occupa la maggior parte della mia giornata, mi sono imbrattuto nella combobox. Questo strumento puo essere associato a diverse origi dati, una di queste è un enum.
Immaginate di avere una combobox chiamata MyCmb. Ora create un oggetto come questo
public enum Animali { Leone, Zebra, Gazzella };
Di default Leone avrà come value 0, Zebra 1 e Gazzella 2. Per cambiare il valore di partenza con cui contare basta fare così:
public enum Animali { Leone = 10, Zebra, Gazzella };

Lo scopo è quello di popolare la nostra comboBox:
MyCmb.DataSource = System.Enum.GetValues(typeof(Animali));

Per accedere al valore selezionato invece si procede in questo modo:
int valore = ((int)Enum.Parse(typeof(Animali), MyCmb.SelectedValue.ToString(), true));

[avhamazon wishlist="3NHMODHRFICUY" asin="0470187573" linktype="pic" locale="US"]

Per creare un nuovo progetto aprire Visual Studio 2005 Professional e create un new project. Tra i vari tipi di progetto scegliete “Guidance Packages” e poi “Smart Client Development May 2007“. Se tutto il necessario è stato installato correttamente dovrebbero apparire due nuovi modelli: Smart Client Application in C# e Smart Client Application in Visual Basic, come mostrato in questa immagine.

Non ci resta che definire il nome del progetto e il suo percorso. A questo punto una nuova winform del wizard di creazione progetto sarà visibile:

Qui definiamo il NameSpace e il percorso delle libreire  necessarie che in genere è C:\Programmi\Microsoft Smart Client Factory\Lib\

[avhamazon wishlist="3NHMODHRFICUY" asin="1590599551" linktype="pic" locale="US"]

Per poter cominciare a sviluppare un piccolo software simile ad Outlook, cioè con un workspace a sinistra che con eventi di tipo click ci fa apparire, su un altro workspace situato ora a destra, determinate viste è necessario installare sul proprio pc i seguenti software:

• Visual Studio 2005 Professional
• Microsoft Framework 3.0
• Enterprise Library January 2006
• Smart Client Software Factory May 2007
• Microsoft Practices Library e CompositeUI.Extensions

Credo che dovrebbe bastare, non metto i link relativi a tutte queste risorse (comunque facilmente reperibili) per il semplice fatto che mi sono state fornite fisicamente e quindi non le ho mai cercate in rete.

[avhamazon wishlist="3NHMODHRFICUY" asin="0321197690" linktype="pic" locale="US"]