Appeler une procédure stockée avec un paramètre en c #

Je peux faire une suppression, une insertion et une mise à jour dans mon programme et j'essaye de faire une insertion par appel d'une procédure stockée créée à partir de ma base de données.

C'est un insert de bouton que je fais bien fonctionner.

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

C'est le début du bouton pour appeler la procédure nommée sp_Add_contactpour ajouter un contact. Les deux paramètres pour sp_Add_contact(@FirstName,@LastName). J'ai cherché sur google un bon exemple mais je n'ai rien trouvé d'intéressant.

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

C'est à peu près la même chose que d'exécuter une requête. Dans votre code d'origine, vous créez un objet de commande, vous le placez dans la cmdvariable et ne l'utilisez jamais. Ici, cependant, vous utiliserez cela à la place de da.InsertCommand.

Utilisez également un usingpour tous les objets jetables, afin d'être sûr qu'ils sont correctement éliminés:

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();
    }
  }
}

Vous devez ajouter des paramètres car ils sont nécessaires pour que le SP s'exécute

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

cmd.Parameters.Add(String parameterName, Object value)est désormais obsolète. Utilisez plutôtcmd.Parameters.AddWithValue(String parameterName, Object value)

Add (String parameterName, Object value) est obsolète. Utiliser AddWithValue (String parameterName, Object value)

Il n'y a aucune différence en termes de fonctionnalité. La raison pour laquelle ils ont désapprouvé le cmd.Parameters.Add(String parameterName, Object value)en faveur de AddWithValue(String parameterName, Object value)est de donner plus de clarté. Voici la référence MSDN pour le même

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();
    }
  }
}

Comme alternative, j'ai une bibliothèque qui facilite le travail avec 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("StoredProcedureName");

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();
        }
}

Les fournisseurs de données .NET se composent d'un certain nombre de classes utilisées pour se connecter à une source de données, exécuter des commandes et renvoyer des jeux d'enregistrements. L'objet de commande dans ADO.NET fournit un certain nombre de méthodes Execute qui peuvent être utilisées pour effectuer les requêtes SQL de différentes manières.

Une procédure stockée est un objet exécutable précompilé qui contient une ou plusieurs instructions SQL. Dans de nombreux cas, les procédures stockées acceptent les paramètres d'entrée et renvoient plusieurs valeurs. Les valeurs de paramètre peuvent être fournies si une procédure stockée est écrite pour les accepter. Un exemple de procédure stockée avec acceptation du paramètre d'entrée est donné ci-dessous:

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

La procédure stockée ci-dessus accepte un nom de pays (@COUNTRY VARCHAR (20)) comme paramètre et renvoie tous les éditeurs du pays d'entrée. Une fois que CommandType est défini sur StoredProcedure, vous pouvez utiliser la collection Parameters pour définir des paramètres.

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

Le code ci-dessus transmet le paramètre de pays à la procédure stockée à partir de l'application 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();
        }
    }
}