Sobre C# 3.0 y las declaraciones de tipos implícitos

Hola ¿Qué tal?


Ahora que se ha liberado el beta 1 de Orcas, es momento de empezar a hablar de las nuevas características del lenguaje, claro que aun pueden tener cambios sin embargo es bueno ir viendo ya lo que trae. Una de las nuevas características del lenguaje es lo referente a la declaración de variables. La declaración de variables en C# 2.0 y anteriores es simple, pues es únicamente un par de palabras ordenadas poniendo en primer lugar el tipo de dato y en seguida el nombre de la variable. Los nombres de las variables siguen ciertas reglas, entre estas está la restricción del uso de números como inicio del nombre de la variable, se restringe el uso de caracteres reservados para el lenguaje y solo se permite el uso del guión bajo, acentos, letras y números. Cabe hacer notar que la eñe [ñ] es permitida como parte del nombre de la variable sin problemas, así que si es necesario utilizar ñ para declarar variables como “año”, “tamaño” se puede usar sin problemas. Un ejemplo de la declaración de variables como los conocemos ahora es:


int cantidad;


En el código anterior vemos una declaración típica de una variable, donde después deberemos inicializarla para poder utilizar su valor, sin embargo, contamos con los inicializadores para realizar esta labor, de donde podemos declarar una variable e inicializarla al mismo tiempo con un valor del mismo tipo de dato del que estamos utilizando en la declaración, esto es para el ejemplo anterior, un entero “int”, podemos entonces declarar e inicializar la variable de esta manera:


int cantidad = 10;


Las declaraciones implícitas tienen sentido en el tipo de código, para utilizarlas temporalmente en el flujo del código solamente, no para utilizarlas como variables de propiedades o variables que se iniciarán posteriormente a la declaración. Tienen ciertas reglas, muy simples por cierto.


La primera es que deben ser declaradas con la palabra clave var en lugar del tipo de dato. Sobre esta palabra, utilizada como en javascript aunque no es de la misma naturaleza del todo y tampoco implica una variable similar al tipo Variant del antiguo Visual Basic. En el primer caso, no es como la variable var de javascript pues aunque indica que la variable no tiene un tipo definido explícitamente no significa que no tenga tipo, pues al tomar el tipo inicial dado implícitamente no cambiaran de tipo después durante la ejecución de código como puede suceder en Javascript. En el segundo caso, aunque no se defina un tipo de dato explícitamente no se comporta como Variant ya que el tipo es asignado de manera implícita y no se puede asignar valores de un tipo incongruente al que ha tomado de manera implícita.


var



La segunda es que debe haber una inicialización de la misma manera que se utilizan los inicializadores, esto es, que debe asignársele un valor al momento de declarar la variable. Al definir un valor de inicio la variable tomará el tipo de dato congruente con el valor que se le ha asignado, con lo que en adelante se asumirá el tipo de dato se ha tomado en la inicialización de la variable. No se puede declarara una variable de tipo implícito con la palabra “var” sin una asignación al momento de hacerlo, esto es, la declaración simple con “var” no está permitida como en el caso de las declaraciones explicitas que pueden definir una variable y asignarles valores posteriormente. Así que, al momento de declarar una variable con “var” se deberá inicializar con un valor para que de esta manera se tome el tipo de dato de manera implícita y congruente con el valor que se ha asignado.


var cantidad = 10;



La tercera se refiere a que la expresión del inicializador en la declaración no debe ser null o dar por resultado null en tiempo de compilación.


El tipo de la variable se infiere por la expresión del inicializador, por lo que estas reglas son necesarias para definir el tipo de la variable declarado implícitamente.


Bueno, pues eso es todo por el momento. Creo que hablaré de lo referente a Extensiones de Métodos en una próxima oportunidad, ya que es una de las nuevas características de C#.


Espero que les sea de utilidad.


Saludos…


Octavio Telis

Liberan últimas versiones de Expression Blend y Orcas

Hola ¿Qué tal?


Bien, solo para comentar la liberación de lo que formalmente es el Beta 1 de ORCAS, es de esperar que esta versión sea más robusta que los anteriores CTPs, de esta versión lo interesante será probar los conceptos de LINQ en todos sus sabores, además de ver la manera en que se integran WPF y WCF a la vida del nuevo .NET Framework, que también ha sido liberado en versión 3.5 Beta 1,  además veremos cómo se integra AJAX a los proyectos web y por último y no menos importante, las nuevas extensiones a los lenguajes .NET, tanto C# como VB.NET, de los cuales veremos cosas interesantes, en lo personal me apasiona el tema de delegados con expresiones Lambda, algo que seguramente evolucionará la manera de definir código de manera simple.


Cabe mencionar que existirán todavía las versiones Express de visual studio, sin duda un buen recurso para los entusiastas y novatos que desean aprender esta tecnología sin invertir más que un tiempo para descargar las versiones, en las referencias incluyo la liga hacia las versiones express de orcas beta 1.


No se lo pierdan, se liberó hoy en la mañana, pruébenlo y disfrútenlo.


Por cierto, el sitio al que hago referencia es lo máximo, mantenido por gente muy ligada al visual studio.


Las ligas:


Orcas Beta 1:


http://msdn2.microsoft.com/en-us/vstudio/aa700831.aspx


Versiones Express:


http://msdn.microsoft.com/vstudio/express/future/default.aspx


.NET Framework 3.5 Beta 1:


http://www.microsoft.com/downloads/details.aspx?FamilyId=36B6609E-6F3D-40F4-8C7D-AD111679D8DC&displaylang=en


Más Referencias:


http://www.netfx3.com/blogs/news_and_announcements/archive/2007/04/19/visual-studio-orcas-beta-1-now-available.aspx


http://wcf.netfx3.com/blogs/news_and_announcements/archive/2007/04/19/net-framework-3-5-beta-1-available-for-download.aspx


 


Por otra parte, qué sería el diseño de interfaz de usuario en XAML sin un diseñador que simplifique la tarea de escribir todo ese XML, pues bien, es importante si se quiere empezar a diseñar utilizando WPF, más ahora que se están liberando estas versiones de Orcas, o bien, si deseas hacer el intento con VS2005 y .NET Framework 3.0. Para esta tarea se está terminando el desarrollo de Expression Blend, el cual es un diseñador de interfaz gráfica que genera XAML para WPF, ahora también se libera el Release Candidate 1, aprovecha y bájalo ya.


Las ligas:


Expression Blend Release Candidate 1


http://www.microsoft.com/products/expression/en/Expression-Blend/try.mspx


Más referencias:


http://wpf.netfx3.com/blogs/news_and_announcements/archive/2007/03/15/expression-blend-release-candidate-1.aspx


Pues bien, esto es todo por hoy, obligado por la emoción de disponer la última versión de estas herramientas que no tardarán mucho en estar liberadas.


No dejen de visitar este sitio:


http://www.netfx3.com/


Sin duda la neta de .net.


Espero que les sea de utilidad.


Saludos…


Octavio Telis


(NETA.- Adj. Mex. Expresión coloquial utilizada para denotar contenido u información que es considerada como la verdad completa o la mejor versión de la verdad)

HotFix para Workflow Foundation

Hola… ¿qué tal?


Si has estado utilizando Worflow Foundation y has experimentado ciertos problemas con el timer una vez que un flujo de trabajo es recargado, puede deberse a un error que ya ha sido corregido. El archivo de actualización que corrige este error salió apenas unos días atrás (2 días, el 12 de abril), por lo que te recomiendo ampliamente que lo instales para no verte en problemas más adelante. Aquí te dejo la liga donde encontrarás la descripción del problema y la descarga del archivo que corrige este problema.


http://www.microsoft.com/downloads/details.aspx?FamilyID=6096ce0f-d21e-47ac-afe2-d4e1c2fce670&DisplayLang=en


Espero que sea de utilidad.


Saludos…


Octavio Telis

Implementar Eventos Genéricos con Delegados Genéricos.

Hola… ¿qué tal?


En esta ocasión voy a cerrar el tema de eventos que dejé pendiente, solo faltaba hablar sobre los eventos genéricos, ya vimos cómo nos pueden ser útiles los eventos, sin embargo dejé un poco abierto el tema al hablar de eventos genéricos.


Los eventos genéricos se basan en la definición de un delegado genérico y nos es útil ya que se pueden tener firmas de eventos donde el sender no sea un object, esto es, consideremos la siguiente definición de delegado:


public delegate void DatoActualizadoEventHandler(object sender, EventArgs e);


En esta línea tenemos una firma convencional de un delegado que se utilizará en algún evento que se lance cuando un dato se actualice, el punto aquí es que en la firma tenemos a un sender de tipo object y a n parámetro e de tipo EventArgs, aunque en ocasiones podemos definir el tipo del parámetro de EventArgs con una tipo definido por nosotros como ya vimos en el pasado post de eventos (siga esta liga). Qué tal que definimos el delegado único, donde el sender pueda ser del tipo mismo de la clase que define el evento, donde el EventArgs sea del tipo que corresponda al evento en un momento dado y con solo definir un delegado de la siguiente manera:


public delegate void EventoEventHandler<T,U>(T sender, U e);


Este delegado nos servirá para todos los eventos que creemos en nuestras aplicaciones, solo una definición para todos los eventos, el detalle será al momento de declarar el evento.


Consideremos dos clases y un solo delegado como muestro a continuación:


    public class Primera


    {


        public Primera()


        {


        }


    }


    public class Segunda


    {


        public Segunda()


        {


        }


    }


Como vemos son clases como cualquier otra, ahora bien, tenemos ya definido el delegado genérico llamado EventHandler, con esta definición ya podemos definir nuestros eventos, aquí veremos cómo es que se declararan los eventos, pero antes, definamos dos clases más para dos tipos de EventArgs, el primero será para pasar información de un dato actualizado y el segundo será para pasar información de un Cálculo, para la segunda utilizaré la definida previamente en el post anterior (aquí), como veremos a continuación:


    public class DataActualizadoEventArgs : EventArgs


    {


        private string descripcionDato;


        private string valorDato;


        public DataActualizadoEventArgs()


            : base()


        {


        }


        public string DescripcionDato


        {


            get


            {


                return descripcionDato;


            }


            set


            {


                descripcionDato = valorDato;


            }


        }


        public string ValorDato


        {


            get


            {


                return valorDato;


            }


            set


            {


                valorDato = value;


            }


        }


    }


    public class CalculoEventArgs : EventArgs


    {


        private string operadorUtilizado;


        private int cantidadOperandos;


        private bool operacionExitosa;


        public CalculoEventArgs()


            : base()


        {


        }


        public string OperadorUtilizado


        {


            get


            {


                return operadorUtilizado;


            }


            set


            {


                operadorUtilizado = value;


            }


        }


        public int CantidadOperandos


        {


            get


            {


                return cantidadOperandos;


            }


            set


            {


                cantidadOperandos = value;


            }


        }


        public bool OperacionExitosa


        {


            get


            {


                return operacionExitosa;


            }


            set


            {


                operacionExitosa = value;


            }


        }


 


    }



Con esto tengo definidas dos clases distintas de EventArgs, las cuales utilizaré en los eventos que definiré en cada una de las clases que cree al principio, como se muestra a continuación, ya aplicando el delegado genérico:


    public class Primera


    {


        public Primera()


        {


        }


        public event EventoEventHandler<Primera, DataActualizadoEventArgs> DatoActualizado;


    }


    public class Segunda


    {


        public Segunda()


        {


        }


        public event EventoEventHandler<Segunda, CalculoEventArgs> CalculoTerminado;


    }


Como podemos ver en el código anterior, se define el evento utilizando el delegado genérico al cual le estamos pasando los parámetros de tipo correspondientes a el tipo mismo de la clase para ocupar el lugar del sender y nuestra clase de EventHandler para definir el tipo de e.


Convendrá restringir el paso de parámetros de tipo en cuanto al parámetro de EventArgs se refiere, y lo podemos hacer indicando que ese parámetro de tipo para el EventArgs sea siempre un tipo derivado de System.EventArgs, para lo cual modificaremos la definición del delegado de la siguiente manera:


    public delegate void EventoEventHandler<T, U>(T sender, U e)


        where U: System.EventArgs;


Aquí estamos restringiendo el paso de parámetros de tipo para la posición de U, donde solo podrán utilizarse tipos derivados de System.EventArgs. Como nota al margen, las restricciones en delegados solo pueden ser tipos que puedan ser derivados, que no estén sellados (sealed), que sean tipos de referencia, que sean interfaces, no se pueden poner restricciones de tipos de valor como int, double, bool, etc. Bueno, ese es otro tema más extenso, ya habrá tiempo para hablar de ello en otra ocasión.


Ahora bien, una vez creada la restricción, entonces  solo podrán pasarse tipos derivados de Sysem.EventArgs en el parámetro U, que no es un problema para nosotros ya que ambas clases de EventArgs son derivadas de System.EventArgs.


La utilización dentro de la clase es igual que como comúnmente se hace, solo que está ves los tipos en los parámetros del delegado deben coincidir con los definidos en el evento. Veamos cómo se utilizaría en un método de la clase Primera:


        public void AtualizarDato()


        {


            DataActualizadoEventArgs args = new DataActualizadoEventArgs();


            args.DescripcionDato = “Mi dato”;


            args.ValorDato = “Valor del dato”;


 


            //…


            //Alguna implementación para actualizar algún dato


            //…


 


            DatoActualizado(this, args); //Lanza el evento al final.


        }


Análogamente se hace lo mismo en la clase Segunda, en donde se tiene definido el siguiente método:


        public void CalcularDato()


        {


            CalculoEventArgs args = new CalculoEventArgs();


            args.CantidadOperandos = 2;


            args.OperadorUtilizado = “Multiplicación”;


 


            //…


            //Alguna implementación para hacer un cálculo


            //…


 


            args.OperacionExitosa = true;


            CalculoTerminado(this, args);


        }


La implementación será un poco diferente, una vez que se van a utilizar los eventos cuando se usen estas clases, hay que agregarlos como comúnmente se hace, solo que se tendrá que pasar el parámetro de tipo según el orden como a continuación:


        Primera prm = new Primera();


        prm.DatoActualizado +=


            new EventoEventHandler<Primera, DataActualizadoEventArgs>


            (prm_DatoActualizado);


 


        Segunda sgn = new Segunda();


        sgn.CalculoTerminado +=


            new EventoEventHandler<Segunda, CalculoEventArgs>


            (sgn_CalculoTerminado);


Los métodos que manejan estos eventos no cambian mucho de lo que ya conocemos, solo que esta vez no veremos a un sender del tipo object sino a un sender del tipo correspondiente con la clase que lanza el evento manejado, como se muestra a continuación:


    static void sgn_CalculoTerminado(Segunda sender, CalculoEventArgs e)


    {


       


    }


 


    static void prm_DatoActualizado(Primera sender, DataActualizadoEventArgs e)


    {


       


    }


Una de las ventajas de utilizar la definición de un delegado genérico para la declaración de eventos, es que al utilizar los métodos manejadores ya no se debe convertir el sender al tipo de la clase que está lanzando el evento, comúnmente hay que realizar una conversión cuando se quiere utilizar el sender dentro del método manejador del evento, algo parecido a esto:


    protected void grd_SelectedIndexChanged(object sender, EventArgs e)


    {


       GridView grid = sender as GridView;


    }


De esta manera se puede utilizar el sender para utilizarlo en operaciones dentro de nuestro código, hacer esto implica una tarea de conversión e tipos que puede afectar al rendimiento de la aplicación, lo que no pasa si utilizamos directamente el tipo como en el caso de los manejadores de eventos genéricos.


Dentro del .NET Framework existe un delegado genérico, sin embargo no tiene un parámetro de tipo para el sender. Este delegado es System.EventHandler<>, y se utiliza muy similar a lo que hicimos, un ejemplo de su uso utilizando nuestras clases de EventArgs sería así:


public event EventHandler<DataActualizadoEventArgs> DatoActualizado;


Pues bien, hasta aquí llegamos con el tema de eventos, completando con esto el uso de delegados genéricos para implementar eventos genéricos.


Espero que les sea de utilidad, como lo ha sido para mi.


Saludos…


Octavio Telis

La abolición de las Variables Globales en Visual Basic

Hola ¿Qué tal?


Estos son tiempos de .NET, tiempos de libertad, es el tiempo en el que por fin hemos visto un visual basic pleno y más poderoso de lo que era antes, recuerdo el Visual Basic 6, el 5 y el anterior VB4 en el cual me inicié en esta venerable profesión.


En aquellas versiones de Visual Basic, los módulos eran un recurso muy útil, una manera de centralizar las funciones o los procedimientos que queríamos poner a disposición de toda nuestra aplicación, ahora es a ha cambiado, sin embargo dentro de lo que existía en las versiones anteriores a .NET, y que fue de mucha utilidad, solo las variables globales, que era la manera típica de mantener estado y tener información disponible en variables que eran accesibles desde cualquier formulario en nuestros proyectos, se utilizaban para el uso de “banderas” (como son llamadas por algunos) que servían para mantener el estado, otra utilidad era almacenar valores que provenían de cálculos o resultados para tenerlos a la mano en cualquier formulario para cuando se requiriera, esto era común, no era malo, y además, se prefería sobre el uso de propiedades por la manera en que se concentraban en un solo lugar. Bien, pues eso fue en el pasado, ahora las variables globales ya no existen (bueno… cómo de que no?), está bien, ya no debería mantenerse esa práctica, y es que no podemos permitirnos prácticas arcaicas cuando lo que tenemos en frente es lo último en tecnología, es un lenguaje nuevo y aunque hay cosas que funcionan de las versiones anteriores, en este lenguaje el modo de programar es totalmente distinto, Visual Basic .NET ha implicado en estos primeros cinco años de vida un cambio de conducta, de pensamiento y de, obviamente, programación. Muchos han tomado Visual Basic .NET como una continuación de Visual Basic 6,  porque funciona y no es con afán de criticar a nadie, solo es la situación que se ve en este mundo del desarrollo. El desarrollo en VB.NET es nuevo y fresco y dentro de sus capacidades está la de no requerir variables globales para funcionar, dado que ahora tiene medios de propagación mucho más eficientes y todavía mejores, más seguros y efectivos y más control.


Si escribo esto es porque cuando pasé de Visual Basic 6 a VB.NET era casi imposible no sucumbir a las antiguas prácticas, sin embargo, con explorar un poco más en las características del lenguaje y con los retos de cambiar por algo que fuera acorde a lo que tenía enfrente me di cuenta de que el uso de las variables globales se volvía prácticamente innecesario, totalmente, ya que poco a poco podía pasar la información entre formularios con mejores y refinadas técnicas de programación orientada a objetos, y utilizando todo lo que nos brinda la nueva especificación del lenguaje.


Consideremos un módulo en Visual Basic .NET, este módulo al compilarse se transforma en una clase estática con miembros estáticos, si utilizamos variables Public dentro del módulo para hacer uso de variable globales lo que estamos creando es una clase con campos “shared” que estarán siempre en memoria y que no serán limpiados de la memoria mientras dure la ejecución de la aplicación, parece no ser tan malo, sin embargo, cuando se empiezan a utilizar campos de tipos de referencia, la memoria se empieza a cargar y conforme se utilicen seguirá ocupando espacio y en ocasiones ya muy extremas hasta puede causar problemas al momento de dibujar los controles de de los formularios por falta de memoria. Bien, un segundo punto al margen, es que el modificador Shared no está pensado para utilizarlo en campos sino en métodos, ya que un método como tal no guardará la referencia de elementos de su interior y estarán disponibles para ser recolectados por el recolector de basura, cosa que no pasa con los campos, y es que al ejecutarse un método shared todo en su interior estará limitado por el ámbito que se crea en el bloque de dicho método, por lo que al terminar la ejecución lo que se utilizó en el interior perderá el ámbito y estará listo para ser descargado de la memoria.


Bueno, ¿y qué hago entonces para sustituir mis variables globales?, la respuesta es simple; se tienen varios mecanismos que nos servirán para propagar un valor a través de clases y formularios, y más que con el  .NET Framework , los formularios ya no se crean y están disponibles al momento de ejecutar la aplicación, como se sucedía en VB 6 y anteriores, ahora, hay que declarar explícitamente el formulario en una variable para poder mostrarlo y aunque pudiera pensarse que las variables globales toman sentido, pues no, ya que si se requiere ocupar un valor que se tiene almacenado al momento de crear el formulario para realizar tareas en el interior de este, pues se le puede pasar de dos posibles maneras.


La primera sería utilizando un constructor dentro de la clase del formulario que vamos a llamar y de esta manera construirlo con el valor que se desea utilizar al momento de crear la instancia, ya del lado del formulario, podemos ocupar una variable para almacenarlo y trabajar con él.


La otra posibilidad es el uso de propiedades en el formulario que se va a llamar, donde inmediatamente después de crear la instancia podremos pasar el valor por medio de la propiedad. El uso del constructor en lo personal me es más útil, ya que obligo a la instancia a pasar el valor que se requiere dentro del formulario  sin dejar lugar a errores en la ejecución.


Otra manera de comunicar valores entre formularios y clases es con el uso de eventos, en un post anterior explico de manera práctica como utilizar un evento para comunicar información de una clase a otra.


Así pues, verán que no hay ya necesidad de tener una variable global para disponer de valores en la aplicación, con el uso de constructores, propiedades y eventos, es posible comunicar valores en el marco sin el riesgo de cargar la memoria y además con un estilo más orientado a .NET. Con lo que las variables globales han sido abolidas.


Pues bien, espero que haga sentido y que les sea de utilidad.


Saludos…


Octavio Telis

Instalando Service Pack 1 en Visual Studio 2005

Hola… nuevamente…


En esta ocasión les dejo algunas consideraciones para instalar el Service Pack 1 sin tormentos.


El service pack 1 es una actualización para VS2005 dada la nueva liberación de Vista y mejoras al entorno. El archivo pesa alrededor de 450MB y se puede descarcargar del sitio de Microsoft en www.microsoft.com/vstudio.


Antes que nada, cierren sus proyectos de Visual Studio y el entorno de desarrollo, instalen todas las plantillas que alguna vez bajaron de internet, ahora es el momento adecuado.


Desinstalen el  Web Projects Extension si alguna vez lo instalaron, el SP1 trae una nueva versión y al detectar que está instalada la versión anterior suspenderá la instalación y pedirá que se desinstale, así que mejor desinstálenlo antes de instalar el SP1.


En ocasiones la falta de memoria puede causar un error al momento de verificar la firma del instalador, esto sucede con paquetes muy grandes de instalación, si bajaron el paquete de instalación de internet  pueden encontrarse con este problema, en la siguiente liga pueden encontrar información para lidiar con él:


http://support.microsoft.com/kb/925336/es


Lo siguiente será ya lo típico, aceptar los acuerdos de licencia y darle continuar, con eso se instala el service pack 1 en Visual Studio 2005.


Espero que les sea de utilidad.


Saludos…


Octavio Telis

Instalando .NET Framework 2.0 SDK en Español con Visual Studio 2005 en Inglés

Hola… ¿Qué tal?


Esta nota es solo una observación sobre la instalación del .NET Framework 2.0 SDK en español en un sistema operativo con Visual Studio 2005 en inglés. Bueno, razón por la que se instalaría el SDK en español es por la documentación en Español, bastante más cómodo de leer que la documentación en inglés que se instala con Visual Studio en inglés, y se dirán ¿Cómo es que se puede dar esta combinación?, bueno, en ocasiones (y no es raro y es más frecuente que ocasional) las empresas de desarrollo instalan Visual Studio en inglés por razones variadas, una puede ser por estándar corporativo, otra por la prontitud de tener  los “Hot Fixes” en el momento en que sales  con la experiencia de que salen primero en inglés y tiempo después en español  (aunque solo son de una a dos semanas de diferencia), o por la idea arraigada de que los productos en inglés son más estables que en español (aunque es el mismo producto pero con un diccionario de títulos en español), o por simple y llano gusto. Bueno, por lo que sea, si tienes un Visual Studio 2005 en Inglés, tal vez te gustaría tener la documentación en inglés, es siempre más cómodo leer en el idioma natal que cualquier otro, la documentación en español es muy buena, es revisada antes de su liberación por mucha gente que compara los textos en inglés con las traducciones en español, por lo que un error de dicción, de interpretación o de traducción es prácticamente inexistente, sin embargo, si llegara a existir, se tienen los mecanismos para comunicarlo a Microsoft y seguramente será corregido para una liberación subsecuente, pero bueno, el índice de errores en la documentación en Español, podríamos decir que es el mismo que en la documentación en inglés.


Bien, si quieres tener la documentación en Español dado que tienes instalada la versión en inglés de Visual Studio, pues solo tienes que descargar el .NET Framework 2.0 SDK de la página de Microsoft en: http://msdn2.microsoft.com/en-us/netframework/aa731542.aspx. La versión que deben elegir es la de español.


Consideraciones en la instalación, bueno, pues aquí está el detalle de la instalación, ya que una instalación completa del .NET Framework causaría modificaciones en los texto de Visual Studio dejándolo como una versión hibrida entre inglés y español, así es, minués en ingles con submenúes en  español, ahora que si te divierte tenerlo así… no pasa nada, los compiladores funcionan como siempre, pero, si quieres conservar la interfaz de tu visual estudio intacta tendrás que instalar el SDK en modo personalizado donde solo tendrán que elegir solo la instalación de la documentación excluyendo lo que se supone que ya está instalado, que es lo que se instaló con Visual Studio 2005.


Pues bien, es todo por esta ocasión y espero que les sea de utilidad.


Saludos…


Octavio Telis


 

Evento de la Comunidad.NET del DF Abril 2007 – RECORDATORIO

Qué tal?


Pues esto es un recordatorio para todos aquellos que nos visitan, quiero extenderles una vez más la invitación al evento del mes de Abril de nuestra comunidad, y es que es nuestro evento del año.


Los detalles pueden encontrarlos aquí:


http://msmvps.com/blogs/otelis/archive/2007/04/05/evento-de-la-comunidad-net-del-mes-de-abril-2007.aspx


Ahí está el lugar y la liga al sitio de registro, para que no se queden sin ir.


Saludos…


Octavio Telis

Uso de ViewState en lugar de QueryString

Hola ¿Qué tal?…


Al andar en esto del desarrollo de aplicaciones web siempre me he obligado a utilizar lo menos posible el llamado query string, porque al utilizar ASP.NET me he dado cuenta que ya se puede evitar sin problemas en muchos de los casos.


Primeramente, para aquellos que se inician en la programación de ASP.NET quiero explicar un poco lo que es un query string.


Un query string es una manera utilizada desde versiones anteriores de ASP en la que se manda información a la página mediante una cadena adicional en la ruta de la página, se concatena a la ruta con un signo de interrogación “?” y se separan los elementos con un signo de ampersand “&”, un ejemplo sería:


 http://www.miserver.com/mipagina.aspx?Id=20&user=10


Dentro del código de la página es posible recuperar los valores del query string (que es la parte agregada después del signo de interrogación) mediante métodos incluidos en el objeto Request de la siguiente manera:


                int id = int.Parse(this.Request.QueryString.Get(0));


En este caso se estaría obteniendo el valor del primer parámetro, según el orden del query string del ejemplo sería “20” que corresponde al parámetro “Id”.


Bien, pues está práctica se me ha hecho un poco insegura por exponer la información al usuario, aunque podría mandarse de manera encriptada, bueno, ahí empieza el trabajo de más, porque al encriptar el parámetro habrá que desencriptarlo, lo cual ya representa un gasto extra para la aplicación, además, se deben validar las longitudes, tipos de datos y valores coherentes que se esperan en el parámetro y es porque los valores se reciben como cadenas de caracteres, es decir, del tipo string. Imaginemos que en el query string del ejemplo, un usuario mal intencionado sustituye el 20 por Hola, esto causaría un error en la línea de código del ejemplo por tratar de convertir una palabra en número por medio del método Parse de int. Es por eso que además habría que validarlo antes de ocuparlo, y además, cuando hablamos de encriptar los valores también debemos validar que el valor encriptado sea lo que esperamos. Esto sin duda tiene un costo en rendimiento, aunque no es muy alto, pero sí son más líneas de código y más susceptibilidad a errores.


A mi sentir, el query string es un recurso que existe en ASP.NET por compatibilidad con la versión anterior, según mi percepción.


En Asp.NET tenemos muchos recursos para manejar la información de las páginas, esa información que podría se candidata a un query string podría ser bien manejada por varios recursos de ASP.NET, uno es Page.Application, aunque utilizarlo expone los elementos a toda la aplicación con lo cual se corre el riesgo de sobrescribir los valores agregados en una sesión diferente por otro usuario, otro es Page.Sessioin, está mejor que Page.Application, ya que los valores utilizados en Page.Session son exclusivos de la sesión, sin embargo, utilizar Page.Session para almacenar valores es riesgoso pues hay que pensar en la cantidad de sesiones que utilizaran la aplicación, ya que estos valores se almacenan en el servidor y podrían poner en riesgo la escalabilidad,  por otra parte, tenemos ViewState, que es el mecanismo que mantiene el estado de la página, ViewState almacena el valor en el código de la página, lo que implica que no utiliza los recursos de memoria del servidor para almacenar los valores. Para almacenar valores es idéntico que con los otros dos pero más conveniente por lo que les mencioné, sin embargo también tiene sus desventajas, por ejemplo, los valores almacenados en ViewState solo están disponibles para la página en cuestión, o sea, si cambiamos de página, los valores se pierden.


En específico me quiero enfocara al uso de ViewState en sustitución del query string al trabajar con una página y no para sustituir Session o Application que tienen su razón de ser y que en ciertas circunstancias son también útiles para sustituir el query string.


Las ventajas del uso de ViewState que me ha sido de mucha utilidad es al construir páginas basadas en usercontrols, en donde requiero pasar información de un usercontrol a otro, dado que los usercontrols se programan en archivos y clases diferentes, puede obtener el dato proporcionado por un user control en otro a través del ViewState sin la necesidad de extender propiedades en muchos de los casos. Claro, puede ser útil en más escenarios y tal vez ahora estés viendo una oportunidad para darle uso o quizás más adelante en tus desarrollos. El uso de del ViewState es simple, aquí muestro un ejemplo:


                ViewState.Add(“Id”, 20);


 En la línea anterior estoy agregando el valor 20, el cual es agregado como un objeto  al elemento del ViewState “Id”, el cual es creado por medio el método Add. Para recuperar el valor del elemento “Id” solo ocupo la siguiente línea de código:


                int Id = (int)ViewState[“Id”];


Ahora bien, siempre es importante que al recuperar el elemento se tenga presente que si no existe en la colección de ViewState entonces ViewState devolverá null, por lo que no está de más verificar que no sea null antes de tomarlo, quedando así:


    int Id;


    if (ViewState[“Id”] != null)


        Id = (int)ViewState[“Id”];



Bien, pues este es un ejemplo muy simple para ilustrar el uso de ViewState, lo que pretendo con esto es motivar al desarrollador a sustituir un query string por ViewState cuando se trabaja con valores dentro de una página en específico, verán que ustedes encontrarán un uso útil para ViewState.


Por último, no les recomiendo el uso de ViewState para almacenar objetos, que aunque es posible siempre y cuando sean objetos serializables, no es muy bueno pues puede incrementar el peso de la página al regresar del servidor dado que se escribirá en la sección codificada de ViewState de la página.


Pues bien, espero que les sea de utilidad y no duden en dejar sus comentarios o dudas al respecto.


Saludos…


Octavio Telis