dissabte, 31 d’agost de 2013

Múltiples plataformes amb Visual Studio

Si recordem estàvem creant un dau fa uns quants posts (m'ha pillat vacances, i les vacances, vacances són ;)). Ara anem a aprofitar el projecte que teníem  que simplement era test i la classe dau, i anem a afegir un nou projecte, per exemple Windows phone: (Botó dret sobre la solució i afegir nou projecte) seleccionem Windows phone:

Afegim un botó que quan fem click cree un dau, i mostre el número. Haurem de referenciar els projectes Project->Add Reference, seleccionar projecte i posem el projecte dau per a poder crear el dau, a banda de es recomanable que tot tinga el mateix namespace, si no haurem d'anar afegint usings.
Es possible que si actualitzeu els namespaces vos done problemes. Haureu també de canviar-ho als arxius .xaml:x:Class="RollDice.App ...

on RollDice és el nom del namespace. Afegim un botó, i un event capturador de l'event:
private void Button_Click_1(object sender, RoutedEventArgs e)
{
            Dau d = new Dau(10);
            int res = d.Tirada();
            MessageBox.Show(res.ToString());
}
I veiem el resultat:
 
Ara anem a fer el mateix amb Android, crearem un projecte Android:



El que anem a fer és substituir el codi de la funció delegada per capturar l'event que hi ha, per un codi similar al que tenien en la funció anterior. Però abans cal enllaçar la classe dau. En principi i en teoria a l'haver fet una biblioteca de classes podriem fer-ho directament afegint al projecte d'Android una referència al projecte Dau, però com hi ha un problema de moment (en teoria estan a punt d'arreglar-ho), anem a fer una xapusa i anem a enllaçar l'arxiu (afegir arxiu existent) de la classe dau.cs i així ho tindrem arreglat.  Una vegada ho tenim, canviem el codi de l'event Click per:
button.Click += delegate {
RollDice.Dau d = new RollDice.Dau(10);
int res = d.Tirada();
button = FindViewById<Button>(Resource.Id.MyButton);
button.Text = res.ToString();
};
 




Arranquem, ens dirà que seleccionem la imatge de l'emulador i tal, i després d'un ratet (la primera vegada ha d'instal·lar tot el framework .net a l'emulador):

 
I ja hem vist com gastar el mateix codi per a Android i per a Windows Phone ;)

Xamarin Studio

Hem va quedar pendent, fa dos posts, explicar com fer una solución en VS multiplataforma. Per a explicar-ho el primer que necessite és un framework multiplataforma. He elegit Xamarin, podía haver elegit qualsevol altre, però este em permet escriure en C# tot el codi, davall el paraigüa de Mono. Si només vols fer programes sense reutilitzar cap component extern ni res, la versió és gratuïta. Si per exemple vols fer jocs i utilitzar Monogame (port de XNA per a moltes plataformes) ahí has d'adquirir alguna versió de pago. També pot ser que vullgues utilitzar VS per a fer programes en Android amb C#....  Doncs hauràs de pagar mínim 300$ per desenvolupador per plataforma mínim. Pot parèixer un poc car, però si vas a dedicar-te professionalment a desenvolupar aplicacions per a móbil no tens més remei (d'este o d'altre similar). M'explique, imaginem que vas a fer un programa per a mòbils i vols fer-ho per a les plataformes més gastades (Windows phone, Iphone i Android). Tens dos opcions o escriure TOT el programa en C#, Objective C i Java (respectivament), i adaptar-te a les particularitats de cada plataforma o escriure tota la lògica en C# (en este exemple) i adaptar la part gràfica (interfície) a cada plataforma.
Aprofitant que sóc professor (;), ho vaig haver de demostrar) he adquirit la versió educacional per 100$ cada plataforma. La instal·lació és molt senzilla, anem a WWW.xamarin.com i baixem l'instal·lador. Segons el compte que tingam (si hem pagat o no) ens instal·larà unes coses o unes altres, però l'avantatja que instal·la tots els requisits. Si teniu  una connexió de risa com jo (3 MB )  estarà un ratet baixant coses (algunes hores) i s'instal·larà els pluggins per al VS (si el teniu instal·lat i si teniu una versió que no siga la express, ja que no permet instal·lar plugin) .
I amb això ja estaríem llestos per al següent post ;)

Val a dir que la comunitat de Xamarin és una comunitat prou activa. Et permet comprar components, té un fòrum de suport, organitzen webminaris (seminaris online)... A mi m'ha agradat l'experiència.

divendres, 30 d’agost de 2013

Presumint d'ordinador

Mira que m'agrada presumir de ben poques coses. De fet em considere (i em solen considerar) una persona ben modesta. Però ara no me n'he pogut estar... Vaig a presumir d'ordinador:


Vaig a sustituir el meu ordinador de sobretaula (amb le stres pantalles) per este bitxet. No està mal, eh?
Especificacions:

  • i7 3610QM
  • 8GB de RAM (ampliables a 32)
  • 128 GB SSD (si no teniu disc SSD vos ho recomane abans de canviar de PC)
  • 500 GB de disc mecànic
  • ATI 7970M  2GB (casinà ;))
Això si ho he fet de segona mà, i el problema és que ara no puc fer-li ni una extensió de garantia ni assegurar-lo (no trobe en cap lloc que ho vullguen fer).
Però és una filigrana... estic escrivint este post des d'una màquina virtual, sense apenes drivers i MacOS va com el llamp. (No, no m'estic passant a MacOS, però per a fer aplicacions per a iphone/ipad/macos no tens un altre remei).

Em queda fer algun test en algun joc, de moment, el heaven engine trau uns 40-50fps, mentres que la torre vella, apenes passava de 15 (en la versió actual, clar). Tots els emuladors de mòbil van a la perfecció... no sé què més puc demar  (a banda de tindre temps per a disfrutar-lo)

diumenge, 11 d’agost de 2013

TDDs + reutilització d'objectes en Visual Studio 2012

Doncs això, mai m'he mostrat partidari de cap metodologia de programació, ni tan sols de la programació orientada a objectes... però deu ser que em faig major ;) Anem a matar en un post dos pardals d'un tir. Anem a gastar una de les bases de les metodologies àgils (en realitat no té per què, es pot emprar en qualsevol metodologia) i anem a començar a veure com fer codi "multiplataforma".
Anem a gastar Visual Studio 2012. Creem una solució de Portable Class Library (en C#):
Creem una nova classe, Dau:
namespace RollDice
{
    public class Dau
    {

    }
Sense cap mètode. Per què sense cap mètode? Ahí està la gràcia dels TDD (Test Driven Development, Desenvolupament Orientat a Test). Anirem omplint la classe segons fallen els tests.
Ara anem a afegir una nova solució, què serà de test c#:
Ens crearà una classe de test buida, li canviarem el namespace per a que siga el mateix que la classe dau:
[TestClass]
    public class testDau
    {

         [TestMethod]
         public void TestMethod1(){
        }
    }

De moment només ens interessa saber que el mètode que hi haja darrere de cada [TesMethod] Serà un test, ens eixirà a la finestra de tests (després veurem).
Què és el primer que hem de comprovar? Que li fa falta a un dau? El nombre de cares, no? Si no heu jugat a rol, possiblement no ho entendreu ;)
canviem el nom al test, per a que siga més encertat, creem un dau amb 4 cares i comprovem que realment les tinga quan es crea, per a això ens caldrà afegir una variable privada dau:
 private Dau dau;
 [TestMethod]
        public void TestCares()
        {
            dau = new Dau(4);
            Assert.AreEqual(4, dau.getCares);           
        }

Anem a pams, el primer que passa és què això no compila, la classe Dau està buida i no té cap mètode, fem que compile, afegim a la classe dau el constructor i la propietat cares:
 public Dau(int cares)
        {
            getCares = cares;
        }       
        public int getCares {  get; private set; }

 Ara que compila anem a veure que fa el test. Crea un dau de 4 cares, i el test passarà (les condicions de passar el test es fan amb les instruccions Assert) si efectivament el test és de 4 cares.  Seleccionem el menu Test->Run All Test

Si el test passa veurem un check verd, si no passa, veureu una aspa roja,comproveu-ho posant:
  Assert.AreEqual(5, dau.getCares);

Una vegada ja tenim comprovat que el constructor funciona, anem a acabar el dau. Què li falta? Tirar, l'opció de tirar. Abans de programar el codi, recordeu, hem de fer el test; afegim a la classe de test:
 [TestMethod]
        public void TestTirades()
        {
                dau = new Dau(10);
                 int tirada = dau.Tirada();
                Assert.IsTrue(tirada <= 10);
                Assert.IsTrue(tirada >= 1);
          }

      
en este exemple, creem un dau de 10 cares, el llancem, i comprovem que la tirada estiga entre 1 i el nombre de cares. Com no compilarà, creem el mètode a la classe dau:
  public int Tirada()
        {
            Random random = new Random();
            return random.Next(1, getCares);
        }

Vejam que el test passa. Òbviament este test, només serà vàlid per a 10 cares, res ens impedix fer este test:

 [TestMethod]
        public void TestTirades()
        {
          
            for (int i = 1; i <= 20; i++)
            {
                dau = new Dau(i);
                int tirada = dau.Tirada();
                Assert.IsTrue(tirada <= i);
                Assert.IsTrue(tirada >= 1);
            }
        }

 I així hauriem comprovat que els daus, almenys fins a 20 cares, funcionen ;). Doncs això és el TDD, primer realitzar quins tests ha de passar (incloent limits de vectors, entrades extranyes, si llança excepcions...)
A propers posts continuarem el projecte afegint múltiples configuracions per al projecte