C# Modelo类代码示例

 public AlterarLoginSenha(Modelo.Usuario usu)
 {
     InitializeComponent();
     SessionUser.nome = usu.Nome;
     Login_Usuario.Text = usu.Login;
     Senha_Usuario.Text = usu.Senha;
 }

 public void GetDisplayValues()
 {
     var list = new Marca().GetDisplayValues();
     list = new Modelo().GetDisplayValues();
     list = new AnoFabricacao().GetDisplayValues();
     WriteLine("Count = {0}", list.Values.Count);
 }

        public static IEnumerable<Modelo.Cliente.ModeloDependenteCliente> ListarDependenteCliente(Modelo.Cliente.ModeloCliente cliente, Func<Modelo.Cliente.ModeloDependenteCliente> criacaoDependenteCliente)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(Constantes.Procedures.Cliente.Dependente.ListarDependenteCliente,
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Dependente.IdCliente, cliente.Id)
                    );

                dynamic dados = objeto as dynamic;
                while (objeto.Reader.Read())
                {
                    Modelo.Cliente.ModeloDependenteCliente DependenteCliente = criacaoDependenteCliente();
                    DependenteCliente.Id = @dados.idClienteDependente;
                    DependenteCliente.Cliente = cliente;
                    DependenteCliente.GrauParentesco = Modelo.Comum.GrausParentesco.Lista.FirstOrDefault((g) => g.Id == @dados.parentesco);
                    DependenteCliente.Nome = @dados.nomeDependente;
                    DependenteCliente.IndCadastro = Convert.ToBoolean(@dados.indCadastro);
                    DependenteCliente.Observacao = @dados.observacao;
                    DependenteCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
                    yield return DependenteCliente;
                }
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

 public static void InserirContatoCliente(Modelo.Cliente.ModeloContatoCliente contatoCliente)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.Cliente.Contato.InserirContatoCliente,
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Contato.IdCliente, contatoCliente.Cliente.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Contato.TipoContato, contatoCliente.TipoContato),
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Contato.TextoContato, contatoCliente.Contato),
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Contato.Observacao, contatoCliente.Observacao)
         );
         dynamic dados = objeto as dynamic;
         objeto.Reader.Read();
         contatoCliente.Id = (int?)@dados.idContatoCliente;
         contatoCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

        /// <summary>Método que representa la llamada al procedure 'Documento_Cab_Actualizar'</summary>
        public int Actualizar(Modelo.Documento_Cab Item)
        {
            try
            {
                using (SqlConnection conexion = new SqlConnection(cadenaConexion))
                {
                    conexion.Open();
                    SqlCommand cmd = new SqlCommand("Documento_Cab_Actualizar @ccosto,@doc,@numero,@idPersona,@total,@usrMod,@fechaMod,@horaMod,@idEstado", conexion);
                    cmd.CommandType = CommandType.Text;

                    cmd.Parameters.AddWithValue("@ccosto", Item.ccosto);
                    cmd.Parameters.AddWithValue("@doc", Item.doc);
                    cmd.Parameters.AddWithValue("@numero", Item.numero);
                    cmd.Parameters.AddWithValue("@idPersona", Item.idPersona);
                    cmd.Parameters.AddWithValue("@total", Item.total);
                    cmd.Parameters.AddWithValue("@usrMod", Item.usrMod);
                    cmd.Parameters.AddWithValue("@fechaMod", Item.fechaMod);
                    cmd.Parameters.AddWithValue("@horaMod", Item.horaMod);
                    cmd.Parameters.AddWithValue("@idEstado", Item.idEstado);

                    int NumFila = cmd.ExecuteNonQuery();

                    return NumFila;
                }
            }
            catch (System.Exception)
            {
                throw;
            }
        }

 public static void InserirGrupoDiferencialCliente(Modelo.Cliente.ModeloGrupoDiferencialCliente grupoDiferencialCliente)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.Cliente.GrupoDiferencial.InserirGrupoDiferencialCliente,
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.GrupoDiferencial.IdCliente, grupoDiferencialCliente.Cliente.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.GrupoDiferencial.IdGrupoDiferencial, grupoDiferencialCliente.GrupoDiferencial.Id)
         );
         dynamic dados = objeto as dynamic;
         objeto.Reader.Read();
         grupoDiferencialCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

 public static void InserirRecorteProcesso(Modelo.Processo.ModeloRecorteProcesso recorteProcesso)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.Processo.Recorte.InserirRecorteProcesso,
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Recorte.IdProcesso, recorteProcesso.Processo.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Recorte.IdUsuario, recorteProcesso.UsuarioInclusao.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.Processo.Recorte.TextoRecorte, recorteProcesso.TextoRecorte)
         );
         dynamic dados = objeto as dynamic;
         objeto.Reader.Read();
         recorteProcesso.DataInclusao = @dados.dataInclusao;
         recorteProcesso.OrigemDados = Modelo.Comum.OrigemDados.Banco;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

 public static void AlterarTipoAcao(Modelo.Acao.ModeloTipoAcao tipoAcao)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(
             Constantes.Procedures.TipoAcao.AlterarTipoAcao,
             new KeyValuePair<string, object>(Constantes.Parametros.TipoAcao.IdAcao, tipoAcao.Id),
             new KeyValuePair<string, object>(Constantes.Parametros.TipoAcao.Descricao, tipoAcao.Descricao)
         );
         tipoAcao.OrigemDados = Modelo.Comum.OrigemDados.Banco;
         tipoAcao.Sujo = false;
     }
     catch (Exception ex)
     {
         throw ex;
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

        public static void InserirTipoAcao(Modelo.Acao.ModeloTipoAcao tipoAcao)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(
                    Constantes.Procedures.TipoAcao.InserirTipoAcao,
                    new KeyValuePair<string, object>(Constantes.Parametros.TipoAcao.Descricao, tipoAcao.Descricao)
                );

                dynamic dados = objeto as dynamic;
                objeto.Reader.Read();
                tipoAcao.Id = (int?)@dados.idAcao;
                tipoAcao.OrigemDados = Modelo.Comum.OrigemDados.Banco;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

        public static IEnumerable<Modelo.Cliente.ModeloProcessoCliente> ListarClienteProcesso(Modelo.Processo.ModeloProcesso processo, Func<Modelo.Cliente.ModeloProcessoCliente> criacaoProcessoCliente)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(Constantes.Procedures.Cliente.Processo.ListarProcessoCliente,
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Processo.IdProcesso, processo.Id),
                    new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Processo.IdCliente, null)
                    );

                dynamic dados = objeto as dynamic;
                while (objeto.Reader.Read())
                {
                    Modelo.Cliente.ModeloProcessoCliente processoCliente = criacaoProcessoCliente();
                    processoCliente.Cliente.Id = @dados.idCliente;
                    AcessoCliente.ObterCliente(processoCliente.Cliente);
                    processoCliente.Processo = processo;
                    processoCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
                    yield return processoCliente;
                }
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

 public static bool ObterClienteProcesso(Modelo.Cliente.ModeloProcessoCliente processoCliente)
 {
     ObjetoBanco objeto = null;
     try
     {
         objeto = ExecucaoProcedure.ExecutarQuery(Constantes.Procedures.Cliente.Processo.ListarProcessoCliente,
                             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Processo.IdProcesso, processoCliente.Processo.Id),
                             new KeyValuePair<string, object>(Constantes.Parametros.Cliente.Processo.IdCliente, processoCliente.Cliente.Id)
                             );
         if (objeto.Reader.Read())
         {
             processoCliente.OrigemDados = Modelo.Comum.OrigemDados.Banco;
             return true;
         }
         else {
             return false;
         }
     }
     finally
     {
         if (objeto != null)
         {
             objeto.Reader.Close();
         }
     }
 }

 public void Insert(Modelo.Clientes cliente)
 {
     SqlConnection conexao = new SqlConnection(strCon);
     string sql = "Insert into Clientes values (@idCidade, @nome, @telefone, @celular, @endereco, @cpf, @email)";
     SqlCommand cmd = new SqlCommand(sql, conexao);
     cmd.Parameters.AddWithValue("@idCidade", cliente.idCidade);
     cmd.Parameters.AddWithValue("@nome", cliente.nome);
     cmd.Parameters.AddWithValue("@telefone", cliente.telefone);
     cmd.Parameters.AddWithValue("@celular", cliente.celular);
     cmd.Parameters.AddWithValue("@endereco", cliente.endereco);
     cmd.Parameters.AddWithValue("@cpf", cliente.cpf);
     cmd.Parameters.AddWithValue("@email", cliente.email);
     conexao.Open();
     try
     {
         cmd.ExecuteNonQuery();
     }
     catch
     {
         Console.WriteLine("Deu erro na inserção de Cliente...");
     }
     finally
     {
         conexao.Close();
     }
 }

 public Servidor()
 {
     Modelo = new Modelo();
     Especificacion = new EspServidor();
     TipoServidor = new TipoServidor();
     Estatus = new Estatus();
 }

        public static void InserirAdvogado(Modelo.Advogado.ModeloAdvogado advogado)
        {
            ObjetoBanco objeto = null;
            try
            {
                objeto = ExecucaoProcedure.ExecutarQuery(
                    Constantes.Procedures.Advogado.InserirAdvogado,
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.OAB, advogado.Oab),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.CPF, advogado.Cpf),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.RG, advogado.Rg),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.Nome, advogado.Nome),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.IndEstagiario, advogado.IndicadorEstagiario),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.EstadoCivil, advogado.EstadoCivil),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.Naturalidade, advogado.Naturalidade),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.Nacionalidade, advogado.Nacionalidade),
                    new KeyValuePair<string, object>(Constantes.Parametros.Advogado.Sexo, advogado.Sexo)
                );

                dynamic dados = objeto as dynamic;
                objeto.Reader.Read();
                advogado.Id = (int?)@dados.idAdvogado;
                advogado.OrigemDados = OrigemDados.Banco;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (objeto != null)
                {
                    objeto.Reader.Close();
                }
            }
        }

        public void CadastrarItensVenda(Modelo.ItensVenda item)
        {
            FactoryConnection conn = new FactoryConnection();
            String query = "";
            try
            {
                if (item.IdProduto == 0)
                {
                    query = "insert into VendaProdutoServico (IdVenda, IdServico) values" +
                     "('" + item.IdVenda + "', '" + item.IdServico + "')";
                }
                if (item.IdServico == 0)
                {
                    query = "insert into VendaProdutoServico (IdVenda,  IdProduto) values" +
                        "('" + item.IdVenda + "', '" + item.IdProduto + "')";
                }

                SqlCommand comand = new SqlCommand(query, conn.AbrirConnexao());
                SqlDataReader reader = comand.ExecuteReader();

            }
            catch (Exception e)
            {
                MessageBox.Show("Não foi possível conectar-se ao banco de dados!");
            }
            finally
            {
                conn.FecharConnecxao();
            }
        }