none
Inserir no banco RRS feed

  • Pergunta

  • 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?

    sábado, 7 de março de 2015 20:36

Respostas

  • 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: andre.corte@cortesolutions.com.br Skype: corte.solutions



    domingo, 8 de março de 2015 21:07
  • 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: andre@cortecobol.com.br Skype: andre.corte4 MSN: andre.r.corte@hotmail.com

    • Marcado como Resposta Guioday sábado, 14 de março de 2015 13:19
    domingo, 8 de março de 2015 21:41
  • Qualquer duvida é só entrar em contato.
    • Marcado como Resposta Guioday domingo, 20 de agosto de 2017 19:19
    segunda-feira, 9 de março de 2015 00:29

Todas as Respostas

  • Tente

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

    sábado, 7 de março de 2015 22:08
  • 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

    • Editado Guioday domingo, 8 de março de 2015 11:57
    domingo, 8 de março de 2015 11:39
  • 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
    domingo, 8 de março de 2015 12:36
  • 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;
            }
        }
    }
    

    domingo, 8 de março de 2015 12:39
  • Esta classe é perfeita.
    Mas só está funcionando com concatenação de strings
    Quero que funcione com passagem de parâmetros.
    domingo, 8 de março de 2015 12:42
  • esta é a mensagem na minha classe banco
    domingo, 8 de março de 2015 12:54
  • Você está declarando um novo SQlCommand por isso ele não está encontrando "@descrDefeito"
    domingo, 8 de março de 2015 13:06
  • 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.
    domingo, 8 de março de 2015 13:58
  • 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

    domingo, 8 de março de 2015 14:00
  • 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.

    • Editado Alexsandro Bertoncini domingo, 8 de março de 2015 14:55 Melhoria na resposta
    • Marcado como Resposta Guioday domingo, 8 de março de 2015 17:17
    • Não Marcado como Resposta Guioday domingo, 8 de março de 2015 20:49
    domingo, 8 de março de 2015 14:20
  • 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
    domingo, 8 de março de 2015 20:43
  • 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: andre.corte@cortesolutions.com.br Skype: corte.solutions



    domingo, 8 de março de 2015 21:07
  • Muito obrigado
    vou estudá-la
    Obrigado mesmo
    Abraços do Guioday
    domingo, 8 de março de 2015 21:37
  • 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: andre@cortecobol.com.br Skype: andre.corte4 MSN: andre.r.corte@hotmail.com

    • Marcado como Resposta Guioday sábado, 14 de março de 2015 13:19
    domingo, 8 de março de 2015 21:41
  • 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
        }
    }


    • Marcado como Resposta Guioday domingo, 8 de março de 2015 23:15
    • Editado Alexsandro Bertoncini segunda-feira, 9 de março de 2015 00:30 Alteração no nome da estancia do banco
    • Não Marcado como Resposta Guioday sábado, 14 de março de 2015 13:20
    domingo, 8 de março de 2015 22:13
  • 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
    domingo, 8 de março de 2015 23:10
  • Qualquer duvida é só entrar em contato.
    • Marcado como Resposta Guioday domingo, 20 de agosto de 2017 19:19
    segunda-feira, 9 de março de 2015 00:29