Un informático en construcción

En ciertas ocasiones, cuando trabajamos con grandes cantidades de datos al mismo tiempo las interfaces de nuestros programas pueden quedar bloqueadas. Esto generalmente hace que el usuario pierda la paciencia y termine cerrando la aplicación con la famosa combinación CTRL+ALT+SUPR.

Para evitarlo podemos hacer uso de los hilos de toda la vida o de la API asíncrona que nos ofrece ADO.NET:

Begin/EndExecuteNonQuery

Begin/EndExecuteReader

Begin/EndExecuteXmlReader

Es muy sencillo así que voy a mostrarlo con un ejemplo en el que hago múltiples inserciones en una tabla de la base de datos.

Lo primero que haremos es crear un objeto SqlConnection y otro SqlCommand:

SqlConnection conexion = new SqlConnection(@"Data Source=.\SQLEXPRESS;AttachDbFilename=C:\nordwind\NORTHWND.MDF;Integrated Security=True; User Instance=True; asynchronous processing=true;");
SqlCommand cmd;
StringBuilder consulta = new StringBuilder();

Ahora abrimos la conexión con la base de datos y en un objeto StringBuilder añado todas las inserciones que tengo que hacer.

try
{
  conexion.Open();
  for(int i=0;i<palabras.Length;i++)
  {
      consulta.Append("INSERT into palabras (palabra) VALUES ('" + palabras.ToString()+"');");
 }

Cuando termina de crear todas las inserciones creo una instancia del SqlCommand al que le paso las inserciones y el objeto SqlConnection.

cmd = new SqlCommand(consulta.ToString(), conexion);

Para ejecutar el comando en otro hilo diferente al del programa principal preparo un delegado que se activara cuando termine la operación.

AsyncCallback callback = new AsyncCallback(MetodoCallBack);

Luego ejecuto el comando de forma asíncrona:

cmd.BeginExecuteNonQuery(callback, cmd);

Por último en la función que ejecuta el delegado recogemos el resultado de la operación y ejecutamos EndExecuteNonQuery.

SqlCommand cmd = (SqlCommand)result.AsyncState;
cmd.EndExecuteNonQuery(result);

El código completo sería el siguiente:

private void btnGuardar_Click(object sender, EventArgs e)
        {
            String[] palabras = txtTexto.Text.Split(" ".ToCharArray());
            SqlConnection conexion = new SqlConnection(@"Data Source=.\SQLEXPRESS;AttachDbFilename=C:\ORTHWND.MDF;Integrated Security=True; User Instance=True; asynchronous processing=true;");
            SqlCommand cmd;
            StringBuilder consulta = new StringBuilder();
            try
            {
                conexion.Open();
                for(int i=0;i<palabras.Length;i++)
                {
                        consulta.Append("INSERT into palabras (palabra) VALUES ('" + palabras.ToString()+"');");
                }
                cmd = new SqlCommand(consulta.ToString(), conexion);
                AsyncCallback callback = new AsyncCallback(MetodoCallBack);
                txtTexto.Enabled = false;
                cmd.BeginExecuteNonQuery(callback, cmd);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
      
        }
        private void MetodoCallBack(IAsyncResult result)
        {
            SqlCommand cmd = (SqlCommand)result.AsyncState;
            cmd.EndExecuteNonQuery(result);
            txtTexto.Enabled = true;
            cmd.Dispose();
        }

Espero que os sirva.

Un saludo

Hola a tod@s,

Después de un tiempo de parón por los exámenes vuelvo por fin al blog. Tengo algún artículo pendiente que intentaré subir lo más rápido posible, pero mientras se termina de cocinar he estado pensando sobre algunos temas que me gustaría mostrar aquí ya que hasta ahora la práctica totalidad de los post estaban centrados en desarrollo, fundamentalmente en .NET.

Así que a partir de ahora expondré algún otro tema que me interesa sobre nuevas formas de interacción con el ordenador y sobre las interfaces de usuario. No soy ningún experto pero me interesan mucho estos temas, hace unos años todo era ciencia-ficción y lo que nos parecía imposible hoy se hace real (interfaces multitactil, interactuar por medio de gestos, pensamientos, etc). Cada día sigo encontrando estudios e investigaciones que merece la pena conocer.

Hoy dejo la primera muestra, una visión de cómo ven en Microsoft sus investigadores la siguiente versión del ratón para el ordenador:

Saludos

Algo que me ha gustado siempre de la plataforma .NET desde que comencé a aprender cosas de ella, es que te propone métodos para hacer las cosas más sencillas y ahorrarte tiempo que puedes ocupar en hacer otras cosas.

En la versión 2.0 de .NET, una de esas cosas que nos hace la vida más fácil a los que programamos son los métodos anónimos, cuya principal ventaja desde mi punto de vista es que nos permite ver inmediatamente lo que hace sin tener que redirigirnos a otras zonas de la clase que estamos desarrollando.

También sería todo mucho más fácil si el que trabaja es el compilador en vez de nosotros o por lo menos, que nos permita centrarnos más en que el programa haga lo que tiene que hacer.

Voy a poner un ejemplo, normalmente nosotros cuando queremos ejecutar una acción en respuesta a un evento, debemos declarar ese evento y “apuntar” al método que queremos ejecutar. Lo podemos ver a continuación con el siguiente código:

port.DataReceived += new System.IO.Ports.SerialDataReceivedEventHandler(port_DataReceived);

En esta línea de código correspondiente al evento que detecta la recepción de datos del puerto serie, estamos creando un manejador del evento “DataReceived”, indicándole donde está el código que debe ejecutar cuando se crea, en este caso el método “port_DataReceived”.

private void port_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
{
this.Invoke(new EventHandler(AdjuntarAlTextbox));
}

“port_DataReceived” solo va a ser ejecutado por el objeto “port” cuando lo crea oportuno y por nadie más, ya que ninguna otra parte del programa va a utilizarlo, a todos nos haría la vida mucho más fácil si lo que va a ejecutar el evento estuviera en el mismo sitio donde se indica “DataReceived” y encima el compilador fuera el que creara la declaración de ese evento.

Para ahorrarnos algunas líneas de código y permitir que el compilador nos ayude a programar vamos a usar un “tipo delegado”. Para ello hacemos uso de la palabra reservada “delegate” y entre llaves colocamos el código que queramos ejecutar, en el caso del ejemplo sería:

port.DataReceived += delegate { this.Invoke(new EventHandler(AdjuntarAlTextbox)); };

De esta manera nosotros no debemos indicar cuál es el manejador del evento que se debe usar, sino que el compilador será quien realice esta tarea. Además al codificar de esta manera sabemos inmediatamente que es lo que va a hacer el programa cuando reciba alguna información por el puerto serie.

No tenemos que indicar la declaración del evento y solo opcionalmente indicaremos los parámetros entre paréntesis a continuación de delegate. Esto es en el caso de necesitar el acceso a la información de algún objeto.

Como veis la palabra “delegate” nos permite hacer unas cuantas cosas muy útiles y sobre todo que nos aportan sencillez en muchos casos.

Otra cosa que podemos hacer es pasar como parámetro un método anónimo, en el caso de necesitar otra instancia del delegado que usamos.

Aquí dejo otro ejemplo:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace metodosAnonimos
{
    public delegate void Primero(string cadena);

    class Program
    {
        static void Main(string[] args)
        {
            Primero a = delegate(string j)
            {
                Console.WriteLine(j);
            };

            a("fijate bien");

            a = new Primero(Program.loquemepasen);

            a("ves la diferencia");

            Thread.Sleep(10000);
        }

        static void loquemepasen(string texto_pasado)
        {
            Console.WriteLine("Puedo hacer cualquier cosa y " + texto_pasado);
        }
    }
}

De todas formas, con los métodos anónimos como con todo, tampoco hay que usarlos a todas horas. Al igual que en muchas ocasiones aclaran el código y hacen que demos menos vueltas buscando lo que hace el programa, también pueden hacer que nos perdamos. Así que hay que usarlos cuando convenga y con moderación.

Para la segunda parte de este post trataremos una característica de C# 3.0 denominada “Expresiones Lambda”, que tienen relación con los método anónimos.

Saludetes

Hoy voy a contar algunas cosas acerca de un cacharro denominado Arduino.

El Arduino es una placa electrónica totalmente programable y de la cual disponemos de toda la información interna gracias a que se trata de hardware libre y toda la documentación se encuentra en disponible a través de internet.

Hace poco comencé a cacharrear con ella para ver todo lo que se podía hacer y la verdad, por lo que he comprobado yo mismo y por lo que otras personas hacen y muestran en internet, se puede hacer casi cualquier cosa.

La placa tiene un coste bajo, alrededor de los 20 euros según modelo y según donde se compre y el valor de los portes, pero es muy barata en comparación con otras placas del mercado y además hay que tener en cuenta la inmensa cantidad de documentación que podemos encontrar en la red.

Podéis ver las especificaciones de la placa en la web oficial de Arduino.

Para desarrollar sobre la placa podemos hacerlo de dos maneras, una es utilizar el IDE que nos proporciona desde la web de Arduino. Este IDE está programado en Java por lo que podemos utilizarlo desde cualquier sistema operativo, el lenguaje es una especie de C muy sencillo de utilizar, por lo que una persona puede hacer cosas interesantes incluso si acaba de aprender a programar.

Un programa de ejemplo podría ser este:

   1:   int ledPin = 13;                  

   2:   int inPin = 10;                    

   3:   int value = 0;                     

   4:   

   5:  void setup() { 

   6:    Serial.begin(9600);

   7:    pinMode(ledPin, OUTPUT);       

   8:    pinMode(inPin, INPUT);            

   9:  } 

  10:   

  11:   

  12:  void loop() 

  13:  {

  14:    value = digitalRead(inPin);       

  15:    digitalWrite(ledPin, value); 

  16:    delayMicroseconds(1000);

  17:    if (value==1)

  18:    {

  19:      Serial.println("Pulsado");

  20:    }

  21:    else{

  22:      Serial.println("Sin pulsar");

  23:    }

  24:    delayMicroseconds(10000);

  25:  }

Con este programa simplemente controlamos cuando pulsamos un botón para encender o apagar un diodo led. Según pulsamos enviamos por el puerto serie un string que indica si está pulsado o no.

Otra forma de programarlo es enviando ordenes a través del puerto serie y aquí es donde entra nuestro querido C#. Hacer un programa que utilice el puerto serie para monitorizar lo que hace el Arduino e incluso enviar órdenes a través del usb es tremendamente sencillo.

Si queremos ver los strings que envía el programa anterior por el puerto serie podemos usar el siguiente programa:

   1:  using System;

   2:  using System.Collections.Generic;

   3:  using System.ComponentModel;

   4:  using System.Data;

   5:  using System.Drawing;

   6:  using System.Linq;

   7:  using System.Text;

   8:  using System.Windows.Forms;

   9:  using System.IO.Ports;

  10:  using System.Threading;

  11:   

  12:  namespace Arduino_lee_recibe

  13:  {

  14:      public partial class Form1 : Form

  15:      {

  16:          SerialPort port;

  17:   

  18:          public Form1()

  19:          {

  20:              InitializeComponent();

  21:              port = new SerialPort("COM4", 9600);

  22:              port.DataReceived += new System.IO.Ports.SerialDataReceivedEventHandler(port_DataReceived);

  23:          }

  24:   

  25:          private void button1_Click(object sender, EventArgs e)

  26:          {

  27:              if (!port.IsOpen)

  28:              {

  29:                  port.Open();

  30:                  button1.Text = "Terminar";

  31:              }

  32:              else

  33:              {

  34:                  port.Close();

  35:                  button1.Text = "Comenzar";

  36:   

  37:              }

  38:          }

  39:   

  40:          private void port_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)

  41:          {

  42:              this.Invoke(new EventHandler(AdjuntarAlTextbox));

  43:          }

  44:   

  45:          private void AdjuntarAlTextbox(object sender, EventArgs e)

  46:          {

  47:              textBox1.AppendText(port.ReadLine()+'\n');

  48:          }

  49:   

  50:          private void Form1_FormClosing(object sender, FormClosingEventArgs e)

  51:          {

  52:              if (port.IsOpen) port.Close();

  53:          }

  54:      }

  55:  }

  56:   

Necesitamos disponer de un formulario con un textbox esté activada y un botón para poder parar y arrancar el programa.

Para hacer uso del puerto serie utilizamos el namespace System.IO.Ports, creamos un objeto de tipo SerialPort y lo inicializamos con el puerto por el que tenemos conectado el Arduino y Baud Rate.

Utilizaremos el método DataReceived para escribir en el textbox cuando el programa detecte la recepción de datos.

Por último debemos tener en cuenta la situación actual del puerto, es decir, si está abierto o cerrado para poder parar la recepción de información o iniciarla.

Como podéis ver es bastante sencillo hacer un pequeño programa. En los próximos post en los que me refiera al Arduino veremos cómo enviar información a la placa para que actue según nuestras pretensiones y como conectar diferentes sensores, servomotores, de cara a poder montar algunos robots sencillos con la placa.

Saludetes

Anda que no hace tiempo desde la última vez que puse un post en el blog, desde entonces no creáis que he tenido tiempo para aburrirme. A parte de seguir con la carrera aprendiendo Smalltalk, recordando Java y recogiendo requisitos para el proyecto de ingeniería del software (además de otras hiervas), me he dedicado a darme una vuelta por Tarragona en el CodeCamp (como queda de lejos ya y solo ha pasado poco más de un mes :O) y luego, concretamente hace un par de semanas a darme una vueltecilla por el TechEd de Berlín 2009.

Tuve la suerte de ser uno de los tres MSPs (Microsoft Student Partners) que asistieron de España al evento, junto con el coordinador nacional de los DotNetClubs. La experiencia en general ha sigo estupenda, el evento (charlas, stands, etc,..) estuvo fenomenal, la organización se preocupaba de que todo estuviera perfecto, la charlas empezaban y terminaban a tiempo y había puestos de comida y bebida por todos lados y unas cuantas XBOX para tocar un poco la guitarra :D

Una pega que si pondría en cuanto a las charlas es que había pocas novedades ya que el PDC era a la semana siguiente, quizás sería mejor poner el TechEd una semana más tarde que el PDC. Así en el PDC se verían las novedades a presentar y en los sucesivos TechEd que se van celebrando podrían explayarse sobre como usar esas nuevas tecnologías presentadas.

Pero bueno, aun así había cantidad de charlas en las que aprender cosas nuevas.

La ciudad, pues que os voy a contar, mucho que ver y muy poco tiempo para hacerlo, algo pudimos hacer aunque solo fuera para echarnos unas fotos y poder decir que habíamos estado allí.

Aunque no estábamos muchos españoles, algunos como Luis Fraile o Isabel Gomez nos los pudimos encontrar por allí

Por otro lado con la llegada a España ya empezamos a organizar más cosillas y ahora estoy llevando un pequeño evento que organizaremos en Valdelaguna, un pueblo de Madrid, donde tendremos a algunos de los coordinadores de los clubs de .NET de España y varios de los mejores profesionales de tecnologías .NET del país.

También estoy haciendo algunas utilidades comunes que luego colgare a modo de tutorial, son muy sencillas pero seguro que a alguno le resultarán útiles sobre todo ver el código.

Y bueno, poco más, esto es simplemente un post que yo llamo de “ping”.

Saludetes 

Hola a tod@s,

Hacía tiempo que no posteaba y os aseguro que no es por falta de ideas ni de ganas, sino de tiempo.

Como todos los principios de curso ha habido que organizarse y este año si cabe aun más, pues la mayor parte de las prácticas son en grupo y organizar las agendas es complicado. Además el año que viene cambian los planes de estudios por la entrada del Plan Bolonia, así que tenemos que dejar todas las asignaturas que podamos bien aprobadas y luego ya veremos qué camino seguimos.

En el club también hemos tenido cambios, algún coordinador nuevo y como siempre ver qué cosas vamos a intentar aprender durante el curso. Una de las novedades es la nueva web del club, durante unos años hemos utilizado un site que nos dejaron funcionando los "abueletes" del club (Cristian y Thempra) pero ya había que darle un lavado de cara a la web y mejorar algunas funcionalidades. Así que al final hemos decidido montar un MojoPortal ("mojete" para los amigos)que no ha quedado nada mal y que es muy fácil de utilizar. Por supuesto está desarrollado en .NET.

Por otro lado el jueves pasado tuvimos nuestra primera reunión. No estuvo nada mal, contamos con caras conocidas y algunas nuevas, lo mejor es que fueron bastante participativos.

Me tocaba a mí dar la charla, así que vimos una pequeña introducción al .NET y al club. Os dejo las ppts por si alguno quiere empezar con todo esto del framework:

Esta semana vamos a tener mucho movimiento, por un lado el jueves en el club tendremos una charla con los campeones de la fase española de la Imagine Cup 09 y por otro lado el viernes me trasladaré a La Pineda (cerca de Tarragona) al "Train the trainers" organizado por Microsoft, luego el sábado y domingo asistiré al CodeCamp organizado por los grupos de usuarios de .NET también en La Pineda.

Y bueno de momento poco más puedo contar, si alguien se pasa por alguno de estos eventos, que salude y nos tomamos una cañita 

Saludetes .

Bueno hoy voy a contar como montar una pequeña infraestructura de compartición de proyectos en cinco minutos para unas cuatro o cinco personas y todo a un precio mínimo, vamos por cero euros. 

Básicamente lo que vamos a necesitar son dos programas, el VisualSVN Server y el Ankhsvn (menudo nombrecito).

El VisualSVN Server es un servidor Subversion para Windows que cuenta con dos versiones una gratuita o Standard, que es la que voy a utilizar y otra de pago también llamada Enterprise que incluye un par de características más. Podéis verlas desde este enlace.

 

Definimos el lugar de instalación, la carpeta donde guardaremos los proyectos y el puerto por el que vamos a acceder. También podemos seleccionar el tipo de autenticación.

Una vez pasamos esta pantalla comienza la instalación del programa.

 

Bueno, como podéis ver la instalación es bien sencilla y en poco tiempo está instalado el servidor. Lo que vamos a hacer ahora es crear un repositorio para nuestro primer proyecto y el correspondiente usuario para que pueda acceder al mismo.

Ejecutáis el VisualSVN Server Manager y os debe aparecer una pantalla como esta:

Lo primero que vamos a hacer es crear un usuario, en la parte de la izquierda pulsamos con el botón derecho sobre Users y en el menú que aparece en Create user.

Simplemente tenemos que introducir el nombre del usuario y su contraseña: 

 

 

Damos un nombre al repositorio y opcionalmente podemos añadir las carpetas de trunk, branches y tags. La carpeta de trunk contiene la rama principal de desarrollo, la de branches contiene copias temporales de la rama principal y la de tags copias de cada versión del proyecto.

 El resultado sería este y la dirección por la que accederíamos sería algo así https://lincestation/cvs/prueba. 

Vamos a asignar el usuario que hemos creado al repositorio para tener controlado quien entra y quien no, para ello pulsamos con el botón derecho sobre el repositorio creado y pulsamos en properties. Aparece una ventana donde agregar usuarios, por defecto está permitida la escritura y lectura a todo el mundo.

 

Lo primero que vamos a hacer es pulsar sobre Add, nos aparece una ventana donde seleccionar el usuario, aceptamos y se agrega al grupo de usuarios. Marcamos el usuario y en permissions le damos derechos de lectura y escritura.

Con el usuario Everyone simplemente le restringimos el acceso con No Access. Quedaría de la siguiente forma:

 

Aceptamos y ahora podemos cerrar la consola de VisualSVN Server, el servidor continuara ejecutándose como un servicio de Windows.

Vamos ahora a instalar el plugin para acceder a este servidor desde Visual Studio 2008. Simplemente aceptamos la licencia e iniciamos la instalación.

Una vez finalizada abrimos nuestro VS2008 y añadimos nuestro servidor a la lista de repositorios, para ello pulsamos sobre File, Subversion y luego sobre Open from Subversion

 

En la ventana que aparece hay un icono desde el que añadir nuevos repositorios justo al lado de la url. Pulsamos sobre el icono y añadimos la dirección.

 

Pulsamos OK y nos pedirá el usuario con el que acceder, una vez hecho esto ya tenemos agregada la dirección. De momento lo que veréis son las carpetas (trunk, branches, tags) que habíamos creado en el repositorio.

Voy a abrir una solución web para subirla al repositorio, una vez abierta la solución pinchamos con el botón derecho sobre el nombre de la misma y luego en Add Solution to Subversion.

 

Aparece una ventana donde tenemos que indicar la dirección del repositorio, pulsando sobre el desplegable aparece la dirección añadida anteriormente, seleccionamos el repositorio como veis en la figura y pulsamos OK.

Volvemos a pulsar con el botón derecho sobre la solución podéis observar que tenemos algunas opciones más. Si pulsamos en Commit Solution Changes, confirmamos que queremos subir los cambios en nuestro proyecto y a través de la interfaz web podemos ver algo como esto:

Podemos actualizar el proyecto a la última versión, confirmar los cambios realizados en el proyecto, ver el historial de la solución, etc.

 

Bueno pues de esta sencilla manera podemos tener a varios usuarios trabajando al mismo tiempo en el mismo proyecto. Evidentemente esta solución no es comparable a tener un TFS (Team Foundation Server) funcionando para el grupo de trabajo, pero creo que como solución rápida para un momento puntual es más que valida.

Espero que resulte de utilidad.

Saludetes

Por fin saco un ratillo para poner algo en el blog, en esta ocasión vamos a ver un pequeño tip sobre como cambiar fácilmente el idioma de nuestro Windows 7.

El jueves pasado salió a la luz la versión RTM de Windows 7 para subscriptores de MSDN y de TechNet, bueno la imagen estaba disponible en inglés y había que aplicar posteriormente el pack del idioma correspondiente.

No es nada difícil cambiar el idioma, pero si nunca lo has hecho o es la primera vez que tienes Windows 7, es normal que le pregunten a uno como se hace. Así que este post va dedicado a todas esas personas que me buscan de servicio técnico en verano

Inicialmente tenemos algo así, inglés por todos lados, así que nos vamos a nuestro querido “Panel de Control”.

En el podemos ver señalada la sección “Clock, Languaje, and Region” (un lugar idóneo para cambiar el idioma ¿no creéis? ). Si pinchamos sobre ella veremos lo siguiente:

un menu en el que cambiar la fecha y la hora, y una segunda opción donde cambiar el idioma.

Si ckickamos en la segunda opción nos aparece un asistente para instalar o desinstalar idiomas, pulsamos en “Install display languajes”.

En este paso nos da la opción de bajarlo del sitio de Microsoft e instalarlo, o instalarlo directamente si ya disponemos del mismo, como es mi caso. Pulsamos sobre la segunda opción y buscamos el archivo que contiene el idioma.

Ahora pulsamos en “Next” y aceptamos la licencia para comenzar el proceso de instalación.

Cuando termina de instalarlo nos muestra los idiomas instalados, seleccionamos el “español” y pulsamos la casilla que hay más abajo para que aplique el idioma a todo el sistema.

Pulsamos sobre “Change display languaje” y nos pide reiniciar el sistema.

Al cabo de unos segundos nuestro sistema tiene un idioma un poco más familiar

Bueno, pues eso es todo, disfrutad de la playa o de los chaparrones que están cayendo estos días.

Saludetes

El primero de todos fué ayer, se trataba de una charla sobre Lego MindStorm dentro de los cursos de verano de la universidad, el curso se llama Robótica móvil: una apuesta de futuro. En la charla estuve junto a Pedro Redondo de Movirobotics y Jonás Talavera, sobre todo me encargue de la parte de desarrollo, enseñando diferentes entornos como Microsoft Robotics Studio, NXT-G y librerias como NxtSharp.

Los siguientes eventos se encuentran dentro de las actividades que se realizan durante la PartyQuijote09 que este año se celebra en Toledo desde el 16 al 19 de Julio. 

El jueves 16 daré una charla similar a la de ayer, pero esta vez "solo ante el peligro" ;y por la noche después de la cena veremos que tal funcionan los Legos que hemos preparado para el torneo "OptimusPrime VS Megatron, el Retonno", el año pasado también hicimos este torneo y parece que gusto a los "compis" de la party.

El viernes 17 tenemos un tallercico de Silverlight entre Pedro González y un servidor. Luego colgare de agún lado la demo del taller.

Además de todo esto intentare frikear todo lo posible y ayudar en otro evento, "Fotografía 3D con PhotoSynth", impartido por José Angel Fernandez y Javier Albert que vienen desde los DotNetClubs de la UPM y de la Universidad de Alcalá.

Todo esto y algo más es lo que tengo previsto para esta semana, a parte de dormir poco intentaré seguir contando lo que hacemos por allí.

Por cierto en cuanto tenga todos los materiales os los cuelgo.

Saludetes

Antes de nada, he visto que existen algunos programas que hacen el proceso que viene a continuación de manera casi automática, pero dado que después de probar varios he comprobado que unos funcionan y otros no, lo mejor creo que es hacerlo a mano (que por lo menos a mi no me falla).

Lo primero de todo es ver si tenemos la carpeta backgrounds en la siguiente dirección: C:\Windows\System32\oobe\info\backgrounds , si no la tenemos debemos ir hasta el directorio oobe, crear info y dentro de este backgrounds.

A continuación vamos a editar el registro de Windows, ya sabéis Inicio -> Ejecutar y ponéis Regedit, debemos ir hasta:  

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\-->

--> Authentication\LogonUI\Background 

Y fijarnos si tiene la clave OEMBackground puesto a 1. Si no es así o no existe lo creamos pulsando con el botón derecho del ratón en la parte derecha del registro y añadiendo un valor DWORD con el nombre que he indicado, lo ponéis a 1 y cerráis el registro.

Ahora vamos a preparar la imagen de fondo, escoged la que queráis, a ser posible de la resolución de vuestra pantalla, la guardáis en  la carpeta backgrounds con el nombre backgroundDefault.jpg y con un tamaño que no supere los 256kb.

Solo queda reiniciar vuestra máquina para comprobar el resultado

Saludetes

Me acabo de encontrar con 3 cursos gratuitos que ha sacado Microsoft Learning sobre Windows 7 para ir conociendo este nuevo sistema operativo.

Los cursos según el tipo de usuario que seas los podéis encontrar en estos enlaces:

• Para usuarios 
• Para profesionales
• Para empresarios

Saludetes ;)

Me encuentro ahora mismo desarrollando un sitio web en ASP.NET  para una asignatura de la universidad y esta tarde me he encontrado con que necesito tener accesibles algunos datos en cualquiera de las páginas que componen el sitio web, así que voy a dejar aquí las dos formas de hacer esto que he encontrado.

Para poneros en situación os diré que mi sitio web está compuesto por una MasterPage, varias páginas de contenido asociadas a la MasterPage y dos páginas más que no están asociadas; la MasterPage tiene un control de LoginName del cual quiero obtener el nombre del usuario que está logueado en cada momento en cualquier página.

Aclaración: podemos obtener el nombre de usuario logueado en el site mediante "this.User.Identity.Name", que sería mucho más correcto para obtener el nombre del usuario en cualquier momento. Sin embargo la idea es ejemplificar como llevar un dato de una parte a otra del site en situaciones en las que no dispongamos del tipo de facilidades como la que tenemos en el caso concreto que he utilizado de ejemplo en el post.

En el Web.config

Para hacer esto he visto varias maneras, la primera de todas se trata de guardar los datos en el Web.config en la zona de "appSettings", esto lo haría de la siguiente forma:

Primero añadiendo una clave a la zona de appSettings en el Web.config

<appSettings>  

        <add key="username" value="valor" />

</appSettings>

Y luego en el código de la página en la que lo necesitemos podemos obtener o modificar el valor de la clave mediante:

System.Configuration.ConfigurationSettings.AppSettings["username"] 

En el Global.asax

Otra manera que he visto es utilizando el archivo Global.asax. Este archivo opcional en los desarrollos de ASP.NET nos permite manejar eventos que ocurren a nivel de la aplicación y de sesión, también nos permite declarar valores que necesitemos entre las diferentes solicitudes.

El archivo Global.asax para que funcione tiene que permanecer en la raíz de la aplicación y solo se admite uno por aplicación ejecutada. Si tenemos algún otro archivo de este tipo en algún subdirectorio no se tendrán en cuenta por la aplicación.

Cuando declaremos una variable dentro de Global.asax estará disponible en todas las páginas de la aplicación. Lo podemos hacer de la siguiente manera:

En el fichero Global.asax declaramos una variable string y luego en Session_Start otorgamos el valor de la cadena a un objeto de tipo Session que en mi caso se llama valorCadena.

public class Global : System.Web.HttpApplication
    {
        string cadena="valor inicial";
        protected void Application_Start(object sender, EventArgs e) { }
        protected void Session_Start(object sender, EventArgs e)
        {
            Session["valorCadena"] = cadena;
        }

...

          ......

Luego en la página que lo necesitemos podemos escribir valores:

       Session["valorCadena"] = "la_cadena_que_quiera_poner";

y leer de la variable:

       Label1.Text = (string)Session["valorCadena"];

Aporte: Jorge Dieguez nos hace un comentario interesante: "..te recomiendo que en lugar de una(o varias) varaibles sueltas uses una clase que te centralize el acceso a la infromacion de contexto(usuario,su perfil, o lo que sea), esta clase es la responable de almacenear el estado en algun lugar(por ejemplo en la sesion) la idea es que la aplicacion no sepa como y donde se guarda la informacion de contexto..". Quizás es la solución más elegante de todas las planteadas.

Pues nada, si hay alguna corrección o manera más de hacer esto ponedlo en los comentarios y así vamos completando entre todos el post

P.D.: Si queréis más información sobre Global.asax podéis leer algo más aquí

Saludetes :)

Este año la verdad es que voy bastante apretado de tiempo me toca correr en todo y no me da tiempo ha hacer todo lo que me gustaría. Una de esas cosas que me hubiera gustado hacer es postear dos videos que hice sobre los instaladores de programas, el tiempo ha pasado y los videos me los he encontrado guardando polvo en el disco duro.

En una de las primeras charlas que tuvimos en el club a principios de curso tratamos el tema de windows forms y no pudimos ver con detenimiento la forma en la que se pueden crear instaladores de programas con Visual Studio. Como lo hice bastante rápido y alguno me vino preguntando varias veces sobre el proceso a seguir, decidí hacer un par de videos cortos en los que explico como hacer el típico setup de toda la vida de forma rápida y otro en el que se ve como hacer este proceso con clickonce.

Aquí los dejo, no explican nada más que lo básico pero como se que ha un par de personas les ha servido de ayuda imagino que a alguno más también le servirá.

Si los queréis descargar tenéis las direcciones más abajo.

LaBloguera.net - Generación de un instalador de aplicaciones

LaBloguera.net - Instalción de aplicaciones con ClickOne

La descarga de los videos, aquí y aquí

Saludetes

Nivel: Básico

Tema: Visual Studio

Autor: César Reneses – Coordinador Albacete DotNetClub

A pesar de llevar ya bastante tiempo entre nosotros mis compañeros del club e incluso los visitantes de mi blog, me siguen preguntando sobre como instalar y solucionar los problemas que surgen durante la instalación del Visual Studio 2008.

Así que me parece interesante de cara a aprender más cosas sobre .NET saber primero como instalar VS2008 ya que principalmente el post va dirigido a gente que no ha tocado nunca Visual Studio y que tiene que instalarlo por primera vez.

Si habéis probado otros entornos de desarrollo iréis notando poco a poco la facilidad y rapidez que da Visual Studio a la hora de programar.

Hay que tener en cuenta que esta es la versión 9 de VS2008 lo que da una idea de lo trabajado que está el entorno. Es cierto que siempre quedan cosas por limar o implementar, características que a muchos nos gustaría tener, etc., pero después de 8 versiones, de recoger sugerencias y peticiones de usuarios durante varios años, es a día de hoy uno de los entornos de desarrollo más completos.

Donde conseguir Visual Studio 2008

Desde la versión de Visual Studio 2005, Microsoft ofrece diferentes versiones gratuitas enfocadas a gente que quiere aprender o experimentar con .NET, este grupo de de herramientas se denominan “express” y están orientadas a cuatro grupos de la tecnología .net, como son el desarrollo web, la programación con C++, C# o Visual Basic.

Estas versiones las podemos descargar desde el sitio web de Microsoft: http://www.microsoft.com/express/product/default.aspx

Los que sois estudiantes universitarios tenéis acceso gratuito a una de las versiones de Visual Studio de pago a través de la Academic Alliance que podéis tener a través de vuestro DotNetClub o de vuestra universidad, y también a través del programa Microsoft DreamSpark si lo tiene concertado vuestra universidad.

La versión que aparece en mi Academic Alliance es la Professional, que se ofrece con fines educativos y sin coste alguno. Además de la versión Professional existen otras versiones como la Standard o la Team System. Podéis bajaros las versiones de prueba desde aquí.

Instalando Visual Studio

Lo primero de todo es tener algo más de 2Gb de espacio libre en disco y paciencia (tarda un poco, pero merece la pena), podemos aligerar el tiempo de instalación si marcamos solo las características justas que necesitamos.

La elección de idioma va en gusto de cada uno, a mi me gusta tenerlo en inglés, ya que si tienes que buscar información sobre alguna característica del entorno o sobre algún error, encuentras más cantidad de información en la red.

Por lo demás metemos el disco y aparece la siguiente ventana para comenzar la configuración de la instalación.

Pulsamos sobre “Install Visual Studio 2008” y carga los componentes necesarios para iniciar la instalación.

Una vez cargados los componentes pulsamos sobre “Next” y en la siguiente pantalla aceptamos el contrato de licencia.

Ahora podemos indicar que programas vamos a instalar, todos, los más comunes o una selección que nos venga bien.

Indicamos la ruta de la instalación y pulsamos en “Install” para que inicie la copia del programa.

Después de un ratillo aparecerá esta pantalla:

Hasta aquí lo que ocurre en la mayoría de los casos, es decir que se instala correctamente. Pero también, aunque es en situaciones muy particulares esta instalación no se nos da tan bien.

Problemas que pueden surgir en la instalación

Como en toda instalación de software el Visual Studio no se libra de esos “fallicos” que tenemos que solucionar.

Error 1330: este error nos indica que alguno de los archivos de instalación está corrupto. Las solución es bien sencilla, copiar los archivos a una carpeta local de nuestro disco duro y volver a comenzar desde allí la instalación.

Aunque parezca increíble la solución es efectiva :D, podéis leer más en el blog de El Bruno y en el de Heath Stewart por duplicado, aquí y aquí.

Web Authoring Component Error: también nos puede aparecer este error en la instalación en el que se produce un conflicto con un archivo perteneciente a office 2007.

Lo más fácil en este caso sería desinstalar Office e instalar VS2008. Pero lo recomendable es echarle un ojo al log de instalación; aquí y aquí os dejo dos ejemplos de como se hace y se soluciona el problema.

Con estos dos errores me he encontrado alguna vez, pero buscando un poco en la red siempre se encuentra la solución.

Donde conseguir más información

Ahora que tenemos el entorno instalado voy a dejar unos enlaces donde conseguir información sobre .NET y preguntar dudas:

Programa Desarrollador 5 Estrellas aquí podrás aprender desde cero las partes más relevantes de la tecnología .NET, con test para que puedas medir tus conocimientos.

Foros, tres son mis preferidos el de los dotnetclubs, los de msdn y los del guille.

No podían faltar cursos específicos sobre diferentes tecnologías como winforms, asp.net, dispositivos móviles, etc. puedes encontrar bastantes en desarrollaconmsdn.com.

Y para terminar un par de comunidades donde leer noticias y artículos sobre tecnología y .NET, labloguera y geeks. La primera dedicada sobre todo a estudiantes y la segunda dedicada más al mundo profesional.

Por ahora esto es todo, ¡nos vemos! :D

Saludetes

Bueno pues WPF es básicamente el sustituto de Windows Forms en un futuro una nueva herramienta para crear aplicaciones con una experiencia rica de usuario. Una nueva tecnología que nos permite desarrollar aplicaciones de escritorio aprovechando mucho más los recursos gráficos de los últimos sistemas windows.

Sobre todo lo más importante es que se pueden crear aplicaciones más usables (siempre que tengamos un experto en usabilidad) y más vistosas (solo si dejamos que el diseñador haga los gráficos y no nosotros).

Una de las cosas que más se resalta en las charlas de WPF es la separación entre la parte de la interfaz y la del código de la aplicación. Por lo que el desarrollador simplemente tiene que ir añadiendo su código sin tener que tocar nada de la interfaz y el diseñador lo mismo pero en su terreno. Las herramientas que ambos usan son, por el lado del desarrollador Visual Studio y por el lado del diseñador Expression Blend.

Anteriormente la forma de comunicación entre ellos era una imagen que creaba el diseñador de como debía más o menos aparecer la interfaz del programa y el desarrollador intentaba llevarla a cabo con algún lenguaje.

Ahora el diseñador cuando crea una interfaz, es esa la que aparecerá finalmente sin adaptaciones de ningún tipo.

Para que desarrollador y diseñador puedan trabajar en un mismo proyecto con estas herramientas tiene que existir un nexo de unión, este es XAML un lenguaje al estilo de XML y que es entendido por Visual Studio y Blend.

Bueno, creo que con esta mini introducción ya vale, necesitaba contar un poco como iba para poder pasar a ver los tipos de aplicaciones y como se crean que será el tema de mi próximo post. De momento os dejo enlaces a aplicaciones reales hechas con WPF.

http://www.turningthepages.com

RoxioCentral

NoteScraps

Otto Store

Saludetes