• Author / Uploaded
• cpaz_navarro

Citation preview

Acceso a base de datos SQL Server desde WebService, con aplicación de escritorio – Parte I Hoy les he traído un ejemplo que se les va a servir a muchos de ustedes. Se trata de crear una aplicación en la cual se usa una conexión a un WebService, y éste a su vez conecte a una base de datos creada en SQL Server 2005. Para lograr esto, hay que tener en cuenta los siguientes puntos: 1. Deberás tener configurado el ASP.NET 2.0 en el servidor donde va a estar ubicado el WebService. En mi caso, como de seguro en la mayoría de usuarios, estoy usando el IIS (por una extraña razón, tuve que configurarlo manualmente. Mierda). 2. El puerto por el cual te conectarás a dicho servidor tendrá que ser fijo, debido a que normalmente el servidor local de ASP.NET otorga puertos aleatorios para evitar conflictos con otras aplicaciones que estén trabajando con dicho servidor. 3. La cadena de conexión a la base de datos que usarás depende de cómo esté configurada la seguridad y los inicios de sesión de los usuarios que acceden al servidor SQL Server. En el caso del ejemplo, uso la sesión predeterminada de Windows. Si hay problemas con tu cadena de conexión, no dudes en consultarme. 4. La forma en cómo están construidos los formularios Windows (que vendrá en partes posteriores de este artículo), es una de las formas más eficaces y avanzadas de hacer formularios. Si es la primera vez que ves la forma en cómo está construido y quieres usarlo, no dudes en hacerlo. Pero no olvides poner referencias de donde lo sacaste, te aseguro que tus huevos aumentaran dos pulgadas de diámetro si lo haces. Si no lo haces y quieres pasarte de listo, espero que tu mamá muera de cáncer, maldito copión ladrón pirata hijo de mil putas. 5. El lenguaje usado es C#, el ejemplo será subido en C#, y sólo si me lo pide un bueno de gente haré una interfaz en Visual Basic. Los programadores que sólo dominan Visual Basic son gente sin cultura ni sentimientos. Y tocan los timbales. 6. Respecto los dos puntos anteriores: si eres estudiante, practícalo, mejóralo, y no hagas “copy-paste”: es el camino para que te conviertas en un buen programador. Si lo haces Dios no te enviará al infierno y serás colmado de bendiciones tántricas. Aclarada toda la situación, procedamos: Primero abrimos el Visual Studio 2008 (sí no lo tienes instalado, ya vendrá una actualización de cómo hacerlo en 2005, si no quieres esperar, instálalo mierda) y creamos una solución. Luego procederemos a crear el WebService. Para esto presionamos anti-click sobre la solución, seleccionamos “Agregar” y luego hacemos click sobre “Nuevo sitio Web”. Nos saldrá el siguiente cuadro de diálogo: Luego seleccionamos “Servicio Web ASP.NET”, elegimos la ubicación (de preferencia dentro de la misma solución) y click en “Aceptar”. En el editor de código aparecerá algo parecido a lo siguiente: Si deseamos, borraremos las siguientes líneas de código (sólo sirven para saludar):

Código: [WebMethod] public string HelloWorld() { return "Hello World"; } Ahora bien, una ligera explicación de cada unos de las variables, métodos y funciones a usar: var_cadenaconexion: Variable que define la cadena de conexión a la base de datos SQL Server. var_conexion: Variable de tipo SqlConnection; permitirá establecer una conexión a la base de datos SQL Server. var_comando: Variable de tipo SqlCommand; permitirá la ejecución de consultas y el paso de parámetros para la ejecución de las mismas. var_adaptador: Variable de tipo SqlDataAdapter; con un funcionamiento parecido al de var_comando, con la salvedad de que además permitirá llenar un conjunto de datos (DataSet) con los datos obtenidos de una consulta. var_resultado: Variable de tipo DataSet; nos permitirá mostrar los registros de una tabla. Lo que resta de variables, es ya bastante obvio cómo para explicarlo, eso si eres programador claro está, aunque no sé porque escribí estas líneas si este blog es justo para ustedes. Ah, también hay otros temas.

Código: String var_cadenaconexion = (@"server=ISMAEL\SQLEXPRESS;database=Bd_Ejemplo1_WebService;integrated security=true"); SqlConnection var_conexion = new SqlConnection(); SqlCommand var_comando = new SqlCommand(); SqlDataAdapter var_adaptador = new SqlDataAdapter(); abrirconexion (): Ésta función nos permitirá, cómo dice su nombre, abrir una conexión a la base de datos SQL Server, para poder realizar las operaciones que nosotros deseamos.

Código: private void abrirconexion() { var_conexion.ConnectionString = var_cadenaconexion; if (var_conexion.State == ConnectionState.Closed) var_conexion.Open(); } cerrarconexion (): Si no te imaginas para que sirve esta función, debe ser que te equivocaste de carrera y debiste haber estudiado corte y confección, o marinera.

Código: private void cerrarconexion() { if (var_conexion.State == ConnectionState.Closed) var_conexion.Close(); } Ahora, entrado a este punto, es preciso comenzar a trabajar en la base de datos. Primero crearemos (como es obvio), nuestra base de datos, la cual lo haremos mediante el siguiente script.

Código: use master create database Bd_Ejemplo1_WebService on ( name = 'Bd_Ejemplo1_WebService_Data', filename = 'E:\ismadelblog_escritos\Bd_Ejemplo1_WebService_Data.mdf', size = 3, maxsize = 50MB, filegrowth = 1 ) log on ( name = 'Bd_Ejemplo1_WebService_Log', filename = 'E:\ismadelblog_escritos\Bd_Ejemplo1_WebService_Log.ldf', size = 3, maxsize = 50MB, filegrowth = 1 ) go Ahora pasemos a crear la tabla “tm_producto”, que nos servirá para este ejemplo:

Código: create table tm_producto ( tm_idproducto int identity(1,1) primary key, tm_nombreproducto varchar(150),

) Go

tm_marcaproducto varchar(50), tm_modeloproducto varchar(50), tm_fecharegproducto datetime, tm_estadoproducto varchar(20)

Nota: ¿Por qué “tm_” antes del nombre propio de la tabla, y de los campos de la misma? Porque quiero darle a la tabla el estatus de tabla principal o “maestra”, de ahí el término, las siglas de lo que representa: tabla “maestra”. Más adelante lo explicaré en otro artículo, tú solo limítate a seguir fielmente lo que esté en este artículo si quieres que funcione tu ejemplo. Por ahora soy tu amo y señor, ya después me escribirás para insultarme. Por ahora no pondré cosas tales como “precio” o “stock”, ya que número uno no son principales para éste ejemplo, y numero dos si eres informático pensante o al menos dedicado ya te habrás dado cuenta que esos dos atributos no deberían pertenecer directamente a la entidad “producto”. Para finalizar con la primera parte de éste artículo, crearemos en la base de datos los procedimientos almacenados necesarios para el funcionamiento de la aplicación: pa_producto_listar: Nos devolverá los registros de la tabla “tm_producto” para mostrarlos en la aplicación. Éste procedimiento recibirá dos parámetros, uno para definir con qué tipo de consulta se va a trabajar, y el otro recibirá los datos que sirvan como criterio para mostrar los datos que nosotros especifiquemos.

Código: create procedure pa_producto_listar ( @tipo varchar(5), @param1 varchar(150) ) as begin if @tipo = '1' begin select * from tm_producto where tm_nombreproducto like '%' + @param1+'%' end if @tipo = '2' begin select * from tm_producto where tm_idproducto = convert(int, @param1) end end go pa_producto_insertar: Insertará un nuevo registro a la tabla (o que pensabas que iba a hacer).

Código: create procedure pa_producto_insertar ( @nombreproducto varchar(150), @marcaproducto varchar(50), @modeloproducto varchar(50), @fecharegproducto datetime, @estadoproducto varchar(20) ) as begin insert into tm_producto ( tm_nombreproducto, tm_marcaproducto, tm_modeloproducto, tm_fecharegproducto, tm_estadoproducto ) values ( @nombreproducto,

)

@marcaproducto, @modeloproducto, @fecharegproducto, @estadoproducto

end go pa_producto_actualizar: Modificará los datos de un registro de la tabla especificado por su id.

Código: create procedure pa_producto_actualizar ( @idproducto int, @nombreproducto varchar(150), @marcaproducto varchar(50), @modeloproducto varchar(50), @fecharegproducto datetime, @estadoproducto varchar(20) ) as begin update tm_producto set tm_nombreproducto = @nombreproducto, tm_marcaproducto = @marcaproducto, tm_modeloproducto = @modeloproducto, tm_fecharegproducto = @fecharegproducto, tm_estadoproducto = @estadoproducto where tm_idproducto = @idproducto end go pa_producto_eliminar: Eliminará los datos de un registro de la tabla especificado por su id.

Código: create procedure pa_producto_borrar ( @idproducto int ) as begin delete from tm_producto where tm_idproducto = @idproducto end go Para terminar con la primera parte de esta “saga”, indicar que si bien es cierto los WebService tienen cierta utilidad para aplicaciones que requieran ser abiertas en cualquier PC con acceso a Internet, el servidor donde deben estar alojados deben ser confiables, seguros, rápidos para los procesos y sobre todo, soportar la “pesadez” de los mismos. Bueno hasta el momento es todo, en la segunda parte veremos cómo crear las funciones en el WebService que trabajarán con los procedimientos almacenados, configuración y diseño de la interfaz.

Acceso a base de datos SQL Server desde WebService, con aplicación de escritorio – Parte II En la primera parte de éste artículo, habíamos avanzado la parte de creación del WebService, así como la base datos, la tabla y los procedimientos almacenados con los cuales se va a trabajar. En ésta oportunidad definiremos las funciones en el WebService que van a interactuar con tales procedimientos. Para eso abrimos nuestro proyecto del WebService que creamos en la primera parte de éste artículo: Ahora bien, pasaremos a definir las funciones anteriormente mencionadas, no sin antes pedirte que prestes atención a la siguiente línea de código: La línea de código que ven es sumamente importante que la pongan en una línea anterior a la definición de cada función que se va a utilizar en la aplicación, porque cuando ustedes quieran llamar a cualquiera

de las funciones que a continuación vamos a crear, y no han puesto dicha línea que define a una función como un método Web, ósea método WebService o del servicio Web.

Código: 1

[WebMethod]

Nota: La línea de código [WebMethod] no está sobre los métodos abrirconexion () ycerrarconexion () porque no ha sido necesario definirlas de ese modo, y no se preocupen que el ejemplo funcionará igual ya que dichos métodos son llamados en las funciones de la misma clase del WebService, por lo que su ejecución se hará al momento de ejecutar las funciones. listar_productos (): Función de tipo DataSet que nos devolverá los registros obtenidos a través del procedimiento almacenado “pa_producto_listar”.

Código: [WebMethod] public DataSet listar_productos( string param_tipo, string param_param1 ) { DataSet var_resultado = new DataSet(); try { abrirconexion(); var_comando.CommandText = "pa_producto_listar"; var_comando.CommandType = CommandType.StoredProcedure; var_comando.Connection = var_conexion; var_comando.Parameters.Add("@tipo",SqlDbType.VarChar,5).Value=param_tipo; var_comando.Parameters.Add("@param1",SqlDbType.VarChar,150).Value= param_param1; var_adaptador.SelectCommand = var_comando; var_adaptador.Fill(var_resultado, "consulta"); var_comando = null; cerrarconexion(); } catch (Exception ex) { throw ex; } return var_resultado; } insertar_producto (): Función de tipo int que nos devolverá un valor mayor a cero si el procedimiento “pa_producto_insertar” agregó correctamente un registro la tabla “tm_producto”, y cero sí ocurrió algún error.

Código: [WebMethod] public int insertar_producto ( string param_nombre, string param_marca, string param_modelo, DateTime param_fecharegistro, string param_estado ) { int var_resultado = 0;

try { abrirconexion(); var_comando.CommandText = "pa_producto_insertar"; var_comando.CommandType = CommandType.StoredProcedure; var_comando.Connection = var_conexion; var_comando.Parameters.Add("@nombreproducto",SqlDbType.VarChar,150).Value = param_nombre; var_comando.Parameters.Add("@marcaproducto",SqlDbType.VarChar, 50).Value= param_marca; var_comando.Parameters.Add("@modeloproducto",SqlDbType.VarChar, 50).Value = param_modelo; var_comando.Parameters.Add("@fecharegproducto",SqlDbType.DateTime).Value = param_fecharegistro; var_comando.Parameters.Add("@estadoproducto", SqlDbType.VarChar).Value = param_estado; var_resultado = var_comando.ExecuteNonQuery(); cerrarconexion(); } catch (Exception ex) { throw ex; } return var_resultado; } actualizar_producto (): Esta función de tipo int actuará de la misma forma que insertar_producto (), sólo que ahora en vez de insertar, modificará los datos de un registro de acuerdo al primer parámetro que le enviaremos, que será la id del registro a modificar.

Código: [WebMethod] public int actualizar_producto ( int param_idproducto, string param_nombre, string param_marca, string param_modelo, DateTime param_fecharegistro, string param_estado ) { int var_resultado = 0; try { abrirconexion(); var_comando.CommandText = "pa_producto_actualizar"; var_comando.CommandType = CommandType.StoredProcedure; var_comando.Connection = var_conexion; var_comando.Parameters.Add("@idproducto",SqlDbType.Int).Value= param_idproducto; var_comando.Parameters.Add("@nombreproducto",SqlDbType.VarChar,150).Value= param_nombre; var_comando.Parameters.Add("@marcaproducto",SqlDbType.VarChar,50).Value= param_marca; var_comando.Parameters.Add("@modeloproducto",SqlDbType.VarChar, 50).Value= param_modelo; var_comando.Parameters.Add("@fecharegproducto", SqlDbType.DateTime).Value= param_fecharegistro; var_comando.Parameters.Add("@estadoproducto", SqlDbType.VarChar).Value= param_estado; var_resultado = var_comando.ExecuteNonQuery(); cerrarconexion(); } catch (Exception ex) {

throw ex; } return var_resultado; } borrar_producto (): Ésta función…

Código: [WebMethod] public int borrar_producto(int param_idproducto) { int var_resultado = 0; try { abrirconexion(); var_comando.CommandText = "pa_producto_borrar"; var_comando.CommandType = CommandType.StoredProcedure; var_comando.Connection = var_conexion; var_comando.Parameters.Add("@idproducto", SqlDbType.Int).Value= param_idproducto; var_resultado = var_comando.ExecuteNonQuery(); cerrarconexion(); } catch (Exception ex) { throw ex; } return var_resultado; } De más está decir que las funciones que acabo de mostrar deben ser agregadas después de los métodos abrirconexion () y cerrarconexion (). Una vez hemos llegado hasta aquí, procederemos a hacer las configuraciones respectivas en la consola de SQL Server 2005. Si no lo tienes instalado entonces instálalo, no voy a hacer un ejemplo con SQL Server 2000. Ahora bien, deberás buscar el usuario “ASPNET”, si no está es porque no ha sido agregado aún, para agregarlo deberás hacer anti-click y seleccionar “Nuevo inicio de sesión…”. Aparecerá un cuadro de diálogo como el siguiente: Harás click en el botón “Buscar”, aparecerá lo siguiente: Hacer click en el botón “Avanzadas…”, para buscar al usuario “ASPNET” y así poder agregarlo. Se desplegará la siguiente ventana: Una vez aquí, haremos click en el botón “Buscar ahora”, y en la lista detalle de la parte inferior se nos mostrará una lista con todos los usuarios que tenemos registrados en el equipo: Como en la imagen, seleccionamos “ASPNET” y luego hacemos click en “Aceptar”. En la otra ventana igualmente haremos click en “Aceptar”. Así tendrá que quedar esta parte del cuadro de diálogo “Inicio de sesión – Nuevo”. Ahora bien, en el mismo cuadro de diálogo seleccionamos la opción “Asignación de usuarios”. El cuadro de diálogo cambiará a lo siguiente: En la vista detalle “Usuarios asignados a este inicio de sesión” seleccionaremos la base de datos con la cual vamos a trabajar, en este caso será “Bd_Ejemplo1_WebService” (o el nombre que le hayan dado ustedes). Luego en la lista de opciones “Miembros de la función de base de datos para: [Nombre de la base seleccionada]” marcaremos la opción que diga “db_owner”. Luego click en “Aceptar”. Ahora iremos a nuestro proyecto del WebService en el Visual Studio, y en el explorador de soluciones buscaremos el proyecto, y luego haremos anti-click en el archivo con extensión .asmx, y finalmente haremos click en la opción “Ver en el explorador”.

En la pantalla del explorador web que tengas, y si todo ha salido bien, se cargará lo siguiente: Para comprobar su correcto funcionamiento, haremos ejemplo: listar_producto (). Se nos mostrará lo siguiente:

click en

una

función

de

la

lista,

por

Hacemos click en “Invocar”, y si todo se ha hecho de la manera correcta y un cruce de dedos, lo siguiente aparecerá: Es un archivo .xml generado con la información de la tabla “tm_producto”. Ahora estamos listos para usar nuestro WebService.

Acceso a base de datos SQL Server desde WebService, con aplicación de escritorio – Parte III Bueno, en el anterior articulo ya habíamos creado y configurado el WebService, ahora nos resta crear el proyecto de la interfaz gráfica, y crear además la referencia al WebService. Para empezar creamos el proyecto dentro de la misma solución, al igual que como lo hicimos con el sitio Web que ocupa el WebService, poniéndole el nombre que más les apetezca: Llegado a este punto, cabe recordarles lo siguiente: no importa como hayan diseñado su formulario, no les pido que el diseño del formulario principal sea como este: …Y el de ingresar nuevos datos a la base tenga el siguiente aspecto: Le haremos anti-click al icono del proyecto de la aplicación en nuestro explorador de soluciones, y hacemos click en “Agregar referencia de servicio…”: De ahí, puede hacerse de dos formas: una es copiando la dirección Web que sale al momento de mostrar en el explorador Web el archivo .asmx del servicio web: Y ponerla en el control desplegable de “Dirección”, así: Y luego haciendo click en el botón “Ir”. La otra es haciéndole click en el botón “Detectar”, de tal manera que el sistema cargará automáticamente los servicios webs que estén presentes, pero me parece más conveniente esta forma. En los paneles de “Servicio” y “Operaciones” se cargarán el servicio Web y las funciones del servicio Web respectivamente, pero sólo se cargarán las operaciones si seleccionas la clase del servicio, así: Luego le das el nombre de tu preferencia: Y finalmente hacemos click en “Aceptar”. A continuación se crearán las referencias al servicio; ya estamos listos para darles uso. Si sabes programar con orientación a objetos, sólo te diré que simplemente tendrás que declarar una variable a manera de instanciar la clase del WebService. De esta manera:

Código: WinAlmacen.ReferenciaServicio1.Service1SoapClient serv1 = new WinAlmacen.ReferenciaServicio1.Service1SoapClient(); listarproductos (): Función para mostrar en el control DataGridView los datos de la tabla“tm_producto”. Aquí se utilizará una función del WebService.

Código: private void listarproductos(string tipo_consulta, string parametro) { DataSet dts = new DataSet(); dts = serv1.listar_productos(tipo_consulta, parametro); this.dtgprint.DataSource = dts.Tables["consulta"]; } Lo siguiente será lo que se tendrá que programar en los controles en donde sea necesario:

En el evento Load del formulario “frmAmd_Producto”: Para el botón de búsqueda btnBuscar en el evento Click:

Código: private void btnBuscar_Click(object sender, EventArgs e) { this.listarproductos("1", this.txtBusqueda.Text); } Para el botón btnNuevo, el cual llamará a otro formulario para el ingreso de un nuevo registro, en el evento Click:

Código: private void btnNuevo_Click(object sender, EventArgs e) { frmAdd_Producto var_nuevoproducto = new frmAdd_Producto(); var_nuevoproducto._idproducto = 0; var_nuevoproducto.ShowDialog(); this.listarproductos("1", ""); } Para el botón btnEditar, el cual volverá a llamar a otro formulario para modificar los datos de un registro especificado por su id, en el evento Click:

Código: private void btnEditar_Click(object sender, EventArgs e) { frmAdd_Producto var_editarproducto = new frmAdd_Producto(); if (this.dtgprint.Rows.Count == 0) return; int indexfila = (this.dtgprint.CurrentCell != null) ? this.dtgprint.CurrentCell.RowIndex : 0; var_editarproducto._idproducto = (int)this.dtgprint.Rows[indexfila].Cells[0].Value; var_editarproducto.ShowDialog(); this.listarproductos("1", ""); } Nota: Si te fijas en el código fuente de los dos botones anteriores, notarás que en las variables que definen al formulario “frmAdd_Producto” (var_nuevoproducto y var_editarproducto) hay otra variable que hace referencia al id del producto, esto no es más que una variable de propiedad del formulario “frmAdd_Producto”, la cual se realizará más adelante. Para el botón btnBorrar, el cual eliminará un registro especificado por su id, en el eventoClick. Aquí se utilizará una función del WebService:

Código: private void btnBorrar_Click(object sender, EventArgs e) { int var_resultado = 0; if (this.dtgprint.Rows.Count == 0) return; if (MessageBox.Show("¿Desea eliminar este registro?", "Atención", MessageBoxButtons.YesNo, MessageBoxIcon.Question)==DialogResult.Yes) { int indexfila = (this.dtgprint.CurrentCell != null) ? this.dtgprint.CurrentCell.RowIndex : 0; var_resultado =

this.serv1.borrar_producto((int)this.dtgprint.Rows[indexfila].Cells[0].Value); if (var_resultado != 0) { MessageBox.Show("Eliminado correctamente", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Information); this.listarproductos("1", ""); } } } Bueno hasta aquí todo bien, ahora pasemos a programar el código para el formulario “frmAdd_Producto”: Primero hay que definir la variable de carácter pública idproducto, y la propiedad también de carácter pública _idproducto. Por medio de estas dos definiciones podremos hacer el paso de valores del formulario “frmAmd_Producto” al formulario “frmAdd_Producto”.

Código: public int idproducto = 0; public int _idproducto { get { return idproducto; } set { idproducto = value; } } Ahora bien, lo que acabo de definir anteriormente no serviría de nada si no lo uso ¿cierto?, pero antes tengo que definir el método con el cual podemos darle utilidad. Mediante el siguiente código lo que haremos será reunir los datos de un registro especificado por su id para luego mostrarlos en el formulario. Nota: Para guardar un orden, se recomienda crear la anterior variable y la propiedad antes de programar el código de los botones btnNuevo y btnEditar. Ahora instanciemos la clase del WebService, como en el formulario anterior:

Código: WinAlmacen.ReferenciaServicio1.Service1SoapClient serv1 = new WinAlmacen.ReferenciaServicio1.Service1SoapClient(); Ahora bien, lo que acabo de definir anteriormente no serviría de nada si no lo uso ¿cierto?, pero antes tengo que definir el método con el cual podemos darle utilidad. Mediante el siguiente código lo que haremos será reunir los datos de un registro especificado por su id para luego mostrarlos en el formulario.

Código: private void obtenerProducto(int param_idproducto) { DataSet dts = new DataSet(); dts = serv1.listar_productos("2", Convert.ToString(param_idproducto)); if (dts.Tables["consulta"].Rows.Count != 0) { this.txtNombreProducto.Text = dts.Tables["consulta"].Rows[0]["tm_nombreproducto"].ToString(); this.txtMarca.Text = dts.Tables["consulta"].Rows[0]["tm_marcaproducto"].ToString(); this.txtModelo.Text = dts.Tables["consulta"].Rows[0]["tm_modeloproducto"].ToString(); this.dtpFechaIng.Value = Convert.ToDateTime(dts.Tables["consulta"].Rows[0] ["tm_fecharegproducto"]); this.cboEstado.SelectedText =

dts.Tables["consulta"].Rows[0]["tm_estadoproducto"].ToString(); } }

Muy bien, ahora en el evento Load del mismo formulario programaremos el siguiente código:

Código: private void frmAdd_Producto_Load(object sender, EventArgs e) { this.obtenerProducto(this.idproducto); } Como de seguro habrás notado, coloco además del código a programar el código del evento en el cual se tiene que programar, eso lo hago para ti, para que veas en donde se debe programar. No vayas a pensar que todo lo que pongo como código se debe programar dentro del evento botón eh… Ahora bien, sólo falta definir a la estrella de este formulario: el método grabarProducto ():

Código: private void grabarProducto() { int var_respuesta = 0; string var_mensaje = ""; string var_nombre = ""; string var_marca = ""; string var_modelo = ""; DateTime var_fechaingreso = DateTime.Now; string var_estado = ""; if (this.txtNombreProducto.Text.Trim().Length == 0) { MessageBox.Show("Ingrese nombre de producto", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); this.txtNombreProducto.Focus(); return; } if (this.txtMarca.Text.Trim().Length == 0) { MessageBox.Show("Ingrese marca de producto", "Atención", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); this.txtMarca.Focus(); return; } var_nombre = this.txtNombreProducto.Text; var_marca = this.txtMarca.Text; var_modelo = this.txtModelo.Text; var_fechaingreso = this.dtpFechaIng.Value; var_estado = this.cboEstado.Text; if (this.idproducto == 0) { var_respuesta = this.serv1.insertar_producto(var_nombre, var_marca, var_modelo, var_fechaingreso, var_estado); var_mensaje = "Producto agregado correctamente"; } else { var_respuesta = this.serv1.actualizar_producto(idproducto, var_nombre, var_marca, var_modelo, var_fechaingreso, var_estado); var_mensaje = "Producto editado correctamente"; } if (var_respuesta != 0) { MessageBox.Show(var_mensaje, "Atención", MessageBoxButtons.OK, MessageBoxIcon.Information); idproducto = 0; this.Close(); } }

Como verán, primero defino las variables que me van a servir para guardar los datos de los ítems del formulario, luego hago una validación de los campos más importantes, para después asignar el valor de los controles a las variables, y finalmente, según el valor del código del producto, hago bien una inserción o una modificación. Luego de todo esto se está mostrando un mensaje y el posterior cierre del formulario, sólo si la respuesta de la ejecución de las funciones del WebService es un valor mayor que cero, es decir, que se hayan ejecutado correctamente. Cabe mencionar también que el valor de la variable idproducto vuelve a cero para cuidar posibles conflictos ante otras operaciones que se realicen en el formulario. Pero el método que acabamos de crear no serviría de nada si no lo llamamos, y para hacer esto programaremos en el botón btnGuardar el siguiente código:

Código: private void btnGrabar_Click(object sender, EventArgs e) { this.grabarProducto(); } El código del botón btnCancelar, será de la siguiente forma:

Código: private void btnCancelar_Click(object sender, EventArgs e) { this.Close(); } En el código del botón btnCancelar está tu código para el botón btnCerrar del anterior formulario.