Para guardar información en una base de datos en lugar de un archivo, puedes utilizar la

clase SqlConnection de C#. La clase SqlConnection representa una conexión abierta a una
base de datos SQL Server 1. Aquí hay un ejemplo de cómo guardar información en una base de datos
utilizando SqlConnection :

C#

using System;
using System.Data.SqlClient;

class Program
{
static void Main(string[] args)
{
string connectionString = @"Data Source=ServerName;Initial
Catalog=DatabaseName;User ID=UserName;Password=Password";
string queryString = "INSERT INTO TableName (ColumnName1, ColumnName2) VALUES
(@Value1, @Value2)";

using (SqlConnection connection = new SqlConnection(connectionString))

{
SqlCommand command = new SqlCommand(queryString, connection);
command.Parameters.AddWithValue("@Value1", "Value1");
command.Parameters.AddWithValue("@Value2", "Value2");

connection.Open();
command.ExecuteNonQuery();
}
}
}

Código generado por IA. Revisar y usar cuidadosamente. Más información sobre preguntas frecuentes.

En este ejemplo, connectionString es una cadena de conexión que especifica la ubicación de

la base de datos y las credenciales de inicio de sesión 1 queryString es una cadena que contiene
una instrucción Transact-SQL para insertar datos en una tabla 1 SqlCommand representa una
instrucción Transact-SQL o un procedimiento almacenado que se ejecuta en una base de datos SQL
Server 1 command.Parameters.AddWithValue agrega un parámetro y su valor a la
colección de parámetros de SqlCommand 1 connection.Open() abre la conexión a la base
de datos 1 command.ExecuteNonQuery() ejecuta la instrucción Transact-SQL y devuelve el
número de filas afectadas
 Aplicar interfaces en C# para vincular con base
de datos
Formular una pregunta
Formulada hace 5 años y 11 meses
Modificada hace 2 años y 5 meses
Vista 693 veces

Tengo este gran problema y es que además de que soy nuevo en esto de programar, me cuesta bastante.
El tema es el siguiente, necesito aplicar MVP a un pequeño programa de escritorio que estoy
desarrollando y para ello necesito desvincular total mente la capa de vista con la creación de objetos.
Por ejemplo, en el codigo siguiente tengo la creacion de la db y tengo que realizar una igualdad, cómo
lo hago aplicando interfaces? Muchas gracias!
private void btnGuardar_Click(object sender, EventArgs e)
{
using (DataContext db = new DataContext())
{
Paciente obj = pacienteBindingSource.Current as Paciente;
if (obj != null)
{
if
(db.Entry<Paciente>(obj).State==System.Data.Entity.EntityState.Detached)
{
db.Set<Paciente>().Attach(obj);
}
if (obj.PacienteID == 0)
{
db.Entry<Paciente>(obj).State =
System.Data.Entity.EntityState.Added;
}
else
db.Entry<Paciente>(obj).State =
System.Data.Entity.EntityState.Modified;

db.SaveChanges();
gridPacientes.Refresh();
pControls.Enabled = false;
}
}
}

 c#
 sql
 interface
 mvp

Compartir
 Mejora esta pregunta
Seguir
formulada el 10 feb. 2018 a las 21:08

ginona
1
 Mirate este tutorial por si te es de ayuda hacerca de MVP
– Miguel Angel Utiel Peñaranda
el 12 feb. 2018 a las 11:53
 antes de iniciar con patron MVP Implementa desarrollo a n-
capas ves-sandola.blogspot.com/2013/07/…
– ger
el 25 feb. 2020 a las 21:04
Añade un comentario

1 respuesta
Ordenado por:
Mayor puntuación (por defecto)
Fecha de modificación (lo más nuevo primero) Fecha de
creación (lo más antiguo primero)
0

El modelo vista controlador, te permite reutilizar código, en este caso te ayuda a no tener que escribir el
código para conectarte en la base de datos en cada nueva clase que lo necesitas.
Ejemplo:
Clase Conexión
using MySql.Data.MySqlClient;
public class Conectar {

public string usuario = "root";

private string a = "0000";

private int aux;

public MySqlConnection conexion = new MySqlConnection();

public void Asignar(string c) {

contrase;
a = c;
}
 public void conectar()
{
conexion = new MySqlConnection();
try {
conexion.ConnectionString = ("server=localhost;user="
+ (usuario + (";password=" + contrase)));
(a + ";database=hotel;port=3306");
conexion.Open();
// ' MsgBox("Conectado")
aux = 1;
}
catch (Exception ex) {
MsgBox(ex.Message);
}

public void Cerrar()

{
try {
conexion.Close();
MsgBox("sesion cerrada");
aux = 0;
}
catch (Exception ex) {
MsgBox(ex.Message);
}
}
}

Cuando necesites abrir la conexión a la base de datos puedes llamarlos usando herencia o declarando el
objeto dentro de la clase.
Herencia:
Class Registro: Conectar{ }
conectar() <-- llamando al objeto

Llamando al Objeto
Conectar obj = new Conectar()
obj.conectar() <-- llamando al objeto

De esta forma tienes acceso a los objetos dentro de la clase Conectar.

Cuando quieras hacer consultas, insertar, actualizar o eliminar te recomendaría crear por cada tabla que
tengas en la base de datos una clase dentro de tu proyecto con el nombre de la tabla, de esta manera lo
puedes organizar mejor tu proyecto.
 Vincular objetos como orígenes de datos en
aplicaciones .NET Framework mediante Visual
Studio
 Artículo
 03/05/2023
 10 colaboradores
Comentarios

En este artículo
1. Requisitos de objetos
2. Ejemplos de uso de objetos personalizados como orígenes de datos
3. Contenido relacionado

Nota

Los conjuntos de datos y las clases relacionadas son tecnologías heredadas de .NET Framework de
principios de la década de 2000 que permiten a las aplicaciones trabajar con datos en memoria
mientras están desconectadas de la base de datos. Son especialmente útiles para las aplicaciones que
permiten a los usuarios modificar los datos y conservar los cambios en la base de datos. Aunque los
conjuntos de datos han demostrado ser una tecnología de gran éxito, se recomienda que las nuevas
aplicaciones de .NET usen Entity Framework Core . Entity Framework proporciona una manera más
natural de trabajar con datos tabulares como modelos de objetos y tiene una interfaz de programación
más sencilla.

Visual Studio proporciona herramientas en tiempo de diseño para trabajar con objetos personalizados
como origen de datos en la aplicación. Cuando quiera almacenar datos de una base de datos en un
objeto que enlace a controles de interfaz de usuario, el enfoque recomendado es usar Entity Framework
para generar la clase, o las clases. Entity Framework genera automáticamente todo el código
reutilizable de seguimiento de cambios, lo que significa que los cambios que se realicen en los objetos
locales se conservarán automáticamente en la base de datos al llamar a AcceptChanges en el objeto
DbSet. Para más información, consulte la documentación de Entity Framework.

Sugerencia

Los métodos para el enlace de objetos que se indican en este artículo solo se deben tener en cuenta si la
aplicación ya está basada en conjuntos de datos. Estos métodos también pueden utilizarse si ya se está
familiarizado con los conjuntos de datos y los datos que se van a procesar son tabulares y no
demasiado complejos o demasiado grandes. Para ver un ejemplo aún más sencillo, que implica cargar
datos directamente en objetos mediante DataReader y actualizar manualmente la interfaz de usuario sin
enlace de datos, consulte Creación de una aplicación de datos sencilla mediante ADO.NET .

Requisitos de objetos
El único requisito para que los objetos personalizados funcionen con las herramientas de diseño de
datos en Visual Studio es que el objeto necesita tener al menos una propiedad pública.
Por lo general, los objetos personalizados no requieren interfaces, constructores ni atributos específicos
para actuar como origen de datos en una aplicación. Sin embargo, si desea arrastrar el objeto desde la
ventana Orígenes de datos a una superficie de diseño para crear un control enlazado a datos y si el
objeto implementa la interfaz ITypedList o IListSource, el objeto debe tener un constructor
predeterminado. De lo contrario, Visual Studio no puede crear instancias del objeto de origen de datos
y muestra un error al arrastrar el elemento a la superficie de diseño.

Ejemplos de uso de objetos personalizados como orígenes de

datos
Aunque hay innumerables maneras de implementar la lógica de la aplicación al trabajar con objetos
como origen de datos, en el caso de las bases de datos SQL hay algunas operaciones estándar que se
pueden simplificar mediante el uso de objetos TableAdapter generados por Visual Studio. En esta
página se explica cómo implementar estos procesos estándar mediante objetos TableAdapter. No está
pensado como guía para crear objetos personalizados. Por ejemplo, normalmente realizará las
siguientes operaciones estándar, independientemente de la implementación específica de los objetos o
de la lógica de la aplicación:
Cargar datos en objetos (normalmente desde una base de datos).
Crear una colección tipada de objetos.
Agregar objetos a una colección y quitarlos de ella.
Mostrar los datos de los objetos a los usuarios en un formulario.
Cambiar o editar los datos de los objetos.
Volver a guardar los datos de los objetos en la base de datos.

Carga de datos en objetos

En este ejemplo, se usan objetos TableAdapter para cargar datos en los objetos. De forma
predeterminada, los objetos TableAdapter se crea con dos tipos de métodos que capturan datos de una
base de datos y rellenan tablas de datos.
El método TableAdapter.Fill rellena una tabla de datos existente con los datos devueltos.

El método TableAdapter.GetData devuelve una nueva tabla de datos rellenada con datos.
 La manera más fácil de cargar los objetos personalizados con datos es llamar al
método TableAdapter.GetData, recorrer en bucle la colección de filas de la tabla de datos
devuelta y rellenar cada objeto con los valores de cada fila. Puede crear un método GetData que
devuelva una tabla de datos rellenada para cualquier consulta agregada a un objeto TableAdapter.

Nota

Visual Studio asigna nombres a las consultas de TableAdapter Fill y GetData de forma
predeterminada, pero puede cambiar esos nombres por cualquier nombre de método válido.

En el ejemplo siguiente se muestra cómo recorrer en bucle las filas de una tabla de datos y rellenar un
objeto con datos:

 C#
 VB
C#Copiar
private void LoadCustomers()
{
NorthwindDataSet.CustomersDataTable customerData =
customersTableAdapter1.GetTop5Customers();

foreach (NorthwindDataSet.CustomersRow customerRow in customerData)

{
Customer currentCustomer = new Customer();
currentCustomer.CustomerID = customerRow.CustomerID;
currentCustomer.CompanyName = customerRow.CompanyName;

if (customerRow.IsAddressNull() == false)
{
currentCustomer.Address = customerRow.Address;
}

if (customerRow.IsCityNull() == false)
{
currentCustomer.City = customerRow.City;
}

if (customerRow.IsContactNameNull() == false)
{
currentCustomer.ContactName = customerRow.ContactName;
}

if (customerRow.IsContactTitleNull() == false)
{
currentCustomer.ContactTitle = customerRow.ContactTitle;
}

if (customerRow.IsCountryNull() == false)
{
currentCustomer.Country = customerRow.Country;
}

if (customerRow.IsFaxNull() == false)
{
 currentCustomer.Fax = customerRow.Fax;
}

if (customerRow.IsPhoneNull() == false)
{
currentCustomer.Phone = customerRow.Phone;
}

if (customerRow.IsPostalCodeNull() == false)
{
currentCustomer.PostalCode = customerRow.PostalCode;
}

if (customerRow.IsRegionNull() == false)
{
currentCustomer.Region = customerRow.Region;
}

LoadOrders(currentCustomer);
customerBindingSource.Add(currentCustomer);
}
}

Creación de una colección tipada de objetos

Puede crear clases de colección para los objetos o usar las colecciones con tipo que el componente
BindingSource proporciona automáticamente.
Al crear una clase de colección personalizada para objetos, se recomienda heredarla
de BindingList<T>. Esta clase genérica proporciona la funcionalidad necesaria para administrar la
colección, así como la capacidad de generar eventos que envían notificaciones a la infraestructura de
enlace de datos en Windows Forms.
La colección generada automáticamente en BindingSource utiliza BindingList<T> para su colección
con tipo. Si la aplicación no requiere ninguna funcionalidad adicional, puede mantener la colección
dentro de BindingSource. Para más información, consulte la propiedad List de la clase BindingSource.

Nota

Si la colección requiere funcionalidad no proporcionada por la implementación base

de BindingList<T> , debe crear una colección personalizada para poder agregarla a la clase según sea
necesario.

En el código siguiente se muestra cómo crear la clase para una colección fuertemente tipada de
objetos Order:

 C#
 VB
C#Copiar
/// <summary>
/// A collection of Orders
/// </summary>
 public class Orders: System.ComponentModel.BindingList<Order>
{
// Add any additional functionality required by your collection.
}

Adición de objetos a una colección

Para agregar objetos a una colección es preciso llamar al método Add de la clase de colección
personalizada o de BindingSource.

Nota

El método Add se proporciona automáticamente para la colección personalizada cuando se hereda

de BindingList<T> .

En el código siguiente se muestra cómo agregar objetos a la colección con tipo en BindingSource:

 C#
 VB
C#Copiar
Customer currentCustomer = new Customer();
customerBindingSource.Add(currentCustomer);
En el código siguiente se muestra cómo agregar objetos a un colección con tipo que hereda
de BindingList<T>:

Nota

Por ejemplo, la colección Orders es una propiedad del objeto Customer .

 C#
 VB
C#Copiar
Order currentOrder = new Order();
currentCustomer.Orders.Add(currentOrder);

Eliminación de objetos de una colección

Para quitar objetos de una colección es preciso llamar a los métodos Remove o RemoveAt de la clase
de colección personalizada o de BindingSource.

Nota

Los métodos Remove y RemoveAt se proporcionan automáticamente para una colección

personalizada cuando esta se hereda de BindingList<T> .

En el código siguiente se muestra cómo buscar y quitar objetos de la colección con tipo
en BindingSource con el método RemoveAt:

 C#
 VB
C#Copiar
int customerIndex = customerBindingSource.Find("CustomerID", "ALFKI");
customerBindingSource.RemoveAt(customerIndex);

Presentación de datos de objeto a los usuarios

Para mostrar los datos de los objetos a los usuarios se utiliza el Asistente para configuración del
origen de datos para crear un origen de datos de objeto y, después, se arrastra todo el objeto o
propiedades individuales al formulario desde la ventana Orígenes de datos.

Modificación de los datos de los objetos

Para editar los datos de objetos personalizados enlazados a datos de controles de Windows Forms, solo
hay que editar los datos del control enlazado (o directamente en las propiedades del objeto). La
arquitectura de enlace de datos actualiza los datos del objeto.
Si la aplicación requiere el seguimiento de los cambios y la reversión de los cambios propuestos a sus
valores originales, esta funcionalidad se debe implementar en el modelo de objetos. Para obtener
ejemplos de la forma en que las tablas de datos realizan un seguimiento de los cambios propuestos,
consulte DataRowState, HasChangesy GetChanges.

Almacenamiento de objetos en la base de datos

Para volver a guardar los datos en la base de datos pase los valores del objeto a los métodos DBDirect
de TableAdapter.
Visual Studio crea métodos DBDirect que se pueden ejecutar directamente en la base de datos. Estos
métodos no requieren objetos DataSet ni DataTable.
Expandir tabla
Método de TableAdapter
Descripción
DBDirect
TableAdapter.Insert Agrega nuevos registros a una base de datos, lo que le permite usar
valores de columna individuales como parámetros de método.
Actualiza los registros existentes en una base de datos. El método
Update utiliza los valores de columna originales y nuevos como
parámetros. Los valores originales se usan para localizar el registro
original, mientras que los nuevos se usan para actualizar ese registro.
TableAdapter.Update
El método TableAdapter.Update también se usa para conciliar los
cambios de un conjunto de datos de nuevo en la base de datos, para lo
que se toman DataSet, DataTable, DataRow, o una matriz
de DataRow como parámetros.
TableAdapter.Delete Elimina los registros existentes de la base de datos en función de los
valores de columna originales usados como parámetros del método.
Para guardar datos de una colección de objetos, recorra en bucle la colección de objetos (por ejemplo,
mediante un bucle for-next). Envíe los valores de cada objeto a la base de datos mediante los métodos
DBDirect de TableAdapter.
 En el ejemplo siguiente se muestra cómo usar el método DBDirect TableAdapter.Insert para
agregar un nuevo cliente directamente a la base de datos:

 C#
 VB
C#Copiar
private void AddNewCustomers(Customer currentCustomer)
{
customersTableAdapter.Insert(
currentCustomer.CustomerID,
currentCustomer.CompanyName,
currentCustomer.ContactName,
currentCustomer.ContactTitle,
currentCustomer.Address,
currentCustomer.City,
currentCustomer.Region,
currentCustomer.PostalCode,
currentCustomer.Country,
currentCustomer.Phone,
currentCustomer.Fax);
}
EJEMPLO DE CONECCION A BASE DE DATOS EN PROYECTO EMPLEADO SUPERVISOR

hacer un metodo que haga una coneccion a base de datos y sea capaz de
guardar todas las propiedades de cada empleado mostrada en el metodo
mostrar empleado en distintas columnas de una tabla empleado. Tambien
hacer lo mismo con cada supervisor

Para lograr esto, primero necesitas establecer una conexión a la base

de datos y luego realizar operaciones de inserción para guardar la
información de cada empleado y supervisor en la base de datos.
Asumiré que estás utilizando SQL Server y que ya tienes una base de
datos con una tabla llamada "Empleado" y una tabla llamada
"Supervisor". Aquí hay un ejemplo de cómo podrías hacerlo:
1. Agrega las referencias necesarias al espacio de nombres using
System.Data.SqlClient; y using System.Configuration;.
2. Crea un método para establecer la conexión a la base de datos:
csharpCopy code
static SqlConnection ObtenerConexion()
{
string cadenaConexion =
ConfigurationManager.ConnectionStrings["NombreDeTuConexion"].ConnectionString;
SqlConnection conexion = new SqlConnection(cadenaConexion);
return conexion;
}

Asegúrate de que en tu archivo de configuración (app.config o web.config) tengas una cadena de

conexión como esta:
xmlCopy code
<connectionStrings>
<add name="NombreDeTuConexion" connectionString="Data Source=TuServidor;Initial
Catalog=TuBaseDeDatos;Integrated Security=True;" />
</connectionStrings>

3. Ahora, crea un método para guardar un empleado en la base de datos:

csharpCopy code
static void GuardarEmpleadoEnBD(Empleados empleado)
{
using (SqlConnection conexion = ObtenerConexion())
{
conexion.Open();

string consulta = "INSERT INTO Empleado (Nombre, Apellido, Calle, Altura,

Ciudad, Provincia, CodigoPostal, Email, CodigoIdentificador, Salario, Permisos) " +
"VALUES (@Nombre, @Apellido, @Calle, @Altura, @Ciudad,
@Provincia, @CodigoPostal, @Email, @CodigoIdentificador, @Salario, @Permisos)";

using (SqlCommand comando = new SqlCommand(consulta, conexion))

{
 comando.Parameters.AddWithValue("@Nombre", empleado.Nombre);
comando.Parameters.AddWithValue("@Apellido", empleado.Apellido);
comando.Parameters.AddWithValue("@Calle", empleado.Direccion.Calle);
comando.Parameters.AddWithValue("@Altura", empleado.Direccion.Altura);
comando.Parameters.AddWithValue("@Ciudad", empleado.Direccion.Ciudad);
comando.Parameters.AddWithValue("@Provincia",
empleado.Direccion.Provincia);
comando.Parameters.AddWithValue("@CodigoPostal",
empleado.Direccion.Codigo_postal);
comando.Parameters.AddWithValue("@Email", empleado.Email);
comando.Parameters.AddWithValue("@CodigoIdentificador",
empleado.Codigo_Identificador);
comando.Parameters.AddWithValue("@Salario", empleado.Salario);
comando.Parameters.AddWithValue("@Permisos", empleado.Permisos);

comando.ExecuteNonQuery();
}
}
}

4. Repite el mismo proceso para guardar un supervisor en la base de datos:

csharpCopy code
static void GuardarSupervisorEnBD(Supervisores supervisor)
{
// Similar al método para guardar empleado, pero con la tabla Supervisor
}

5. Ahora, en tu método principal (Main), después de llenar tus arreglos, puedes llamar a estos
métodos para guardar la información en la base de datos:
csharpCopy code
// Después de llenar tus arreglos ListaEmpleados y ListaSupervisores
foreach (var empleado in ListaEmpleados)
{
GuardarEmpleadoEnBD(empleado);
}

foreach (var supervisor in ListaSupervisores)

{
GuardarSupervisorEnBD(supervisor);
}

Ten en cuenta que este es un ejemplo básico y puede requerir ajustes según tu entorno específico y
necesidades de seguridad. Además, siempre se recomienda utilizar parámetros en las consultas SQL
para evitar ataques de inyección de SQL.