stored - Llamar a un procedimiento almacenado con el parámetro en c#

mapear stored procedure entity framework

Question

Puedo hacer una eliminación, insertar y actualizar en mi programa e intento hacer una inserción llamando a un procedimiento almacenado creado desde mi base de datos.

Esta inserción de un botón que hago funcionar bien.

private void btnAdd_Click(object sender, EventArgs e)
{
        SqlConnection con = new SqlConnection(dc.Con);
        SqlCommand cmd = new SqlCommand("Command String", con);

        da.InsertCommand = new SqlCommand("INSERT INTO tblContacts VALUES (@FirstName, @LastName)", con);
        da.InsertCommand.Parameters.Add("@FirstName", SqlDbType.VarChar).Value = txtFirstName.Text;
        da.InsertCommand.Parameters.Add("@LastName", SqlDbType.VarChar).Value = txtLastName.Text;

        con.Open();
        da.InsertCommand.ExecuteNonQuery();
        con.Close();

        dt.Clear();
        da.Fill(dt);
    } 

Este es el inicio del botón para llamar al procedimiento llamado sp_Add_contact para agregar un contacto. Los dos parámetros para sp_Add_contact(@FirstName,@LastName) . Busqué en Google un buen ejemplo pero no encontré nada interesante.

private void button1_Click(object sender, EventArgs e)
{
        SqlConnection con = new SqlConnection(dc.Con);
        SqlCommand cmd = new SqlCommand("Command String", con);
        cmd.CommandType = CommandType.StoredProcedure;

        ???

        con.Open();
        da. ???.ExecuteNonQuery();
        con.Close();

        dt.Clear();
        da.Fill(dt);
    }

Answer 1

Agregar los parámetros por separado me dio problemas, así que lo hice y funcionó de maravilla:

 string SqlQ = string.Format("exec sp_Add_contact ''{0}'', ''{1}''", txtFirstName.Text, txtLastName.Text);
 using (SqlConnection con = new SqlConnection(dc.Con)) {
   using (SqlCommand cmd = new SqlCommand("sp_Add_contact", con)) {


    con.Open();
    cmd.ExecuteNonQuery();
 }
}

Answer 2

Como alternativa, tengo una biblioteca que facilita el trabajo con procs: https://www.nuget.org/packages/SprocMapper/

SqlServerAccess sqlAccess = new SqlServerAccess("your connection string");
    sqlAccess.Procedure()
         .AddSqlParameter("@FirstName", SqlDbType.VarChar, txtFirstName.Text)
         .AddSqlParameter("@FirstName", SqlDbType.VarChar, txtLastName.Text)
         .ExecuteNonQuery("StoreProcedureName");

Answer 3

Debe agregar parámetros, ya que es necesario que el SP se ejecute

using (SqlConnection con = new SqlConnection(dc.Con))
{
    using (SqlCommand cmd = new SqlCommand("SP_ADD", con))
    {
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.AddWithValue("@FirstName", txtfirstname);
        cmd.Parameters.AddWithValue("@LastName", txtlastname);
        con.Open();
        cmd.ExecuteNonQuery();
    }            
}

Answer 4

Es más o menos lo mismo que ejecutar una consulta. En su código original está creando un objeto de comando, colocándolo en la variable cmd , y nunca lo use. Aquí, sin embargo, usará eso en lugar de da.InsertCommand .

Además, use a para todos los objetos desechables, de modo que esté seguro de que están dispuestos correctamente:

private void button1_Click(object sender, EventArgs e) {
  using (SqlConnection con = new SqlConnection(dc.Con)) {
    using (SqlCommand cmd = new SqlCommand("sp_Add_contact", con)) {
      cmd.CommandType = CommandType.StoredProcedure;

      cmd.Parameters.Add("@FirstName", SqlDbType.VarChar).Value = txtFirstName.Text;
      cmd.Parameters.Add("@LastName", SqlDbType.VarChar).Value = txtLastName.Text;

      con.Open();
      cmd.ExecuteNonQuery();
    }
  }
}

Answer 5

Los proveedores de datos .NET consisten en una serie de clases utilizadas para conectarse a una fuente de datos, ejecutar comandos y devolver conjuntos de registros. El objeto de comando en ADO.NET proporciona una cantidad de métodos de ejecución que se pueden usar para realizar las consultas SQL en una variedad de formas.

Un procedimiento almacenado es un objeto ejecutable precompilado que contiene una o más sentencias SQL. En muchos casos, los procedimientos almacenados aceptan parámetros de entrada y devuelven valores múltiples. Los valores de los parámetros se pueden suministrar si se escribe un procedimiento almacenado para aceptarlos. A continuación, se muestra un procedimiento almacenado de muestra con el parámetro de entrada aceptado.

  CREATE PROCEDURE SPCOUNTRY
  @COUNTRY VARCHAR(20)
  AS
  SELECT PUB_NAME FROM publishers WHERE COUNTRY = @COUNTRY
  GO

El procedimiento almacenado anterior acepta un nombre de país (@COUNTRY VARCHAR (20)) como parámetro y devuelve todos los editores del país de entrada. Una vez que CommandType se establece en StoredProcedure, puede usar la colección Parameters para definir parámetros.

  command.CommandType = CommandType.StoredProcedure;
  param = new SqlParameter("@COUNTRY", "Germany");
  param.Direction = ParameterDirection.Input;
  param.DbType = DbType.String;
  command.Parameters.Add(param);

El código anterior pasa el parámetro de país al procedimiento almacenado desde la aplicación C #.

using System;
using System.Data;
using System.Windows.Forms;
using System.Data.SqlClient;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            string connetionString = null;
            SqlConnection connection ;
            SqlDataAdapter adapter ;
            SqlCommand command = new SqlCommand();
            SqlParameter param ;
            DataSet ds = new DataSet();

            int i = 0;

            connetionString = "Data Source=servername;Initial Catalog=PUBS;User ID=sa;Password=yourpassword";
            connection = new SqlConnection(connetionString);

            connection.Open();
            command.Connection = connection;
            command.CommandType = CommandType.StoredProcedure;
            command.CommandText = "SPCOUNTRY";

            param = new SqlParameter("@COUNTRY", "Germany");
            param.Direction = ParameterDirection.Input;
            param.DbType = DbType.String;
            command.Parameters.Add(param);

            adapter = new SqlDataAdapter(command);
            adapter.Fill(ds);

            for (i = 0; i <= ds.Tables[0].Rows.Count - 1; i++)
            {
                MessageBox.Show (ds.Tables[0].Rows[i][0].ToString ());
            }

            connection.Close();
        }
    }
}

Answer 6

cmd.Parameters.Add(String parameterName, Object value) está en desuso ahora. En su lugar, use cmd.Parameters.AddWithValue(String parameterName, Object value)

Agregar (String parameterName, Object value) ha quedado en desuso. Use AddWithValue (String parameterName, valor del objeto)

No hay diferencia en términos de funcionalidad. La razón por la que desaprobaron el cmd.Parameters.Add(String parameterName, Object value) a favor de AddWithValue(String parameterName, Object value) es para dar más claridad. Aquí está la referencia de MSDN para el mismo

private void button1_Click(object sender, EventArgs e) {
  using (SqlConnection con = new SqlConnection(dc.Con)) {
    using (SqlCommand cmd = new SqlCommand("sp_Add_contact", con)) {
      cmd.CommandType = CommandType.StoredProcedure;

      cmd.Parameters.AddWithValue("@FirstName", SqlDbType.VarChar).Value = txtFirstName.Text;
      cmd.Parameters.AddWithValue("@LastName", SqlDbType.VarChar).Value = txtLastName.Text;

      con.Open();
      cmd.ExecuteNonQuery();
    }
  }
}

Answer 7

public void myfunction(){
        try
        {
            sqlcon.Open();
            SqlCommand cmd = new SqlCommand("sp_laba", sqlcon);
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.ExecuteNonQuery();
        }
        catch(Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
        finally
        {
            sqlcon.Close();
        }
}