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

image

   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:

image

image

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

image

¿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

image

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:

image

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

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

image

.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:

image

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:

image

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:

 

tabla

– Imagen tomada del curso DCE 2005

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

image

– 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

Mis pisadas hacia el examen 70-536 – Introducción

Hola qué tal? Sé que mi último post data desde diciembre, simplemente, no había tenido tiempo de escribir, quiero agradecer a todos aquellos que dejaron comentarios :), aquí me tienen de nuevo je je.

Estoy por presentar el examen de Microsoft 70-536: TS: Microsoft .NET Framework – Application Development Foundation, para lo cual estoy teniendo un entrenamiento personal muy fuerte, ahora bien, me gustaría compartir con los interesados, las cosas que vaya aprendiendo a través de este, mi humilde blog.

image

La cosa está así, haré posts respecto a un tema en específico, explicando las bases, para posteriormente publicar un video en donde abarque de forma práctica cómo se pueden aplicar esos conocimientos en la vida real. Eso sí, abarcaré todos los temas correspondientes al temario del examen, no importa que vaya lento, lo importante es que quede bien hecho.

Esto lo hago, en parte para tener una base de conocimientos personal, y para que todo aquel, que al igual que yo, vaya a presentar este examen, o bien, simplemente para abarcar conocimientos.

Si quieren obtener mas información al respecto, aquí está el link de la descripción del examen:

http://www.microsoft.com/learning/en/us/exams/70-536.aspx

Pues entonces, a estudiar se ha dicho! 😉

 

Héctor Uriel Pérez Rojas

Me uno al equipo de mty.Coders

Bien, pues el día de hoy, Michael A. Warner de Alva me ha dado la bienvenida a la comunidad mty.Coders, el post lo puden ver aquí: Permanent Link to ¡Héctor Pérez se une al equipo!; espero colaborar activamente con ellos, y con ello, que hagamos crecer esta comunidad cada día mas.

mty.Coders, como lo definen sus creadores Michael Warner y Gustavo Barrientos,

es un Blog de Noticias de TI, Comunidad de Desarrolladores y Foro de Discusión orientado a estudiantes, desarrolladores y consultores, fundado en Monterrey, Nuevo León, México. Es un lugar dónde compartir código, snippets, tutorials, e información relativo a la programación y consultoría de TI, etc.

Me ha gustado en particular el propósito:

El propósito del sitio es abrir puertas y unir a los programadores para compartir conocimientos, ideas, código y programas en español.

La web esta llena de información en Ingles, sin embargo hay muy poca información relevante en español.

En eso concuerdo mucho con ellos, así que te invito de la manera mas cordial, a que te unas a nosotros, y hagamos de esta comunidad algo grande! Gracias pues, Michael, y en hora buena 🙂

Link de la comunidad: http://mtycoders.com

Salu2

Héctor Pérez