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.