Inserir no banco

Question

Amigos, quando executo esse código:

public void INSERIR(Defeito def)
   {
      string sql = ("INSERT INTO Defeito(descriDefeito) VALUES (@descriDefeito)");
       SqlCommand cmd = new SqlCommand(sql);

       cmd.Parameters.AddWithValue("@descriDefeito", SqlDbType.VarChar).Value = def.NomeDefeito;
       Banco bd = new Banco();
       bd.atualiza(sql);

}

Aparece esse erro:

Must declare the scalar variable "@descriDefeito".

O que está errado?

Answer 1

Tente
cmd.Parameters.AddWithValue("@descriDefeito",  def.NomeDefeito);

Answer 2

mesmo erro.
Não funciona.

Só funciona se eu usar concatenação de strings 
string sql = ("INSERT INTO Defeito(descriDefeito) VALUES ('"+descriDefeito+"')");
mas sei que assim não é elegante. Quero fazer do jeito certo
Obrigado

Answer 3

Qual instrução esta no seu metodo bd.Atualiza(sql); aparentemente você não está usando o command, e no command que está o paramento @descriDefeito

Answer 4

namespace BancoAssistence
{
    public class Banco
    {
        // instanciando meu connection 
        private SqlConnection abreconexao()//sera criado um objeto chamado con do tipo OLEDB connection
        {
            SqlConnection con = new SqlConnection();
            con.ConnectionString = "Data Source=.\\SQLEXPRESS;AttachDbFilename=C:\\Banco_Assistence\\BDAssistence.mdf;Integrated Security=True;Connect Timeout=30;User Instance=True";
            con.Open();
            return con;// retorna o objeto con
        }

        //
        // será feito 4 componentes command, data adapter,datareader e connection ja criado acima
        // instanciando meu command 
        public void atualiza(string sql)// atualiza o banco e nao retorna nada
        {
            SqlCommand comando = new SqlCommand(sql, abreconexao());// criando objeto comando
            comando.ExecuteNonQuery();// insere atualiza
        }

        // instaciando datareader que recebe commad que das os comandos para ele ir ao banco e retornar
        public SqlDataReader consultadr(string sql)
        {
            SqlCommand comando = new SqlCommand(sql, abreconexao());
            return comando.ExecuteReader();
        }

        public DataTable consulta(string sql)
        {
            DataTable dt = new DataTable();
            SqlDataAdapter da = new SqlDataAdapter(sql, abreconexao());
            da.Fill(dt);// data adapter preencher o data table
            return dt;
        }
    }
}

Answer 5

Esta classe é perfeita.
Mas só está funcionando com concatenação de strings
Quero que funcione com passagem de parâmetros.

Answer 6

Answer 7

Você está declarando um novo SQlCommand por isso ele não está encontrando "@descrDefeito"

Answer 8

entendi
Agora contornei, instanciando apenas a s

namespace BancoAssistence
{
    public class BancoCmd
    {
        // instanciando minha string de conexão
        public String abreconexao()
        {  
            string con = "Data Source=.\\SQLEXPRESS;AttachDbFilename=C:\\Banco_Assistence\\BDAssistence.mdf;Integrated Security=True;Connect Timeout=30;User Instance=True";       
            return con;// retorna o objeto con
        }
    }
}

tring.

Answer 9

public void INSERIR(Defeito def)
        {


            BancoCmd bancoCmd = new BancoCmd();

            SqlConnection con = new SqlConnection(bancoCmd.abreconexao());

            string sql = ("INSERT INTO Defeito(descriDefeito) VALUES (@descriDefeito)"); ;

            SqlCommand cmd = new SqlCommand(sql, con);

            cmd.Parameters.AddWithValue("@descriDefeito", SqlDbType.VarChar).Value = def.NomeDefeito;

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

//assim funcionou perfeitamente

Answer 10

Você poderia ter atualizado o seu metodo atualiza para

 public void atualiza(string sql, params SqlParameter[] parameters)
        {
            Exception erro = null;

            try
            {               
                SqlCommand command = new SqlCommand(sql, abreconexao());               
                command.Parameters.AddRange(parameters); //adiciona os parametros
               comando.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
               //execption
            }
            finally
            {
                //fechar conexão com o banco
            }
        }

e chamaria dessa outra

 public void Inserir(Defeito def)
        {
            string query = "INSERT INTO Defeito(descriDefeito) VALUES (@descriDefeito)";
Banco bd = new Banco()
            bd.Atualiza(query,                            
                new SqlParameter("@descriDefeito", def.NomeDefeito));
        }

Não esqueça de marcar o topico como resolvido.

Answer 11

Como ficaria toda a minha classe banco?
Na verdade, eu quero usar uma classe banco com todas as operações
e depois só chamá-las

Answer 12

Guioday, boa tarde!

Crie uma classe com o nome acessa banco e add este fonte:

  /// <summary>
    /// Classe de conexão com banco de dados e executa os metodos de 
    /// executar e consultar informações da base de dados
    /// </summary>
    public class DbContext
    {
        #region Métodos Privados

        /// <summary>
        /// Método de conexão com banco de dados
        /// </summary>
        private SqlConnection _connection;

        /// <summary>
        /// Método de conexão com banco de dados
        /// </summary>
        /// <returns>Retorna a string de conexão</returns>
        private SqlConnection CreateConnection()
        {
            return _connection = new SqlConnection(ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString());
        }

        /// <summary>
        /// Paramentros que serão enviados ao banco
        /// </summary>
        private SqlParameterCollection _parameterCollection = new SqlCommand().Parameters;

        /// <summary>
        /// Criar comando que recebe o nome da procedure e os tipos
        /// </summary>
        /// <param name="commandType">Comandos</param>
        /// <param name="nomeProcedure">Nome da procedure</param>
        /// <returns>Retorna os comandos</returns>
        private SqlCommand CreateCommand(CommandType commandType, string procedure)
        {
            /* Criar conexão com banco de dados */
            _connection = this.CreateConnection();

            /* Abrir conexão */
            _connection.Open();

            /* Criar comando que vai enviar informações para o banco */
            SqlCommand _command = _connection.CreateCommand();

            /* Adicionar as informações dentro do comando que vai enviar para o banco */
            _command.CommandType = commandType;

            /* Recebe o nome da procedure que esta sendo executada */
            _command.CommandText = procedure;

            /* Defini o tempo que a conexão ficará aberta (Em Segundos [7200] = 2 horas) */
            _command.CommandTimeout = 7200;

            /* Adicionar os paramentros no comando */
            foreach (SqlParameter item in _parameterCollection)
            {
                /* Adicona o parametro e o valor */
                _command.Parameters.Add(new SqlParameter(item.ParameterName, item.Value));
            }

            /* Executar o comando, manda o comando ate o banco com as informações */
            return _command;
        }

        #endregion

        #region Métodos Publicos

        /// <summary>
        /// Método que limpa os parametros
        /// </summary>
        public void CleanParameter()
        {
            this._parameterCollection.Clear();
        }

        /// <summary>
        /// Método adicona paramentros dentro da coleção de paramentro
        /// </summary>
        /// <param name="parametro">recebe os parametros passado na procedure</param>
        /// <param name="valor">valor passado na procedure</param>
        public void AddParameter(string parameters, object value)
        {
            try
            {
                this._parameterCollection.Add(new SqlParameter(parameters, value));
            }
            catch (Exception exception)
            {
                throw new Exception(exception.ToString());
            }
        }

        /// <summary>
        /// Método executa persistencia no banco de dados (Inserir, Atualiza e Excluir)
        /// Método executa a manipulação da procedure no banco
        /// Usado para insert, delete e update
        /// </summary>
        /// <param name="commandType">é um enum</param>
        /// <param name="nomeProcedure">recebe o nome da procedure</param>
        /// <returns>retorna um objeto</returns>
        public object RunCommand(CommandType commandType, string procedure)
        {
            try
            {
                /* Recebe os paramentros en envia para o banco*/
                SqlCommand _command = this.CreateCommand(commandType, procedure);

                var retorno = _command.ExecuteScalar();

                /* Finaliza Conexão com banco de Dados */
                this._connection.Close();
                this._connection.Dispose();

                /* Executar o comando, manda o comando ate o banco com as informações */
                return retorno;
            }
            catch (Exception exception)
            {
                throw new Exception(exception.ToString());
            }
        }

        /// <summary>
        /// Método consulta informações na base de dados
        /// </summary>
        /// <param name="commandType">é um enum</param>
        /// <param name="nomeProcedure">recebe o nome da procedure</param>
        /// <returns>retorna um objeto</returns>
        public DataTable RunConsultation(CommandType commandType, string procedure)
        {
            try
            {
                /* Recebe os paramentros en envia para o banco*/
                SqlCommand _command = this.CreateCommand(commandType, procedure);

                /* Criar um adptador */
                var sqlDataAdapter = new SqlDataAdapter(_command);

                /* Criar datatable vasia aonde vou adicionar os valores que serão retornados do banco */
                var dataTable = new DataTable();

                /* Mandar comando ir ate o banco buscar os daods e o o adptador preencher a datatable */
                sqlDataAdapter.Fill(dataTable);

                /* Finaliza Conexão com banco de Dados */
                this._connection.Close();
                this._connection.Dispose();

                /* Retorna a tabela preenchida */
                return dataTable;
            }
            catch (Exception exception)
            {
                throw new Exception(exception.ToString());
            }
        }

        #endregion
    }

este cara vai solucionar seu problema.

Este é o modelo de como chamar os métodos.

        public List<AlunoEntity> GetAll()
        {
            try
            {
                /* Retorna uma lista */
                var retorno = new List<AlunoEntity>();

                /* Limpa os parametros */
                context.CleanParameter();

                /* Recebe os parametros para ser atualizados e o nome da procedure */
                var dataTable = context.RunConsultation(CommandType.StoredProcedure, "uspAlunoGetAll");

                /* O foreach varre o datarow e adiciona cada linha em uma lista ate acabar coleção */
                foreach (DataRow linha in dataTable.Rows)
                {
                    /* Adiciona as informações na entidade */
                    var obj = new AlunoEntity
                    {
                        CodigoPessoaAluno = Convert.ToInt32(linha["CodigoPessoa"]),
                        Nome = linha["Nome"].ToString(),
                        Conhecimento = linha["Conhecimento"].ToString(),
                        Descricao = linha["Descricao"].ToString(),
                        ResponsavelAlteracao = linha["ResponsavelAlteracao"].ToString(),
                        Curso = new CursoEntity
                        {
                            Nome = linha["Curso"].ToString()
                        }
                    };

                    var contato = new ContatoEntity
                    {
                        Email = linha["Email"].ToString(),
                        Facebook = linha["Facebook"].ToString(),
                        Telefone = linha["Telefone"].ToString(),
                    };

                    obj.Pessoa.Contato.Add(contato);

                    retorno.Add(obj);
                }

                /* Retorna uma lista */
                return retorno;
            }
            catch (Exception exception)
            {
                throw new Exception("Não foi possivel efetuar busca: " + exception.ToString());
            }
        }

  private string Insert(AlunoEntity entity)
        {
            /* Limpa os parametros */
            context.CleanParameter();

            /* Recebe os parametros para ser inseridos */
            context.AddParameter("@Nome", entity.Nome);
            context.AddParameter("@Email", entity.Pessoa.Contato.FirstOrDefault().Email);
            context.AddParameter("@Facebook", entity.Pessoa.Contato.FirstOrDefault().Facebook);
            context.AddParameter("@Telefone", entity.Pessoa.Contato.FirstOrDefault().Telefone);
            context.AddParameter("@Conhecimento", entity.Conhecimento);
            context.AddParameter("@Descricao", entity.Descricao);
            context.AddParameter("@ResponsavelAlteracao", entity.Nome);
            context.AddParameter("@Inscrito", entity.Inscrito);

            /* Recebe os parametros para ser inseridos e o nome da procedure */
            return context.RunCommand(CommandType.StoredProcedure, "uspAlunoInserir").ToString();
        }

        public ContatoEntity GetById(string value)
        {
            try
            {
                /* Retorna uma lista */
                var retorno = new ContatoEntity();

                /* Limpa os parametros */
                context.CleanParameter();

                /* Recebe os parametros para efetuar a pesquisa */
                context.AddParameter("@Email", value);

                /* Recebe os parametros para ser atualizados e o nome da procedure */
                var dataTable = context.RunConsultation(CommandType.StoredProcedure, "uspLogin");

                /* O foreach varre o datarow e adiciona cada linha em uma lista ate acabar coleção */
                foreach (DataRow linha in dataTable.Rows)
                {
                    /* Adiciona as informações na entidade */
                    retorno.Email = linha["Email"].ToString();
                }

                /* Retorna uma lista */
                return retorno;
            }
            catch (Exception exception)
            {
                throw new Exception("Não foi possivel efetuar busca: " + exception.ToString());
            }
        }

---

Att, André Côrte Analista desenvolvedor E-mail: [e-mail] Skype: corte.solutions

Answer 13

Muito obrigado
vou estudá-la
Obrigado mesmo
Abraços do Guioday

Answer 14

Pode adicionar estes dois métodos na class que informei acima e usa o text em vez de procedure.

  #region Usando text e não procedure

        /// <summary>
        ///  Método abre conexão e salva informaçõe no banco
        ///  Método utilizado quando for executar um insert delete ou update utilizando query no c#
        /// </summary>
        /// <param name="qry">recebe o tipo de query como insert delete ou update</param>
        /// <param name="command">recebe o command para executar</param>
        public static void ExecuteNonQuery(string qry, SqlCommand command)
        {
            try
            {
                var connection = new SqlConnection(Common.ConnectionString.Connection);
                connection.Open();
                command.Connection = connection;
                command.CommandType = System.Data.CommandType.Text;
                command.CommandText = qry;
                command.ExecuteNonQuery();
                connection.Close();
            }
            catch (Exception exception)
            {
                throw new Exception(exception.ToString());
            }
        }

        /// <summary> 
        ///  Método abre conexão e salva informaçõe no banco
        ///  Método utilizado quando for executar um insert delete ou update utilizando query no c#
        /// </summary>
        /// <param name="qry">recebe o tipo de query como insert delete ou update</param>
        /// <param name="command">recebe o command para executar</param>
        /// <returns>retorna um datareader</returns>
        public static SqlDataReader ExecuteReader(string qry, SqlCommand command)
        {
            try
            {
                var connection = new SqlConnection(Common.ConnectionString.Connection);
                connection.Open();
                command.Connection = connection;
                command.CommandText = qry;
                return command.ExecuteReader();
            }
            catch (Exception exception)
            {
                throw new Exception(exception.ToString());
            }
        }

        #endregion

---

Att, André Côrte Técnico de TI E-mail: [e-mail] Skype: andre.corte4 MSN: [e-mail]

Answer 15

Para um projeto aparti utilizando ADO utilizo essa classe para conexão não sei se vai se de ajuda, mas está bem legal.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Projeto
{
    public class DatabaseHelper
    {
        #region Propriedades

        public SqlConnection MyBdConnection { get; set; }
        public string NomeStringConexao { get; set; }
        
        #endregion

        #region Construtores

        public DatabaseHelper()
        {
            this.NomeStringConexao = "Data Source=.\\SQLEXPRESS;Initial Catalog=POS;Integrated Security=True";
            this.MyBdConnection = new SqlConnection(this.NomeStringConexao);
        }

        public DatabaseHelper(string nomeStringConexao)
        {
            this.NomeStringConexao = nomeStringConexao;
            this.MyBdConnection = new SqlConnection(this.NomeStringConexao);
        }

        #endregion

        #region Métodos Privados

        private string GetCorrectParameterName(string parameterName)
        {
            if (parameterName[0] != '@')
            {
                parameterName = "@" + parameterName;
            }
            return parameterName;
        }

        #endregion

        #region Métodos Públicos

        public static DatabaseHelper Create()
        {
            return new DatabaseHelper();
        }

        public static DatabaseHelper Create(string nomeStringConexao)
        {
            return new DatabaseHelper(nomeStringConexao);
        }

        public void OpenConnection()
        {
            if (this.MyBdConnection.State == System.Data.ConnectionState.Closed)
            {
                this.MyBdConnection.Open();

            }
        }

        public void CloseConection()
        {
            this.MyBdConnection.Close();

        }

        public SqlParameter BuildParameter(string nome, object valor, DbType tipo, int size)
        {
            SqlParameter parametro = new SqlParameter(this.GetCorrectParameterName(nome), valor);
            parametro.DbType = tipo;
            parametro.Size = size;
            return parametro;

        }

        public void BuildParameter(string nome, object valor, DbType tipo, int size, List<SqlParameter> listParametros)
        {
            SqlParameter parametro = this.BuildParameter(nome, valor, tipo, size);
            listParametros.Add(parametro);
        }

        public SqlParameter BuildOutPutParameter(string nome, DbType tipo, int size)
        {
            SqlParameter parametro = new SqlParameter();
            parametro.ParameterName = this.GetCorrectParameterName(nome);
            parametro.DbType = tipo;
            parametro.Size = size;
            parametro.Direction = ParameterDirection.Output;
            return parametro;
        }

        public void BuildOutPutParameter(string nome, DbType tipo, int size, List<SqlParameter> listParametros)
        {
            SqlParameter parametro = this.BuildOutPutParameter(nome, tipo, size);
            listParametros.Add(parametro);
        }

        public void ExecuteNonQuery(SqlCommand command)
        {
            command.ExecuteNonQuery();
        }

        public void ExecuteNonQuery(SqlCommand command, bool openConnection)
        {
            if (openConnection)
            {
                this.OpenConnection();

            }
            this.ExecuteNonQuery(command);
            if (openConnection)
            {
                this.CloseConection();
            }
        }

        public SqlDataReader ExecuteDataReader(string query, params SqlParameter[] parameters)
        {

            SqlCommand command = this.MyBdConnection.CreateCommand();
            command.CommandText = query;
            command.Parameters.AddRange(parameters);
            SqlDataReader reader = command.ExecuteReader();
            return reader;
        }

        public void ExecuteNonQuery(string query, params SqlParameter[] parameters)
        {
            Exception erro = null;

            try
            {
                this.OpenConnection();
                SqlCommand command = this.MyBdConnection.CreateCommand();
                command.CommandText = query;
                command.Parameters.AddRange(parameters);
                this.ExecuteNonQuery(command);
                this.CloseConection();

            }
            catch (Exception ex)
            {

                erro = ex;
            }
            finally
            {
                this.CloseConection();
            }
            if (erro != null)
            {
               //throw erro;
                Console.WriteLine("Algumas informações já estão cadastradas, tente novamente!");
               Console.ReadKey();
            }
        }

        public void ExecuteCommands(params SqlCommand[] commands)
        {
            Exception erro = null;
            SqlTransaction trans = null;
            try
            {
                this.MyBdConnection.Open();
                trans = this.MyBdConnection.BeginTransaction();
                for (int i = 0; i < commands.Length; i++)
                {
                    commands[i].Transaction = trans;
                    this.ExecuteNonQuery(commands[i]);

                }
                trans.Commit();
                this.MyBdConnection.Close();
            }
            catch (Exception ex)
            {

                trans.Rollback();
                erro = ex;
            }
            finally
            {
                this.MyBdConnection.Close(); 
            }
            if (erro != null)
            {
                throw erro; 
            }
        }
        #endregion
    }
}

Answer 16

Estou estudando ela aqui.
Não posso implementá-la em meu projeto ainda.
Vou ter que criar um novo projeto para testar as operações do banco.
Você se dedicou e eu fico muito agradecido.
Obrigado, amigo.

Abraços do  Guioday

Answer 17

Qualquer duvida é só entrar em contato.