Utilizando la Biblioteca SqlHelper (3/3)

Ejecutar una consulta y devolver un sólo valor:

Como bien es sabido, para ejecutar una consulta y devolver un sólo valor a través de un SqlCommand, debemos ejecutar un el método ExecuteNonQuery().

Es fácil realizar una ejecución de este método de forma controlada a través de la biblioteca SqlHelper, ya que contiene métodos que nos facilitarán dicha tarea. Esto nos permitirá devolver un valor con tan sólo 2 líneas de código:

        private void StartScalarDemo()
        {
            var query = "SELECT CompanyName FROM Customers WHERE CustomerID = 'BLAUS'";
            var result = SqlHelper.ExecuteScalar(GlobalData.ConnectionString, CommandType.Text, query);
            Debug.WriteLine(result);                               
        }

En primer lugar, hemos de definir la sentencia a ejecutar, mientras que en la siguiente ejecutaremos el método denominado ExecuteNonQuery que se encargará de llevar a cabo todo el proceso correspondiente al manejo de apertura y cierre de la base de datos, así como la gestión de errores.

Ejecutar una consulta del tipo NonQuery:

Si lo que deseamos es llevar a cabo la ejecución de una consulta que no devuelva información de la base de datos (tal como un insert o un delete), la lógica será similar al ejemplo anterior, con la diferencia de que el método que hemos de ejecutar es ExecuteNonQuery, que nos devolverá el número de filas afectadas, y el cual ejecutaremos de la siguiente forma en el caso de querer insertar información:

        private void StartNonQueryDemo1()
        {
            String query = "";
            query = query + "INSERT INTO [dbo].[Customers] " + "\n";
            query = query + "           ([CustomerID] " + "\n";
            query = query + "           ,[CompanyName] " + "\n";
            query = query + "           ,[ContactName] " + "\n";
            query = query + "           ,[ContactTitle] " + "\n";
            query = query + "           ,[Address] " + "\n";
            query = query + "           ,[City] " + "\n";
            query = query + "           ,[Region] " + "\n";
            query = query + "           ,[PostalCode] " + "\n";
            query = query + "           ,[Country] " + "\n";
            query = query + "           ,[Phone] " + "\n";
            query = query + "           ,[Fax]) " + "\n";
            query = query + "     VALUES " + "\n";
            query = query + "           ('XYZ' " + "\n";
            query = query + "           ,'HECTORS COMPANY' " + "\n";
            query = query + "           ,'HÉCTOR PÉREZ' " + "\n";
            query = query + "           ,'M.C.C' " + "\n";
            query = query + "           ,'AV. HOGWARTS' " + "\n";
            query = query + "           ,'MAGICLAND' " + "\n";
            query = query + "           ,'REGIONLAND' " + "\n";
            query = query + "           ,'99999' " + "\n";
            query = query + "           ,'UK' " + "\n";
            query = query + "           ,'2222' " + "\n";
            query = query + "           ,'2222')";

            var result = SqlHelper.ExecuteNonQuery(GlobalData.ConnectionString, CommandType.Text, query);
            Debug.WriteLine("Registros agregados: {0}", result);
        }

En caso de desear eliminar el registro insertado en el ejemplo anterior, o bien, algún otro, debemos hacer una ejecución como en el siguiente ejemplo:

        private void StartNonQueryDemo2()
        {
            String query = "DELETE FROM [Customers] WHERE [CustomerID] = 'XYZ'";            

            var result = SqlHelper.ExecuteNonQuery(GlobalData.ConnectionString, CommandType.Text, query);
            Debug.WriteLine("Filas eliminadas: {0}", result);
        }

Hemos visto que la utilización de la biblioteca SqlHelper es de mucha ayuda a la hora de programar, lo único que falta es que la integres a tus proyectos si te ha gustado. De nuevo, dejo el link de github si deseas integrar una biblioteca de clases de utilidades que se irán agregando poco a poco.

Saludos.

Generando una clase intermedia a través de wsdl.exe para conectarnos a un servicio web .asmx

Como bien sabemos, la forma más sencilla para agregar y posteriormente consumir un servicio web, es a través del menú contextual de Visual Studio:

Sin embargo, existen otras formas de consumir un servicio web de manera sencilla y transparente. Una de ellas puede ayudarnos además, para analizar, estudiar y aprender del código generado. Esta forma es a través de la herramienta wsdl.exe, que se encuentra en la siguiente ruta:

C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.6.1 Tools

Debemos navegar a través de una consola de comandos a la dirección antes especificada, y utilizar algunas de las opciones disponibles. La simbología para utilizar la herramienta, es:

wsdl.exe <opciones> <dirección_url o ruta_de_acceso> …

Si deseamos ver las opciones disponibles, bastará con escribir simplemente wsdl.exe:

Vamos a utilizar el servicio “Weight Unit Convertor”, disponible en la página http://webservicex.net/, para generar la clase correspondiente. Lo primero que debemos hacer, es navegar al servicio web, donde nos será mostrado el Endpoint:

Dicho Endpoint, será el que utilizaremos para generar nuestra clase, debiendo colocarlo de la siguiente forma en la consola de comandos:

wsdl http://www.webservicex.net/ConvertWeight.asmx?WSDL

Lo que nos generará una clase en el directorio mismo de la herramienta:

Podemos agregar la clase generada a un proyecto desde Visual Studio, donde nos mostrará algunos errores si no hemos agregado la biblioteca System.Web.Services, por lo que es necesario que se encuentre dentro del proyecto donde utilizaremos el servicio web.

Con esto, podremos utilizar la clase generada como cualquier otra:

Además de que funcionará de manera correcta:

¡Saludos!

Utilizando la Biblioteca SqlHelper (2/n)

Ejecutar consulta y llenar un DataReader:

Para llevar a cabo la ejecución de una consulta y rellenar un DataReader, disponemos de los siguientes métodos:

En esta demostración, utilizaremos el método:

public static System.Data.SqlClient.SqlDataReader ExecuteReader(string connectionString, System.Data.CommandType commandType, string commandText)

Podemos observar, que se nos pide como primer parámetro una cadena de conexión, como segundo el tipo de comando (si es consulta normal o un stored procedure), y como tercer, la consulta como tal.

En primer lugar, definiremos en una variable la consulta que deseamos ejecutar:

var sqlQuery = "SELECT * FROM Customers";

En segundo lugar, llamaremos al método que nos interesa, pasándole como referencia la cadena de conexión que definimos en el post anterior, seguido por el tipo de enumeración que deseamos aplicar, y la consulta definida previamente. Cabe destacar, que utilizaremos un using para cerrar la conexión y eliminar la instancia una vez que la dejemos de utilizar:

 using (var newDataReader = SqlHelper.ExecuteReader(
                GlobalData.ConnectionString,
                CommandType.Text, sqlQuery))

Por último, haremos un recorrido por el datareader e imprimiremos la información deseada:

while (newDataReader.Read())
                {
                    var customerInfo = string.Format(
                        "Company Name: {0}, ContactName: {1}",
                        newDataReader.GetString(1),
                        newDataReader.GetString(2));
                    Debug.WriteLine(customerInfo);                    
                }

Quedando el código completo del método, de la siguiente manera:

 private void StartDataReaderDemo()
        {
            //Utilizando SqlHelper para llenar un DataReader
            var sqlQuery = "SELECT * FROM Customers";
            using (var newDataReader = SqlHelper.ExecuteReader(
                GlobalData.ConnectionString,
                CommandType.Text, sqlQuery))
            {
                while (newDataReader.Read())
                {
                    var customerInfo = string.Format(
                        "Company Name: {0}, ContactName: {1}",
                        newDataReader.GetString(1),
                        newDataReader.GetString(2));
                    Debug.WriteLine(customerInfo);                    
                }
            }


        }

Ejecutar consulta a un Stored Procedure y llenar un DataReader:

La forma para llevar a cabo una consulta a un procedimiento almacenado, conlleva básicamente los mismos pasos que anteriormente, con la diferencia, que debemos especificar el nombre del procedimiento almacenado en lugar de la consulta:

var sqlQuery = "Sales by Year";

En segundo lugar, debemos definir un arreglo de tipo SqlParameter, definiendo los parámetros que deseamos pasar:

            var param1 = new SqlParameter {ParameterName = "@Beginning_Date", Value = new DateTime(1995, 1, 1) };
            var param2 = new SqlParameter { ParameterName = "@Ending_Date", Value = new DateTime(1997, 1, 1)};
            SqlParameter[] parameters = new[] {param1, param2};

Lo demás, es prácticamente lo mismo, el código completo del método se encuentra a continuación:

        private void StartDataReaderDemo2()
        {
            //Utilizando SqlHelper para llenar un DataReader a través de un stored procedure
            var sqlQuery = "Sales by Year";
            var param1 = new SqlParameter {ParameterName = "@Beginning_Date", Value = new DateTime(1995, 1, 1)};
            var param2 = new SqlParameter {ParameterName = "@Ending_Date", Value = new DateTime(1997, 1, 1)};
            SqlParameter[] parameters = new[] {param1, param2};
            using (var newDataReader = SqlHelper.ExecuteReader(
                GlobalData.ConnectionString,
                CommandType.StoredProcedure, sqlQuery, parameters))
            {
                while (newDataReader.Read())
                {
                    var customerInfo = string.Format(
                        "Order ID: {0}, Subtotal{1}",
                        newDataReader.GetInt32(1),
                        newDataReader.GetDecimal(2));
                    Debug.WriteLine(customerInfo);
                }
            }
        }

Utilizando la Biblioteca SqlHelper (1/n)

En una publicación pasada, agregamos a nuestra solución una clase que puede llevar a cabo la ejecución de consultas a un servidor SQL Server, vamos a ver en esta entrada cómo utilizar algunos de los métodos incluidos en la clase, tomando como la base de datos Northwind como ejemplo.

Ejecutar consulta y llenar un DataSet:

Si se quiere llenar un DataSet para trabajar posteriormente con él, podemos ejecutar el método denominado “ExecuteDataset”, el cual tiene 8 sobrecargas (Dar click en la imagen para ver en tamaño real):

La clase nos da una amplia gama de sobrecargas para poder pasar todo tipo de parámetros necesarios para llevar a cabo la ejecución de una consulta y posterior llenado de un Dataset, como ejemplo, vamos a ocupar el segundo método:

SqlHelper.ExecuteDataset(string, System.Data.CommandType, string)

cuya definición es:

public static System.Data.DataSet ExecuteDataset(string connectionString, System.Data.CommandType commandType, string commandText)

Es decir, debemos pasar como primer parámetro una cadena de conexión (Existe otro método para pasar directamente un objeto ConnectinString), para cuestiones de simplicidad, he creado una clase que mantiene la cadena de conexión centralizada:

    public static class GlobalData
    {
        public static string ConnectionString { get; set; }
        static GlobalData()
        {
            ConnectionString = @"Data Source=.\SQLSERVER;Initial Catalog=Northwind;Integrated Security=True";
        }
    }

Debemos crear una variable para almacenar la consulta que deseemos ejecutar, en mi caso será la siguiente:

var sqlQuery = "SELECT * FROM Customers";

Listo, ya podremos utilizar el método con la información previamente definida, colocando el resultado de la ejecución de tipo DataSet en una nueva variable:

            var newDataSet = SqlHelper.ExecuteDataset(
                GlobalData.ConnectionString,
                CommandType.Text, sqlQuery);
            var customers = newDataSet.Tables[0];

Si deseamos consultar el resultado, debemos obtener una de las tablas de la consulta en primer lugar:

var customers = newDataSet.Tables[0];

para posteriormente utilizar Linq para llevar a cabo la consulta (Debemos utilizar un método especial llamado .AsEnumerable para poder realizar consultas con Linq, que se encuentra en el ensamblado System.Data.DataSetExtensions), y como buena práctica, definir un nuevo tipo anónimo para poder utilizar las propiedades desde código:

            var query = from customer in customers.AsEnumerable()
                        select new
                        {
                            CompanyName = customer.Field<string>("CompanyName"),
                            ContactName = customer.Field<string>("ContactName")
                        };

Por último, podemos recorrer el resultado de la consulta Linq e imprimir la información necesaria:

            foreach (var customer in query)
            {
                Debug.WriteLine(customer.CompanyName);
            }

Recuerden que el código se irá complementando en el repositorio de GitHub:

https://github.com/hprez21/Hyrule

 

En la próxima entrada seguiremos viendo más métodos

Manipulando archivos de Excel con C# sin morir en el intento (1/n)

Como desarrolladores, muchas veces nos hemos enfrentado a la necesidad de manipular archivos en formato excel.

Una forma, es manipular dichos archivos a través de la biliboteca de interoperabilidad Microsoft.Office.Interop.Excel.dll. Sin embargo, esto requiere que tengamos instalados ensamblados especiales de acuerdo a la compilación que hayamos realizado, lo cual podría provocar el clásico error El proveedor ‘Microsoft.ACE.OLEDB.12.0’ no está registrado en el equipo local. En esta entrada, veremos una forma mucho más sencilla de manipular archivos de Excel de una forma nativa y sin necesidad incluso de tener instalado Excel en la máquina de los clientes.

Overview

Los archivos de Office de las versiones actuales de Office, están basados en OpenXML, cuya definición en Wikipedia es:

Office Open XML (también llamado OOXML u OpenXML) es un formato de archivo abierto y estándar cuyas extensiones más comunes son .docx, .xlsx y .pptx. Se le utiliza para representar y almacenar hojas de cálculo, gráficas, presentaciones y documentos de texto. Un archivo Office Open XML contiene principalmente datos basados en el lenguaje de marcado XML, comprimidos en un contenedor .zip específico.

Es decir, que si contamos con un archivo con extensión .xlsx, basta con cambiarle dicha extensión por una .zip, para poder descomprimirlo y ver en su interior el contenido del archivo tal como en la siguiente imágen:

Podemos darnos cuenta entonces, que un archivo de Excel no es más que un conjunto de archivos xml que podemos manipular a nuestro antojo para llevar a cabo distintas operaciones.

Trabajando con archivos de Excel

Para no reinventar la rueda, hoy en día existen diferentes alternativas para abrir documentos con formato open xml. En esta publicación haremos uso de ClosedXML Basta con ir a la página oficial en CodePlex para descargar la dll que necesitemos (framework 3.5 o 4) y descomprimir el archivo .zip descargado para poder utilizar la biblioteca. Por último (Lo remarco en rojo porque es importante) debemos descargar la biblioteca DocumentFormat.OpenXml, ya sea para el framework +4.0 ó 3.5

Creando un archivo de Excel

El uso de la biblioteca (al ser orientado a objetos) resulta extremadamente sencillo. Si deseamos crear una instancia de un libro de Excel, basta con utilizar la clase XLWorkbook, el cual contiene una propiedad haciendo referencia a las hojas del libro, las que a su vez contienen referencias a las celdas.

Nuestro primer ejemplo, consistirá en crear un libro en Excel, el código para hacerlo es el siguiente:

var workbook = new XLWorkbook();
var worksheet = workbook.Worksheets.Add("Sample Sheet");
worksheet.Cell("A1").Value = "Hola mundo desde Excel!";
workbook.SaveAs("HelloWorld.xlsx");

 

Una vez ingresado el código en el manejador de eventos de un botón, tendremos un libro de Excel satisfactoriamente creado:

En la siguiente entrada, nos dedicaremos a manipular archivos de Excel existentes.

¡Hasta la próxima!

Manejar acceso a datos a través de una clase administrada (1/n) (Hyrule)

Tomando como referencia un post anterior, continúo esta serie de artículos relacionados con facilitar nuestro día a día en el desarrollo de aplicaciones.

Para propósitos de esta serie de posts, utilizaremos un repositorio en GitHub, alojado en la dirección:

https://github.com/hprez21/Hyrule

A menudo me encuentro con muchos programadores que no tienen separada su lógica para acceso a datos, inclusive en proyectos grandes y de suma importancia. Es común observar en estos proyectos, la repetición constante de código para llevar a cabo una simple ejecución de una consulta a la base de datos.

La primer clase que agregaremos en nuestra biblioteca de clases, se llama “SQLHelper”, desarrollada por Microsoft como parte de su Microsoft Data Access Application Block for .NET, el cual podemos encontrar en el respositorio de GitHub, y la cual está compuesta por más de 4,500 líneas de código.

Para poder llevar a cabo una prueba rápida de la biblioteca, agregaremos un nuevo proyecto en Visual Studio de tipo consola al que denominaremos “Hyrule.DemosData”, al cual agregaremos la referencia a Hyrule.Data:

Una vez hecho esto, podemos agregar la referencia en código, y utilizar la clase para ver la lista de métodos disponibles:

 

Otra forma de conocer qué métodos están disponibles para nuestro uso, es yéndonos al menú View –> Object Browser, donde examinando el espacio de nombres Hyrule.Data, podemos observar la lista de métodos disponibles.

En la próxima entrega, comenzaremos a ver la forma de utilizar de forma general, los métodos de la clase.

 

Saludos.

Material de la plática “Introducción a los patrones de diseño” impartida el día 30/01/2015

Hola a todos, les comparto el material de la conferencia mostrada el día de ayer sobre patrones de diseño, con todo y código fuente, espero lo aprovechen.

https://github.com/hprez21/Introduccion-a-los-patrones-de-disenio

 

Saludos.

Diferencia entre tipo de dato float, double y decimal en C#

Todos estos tipos de dato son similares debido a que todos tienen un valor decimal, pero son diferentes en la forma en la que almacenan dicho valor. Un valor del tipo float tiene una precisión de 7 dígitos, mientras que un valor del tipo double entre 15-16 dígitos. Por otra parte, un valor del tipo decimal, tiene una precisión de 28-29 dígitos. Esto significa que debemos utilizar cada uno de ellos, de acuerdo a la situación a la que nos enfrentemos:

Decimal:

Debe ser utilizado en aplicaciones de alta precisión, como por ejemplo, las financieras, o aquellas donde se hagan cálculos que requieran suma precisión.

Double:

Puede usarse en situaciones que no requieran el uso de dinero.

Float:

Puede usarse en situaciones en las que puedan existir errores de redondeo, y requieran el uso intensivo de procesamiento, como el dibujo de gráficas o juegos.

Ejemplos de Uso:

//Decimal
decimal decimal = 12.12m;

//Flotante
float doble = 12.12f;

//Doble
double doble = 12.12d;

 

Saludos.

Creando una Biblioteca de Utilidades (Parte 1): Creando nuestro proyecto

¡Hola a todos! Tengo que admitir, que cuando uno empieza a programar, comete sin fin de errores, uno de los más cometidos, es el de no reutilizar el código que ya se ha escrito en proyectos anteriores.

En esta serie de entradas, escribiré acerca de cómo tener un set de clases y métodos, que podremos utilizar y reutilizar a lo largo de nuestros proyectos, algunas piezas de código son mi creación, algunas otras debo admitir no son creación mía (siempre que pase esto, haré la referencia debida al autor); y por creación de set de clases, no me refiero únicamente a clases que tendrán métodos que nos ayudarán, sino también a controles personalizados, que extiendan la funcionalidad de controles ya existentes de .Net. Todo esto lo veremos a través de estas entradas, que si bien, tengo bastante código por compartir, me gustaría que me dieran su opinión, si hay piezas de código que quieran que examinemos, con gusto también lo haremos 🙂

Empecemos entonces nuestro viaje.

En primer lugar, crearemos un nuevo proyecto, del tipo Biblioteca de Clases, en mi caso lo haré en C#. Sin embargo, quiero destacar que la dll que se generará a través de este proyecto, funcionará en nuestros proyectos tanto de C# como de VB. En  mi caso lo nombraré “Utilidades”

 

Esto nos creará un archivo llamado Class1.cs. Lo eliminemos para empezar desde 0.

Bien, ya que tenemos listo esto, debemos tener una forma de organizar nuestras clases ¿verdad? Esto lo haremos a través de los llamados namespaces, en la próxima entrega hablaremos más de ellos =).

P.D. Para tener una lectura más amena de estos posts, recomiendo el visor modo Lectura de Safari, está increíble! y hace la lectura mas sencilla:

Salu2!

Héctor Uriel Pérez Rojas

Creando una biblioteca de Utilidades (Intro)

¡Hola amigos y amigas! Gusto en saludarles =), ya tenía rato que no pasaba por aquí para escribir algo técnico, pero a veces el tiempo falta .

En esta ocasión, iniciaré una serie de posts para crear un set de clases que podrán reutilizar para sus proyectos. Esta serie irá en aumento, si alguien tiene algo que quiera compartir, algún tip, alguna pieza de código que podamos agregar a dicha biblioteca, bienvenido sea =).

Así que en esta semana, la primera clase o método para nuestra biblioteca, no desesperéis =D.

P.D. He agregado mi gamer tag de xbox live, por si alguien quiere echar una retita .

 

Salu2

Héctor Uriel Pérez Rojas

Tips para programar Orientado a Objetos con C#.- Tip #3: Ten un constructor central

Hola, tercera tip para programar Orientado a Objetos en C#, cualquier duda o comentario, háganmelo saber 🙂

Contexto:

Es muy común en las aplicaciones .Net, tener clases que tengan constructores de diversas firmas, es decir, que puedan ser llamadas de distintas formas. Un ejemplo, tomado de las clases del .NET Framework, es la clase SqlCommand, la cual tiene varios parámetros con los cuales puede ser inicializado:

Como puedes ver, cuando trabajas con esta clase, puedes llamar a la misma pasándole ningún parámetro, una cadena como parámetro, o bien un cadena y un objeto del tipo SqlConnection, para los que no lo sepan, a esto se le llama overloading (o sobrecarga en español), y nos sirve para tener un mismo método con el mismo nombre, pero que reciba diferentes parámetros.

Hagamos nosotros un ejemplo de esto, creemos una nueva clase, con 3 propiedades, y 1 constructor, que será básicamente lo que hemos visto en el tip # 2:

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public decimal Efectivo { get; set; }

   6:  

   7:     public Cliente(string _nombre, int _edad, decimal _efectivo)

   8:     {

   9:         this.Nombre = _nombre;

  10:         this.Edad = _edad;

  11:         this.Efectivo = _efectivo;

  12:     }

  13: }

A esta clase, le agregaremos un nuevo constructor, el cual tendrá una sobrecarga de 2 parámetros, y en el cual, inicializaremos el valor efectivo a 0:

 

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public decimal Efectivo { get; set; }

   6:  

   7:     public Cliente(string _nombre, int _edad, decimal _efectivo)

   8:     {

   9:         this.Nombre = _nombre;

  10:         this.Edad = _edad;

  11:         this.Efectivo = _efectivo;

  12:     }

  13:  

  14:     public Cliente(string _nombre, int _edad)

  15:     {

  16:         this.Nombre = _nombre;

  17:         this.Edad = _edad;

  18:         this.Efectivo = 0.00M;

  19:     }

  20: }

¿Y si tuviéramos otro constructor que no recibiera parámetros y quisiéramos inicializar todo a 0? ¿Qué tal otro constructor que solo reciba un parámetro? Y si tuvieras un constructor que tuviera 10 parámetros y tuviéramos que inicializar cada propiedad mediante la asignación de estos parámetros? Tendríamos que empezar a copiar y a pegar el código de cada constructor. Se dice que cuando se empieza a repetir nuestro código, algo está mal.

Mucho lío ¿No?

Solución:

Crear un constructor central, que haga todo el trabajo, y que sea solamente llamado en los constructores que deriven de él.

Así es, en nuestro ejemplo, tomaremos como constructor base el primer constructor con 3 parámetros, y lo único que haremos, será usarlo en nuestro segundo constructor de la siguiente manera:

   1: public Cliente(string _nombre, int _edad) 

   2:             : this(_nombre, _edad, 0.00M)

Esa es la manera de crear constructores que usen a uno principal. Para que veas que tanto se simplifica el código, aquí dejo el código para crear los constructores con ninguno, uno, dos y tres parámetros.

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public decimal Efectivo { get; set; }

   6:  

   7:     public Cliente(string _nombre, int _edad, decimal _efectivo)

   8:     {

   9:         this.Nombre = _nombre;

  10:         this.Edad = _edad;

  11:         this.Efectivo = _efectivo;

  12:     }

  13:     

  14:     public Cliente(string _nombre, int _edad) 

  15:         : this(_nombre, _edad, 0.00M)

  16:     {

  17:     }

  18:     public Cliente(string _nombre)

  19:         : this(_nombre, 18, 0.00M)

  20:     {

  21:     }

  22:     public Cliente()

  23:         : this("Héctor", 18, 0.00M)

  24:     {

  25:     }

  26: }

Ahora sí, tenemos disponibles diferentes inicializaciones para nuestra clase:

Nada de copiar y pegar. Cool eh? 🙂

Link de la solución: Tip3.zip

Salu2

Héctor Uriel Pérez Rojas

Tips para programar Orientado a Objetos con C#.- Tip #2: Crea y Usa Constructores

 

Segundo Tip para programar Orientado a Objetos con C#, espero que a mas de uno le sirva 🙂

Contexto:

En el ejemplo del tip # 1, hemos creado una clase Cliente, el cual tiene 3 propiedades (Nombre, Edad y Cuenta). Cuando hemos hecho uso de esta clase, ha sido de la siguiente forma:

   1: static void Main(string[] args)

   2: {

   3:     Cliente cliente = new Cliente();

   4:     cliente.Nombre = "Héctor";

   5:     cliente.Edad = 23;

   6:     cliente.Cuenta = 22312;

   7:     System.Console.WriteLine(cliente);

   8: }

Como podemos ver, tenemos que inicializar explícitamente cada una de las propiedades (cliente.Nombre=”Héctor; ….).

Imagina que tienes que crear una lista de Clientes, e inicializarla desde el inicio, una posible solución sería esta:

   1: public List<Cliente> RellenarLista()

   2: {

   3:     List<Cliente> lista = new List<Cliente>();

   4:  

   5:     Cliente cliente1 = new Cliente();

   6:     cliente1.Nombre = "Héctor";

   7:     cliente1.Edad = 23;

   8:     cliente1.Cuenta = 1111;

   9:     lista.Add(cliente1);

  10:  

  11:     Cliente cliente2 = new Cliente();

  12:     cliente2.Nombre = "Vianey";

  13:     cliente2.Edad = 23;

  14:     cliente2.Cuenta = 1111;

  15:     lista.Add(cliente2);

  16:  

  17:     Cliente cliente3 = new Cliente();

  18:     cliente3.Nombre = "Anahí";

  19:     cliente3.Edad = 23;

  20:     cliente3.Cuenta = 1111;

  21:     lista.Add(cliente3);

  22:  

  23:     return lista;

  24: }

Ahora imagina, si fueran decenas de clientes los que tuvieras que inicializar, esto se vuelve cada vez mas complicado, con la sintaxis que hemos estado utilizando.

Solución:

El tip de este día es, crear constructores para inicializar los valores de las propiedades una vez creada la clase. ¿Cómo se hace esto?

A través de un constructor. Un constructor es un método que se ejecutará cuando la clase sea instanciada. Si no está declarado uno por nosotros, el .NET  Framework creará uno por nosotros.

Primero debemos modificar nuestra clase Clientes, creando un constructor. Un constructor tiene la forma:

   1: Class Cliente

   2: {

   3:     public Cliente()

   4:     {

   5:     }

   6: }

Como puedes ver, es parecido a un método, toma el mismo nombre que la clase, y no tiene ningún tipo de retorno. Este constructor será llamado cuando se utilice la palabra new.

Para nuestro ejemplo, debemos modificar nuestro constructor, de tal forma que podamos inicializar nuestras propiedades (Nombre, Edad y Cuenta), una vez que sea creada la instancia de la clase. Esto lo logramos de la siguiente manera:

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public int Cuenta { get; set; }

   6:  

   7:     public Cliente(string _nombre, int _edad, int _cuenta)

   8:     {

   9:         this.Nombre = _nombre;

  10:         this.Edad = _edad;

  11:         this.Cuenta = _cuenta;

  12:     }

  13: }

Ahora bien, cuando queramos crear una nueva instancia de Cliente, se nos pedirá que le pasemos los parámetros solicitados por el constructor que hemos creado, si no, este marcará error:

Lo que el error nos dice, es que el constructor de Cliente, tiene 3 parámetros, y que está tratando de ser invocado, sin ninguno, por lo que nuestra inicialización quedaría:

   1: class ListaClientes

   2: {

   3:     public List<Cliente> RellenarLista()

   4:     {

   5:         List<Cliente> lista = new List<Cliente>();

   6:  

   7:         Cliente cliente1 = new Cliente("Héctor", 23, 1111);

   8:         lista.Add(cliente1);

   9:  

  10:         Cliente cliente2 = new Cliente("Vianey", 21, 2342);

  11:         lista.Add(cliente2);

  12:  

  13:         Cliente cliente3 = new Cliente("Anahí", 22, 8232);

  14:         lista.Add(cliente3);

  15:  

  16:         return lista;

  17:     }

  18: }

Como vemos, se ha simplificado muchísimo el código, haciéndolo mas fácil de leer, y de escribir. Cualquier duda o comentario, no duden en escribirlo 🙂

Link del ejemplo: Tip2.zip

Salu2

Héctor Uriel Pérez Rojas

Tips para programar Orientado a Objetos con C#.- Tip #1: Override ToString()

 

Hola! ¿Qué tal? Espero que todos anden bien 😉 En esta nueva colección de posts, mencionaré algunos tips que pueden ayudar a mas de uno, a sacar el mayor provecho mientras desarrolla en una programación Orientada  a Objetos. Espero que les gusten, como siempre, comentarios, preguntas son recibidos, así que empezamos.

Contexto:

Muchas veces, cuando somos nuevos programando, cometemos el error de trabajar con nuestras clases sin sobreescribir el método ToString que viene por defecto en la clase, a qué me refiero con esto? Pues a esto:

Supongamos que tenemos una clase Cliente, con la siguiente estructura:

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public int Cuenta { get; set; }

   6: }

Para probarla, he creado una solución de tipo consola, sobre la cual creo una nueva instancia de la clase, le asigno vales a sus propiedades, y posteriormente la mando a llamar para su impresión a través del método WriteLine de la Consola:

   1: static void Main(string[] args)

   2: {

   3:     Cliente cliente = new Cliente();

   4:     cliente.Nombre = "Héctor";

   5:     cliente.Edad = 23;

   6:     cliente.Cuenta = 22312;

   7:     System.Console.WriteLine(cliente);

   8: }

Esto, nos tira el siguiente resultado:

Solución:

Ok, vamos con el tip, sobreescribir el método ToString que viene por defecto en cada clase, para especificar qué queremos imprimir cuando ésta sea llamada, lo único que tenemos que hacer, es agregar la siguiente sintaxis a nuestra clase:

   1: public override string ToString(){}

Con lo que, específicamente nuestra clase quedaría:

   1: class Cliente

   2: {

   3:     public string Nombre { get; set; }

   4:     public int Edad { get; set; }

   5:     public int Cuenta { get; set; }

   6:  

   7:     public override string ToString()

   8:     {

   9:         return "Mi nombre es: " + Nombre

  10:             + " y tengo: " + Edad

  11:             + "y mi cuenta ficticia es: " + Cuenta;

  12:     }

Ahora, volvemos a llamar a nuestra clase desde nuestra aplicación de consola, con lo que nos retorna:

Ejemplo práctico:

Ahora bien, para que no se quede todo en una aplicación de consola, para probar esto mismo he creado un formulario en WPF(igual pudo haber sido una aplicación Windows Forms, ASP.NET, etc):

Básicamente, el concepto es el mismo, introduce el usuario un nombre, su edad y su cuenta, y posteriormente es agregado a la lista de los clientes.

   1: private void btnAgregar_Click(object sender, RoutedEventArgs e)

   2: {

   3:     Cliente cliente = new Cliente();

   4:     cliente.Nombre = txbNombre.Text;

   5:     cliente.Edad = int.Parse(txbEdad.Text);

   6:     cliente.Cuenta = int.Parse(txbCuenta.Text);

   7:     lsbCuentas.Items.Add(cliente);

   8: }

Ahora bien, si esto es usado sin el método sobreescrito de nuestra clase clientes, lo que se agrega es lo siguiente:

mientras, que sobreescribiendo el método ToString, obtenemos:

Les dejo el archivo de la solución en Visual Studio:

Tip1.zip

Salu2

Héctor Uriel Pérez Rojas

Duda en el blog

Bueno, pues en la sección de preguntas y respuestas me llega la siguiente consulta:

Hola Hector, muchas gracias por tu sitio,
ahora paso a mi consulta,
me gustaria tener un textbox en c# que haga autocompletar por ejemplo a las direcciones de email a partir de la @,
por ejemplo, que al escribir “usuariox@” el autocompletar muestre las opciones disponibles p.e. “@yahoo.com, @yahoo.es, @hotmail.com, @gmail.com, etc”, y que valla autocompletando segun se valla escribiendo la direccion p.e. “usuariox@ya” entonces muestre el autocompletar como “hoo.com, hoo.es, etc”
ya que he intentado con las propiedades del textbox agregando los items en autocomplete source custom como “@yahoo.com, @hotmail.com, @gmail.com, etc”
y el autocompletar solo se activa cuando comienzo a escribir con una “@” mostrando entonces las opciones o items;
he buscado por la red y no he encontrado nada parecido a lo que me interesa, espero no pedir mucho y haberme explicado bien,
en todo caso con que se activara el autocompletar a partir de la @ eso seria genial.

De antemano muchas gracias por tu ayuda.

Bueno, pues cuando leí esta consulta, me acordé rápidamente de el autocompletetextbox que creamos hace algún tiempo aquí

Bien, continuando con ese ejemplo, lo único que he hecho para que cumpla el requisito de arriba, es agregarle un evento KeyDown, para posteriormente detectar si se ha agregado un @ en la cadena, si es así pues se llena de posibles valores el ComboBox. Una imagen vale mas que mil palabras:

Hasta aquí todo normal, no nos muestra opciones a elegir aún, pero mira lo que sucede cuando agregamos el arroba y empezamos a escribir hotmail.com:

Proyecto: http://cid-2c11b62be5eb284d.skydrive.live.com/self.aspx/P%c3%bablico/Proyectos%20Blog/Autocomplete%20mails.zip

Salu2

Héctor Uriel Pérez Rojas

Reggyctor liberado

¿Cuántas veces no hemos estado en medio de la lectura de algún libro en otro idioma y nos encontramos con una palabra que desconocemos? Bueno, al menos a mí me ha pasado, lo molesto viene cuando uno tiene que ir a algún sitio de traducción en línea gratuito, es decir, el hecho de tener que cambiar de el documento, hacia el navegador. Para resolver esto, me di a la tarea de crear mi propio traductor, una aplicación en WPF llamado reggyctor, el cual tiene la habilidad de traducir en 15 diferentes idiomas.

Para llevar a cabo dicha tarea, he usado el servicio de traducción de microsoft translator. He subido en codeplex dicho proyecto, está tanto el instalador, como el código fuente. Aquí les dejo algunas capturas:

Splashscreen:

Programa en el escritorio:

Reggyctor en acción:

Espero que a mas de uno le sirva, comentarios bienvenidos 🙂

Proyecto: http://reggyctor.codeplex.com/

Salu2

Héctor Uriel Pérez Rojas

Copiando un archivo a una carpeta

Meli nos escribe esto:

estoy empezando con WPF y no se como poder transportar o copiar diferentes archivos o musica o videos a nuestro programa

Una pregunta que a mas de uno le habrá roto la cabeza, sin embargo, la solución es muy sencilla.

En primer lugar, he creado una solución WPF muy sencilla, con un botón, el cual, al dar click sobre él,  como en un ejemplo anterior, creamos un OpenFileDialog y le ponemos algunas propiedades

   1: OpenFileDialog fd = new OpenFileDialog();

   2: fd.Filter = 

   3:      "Archivos de imágen (.jpg)|*.jpg|All Files (*.*)|*.*";

   4: fd.Multiselect = false;

Posteriormente, checamos si el usuario ha hecho click sobre el botón ok, una vez seleccionado su archivo:

 

   1: bool? checarOK = fd.ShowDialog();

   2:             if (checarOK == true)

   3:             {

Si se ha seleccionado un archivo, y posteriormente clickeado sobre OK, recuperaremos la ruta del archivo:

   1: string archivoOrigen = fd.FileName;

Luego, especificaremos la ruta del directorio al cual queremos enviar nuestros archivos, si te has dado cuenta, muchos programas utilizan alguna carpeta sobre Documents, no sobre la aplicación, en nuestro caso, creamos la carpeta sobre Public:

   1: string rutaDestino = 

   2:     @"C:\Users\Public\CarpetaPrueba\SubDir";

Posteriormente, para crear un nuevo archivo, combinaremos la ruta del destino, con el nombre del archivo que hemos obtenido del OpenFileDialog:

   1: string archivoDestino = 

   2:     System.IO.Path.Combine(rutaDestino, fd.SafeFileName);

En caso de que sea la primera vez que se ejecute la aplicación, y no exista el folder de Subdir, lo crearemos:

   1: if(!System.IO.Directory.Exists(rutaDestino))

   2:  {

   3:    System.IO.Directory.CreateDirectory(rutaDestino);

   4:  }

Y finalmente, copiamos el archivo:

   1: System.IO.File.Copy

   2:     (archivoOrigen, archivoDestino, true);

Por si no entendieron algún paso, les paso el link de la solución:

http://cid-2c11b62be5eb284d.skydrive.live.com/self.aspx/P%c3%bablico/Proyectos%20Blog/CopyFiles.zip

 

Salu2

Héctor Uriel Pérez Rojas

Manejando cadenas de conexión en .Net con C#(3/3)

Bien, llegamos a la tercera y última entrega sobre el manejo de conexiones en .net con C#, hemos hablado en el pasado acerca de cómo crear una cadena de  conexión en la parte 1 y acerca de una manera mas eficiente para mejorar nuestro código en la parte 2.

En esta parte, hablaremos acerca de colocar nuestra cadena de conexión en un archivo de configuración, y cómo poder hacer uso de la misma en nuestro código.

Vamos a retomar el mismo proyecto que hemos venido manejando, y lo primero que haremos será agregar un nuevo archivo de configuración:

Lo dejaremos con el nombre por defecto. Ahora, el archivo creado nos mostrará lo siguiente:

¿Para qué servirá esto? Bueno, pues imagina que tienes 10 llamadas a tu base de datos con el código que hemos venido trabajando, si recuerdas, definimos en el código nuestra cadena de conexión; ¿Qué pasaría si de repente debemos cambiar el servidor de la conexión? pues un lío, habría que sustituir de una u otra forma cada una de las connection strings. Para evitarnos esto, creamos el archivo de configuración de nuestra aplicación, donde podremos agregar desde cadenas de conexión, hasta por ejemplo, colores de algún elemento visual. El formato de nuestro App.config está en xml, por lo que deberemos empezar a especificar etiquetas.

Nuestra primera etiqueta que agregaremos quedará:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <configuration>

   3:     <connectionStrings>        

   4:     </connectionStrings>

   5: </configuration>

Si te das cuenta, cuando empiezas a escribir dentro del app.config, el intellisense de visual studio te indica de hecho, que <connectionStrings> está disponible para autocompletar.

Excelente, ahora, dentro de connectionStrings, podemos definir la cantidad de cadenas de conexión que nosotros queramos, pero solo definiremos una en nuestro ejemplo, agregamos pues, una nueva cadena de conexión de la siguiente manera:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <configuration>

   3:   <connectionStrings>

   4:       <add name="miCadenaConexion" 

   5:            connectionString="Data Source=.\SQLEXPRESS;

   6:               Initial Catalog=BalloonShop;

   7:               User=balloonshop;

   8:               password=contraseña"/>

   9:   </connectionStrings>

  10: </configuration>

donde:

name = Nombre de tu cadena de conexión, puede ser cualquier nombre que desees;

connectionString = Hemos rescatado la cadena de conexión, que hemos utilizado en los posts anteriores, y la hemos colocado aquí.

Y listo, ya está listo nuestro archivo app.config, nos aseguramos de salvarlo, y ahora, cómo usarlo desde nuestro código?

Lo primero que debemos hacer, es agregar una nueva referencia, al ensamblado System.Configuration

Con un using, especificamos que queremos usar System.Configuration:

   1: using System.Configuration;

Ahora, cuando vayamos a definir nuestra cadena de conexión, debemos poner algo como esto:

   1: string miCadenaConexion = 

   2:                 ConfigurationManager.

   3:                 ConnectionStrings["miCadenaConexion"].

   4:                 ConnectionString;

Lo que hacemos, es llamar al administrador de configuraciones, quien obtiene la parte de connectionStrings de nuestro archivo app.config, ahí le especificamos el nombre de la cadena de conexión que queremos usar, y al final, le decimos que es la parte de connectionString la que nos interesa.

Si probamos nuestro código de ayer con esta modificación:

   1: using System;

   2: using System.Data.SqlClient;

   3: using System.Configuration;

   4:  

   5: namespace Cadenas_conexion_1

   6: {

   7:     class Program

   8:     {

   9:         static void Main(string[] args)

  10:         {

  11:             string miCadenaConexion = 

  12:                 ConfigurationManager.

  13:                 ConnectionStrings["miCadenaConexion"].

  14:                 ConnectionString;

  15:  

  16:             SqlConnection sqlconnection;

  17:  

  18:             using (sqlconnection = 

  19:                 new SqlConnection(miCadenaConexion))

  20:             {

  21:                 sqlconnection.Open();

  22:                 if (sqlconnection.State == 

  23:                     System.Data.ConnectionState.Open)

  24:                 {

  25:                     Console.WriteLine

  26:                         ("Conexión abierta");

  27:                     Console.Read();

  28:                 }

  29:             }

  30:  

  31:             if (sqlconnection.State 

  32:                 == System.Data.ConnectionState.Open)

  33:             {

  34:                 Console.WriteLine

  35:                     ("La conexión sigue abierta!");

  36:                 Console.Read();

  37:  

  38:             }

  39:             else

  40:             {

  41:                 Console.WriteLine

  42:                     ("La conexión se ha cerrado satisfactoriamente! :)");

  43:                 Console.Read();

  44:             }

  45:         }

  46:     }

  47: }

Obtendremos el mismo resultado:

Jeje, hemos pues, descrito en estas 3 partes, las mejores prácticas para manejar de una forma eficiente nuestras cadenas y conexiones a una base de datos, mas adelante, haremos uso de esto ampliamente 🙂

Salu2

Héctor Uriel Pérez Rojas

Manejando cadenas de conexión en .Net con C#(2/3)

En el post anterior, explicábamos acerca los partes que lleva una cadena de conexión, tanto cuando es autentificada por Windows, así como cuando es autentificada por rol SQL Server.

Bien, pues en este post, nos enfocaremos a ver una forma mucho más eficiente de conectarnos a nuestra base de datos.

En primer lugar, si recordamos el código del post anterior, tenía algo como esto:

   1: try

   2: {

   3:   sqlconnection.Open();

   4:   Console.WriteLine("Conexión Abierta Satisfactoriamente!");

   5: }

   6: catch (Exception ex)

   7: {

   8:   Console.WriteLine("Falló al tratarse de conectar a Base de Datos!");

   9: }

  10: finally

  11: {

  12:   sqlconnection.Close();

  13:   Console.ReadLine();

  14: }

Se podría decir, que este código está bien, sin embargo, existe un problema debido a que no se liberan los recursos una vez cerrada la conexión. Esto mismo hubiera pasado si hubiésemos tenido un sqlcommand.

Para arreglar esto, lo que debemos hacer, es poner el código dentro de un bloque a través de un using, el cual nos permitirá liberar de forma automática los recursos.

El using, es usado de la siguiente manera:

   1: using (SqlConnection sqlconnection = 

   2:         new SqlConnection(miCadenaConexion))

   3: {

   4:   sqlconnection.Open();               

   5: } 

como vez, en esta sección lo  estamos usando como un bloque, define un ámbito donde al final, el objeto automáticamente se destruirá, por eso no es necesario ni siquiera cerrar la conexión. A este código se le puede implementar un try – catch para probar capturar excepciones, pero para comprobar, y veas que no te miento, usaré el siguiente código para revisar el estado de nuestra conexión a la base de datos:

   1: SqlConnection sqlconnection;

   2:  

   3: using (sqlconnection = new SqlConnection(miCadenaConexion))

   4: {

   5:   sqlconnection.Open();

   6:   if (sqlconnection.State == System.Data.ConnectionState.Open)

   7:   {

   8:     Console.WriteLine("Conexión abierta");

   9:     Console.Read();

  10:   }

  11: }

  12:  

  13: if (sqlconnection.State == System.Data.ConnectionState.Open)

  14: {

  15:   Console.WriteLine("La conexión sigue abierta!");

  16:   Console.Read();

  17: }

  18: else

  19: {

  20:   Console.WriteLine("La conexión se ha cerrado satisfactoriamente! :)");

  21:   Console.Read();

  22: }

Como vez, lo que hacemos es primero comprobar el estado de la conexión dentro del primer if, y posteriormente lo volvemos a comprobar una vez saliéndonos del bloque using, con lo cual obtenemos:

Es una práctica recomendada, y que mejora mucho la forma de programar 🙂

Salu2

Héctor Uriel Pérez Rojas

Manejando cadenas de conexión en .Net con C#(1/3)

Esta es una duda muy común entre los que inician a trabajar con bases de datos desde .Net, así que aquí trataré de explicar en primer lugar, qué son, y posteriormente, cómo usarlas desde nuestras aplicaciones.

En primer lugar, para esta demo, he creado un proyecto nuevo en Visual Studio, del tipo consola.

Ahora, lo que haremos será abrir el Server Explorer de Visual Studio(Ctrl+Alt+S), y agregaremos una nueva conexión a la base de datos, que queramos conectarnos:

Suponiendo que nuestro proveedor es SQL Server, especificamos el nombre del Servidor de SQL Server, si es una conexión a través de Windows Authetication o SQL Server Authetication, y la base de datos correspondiente, para hacer un poco más práctico esto, agregaré 2 conexiones a la base de datos, una a través de autentificación por Windows, y la otra a través de autentificación SQL Server:

NOTA: En caso de no conocer tu Servidor SQL Server, dirigete a tu aplicación SQL Server Management Studio, donde podrás saber qué servidores tienes disponibles en tu máquina:

Si ahora nos dirigimos a las propiedades en Visual Studio de cada una de las conexiones, veremos diferentes cadenas de conexión:

De la conexión por Autentificación Windows:

De la conexión por SQL Server:

Para poder hacer uso, de las clases que .Net nos proporciona para poder trabajar con Bases de Datos, lo primero que tenemos que hacer es colocar dentro de la sección de nuestros using, el siguiente namespace:

   1: using System.Data.SqlClient;

Teniendo esto, vamos a hacer algo muy sencillo, no haremos consultas ni nada por el estilo, simplemente queremos comprobar que podemos abrir la Base de Datos apropiadamente, para esto, en primer lugar, declararemos una variable del tipo string, donde almacenaremos nuestra cadena de conexión a la base de datos autentificada por medio de Windows:

   1: string miCadenaConexion= @"Data Source=.\SQLEXPRESS;

   2:                            Initial Catalog=BalloonShop;

   3:                            Integrated Security=true";

donde:

Data Source = El Servidor de Base de datos;

Initial Catalog = Tu Base de Datos a la que te conectarás;

Integrated Security = Significa que la seguridad de Windows será usada en vez de un Login de SQL.

Nota: La @, sirve para poder hacer uso del símbolo \ sin que nos tire un error.

Bien, toca el turno a crear un objeto del tipo Connection String, a la cual le pasaremos como parámetro, la cadena de conexión especificada anteriormente:

   1: SqlConnection sqlconnection = new SqlConnection
                                       (miCadenaConexion);

Así de fácil y sencillo quedó listo esto, ahora, para probarla, lo que haremos será tratar de abrirla en un bloque try-catch-finally, para ver si es correctamente abierta:

   1: try

   2: {

   3:     sqlconnection.Open();

   4:     Console.WriteLine
          ("Conexión Abierta Satisfactoriamente!");

   5: }

   6: catch (Exception ex)

   7: {

   8:     Console.WriteLine
          ("Falló al tratarse de conectar a Base de Datos!");

   9: }

  10: finally

  11: {

  12:     sqlconnection.Close();

  13:     Console.ReadLine();

  14: }

Con lo que el código final queda así:

   1: using System;

   2: using System.Data.SqlClient;

   3:  

   4: namespace Cadenas_conexion_1

   5: {

   6:     class Program

   7:     {

   8:         static void Main(string[] args)

   9:         {

  10:             string miCadenaConexion = 
                  @"Data Source=.\SQLEXPRESS;
                  Initial Catalog=BalloonShop;
                  Integrated Security=true";

  11:             SqlConnection sqlconnection = new SqlConnection
                                             (miCadenaConexion);

  12:             try

  13:             {

  14:                 sqlconnection.Open();

  15:                 Console.WriteLine
                      ("Conexión Abierta Satisfactoriamente!");

  16:             }

  17:             catch (Exception ex)

  18:             {

  19:                 Console.WriteLine
                 ("Falló al tratarse de conectar a Base de Datos!");

  20:             }

  21:             finally

  22:             {

  23:                 sqlconnection.Close();

  24:                 Console.ReadLine();

  25:             }

  26:         }

  27:     }

  28: }

Probamos el código y obtenemos lo siguiente:

Si hubiesemos querido usar un LogIn de SQL Server, lo único que tenemos que hacer, es cambiar la cadena de conexión por una de este tipo:

   1: string miCadenaConexion = @"Data Source=.\SQLEXPRESS;

   2:                             Initial Catalog=BalloonShop;

   3:                             User=balloonshop;

   4:                             password=contraseña";

Y listo!

Nos vemos en la parte 2! 😉

Héctor Uriel Pérez Rojas

AutoComplete TextBox en WPF

Hace algunos días, durante el desarrollo de un proyecto, me di cuenta que este es un control que debería sin duda, estar entre los controles de WPF, sin embargo, otra es la realidad.

Así que, en este post, crearemos un Autocomplete TextBox de una manera muy pero muy sencilla, de hecho, será un ComboBox el que utilizaremos para este fin:

1.- En primer lugar, he creado un ComboBox, al cual le he agregado algunos elementos del tipo TextBlock:

Con esto tendremos un ComboBox común y corriente:

2.- Lo único que debemos hacer, es cambiar 2 propiedades del ComboBox, a verdaderas, las cuales son “IsEditable” y “StaysOpenOnEdit”

3.- Ponerle un nombre al ComboBox  (En mi caso le he puesto miComboBox), y posteriormente agregar un evento del tipo GotFocus, con el siguiente código:

   1: private void miComboBox_GotFocus(object sender, System.Windows.RoutedEventArgs e)

   2: {

   3:     miComboBox.IsDropDownOpen = true;

   4: }

Esto nos servirá, para que la lista sea abierta cada vez que entremos en el ComboBox.

4.- Editar la copia del ComboBox

y eliminar el elemento ToggleButton:

5.- Todo listo, a probarlo!!!!

Wow, funciona de maravilla 😀

En el siguiente post, mostraré cómo usarlo de una manera más práctica ;), hasta entonces, nos vemos.

Salu2

Héctor Uriel Pérez Rojas

Mis pisadas hacia el examen 70-536 – Capítulo 1, Lección 1: Usando los tipos valor

.NET, tiene 2 formas de almacenar las variables, por valor y por referencia.

¿Qué quiere decir esto? Bien, pues las variables tipo valor, son almacenadas en algo que se llama STACK, o traducido al español, pila; y que meramente es almacenado su valor. Esto significa, que si declaras una variable del tipo entero con valor 2, el valor 2 será almacenado en la pila. Para que lo entiendas mejor, un dibujo que describe esto:

Como se ve en el dibujo, cada rectángulo es un espacio en memoria, donde se almacenan los valores.

Ahora bien, existen 3 diferentes tipos valor:

Tipos Valor Built-In:

Son los tipos de datos, que ya vienen predefinidos con el framework, entre ellos podemos encontrar los siguientes con su respectiva descripción, y su respectivo alias para el lenguaje C# o bien VB.NET:

 

– Imagen tomada del curso DCE 2005

y el tamaño de cada uno de ellos, lo podemos observar en la siguiente imagen:

– Imagen tomada

Ahora bien, es muy pero muy importante, que estas tablas te las aprendas si es que quieres certificarte, ya que en el examen, vienen preguntas que hace referencia a conversiones entre los distintos tipos de datos.

Además, es importante aclarar, que existen muchos mas tipos de datos built-in, pero los que hemos visto en estas tablas, son los mas importantes.

Ejemplo de pregunta de certificación:

Trabajas en la compañía “La fábrica de las sorpresas”, donde usan Visual Studio 2008 para el desarrollo de aplicaciones.

Estás en el proceso de almacenar valores numéricos de hasta 2,100,000,000 en una variable, pudiendo requerir el almacenamiento negativo de valores también. Si la optimización en el uso de la memoria es requerido, sobre qué tipo de valor debes almacenar dichos valores?

a) Int32

b) UInt16

c) UInt32

d) Int16

 

Tipos Valor Nulos

También, existe la posibilidad de definir variables nulas, o sea una variable que inicialmente no tenga ningún valor. Esto se hace a través de una estructura de la siguiente forma:

   1: Nullable<int> miVariable = null;

O bien, en C#, tenemos una “forma bonita” de declarar valores nulos, o sea para no tener que estar poniendo todo eso de Nullable<int>, basta con aplicar un signo de interrogación después del tipo de dato, para indicar que éste puede ser nulo:

   1: int? miVariable = null;

pero, ¿y para qué nos serviría algo así?, bueno, pues por poner un ejemplo, cuando se le asigna a una variable la estructura de Nullable, adquiere otras propiedades, como por ejemplo, una propiedad llamada HasValue, la cual nos podría servir para verificar que la variable ha obtenido algún valor:

   1: int? miVariable = null;

   2: 

   3:             if(miVariable.HasValue)

   4:                 Console.WriteLine("La variable tiene valor");

   5:             else

   6:                 Console.WriteLine("La variable no tiene valor");

 

Tipos Valor Definidos por el usuario

Estos tipos de datos, mejor conocidos como estructuras, de igual forma son almacenados sobre la pila. En muchos casos, su comportamiento es muy pero muy parecido al de las clases, al poder crearles constructores, métodos, atributos y mas.

Las estructuras, están compuestas de otros tipos de datos, los cuales hacen mas fácil trabajar con nuestros tipos definidos.

Las estructuras, se definen a través de la palabra clave struct (en C#); por ejemplo, podemos definir una estructura llamada Persona, con otro tipo de dato dentro de sí mismo, de tipo entero, para almacenar la edad:

   1: struct Persona

   2:     {

   3:         private int _edad;

   4:     }

Incluso, una estructura puede contener un tipo de valor definido por nosotros mismos. Supongamos que tenemos otra estructura del tipo Personal, sobre la cual queremos almacenar una variable definida por nosotros anteriormente, en este caso la estructura Persona:

   1: struct Personal

   2:     {

   3:         private Persona _persona1;

   4:     }

Ahora bien, cuál es la diferencia entre una clase y una estructura??

Bueno, pues esto es algo en lo que aquellos que están aprendiendo un lenguaje usualmente no se paran a pensar, sin embargo, existen varios criterios, entre los cuales, destacan los siguientes:

• Representen un único valor lógicamente
• Tengan un tamaño menor a los 16 bytes
• No es frecuentemente cambiado después de ser creado
• No es convertido (Cast) a un tipo referencia

Enumeraciones

Supongamos que tienes una variable, la cual puede tener diferentes valores, por ejemplo, una variable llamada Estados, la cual puede tener como valores: “Aguascalientes, Baja California … Zacatecas”, o sea, 32 posibles valores. Pues esto meramente hacen las enumeraciones, enumerar cada uno de los valores que puede tener dicha variable. Esto le sirve a los desarrolladores para limitar las opciones disponibles para un valor. El ejemplo de los estados quedaría así:

   1: enum Estados

   2: {

   3:     Aguacalientes,

   4:     BajaCalifornia,

   5:     Chiapas,

   6:     Sonora,

   7:     Zacatecas

   8: }

Bueno eso es todo, a continuación les dejo el video de la lección:

Espero que haya quedado bien claro este tema, y cualquier comentario o sugerencia, no duden en contactarme, asimismo, de antemano les pido su apoyo para el próximo concurso de BlogIt, que muy pronto empieza, no les pido dinero a cambio de esta base de conocimientos para el examen 70-536, sin embargo, si les pido su voto de antemano, pronto les pondré el link. Gracias 🙂

 

Héctor Uriel Pérez Rojas

“Hector the Wizard” finalmente publicado

Hola qué tal a todos? Bueno pues esta es una aplicación que he creado para el concurso de Mix 09, el reto se llama Mix 10K, se trata de crear una aplicación donde el total de archivos para la aplicación pese como limite 10k. Esta es la aplicación:

Básicamente, los primeros 5 pasos son para obtener un número, el cual puedes hacer en la aplicación, o a mano, el paso numero 6 es donde a partir del número en el paso 5, se tratará de adivinar el número sobrante.

Si quieres probarla y de paso votar por mí 😛 , puedes checarla aquí:

Mi entrada en el concurso 10k Competition

😉

Héctor Pérez

¿Cómo crear un Splash Screen en WPF?

John 10:14-15“I am the good shepherd; I know my sheep and my sheep know me— just as the Father knows me and I know the Father—and I lay down my life for the sheep.”

Para aquellos no familiarizados con el tema, el Splash Screen según la Wikipedia es:

“Splash screen is a term used to describe an image that appears while a computer program is loading. Splash screens sometimes do not cover the entire screen, but only a rectangle near the center. The splash screens of operating systems and some applications that expect to be run full-screen usually cover the entire screen.”

En palabras sencillas, un splash screen es la imagen que te aparece cuando inicias algún programa como office, visual studio, etc. Bien, pues para que tengas una idea, antes, era un tanto complicado hacer que estas aparecieran en escena, ya que no aparecen junto con la aplicación, sino que son lanzadas justo antes de que se cargue completamente tu programa, y esperan a que este se cargue para darle paso. Pues hoy aprenderemos a hacerlo sin tanto esfuerzo.

Antes que nada, los requisitos, Visual studio 2008, y lo más importante, el SP1 del framework 3.5.

Método 1:

Crear una aplicación WPF estándar. Paso siguiente es agregar la imágen que quieras que sea tu splashscreen:

En mi caso, he creado una para efectos de la demostración:

Acto seguido, es irnos a las propiedades de la imagen que hemos insertado, y cambiar el modo de Build Action a Splash Screen:

Si has hecho todo bien, seguramente debe de salirte tu splash screen antes de cargar la aplicación:

Sencillo no?

Paso # 2:

Para continuar con la demo, cambiaremos el modo de la imagen a None:

Dirigete a tu archivo (en mi caso) Window1.xaml.cs, donde agregarás el siguiente código, desupés del método InitializeComponent():

SplashScreen sp = new SplashScreen("tarjeta.png");
sp.Show(true);

Si te das cuenta, lo que hacemos aquí, es crear un nuevo SplashScreen, pasando el parámetro de nuestra imágen al constructor. La propiedad de Show, que tiene que ser booleano, identifica si la imagen se cerrará sola cuando se cargue nuestro programa o no. Ahora puedes probar el programa y verás que sucede lo mismo que la vez anterior.

Espero que te sea de utilidad 😉

Salu2

Héctor Pérez

Abriendo archivos desde WPF

Hola qué tal?, bueno pues en las dudas y comentarios, ha surgido una pregunta, la cual parafraseo:

"…estoy haciendo una aplicación en wpf, el problema es que necesito insertar una imagen, ojo, ésta es una imagen cualquier, lo que necesito es insertar imagenes que originalmente no estén en el proyecto… "

Ahora bien, cómo insertamos una imagen, o mas bien, la pregunta sería,¿ cómo obtengo acceso a un archivo en mi computadora?

Para efectos de esta demo, he creado un archivo WPF, con 2 elementos, un control del tipo Image, y un control del tipo Button:

Ahora bien, una cosa importante es ponerle nombre a ambos elementos, en este caso, al control image le he puesto por nombre imagen, y al boton btn_imagen.

Lo siguiente es declarar el evento para nuestro botón (lo pudes hacer dando doble click sobre el botón).

private void Button_Click(object sender, RoutedEventArgs e)

{

}

Ahora bien, tanto en winforms como en WPF, está disponible para nosotros la clase OpenFileDialog, el cual, nos permitirá abrir un cuadro de diálogo desde el cual podremos seleccionar uno o mas archivos a ser abiertos, entonces no queda mas que declarar una nueva instancia de dicha clase:

OpenFileDialog openFileDialog1 = new OpenFileDialog();

Bien, ahora, tenemos que especificar un filtro para los archivos que buscaremos, ya sean con extensión .txt, .docx, etc etc etc, esto lo hacemos con la propiedad Filter:

openFileDialog1.Filter = "Archivos de imágen (.jpg)|*.jpg|All Files (*.*)|*.*";

Como puedes darte cuenta, en este caso hemos especificado que cuando abra el cuadro de diálogo, aparezcan como selección los archivos con extensión .jpg, y por otro lado, todos los archivos.

Lo siguiente es declarar la propiedad de Index a 1, esto es para obtener el Index del filtro que anteriormente especificamos, dentro de nuestro cuadro de diálogo:

openFileDialog1.FilterIndex = 1;

Permitiremos que varios archivos puedan ser selccionados a la vez, o sólo uno? En este caso le diremos que podrán ser varios, con la propiedad Multiselect:

openFileDialog1.Multiselect = true;

Ahora, falta checar si hemos presionado el botón de OK o el de cancel, esto se puede hacer fácilmente con una declaración de un booleano, al cual se le asigne la respuesta del file dialog:

bool? checarOK = openFileDialog1.ShowDialog();

Ok, en dado caso de que haya el usuario clickeado en OK, debemos especificar qué pasará, para esto usaremos la propiedad “FileName”, la cual, obtiene la ruta del archivo que hayamos selccionado, la cual es una cadena; un breakpoint aquí, y es que, si checamos en las dependency propierties de WPF, veremos que Image tiene una llamada source, a la cual normalmente le asignamos la ruta de los archivos que tenemos(p.e. \images\imagen.jpg), por lo que fácilmente podríamos irnos con la finta de que quedaría algo así:

imagen.source = openFileDialog1.FileName.ToString;

pues eso es totalmente erróneo, lo que debemos hacer, es crear un nuevo BitmapImage, con la ruta que nos haya arrojado precisamente FileName de nuestro cuadro de diálogo, y posteriormente asignarselo al control Image:

imagen.Source = new BitmapImage(new Uri(openFileDialog1.FileName));

Ahora,  a probar nuestra aplicación:

La ventana principal:

La ventana después de haber presionado el botón:

La ventana después de haber seleccionado una imágen:

Entonces, el código final queda:

private void Button_Click(object sender, RoutedEventArgs e)
{
    OpenFileDialog openFileDialog1 = new OpenFileDialog();
    openFileDialog1.Filter = "Archivos de imágen (.jpg)|*.jpg|All Files (*.*)|*.*";
    openFileDialog1.FilterIndex = 1;
    openFileDialog1.Multiselect = true;
    bool? checarOK = openFileDialog1.ShowDialog();
    if (checarOK==true)
    {              
        //imagen.source = openFileDialog1.FileName.ToString;
         //(System.Windows.Media.ImageSource)
        imagen.Source = new BitmapImage(new Uri(openFileDialog1.FileName));
    }
}

Y aquí está el enlace para descargar la demo:

AbrirImagen.zip

Salu2 y éxito 😉

Héctor Pérez

Databinding en WPF (2/N)

Hola de nuevo a todos, y felices fiestas patrias!! jaja, vale, pues en este día he llevado a cabo la grabación de la segunda parte de la serie «Databinding en WPF», espero que les sirvan mucho los conceptos que se tratan en estos videos. Cualquier duda o comentario, no duden en dejarlos vale? Me despido pues y q VIVA MÉXICO!!!!

Salu2

VIDEO EN MSN VIDEO:

LINK PARA DESCARGAR Screencast (Peso 27.2MB):

Databinding%202.wmv-download

Espero comentarios, y que Dios los Bendiga 🙂

Héctor Pérez

Convirtiendo controles 2-D en 3-D en WPF

Bien, hola qué tal de nuevo? Ok en la sección de Preguntas y Respuestas Tere pregunta cómo poder manipular un TextBox en Expression Blend como si un objeto 3-D se tratara.

Bien pues aquí les explico 3 formas en las que se puede hacer, casi lo mismo(porque no en todos es tan sencillo).

Bueno, primero entender que como su nombre lo dice, la función de «Make Image 3D» funciona solo para convertir imágenes en objetos 3-D, no para otro tipo de controles, por lo tanto:

Forma # 1:

Vamos a crear un nuevo proyecto, insertamos un textbox:

Acto seguido, teniendo el TextBox seleccionado, lo convertimos en un VisualBrush:

Le pones el nombre que desees, y ya lo tendrás disponible para usarlo.

Posteriormente, lo que tienes que hacer es insertar una imagen, y convertirla en 3-D:

Vale, ahora que tienes una imagen 3-D, tienes que agregarle como material el VisualBrush que has creado anteriormente al modelo:

Por si no lo alcanzas a ver, el elemento al que modificamos el material se encuentra en :

ViewPort3D->ModelContainer->Content->Model (Cuadro Rojo)

el cual te mostrará en las propiedades un BackMaterial y un Material(Cuadro amarillo), una vez seleccionado el mismo, te mostrará los Brushes que pudes agregarle, en la seccion de hasta la derecha, se encuentran tus propios Brushes, en el cual estará el que has creado hace un momento, al momento de seleccionarlo automáticamente la imagen obtendrá una «copia» de lo que esté pasando en el TextBox original, con esto podrás mover la imagen como si fuera un objeto tridimensional, pero…. hay un pequeño problema…..

NO PUEDES ESCRIBIR SOBRE ÉL; ¿Porqué? Pues porque es una simple imágen. Esto sirve principalmente para animar labels, texblocks, etc; pero si lo que quisieras es escribir realmente en el textbox, lo puedes hacer con la siguiente forma:

 

Forma # 2:

Para esta forma, requieres bajar las 3D Tools for the Windows Presentation Foundation, misma que fue creada por el equipo 3D de WPF.

Bien, voy a crear un nuevo proyecto, agrego una referencia a la DLL que se encuentra dentro de la carpeta que acabo de descargar con el nombre de 3DTools.dll

Ahora agregas una referencia al assembly desde el código XAML:

NOTA: Para los que no saben que acabo de hacer, estoy creando una referencia a la DLL que agregué, paso a paso quiero decir:

xmlns = xml namespace; o sease que estoy creando una referencia a un espacio de nombres.

xmlns:local = Estoy nombrando de alguna forma mi acceso al assembly, en este caso local, aunque pudo haber sido cualquier otro.

«clr-namespace:_3dTools; = clr-namespace es la sintaxis para ubicar un espacio de nombres

assembly=3DTools»  = Es el ensamblado o la librería que acabamos de agregar, y donde se encuentra _3dTools.

Bien, ahora, procedemos a escribir el código que empezará a crear en sí los objetos 3D:

<Window.Resources> 
    <MeshGeometry3D x:Key=»3dMesh»
        Positions=»-1,1,0 -1,-1,0 1,-1,0 1,1,0″
        TextureCoordinates=»0,0 0,1 1,1 1,0″
        TriangleIndices=»0 1 2 0 2 3″/> 
    <RotateTransform3D x:Key=»3dTransform»>
      <RotateTransform3D.Rotation>
        <AxisAngleRotation3D Angle=»45″ Axis=»0 1 1″ />
      </RotateTransform3D.Rotation>
    </RotateTransform3D> 
    <Grid Background=»White» x:Key=»3dMaterial»>
      <Grid.RowDefinitions>
        <RowDefinition Height=»*»/>
        <RowDefinition Height=»*»/>
        <RowDefinition Height=»*»/>
      </Grid.RowDefinitions> 
      <TextBox Grid.Row=»0″>Demo con WPF 3D Tools</TextBox>
      <Slider Grid.Row=»1″ />
      <Button Grid.Row=»2″ Width=»60″ Height=»25″>Aceptar</Button> 
    </Grid> 
  </Window.Resources>

jeje, parece un poco complicado, pero trataré de explicar un poco:

Empiezo definiendo dentro de los Recursos de la aplicación (Window.Resources), en primer lugar, un mashGeometry3D(Geometría de malla), el cual será el encargado de darle forma a mi objeto 3D, esto lo hago con positions(Posiciones Vertex de mi malla), TextureCoordinates(Sirve para definir las coordenadas de mi textura) y TriangleIndices(Indices Triangulares); estos son los recursos base  para definir la textura de mi objeto 3D. Posteriormente Hago un RotateTransform3D para voltear un poco mi objeto 3D, y agrego una serie de elementos(Grilla, dentro de la misma un textbox, un slider y un botón). Como puedes darte cuenta, a cada uno de los elementos que ligaremos les hemos puesto un x:Key, que servirá para referenciarlos (3dMes, 3dTransform y 3dMaterial)

Ahora, el código en sí de la aplicación:

<Grid> 
    <local:TrackballDecorator>
    <local:Interactive3DDecorator> 
      <Viewport3D Width=»450″ Height=»225″> 
        <Viewport3D.Camera>
          <PerspectiveCamera Position=»0, 0, 4″  FieldOfView=»75″ />
        </Viewport3D.Camera> 
        <ModelVisual3D>
          <ModelVisual3D.Content>
            <DirectionalLight Color=»White» Direction=»0,0,-1″ />
          </ModelVisual3D.Content>
        </ModelVisual3D> 
        <local:InteractiveVisual3D
            Transform=»{StaticResource 3dTransform}»
            Geometry=»{StaticResource 3dMesh}»
            Visual=»{StaticResource 3dMaterial}» />
      </Viewport3D> 
    </local:Interactive3DDecorator>
    </local:TrackballDecorator> 
  </Grid>

Aquí, lo que estamos haciendo es, en primer lugar:

<local:TrackballDecorator> = Ingresamos a los métodos de nuestra clase Tools3D, este principalmente nos sirve para hacer un zoom in y zoom out, además de hacer rotación a voluntad del objeto.

<local:Interactive3DDecorator> = Sirve para interactuar con los elementos de nuestro modelo 3D

<Viewport3D… =  Definimos un Viewport3D, así como el que se crea cuando convertimos una imagen en 3D

<Viewport3D.Camera> = Agregamos una cámara

<PerspectiveCamera = Posicionamos la camara

<ModelVisual3D Creamos nuestro modelo 3D

<ModelVisual3D.Content = En nuestro caso, lo estamos usando para agregar una luz

<local:InteractiveVisual3D
            Transform=»{StaticResource 3dTransform}»
            Geometry=»{StaticResource 3dMesh}»
            Visual=»{StaticResource 3dMaterial}» />

Hacemos un binding de cada una de las propiedades de nuestro objeto interactivo 3D, uno al Transform, otro a la malla que definimos, y el último al material 3D(este último contendrá nuestros controles).

Y bien, luego luego aparece en el diseñador el aspecto que nuestra aplicación tiene, y al cual al correrlo, se observa así:

He seleccionado el texto para que veas que efectivamente funciona, ahora puedes de igual manera acercar o alejar el objeto, y rotarlo a tu gusto:

Si no quieres que aparezca cortado el control, lo único que tienes que hacer es poner en falsa la propiedad «CliptoBounds»:

Forma # 3:

Bien, hemos usado una DLL en la forma anterior, sin embargo, con el Framework 3.5 se incluye un control para colocar objetos 2D dentro de objetos 3D,  su nombre es Viewport2DVisual3D; para lo que tendremos que agregar otro espacio de nombres:

xmlns:d=»http://schemas.microsoft.com/expression/blend/2008″

Seguiremos con el proyecto anterior para que te des una idea mas clara de como funciona esto. Primero borra todas las referencias de código que empiecen con <local: …/>, menos la de <local:InteractiveVisual3D.

Lo que vas a hacer ahora, es cambiar esa referencia <local:InteractiveVisual3D , por un elemento Viewport2DVisual3D

        <Viewport2DVisual3D
            Transform=»{StaticResource 3dTransform}»
            Geometry=»{StaticResource 3dMesh}»
            Visual=»{StaticResource 3dMaterial}»>
        </Viewport2DVisual3D>
      </Viewport3D>

Ahora, lo único que falta es agregar el material en sí del objeto Viewport2DVisual3D:

<Viewport2DVisual3D.Material>
    <DiffuseMaterial Viewport2DVisual3D.IsVisualHostMaterial=»true»/>
</Viewport2DVisual3D.Material>

Al final quedaría así:

<Viewport2DVisual3D
            Transform=»{StaticResource 3dTransform}»
            Geometry=»{StaticResource 3dMesh}»
            Visual=»{StaticResource 3dMaterial}»>
          <Viewport2DVisual3D.Material>
            <DiffuseMaterial Viewport2DVisual3D.IsVisualHostMaterial=»true»/>
          </Viewport2DVisual3D.Material>
        </Viewport2DVisual3D>

Con esto obtienes un resultado muy parecido al anterior,

con la pequeña gran diferencia de que no pudes hacer zoom in, zoom out, ni rotar a voluntad en tiempo de ejecución, para lo cual, si gustas puedes agregarle funcionalidad nuevamente poniendo tu ViewPort3D dentro del elemento:

<local:TrackballDecorator> , con su etiqueta de cierre respectivamente.

Bueno, eso es todo, aquí les dejo los proyectos creados con cada una de las formas antes descritas:

Forma 1: 3D_Forma_1.rar-download

Forma 2: 3D_Forma_2.rar-download

Forma 3: 3D_Forma_3.rar-download

Bien, espero que hayáis entendido los conceptos básicos, una vez hecha cualquiera de las formas anteriores, es posible mover nuestros controles a entera libertad en Blend, que es lo que me habían pedido, si queréis aprender al 100 les recomiendo que lean un libro relacionado al mismo, uno que les puedo recomendar es:

3D Programming for Windows

http://www.charlespetzold.com/3D/index.html

Salu2, y por favor Tere o los demás, si pueden hacerme un feedback lo agradecería mucho, Salu2 y éxito!

Héctor Pérez

Nuevas Características de C# 3.0 (Automatically Implemented Properties)

A partir de esta entrada, empezaré una serie de posts donde mencionaré las nuevas características de c# 3.0, con las cuales simplificarás código y te ahorrarás tiempo.

Primero, vamos a hablar de las Automatically Implemented Properties(Propiedades implementadas automáticamente).

Anteriormente, y es común que las propiedades se establezcan de esta forma:

public class Persona
{
    private string nombre;
    private string ciudad;

    public int NOMBRE {
    get { return nombre; }
    set {  = value; } }

    public int CIUDAD {
    get { return ciudad; }
    set { y = value; } }
}

 

como vemos, primero se declaran atributos, en este caso nombre y ciudad, y posteriormente se crean las 2 propiedades correspondientes, ambas de escritura y lectura.

Ahora, en C#, ya no es necesario todo eso, y se simplifica a lo siguiente:

public class Persona
{
    public int NOMBRE{get; set;}
    public int CIUDAD {get; set;}
}

¿Qué ha cambiado? Bien, que ya no es necesario todo ese rollo de get{ return…..; sino que el compilador infiere que estamos estableciendo un regreso de valor y una asignación de valor, pero entra la duda, qué pasaría si quisieramos que fuera una propiedad de solo lectura? Bien, pues sencillo, tenemos que declarar el valor para set como privado, es decir:

public class Point
{
    public int NOMBRE{get; private set;}
    public int CIUDAD  {get; private set;}
}

Mucho mas sencillo no?

Salu2

Héctor Pérez

¿Cómo cargar una tabla de BD hecha en SQL 2005 en WPF?

 

Bien, pues esta es una pregunta que me ha llegado hoy, así que he decidido escribir sobre esto hoy.

Antes que nada; ¿Qué control usar?

Bien, los que ya están mas adentrados en esto, sabrán que actualmente el control DataGridView existente en Windows Forms no existe en WPF, pero sí en silverlight, así que, lo que yo les recomiendo es usar un control ya existente y que es gratuito, se llama Xceed DataGrid for WPF, y lo puedes descargar desde aquí:

http://xceed.com/Grid_WPF_Intro.html

Tienes que registrarte para que te den un serial válido, la verdad es un control muy sencillo de usar, vale si no estás convencido puedes echarle un vistazo al demo aquí:

http://xceed.com/Grid_WPF_Demo.html

Bien, si ya has descargado e instalado el control, lo que tienes que hacer es :

1.- Importar las librerías necesarias, yo lo he hecho desde Visual Studio, ya has de saber, click derecho sobre el proyecto, agregar referencias, e importas todas las que empiecen con XCeed(XCeed.Controls,XCeed.Datagrid… etc).

Una vez hecho esto, si vas a tu ToolBar, notarás que tienes nuevos controles disponibles para insertar, en este caso debes insertar el DataGridControl:

Como puedes observar, el control es insertado inmediatamente, y a la vez Visual Studio nos genera el código necesario para hacer referencia al namespace.

2.- Vale lo siguiente es configurar el control desde XAML, esto lo haremos agregando 2 atributos a nuestro control, los atributos serán:

x:Name=»playersGrid» ItemsSource=»{Binding}

O sease agregamos un nombre a la grilla para que pueda ser usada desde código, y la fuente de datos de la misma, en este caso solo ponemos Binding, el cual hará binding con lo generado desde el código C#.

A continuación, vamos a nuestro archivo Code behind, y agregamos lo siguiente:

 

 

protected override void OnInitialized(EventArgs e)
{

    DataSet ds;

    base.OnInitialized(e);

    ds = getData();

    playersGrid.DataContext = ds.Tables[«cliente»];

}

private DataSet getData()
{

    string connString = string.Format(«Data Source=HÉCTOR1\\SQLEXPRESS; AttachDbFilename=|DataDirectory|\\Libreria.mdf; Integrated Security=True; User Instance=True»);

    SqlConnection conn = new SqlConnection(connString);

    DataSet dataSet = new DataSet();

    SqlDataAdapter playersAdapter = new SqlDataAdapter();

    playersAdapter.SelectCommand = new SqlCommand(«Select cve_cliente, nombre, paterno, materno, calle, ciudad from cliente», conn);

    playersAdapter.Fill(dataSet, «cliente»);

    return dataSet;

}

 

Básicamente, aquí lo que hago es hacer una conexión con mi servidor de Base de Datos, hago la consulta correspondiente y regreso el dataset cliente, el cual entrará en el DataContext de la grilla. Si quieres probar con tu base de datos, tienes que cambiar:

«Data Source=NOMBRE_DE_TU_SERVIDOR;

DataDirectory|\\TU_BASE_DE_DATOS.mdf;

 

(«Select cve_cliente, nombre, paterno, materno, calle, ciudad from cliente» POR TU SENTENCIA SQL,

«cliente» por la tabla que quieres meter en el DataContext.

Con todo esto, el resultado será algo como esto:

Ahora bien, si quieres jugar un poco mas, puedes darle click al centro de la Grilla:

Con lo cual nos aparecerán opciones de configuración de la grilla, en mi caso, cambié el tipo de vista y el tema:

con lo cual, nos queda algo mas chévere:

 

Espero que les haya sido de utilidad, un saludo, por cierto, igual pudiste haber utilizado el mismo control DataGridView usado en el framework 2, pero por el momento creo que esto es mejor no? Salu2

Link del proyecto: EjemploDataGrid.rar-download

Héctor Pérez

Visual Basic .NET vs C# .NET: ¿Cual es mejor y por qué?

 

El próximo 6 de Mayo, Second Nug tiene el honor de presentar a dos ponentes de excepción, Guillermo Som (el Guille) y Marino Posadas (el Ave Fénix), en la que será una gran batalla donde dos voces con gran experiencia expondrán sus mejores bazas en un duelo sin igual: VB .NET vs C# .NET.
Sabremos por qué se decantaron por un lenguaje u otro y nos presentarán su evolución en las nuevas versiones del .NET Framework. Nos desvelaran secretos y trucos de sus defendidos y veremos si es cierto aquello de que lo que se puede hacer con uno, se puede realmente hacer con el otro.
Además los asistentes podrán resolver sus dudas preguntando a nuestros expertos y participar en el resultado final de la contienda.
El eterno dilema al descubierto. ¿Quién será el vencedor?

El evento será a las 19:30 – 21:30 (GMT+2), y como en las anteriores ocasiones, se retransmitirá vía Web a través de Live Meeting.

Si no tienes Live Meeting, puedes descargarlo en el siguiente enlace.

Podéis registraros en el evento en el siguiente enlace.

Héctor Pérez