V1 Contenidos Unidad 1 Semana 6

TALLER DE PROGRAMACIÓN.
NET
PROGRAMACIÓN EN .NET
ESCUELA DE CONSTRUCCIÓN E INGENIERÍA
Director de Escuela / Marcelo Lucero
ELABORACIÓN
Experto disciplinar / Cristián Molina
Diseñador instruccional / Evelyn Aguilera
VALIDACIÓN PEDAGÓGICA
Jefa de diseño instruccional y multimedia / Alejandra San Juan Reyes
Experto disciplinar / Carlos Garcés
DISEÑO DOCUMENTO
Didactic
Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 2

Contenido
APRENDIZAJE ESPERADO DE LA SEMANA: ...................................................................... 4
1. IDENTIFICA CONECTORES .NET ADECUADOS PARA MANEJO DE BASE
DE DATOS EN VISUAL STUDIO, PARA LA CONSTRUCCIÓN DE
SOFTWARE............................................................................................................... 4
1.1. SQLCONNECTION: CONEXIÓN CON EL SQL SERVER ....................................... 4
1.1.1. PROBLEMA ............................................................................................................... 4
1.2. DISEÑO BASE DATOS RELACIONAL DE ACUERDO A MODELO ENTIDAD
RELACIÓN................................................................................................................. 9
1.3. SQLCOMMAND (INSERT): INSERTAR REGISTRO ............................................. 15
1.4. SQLCOMMAND (SELECT): LISTAR REGISTROS ............................................... 15
1.5. SQLCOMMAND (SELECT): CONSULTAR REGISTROS ...................................... 16
1.6. SQLCOMMAND (DELETE): BORRAR REGISTRO ............................................... 16
1.7. SQLCOMMAND (UPDATE): MODIFICAR REGISTRO.......................................... 16
1.8. SQLCOMMAND : PASANDO PARÁMETROS ....................................................... 16
EJEMPLIFICACIÓN ............................................................................................................... 16
1.9. PROCEDIMIENTO PARA CONTROLAR ERRORES Y EXCEPCIONES QUE
SE PRODUCEN CON EL ENLACE DE DATOS .................................................... 17
1.10. GUARDA LA INFORMACIÓN DE LA EXCEPCIÓN EN UN LOG .......................... 23
1.11. GUARDA EN EL LOG EXCEPTION.TOSTRING() EN LUGAR
EXCEPTION.MESSAGEERROR ............................................................................ 24
1.12. COLOCAR UN ÚNICO TRY – CATCH EN EL NIVEL SUPERIOR DE CADA
HILO (THREAD) ...................................................................................................... 24
1.13. APLICACIONES DE CLIENTE (UI) UTILIZAR CAPTURADORES DE
ERRORES GLOBALES........................................................................................... 24
1.14. SI TRABAJAS CON LIBRERÍAS DE TERCEROS CAPTURA LAS
EXCEPCIONES EN EL NIVEL MÁS BAJO ............................................................ 26

APRENDIZAJE ESPERADO DE LA SEMANA:
• Construyen software en base a requerimientos de usuarios utilizando bases de
datos y comprobando excepciones de sistema y de base de datos.
1. IDENTIFICA CONECTORES .NET ADECUADOS PARA

MANEJO DE BASE DE DATOS EN VISUAL STUDIO,
PARA LA CONSTRUCCIÓN DE SOFTWARE
Una de las partes más importantes, es la de conectar a una base de datos. En esta semana
y que será de utilidad para los principiantes, ayudaremos a entender los diferentes pasos
para conectarnos a una base de datos, ya que existen muchas maneras de conectarse a
bases de datos con C#, pero aquí revisaremos la manera más simple.
1.1. SQLCONNECTION: CONEXIÓN CON EL SQL SERVER

Desde .Net disponemos de un conjunto de clases para conectarnos y pedir al SQL Server
que ejecute comandos.
El primer paso es conectarnos con nuestro servidor de base de datos que instalamos en los
conceptos anteriores y vimos cómo podemos comunicarnos utilizando el Microsoft SQL
Server Management Studio.
1.1.1. PROBLEMA
Confeccionar una aplicación que permita conectarnos con nuestro servidor de base de
datos y seleccionar una determinada base de datos. Luego de la conexión cerrar la misma.
a).- Para conectarnos con el servidor y seleccionar una base de datos debemos utilizar la
clase SqlConnection:
SqlConnection conexion=new SqlConnection("server=DIEGO-PC ; database=base1 ;
integrated security = true");
El string que le pasamos al constructor del SqlConnection le indicamos como primer dato el
nombre de nuestro servidor, en su máquina lo puede ubicar cuando arranca el SQL Server
Management Studio:

Figura 1: SQL Server
Fuente: https://www.tutorialesprogramacionya.com/csharpya/imagentema/foto169.jpg
Algo importante si su nombre incluye la barra "\" luego disponga dos seguidas ya que C#
esta barra es un caracter de control y por lo tanto para disponer una debemos disponer "\\".
El segundo dato que se le pasa es el nombre de la base de datos con la que nos
comunicaremos, en nuestro caso creamos previamente la base de datos "base1" y
finalmente el último dato obligatorio es indicar "integrated security = true", esto hace que se
utilice el usuario propio de Windows y no necesitemos por el momento crear otros usuarios
propios de SQL Server.
b).- Creemos un nuevo proyecto en Visual Studio y demos como nombre: BaseDatos1.
La interfaz visual es un simple botón:
Figura 2: Interfaz visual


c).- El código fuente es:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Data.SqlClient;
namespace PruebaBaseDatos1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)

{
SqlConnection conexion = new SqlConnection("server=DIEGO-PC ;
database=base1 ; integrated security = true");
conexion.Open();
MessageBox.Show("Se abrió la conexión con el servidor SQL Server y se
seleccionó la base de datos");
conexion.Close();
MessageBox.Show("Se cerró la conexión.");

}
}
}
d).- Lo primero que hacemos es incluir el espacio de nombres:
using System.Data.SqlClient;
Este espacio de nombres define la clase SqlConnection.
Para el evento Click del button1 implementamos primero la creación de un objeto de tipo
SqlConnection:
SqlConnection conexion = new SqlConnection("server=DIEGO-PC ;
database=base1 ; integrated security = true");
e).- Abrimos la conexión:
conexion.Open();
f).- Mostramos un mensaje que la conexión se abrió:
MessageBox.Show("Se abrió la conexión con el servidor SQL Server y se
seleccionó la base de datos");
g).- Cerramos la conexión:
conexion.Close();
h).- Mostramos finalmente un mensaje del cierre de la conexión:
MessageBox.Show("Se cerró la conexión.");
Si aparece algún error es que especificó en forma incorrecta la cadena de conexión, por
ejemplo si disponemos un nombre equivocado de servidor por ejemplo:
SqlConnection conexion = new SqlConnection("server= --------- ; database=base1 ;
integrated security = true");
i).- Luego debe detenerse nuestro programa indicando donde ocurrió el error:

Figura 3: Error
También ocurrirá un error si disponemos un nombre de base de datos inexistente:
Figura 4: Error ejemplo

j).- Si todo está correcto podemos seguir con los próximos conceptos para pedir que SQL
Server ejecute comando y recuperar los resultados.
Fuente:https://www.tutorialesprogramacionya.com/csharpya/detalleconcepto.php?codigo=199&inicio=60

1.2. DISEÑO BASE DATOS RELACIONAL DE ACUERDO A
MODELO ENTIDAD RELACIÓN
a).- Desde el menú de inicio de Windows podemos acceder al SQL Server Management
Studio:
Figura 5: Menú
b).- Cuando iniciamos el programa aparece un diálogo donde debemos ingresar "Nombre
del Servidor" y la "Autenticación":
Figura 6: Inicio programa

c).- Ya luego de la conexión al servidor podemos, por ejemplo, proceder a crear nuestra
primer base de datos, presionamos el botón derecho del mouse estando posicionado en
"Base de datos" y elegimos "Nueva base de datos...":

Figura 7: Creación base de datos
d).- Elegiremos como nombre para la base de datos a crear: "base1":
Figura 8: Nombre base de datos


e).- Ahora seleccionamos la "base1" y presionamos el botón derecho del mouse sobre
"tablas" y elegimos la primer opción "tabla":
Figura 9: Tabla base de datos

f).- Vamos a crear una tabla llamada "articulos" que la definiremos con tres campos:
codigo int primary key identidad
descripcion varchar 50
precio float
El primer campo lo creamos (debemos presionar el botón derecho del mouse sobre el
campo para definirlo como clave primaria):

Figura 10: Definición de campos base de datos
Los tres campos que definimos son:
Figura 11: Definición de campos base de datos realizado

Y presionando el ícono siguiente definimos el nombre de la tabla:

Figura 12: Definición nombre tabla
Asignamos como nombre a la tabla "artículos":
Figura 13: Definición nombre tabla artículos

Para ejecutar comando SQL sobre una determinada base de datos procedemos a
posicionar la flecha del mouse sobre una base de datos, por ejemplo “base1” y
presionamos el botón derecho del mouse seleccionando “Nueva consulta”:

Figura 14: Nueva consulta
En la ventana de consultas podemos escribir y ejecutar comandos SQL:
Figura 15: Comandos SQL

Si escribimos luego del comando insert un select podemos ver el registro añadido:
Figura 16: Registro añadido

1.3. SQLCOMMAND (INSERT): INSERTAR REGISTRO

Vimos en el concepto anterior como conectarnos al servidor de SQL Server y seleccionar
una base de datos. Veremos ahora como pedir que el SQL Server ejecute un comando
"INSERT".
Trabajaremos con la base de datos "base1" que creamos en conceptos anteriores y con la
tabla "articulos" que también creamos previamente con la estructura:
codigo int primary key identidad
descripcion varchar 50
precio float
1.4. SQLCOMMAND (SELECT): LISTAR REGISTROS

Vimos el concepto anterior como enviar datos al servidor para que se efectúe un insert en
una tabla.
Veremos ahora como recuperar los datos almacenados en una tabla para mostrarlos en
pantalla.

1.5. SQLCOMMAND (SELECT): CONSULTAR REGISTROS
En el concepto anterior recuperamos todos los registros de una tabla. Ahora veremos cómo
podemos rescatar uno en particular.
1.6. SQLCOMMAND (DELETE): BORRAR REGISTRO

Otra de las actividades comunes con los datos es la eliminación. Para eliminar registros de
una tabla debemos emplear el comando SQL delete.
1.7. SQLCOMMAND (UPDATE): MODIFICAR REGISTRO

Vimos hasta ahora el alta (carga), consulta (búsqueda) y baja (borrado). Ahora veremos
cómo modificar datos de una fila de la tabla.
Para modificar datos debemos utilizar el comando SQL update.
1.8. SQLCOMMAND : PASANDO PARÁMETROS

Hemos visto que podemos formar un comando SQL para enviarlo a SQL Server generando
un string concatenando los datos que ingresa el operador por teclado:
string cadena = "insert into articulos(descripcion,precio) values ('" + descri + "'," + precio +
")";
Esta metodología tiene el inconveniente cuando hay que elaborar comandos SQL con
muchos campos (imaginemos que tenemos que elaborar un insert con una tabla que tiene
más de 10 campos)
Para solventar esta dificultad se introduce el concepto de parámetros dentro del comando
SQL.
EJEMPLIFICACIÓN
Para complementar los temas vistos, les invitamos a revisar los documentos llamados:
- Insertar
- Listar registro
- Consultar registro
- Eliminar registro
- Modificar registro
Pueden acceder a través del menú Recursos complementarios de la unidad 1, Material
complementario.

1.9. PROCEDIMIENTO PARA CONTROLAR ERRORES Y
EXCEPCIONES QUE SE PRODUCEN CON EL ENLACE DE
DATOS
La librería o API de Java proporciona gran cantidad de clases que manejan casi cualquier
tipo de excepción, pero no estamos obligados a utilizar solo esas clases sino que podemos
crear nuestras propias excepciones.
Si queremos crear una excepción no verificada debemos heredar de RuntimeException y si
queremos que sea verificada deberemos heredar de Exception o de alguna de sus
subclases.
A menudo, las excepciones y los errores se producen en los objetos comerciales
subyacentes cuando se enlazan a controles. Puede interceptar estos errores y excepciones
y, después, recuperar o pasar la información de error al usuario controlando el evento
BindingComplete para un componente Binding, BindingSource o CurrencyManager
determinado.
a).- Ejemplo
En este ejemplo de código se muestra cómo controlar errores y excepciones que se
producen durante una operación de enlace de datos. Muestra cómo interceptar los errores
controlando el evento Binding.BindingComplete de los objetos Binding. Para interceptar
errores y excepciones controlando este evento, debe habilitar el formato del enlace. Puede
habilitar el formato al crear el enlace o al agregarlo a la colección de enlaces, o
estableciendo la propiedad FormattingEnabled en true.
C#
Copiar
using System;
using System.Drawing;
using System.Windows.Forms;
class Form1 : Form

{
private BindingSource BindingSource1 = new BindingSource();
private TextBox textBox1 = new TextBox();
public Form1()
{

//Set up the textbox controls.
this.textBox1.Location = new System.Drawing.Point(82, 13);
this.textBox1.TabIndex = 1;
// Add the textbox controls to the form

this.Controls.Add(this.textBox2);
// Handle the form's Load event.

this.Load += new System.EventHandler(this.Form1_Load);
}
Binding partNameBinding;
Binding partNumberBinding;
private void Form1_Load(object sender, EventArgs e)

{
// Set the DataSource of BindingSource1 to the Part type.
BindingSource1.DataSource = typeof(Part);
// Bind the textboxes to the properties of the Part type,

// enabling formatting.
partNameBinding = textBox1.DataBindings.Add("Text",
BindingSource1, "PartName", true);

partNumberBinding = textBox2.DataBindings.Add("Text", BindingSource1,
"PartNumber",
true);
//Bind the textbox to the PartPrice value with currency formatting.

textBox3.DataBindings.Add("Text", BindingSource1, "PartPrice", true,
DataSourceUpdateMode.OnPropertyChanged, 0, "C");
// Handle the BindingComplete event for BindingSource1 and

// the partNameBinding.
partNumberBinding.BindingComplete +=
new BindingCompleteEventHandler(partNumberBinding_BindingComplete);
partNameBinding.BindingComplete +=
new BindingCompleteEventHandler(partNameBinding_BindingComplete);
// Add a new part to BindingSource1.

BindingSource1.Add(new Part("Widget", 1234, 12.45));
}
// Handle the BindingComplete event to catch errors and exceptions

// in binding process.
void partNumberBinding_BindingComplete(object sender,
BindingCompleteEventArgs e)
{
if (e.BindingCompleteState != BindingCompleteState.Success)
MessageBox.Show("partNumberBinding: " + e.ErrorText);
}
// Handle the BindingComplete event to catch errors and

// exceptions in binding process.

void partNameBinding_BindingComplete(object sender,
BindingCompleteEventArgs e)
{
if (e.BindingCompleteState != BindingCompleteState.Success)
MessageBox.Show("partNameBinding: " + e.ErrorText);
}
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.Run(new Form1());
}
}
// Represents a business object that throws exceptions when invalid values are
// entered for some of its properties.
public class Part
{
private string name;
private int number;
private double price;
public Part(string name, int number, double price)

{
PartName = name;
PartNumber = number;
PartPrice = price;
}
public string PartName

{

get { return name; }
set
{
if (value.Length <= 0)
throw new Exception("Each part must have a name.");
else
name = value;
}
}
public double PartPrice
{
get { return price; }
set { price = value; }
}
public int PartNumber
{
get { return number; }
set
{
if (value < 100)
throw new Exception("Invalid part number." +
" Part numbers must be greater than 100.");
else
number = value;
}
}
}
Cuando se ejecuta el código y se especifica una cadena vacía como nombre de elemento o
un valor inferior a 100 como número de elemento, aparece un cuadro de mensaje. Este es
el resultado de controlar el evento Binding.BindingComplete para estos enlaces de cuadro
de texto.

Fuente: https://www.tutorialesprogramacionya.com/csharpya
b).- Compilar el código

Puede automatizar los scripts de compilación o cualquier otra operación externa en los
archivos que tiene en el área de trabajo actual al ejecutarlos directamente en el IDE. Para
configurar una tarea nueva, haga clic con el botón derecho en un archivo o una carpeta y
seleccione Configurar tareas.
Figura 17: Compilar código

Fuente: https://docs.microsoft.com/es-es/visualstudio/ide/media/customize-configure-tasks-
menu.png?view=vs-2019
De este modo, se crea (o abre) el archivo tasks.vs.json en la carpeta .vs. En este archivo,
puede definir una tarea de compilación o una tarea arbitraria y, después, invocarla con el
nombre que le asignó en el menú contextual del Explorador de soluciones.
Fuente: https://docs.microsoft.com/es-es/visualstudio/ide/customize-build-and-debug-tasks-in-visual-
studio?view=vs-2019

1.10. GUARDA LA INFORMACIÓN DE LA EXCEPCIÓN EN UN
LOG
Las excepciones ocurren cuando no lo esperamos, por eso cuando suceden es importante
capturar toda la información posible y guardarla en un Log (fichero texto, base datos etc.)
En general con tres de las propiedades de la excepción suele haber suficiente información
como para saber la causa del error y poder corregirlo.
MessageError: proporciona una explicación de lo que ha ocurrido.
InnerException: proporciona información sobre la excepción interna.
StackTrace: proporciona información de la pila de llamadas antes de la excepción.
La más desconocida de estas propiedades es StackTrace.
StackTrace permite saber la clase, el método e incluso la línea de código donde se produce
la excepción. Y no sólo eso, sino que además muestra los métodos anteriores por los que
ha pasado el flujo del programa antes de producirse la excepción. Si no guardas esta
información es muy probable que no puedas averiguar la causa del error.
Así pues, con esta información se podría escribir un código como este:
try {
MetodoQueProvocaUnaExcepcion();
}
catch (Exception ex)
{
// Qué ha sucedido
var mensaje = "Error message: " + ex.Message;
// Información sobre la excepción interna

if (ex.InnerException != null)
{
mensaje = mensaje + " Inner exception: " + ex.InnerException.Message;
}
// Dónde ha sucedido
mensaje = mensaje + " Stack trace: " + ex.StackTrace;
Log(mensaje);
}

1.11. GUARDA EN EL LOG EXCEPTION.TOSTRING() EN
LUGAR EXCEPTION.MESSAGEERROR
Sin embargo, el método ToString() de la excepción ya proporciona toda esta información y
el código anterior se puede reducir de la siguiente manera:
try
{
MetodoQueProvocaUnaExcepcion();
}
catch (Exception ex)
{
Log(ex.ToString());
}
MINIMIZA EL NÚMERO DE TRY - CATCH
La primera intuición para protegernos contra las excepciones es colocar un try – catch en
cada método, pero esto tiene dos claras desventajas:
El código sería verboso. Cada bloque try – catch se convierte en una interferencia para
comprender la intención del código que contiene. Es algo parecido a la publicidad de una
web, te acostumbras a ignorarla, pero está ahí, y si desapareciese sentirías un gran alivio
Rompe con el principio DRY (Don’t Repeat Yourself). Básicamente porque estarías
repitiendo el mismo try – catch múltiples veces. Cualquier cambio en la manera de procesar
la excepción en el catch se podría convertir en un verdadero tormento.
Se puede lograr exactamente lo mismo colocando un único try – catch en el nivel más alto
del código.
1.12. COLOCAR UN ÚNICO TRY – CATCH EN EL NIVEL

SUPERIOR DE CADA HILO (THREAD)
Cuando ocurre una excepción en cualquier punto de la aplicación (o hilo) esta se irá
propagando hacia los métodos de las capas superiores hasta llegar al nivel más alto. Por
eso no es necesario capturar la excepción en el método exacto que la produce. Si dejamos
que se propague y la capturamos en un nivel superior, la propiedad StackTrace ya nos
indicará la información sobre el lugar exacto donde se produjo el error.
1.13. APLICACIONES DE CLIENTE (UI) UTILIZAR

CAPTURADORES DE ERRORES GLOBALES.
Cuando ocurre un error inesperado en aplicaciones de cliente, si colocamos el try - catch en
el nivel superior, por ejemplo en el “main”, el programa terminará después de la excepción.
Este comportamiento no es deseable sobre todo porque genera frustración en los usuarios.

En estos casos lo mejor es mostrar un mensaje de error genérico y continuar donde se
encontraba el usuario.
Según el tipo de aplicación que desarrolles existen diferentes técnicas para capturar los
errores inesperados globlamente:
Winforms
Application.ThreadException: captura todas las excepciones del hilo principal
(Main).
AppDomain.CurrentDomain.UnhandledException: captura las excepciones
provocadas por hilos diferentes al principal.
WPF
Application.Current.DispatcherUnhandledException: captura las excepciones del hilo
principal.
Dispatcher.UnhandledException: captura las excepciones provocadas por hilos
diferentes al principal.
AppDomain.CurrentDomain.UnhandledException: captura las excepciones de todos
los hilos de AppDomain.
TaskScheduler.UnobservedTaskException: captura las excepciones de los hilos de
AppDomain que utiliza un planificador de tareas en operaciones asíncronas.
Asp.Net clásico
System.Web.Http.ExceptionHandling.IExceptionLogger: captura cualquier excepción
en la aplicación y permite guardarla en un log.
System.Web.Http.ExceptionHandling.IExceptionHandler: último nivel de captura de
excepciones.
Application_Error (en global.asax): captura cualquier error dentro del hilo que
procesa la petición (Request).
Asp.Net Core
Configurar un HandlerExceptionMiddleware.
Utilizando cualquiera de estas técnicas lograrás centralizar la captura de excepciones en un
sólo lugar y conseguirás el mismo efecto que si tuvieras un try - catch en cada uno de los
métodos.
Las tecnologías van cambiando, pero el concepto es el mismo. Busca la manera de
capturar las excepciones de un modo global.

1.14. SI TRABAJAS CON LIBRERÍAS DE TERCEROS CAPTURA
LAS EXCEPCIONES EN EL NIVEL MÁS BAJO
Justo al contrario del punto anterior :). Al trabajar con librerías externas a nuestro código,
éstas pueden devolver excepciones. Es perfectamente lícito que las librerías externas
lancen excepciones porque no conocen el contexto, pero ese contexto en nuestro código
puede tener sentido, con lo que podríamos capturar la excepción y procesarla
adecuadamente.
Por ejemplo, si queremos escribir en un fichero de texto pero el fichero es de sólo lectura,
podríamos capturar la excepción UnauthorizedAccessException con el objetivo de mostrar
un mensaje al usuario indicando que el fichero no admite la escritura. Con esa información
el usuario puede actuar en consecuencia para conseguir su objetivo.
Esta clase de excepciones deben capturarse en el nivel más bajo:
public void CrearUnaLineaEnFichero(string rutaFichero, string textoLinea)
{
Fichero fichero = new Fichero(rutaFichero);
bool resultado = EscribirLinea(fichero, textoLiena);
if (!resultado)
{
MostrarPorPantalla(“El fichero es de sólo lectura. Selecciona otro fichero”);
}
}
private bool EscribirLinea(Fichero fichero, string textoLinea)
{
try
{
using (StreamWriter sw = new StreamWriter(fichero.Ruta))
{
file.AppendText(textoLinea);
}
}
catch (UnauthorizedAccessException)

{
return false;
}
}
El método únicamente devolverá falso si el fichero es de sólo lectura. Cualquier otra
excepción no será capturada dentro del método.
Solo debemos capturar las excepciones que sepamos cómo procesar. En caso de que la
librería lance una excepción no conocida lo mejor es dejar que se propague a las capas
superiores y que sea capturada por el try – catch global.
Conclusiones:
1. Guarda toda la info de las excepciones en un log.
2. Exception.ToString() suele ser suficiente para guardar toda la info necesaria.
3. Cuantos menos try – catch tenga la aplicación más mantenible será.
4. Coloca un try –catch en el nivel superior de cada hilo.
5. En aplicaciones cliente busca la manera de capturar las excepciones no controladas
de una manera global.
6. Para excepciones que sepas procesar de librerías externas coloca el try – catch en la
capa más interna.

V1 Contenidos Unidad 1 Semana 6

Caricato da

Informazioni sul documento

Descrizione originale:

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

V1 Contenidos Unidad 1 Semana 6

Caricato da

Copyright:

Formati disponibili

TALLER DE PROGRAMACIÓN.

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 2

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 3

1. IDENTIFICA CONECTORES .NET ADECUADOS PARA

1.1. SQLCONNECTION: CONEXIÓN CON EL SQL SERVER

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 4

Figura 2: Interfaz visual

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 5

private void button1_Click(object sender, EventArgs e)

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 6

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 7

También ocurrirá un error si disponemos un nombre de base de datos inexistente:

Figura 4: Error ejemplo

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 8

Figura 6: Inicio programa

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 9

d).- Elegiremos como nombre para la base de datos a crear: "base1":

Figura 8: Nombre base de datos

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 10

Figura 9: Tabla base de datos

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 11

Los tres campos que definimos son:

Figura 11: Definición de campos base de datos realizado

Y presionando el ícono siguiente definimos el nombre de la tabla:

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 12

Asignamos como nombre a la tabla "artículos":

Figura 13: Definición nombre tabla artículos

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 13

En la ventana de consultas podemos escribir y ejecutar comandos SQL:

Figura 15: Comandos SQL

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 14

Figura 16: Registro añadido

1.3. SQLCOMMAND (INSERT): INSERTAR REGISTRO

1.4. SQLCOMMAND (SELECT): LISTAR REGISTROS

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 15

1.6. SQLCOMMAND (DELETE): BORRAR REGISTRO

1.7. SQLCOMMAND (UPDATE): MODIFICAR REGISTRO

1.8. SQLCOMMAND : PASANDO PARÁMETROS

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 16

class Form1 : Form

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 17

// Add the textbox controls to the form

// Handle the form's Load event.

private void Form1_Load(object sender, EventArgs e)

// Bind the textboxes to the properties of the Part type,

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 18

//Bind the textbox to the PartPrice value with currency formatting.

// Handle the BindingComplete event for BindingSource1 and

// Add a new part to BindingSource1.

// Handle the BindingComplete event to catch errors and exceptions

// Handle the BindingComplete event to catch errors and

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 19

public Part(string name, int number, double price)

public string PartName

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 20

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 21

b).- Compilar el código

Figura 17: Compilar código

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 22

// Información sobre la excepción interna

Taller de Bases de datos / Diseño e implementación de Bases de Datos en SQL 23

1.12. COLOCAR UN ÚNICO TRY – CATCH EN EL NIVEL

1.13. APLICACIONES DE CLIENTE (UI) UTILIZAR