Búsqueda y Reemplazo de Palabras.

Imaginemos que tenemos un documento y queremos reemplazar una palabra por otra.

Para ubicarte en la forma que he trabajado, les comento que he definido un proyecto del tipo ClassLibrary y allí he colocado los métodos necesarios.

public class WordCsharp
    {

        Word.Application _objWordApplication; //Objeto Word
        Word.Document _objWordDocument;  //Objeto Document
        Object oMissing = System.Reflection.Missing.Value;

	//Funcion que sirve para abrir un archivo de Word creado previamente.
        private void LoadWordFile(string _filename)
        {
            _objWordApplication = new Word.Application();
            _objWordDocument = _objWordApplication.Documents.Open(_filename,false,false,false,
				ref oMissing, ref oMissing,
				ref oMissing, ref oMissing);
            _objWordApplication.Visible = true;
        }

	//Funcion que Busca y reemplaza un texto por otro.
        public void FindReplace(string _filename, string _find, string _replace)
        {
            	//Abrimos el archivo
		LoadWordFile(_filename);
		//Seleccionamos todo el documento para buscar y reemplazar el texto
                Word.Find findObject = _objWordApplication.Selection.Find;
                findObject.ClearFormatting();
                findObject.Text = _find;
                findObject.Replacement.ClearFormatting();
                findObject.Replacement.Text = _replace;

                //Escoger esta opción permite reemplzar todas las
		//ocurrencias del texto en el documento.
		object replaceAll = Word.WdReplace.wdReplaceAll;
                findObject.Execute(ref oMissing, ref oMissing,
				   ref oMissing, ref oMissing, ref oMissing,
                                   ref oMissing, ref oMissing, ref oMissing,
				   ref oMissing, ref oMissing, ref replaceAll,
				   ref oMissing, ref oMissing, ref oMissing,
				   ref oMissing);
            }

        }
    }

Insertando una Tabla

Continuando con la misma clase anterior, ahora vamos a crear un método que inserte, al final del documento, una tabla. La dimensión de la tabla la puedes pasar como parámetro.

public void InsertTable(string _filename,int _col, int _row)
        {

            //Abrimos el archivo
            LoadWordFile(_filename);
            //Bookmark de final del archivo
	    Object end_document="\\endofdoc";
	    //Definimos la tabla
            Word.Table _table;
            Word.Range wrdRng = _objWordDocument.Bookmarks.get_Item(ref end_document).Range;
            _table = _objWordDocument.Tables.Add(wrdRng, _row, _col,
					ref oMissing, ref oMissing);
            _table.Range.ParagraphFormat.SpaceAfter = 6;
            int r, c;
            string strText;
            for (r = 1; r <= _row; r++)
                for (c = 1; c <= _col; c++)
                {
		    //Este es el texto que vamos a colocar en cada Celda
                    strText = "r" + r + "c" + c;
                    _table.Cell(r, c).Range.Text = strText;
                }
            //Cambiando los items de la primera fila
            _table.Rows[1].Range.Font.Bold = 1;
            _table.Rows[1].Range.Font.Italic = 1;
            //Visualizando los bordes Verticales y Horizontales
            _table.Borders[Word.WdBorderType.wdBorderVertical].Visible=true ;
            _table.Borders[Word.WdBorderType.wdBorderHorizontal].Visible = true; 

        }

Observa con cuidado que en el método anterior se abre el documento nuevamente. Esa línea la puedes quitar si es que sobre UN solo documento se va a aplicar varias opciones.

Espero que le saquen provecho a este post automatizando cada vez mas cosas en Word.

Luego de analizar la situación, hemos decidido empezar este 2012 con un ánimo renovado, borrando lo anterior y esperando que la fortuna nos acompañe y sobre todo que ustedes continuen leyendo y escribiendo sus comentarios  a los post que vamos a ir escribiendo.

Ahora si, los dejamos con el nuevo post, no sin antes darles gracias por su tiempo en leer estas líneas.

Atte.

Copstone….Programando por Diversión

En el post anterior vimos de que trataba el MVC. En este post vamos a analizar una aplicación Web sencilla  con ASP.NET y MVC 3. El concepto de  MVC 3 en ASP.NET hace referencia a un framework para que nuestras aplicaciones web sean desarrolladas bajo el patrón MVC. Lo puedes descargar desde este link.

Creación del Proyecto

Luego de instalar los archivos, reinicia tu VS 2010 y crea un nuevo proyecto del tipo Web en el lenguaje C#. De manera específica vamos a realizar un proyecto del tipo ASP. NET MVC 3 Web Application.

Le voy a poner de nombre al proyecto DemoMVC3App y luego pulsar el botón OK

Luego de pulsar el botón, vamos a acceder a una nueva ventana. En esta ventana vamos a escoger el motor de vistas que usaremos y el template del proyecto que usaremos.

• Para el Motor de Vistas (View Engine) escogeremos RAZOR. Este motor permite un acceso mejorado a las vistas que las del motor ASPX. Este es uno de los cambios del MVC 3 con respecto a sus predecesores.
• En el caso de los template, usaremos el template que permite la creación de una “project with an account controller that uses forms authentication.”

Luego de presionar OK, esperamos unos segundos y se crea el proyecto de la siguiente forma:

Como pueden ver, en el Solution Explorer, se han creado carpetas y llaman la atención 3 de ellas, Controllers, Models y Views.

Vistas

Como ya saben, las vistas vienen a ser las interfaces que van a visualizar el usuario. Si ejecutan la aplicación, tal como está, verán la siguiente página inicial:

Si analizamos la interacción del usuario con la página tenemos:

• Puede dar Click en HOME
• Puede dar Click en About
• Puede dar Click en LogOn

Estas tres interacciones, según el concepto de MVC, deberían generar, cada una,  un evento el cual debe de ser controlado por un Controller y llevar a la visualización de vistas, digamos 3 vistas. Veamos si esto es cierto.

Vamos a VS2010, en la carpeta Views, veamos que hay dentro de esa carpeta.

Si expandimos la carpeta View, vemos que existe una subcarpeta Account, con varios archivos, pero nos interesa por ahora LogOn.cshtml. También vemos una carpeta llamada Home con dos archivos About.cshtml e Index.cshtml.

A estas alturas ya deben de haber deducido algo, y si no se los digo. Los archivos mencionados, son las vistas de las 3 opciones que mencionamos líneas arribas. Para despejar las dudas, los invito a abrir esos archivos y verán que el contenido de los mismos son tag o controles que se visualizan al momento de dar click en cada una de las opciones.

Una pregunta se cae de madura y si no te la haces, la hago yo. Se dieron cuenta que los archivos tienen extensión CSHTML?, la respuesta es el motor de vistas seleccionado RAZOR.

Controladores

Nuevamente recordemos el concepto de MVC. El controlador intercepta los eventos y dependiendo de lo que se desee realizar interactúa, finalmente, con una vista para visualizar algo.

Veamos el contenido de la carpeta Controllers del proyecto.

Contiene dos archivos, uno llamado AccountController.cs y otro llamado HomeController.cs.

Para que tenga sentido estos nombres recordemos que en la carpeta Views encontramos dos subcarpetas. Una llamada Account y otra llamada Home. Por lo tanto AccountController es el controlador de las vistas de la carpeta Account y HomeController el controlador de las vistas que se encuentran la carpeta Home.

Ahora, vamos a ver el contenido de un Controlador. Veamos el archivo HomeController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace DemoMVC3App.Controllers
{
    public class HomeController : Controller
    {
	//Esta método se invoca cuando el usuario da click en la opción HOME.
	//La página de HOME es la página de inicio de la aplicación
        //Para que quede claro diremos que si el website esta en localhost,
	//esta página se visualiza si colocamos en el browser
	//http://localhost o http://localhost:1239/Home/ en la barra de direcciones

	public ActionResult Index()
        {
            ViewBag.Message = "Welcome to ASP.NET MVC!";

            return View();
        }

	//Esta método se invoca cuando el usuario da click en la opción ABOUT.
        //Para que quede claro diremos que si el website esta en localhost
	//Si colocamos en el browser http://localhost:1239/Home/About

        public ActionResult About()
        {
            return View();
        }
    }
}

En este punto y ya casi para terminar este post, debemos de dejar en claro como funciona la vista y el controlador.

• Si en la carpeta Views existe una subcarpeta llamada Home (que agrupa a muchas vistas) en la carpeta Controllers debe de haber un archivo llamado HomeController que será el controlador de las vistas.
• Si dentro de la subcarpeta Home, que hay en Views, existe un archivo llamado Index.cshtml, en el archivo HomeController debe de haber un método public ActionResult Index().

En el siguiente post, vamos a agregar vistas y trabajar con el controlador para que veas lo sencillo que es.

Este tipo de patrón, es común en aplicaciones del tipo Web, donde claramente se puede ver que la interfaz es el código HTML. Otra aplicación , más moderna, de este patrón es en el desarrollo de aplicaciones Móviles.

Si regresamos por un momento al nombre de este post, vamos a notar que esta compuesto por tres palabras Modelo, Vista y Controlador. Aprender estos tres conceptos son, entonces, de suma importancia para aprender como trabaja el patrón.

• Modelo: Esta conformado por los datos que forman parte de la aplicación, engloba los métodos necesarios para acceder (lógica) y manipular los datos.  El modelo debe de ser fácil de entender, y capaz de soportar a la mayor variedad de clientes. Debe de tener una interfaz que permita exponer los métodos para acceder y actualizar el estado de los objetos y ejecutar procesos complejos.  El modelo contiene servicios que son accedidos por el controlador, ya sea para consulta o efectuar algunos cambio de estado. El modelo debe notificar a la vista cuando exista algún cambio de estado.
• Vista: Se encarga de presentar, al cliente, el estado del modelo en un formato adecuado para interactuar. Usualmente es conocida como la interfaz de usuario. La semántica de la presentación se
  encapsulado dentro de la vista, por lo tanto los datos del modelo se puede adaptar para diferentes tipos de clientes. La vista debe de actualizarse cuando hay un cambio en el modelo.
• Controlador: Se encarga de responde a eventos, usualmente acciones del usuario, e invoca peticiones al modelo y, probablemente, a la vista. El controlador se encarga de seleccionar la siguiente vista basado en el usuario de entrada y el resultado de las operaciones del modelo.

Veamos, gráficamente, la interacción entre estos tres componentes:

Para que quede claro el funcionamiento de MVC, analicemos el siguiente ejemplo:

Caso: Imaginemos que hemos desarrollado una página de Registro de Datos. El usuario, luego de ingresar la informacion necesaria, pulsa el botón OK.  En ese momento, el uso de MVC en nuestra aplicación lleva a lo siguiente:

1. El usuario interactúa con la interfaz de usuario, pulsando el botón OK ( o cualquier otro tipo de disparador).
2. El controlador recibe (por parte de los objetos de la vista) la notificación de la acción solicitada por el usuario. El controlador gestiona el evento que llega, frecuentemente a través de un gestor de eventos (handler) o callback.
3. El controlador accede al modelo, actualizándolo, posiblemente modificándolo de forma adecuada a la acción solicitada por el usuario.
4. El controlador delega a los objetos de la vista la tarea de desplegar la interfaz de usuario. La vista obtiene sus datos del modelo para generar la interfaz apropiada para el usuario(según los permisos o roles que tenga)  donde se reflejan los cambios en el modelo. Durante la interacción el controlador no pasa objetos de dominio (el modelo) a la vista aunque puede dar la orden a la vista para que se actualice. Nota: En algunas implementaciones la vista no tiene acceso directo al modelo, dejando que el controlador envíe los datos del modelo a la vista.
5. La interfaz de usuario (vista) espera nuevas interacciones del usuario, comenzando el ciclo nuevamente.

Espero que con este post quede claro lo que significa el modelo vista controlador, dado que lo voy a usar en un próximo post.

Sin importar el lenguaje que utilices, lo importantes es que debes siempre saber que: Al ejecutar una aplicación, el sistema operativo (sea Winodws o Linux) inicia un proceso para la aplicación y le asigna una serie de recursos para poder ejecutarse.

Es sobre este proceso (o llamado también hilo principal de ejecución), es sobre el cual aparece la primera pantalla de nuestra aplicación y se "cuelgan" las demás pantallas para ejecutarse.

Indudablemente que, si tenemos una opción que trabaja con máquinas o servidores ubicados remotamente, la invocación, ejecución y visualización de la información puede demorar más de lo debido. Una forma para aminorar esto o al menos hacer que nuestra aplicación siga ejecutándose de forma normal, mientras se procesa una operación es usar hilos (thread en inglés)

Definamos a un thread, como una unidad (bloque de código) que es ejecutado para realizar una operación determinada que: demora más de lo planeado o se quiere hacer de forma paralela. En ambos caso lo que hace el Sistema Operativo es lanzar un subproceso del proceso principal, de forma que desde el hilo principal de ejecución se desprenden las demás invocaciones. Algunos ejemplos del uso de thread, tenemos:

• Descargas de imágenes
• Invocaciones del servicio Web
• Descargas y cargas de archivos (incluso para las aplicaciones punto a punto)
• Cálculos locales complejos
• Transacciones de base de datos
• Acceso del disco local, dada su baja velocidad relativa al acceso a memoria

Aunque hay varias formas de implementar thread en nuestras aplicaciones, este artículo va a enseñar sólo dos de ellas: AutoResetEvent y usando el componente BackgroundWorker

AutoResetEvent

Notifica que se ha producido un evento a un subproceso en espera y permite que los subprocesos se comuniquen unos con otros mediante señalamientos. Un subproceso espera una señal mediante una llamada a WaitOne en el método que se esta procesando en el AutoResetEvent. Si AutoResetEvent se encuentra en el estado no señalado, el subproceso se bloquea en espera de que el subproceso que controla el recurso en ese momento indique que dicho recurso está disponible mediante una llamada a Set.

A diferencia de BackgroundWorker, no contempla eventos para reportar progreso de ejecución de los hilos (threads) y se debe considerar que los “try catch” van en cada método para el manejo de excepciones que es una diferencia mas con BackgroundWorker.

Figura 1. Sincronización de threads con AutoResetEvent

Es posible que cada hilo se vaya enterando de lo que hace uno anterior mediante los señalamientos que comento en el primer párrafo, sin embargo, para efectos demostrativos únicamente de este artículo se esta tomando en cuenta que se desea sincronizar las tareas y estar al tanto del momento en todas las que se pongan en el ThreadPool hayan terminado.

//Incluir en nuestra clase:
using System.Threading;
.
.
.

//Se instancia la clase, en este caso son tres hilos los que se ilustran
autoEventos = new AutoResetEvent[]
{
  new AutoResetEvent(false),
  new AutoResetEvent(false),
  new AutoResetEvent(false)
};
.
.
.

        //Se pone la tarea pesada por hilo dentro de cada metodo
        void LanzaHilo1(object stateInfo)
        {
            for (int i = 0; i < 300; i++)
            {
                System.Threading.Thread.Sleep(50); //simulando trabajo
            }
            _hilo1Completado = true;
            //Se libera recurso
            autoEventos[0].Set();
        }

        void LanzaHilo2(object stateInfo)
        {
            for (int a = 0; a < 100; a++)
            {
                System.Threading.Thread.Sleep(50); //simulando trabajo
            }
            _hilo2Completado = true;
            //Se libera recurso
            autoEventos[1].Set();
        }
.
.
.
        //Se lanzan los hilos
        string LanzaHilosJuntos()
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(LanzaHilo1));
            ThreadPool.QueueUserWorkItem(new WaitCallback(LanzaHilo2));
            ThreadPool.QueueUserWorkItem(new WaitCallback(LanzaHilo3));

            WaitHandle.WaitAll(autoEventos);

            label1.ForeColor = Color.Blue;
            label2.ForeColor = Color.Blue;
            label3.ForeColor = Color.Blue;

            return "Hilos terminados";
        }

Nota: En caso de implementar el código y que se presente un error del tipo “WaitAll For Multiple Handles on a STA Thread Is Not Supported”, existen dos posibles soluciones, la primera es en el program.cs de la aplicación cambiar el atributo [STAThread] por [MTAThread] y con esto indicamos que nuestra aplicación es multiprocesos; la otra solución es usar ManualResetEvent en vez de AutoResetEvent.

BackgroundWorker

El componente BackgroundWorker proporciona la capacidad de ejecutar operaciones que llevan mucho tiempo de forma asincrónica ("en segundo plano"), en un subproceso diferente del subproceso principal de la interfaz de usuario de la aplicación. Para utilizar BackgroundWorker, simplemente hay que indicarle el método de trabajo cuya ejecución en segundo plano lleva mucho tiempo y, a continuación, llamar al método RunWorkerAsync . RunWorkerAsync toma un parámetro object opcional, que se utiliza para pasar argumentos al método de trabajo. Este método de trabajo es el evento DoWork que la clase BackgroundWorker expone, es en donde se pone la carga de trabajo que tardará tanto tiempo. Cuando finaliza el método, BackgroundWorker avisa al subproceso que hace la llamada desencadenando el evento RunWorkerComplete, que puede contener los resultados de la operación y que es en donde podemos tener acceso a la interfaz de la aplicación.

Usando BackgroundWorker se recomienda el uso de excepciones sobre los parámetros que devuelve DoWork en los argumentos que se pasan a RunWorkerComplete mediante “e.Error” en vez de usar un “try catch” por cada llamada.

Figura 2. Realizando tareas en segundo plano con BackgroundWorker

Para conocer las mejores prácticas en el subprocesamiento administrado te recomiendo que visites: http://msdn.microsoft.com/es-es/library/1c9txz50(v=VS.80).aspx

//Se inicializa el componente para cada hilo
BackgroundWorker _hilo1 = new BackgroundWorker();
_hilo1.DoWork += new DoWorkEventHandler(_hilo1_DoWork);
_hilo1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_hilo1_RunWorkerCompleted);
_hilo1.ProgressChanged += new ProgressChangedEventHandler(_hilo1_ProgressChanged);

//Se manda llamar el metodo para ejecutar la tarea pesada
_hilo1.RunWorkerAsync();

BackgroundWorker _hilo2 = new BackgroundWorker();
_hilo2.DoWork += new DoWorkEventHandler(_hilo2_DoWork);
_hilo2.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_hilo2_RunWorkerCompleted);
_hilo2.ProgressChanged += new ProgressChangedEventHandler(_hilo2_ProgressChanged);

_hilo2.RunWorkerAsync();
.
.
.
        //Empieza el trabajo pesado
        void _hilo2_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker bw = sender as BackgroundWorker;
            for (int i = 0; i < 100; i++)
            {
                System.Threading.Thread.Sleep(50); //simulando trabajo
                bw.WorkerReportsProgress = true;
                bw.ReportProgress(i);
            }
            e.Result = true;
        }

        //Se completa el trabajo pesado y ya se tiene acceso a la interfaz de usuario
        void _hilo2_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            lblProgresoTotal.Text = "Hilo 2 completado";
            hilo2Completado = Convert.ToBoolean(e.Result);
            txtHilo2.Enabled = false;
            label2.ForeColor = Color.Blue;
            lblProgresoHilo2.ForeColor = Color.Blue;

            if (hilo1Completado && hilo2Completado && hilo3Completado)
                btnComienzaHilos.Enabled = true;
        }

        //Progreso del trabajo asignado en DoWork
        void _hilo2_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            lblProgresoHilo2.Text = e.ProgressPercentage.ToString() + "%";
            txtHilo2.Text = txtHilo2.Text + e.ProgressPercentage.ToString() + Environment.NewLine;
        }

Demo

En el código que se adjunta, se muestra de forma sencilla una manera de usar AutoResetEvent y BackgroundWorker así como la principal diferencia entre ambos.

Conclusión

Cuando se usa BackgroundWorker se tiene la flexibilidad de tener acceso a la interfaz de usuario desde RunWorkerCompleted una vez que se van completando las tareas en segundo plano.

AutoResetEvent es de gran ayuda cuando es necesario realizar varios procesos al mismo tiempo con la funcionalidad de sincronización de tareas para esperar el término de cada hilo y poder hacer uso del resultado de cada uno en un proceso posterior.

Ambos casos (AutoResetEvent y BackgroundWorker) ven en aumento su performance con las maquinas de los últimos años que contienen núcleos con más de un procesador, ya que realmente pueden ejecutar varios procesos paralelos.

Fuentes AutoResetEvent

http://msdn.microsoft.com/es-es/library/system.threading.autoresetevent(v=VS.90).aspx

http://blogs.msdn.com/b/johnlee/archive/2007/07/10/waithandle-waitall-for-multiple-handles-on-a-sta-thread-is-not-supported.aspx

Fuentes BackgroundWorker

http://msdn.microsoft.com/es-es/library/ms233672(v=VS.80).aspx

http://msdn.microsoft.com/es-es/library/8xs8549b(VS.80).aspx

http://dotneat.iloire.com/2010/03/06/ejemplo-backgroundworker-en-csharp/

En esta oportunidad veremos, a partir de una aplicación Consola, como podemos acceder a la configuración regional y luego definir una para poder aplicarla dentro de nuestra aplicación, sin tener la necesidad de cambiar la de nuestro sistema operativo.

Comenzaremos diciendo que para poder utilizar las clases que indicaré, debes de asegurarte de tener referencia al siguiente namespace:

using System.Globalization;

Utilizar este namespace nos permite acceder, entre otras cosas, a la clase CultureInfo. Esta clase es la que nos va a permitir trabajar con la cultura actual y cambiarla dentro de nuestra aplicación.

Veamos como podemos acceder a la cultura actual de nuestra aplicación obtener sus principales características:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//Namespace
using System.Globalization;

namespace CultureInfoConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            //Obtenemos la Cultura Actual
            CultureInfo culturaactual = CultureInfo.CurrentCulture;
            //CultureInfo culturaactual=CultureInfo.CurrentCulture;
            //INFORMACION
            Console.WriteLine("CompareInfo: {0}", culturaactual.CompareInfo);
            Console.WriteLine("DisplayName : {0}", culturaactual.DisplayName);
            Console.WriteLine("EnglishName: {0}", culturaactual.EnglishName);
            Console.WriteLine("IsNeutralCulture: {0}", culturaactual.IsNeutralCulture);
            Console.WriteLine("IsReadOnly: {0}", culturaactual.IsReadOnly);
            Console.WriteLine("LCID: {0}", culturaactual.LCID);
            Console.WriteLine("Name: {0}", culturaactual.Name);
            Console.WriteLine("NativeName: {0}", culturaactual.NativeName);
            Console.WriteLine("Parent: {0}", culturaactual.Parent);
            Console.WriteLine("TextInfo: {0}", culturaactual.TextInfo);
            //MONEDA
            Console.WriteLine("CurrencySymbol: {0}", culturaactual.NumberFormat.CurrencySymbol);
            Console.WriteLine("CurrencyDecimalSeparator: {0}", culturaactual.NumberFormat.CurrencyDecimalSeparator);
            Console.WriteLine("CurrencyDecimalDigits: {0}", culturaactual.NumberFormat.CurrencyDecimalDigits);
            //FECHA y HORA
            Console.WriteLine("ShortDatePattern: {0}", culturaactual.DateTimeFormat.ShortDatePattern);
            Console.WriteLine("DateSeparator: {0}", culturaactual.DateTimeFormat.DateSeparator);
            Console.WriteLine("ShortTimePattern: {0}", culturaactual.DateTimeFormat.ShortTimePattern);
            Console.WriteLine("TimeSeparator: {0}", culturaactual.DateTimeFormat.TimeSeparator);

            Console.WriteLine("\nDias de la semana : ");
            foreach (string s in culturaactual.DateTimeFormat.DayNames)
            { Console.Write("{0} " ,s.ToUpper() ); }

            Console.WriteLine("\nMeses del año : ");
            //MESES DEL AÑO
            foreach (string s in culturaactual.DateTimeFormat.MonthNames )
            { Console.Write("{0} ",s.ToUpper()); }

             Console.ReadLine();

        }
    }
}

En el código anterior, como puedes apreciar, he obtenido la cultura de nuestra aplicación a través de: CultureInfo.CurrentCulture, y a partir de esto podemos acceder a la características propia de la cultura.

En mi caso, mi cultura por defecto es "en-US", pero esto no es impedimento para que pueda cambiarla dentro de mi aplicación, mira el siguiente ejemplo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
//Namespace
using System.Globalization;

namespace CultureInfoConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            //Definimos una nueva cultura
            CultureInfo nuevacultura = new System.Globalization.CultureInfo("es-PE", false);
            //Asignamos la nueva cultura a nuestra aplicación
            System.Threading.Thread.CurrentThread.CurrentCulture = nuevacultura;
            //Obtenemos la Cultura Actual
            CultureInfo culturaactual = CultureInfo.CurrentCulture;
            //CultureInfo culturaactual=CultureInfo.CurrentCulture;
            //INFORMACION
            Console.WriteLine("CompareInfo: {0}", culturaactual.CompareInfo);
            Console.WriteLine("DisplayName : {0}", culturaactual.DisplayName);
            Console.WriteLine("EnglishName: {0}", culturaactual.EnglishName);
            Console.WriteLine("IsNeutralCulture: {0}", culturaactual.IsNeutralCulture);
            Console.WriteLine("IsReadOnly: {0}", culturaactual.IsReadOnly);
            Console.WriteLine("LCID: {0}", culturaactual.LCID);
            Console.WriteLine("Name: {0}", culturaactual.Name);
            Console.WriteLine("NativeName: {0}", culturaactual.NativeName);
            Console.WriteLine("Parent: {0}", culturaactual.Parent);
            Console.WriteLine("TextInfo: {0}", culturaactual.TextInfo);
            //MONEDA
            Console.WriteLine("CurrencySymbol: {0}", culturaactual.NumberFormat.CurrencySymbol);
            Console.WriteLine("CurrencyDecimalSeparator: {0}", culturaactual.NumberFormat.CurrencyDecimalSeparator);
            Console.WriteLine("CurrencyDecimalDigits: {0}", culturaactual.NumberFormat.CurrencyDecimalDigits);
            //FECHA y HORA
            Console.WriteLine("ShortDatePattern: {0}", culturaactual.DateTimeFormat.ShortDatePattern);
            Console.WriteLine("DateSeparator: {0}", culturaactual.DateTimeFormat.DateSeparator);
            Console.WriteLine("ShortTimePattern: {0}", culturaactual.DateTimeFormat.ShortTimePattern);
            Console.WriteLine("TimeSeparator: {0}", culturaactual.DateTimeFormat.TimeSeparator);
            Console.WriteLine("\nDias de la semana : ");
            foreach (string s in culturaactual.DateTimeFormat.DayNames)
            { Console.Write("{0} " ,s.ToUpper() ); }
            Console.WriteLine("\nMeses del año : ");
            //MESES DEL AÑO
            foreach (string s in culturaactual.DateTimeFormat.MonthNames )
            { Console.Write("{0} ",s.ToUpper()); }
            Console.ReadLine();

        }
    }
}

En la primera línea, dentro de Program, puedes apreciar que estoy definiendo una cultura "es-PE", español Perú, la cual la asigno como cultura actual de mi aplicación.

Hacer esto, entre otras cosas, me permite acceder a los nombres del día y mes en el idioma correcto y poder hacer algo con estas posteriormente.

Como puedes apreciar, manejar las culturas en nuestras aplicaciones, es bastante sencillo, permitiéndonos personalizar nuestra aplicación dependiendo del idioma que desees ejecutar. En un próximo post veremos como hacerlo con una aplicación Windows.

Mi objetivo en este post es ayudarte a consumir este servicio, desde una simple aplicación del tipo consola para que veas lo fácil que es.

Antes de empezar te diré que voy a trabajar sobre la solución anterior, agregando a ésta los proyectos que voy a ir mencionando.

Paso 1. Crear un WCF Service Application

Luego de abrir la solución anterior, con el servicio definido, vamos a adicionar un WCF Service Application.

Esto agregará a la solución una aplicación, con dos clases por defecto, las cuales deberás eliminar. Mira la siguiente figura.

Luego de eliminado los dos archivos, voy a renombrar Service1.svc por MiServicio.svc. De forma que el proyecto quede de la siguiente forma:

Paso 2. Referenciar al WCFServiceLibrary creado

Recuerda que en el post anterior, creamos el servicio en un WCFServiceLibrary, por lo que ahora, en el proyecto que acabamos de agregar en el paso anterior, vamos a referenciarlo. Recuerda que basta con dar clic derecho del mouse sobre el proyecto WCF Service Application y pulsar Add Reference.

En la pantalla que aparece, escogemos el tab de Proyects y seleccionamos el proyecto que contiene nuestro servicio definido.

Paso 3. Apuntando al servicio correcto

Luego de agregada la referencia, vamos a indicarle a nuestro proyecto WCF Service Application que apunte al servicio definido.

Para hacer esto, seleccionaremos MiServicio.svc

y damos clic derecho para ingresar a la opción View Code, o pulsamos simplemente F7, luego de seleccionar el archivo.

Al acceder a esta opción, podremos visualizar el siguiente código:

<%@ ServiceHost Language="C#" Debug="true" Service="WcfService1.Service1" CodeBehind="Service1.svc.cs" %>

Este código hace referencia al Servicio, por lo que debemos de cambiar la sección de Service y eliminar el bloque de CodeBehind, dejando el código de la siguiente forma.

<%@ ServiceHost Language="C#" Debug="true" Service="WCFServiceLibrary.MiServicio"%>

Recuerda que en el paso anterior hicimos referencia al WCF Service Library definido, y es allí donde encontramos el servicio WCFServiceLibrary.MiServicio, por lo que podemos usarlo sin ningún problema.

Luego de realizar los cambios, ejecutemos la aplicación creada para ver si todo esta OK.

Te debe de salir lo siguiente:

Ya que nos aseguramos que el servicio funciona adecuadamente, vamos a crear un proyecto del tipo consola.

Paso 4: Crear un Proyecto del Consola

No voy a explicar mucho en este paso, porque ya hemos creado muchos proyectos consola en el blog. Lo único que aclararé es que debes de adicionar el proyecto a la solución que contiene hasta entonces dos proyectos, uno del tipo WCF Service Library y el WCF Service Application.

Paso 5: Referenciar  System.ServiceModel

Al Proyecto consola le vamos a agregar referencia, en primer lugar al Assembly System.ServiceModel. Recuerda que para hacer esto basta con ir a la opción Add Reference, y en la pantalla que aparece, buscar System.ServiceModel en el tab .Net.

Paso 6: Referenciar  el Servicio Creado

Bueno, para poder usar el Servicio WCF, debemos de referenciarlo. Para hacer esto debemos de dar clic derecho del mouse sobre el proyecto Consola y seleccionar la opción Add Service Reference. En la pantalla que aparece seleccionamos Discover-> Services in Solution

Aparecerán listados los servicios que tenemos, seleccionaremos el que dice MiServicio.svc. Mira la siguiente imagen.

Aprecia que he cambiado también el Namespace, en la parte inferior.

Luego de seleccionar el servicio y cambiar el Namespace, pulsar OK.

Paso 7: Codificar la invocación a las Operaciones del Servicio

Cambiar el código de Progrma.cs del proyecto Consola por el siguiente:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel; //Referencia al Assembly Referenciado

namespace ConsoleApplicationRunService
{
    class Program
    {
        static void Main(string[] args)
        {
            //Definición del Cliente al Servicio referenciado
            MiServicioReference.MiServicioClient cliente = new
					MiServicioReference.MiServicioClient();
            //Invocación a la Operación Factorial
            Console.WriteLine("El Factorial de 5 es : {0}",cliente.Factorial(5));
            Console.WriteLine("Los 10 Primeros numeros Fibonacci son : ");
            //Invocación a la Operación Numeros_Fibonacci
            foreach (int i in cliente.Numeros_Fibonacci(10))
                Console.WriteLine("{0}", i);
            //Invocación a la Operación Sumatoria_Fibonacci

            Console.WriteLine("La suma de los 10 primero numeros fibonacci es : {0}",
					cliente.Sumatoria_Fibonacci(10));
            Console.ReadLine(); 

        }
    }
}

Ejecuta la aplicación y puedes apreciar que se invoca al servicio WCF creado, mostrando en pantalla el resultado de la invocación a éstos.

Microsoft desde ya hace unos años, viene trabajando con el concepto de  Windows Communication Foundation (WCF).  Voy a transcribir la definición oficial de WCF que nos da Microsoft en su página web.

Windows Communication Foundation (WCF) es un marco de trabajo para la creación de aplicaciones orientadas a servicios. Con WCF, es posible enviar datos como mensajes asincrónicos de un extremo de servicio a otro. Un extremo de servicio puede formar parte de un servicio disponible continuamente hospedado por IIS, o puede ser un servicio hospedado en una aplicación. Un extremo puede ser un cliente de un servicio que solicita datos de un extremo de servicio. Los mensajes pueden ser tan simples como un carácter o una palabra que se envía como XML, o tan complejos como una secuencia de datos binarios. A continuación se indican unos cuantos escenarios de ejemplo:

• Un servicio seguro para procesar transacciones comerciales.
• Un servicio que proporciona datos actualizados a otras personas, como un informe sobre tráfico u otro servicio de supervisión.
• Un servicio de chat que permite a dos personas comunicarse o intercambiar datos en tiempo real.
• Una aplicación de panel que sondea los datos de uno o varios servicios y los muestra en una presentación lógica.
• Exponer un flujo de trabajo implementado utilizando Windows Workflow Foundation como un servicio WCF.
• Una aplicación de Silverlight para sondear un servicio en busca de las fuentes de datos más recientes.

Gráficamente, veamos que podemos ganar implementando servicios WCF al momento de desarrollar nuestras aplicaciones.

Como podemos apreciar, WCF nos brinda un canal seguro de comunicación (a través de contratos) no solo entre aplicaciones de una misma máquina, sino a través de una red que puede estar conformada por servidores Windows o Linux (Interoperabilidad).

Bueno, basta de teoría y veamos como crear un proyecto del tipo WCF en Visual Studio 2010 y utilizando las características que nos da el .Net Framework 4.0

Paso 1: Definir el Contrato

Cuando hablamos de servicios, recuerda que siempre debe de haber un proveedor y un consumidor del servicio, por lo que es necesario definir cómo se llevará la comunicación entre estos dos entes. A este proceso le llamaremos: Definición del Contrato.

En el Contrato definiremos básicamente lo siguiente:

• Las operaciones que se podrán realizar.
• Las firmas y los tipos de datos que se enviarán y/o recibirán durante la invocación de las operaciones.
• Los protocolos y formatos de serialización que se utilizan para llevar a cabo la comunicación.

Luego de definido esto, recién podemos llevarlo a la programación.

Para el ejemplo voy a definir algo bastante sencillo. Haremos un contrato para permitir la realización de las siguientes operaciones básicas:

• Factorial de un número

  long Factorial(long x);

• Devolver una Lista de enteros, con los "n" primeros números de la serie de Fibonacci.

  List<int> Numeros_Fibobacci(int n);

• Suma de los primeros "n" números de la serie de Fibonacci.

  double Sumatoria_Fibonacci(int n);

Paso 2: Creando un Proyecto del Tipo WCF Service Library

Luego de definido las operaciones y el contrato, vamos a crear una aplicación del tipo WCF Service Library, para implementarlos.

Luego de creada la aplicación te pediría que borres los archivos IService1.cs y Service1.cs para que aprendamos a crear los servicios, sin necesidad de una ayuda.

Luego de borrar ambos archivos, vamos a adicionar (Add New Item) a nuestro proyecto una Clase (llamado MiServicio) y una Interface (llamada IMiServicio). Te dejo la siguiente imagen para que veas a lo que me refiero.

Luego de creada la Clase y la Interface, debes de adicionar el siguiente using en ambas:

using System.ServiceModel;

Ahora si, vamos a programar las operaciones que hemos definido dentro de nuestro contrato. Empezaremos con la Interface.

Paso 3: Codificando la Interface

Luego de agregada la referencia, debemos de adicionar un atributo a nuestra interface, el atributo es [ServiceContract], quedando nuestro código de la siguiente forma:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace WCFServiceLibrary
{
    [ServiceContract]
    public interface IMiServicio
    {

    }
}

Ahora codificaremos sólo  las firma de nuestra operaciones anteponiendo a cada una el atributo [OperationContract] , quedando nuestro código de la siguiente forma:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace WCFServiceLibrary
{
    [ServiceContract]
    public interface IMiServicio
    {
        [OperationContract]
        long Factorial(long x);

        [OperationContract]
        double Sumatoria_Fibonacci(int n);

        [OperationContract]
        List<int> Numeros_Fibobacci(int n);

    }
}

Paso 4: Codificando la Clase

Terminada la Interface, debemos de implementar cada Operación, esto lo hacemos en la clase, por lo que debemos de indicar, mediante un identificador, que la clase va a implementar los métodos definidos en la Interface.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace WCFServiceLibrary
{
    //Al momento de definir la clase, indicamos que implementará los
    //métodos de la Interface IMiServicio
    public class MiServicio:IMiServicio
    {

    }
}

Luego implementamos los métodos que hemos definido.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ServiceModel;

namespace WCFServiceLibrary
{
    //Al momento de definir la clase, indicamos que implementará los
    //métodos de la Interface IMiServicio
    public class MiServicio:IMiServicio
    {
        public long Factorial(long x)
        {
            if (x <= 1 ) return 1;
            else
            {
                return x*Factorial(x - 1);
            }
        }

        public double Sumatoria_Fibonacci(int n)
        {
            List<int> numeros = Numeros_Fibobacci(n);
            return numeros.Sum();
       }

        public List<int> Numeros_Fibobacci(int n)
        {
            List<int> numeros = new List<int>();
            int a, b, c;
            a = 1;
            b = 0;
            for (int i = 0; i < n;i++ )
            {
                c = a + b;
                numeros.Add(c);
                a = b;
                b = c;

            }
            return numeros;
        }

    }
}

Como puedes apreciar, la implementación de las operaciones la he utilizado de forma normal, sin ningún operador o atributo diferente a los que ya conoces.

Paso 5: Cambiando el Archivo de Configuración

Luego de definir el contrato, es necesario publicarlo para que pueda ser consumido, esto lo hacemos colocando el nombre del servicio, donde esta publicado, y el tipo de enlace que permitirá.

Voy a colocar parte del App.config para que veas que información se coloca por cada uno de los servicios:

<system.serviceModel>
    <services>
	<!-- Nombre del Servicio (Namespace.NombreClase) -->
      <service name="WCFServiceLibrary.MiServicio">
        <host>
          <!-- Direccion del Servicio-->
	  <baseAddresses>
            <add baseAddress = "http://localhost:8732/Design_Time_Addresses/WCFServiceLibrary/MiServicio/" />
          </baseAddresses>
        </host>
        <!-- Service Endpoints -->
        <!-- Unless fully qualified, address is relative to base address supplied above -->
        <endpoint address ="" binding="wsHttpBinding" contract="WCFServiceLibrary.IMiServicio">
          <!--
              Upon deployment, the following identity element should be removed or replaced to reflect the
              identity under which the deployed service runs.  If removed, WCF will infer an appropriate identity
              automatically.
          -->
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>
        <!-- Metadata Endpoints -->
        <!-- The Metadata Exchange endpoint is used by the service to describe itself to clients. -->
        <!-- This endpoint does not use a secure binding and should be secured or removed before deployment -->
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange"/>
      </service>
    </services>

Luego de realizar los cambios podemos probar nuestros servicios, ejecutando nuestra aplicación con F5

Paso 6: Probando nuestro Servicio WCF

Al ejecutar la aplicación creada, Visal Studio, ejecuta WCF Test Client, añadiendo el servicio creado y las operaciones que este contempla, de forma que podremos probar si estas se ejecutan adecuadamente.

Para probar cada operación, basta con dar doble clic en una de ellas y en la pantalla que aparece, dar valores a los datos requeridos para luego invocarlos.  Mira la siguiente imagen, donde pruebo la Función Factorial para un valor de x=5.

Como podrás ver, es bastante sencillo implementar un servicio WCF. Si bien es cierto he usado operaciones bastante sencillas, tu puedes utilizar lo aprendido aquí para trabajar con Base de Datos, por ejemplo, de forma que trabajes a través de servicios que a su vez puedan ser aprovechadas por otras aplicaciones. Espero te sea de ayuda este post para tus trabajos posteriores.

En busca de esta comunicación, una de las Arquitecturas más usadas actualmente para el desarrollo de aplicaciones que existe es SOA (Arquitectura Basada en Servicios). SOA, no es un lenguaje ni un software, es un modelo que debemos seguir para implementar aplicaciones y que éstas puedan exponer ciertos "servicios", que pueden ser invocados o consumidos por otras aplicaciones.

Te muestro un ejemplo, digamos que acabas de terminar de desarrollar, para una misma empresa, dos aplicaciones , una aplicación encargada de manejar el ingreso y salida de materiales (Logística) y otra encargada de abastecimiento de materiales (Compra).

Imagínate ahora que son las mejores aplicaciones que hiciste hasta ahora, funcionan excelente, pero existe un pequeño problema. El encargado de comprar el material, no recibe notificación alguna cuando el material solicitado llega y vuelve a pedir más de ese mismo material. O peor aún, el encargado de logística a pesar de tener controlado su ingreso y salida de materiales, no expone esta información al resto de áreas de la empresa. En conclusión, pueden ser dos buenas aplicaciones pero funcionan como una isla, no se comunican, dificultando que la información fluya por las diversas áreas una misma empresa, como puedes ver este es un gran problema.

Si este ejemplo pasa en dos aplicaciones realizadas por una misma persona, imagínate que puede pasar con aplicaciones realizadas por diversos proveedores y quizás en diversas plataformas.

SOA, lo que propone es un modelo de trabajo donde las aplicaciones que se realizan, expongan parte de sus responsabilidades a otras que lo necesiten de forma que podamos armonizar el trabajo. Si hablamos de una empresa, para que podamos armonizar y soportar el trabajo entre la diversas áreas: Logística, Compras, Ventas, Finanzas, Contabilidad, etc . Ahora, esto no es una tarea sencilla, implica un arduo trabajo .

SOA, promueve la exposición de servicios por parte de una aplicación hacia otra, por lo que debemos tener en claro los siguiente conceptos:

Como puedes apreciar, no es una tarea sencilla. Es una tarea ardua de coordinación permanente, que empieza con una buena definición de los procesos y luego de las aplicaciones que den soporte a los procesos definidos.

SOA promueve el uso de servicios como exposición de las responsabilidades entre los aplicaciones (o sistemas) y para desarrollar esto ha encontrado en los Servicios Web, la mejor forma de poder implementar este concepto, dado que permite a un proveedor publicar un servicio y al consumidor consumirlo, utilizando un soporte independiente como los son WSDL (Estándar que permite definir cualquier servicio Web) y SOAP (Protocolo que define y permite como se puede intercambiar información, mediante el uso de XML). Veamos el siguiente gráfico

Como podemos ver en el gráfico anterior, podemos ver que como interactúan los proveedores con los consumidores sin importar de la plataforma que estamos hablando.

Ahora, si colocamos un concepto adicional como Orquestación vemos que la arquitectura SOA, toma un grado mayor de complejidad, debido a que estamos hablando no sólo de WSDL y SOAP, sino de conceptos como Seguridad, Transacción, Administración, Registro, etc, siendo estos siempre soportados por estándares independientes de los lenguajes en este caso, los WS.

Ahora, SOA, no es sólo servicios, bueno si lo es, pero siempre debemos ir un poco más allá, trabajar con SOA permite reutilizar los servicios existentes para construir otros, mejores o más complejos, de forma que podamos aprovechar el trabajo realizado anteriormente y no estar constantemente empezando desde cero. Pensar en servicios que pueden ser aprovechados por otros, permite realizar un mejor trabajo tanto dentro como fuera de tu organización.

Mira el siguiente gráfico para que veas los cambios que propone SOA en el desarrollo de aplicaciones.

SOA es realmente un tema bastante amplio, por lo que sólo he escrito acerca de las generalidades de esta arquitectura, te recomiendo leer más, dado que SOA viene siendo usado actualmente, esta en auge, y con las herramientas que tienen los lenguajes de programación puedes implementar mejores servicios para tus aplicaciones.

Antes de empezar a analizar el código, diremos que Visual Studio 2008, permite crear proyectos del tipo Office; es decir, ya viene preparado para crear aplicaciones (Add-ins) no sólo con MS Word, sino con MS Excel, MS Outlook, de una forma bastante sencilla, pero no voy a usar esa opción.

Lo que voy a hacer es mediante un proyecto ClassLibrary, interactuar con el Assembly (Interop) que me permite trabajar con MS Word, como si fuera una clase mas. Este Assembly viene con Visual Studio 2008, pero si por alguna razón no lo tienes, te dejo este link: http://msdn.microsoft.com/es-es/library/15s06t57(VS.80).aspx

Bueno, empezaremos creando un proyecto del tipo ClassLibrary al cual le voy a agregar la siguiente referencia: Microsoft.Office.Interop.Word. Para MS Office 2007, la versión de este Assembly es la 12.0, para MS Office 2003, es la 11.0.

Luego que ya esta creado el proyecto ClassLibrary y hemos añadido la referencia antes indicada, debes de agregar este línea en el código de nuestra clase.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Word = Microsoft.Office.Interop.Word; //Agrega esta línea

Agregada la línea anterior, voy colocar un método a la clase del ClassLibrary, de forma que podamos: crear una instancia de una aplicación MSWord, agregarle un Documento para poder escribir y luego insertar texto en el documento.

Te dejo el código:

public class Reporte
{

        public void EscribirenunDocumentoWord()
        {
            //Objeto del Tipo Word Application
            Word.Application objWordApplication;
            //Objeto del Tipo Word Document
            Word.Document objWordDocument;
            // Objeto para interactuar con el Interop
            Object oMissing = System.Reflection.Missing.Value;

            //Creamos una instancia de una Aplicación Word.
            objWordApplication = new Word.Application();
            //A la aplicación Word, le añadimos un documento.
            objWordDocument = objWordApplication.Documents.Add(ref oMissing,
                                                             ref oMissing,
                                                             ref oMissing,ref oMissing );

            //Activamos el documento recien creado, de forma que podamos escribir en el
            objWordDocument.Activate();
            //Empezamos a escribir
            objWordApplication.Selection.TypeText("Este es un ejemplo desarrollado por ");
            objWordApplication.Selection.TypeText("COPSTONE, esperamos que sea útil y ");
            objWordApplication.Selection.TypeText(" que te ayude a crear nuevas y  ");
            objWordApplication.Selection.TypeText("mejores aplicaciones. ");
            //Indicamos que el texto anterior es parte de un párrafo.
            objWordApplication.Selection.TypeParagraph();

            //Ahora veamos como cambiar el tipo y tamaño de la letra

            objWordApplication.Selection.Font.Name="Arial" ; //Cambiamos el nombre
            objWordApplication.Selection.Font.Size= 19; //Cambiamos el tamaño
            //Alinearemos el texto que vamos a escribir al centro
            objWordApplication.Selection.ParagraphFormat.Alignment=
               Microsoft.Office.Interop.Word.WdParagraphAlignment.wdAlignParagraphCenter ;
            //Agregamos al texto
            objWordApplication.Selection.TypeText("Hecho por Copstone 2010");
            //Indicamos que el texto anterior es un párrafo
            objWordApplication.Selection.TypeParagraph();
            //Hace visible la Aplicacion para que veas lo que se ha escrito
            objWordApplication.Visible = true; 

        }

Ahora, si quieres automatizar mas cosas como insertar tablas, imágenes, debes de empezar con leer el esquema del objeto MSWord, te dejo un link donde puedes encontrar mayor información: http://msdn.microsoft.com/en-us/library/kw65a0we(VS.80).aspx

Espero que este post te sea de mucha ayuda y si tienes alguna duda, deja un comentario.

Para lo que no conocen de Silverlight, les puedo que esta herramienta es de Microsoft y es la propuesta que viene manejando esta compañía para crear aplicaciones web con mayores funciones multimedia, esto incluye videos, gráficos, animaciones, etc. Si, porque no decirlo, es la competencia de Adobe Flash.

En esta ocasión vamos a ver ejemplos acerca de Silverlight 4.0, para que veas lo sencillo que es esta herramienta, para tal efecto tengo instalado en mi PC, Visual Studio 2010 y Silverlight 4.0 RC2.

Creando una Aplicación Silverlight 4.0

Visual Studio 2010, tiene el mismo menú que sus versiones anteriores, por lo que accediendo a :

File-> New->Project, podemos acceder a la ventana con todos los tipos de proyecto que podemos crear, en esta ocasión seleccionaré Silverlight, en Installed Templates y Silverlight Application como tipo de apliación. Ambos siempre en C#. Te dejo la imagen para que te orientes:

Luego de pulsar el botón de OK, accedemos a la siguiente ventana, donde podemos escoger la versión de Silverlight que vamos a utilizar. En este punto es necesaria una aclaración. Visual Studio 2010, trae por defecto Silverlight 3, pero instalando las Silverligth 4.0 RC2, podemos trabajar con ambas versiones.

Damos OK y listo, obtenemos lo siguiente:

En la figura podemos observar 3 secciones:

• Sobre la derecha de la imagen, tenemos nuestro conocido Solution Explorer  con dos proyectos. Uno con el componente Silverlight (donde se encuentran archivos con extensión xaml) y otro una aplicación Web, donde se incrustará el componente y podrá ser visualizado.
• Sobre la parte central, tenemos nuestra área de trabajo (Layout), haciendo una analogía con una  Web Application, vendría a ser nuestro formulario.
• En la parte inferior, tenemos el código del formulario, esta sección se va actualizando conforme vamos agregando componentes o modificando opciones.

Colocando un Label

Como puedes apreciar, trabajar con una Aplicación Silverlight, no va a ser nada del otro mundo. Es más, para cumplir con el objetivo del post,  veremos que el toolbox es muy parecido al que ya estamos acostumbrado y existen casi los mismos controles. Voy a utilizar un Label y lo colocaré en mi área de trabajo.

Terminando de Colocar el Label, podemos apreciar que este aparece con dos flechas, las cuales te ayudarán a ubicar mejor el componente en la región que desees.

Y en la parte inferior, como puedes apreciar, se ha actualizado el código.

Para trabajar con las propiedades del componente, lo puedes hacer de la forma tradicional: Accediendo a Properties (con F4, de manera rápida) y allí cambiar la propiedad necesaria. Otra forma de cambiar el valor de las propiedades es hacerlo a través del código, agregando el nombre la propiedad y el valor. Esto es lo que voy a hacer yo.

<Grid x:Name="LayoutRoot" Background="White">
        <sdk:Label Height="28" HorizontalAlignment="Left" Margin="62,49,0,0"
        Name="Label1" VerticalAlignment="Top" Width="120"
        Content="Hola Mundo"/>
    </Grid>

Como podrás ver, le he colocado al código al ya existente, Content="Hola Mundo".

Veamos que más podemos hacer:

<Grid x:Name="LayoutRoot" Background="White">
        <sdk:Label Height="28" HorizontalAlignment="Left" Margin="62,49,0,0"
        Name="Label1" VerticalAlignment="Top" Width="120"
        Content="Hola Mundo"FontFamily="Arial Black" FontSize="20"
	Background="Salmon" Foreground=" Blue"/>/>
    </Grid>

Si analizas el código, puedes apreciar, que he realizado cambios sobre la fuente: Familia, Size, Background y Foreground.

Una aclaración necesaria, el color por defecto del Layout, es White, eso dice en la primera línea del código que estoy colocando:

<Grid x:Name="LayoutRoot" Background="White">

Ahora,si cambio este valor puedo tener este efecto:

<Grid x:Name="LayoutRoot" Background="Salmon">
        <sdk:Label Height="30" HorizontalAlignment="Left" Margin="62,49,0,0"
	Name="Label1" VerticalAlignment="Top"
	Width="132" Content="Hola Mundo" FontFamily="Arial Black"
        FontSize="20" Foreground=" Blue"/>
    </Grid>

Espero que a partir de ahora puedas involucrarte más en el mundo de las aplicaciones Web, utilizando Silverlight como herramienta para desarrollarlas.