Wiki sobre Arquitectura del software en Geeks•ms

Software Arquitecture

Oscar — Sun, 12 Feb 2012 01:11:03 GMT

Revisión actual enviado a Wiki sobre Arquitectura del software en Geeks•ms por Oscar a 2/12/2012 2:11:03 AM

Good site¡

Concepto de arquitectura de software

Ángel Manuel — Fri, 07 Jan 2011 14:14:49 GMT

Revisión actual enviado a Wiki sobre Arquitectura del software en Geeks•ms por Ángel Manuel a 1/7/2011 3:14:49 PM

Un conversor Fº-Cº en tu sitio web (ELIMINADO)Concepto de arquitectura de software

Elimino este artículo debido a que la programación a

El concepto de arquitectura del software abarca varias definiciones, pero podemos definirlo como la estructura de más alto nivel de ese sistema, que se hacía referenciaabarca componentes de software, no está orientada a sitios web las propiedades visibles externas de esos componentes, y la aplicación que las relaciones entre estos. También se programaría sería errónea en sitios webdefinen así a los documentos relativos a ésta.

Disculpen las molestias

Se suele expresar en diagramas, habiendo varios tipos de arquitecturas como por ejemplo la cliente servidor.

Un cordial saludo

Un conversor Fº-Cº en tu sitio web (ELIMINADO)

Ángel Manuel — Fri, 07 Jan 2011 13:20:26 GMT

Revisión 6 enviado a Wiki sobre Arquitectura del software en Geeks•ms por Ángel Manuel a 1/7/2011 2:20:26 PM

Un conversor Fº-Cº en tu sitio web (ELIMINADO)

Archivado en: asp.net, conversor en sitio web, visual basic, farenheit-celsius

Elimino este artículo debido a que la programación a la que se hacía referencia, no está orientada a sitios web y la aplicación que se programaría sería errónea en sitios web.

Disculpen las molestias.

Un cordial saludo

Un conversor Fº-Cº en tu sitio web (ELIMINADO)

Ángel Manuel — Wed, 08 Sep 2010 12:59:44 GMT

Revisión 5 enviado a Wiki sobre Arquitectura del software en Geeks•ms por Ángel Manuel a 9/8/2010 2:59:44 PM

Un conversor Fº-Cº en tu sitio web (ELIMINADO)

Archivado en: asp.net, conversor en sitio web, visual basic, farenheit-celsius

Quiero enseñarles cómo poder implementar un conversor Farenheit-Celsius en tu sitio web (el sitio debe ser de tipo ASP.NET porque en HTML, PHP u otros lenguajes, no sirve esto). Para ello deberemos disponer de Visual Web Express Edition/Visual Studio, y realizar los siguientes pasos:

Iniciar Visual Studio/Visual Web Express
Ir
Elimino este artículo debido a Archivo>Nuevo>Sitio web; y seleccionamos "Sitio Web ASP.NET", habiendo seleccionado Visual Basic como lenguaje.
Insertamos un control "Button", seleccionándolo del cuadro de herramientas (no de HTML).
Hacemos doble clic, y accederemos que la programación a la secc. del código e insertamos el código que muestro más abajo (el lenguaje del código es Visual Basic):
Pulsamos las teclas Ctrl+F5, y se mostrará el sitio.
Haz clic en el botón y te saldrá una ventana con el conversor (si no te aparecehacía referencia, estarno está minimizada, así que restaúrela)

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        Dim FTemp, Celsius As Single
        Dim strFTemp As String
        Dim Prompt As String = "Insert a Farenheit unit."
        Do
            strFTemp = InputBox(Prompt, "Conversor")
            If strFTemp <> "" Then
                FTemp = CSng(strFTemp)
                Celsius = Int((FTemp + 40) * 5 / 9 - 40)
                MsgBox(Celsius, , "Unit in Celsius")
            End If
        Loop While strFTemp <> ""
        End
    End Sub

Si usted lo desea, puede probar orientada a realizar este proceso en otra plataforma como MonoDevelop u otra, pero no estoy muy seguro de sitios web y la posibilidad de como lo harías en Visual Studio.

Puedes descargar un proyecto que se hizo como aplicación de escritorio en http://code.google.com/p/celsiter, estando dicha aplicación disponible que se programaría sería errónea en inglés y español.sitios web.

Disculpen las molestias.

Un cordial saludo

Un conversor Fº-Cº en tu sitio web

Ángel Manuel — Sun, 14 Mar 2010 14:04:10 GMT

Revisión 4 enviado a Wiki sobre Arquitectura del software en Geeks•ms por Ángel Manuel a 3/14/2010 3:04:10 PM

Un conversor Fº-Cº en tu sitio web

Archivado en: asp.net, conversor en sitio web, visual basic, farenheit-celsius

Iniciar Visual Studio/Visual Web Express
Ir a Archivo>Nuevo>Sitio web; y seleccionamos "Sitio Web ASP.NET", habiendo seleccionado Visual Basic como lenguaje.
Insertamos un control "Button", seleccionándolo del cuadro de herramientas (no de HTML).
Hacemos doble clic, y accederemos a la secc. del código e insertamos el código que muestro más abajo (el lenguaje del código es Visual Basic):
Pulsamos las teclas Ctrl+F5, y se mostrará el sitio.
Haz clic en el botón y te saldrá una ventana con el conversor (si no te aparece, estará minimizada, así que restaúrela)

Si usted lo desea, puede probar a realizar este proceso en otra plataforma como MonoDevelop u otra, pero no estoy muy seguro de la posibilidad de como lo harías en Visual Studio.

Puedes descargar un proyecto que se hizo como aplicación de escritorio en http://code.google.com/p/celsiter, estando dicha aplicación disponible en inglés y español.

Un conversor Fº-Cº en tu sitio web

Ángel Manuel — Sun, 14 Mar 2010 14:03:01 GMT

Revisión 3 enviado a Wiki sobre Arquitectura del software en Geeks•ms por Ángel Manuel a 3/14/2010 3:03:01 PM

Un conversor Fº-Cº en tu sitio web

Archivado en: asp.net, conversor en sitio web, visual basic, farenheit-celsius

Quiero enseñarles cómo poder implementar un conversor Farenheit-Celsius en tu sitio web. Para ello deberemos disponer de Visual Web Express Edition/Visual Studio, y realizar los siguientes pasos:

Iniciar Visual Studio/Visual Web Express
Ir a Archivo>Nuevo>Sitio web; y seleccionamos "Sitio Web ASP.NET", habiendo seleccionado Visual Basic como lenguaje.
Insertamos un control "Button", seleccionándolo del cuadro de herramientas (no de HTML).
Hacemos doble clic, y accederemos a la secc. del código e insertamos el código que muestro más abajo (el lenguaje del código es Visual Basic):
Pulsamos las teclas Ctrl+F5, y se mostrará el sitio.
Haz clic en el botón y te saldrá una ventana con el conversor (si no te aparece, estará minimizada, así que restaúrela)

Si usted lo desea, puede probar a realizar este proceso en otra plataforma como MonoDevelop u otra, pero no estoy muy seguro de la posibilidad de como lo harías en Visual Studio.

Puedes descargar un proyecto que se hizo como aplicación de escritorio en http://code.google.com/p/celsiter, estando dicha aplicación disponible en inglés y español.

Un conversor Fº-Cº en tu sitio web

Ángel Manuel — Sat, 13 Mar 2010 15:06:50 GMT

Revisión 2 enviado a Wiki sobre Arquitectura del software en Geeks•ms por Ángel Manuel a 3/13/2010 4:06:50 PM

Un conversor Fº-Cº en tu sitio web

Archivado en: asp.net, conversor en sitio web, visual basic, farenheit-celsius

Iniciar Visual Studio/Visual Web Express
Ir a Archivo>Nuevo>Sitio web; y seleccionamos "Sitio Web ASP.NET", habiendo seleccionado Visual Basic como lenguaje.
Insertamos un control "Button", seleccionándolo del cuadro de herramientas (no de HTML).
Hacemos doble clic, y accederemos a la secc. del código e insertamos este el código:ódigo que muestro más abajo:
Pulsamos las teclas Ctrl+F5, y se mostrará el sitio.
Haz clic en el botón y te saldrá una ventana con el conversor (si no te aparece, estará minimizada, así que restaúrela)

Un conversor Fº-Cº en tu sitio web

Ángel Manuel — Sat, 13 Mar 2010 15:06:04 GMT

Revisión 1 enviado a Wiki sobre Arquitectura del software en Geeks•ms por Ángel Manuel a 3/13/2010 4:06:04 PM

Iniciar Visual Studio/Visual Web Express
Ir a Archivo>Nuevo>Sitio web; y seleccionamos "Sitio Web ASP.NET", habiendo seleccionado Visual Basic como lenguaje.
Insertamos un control "Button", seleccionándolo del cuadro de herramientas (no de HTML).
Hacemos doble clic, y accederemos a la secc. del código e insertamos este código:
Pulsamos las teclas Ctrl+F5, y se mostrará el sitio.
Haz clic en el botón y te saldrá una ventana con el conversor (si no te aparece, estará minimizada, así que restaúrela)

TabControl con algunas mejoras (C# / VB)

Javier Torrecilla — Mon, 18 Oct 2010 14:29:34 GMT

Revisión actual enviado a Wiki sobre Arquitectura del software en Geeks•ms por Javier Torrecilla a 10/18/2010 4:29:34 PM

Desde las versiones antiguas de Visual Studio, me he encontrado con un pequeño problema a la hora de trabajar con el TabControl: Ocultar / Mostrar las TabPages.

Pese a que el control TabControl, presenta una propiedad “TabPageCollection” que alberga todas las TabPages del Control, y a su vez cada TabPage tienen unos métodos Hide y Show, su funcionamiento no es el que “yo” desearía. Me explico:

- Si yo llamo al método Hide de un TabPage, me gustaría que este TabPage no fuera visible de cara al usuario.

¿Qué sucede cuando llamo al método Hide?: Puesto que el objeto TabPage, herede del control Panel, el método Hide, se encarga de ocultar el panel que se muestra en el control TabControl y todo su contenido, pero no la cabecera de la “pestaña”.

Del mismo modo el método Show() lo que va a realizar es mostrar su contenido.

Por ello, he creado un control de Usuario para implementar los métodos HideTabPage y ShowTabPage.

Para poder realizar estos métodos he creado una lista privada para manejar las “TabPages”:

List<TabPage> AllTabPages;

Para su correcto funcionamiento, en el Constructor de la Clase, inicializo la lista:

AllTabPages = new List<TabPage>();

Y ya se puede implementar la funcionalidad:

public void HideTabPage(TabPage tb)

{

            if (TabPages.Contains(tb))

   {

                foreach (TabPage t in TabPages)

                {

                    if (!AllTabPages.Contains(t))

                        AllTabPages.Add(t);

                }

this.TabPages.Remove(tb);

}

       }

public void ShowTabPage(TabPage tb)

       {

           if ((AllTabPages.Contains(tb)) && (!TabPages.Contains(tb)))

               this.TabPages.Add(tb);

       }

Para su utilización bastaría con hacer una llamada de la siguiente manera:

extTabControl1.HideTabPage(TabPage1);

o

extTabControl1.ShowTabPage(TabPage1);

Además de Ocultar y Mostrar un TabPage, he generado la posibilidad de Habilitar / Deshabilitar TabPages y que el control no entre en TabPages Deshabilitadas. Para lograrlo he sobrescrito el método Selecting del control:

protected override void OnSelecting(TabControlCancelEventArgs e)

{

   if (e.TabPageIndex > -1)

{

               TabPage tb = TabPages[e.TabPageIndex];

               if (tb.Enabled == false)

                   e.Cancel = true;

               else

                   base.OnSelecting(e);

           }

       }

Os dejo el enlace a CodePlex donde lo he publicado.

Si tenéis cualquier duda, aquí estoy.

Saludos

Los atributos y su uso en VS.

Javier Torrecilla — Wed, 06 Oct 2010 09:09:49 GMT

Revisión actual enviado a Wiki sobre Arquitectura del software en Geeks•ms por Javier Torrecilla a 10/6/2010 11:09:49 AM

Este ejemplo viene a servir para destacar el uso de los atributos en el código.

Si entrais aquí , podréis ver más en detalle la definición de los atributos.

Los atributos pueden aplicar a Clases, Métodos o Funciones y Propiedades.

Se pueden usar uno o varios sobre el mismo objeto.

Sintaxis:

VB "<"Atributo([Parametros])">" _ (Sobras las ")Clase, método o propiedad

C# [Atributo([Parametros])] Clase, método o propiedad

Algunos ejemplos de atributos son:

- Serializable: Permite guardar una clase como un fichero XML a través de un Serializer.

- Required: hace indicar que una propiedad es obligatoria. Acepta el parámetro ErrorMessage donde se podría indicar el valor en el caso de que no se rellene la propiedad.

- StringLength: nos permite validar longitudes de una cadena, he indicar un mensaje de error si no se cumple.

- RegularExpression: nos permite validar una cadena con una expresión regular dada. Para ver ejemplos de expresiones regulares podeis visitar este enlace.

-DisplayNameAttribute: nos permite darle un alias a una propiedad.

El ejemplo, consiste en la creación de ficheros XML a través de MVC. El código fuente del ejemplo lo teneis en este enlace

Introducción a las Expresiones Regulares.

Josué Yeray Julián Ferreiro — Mon, 13 Sep 2010 09:28:03 GMT

Revisión actual enviado a Wiki sobre Arquitectura del software en Geeks•ms por Josué Yeray Julián Ferreiro a 9/13/2010 11:28:03 AM

Hola a todos

Las expresiones regulares acompañan a los programadores desde hace mucho tiempo, se comenzó a hablar de ellas en Teoría de la información desde el año 1950, y desde entonces han supuesto una potente forma de procesar textos basada en patrones de búsqueda.

Aún así muchas veces es una parte del desarrollo que pasa desapercibida por lo que he decidido dedicarle algo de tiempo y explicaros sus orígenes, historia, implementaciones y gran funcionalidad, estoy seguro que os podrán sacar de más de un aprieto.

Pero… ¿Que son las Expresiones regulares?

Una expresión regular, también llamada patrón, es una expresión que define de manera genérica un conjunto de cadenas, de las que conocemos su estructura básica pero no conocemos cada uno de los caracteres que pueden componerlas.

Por poner un ejemplo, pensemos en una lista de elementos: Casa, Caza, Caasa, podríamos describir todos estos elementos con la expresión regular o patrón [ Ca(a?|s|z)a ], que identificaría las 3 cadenas antes indicadas, más adelante analizaremos más a fondo este patrón para que comprendáis su significado.

Historia

Los orígenes de las expresiones regulares se encuentran en la teoría de autómatas y la teoría de lenguajes formales, en 1950 el matemático Stephen Cole Kleene describió estos modelos usando su notación matemática llamada Regular Sets, y adaptados posteriormente al editor ed de UNIX, para más tarde ser usadas en expr, AWK, Emacs, vi y lex.

El uso de expresiones regulares en modelado de datos e información estructurada comenzó en 1960 y se expandió considerablemente en 1980. El núcleo del standard Lenguaje de especificaciones estructuradas son las expresiones regulares.

Expresiones Regulares en .NET

.NET incluye un motor de expresiones regulares desde su primera versión, que no ha sufrido cambios importantes y es uno de los mejor implementados que podemos encontrar.

Para usar expresiones regulares en nuestra aplicación simplemente debemos importar el namespace System.Text.RegularExpressions al inicio de nuestra clase:

Imports System.Text.RegularExpressions

Class MainWindow

End Class

Una vez hecho esto podremos acceder a la clase RegEx, que representa una instancia del motor de expresiones regulares de .NET, podemos usar esta clase para buscar rápidamente una subcadena dentro de una gran cantidad de texto o para extraer, editar, reemplazar o eliminar subcadenas de texto.

Para ello, primero debemos definir el patrón o expresión que queremos buscar. Para esto las expresiones regulares cuentan con todo un ejercito de definiciones que nos ayudan a indicar el texto que queremos considerar una coincidencia:

Definición	Descripción
\|	ó.
^	Inicio de la línea.
$	Fin de la línea.
\A	Inicio de la cadena.
\Z	Fin de la cadena.
\b	Inicio / Fin de palabra.
\B	No al inicio o fin de palabra.
*	Buscar el dígito o letra anterior 0 ó más veces.
?	Buscar el dígito o letra anterior 0 ó 1 vez.
+	Buscar el dígito o letra anterior al menos 1 vez.
{n}	Buscar exactamente el contenido de las llaves.
{n,m}	Buscar todas las coincidencias entre n y m.
{n,}	Buscar desde n en adelante.
\u0000 - \uFFFF	Buscar el caracter unicode.
?<nombre>Expr.Regular	Asignar un nombre al grupo de captura.

Esta es una pequeña lista de los elementos del lenguaje de las expresiones regulares, puedes encontrar una referencia completa en MSDN, aquí.

Con esto, pongamos un ejemplo práctico, imaginad que estáis analizando el texto de un archivo html y queréis encontrar todas las referencias a imágenes jpg y almacenarlas en una lista de cadenas para descargarlas posteriormente, sería tan sencillo como hacer esto:

(nota: esto es solo un ejemplo y bajo ciertas condiciones controladas, no identificaría correctamente todas las imágenes en un html real, es solo una muestra)

Dim Patron As String = "src='?<imagen>(http.*jpg)'\s+"
Dim Expresion As New Regex(Patron, RegexOptions.IgnoreCase)
Dim ListaImagenes As New List(Of String)

For Each Coincidencia As Match In Expresion.Matches(InputText)
ListaImagenes.Add(Coincidencia.Groups("imagen").Value)
Next

Como podéis ver es realmente sencillo usar expresiones regulares, son muy útiles para validación de entrada de texto, podéis definir varios patrones “no permitidos” y comprobar el texto que ha introducido el usuario en busca de ellos, por ejemplo podéis buscar un patrón SQL para evitar SQL Injection en aplicaciones Web o un patrón con el tipo de texto que el usuario debe introducir para verificar que el dato es correcto.

He preparado un pequeño programa en VB.NET y WPF que os permite cargar un archivo de texto e introducir una expresión regular a buscar en ese texto y os devuelve todas las coincidencias encontradas:

Conclusión

Bueno, las expresiones regulares son tan antiguas como la informática misma, pero son un recurso muy valioso hoy en día, puesto que nos ofrecen una herramienta inestimable para validar, corregir y extraer información de archivos sin formato predefinido, que de otra forma nos darían dolores de cabeza.

Espero que os haya gustado tanto leer este artículo como a mi escribirlo.

Por si tenéis alguna dificultad, a parte por supuesto de poder contactar conmigo tanto dejando mensajes, como en mi twitter, como en msdn o a mi email directamente, os dejo el proyecto completo para descarga.

Muchas gracias por leerme y Happy Coding!

Descargar Código fuente.

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

hectorperez — Fri, 10 Sep 2010 05:05:18 GMT

Revisión actual enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/10/2010 7:05:18 AM

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 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 bases de datos.

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

hectorperez — Thu, 09 Sep 2010 04:04:24 GMT

Revisión actual enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/9/2010 6:04:24 AM

Anteriormente, explicamos 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

Nos vemos en la parte 3!

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

hectorperez — Thu, 02 Sep 2010 03:52:44 GMT

Revisión actual enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 5:52:44 AM

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

Archivado en: C#

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!

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

hectorperez — Thu, 02 Sep 2010 03:49:16 GMT

Revisión 8 enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 5:49:16 AM

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

Archivado en: C#

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:

1: using System.Data.SqlClient;

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

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

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:

Y listo!

Nos vemos en la parte 2!

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

hectorperez — Thu, 02 Sep 2010 03:46:13 GMT

Revisión 7 enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 5:46:13 AM

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

Archivado en: C#

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:

1: using System.Data.SqlClient;

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

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);SqlConnection

                                             (miCadenaConexion);
12:             try
13:             {
14:                 sqlconnection.Open();

15: Console.WriteLine

                      ("Conexión Abierta Satisfactoriamente!");
16:             }
17:             catch (Exception ex)
18:             {

19: Console.WriteLine

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!

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

hectorperez — Thu, 02 Sep 2010 03:44:44 GMT

Revisión 6 enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 5:44:44 AM

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

Archivado en: C#

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:

1: using System.Data.SqlClient;

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

1: SqlConnection sqlconnection = new SqlConnection
(miCadenaConexion);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);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!

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

hectorperez — Thu, 02 Sep 2010 03:43:35 GMT

Revisión 5 enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 5:43:35 AM

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

Archivado en: C#

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

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

hectorperez — Thu, 02 Sep 2010 03:12:42 GMT

Revisión 4 enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 5:12:42 AM

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

Archivado en: C#

<o:p></o:p>

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:

<o:p></o:p>

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 Autentificación SQL SQL Server:

<o:p></o:p>

<o:p>

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:<o:p></o:p>
1: using System.Data.SqlClient;

<o:p></o:p>
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:<o:p></o:p>
   1: string miCadenaConexion= @"Data Source=.\SQLEXPRESS;<o:p></o:p>
   2:                            Initial Catalog=BalloonShop;<o:p></o:p>
   3:                            Integrated Security=true";<o:p></o:p>";
donde:<o:p></o:p>
Data Source = El Servidor de Base de datos;<o:p></o:p>
Initial Catalog = Tu Base de Datos a la que te conectarás;<o:p></o:p>ás;
Integrated Security = Significa que la seguridad de Windows será usada en vez de un Login de SQL.<o:p></o:p>
Nota: La @, sirve para poder hacer uso del símbolo \ sin que nos tire un error.<o:p></o:p>
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:<o:p></o:p>

</o:p>

1: SqlConnection sqlconnection = new SqlConnection

                                       (miCadenaConexion);<o:p></o:p>
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:<o:p></o:p>
   1: try<o:p></o:p>
   2: {<o:p></o:p>
   3:     sqlconnection.Open();<o:p></o:p>

<o:p></o:p>

4: Console.WriteLine<o:p> </o:p>

          ("Conexión Abierta Satisfactoriamente!");<o:p></o:p>");
   5: }<o:p></o:p>
   6: catch (Exception ex)<o:p></o:p>
   7: {<o:p></o:p>

<o:p></o:p>

8: Console.WriteLine<o:p> </o:p>

          ("Falló al tratarse de conectar a Base de Datos!");<o:p></o:p>");
   9: }<o:p></o:p>
10: finally<o:p></o:p>
11: {<o:p></o:p>
12:     sqlconnection.Close();<o:p></o:p>
13:     Console.ReadLine();<o:p></o:p>
14: }<o:p></o:p>
Con lo que el código final queda así:<o:p></o:p>í:
   1: using System;<o:p></o:p>
   2: using System.Data.SqlClient;<o:p></o:p>
   3: <o:p></o:p>
   4: namespace Cadenas_conexion_1<o:p></o:p>
   5: {<o:p></o:p>
   6:     class Program<o:p></o:p>
   7:     {<o:p></o:p>
   8:         static void Main(string[Main(string[] args)<o:p></o:p>
   9:         {<o:p></o:p>

<o:p></o:p>

10: string miCadenaConexion = <o:p></o:p>

<o:p></o:p>

@"Data Source=.\SQLEXPRESS;<o:p></o:p>

<o:p></o:p>

Initial Catalog=BalloonShop;<o:p></o:p>

<o:p> </o:p>

Integrated Security=true";<o:p></o:p>

<o:p></o:p>";

11: SqlConnection sqlconnection = new SqlConnection<o:p> </o:p>

                                             (miCadenaConexion);<o:p></o:p>
12:             try<o:p></o:p>
13:             {<o:p></o:p>
14:                 sqlconnection.Open();<o:p></o:p>

<o:p></o:p>

15: Console.WriteLine<o:p> </o:p>

                      ("Conexión Abierta Satisfactoriamente!");<o:p></o:p>");
16:             }<o:p></o:p>
17:             catch (Exception ex)<o:p></o:p>
18:             {<o:p></o:p>

<o:p></o:p>

19: Console.WriteLine<o:p> </o:p>

                 ("Falló al tratarse de conectar a Base de Datos!");<o:p></o:p>");
20:             }<o:p></o:p>
21:             finally<o:p></o:p>
22:             {<o:p></o:p>
23:                 sqlconnection.Close();<o:p></o:p>
24:                 Console.ReadLine();<o:p></o:p>
25:             }<o:p></o:p>
26:         }<o:p></o:p>
27:     }<o:p></o:p>
28: }<o:p></o:p>
Probamos el código y obtenemos lo siguiente:<o:p></o:p>

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:<o:p></o:p>
   1: string miCadenaConexion = @"Data Source=.\SQLEXPRESS;<o:p></o:p>
   2:                             Initial Catalog=BalloonShop;<o:p></o:p>
   3:                             User=balloonshop;<o:p></o:p>
   4:                             password=contraseña";<o:p></o:p>ña";
Y listo!

<o:p></o:p>

Nos vemos en la parte 2!<v:shapetype coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f" id="_x0000_t75"><v:stroke joinstyle="miter"></v:stroke><v:formulas><v:f eqn="if lineDrawn pixelLineWidth 0"></v:f><v:f eqn="sum @0 1 0"></v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f></v:formulas><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock></v:shapetype><v:shape o:spid="_x0000_i1025" type="#_x0000_t75" alt="Descripción: ;)" id="Imagen_x0020_1" style="width: 11.25pt; height: 11.25pt; visibility: visible; mso-wrap-style: square;"><v:imagedata src="file:///C:\Users\HECTOR\AppData\Local\Temp\msohtmlclip1\01\clip_image001.gif" o:title=";)"></v:imagedata></v:shape><o:p></o:p>

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

hectorperez — Thu, 02 Sep 2010 03:03:17 GMT

Revisión 3 enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 5:03:17 AM

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

Archivado en: C#

<o:p></o:p>

<v:shapetype coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f" id="_x0000_t75"><v:stroke joinstyle="miter"></v:stroke><v:formulas><v:f eqn="if lineDrawn pixelLineWidth 0"></v:f><v:f eqn="sum @0 1 0"></v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f></v:formulas><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock></v:shapetype><o:p></o:p>

<o:p></o:p>

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:

<o:p></o:p>

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 Autentificación SQL Server:

<o:p></o:p>

<o:p>

1: using System.Data.SqlClient;

<o:p></o:p>

1: string miCadenaConexion= @"Data Source=.\SQLEXPRESS;<o:p></o:p>

2: Initial Catalog=BalloonShop;<o:p></o:p>

3: Integrated Security=true";<o:p></o:p>

donde:<o:p></o:p>

Data Source = El Servidor de Base de datos;<o:p></o:p>

Initial Catalog = Tu Base de Datos a la que te conectarás;<o:p></o:p>

Integrated Security = Significa que la seguridad de Windows será usada en vez de un Login de SQL.<o:p></o:p>

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

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:<o:p></o:p>

</o:p>

1: SqlConnection sqlconnection = new SqlConnection

(miCadenaConexion);<o:p></o:p>

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:<o:p></o:p>

1: try<o:p></o:p>

2: {<o:p></o:p>

3: sqlconnection.Open();<o:p></o:p>

<o:p></o:p>

4: Console.WriteLine<o:p> </o:p>

("Conexión Abierta Satisfactoriamente!");<o:p></o:p>

5: }<o:p></o:p>

6: catch (Exception ex)<o:p></o:p>

7: {<o:p></o:p>

<o:p></o:p>

8: Console.WriteLine<o:p> </o:p>

("Falló al tratarse de conectar a Base de Datos!");<o:p></o:p>

9: }<o:p></o:p>

10: finally<o:p></o:p>

11: {<o:p></o:p>

12: sqlconnection.Close();<o:p></o:p>

13: Console.ReadLine();<o:p></o:p>

14: }<o:p></o:p>

Con lo que el código final queda así:<o:p></o:p>

1: using System;<o:p></o:p>

2: using System.Data.SqlClient;<o:p></o:p>

3: <o:p></o:p>

4: namespace Cadenas_conexion_1<o:p></o:p>

5: {<o:p></o:p>

6: class Program<o:p></o:p>

7: {<o:p></o:p>

8: static void Main(string[] args)<o:p></o:p>

9: {<o:p></o:p>

<o:p></o:p>

10: string miCadenaConexion = <o:p></o:p>

<o:p></o:p>

@"Data Source=.\SQLEXPRESS;<o:p></o:p>

<o:p></o:p>

Initial Catalog=BalloonShop;<o:p></o:p>

<o:p> </o:p> Integrated Security=true";<o:p></o:p>

<o:p></o:p>

11: SqlConnection sqlconnection = new SqlConnection<o:p> </o:p>

(miCadenaConexion);<o:p></o:p>

12: try<o:p></o:p>

13: {<o:p></o:p>

14: sqlconnection.Open();<o:p></o:p>

<o:p></o:p>

15: Console.WriteLine<o:p> </o:p>

("Conexión Abierta Satisfactoriamente!");<o:p></o:p>

16: }<o:p></o:p>

17: catch (Exception ex)<o:p></o:p>

18: {<o:p></o:p>

<o:p></o:p>

19: Console.WriteLine<o:p> </o:p>

("Falló al tratarse de conectar a Base de Datos!");<o:p></o:p>

20: }<o:p></o:p>

21: finally<o:p></o:p>

22: {<o:p></o:p>

23: sqlconnection.Close();<o:p></o:p>

24: Console.ReadLine();<o:p></o:p>

25: }<o:p></o:p>

26: }<o:p></o:p>

27: }<o:p></o:p>

28: }<o:p></o:p>

Probamos el código y obtenemos lo siguiente:<o:p></o:p>

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:<o:p></o:p>

1: string miCadenaConexion = @"Data Source=.\SQLEXPRESS;<o:p></o:p>

2: Initial Catalog=BalloonShop;<o:p></o:p>

3: User=balloonshop;<o:p></o:p>

4: password=contraseña";<o:p></o:p>

Y listo!

<o:p></o:p>

Nos vemos en la parte 2! <v:shapetype coordsize="21600,21600" o:spt="75" o:preferrelative="t" path="m@4@5l@4@11@9@11@9@5xe" filled="f" stroked="f" id="_x0000_t75"><v:stroke joinstyle="miter"></v:stroke><v:formulas><v:f eqn="if lineDrawn pixelLineWidth 0"></v:f><v:f eqn="sum @0 1 0"></v:f><v:f eqn="sum 0 0 @1"></v:f><v:f eqn="prod @2 1 2"></v:f><v:f eqn="prod @3 21600 pixelWidth"></v:f><v:f eqn="prod @3 21600 pixelHeight"></v:f><v:f eqn="sum @0 0 1"></v:f><v:f eqn="prod @6 1 2"></v:f><v:f eqn="prod @7 21600 pixelWidth"></v:f><v:f eqn="sum @8 21600 0"></v:f><v:f eqn="prod @7 21600 pixelHeight"></v:f><v:f eqn="sum @10 21600 0"></v:f></v:formulas><v:path o:extrusionok="f" gradientshapeok="t" o:connecttype="rect"></v:path><o:lock v:ext="edit" aspectratio="t"></o:lock></v:shapetype><v:shape o:spid="_x0000_i1025" type="#_x0000_t75" alt="Descripción: ;)" id="Imagen_x0020_1" style="width: 11.25pt; height: 11.25pt; visibility: visible; mso-wrap-style: square;"><v:imagedata src="file:///C:\Users\HECTOR\AppData\Local\Temp\msohtmlclip1\01\clip_image001.gif" o:title=";)"></v:imagedata></v:shape><o:p></o:p>

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

hectorperez — Thu, 02 Sep 2010 03:01:11 GMT

Revisión 2 enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 5:01:11 AM

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

Archivado en: C#

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

<o:p></o:p>

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:<o:p></o:p>

<o:p></o:p>

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:

<o:p></o:p>

Si ahora nos dirigimos a las propiedades en Visual Studio de cada una de las conexiones, veremos diferentes cadenas de conexión:<o:p></o:p>ón:
De la conexión por Autentificación Windows:<o:p></o:p>

De la conexión por Autentificación SQL Server:

<o:p></o:p>

<o:p>

1: using System.Data.SqlClient;

<o:p></o:p>

1: string miCadenaConexion= @"Data Source=.\SQLEXPRESS;<o:p></o:p>

2: Initial Catalog=BalloonShop;<o:p></o:p>

3: Integrated Security=true";<o:p></o:p>

donde:<o:p></o:p>

Data Source = El Servidor de Base de datos;<o:p></o:p>

Initial Catalog = Tu Base de Datos a la que te conectarás;<o:p></o:p>

Integrated Security = Significa que la seguridad de Windows será usada en vez de un Login de SQL.<o:p></o:p>

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

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:<o:p></o:p>

</o:p>

1: SqlConnection sqlconnection = new SqlConnection

(miCadenaConexion);<o:p></o:p>

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:<o:p></o:p>

1: try<o:p></o:p>

2: {<o:p></o:p>

3: sqlconnection.Open();<o:p></o:p>

<o:p></o:p>

4: Console.WriteLine<o:p> </o:p>

("Conexión Abierta Satisfactoriamente!");<o:p></o:p>

5: }<o:p></o:p>

6: catch (Exception ex)<o:p></o:p>

7: {<o:p></o:p>

<o:p></o:p>

8: Console.WriteLine<o:p> </o:p>

("Falló al tratarse de conectar a Base de Datos!");<o:p></o:p>

9: }<o:p></o:p>

10: finally<o:p></o:p>

11: {<o:p></o:p>

12: sqlconnection.Close();<o:p></o:p>

13: Console.ReadLine();<o:p></o:p>

14: }<o:p></o:p>

Con lo que el código final queda así:<o:p></o:p>

1: using System;<o:p></o:p>

2: using System.Data.SqlClient;<o:p></o:p>

3: <o:p></o:p>

4: namespace Cadenas_conexion_1<o:p></o:p>

5: {<o:p></o:p>

6: class Program<o:p></o:p>

7: {<o:p></o:p>

8: static void Main(string[] args)<o:p></o:p>

9: {<o:p></o:p>

<o:p></o:p>

10: string miCadenaConexion = <o:p></o:p>

<o:p></o:p>

@"Data Source=.\SQLEXPRESS;<o:p></o:p>

<o:p></o:p>

Initial Catalog=BalloonShop;<o:p></o:p>

<o:p> </o:p> Integrated Security=true";<o:p></o:p>

<o:p></o:p>

11: SqlConnection sqlconnection = new SqlConnection<o:p> </o:p>

(miCadenaConexion);<o:p></o:p>

12: try<o:p></o:p>

13: {<o:p></o:p>

14: sqlconnection.Open();<o:p></o:p>

<o:p></o:p>

15: Console.WriteLine<o:p> </o:p>

("Conexión Abierta Satisfactoriamente!");<o:p></o:p>

16: }<o:p></o:p>

17: catch (Exception ex)<o:p></o:p>

18: {<o:p></o:p>

<o:p></o:p>

19: Console.WriteLine<o:p> </o:p>

("Falló al tratarse de conectar a Base de Datos!");<o:p></o:p>

20: }<o:p></o:p>

21: finally<o:p></o:p>

22: {<o:p></o:p>

23: sqlconnection.Close();<o:p></o:p>

24: Console.ReadLine();<o:p></o:p>

25: }<o:p></o:p>

26: }<o:p></o:p>

27: }<o:p></o:p>

28: }<o:p></o:p>

Probamos el código y obtenemos lo siguiente:<o:p></o:p>

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:<o:p></o:p>

1: string miCadenaConexion = @"Data Source=.\SQLEXPRESS;<o:p></o:p>

2: Initial Catalog=BalloonShop;<o:p></o:p>

3: User=balloonshop;<o:p></o:p>

4: password=contraseña";<o:p></o:p>

Y listo!

<o:p></o:p>

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

hectorperez — Thu, 02 Sep 2010 02:57:51 GMT

Revisión 1 enviado a Wiki sobre Arquitectura del software en Geeks•ms por hectorperez a 9/2/2010 4:57:51 AM

En primer lugar, para esta demo, he creado un proyecto nuevo en Visual Studio, del tipo consola.<o:p></o:p>

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:<o:p></o:p>

<o:p></o:p>

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:

<o:p></o:p>

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

De la conexión por Autentificación Windows:<o:p></o:p>

De la conexión por Autentificación SQL Server:

<o:p></o:p>

<o:p>

1: using System.Data.SqlClient;

<o:p></o:p>

1: string miCadenaConexion= @"Data Source=.\SQLEXPRESS;<o:p></o:p>

2: Initial Catalog=BalloonShop;<o:p></o:p>

3: Integrated Security=true";<o:p></o:p>

donde:<o:p></o:p>

Data Source = El Servidor de Base de datos;<o:p></o:p>

Initial Catalog = Tu Base de Datos a la que te conectarás;<o:p></o:p>

Integrated Security = Significa que la seguridad de Windows será usada en vez de un Login de SQL.<o:p></o:p>

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

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:<o:p></o:p>

</o:p>

1: SqlConnection sqlconnection = new SqlConnection

(miCadenaConexion);<o:p></o:p>

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:<o:p></o:p>

1: try<o:p></o:p>

2: {<o:p></o:p>

3: sqlconnection.Open();<o:p></o:p>

<o:p></o:p>

4: Console.WriteLine<o:p> </o:p>

("Conexión Abierta Satisfactoriamente!");<o:p></o:p>

5: }<o:p></o:p>

6: catch (Exception ex)<o:p></o:p>

7: {<o:p></o:p>

<o:p></o:p>

8: Console.WriteLine<o:p> </o:p>

("Falló al tratarse de conectar a Base de Datos!");<o:p></o:p>

9: }<o:p></o:p>

10: finally<o:p></o:p>

11: {<o:p></o:p>

12: sqlconnection.Close();<o:p></o:p>

13: Console.ReadLine();<o:p></o:p>

14: }<o:p></o:p>

Con lo que el código final queda así:<o:p></o:p>

1: using System;<o:p></o:p>

2: using System.Data.SqlClient;<o:p></o:p>

3: <o:p></o:p>

4: namespace Cadenas_conexion_1<o:p></o:p>

5: {<o:p></o:p>

6: class Program<o:p></o:p>

7: {<o:p></o:p>

8: static void Main(string[] args)<o:p></o:p>

9: {<o:p></o:p>

<o:p></o:p>

10: string miCadenaConexion = <o:p></o:p>

<o:p></o:p>

@"Data Source=.\SQLEXPRESS;<o:p></o:p>

<o:p></o:p>

Initial Catalog=BalloonShop;<o:p></o:p>

<o:p> </o:p> Integrated Security=true";<o:p></o:p>

<o:p></o:p>

11: SqlConnection sqlconnection = new SqlConnection<o:p> </o:p>

(miCadenaConexion);<o:p></o:p>

12: try<o:p></o:p>

13: {<o:p></o:p>

14: sqlconnection.Open();<o:p></o:p>

<o:p></o:p>

15: Console.WriteLine<o:p> </o:p>

("Conexión Abierta Satisfactoriamente!");<o:p></o:p>

16: }<o:p></o:p>

17: catch (Exception ex)<o:p></o:p>

18: {<o:p></o:p>

<o:p></o:p>

19: Console.WriteLine<o:p> </o:p>

("Falló al tratarse de conectar a Base de Datos!");<o:p></o:p>

20: }<o:p></o:p>

21: finally<o:p></o:p>

22: {<o:p></o:p>

23: sqlconnection.Close();<o:p></o:p>

24: Console.ReadLine();<o:p></o:p>

25: }<o:p></o:p>

26: }<o:p></o:p>

27: }<o:p></o:p>

28: }<o:p></o:p>

Probamos el código y obtenemos lo siguiente:<o:p></o:p>

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:<o:p></o:p>

1: string miCadenaConexion = @"Data Source=.\SQLEXPRESS;<o:p></o:p>

2: Initial Catalog=BalloonShop;<o:p></o:p>

3: User=balloonshop;<o:p></o:p>

4: password=contraseña";<o:p></o:p>

Y listo!

<o:p></o:p>