Vamos a imaginar un sencillo método:

void Saludo(string nombre, int edad, string ciudad)
{
    Console.WriteLine("Hola me llamo {0} tengo {1} años y vivo en {2}", nombre, edad, ciudad);
}

¿Cómo se puede usar este método? Es una respuesta obvia ¿Verdad?:

Saludo("Jesus", 24, "Cádiz");

El problema es que quizá no te acuerdes de si primero pedia la edad o la ciudad… Eso si, sabes como se llaman los parámetros, entonces puedes hacer:

Saludo(nombre: "Jesus", edad: 24, ciudad: "Cádiz");

El resultado es sin duda más legible (aunque más redundante), también podemos hacer algo así:

Saludo(ciudad: "Cádiz", edad: 24, nombre: "Jesus");

Hemos variado el orden de los parámetros, pero como le hemos dado un nombre pues no hay problema en ello.

Ahora bien, por otro lado están los parámetros opcionales.

Por ejemplo, tenemos un método para insertar un elemento a una base de datos, por defecto los elementos van a la categoría Sin Categoría a menos que especifiquemos lo contrario:

static void InsertarElemento(string nombre, string categoria = "Sin Categoria", bool debug = false)
{
    if (debug)
        Console.WriteLine("Nombre: {0}\nCategoria: {1}", nombre, categoria);

    // Insertar en base de datos
}

Fijamos en la sintaxis del método, le hemos asignado un valor a un par de parámetros. Con esto queremos decirle que esos parámetros son opcionales, no tenemos por qué darles un valor al llamar al método, y en caso de no hacerlo usará esos valores asignados (el nombre sin embargo si es obligatorio), por ejemplo:

InsertarElemento("Canasta");

Con esto asignamos a la base de datos un elemento con el nombre Canasta y como categoría Sin Categoría.

¿Que queremos darle una categoria nosotros y ademas activar el modo debug?:

InsertarElemento("Canasta", "Mimbre", true);

Hemos asignado un valor nuevo a los dos parámetros opcionales, al estar el modo debug activado, antes de insertar el elemento en la base de datos, lo imprimirá:

Nombre: Canasta
Categoria: Mimbre

Lo bueno de esto es que podemos usar los parámetros opcionales y con nombre a la vez, por ejemplo, ¿Cómo podríamos activar el modo debug sin cambiar la categoría por defecto?

Tenemos que hacer uso de los parámetros con nombre, o sea:

InsertarElemento("Canasta", debug: true);

Nos hemos “saltado” el parámetro de la categoría gracias a los parámetros con nombre.

Esto imprimiría:

Nombre: Canasta
Categoria: Sin Categoria

Los parámetros opcionales y con nombre son muy útiles a la hora de trabajar con COM ya que estos métodos suelen recibir hasta una docena de parámetros opcionales y quizá solo uno importante… Antes teníamos que especificarlos todos, ahora simplemente podemos especificar el importante e ignorar el resto.

Diseño Ágil con TDD por Carlos Blé Jurado.

Con este libro aprenderemos a crear programas de calidad, a prueba de bombas e incluso con diseños más simples.

Como ya habréis supuesto, este libro nos enseña todo lo relacionado con el mundo de los tests, en concreto el mundo del Test-Drive Development (A partir de ahora TDD. El TDD es una técnica de desarrollo en la cual escribimos los tests antes que el propio código. Aunque pueda parecer chocante en un principio, gracias a esta técnica, conseguiremos una gran cantidad de mejoras en nuestro código que hará que amemos el TDD hasta el fin de los días

Ya que os he emocionado un poco con el TDD, paso a la reseña del libro.

El libro está dividido en dos partes, una parte teórica y una parte práctica, sin duda una buena combinación en un libro informático.

En la parte teórica Carlos hace un buen trabajo intentando poner sobre la mesa la teoría del TDD y todo lo que le rodea.

Nos cuenta qué es el agilismo y por qué gusta tanto a aquellos que lo prueban.

Después de ponernos los dientes largos, empieza a hablarnos de qué es el TDD y qué ventajas tiene frente al desarrollo tradicional.

Nos dá una pequeña introducción al ATDD para pasar a explicarnos qué tipos de tests hay y en qué ambitos nos ayudan.

¡Pero no solo eso! Todavía explica muchas más cosas, nos habla de qué frameworks tenemos a disposición para trabajar con tests, técnicas que se pueden usar para simplificarnos la vida o incluso nos recuerda los tan importantes principios del diseño orientado a objetos (que siempre viene bien recordar).

Por último, como en todo buen libro de informática, está la parte practica.

En la parte práctica vamos a poner practicar todo aquello que hemos aprendido en la parte teórica.

Para ello harémos un proyecto en C# donde aprenderemos a crear una aplicación desde 0 usando TDD. Por si esto fuera poco, luego portaremos esta aplicación a Python.

Termina el libro con unos cuantos consejos sobre antipatrones y los errores más comunes.

Vamos con algunas de sus cosas positivas:

• La parte teórica es más que correcta. Lo suficientemente simple para que no nos liemos con cosas que no nos interesan, y lo suficientemente complejo para que podamos ver todo lo aprendido.
• Poner un ejemplo en Python es más que acertado. No hay nada mejor que ver un ejemplo desde otro punto de vista para terminar de entender las cosas

Como ningún libro se salva de tener algun punto más negro, pues aquí vamos:

• Algún tema de la teoría puede ser dificil de agarrar en una primera lectura. Cosa lógica puesto que muchos de esos temas son para escribir un libro entero y no sólo un capítulo

Así que como punto final, si queréis introduciros en el mundo del TDD, éste libro ha de estar entre las primeras opciones.

Aquí os dejo la página del libro donde podéis comprarlo, descargar el pdf de forma gratuita y por qué no, donar algo al autor por su buen trabajo.

Página de Diseño Ágil con TDD

Hasta otra

He creado un cliente de Twitter, es un cliente sencillito que he hecho con el proposito de aprender y de divertirme un poco.

Os dejo una screen:

Mi primera intención era la de crear un artículo explicando paso por paso como crear un cliente Twitter, pero la verdad es que aunque simple el cliente, ha terminado con más código del que pensaba.

Aun así os daré algunos detalles para que cuando mirés el código pues sepais más o menos qué hace cada cosa.

No he usado ninguna librería concreta para desarrollar esta primera versión del cliente de Twitter. Simplemente he usado el REST API el cual es bastante limitado.

La clase TwitterClient es la que nos permitirá descargar nuestros Tweets y cambiar nuestro estado. No hace nada más. Cuando cambie la librería, añadiré más opciones a la interfaz de dicha clase sin modificar las opciones que ya hay.

Podeis observar que la clase lo que hace es descargar un XML con los tweets y parsearlos.

Por otro lado, podéis ver que la estructura del proyecto es MVP aunque le he añadido tambien la clase DelegateCommand para usar comandos siempre que sea posible.

Lo más complejo del proyecto es la UI, en la cual he usado Data Templates, Fake DataContext (Dos cosas que habéis aprendido aquí), además de un botón custom con una pequeña animación.

El código de la UI quizá sea un poco guarrete, pero es la primera aplicación que hago usando Blend 3 como aplicación de diseño principal.

Nada más, os dejo aquí el enlace a la aplicación:

TwitFox

Un saludo!

Este libro tiene una finalidad muy concreta, enseñar qué ofrece C# 2 y 3.
Al ser un libro avanzado, necesita que o bien seáis programadores de Java o bien que conozcáis C# 1 como mínimo.
Como ya he dicho, este libro es maravilla (sí, parece que todos los libros que leo son maravilla, eso o que pierdo mucho tiempo descartando libros para quedarme con uno decente ), aunque son solo 424 páginas, parecerá que son 2 mil, pues es muy denso.

El libro está dividido en 3 partes, cada una dedicada a las 3 versiones de C# que hay .

Parte 1:
Ya he dicho que este libro se centra en la versión 2 y 3 de C#, pero aun así, el autor quiere dedicar un poco de tiempo a hablarnos de lo que nos ofreció C# cuando nació y además de hacernos ver las cosas que se hacían mal en C# 1 y como C# 2 y 3 nos ofrecen una mejor alternativa para esos casos concretos.
Por otro lado, esta parte empieza con lo típico y es que parece que ningún autor es capaz de resistir la tentación de poner la historia de C#, .NET y toda la pesca.
Después de este aburrido capítulo, empieza ya lo interesante.
Nos recordará algunas cosas básicas de C# para posteriormente mostrarnos que esas cosas maravillosas que usábamos, apestan y que ahora tenemos mejores formas de hacerlo. Básicamente lo que el autor quiere aquí es ponerte los dientes largos mostrándote por ejemplo como molan las Lambdas.

Parte 2:
Ésta parte, titulada “Resolviendo los problemas de C# 1” se centrará en C# 2, el cual tiene jugosas novedades que hará que nuestro código C# sea mucho mejor .
Nos hablará de la necesidad de los genéricos aunque también de sus limitaciones.
También abordará sobre los tipos ‘nullables’, lo cual nos ayudará cuando tratemos con bases de datos.
Veremos cómo implementar mejores delegados gracias a los métodos anónimos.
Un poco de iteradores también y para terminar un conjunto de cosas no menos importantes.

Parte 3:
Esta parte es igual a la anterior, más features pero esta vez las de C# 3.
Tipos anónimos, inicialización simplificada, lambda, métodos de extensión (extension methods) y sobre todo…. LINQ.
Ahora es cuando os emocionáis como yo y decís, uhm ¡LINQ!. Después de más de 300 páginas leídas, viene quizá lo más interesante.
Siento desilusionaros, porque para mí, este es el punto flojo del libro. ¿Por qué? Intenta en poco menos de 100 páginas, explicarnos todo LINQ to Objects, SQL, XML, DataSet pero intenta hacerlo de forma muy bruta ya que intenta meterte ahí con calzador toda la teoría detrás de LINQ la cual no es fácil de digerir.
Yo entiendo que en 100 páginas no se puede explicar todo LINQ, pero yo lo habría dejado en una explicación básica o directamente lo hubiese sacado del libro.
Para aprender LINQ hay otro libro de esta misma casa que ya reseñaré más adelante.

Conclusión:
En conclusión, este libro es la mejor manera para llegar a dominar lo que se dice TODO C#, eso sí, es aburridísimo como habréis podido notar de mi reseña… No deja de ser escupir features una tras otra sin cesar. Aun así, lo hace una forma magistral, fácil de entender y sobretodo fácil de digerir.

Sin más preámbulos:

Positivo:

• Nos hace ver lo que hacemos mal y cómo mejorarlo.
• Explica todas las features del lenguaje en su versión 2 y 3.
• Los ejemplos de código, aunque de juguete, son muy claros.
• No deja nada sin explicar, tiene respuesta a todo.

Negativo:

• La parte de LINQ, sobraba, muy difícil de asimilar.
• Algunas partes muy concretas son duras y difíciles de entender (Lease expression trees).

La nota será de 9.8. Le habría dado más puntos si hubiese quitado la parte de LINQ, puesto que solo hace confundir, y ya lo hubiese rematado si hubiese encontrado una forma de explicar los ‘Expression trees’ de una forma entendible.
Si os termináis de leer este libro, probablemente el próximo a la cola sería el de Linq In Action, ya que explica LINQ de forma magistral y hasta los ‘Expression trees’ los explica bien jeje.

Bueno, os dejo el enlace a la página oficial del libro:

Link

Un saludo,
Fox

Siento no escribir tanto como me gustaría, pero estuve de exámenes hace poco, y ahora he empezado a trabajar.

Bueno, antes de dichos exámenes escribí una nueva versión del Apunta Notas y la anucio por aquí para que la probeis.

Dicha versión tiene:

• Ahora al borrar una categoría te da la opción de borrar todas las notas asociadas a ella.
• Si decides no borrar dichas notas, se enviarán a una categoría oculta llamada “Papelera”.
• Ahora al pulsar intro se añadirá la nota automaticamente (antes no me funcionaba por un pequeño bug que no veía)
• Los rectangulos de los colores también son botones para seleccionar el color
• Algun bug solucionado

Quizá se me olvide algo, pero ahora no caigo, realmente metí muchas mejoras a lo largo de 2 dias de trabajo con el.

Los enlaces están donde siempre

A ver si este fin de semana puedo hacer algo más interesante.

Pues aquí estoy orgulloso de presentaros la nueva versión de mi programa de notas. Como veréis a continuación, el cambio es significativo:

Como podéis ver, ahora soporta distintas categorías y estas, distintos colores.

No sólo eso, si no que además podeis ampliar el tamaño de las notas por si quereis verla desde lejos del monitor[1]:

También tiene un editor de categorías donde podrás modificar todos los apartados de éstas como podéis ver aquí:

Como veis, podeis cambiar el nombre, color de fondo, color de texto… y además podéis ver una vista prévia de la nota para ver como quedará.

Para más detalles y descarga podéis visitar la página de Apunta Notas 2.

[1]: Yo personalmente apunto las cosas que le quiero comentar a mi novia y cuando la llamo me tumbo en la cama, así que pongo las notas bien grandecitas y así las veo desde allí

Estáis deseosos de aprender más maravillas de WPF, ¿verdad? Pues nada, aquí os traigo algo muy util que os podría venir bien para vuestros propios desarrollos.

Empezamos con la gran pregunta:

¿Qué son los Data Templates?

Imagina que tienes una clase llamada Persona, Animales, etc. y queréis representar instancias de dichas clases visualmente en vuestro programa, el problema como ya sabes es que dichas clases no tienen ninguna representación visual, con lo cual el resultado de ligar una instancia (o una lista de instancias) a un control como por ejemplo un ItemsControl sería el de llamar al método ToString de la instancia lo que nos da un resultado pésimo.

¿Qué podemos al respecto? Pues lo que estabas pensando si, usar Data Templates.

¡Al turrón!

Creamos un nuevo proyecto llamado Data Templates y creamos una clase llamada Personas, dicha clase contendrá este código:

public class Persona
{
    public string Nombre {get; set; }
    public string Direccion { get; set; }
    public string Telefono { get; set; }
    public int Edad { get; set; }
    public string Sexo { get; set; }
    public string UrlImagen { get; set; }
    public string Color { get; set; }

    public Persona(string nombre, string direccion, string telefono,
                    int edad, string sexo)
    {
        Nombre = nombre;
        Direccion = direccion;
        Telefono = telefono;
        Edad = edad;
        Sexo = sexo;

        if (Sexo.Equals("Hombre"))
        {
            Color = "#bcebf9";
            UrlImagen = "Imagenes\\hombre.png";
        }
        else
        {
            Color = "#f8c2cd";
            UrlImagen = "Imagenes\\mujer.png";
        }
    }

    public override string ToString()
    {
        return string.Format("Hola me llamo {0}, vivo en {1}, mi telefono es {2}, tengo {3} años y soy {4}", Nombre, Direccion, Telefono, Edad, Sexo);
    }
}

Nada aquí que os vaya a sorprender, una clase Persona, que aunque bastante mejorable, va de sobra para nuestro ejemplo. Puntualizo un par de cosas:

Ignorad por ahora el tema de las imagenes y el color, eso se usará más adelante (también meteremos las imagenes más adelante en el proyecto)
El método ToString solo es para ver como quedaría la cosa sin Data Templates y luego se borrará.

Ahora creamos una clase llamada Presenter y le añadimos el siguiente código:

class Presenter
{
    private List<Persona> listaPersonas;

    public Presenter()
    {
        listaPersonas = new List<Persona>();

        listaPersonas.Add(new Persona("Jesus", "Calle 13", "132456789", 23, "Hombre"));
        listaPersonas.Add(new Persona("Rosi", "Big street 15", "987654321", 27, "Mujer"));
        listaPersonas.Add(new Persona("Álvaro", "To lejos street", "147258369", 24, "Hombre"));
    }

    public List<Persona> ListaPersonas
    {
        get { return listaPersonas; }
        set { listaPersonas = value; }
    }
}

Una clase normal y corriente, simplemente creamos una lista de personas y añadimos algunos ejemplos de personas.

Ahora abrimos el code-behind de la ventana (Windows1.xaml) y modificamos el constructor para que quede de esta manera:

public Window1()
{
    InitializeComponent();
    DataContext = new Presenter();
}

Y ahora, abrimos la ventana en sí y colocamos este markup:

<Window x:Class="DataTemplates.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Data Templates" Height="600" Width="600">
    <ItemsControl ItemsSource="{Binding ListaPersonas}">

    </ItemsControl>
</Window>

Aquí simplemente añadimos un ItemsControl vacío al que le ligamos la lista que hemos creado anteriormente.

Ahora ejecutamos la aplicación y vemos el resultado:

Como podeis ver, apesta, es lo más cutre “ever seen”, así que vamos a arreglarlo usando los Data Templates.

Antes que nada, me gustaría explicar una cosilla para que no os lieis tanto:

Hay 2 clases bases para los controles, por un lado tenemos la clase ContentControl de la cual heredarán aquellos controles que solo tienen una pieza de contenido, como button, Label, etc.
Por otro lado tenemos la clase ItemsControl de la cual heredarán aquellos controles que muestran una colección de items, como TreeView, ListBox, etc.

Si con la funcionalidad básica que nos ofrecen dichas clases bases vamos bien, no tenemos por qué usar ninguna hija, y en este caso como habeis visto, hemos usado simplemente un ItemsControl pues es todo lo que necesitamos.

Bueno, al grano, si queremos usar los Data Templates, lo unico que debemos hacer es decirle al control, en este caso el ItemsControl, que vamos a definir el aspecto de cada item del control, ¿Cómo? Así:

<ItemsControl ItemsSource="{Binding ListaPersonas}">
    <ItemsControl.ItemTemplate>
		<DataTemplate>
			...
		</DataTemplate>
	</ItemsControl.ItemTemplate>
</ItemsControl>

Ahí, donde están los puntos suspensivos pues añadimos todo el xaml necesario para lograr el aspecto que queramos. Recordad que estamos definiendo el aspecto de UN solo item y no de toda la colección a la vez, así que ahi escribimos como queremos que se vea cada item y ya se aplicará para todos los items de la lista.

Así que sabiendo esto, vamos a modificar nuestro ejemplo.

Para empezar, puedes borrar el ToString de la clase Personas que ya no nos vale, una vez hecho esto, creamos el directorio Imagenes dentro del proyecto y ahi metemos las dos imágenes que voy a adjuntar a continuación (boton derecho -> guardar como):

Ya lo único que nos queda es modificar el ItemsControl añadiendole el template de cómo queremos que se represente cada instancia de la clase.

El código de la ventana quedaría así:

<Window x:Class="DataTemplates.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Data Templates" Height="600" Width="600"
    Background="#f8fffb">
    <ItemsControl ItemsSource="{Binding ListaPersonas}">
        <ItemsControl.ItemTemplate>
            <DataTemplate>
                <Border BorderBrush="#4f9d70" BorderThickness="2"
                        Margin="5" Padding="2.5">
                    <Grid Background="{Binding Color}">
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="auto" />
                            <ColumnDefinition Width="auto" />
                            <ColumnDefinition Width="*" />
                        </Grid.ColumnDefinitions>
                        <Grid.RowDefinitions>
                            <RowDefinition Height="auto" />
                            <RowDefinition Height="auto" />
                            <RowDefinition Height="auto" />
                            <RowDefinition Height="auto" />
                        </Grid.RowDefinitions>
                        <Border BorderBrush="#4f9d70"  BorderThickness="1"
                                Margin="2.5" Grid.RowSpan="4">
                            <Image Source="{Binding UrlImagen}" />
                        </Border>
                        <TextBlock Text="Nombre: " FontSize="20" FontWeight="Bold" Grid.Column="1" />
                        <TextBlock Text="{Binding Nombre}" FontSize="20" Grid.Column="2" />

                        <TextBlock Text="Dirección: " FontSize="20" FontWeight="Bold" Grid.Column="1" Grid.Row="1" />
                        <TextBlock Text="{Binding Direccion}" FontSize="20" Grid.Column="2" Grid.Row="1" />

                        <TextBlock Text="Teléfono: " FontSize="20" FontWeight="Bold" Grid.Column="1" Grid.Row="2" />
                        <TextBlock Text="{Binding Telefono}" FontSize="20" Grid.Column="2" Grid.Row="2" />

                        <TextBlock Text="Edad: " FontSize="20" FontWeight="Bold" Grid.Column="1" Grid.Row="3" />
                        <TextBlock Text="{Binding Edad}" FontSize="20" Grid.Column="2" Grid.Row="3" />
                    </Grid>
                </Border>
            </DataTemplate>
        </ItemsControl.ItemTemplate>
    </ItemsControl>
</Window>

Bueno, aunque os de miedo al principio, el código es bastante facilón.

Añadimos un borde y dentro pues un grid y dentro de dicho grid colocamos los controles para representar los datos.

Aquí muy importante decir, que el DataContext dentro del DataTemplate será la instancia del objeto con el que estamos tratando, así que por ejemplo:

<TextBlock Text="{Binding Nombre}" FontSize="20" Grid.Column="2" />

Aqui con Nombre no nos estamos refiriendo a una propiedad llamada Nombre dentro de Presenter (el DataContext de la ventana), si no a la propiedad Nombre de las instancias de Persona que tiene la lista.

Ahora estáis viendo el uso que le doy a la propiedad Color dentro de la clase Persona, lo uso para definir el color de fondo del item. Sé que no debería añadir esta propiedad dentro de la clase, pero lo hago con motivos ilustrativos simplemente.

Creo que aquí no hay más nada que requiera de una explicación, aunque si os dejaré una screenshot para aquellos que no estén escribiendo el ejemplo en sus ordenadores.

Bueno, creo que no se me olvida nada, ahora solo queda esperar vuestros comentarios para ver que os ha parecido el artículo.

Os adjunto el proyecto : DataTemplates.rar

El primer programa que voy a colocar será “Apunta Notas”, aquí os dejo una captura:

Apunta notas es un sencillito programa para eso mismo, escribir notas.

Está escrito usando C# y WPF.

Para más información, haced click en la pestaña “Mis programas” arriba en la web o bien haced click directamente aquí:

Información Apunta Notas

Espero vuestros comentarios.

Saludos,
Fox

También me gustaría disculparme, puesto que la mayoría de libros que analizaré serán en inglés, puesto que la gran mayoría de documentación está en dicho idioma, y si quereis ser informáticos, en inglés es un requisito obligatorio.

El honor de mi primera reseña lo tendrá un libro de la que es mi colección favorita, “Head First”, en concreto “Head First C#”.

Antes que nada, para aquellos que no conozcan los libros de “Head First”, decir que son unos libros que se centran en introducirte en una materia, pero sin llegar a profundizar demasiado, pero lo justo y necesario como para poder desenvolverte en la materia. Entonces… ¿Por qué Head First? Puesto que no verás un libro de programación igual, estos están lleno de dibujitos y ejemplos muy graciosos tales como el de “Mi perro ha sido abducido por unos aliens, ¿Lo habeis visto?” (Este del libro de PHP).

Yo tengo un dicho: “Materia que explican los libros de Head First, materia que entiendes”. Lo explican de tal forma, con unos ejemplos tan tan sencillos y simpáticos, que no hay forma de que no te enteres de lo que están explicando. Bueno, no me enrollo más y vamos al lio.

Head First C#, tales como el resto de libros de la serie “Head First”, se presenta como un libro de iniciación a C#, aunque eso si, necesitarías una pequeña base ya que no se dedica a explicar las estructuras básicas de control ni nada de eso. Directamente se centra en QUE ofrece C#.

Empieza con un motivador capítulo para aquellos nuevos a .NET puesto que te pone un ejemplo de como crear una base de datos (usando SQL server), crear las tablas, los datos…. Y posteriormente, un formulario donde simplemente arrastras la tabla a este, y aparecen los campos de dicha tabla en el formulario. Ahi directamente podrás insertar, modificar y borrar los datos… Y eso con 2 líneas de código. El capítulo termina enseñandote a crear un paquete de la aplicación y publicarla. Vamos, un muy buen comienzo para ir abriendo boca de lo que Visual Studio te ofrece.

El resto de capitulos ya están más centrados en lo que C# ofrece. Si bien es cierto que el libro explica C# 3.5, explica más bien lo básico de C# como para poder empezar a hacer tus propias creaciones.

Esto quiere decir que no vais a ver nada sobre atributos, threads y alguna cosa más avanzada o quizá menos usada como reflexión. Sin embargo, si hay una pequeña introducción a LINQ.

También ponen algún tema sobre GDI+, lo cual puede pareceros interesantes a aquellos que useis Windows Forms, pero no para aquellos que sean de WPF.

Lo buenísimo de este libro, es que a lo largo del este te incita a hacer 3 programas, de los cuales te da el material necesario para desarrollarlo (como imágenes), pero no te ofrece el código fuente. De hecho, en su día hicieron un concurso para ver quien los implementaba mejor.

No son los típicos programas aburridos, si no programas que te gustaría hacer, puesto que son muy divertidos.

En el primer programa, te hacen programar un simulador de apuestas de carrera de caballos, pero con animaciones y todo! Vamos, te salen los caballos pintados por pantalla corriendo hasta la meta!

En el segundo, te piden hacer un pequeño juego de aventura visto desde arriba donde un pequeño personajillo se va moviendo haciendo click en unos botones, incluso pega a los bichos.

Y en el tercero, es un pequeño clon de Space Invaders, el cual imagino que todos conocereis

Paso a destacar lo que yo considero los aspectos negativos y positivos:

Positivo:

• Es Head First, con lo que todo ello conlleva.

• Los programas que te piden hacer son divertidos de programar.

• Conseguirás tener un conocimiento de C# bastante decente.

• El primer capítulo os motivará con la plataforma .NET

Negativo:

• No explica algunos conceptos más avanzados del lenguaje

• Requiere al menos un conocimiento básico de programación

Como libro de introducción a C# está muy bien, te divertirás mucho con el, asegurado.

Como nota le daría un 7,5/10 ya que podría explicar algunas de las cosas más dificiles como threads, al estilo Head First.

Os dejo unos cuantos enlaces:

Página web del libro
Capítulo de ejemplo