Incluso Virtual Box me ha fallado en ocasiones hasta que por fin he conseguido hacerlo funcionar. Para ello, (en mi caso), he tenido que asignarle 4 Gb de Ram / 40Gb de Hdd / 2 Cores. Quizá funcione con menos, pero por lo menos con esto ha funcionado a la perfeccion.

Creo que el problema inicial que tenía anteriormente es la asignacion del disco duro, asignaba 20Gb y después de instalarlo ocupa 25Gb. ¿Significa que no hace ciertas comprobaciones de hardware? (probablemente no).

La primera impresión que me llevo es que es similar a Windows phone pero tiene la posibilidad de poder ver el escritorio al igual que Windows 7 (mas bien parece una version de windows 7 con algunas mejoras, sobre todo en el arranque).
Hace tiempo leí que no se podría manejar el sistema de ficheros tal como lo conocemos hoy día, parece que eso es algo infundado (el menos tal y como lo veo ahora mismo).
El menú inicial (metro) parece que se puede remover fácilmente y sin problema al menos no se queja, aunque me da la impresion que todo se acabará basando en esto. Ademas veremos cuando los fabricantes de hardware instalen su secure BIOS que sucede con todo esto.

Por otro lado, me preocupa no poder ver las herramientas ni los programas instalados en la barra de inicio, no me queda claro aun como será este sistema (por otros artículos que leí no hace mucho).

Adjunto un pantallazo como una primera vista de lo que puede ser Windows 8.

Voy a lo que nos interesa, al menos en este blog, la programación.

Esta versión concretamente incluye Visual Studio 2011, en primer momento pensé que se podría programar para Windows phone, pero he visto que no, probablemente requiera plugins para ello.
Las plantillas que incluye son cuanto más curiosas. Adjunto un pantallazo de la ventana de inicio.

Por último, he intentado instalar VC++ 6 debido a otra de las cosas que leí hace algún tiempo sobre la programación en código nativo. Solamente puedo decir que ha petado y no me deja instalarlo. Lo haré portable y lo probaré por curiosidad y la curiosidad de aquellos que siguen programando en lenguajes un tanto antiguos pero se resisten a cambiar como el VB6 (Por ejemplo).

Ya veremos dentro de unos meses que sucede…
 

Saludos.

Después de estar un rato configurando reiniciando y demás, he descubierto que el Blue Screen de Windows 8 es más chulo. Adjunto el pantallazo y a ver si después de dentro de un rato probando puedo hacer que arranque en el ordenador.

He probado varias configuraciones con VmWare y no parece funcionar, ademas, he seguido varios post que hablan del tema pero, nada. Asi que cuando configure una particion para meter windows 8 volveré a escribir otro post…

Saludos.

Para comenzar a usar nuestra pequeña camara en el Pc basta con que descarguemos de la página oficial el SDK, son aproximadamente unos 20 megas. Este es el link. Después de instalarlo, ya tenemos todo preparado, recordar que para poder usarlo necesitamos tener tanto Windows 7, como Visual Studio 2010, no importa si es una versión express.

Dentro de la carpeta que acabamos de instalar podremos encontrar varios ejemplos, en C++ o en C#. Parece que Microsoft poco a poco se despide de dar soporte en Visual Basic. Los ejemplos, nos permiten tanto ver el esqueleto de nuestro cuerpo, como grabar sonidos, mandar comandos de voz,  etc.  Los ejemplos vienen realmente completos.

Pero veamos por nosotros mismos que contiene la SDK. Se compone de dos espacios de nombre, relativamente sencillo, la de audio solo contiene la posibilidad de capturar sonido y donde realmente se han esforzado los de Redmon es con el NUI.  Aún no he podido realizar nada, pero sinceramente por lo que se puede ver, han creado la SDK relativamente simple, pero con bastante potencia para aprovechar todo el rendimiento que nos da el aparatito.

Esperemos que se realicen todavia más proyectos, como los que se estaban viendo con las librerias independientes. En los proximos días intentare subir alguna aplicación facilita hecha por mí, para comenzar a utilizar el Kinect en nuestros ordenadores.

Saludos.

Ante todo, pido disculpas por mi falta de actualización en el blog, aunque mis compañeros de bitacoras hayan escrito, estamos bajando el ritmo de actualización y eso es algo que sabemos y no nos gusta. Pero escribir un documento de este tipo, suele ser algo que requiera de un rato que usar.

Bueno, hoy voy a hablar de una de las mejoras del nuevo Framework 4.0. Aunque en más de un medio se haya hablado de ello, creo que no hay demasiados artículos en español que hablen al respecto, me refiero a los Dynamics.

El tipo Dynamic es un tipo de dato que es completamente maleable. Parafraseando a Bruce Lee, Be water my friend. Que queremos decir con esto; pues que cualquier variable que declaremos como dynamic se comportara de una manera maleable, pudiendo tomar distintas formas: un string, un entero, un tipo double, etc.

Podremos pensar que este tipo de dato puede ser funcional, pero no es interesante abusar de estos ya que su funcionamiento no puede ser el que quisieramos, además de que aumenta el uso de memoria.

La manera de declarar un tipo dynamic es muy sencilla, es así:

dynamic variabledinamica;

El dato se modificara según el valor que contega, podemos verificar de que tipo de dato es, usando el método GetType(). Ya que el intelisense de Visual Studio no funcionara, la razón, es muy sencilla, no tenemos anunciado el tipo de clase de la que se trata. Ojo, debemos tener cuidado, si fuesemos a acceder a un método, el cual no existiese en esa clase, se producirá una excepción.

Como comentabamos, al usar el método GetType() para obtener el tipo de dato del que se trata, nos dara un valor diferente según el tipo de dato del que se trate. Veamoslo con un ejemplo:

dynamic variabledinamica = “2″;

Console.Writeline(variabledinamica.GetType().ToString()); //Nos devolvera System.String

variabledinamica = 2;

Console.Writeline(variabledinamica.GetType().ToString()); //En este caso nos devolverá un System.Int32

variabledinamica = 2.2;

Console.Writeline(variabledinamica.GetType().ToString()); //Se mostrara un System.Double

Otro de los potenciales que tiene dynamic, es que podemos declarar colecciones genericas, por lo tanto tendremos colecciones de dinamics, lo que conlleva que podremos introducir todo tipo de objetos dentro de esa colección, desde nuestras propias clases como, clases convencionales.

Ahora pasaremos a los inconvenientes que veo con los dynamics, el uso de estos debe hacerse con extremo cuidado, la manera de actuar de los dynamics puede tener un funcionamiento que vaya en contra nuestra. Por ejemplo, si tenemos dos variables dynamic, una que contenta un valor de string y otra de un entero, tal vez querramos que se haga una suma, mientras se concatene como si fuesen cadenas.

Si no sabemos usarla con conciencia, nos puede generar errores, porque nos ingrese tipos de datos que no deseamos en esa operación.

Tampoco podemos abusar de ellos, el uso de memoria es mayor que una variable convencional, por las pruebas realizadas, unas cinco veces más que con variables estandar.

Hasta aquí, este pequeño post de los dynamics. No debemos abusar del uso de estos por los inconvenientes que hemos indicado, el aumento del consumo de memoria por su parte y que el funcionamiento es arbitrario. No obstante, nos podemos encontrar con problemas de diseño dentro de nuestras aplicaciones en los cuales la única manera de solventarlos sea de esta.

Un saludo.

Lo primero es explicar la diferencia entre un For y un For Each, para esto nos ayudamos para esto de la wikipedia:

For: Es una estructura de control en la que podemos indicar un numero máximo de iteraciones

PARA i := 0 a CantidadRegistros(tabla) - 1, PASO = 1
 PróximoRegistro(tabla)
 HacerAlgo(ElementoActual(tabla))
FIN PARA

For Each: Este bucle es una evolución del concepto del bucle Para en algunos lenguajes. Se utiliza para recorrer estructuras repetitivas de datos de forma más simple y ágil

POR CADA x DE tipo EN Vector HACER
 x = AlgunaOperación(x)
FIN PARA

Como vemos, y según nuestra wikipedia el bucle for each es realmente útil sobre todo para su uso en colecciones

Si lo vemos así, parece que las diferencia son obvias. Pero veamos con mayor profundidad:

Midiendo el tiempo de ejecución de un ejemplo:

He creado un ejemplo en c# con los dos For. Ademas, utilizo el espacio de nombres de System.Diagnostic para poder hacer una medición de tiempo de ejecución mediante la clase StopWatch. Pego el ejemplo a continuación y posteriormente los resultados.

        private void button1_Click(object sender, EventArgs e)
        {
            string []prueba = new string[256];
            string prueba2 = "";

            prueba2 = "";

            var timer2 = Stopwatch.StartNew();

            foreach (string c in prueba)
            {
                prueba2 = prueba2 + c;
            }
            timer.Stop();

            string tiempo = string.Format("Tiempo en Ticks: {0}", timer.ElapsedTicks);

            var timer2 = Stopwatch.StartNew();

            for (int a = 0; a < 256; a++)
            {
                prueba2 = prueba2 + prueba[a];
            }
            timer2.Stop();
            string tiempo2 = string.Format("Tiempo en Ticks: {0}", timer2.ElapsedTicks);
        }

El resultado que me da en mi equipo es 14 ticks para el foreach y 10 para el for normal. Realmente como mejor se ve esto es haciendo for con una gran cantidad de números de iteraciones, es decir, si vamos a hacer algo pequeño, la diferencia es mínima e incluso en la ejecución que he puesto hay muchos factores que pueden haber influido a la hora de hacer el calculo.

Si seguimos indagando un poco mas, podemos ver el desensamblado con las instrucciones que se generan no las voy a comentar por que la ultima vez que intenté explicar esto en una conferencia aburrí a las moscas…

A continuación dejo las instrucciones que se ejecutan al crear un foreac.

Como vemos a simple vista el for each genera mas instrucciones por lo que después tarda un pelin mas que el for.

Con esto podemos llegar a diversas conclusiones:

- Personalmente uso For each por que me agiliza muchísimo la labor de programar y muchas veces se entiende mejor el código que con el For

- El for es ligeramente mas rápido que el foreach

- Si se trabaja con aplicaciones pequeñas, bases de datos pequeñas la diferencia no se notará pero, si es al contrario, es decir tenemos miles de lineas de código y constantes bucles, puede que si se note…

El próximo post hablare un poco del SQL.

Nota: Articulo basado en.  http://www.codeproject.com/KB/cs/foreach.aspx

Saludos a todos.

Desde hace no mucho me he iniciado en jquery. Estaba utilizando las mootools para un menu, el problema que he tenido es que al intentar combinar el Overlay (para realizar popups con efectos chulos) me ha resultado un coñazo debido a que parece ser que ambos frameworks se repelen (por decir algo).

En realidad lo que sucede es que el $ provoca conflictos entre frameworks. Para solucionarlo existe una funcion en jquery, llamada jQuery.noConflict(); la cual hace que se sustituya el $ por jquery

Ejemplo:
Antes:  $(function () {….

Después:  jQuery(function () {…

hasta aqui con este mini-post, espero que haya sido de gran ayuda.

Por supuesto Blend 4 nos ofrece la posibilidad de crear un botón sencillo con apenas dos Clic como se muestra en la siguiente imagen:

Con esto conseguimos un botón clásico, pero en este tutorial vamos a crear botones fuera de las formas clásicas y con un aspecto mucho más profesional a través de dos ejemplos de botones.
Para empezar vamos a crear la forma base de nuestro botón, empezaremos con uno sencillo, en mi caso una elipse.

Posicionamos nuestra elipse, clicamos en ‘Fill’ y elegimos el color que le queramos poner.

Asignamos el valor 3 en ‘StrokeThickness’ para hacer más visible el borde del botón y cambiamos el color del borde en ‘Stroke’, en mi caso un azul oscuro.

Ahora vamos a darle algo de vidilla a nuestro botón añadiendo algunos brillos, para esto vamos a crear otras dos elipses que ocupen la mitad superior de nuestro botón, elegimos como colores los indicados en la imagen y para conseguir transparentes modificamos el Alpha a 0%.

Para el siguiente paso vamos a crear una elipse blanca de Alpha 40% y otra de cualquier color que cubra casi totalmente la anterior (en la imagen se ve más claro).

Ahora vamos a substraer de la elipse blanca todo lo que tapa la roja, para esto seleccionaremos ambas con crtl+clic y pulsando clic derecho sobre la blanca elegiremos combine/Subtract.

Nos quedara algo tal que así.

Haremos una copia (ctrl+c y ctrl+v) de esta forma que hemos creado al substraer (capa [path]) la rotaremos horizontalmente y la colocaremos en el lado opuesto.

Vamos a darle un toque más de botón añadiendo dos elipses más y situándolas al fondo del todo arrastrando sus capas encima del resto.
La primera será unos 2 pixels más grande que nuestro botón y será de color negro con un borde de 2 pixels con un degrado negro/gris.
La segunda la haremos unos 4 pixels más grande que la anterior e ira al fondo de todas y su color será un degrado de blanco a gris claro en sentido inverso al usado en la última elipse.
Escrito puede sonar enrevesado, pero en la imagen de debajo lo veréis claro.

Para acabar con el diseño de nuestro botón algún símbolo o texto en su interior dependiendo de su función, en mi caso hare un símbolo de “play” creando un cuadrado blanco pulsando y rotando el cuadrado 45 grados lo que nos dará un rombo.

Ahora solo tenemos que substraer la mitad izquierda de nuestro rombo, como os mostré en pasos anteriores, creando otro cuadrado que tape la mitad y eligiendo combine/Subtract.Como último toque le añadiremos a esta forma de “play” un borde.Y ya tenemos nuestro botón de fabricación casera al más puro estilo megavideo.

Hasta aquí la creación del diseño de nuestro botón, ahora viene la parte más importante, hacer que nuestro conjunto de formas se convierta en un botón, para eso seleccionamos todas las capas del botón, clic derecho y elegimos Group Into/grid.

Posteriormente haremos clic derecho en el Grid donde hemos agrupado las capas del botón para seleccionar Make Into Control.

Elegimos Button como tipo de control y marcamos Application.
Con esto se trasformará en un botón, nos añadirá por defecto un texto que podemos eliminar.

Ahora podemos ir a States y modificar los colores y las formas cuando el botón sea pulsado, con el ratón encima o no disponible por ejemplo.

Hasta aquí nuestro primer botón que nos ha quedado la mar de vistoso.

Para nuestro segundo botón usaremos una imagen como mascara para la forma de nuestro botón, de esta forma podremos hacer un botón con formas muy difíciles de conseguir con las formas geométricas que Blend trae por defecto.
En mi caso he pintado en Photoshop el logo de NamoCode y lo he guardado sin fondo en formato PNG.

En Blend creamos un rectángulo, en Fill elegimos el color que deseemos y en OpacityMask seleccionamos imagen y la ponemos en modo Uniform.

No voy a describir paso por paso de nuevo los cambios que hice a este botón, la imagen creo que deja claro los añadidos que le hice.

Le cambio los colores cuando sea presionado (Pressed) y listo.
Ya tenemos nuestro botón con el logo que queramos.

Y hasta aquí este tutorial, siguiendo estos pasos podréis crear vuestros propios botones, en próximos tutoriales ampliare esta información para por ejemplo crear animaciones para nuestros botones.
Recordar, si os surge alguna duda solo tenéis que comentar y os responderé en la mayor brevedad.

Hasta la próxima.

Antes de comenzar con el último punto dentro de nuestro Curso de C#, el acceso a Bases de datos. Quería hacer también un pequeño corto, para mostrar las colecciones genericas y como aumentan la capacidad del programador cuando se usan.

Cuando comencé a programar, solamente usaba arrays y matrices para trabajar con muchos datos a la vez. Pero en el momento que descubrí todos los tipos de colecciones que existían y la facilidad de usarlos, no dude ni un segundo en usarlo. Además, esta completamente probado que la eficiencia de estos es mucho mayor, tanto en ahorro de memoria, como en procesamiento, como en facilidad para el desarrollador.

Las colecciones genéricas aparecen por primera vez en el Framework 2.0. Aunque existen al menos unos diez tipos de colecciones, en este post vamos a hablar de tres, anteriormente, también existían colecciones pero el inconveniente que tenían era, que se trataban de colecciones que almacenaban el tipo de dato Object, por lo tanto la perdida de memoria y tiempo de proceso se debe a este hecho, me explico.

Como es un Object entra el proceso de Boxing y Unboxing. A la gente nueva en el desarrollo le sonara algo raro. Aunque ya lo habremos mencionado en alguna otra ocasión en .Net todos las clases heredan de la clase primaria que es Object, incluso los tipos de datos, aunque no es del todo correcto. Por lo tanto el proceso de Boxing y Unboxing es el siguiente. Se explica de una manera sencilla. Cuando realizamos el proceso de Boxing se introduce nuestro dato en una caja, en este caso la caja es Object, por eso las colecciones que no son genericas, permiten introducir cualquier tipo de objeto.

Sin embargo, el proceso de Unboxing, desenvuelve el anterior objeto metido en una caja, debemos tener mucho cuidado con este proceso, porque si este proceso que realizamos no contiene el objeto que esperamos se puede producir una excepción.

Pongamos un ejemplo aplicado a la vida cotidiana. Tenemos una caja, en donde meteremos manzanas, pero sin querer introducimos también una pera. Ahora mandamos esa caja a un frutero, cuando el frutero compruebe que dentro de la caja de manzanas ahí una pera, podría molestarse.

Eso es lo que ocurre con el fenomeno de boxing y unboxing.

Esto no ocurre con las colecciones genericas, una coleccion generica solo acepta objetos del tipo del cual hayamos creado la colección en cuestión. Si la caja es de manzanas, solo se podrán meter manzanas. Con las colecciones no genericas, no ocurría esto, se podían introducir manzanas, peras e incluso pelotas, pero después podría haber confusión. Además de que el proceso en cuestión demora mucho la tarea.

Las colecciones genericas que vamos a ver en este post, son tres, como ya indicábamos arriba y tienen su homonimos dentro de las colecciones simples, que solo aceptan objetos. Los tipos son List, Dictionary y Stack.

List

Las listas son una de las colecciones más convencionales que podemos usar. Estas nos permiten acceder a cualquier elemento que exista en la misma, además de poder trabajar con la misma correctamente. Para acceder a un objeto en cuestión, podemos acceder a él mediante su índice.  Su homonimo no genérico es el tipo ArrayList.

Siempre que declaramos una lista generica o cualquier otra colección genérica debemos indicar de que tipo de objeto va a tratarse la lista, de la siguiente manera:

List<string> listadestring = new List<string>();

En este caso hemos creado una lista de objetos que albergará string. Pero también podemos crear una que acepte enteros o cualquier otro tipo de objeto. También podemos crear una lista de listas, ya que la lista genérica en si, también es un objeto como en el siguiente ejemplo:

List<List<string>> listadelistadestring = new List<List<string>>();

En este caso, hemos creado una lista que albergara a su vez listas de string, este segundo ejemplo puede resultar algo lioso, pero es para comprobar que podemos tener listas al estilo de una matriz por así decirlo.

Este tipo de objetos heredan de la interfaz IList, por lo que cualquier lista posee unos determinados métodos en todas las listas. Los métodos más interesantes son los siguientes:

Add(objeto)

Nos permitirá añadir un objeto, el parametro debe de ser del mismo tipo del cual hemos creado la lista, en el caso que veíamos antes de string.

AddRange(IEnumerable<objeto>)

Existen muchos tipos de objetos que también heredan de la interfaz IEnumerable, como las colecciones por ejemplo, esto nos permite introducir un grupo de elementos siempre y cuando pasemos como parametro un objeto que herede de la interfaz IEnumerable del tipo de objeto que también es nuestra colección.

Clear()

Este método, nos permite limpiar toda la lista, para dejarla vacía.

Contains(objeto)

Mediante contains, recuperaremos un booleano indicándonos si el objeto del mismo tipo de la colección se encuentra dentro de nuestra lista, True o en caso contrario no existe. False.

Count

Aunque se trata de una propiedad, Count, nos permite comprobar recuperando un entero, cuanto es el número de elementos que tenemos dentro de la lista.

Remove(objeto)

Con Remove, podemos eleminar un objeto de nuestra lista, siempre que este se encuentre dentro de la misma.

ToArray()

Dictionary

Este método, me resulta bastante útil. Ya que me siento más cómodo trabajando con listas, antes de que con arrays convencionales. Usando este método, recuperamos un array del mismo tipo de la lista. En muchas ocasiones hay métodos a los debemos devolver un array. Por lo tanto si usamos una lista genérica que puede resultarnos mucho más cómodo en su uso y posteriormente usamos este método para recuperar un array es mucho más útil.

Existen mucho más métodos, que nos pueden dar una gran funcionalidad dentro de la lista, pero son métodos más complejos a los cuales se le tienen que pasar procedimientos, ya haremos otra entrada para hablar de ellos, porque puede dar mucha funcionalidad a nuestra aplicación.

Nuestra segunda colección genérica que nos puede ser de gran utilidad dentro de nuestras aplicaciones es la de tipo Dictionary. Esta recibe dos parametros genericos. Dentro de las colecciones convencionales, su homonimo es el HashTable, en el caso de la HashTable teníamos también dos objetos, uno de tipo string y el segundo de tipo object. El primer objeto sirve de Key, este tipo de colecciones resultan útiles, para el desarrollador, ya que en vez de tener que buscar un elemento mediante su valor de índice, podemos localizarlo mediante su Key.

A diferencia de la HashTable, las colecciones de tipo Dictionary permiten elegir el tipo de objeto que será Key y cual será el que almacene. Es evidente que el objeto que haga la función de Key, debe ser un tipo de objeto no demasiado pesado ya que las búsquedas se harán en base a él.

Otro detalle de importancia al usar este tipo de colecciones es que nunca se pueden repetir la Key, por lo tanto si agregamos dos entradas con el mismo valor en la Key, se producirá una excepción. Creemos por ejemplo de un Dictionary para almacenar cumpleaños, por lo tanto nuestra Key será un string y nuestro objeto será un DateTime. La instanciación sería así:

Dictionary<string, DateTime> fechasdecumpleanos = new Dictionary<string, DateTime>();

Los métodos que podemos considerar interesantes, son los mismos que podemos encontrar dentro de una lista, pero tenemos dos detalles que la diferencían.

El primero es que no se pueden introducir dos entradas con el mismo valor en la Key, en este caso el método Add, acepta dos parametros, en nuestro ejemplo string y DateTime. Si el objeto de string, si añadiesemos dos filas con el valor dentro de string que fuesen “Cumpleaños de Patri” , al añadir el segundo valor se produciría una excepción.

Lo segundo, es la capacidad que obtenemos para la búsqueda de elementos de una manera más sencilla. Es decir, si en una lista solo podíamos buscar mediante la posición de la lista, es decir, mediante un entero. Como en el siguiente ejemplo:

lista[5] Así accederiamos al sexto elemento de la lista, debemos tener en cuenta que al igual que en los arrays, el primer elemento es el valor O.

En el caso de un dictionary, buscaríamos un elemento debido a su array, en el caso del ejemplo mediante una cadena de texto.

fechasdecumpleanos["Cumpleaños de Patri"]

Esto puede resultar mucho más cómodo, además de más rapido y eficiente.

También debemos mencionar, que podemos acceder a las Keys solamente mediante la propiedad Keys del Dictionary y los valores de Objeto mediante la propiedad Values.

Por último, un solo elemento del dictionary es el objeto de tipo KeyValuePair, este también es un objeto genérico por lo que también contiene los elementos que hayamos declarado dentro del Dictionary.

Stack

La Stack o también conocida en español Pila. Es uno de los tipos de colecciones más primigenios que pueden existir. Su acceso es mucho más rápido y sencillo que otras colecciones, pero también tenemos que indicar que su complejidad es menor. Solo podemos acceder al último objeto agregado y su capacidad está más limitada que las colecciones anteriores, sin embargo, también es mucho más rápida y eficiente, al no requerir de tanta memoria.

La declaración de una pila es muy similar a la lista, en este caso haremos un ejemplo de una pila que solo acepte enteros.

Stack<int> pilaenteros = new Stack<int>();

Para agregar elementos tenemos que utilizar el siguiente método Push, con un parametro que será igual al tipo de objeto. Para eliminar elementos de nuestra pila usaremos el método Pop, este retorna un tipo de objeto igual al de la pila, de hecho el elemento que hayamos removido.

Una pila no, nos resulta útil por ejemplo si queremos acceder a un objeto que se encuentra en mitad de la misma, porque tendremos que ir eliminando objeto por objeto de la misma, hasta alcanzar este.

No obstante nos puede ser útil para muchas otras cosas, por ejemplo, si queremos introducir un grupo de peticiones dentro de nuestra aplicación a otro módulo de la misma por ejemplo, estas se van agregando a la pila y se van eliminando según el módulo se vaya encontrando libre o para introducir una cantidad de datos que posteriormente vamos ir trabajando con él.

Bien, hasta aquí, esta pequeña introducción de las colecciones genéricas. Acostumbrarnos a usarlas, nos puede permitir un desarrollo mucho más ágil y eficiente dentro de nuestras aplicaciones. Ya que resultan menos engorrosas para su utilización dentro de una aplicación, a difierencia de las colecciones no genéricas o el uso de arrays.

Éxisten muchas más colecciones, que puedes descubrir tu mismo. Aunque a simple vista todas puedes cubrir las necesidades dentro de un desarrollo, puedes encontrarte con la incertidumbre de necesitar una funcionalidad más especifica, en ese caso puedes crear tus propias colecciones ya que todas proceden de interfaces, además de poder heredar completamente cada una de ellas.

Hasta aquí el curso de hoy, en la siguiente entrega comenzaremos con las bases de datos.

Un saludo!

Este tutorial es el punto de inicio para una serie de guías para sacar todo el provecho a Expression Blend 4 para crear aplicaciones web.En este primer tutorial aprenderemos a crear nuestra página “Hola mundo”, una sencilla web con contenido estático para iniciarnos en Blend en muy pocos pasos. Este tutorial será implementado con otros posteriores, los primeros tratarán sobre la personalización del diseño de nuestra web, creación de botones y animaciones en Silverlight, bueno empezamos.

Para empezar vamos crear nuestro proyecto. Pulsamos New Project al iniciar Blend. En el tipo de proyecto elegimos Silverlight/ Silverlight Application + Website y ponemos nombre a nuestros proyecto.

Con esto obtendremos nuestra página en blanco tal que así.

Clicamos UserControl. 

Ahora modificamos el tamaño de nuestra página al que deseemos.

Para esto en el lado derecho, en propiedades cambiamos Width y Height a los que queramos.

Ahora que tenemos nuestra página en blanco al tamaño que deseamos, vamos a cargar una imagen de fondo, para que no esté tan sosa. En mi caso es una imagen simple que hice con el Photoshop y un par de pinceles.

· 1.- Clicamos en LayoutRoot.

· 2.- En Background marcamos imagen.

· 3.- Clicamos el botón de examinar (…) y elegimos la imagen que queramos.

En el siguiente paso vamos a añadir algo de contenido a nuestra página web, para esto vamos a crear un Canvas que contendrá nuestras imágenes, texto, etc.

Situamos nuestro canvas medianamente centrado y lo fijamos como indica la imagen para que al redimensionar la ventana del explorador, nuestro canvas no cambie de posición.

· 1.- Fijamos el canvas a la izquierda y arriba.

Ahora ha llegado el momento de crear nuestro “Hola mundo”, para esto nos vamos a Assets/All/TextBlock para crear nuestra etiqueta de texto.

Colocamos nuestro TextBlock en un espacio dentro del Canvas y escribimos nuestro texto.

También añadiremos una imagen a nuestro Canvas de la siguiente manera:

· 1.- Clicamos en Assets/All/Image y la situamos en la posición deseada.

· 2.- En las propiedades de la imagen, en la opción Source, pulsamos el botón de examinar y elegimos nuestra foto. Para que no se deforme elegiremos en Stretch la opción Uniform.

Añadiremos también una cabecera a nuestra web que no es otra cosa que una imagen fuera de nuestro Canvas. Fijaremos la imagen arriba a la izquierda para que no se mueva.

Vamos a añadir un botón:

· 1.- Seleccionamos Assets/Button y posicionamos nuestro botón donde deseemos.

Mi Botón es uno personalizado creado por mí, podréis crear botones así siguiendo un tutorial sobre botones customizados que subire pronto.

Ahora voy a saltarme unos pasos sin importancia, os lo resumo:

Creamos un segundo botón.

Creamos un canvas del mismo tamaño que el ya existente y lo rellenamos con un textblock y una imagen.

Vamos a hacer que al pulsar el botón “Inicio” se muestre el primer canvas, pero no el segundo y cuando se pulse “Btn2” pase lo contrario. Para hacer estos cambios nos iremos al código c# que hay tras nuestra web en Projects/MainPage.xaml.cs

El código que añadiremos ira tras el “InitializeComponent()”. Como queremos que al abrir la web solo muestre de inicio el canvas 1, escribiremos canvas2.Opacity=0.

Volvemos al diseño.

· 1.- Seleccionamos el botón inicio.

· 2.- En Propieties pulsamos Events (A la derecha de Name). Doble clic en el evento Click.

Con esto se nos creara la función btn_inicio_click.

· 1.-Dentro de la función click añadimos las instrucciones para que la opacidad de canvas1 sea 100 y la de canvas2 sea 0.

· 2.- Repetimos el proceso con el botón 2 pero la opacidad de nuestros canvas ira al contrario.

Y ya está, con esto tendremos nuestros botones programados y nuestra primera web de prueba lista, en próximos tutoriales tratare de explicar cómo completar nuestra web con recursos más avanzados.

Recordad, si os surge una duda solo tenéis que comentar y os responderé en la mayor brevedad.

Hasta la próxima.

Mi intención es completar un poco más el abanico de guías y tutoriales que podéis leer en nuestro blog mostrándoos cosas interesantes sobre todo lo relacionado con el diseño, desde el 3d al retoque fotográfico pasando por la edición de video, el diseño web, etc. Así como ayudaros a que dominéis programas como After Effects, Expression Blend, Sony Vegas, 3dMax y muchos otros.

No me extiendo más, pronto sabréis de mí con mis primeros tutoriales.

Hasta más ver.