C# Entidades类代码示例

        public void guardarVehiculo(Entidades.Vehiculo vehiculo)
        {
            SqlConnection conexion = new SqlConnection(cadenaConexion);
            conexion.Open();
            SqlCommand cmd = new SqlCommand("proc_Vehiculo", conexion);
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("@accion", "i");
            cmd.Parameters.AddWithValue("@Vehiculo_Placa", vehiculo.Vehiculo_Placa);
            cmd.Parameters.AddWithValue("@Parame_MarcaV", vehiculo.Parame_MarcaV);
            cmd.Parameters.AddWithValue("@Pardet_MarcaV", vehiculo.Pardet_MarcaV);
            cmd.Parameters.AddWithValue("@Parame_Modelo", vehiculo.Parame_Modelo);
            cmd.Parameters.AddWithValue("@Pardet_Modelo", vehiculo.Pardet_Modelo);
            cmd.Parameters.AddWithValue("@Parame_SubModelo", vehiculo.Parame_SubModelo);
            cmd.Parameters.AddWithValue("@Pardet_SubModelo", vehiculo.Pardet_SubModelo);
            cmd.Parameters.AddWithValue("@Vehiculo_Anio", vehiculo.Vehiculo_Anio);
            cmd.Parameters.AddWithValue("@Vehiculo_NoMotor", vehiculo.Vehiculo_NoMotor);
            cmd.Parameters.AddWithValue("@Vehiculo_Observacion", vehiculo.Vehiculo_Observacion);

            SqlDataAdapter sda = new SqlDataAdapter(cmd);
            try
            {
                cmd.ExecuteNonQuery();
                conexion.Close();
            }
            catch { throw; }
        }

        public override string guardar(Entidades.PlatosCartaPlatos platosCarta)
        {
            string mensaje = "";
            try
            {
                int cont = 0;
                OleDbConnection conexion = Entidades.Conexion.GetInstancia().crearConexion();

                OleDbCommand cmdUpdate = new OleDbCommand("Update CartaPlatoPlatos Set Activo = @activo Where IdCartaPlato = @idCartaPlato and IdPlato = @idPlato", conexion);
                cmdUpdate.Parameters.AddWithValue("@activo", platosCarta.Activo);
                cmdUpdate.Parameters.AddWithValue("@idCartaPlato", platosCarta.IdCartaPlato);
                cmdUpdate.Parameters.AddWithValue("@idProducto", platosCarta.IdPlato);
                cont = cmdUpdate.ExecuteNonQuery();
                mensaje = "Actualizado con exito.";
                if (cont == 0)
                {
                    OleDbCommand cmd = new OleDbCommand("Insert Into CartaPlatoPlatos(IdCartaPlato,IdPlato,Activo) Values(@idCartaPlato,@idPlato,@activo)", conexion);
                    cmd.Parameters.AddWithValue("@idCartaPlato", platosCarta.IdCartaPlato);
                    cmd.Parameters.AddWithValue("@idPlato", platosCarta.IdPlato);
                    cmd.Parameters.AddWithValue("@activo", platosCarta.Activo);
                    cmd.ExecuteNonQuery();
                    mensaje = "Guardado con exito.";
                }
            }
            catch (Exception ex)
            {
                mensaje = "Ocurrio un problema al guardar " + ex.Message;
            }

            return mensaje;
        }

        public string Excluir(Entidades.GrupoTrabalhoUsuario entidade)
        {
            try
            {
                Dados.LimparParametros();
                object objRetorno = null;
                if (entidade != null && entidade.Usuario != null && entidade.Usuario.IdUsuario > 0 &&
                    entidade.GrupoTrabalho != null && entidade.GrupoTrabalho.IdGrupoTrabalho > 0)
                {
                    Dados.AdicionarParametros("@vchAcao", "DELETAR");
                    Dados.AdicionarParametros("@intIdUsuario", entidade.Usuario.IdUsuario);
                    Dados.AdicionarParametros("@intIdGrupoTrabalho", entidade.GrupoTrabalho.IdGrupoTrabalho);

                    objRetorno = Dados.ExecutarManipulacao(CommandType.StoredProcedure, "spGrupoTrabalhoUsuario");
                }

                int intResultado = 0;
                if (objRetorno != null)
                {
                    if (int.TryParse(objRetorno.ToString(), out intResultado))
                        return intResultado.ToString();
                    else
                        throw new Exception(objRetorno.ToString());
                }
                else
                {
                    return "Não foi possível executar";
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void Abrir(Entidades.Mercadoria.Mercadoria mercadoria, Entidades.Acerto.ControleAcertoMercadorias acerto)
        {
            // Limpa a lista
            lista.Items.Clear();

            // Limpa a hash:
            hashListViewItemRastro = new Dictionary<ListViewItem, RastroItem>();

            // Obtém os dados do BD
            List<RastroItem> rastro =  acerto.ObterRastro(mercadoria);

            // Cria a lista 
            foreach (RastroItem itemRastro in rastro)
            {
                ListViewItem item = new ListViewItem(new String[lista.Columns.Count]);
                
                item.SubItems[colData.Index].Text = itemRastro.Data.ToLongDateString();
                item.SubItems[colDescrição.Index].Text = itemRastro.Descrição;
                item.SubItems[colDocumento.Index].Text = itemRastro.Documento;
                item.SubItems[colQuantidade.Index].Text = itemRastro.Quantidade.ToString();

                hashListViewItemRastro[item] = itemRastro;
                lista.Items.Add(item);
            }

            if (rastro.Count == 1)
                lista.Items[0].Selected = true;
        }

        public static List<Entidades.TipoArregloDisco> Obtener(Entidades.TipoArregloDisco a)
        {
            List<Entidades.TipoArregloDisco> lista = new List<Entidades.TipoArregloDisco>();
            try
            {
                using (ISession session = NHibernateHelper.OpenSession())
                {
                    //Option
                    ICriteria crit = session.CreateCriteria(typeof(Entidades.TipoArregloDisco));
                    if (a.IdTipoArreglo != 0 && a.IdTipoArreglo.ToString() != "")
                        crit.Add(Restrictions.Eq("IdTipoArreglo", a.IdTipoArreglo));
                   if (!string.IsNullOrEmpty(a.Tipo))
                        crit.Add(Restrictions.Like("Tipo", a.Tipo));
                    if (!string.IsNullOrEmpty(a.Descripcion))
                        crit.Add(Restrictions.Like("Descripcion", a.Descripcion));

                    crit.AddOrder(Order.Asc("Tipo"));

                    lista = (List<Entidades.TipoArregloDisco>)crit.List<Entidades.TipoArregloDisco>();
                }
            }
            catch
            {
                return lista;
            }

            return lista;
        }

        public static List<Entidades.ConceptoEstatus> Obtener(Entidades.ConceptoEstatus a)
        {
            List<Entidades.ConceptoEstatus> lista = new List<Entidades.ConceptoEstatus>();
            try
            {
                using (ISession session = NHibernateHelper.OpenSession())
                {
                    //Option
                    ICriteria crit = session.CreateCriteria(typeof(Entidades.ConceptoEstatus));
                    if (a.IdConceptoEstatus != 0 && a.IdConceptoEstatus.ToString() != "")
                        crit.Add(Restrictions.Eq("IdConceptoEstatus", a.IdConceptoEstatus));
                   if (!string.IsNullOrEmpty(a.Concepto))
                        crit.Add(Restrictions.Like("Concepto", a.Concepto));

                    crit.AddOrder(Order.Asc("Concepto"));

                    lista = (List<Entidades.ConceptoEstatus>)crit.List<Entidades.ConceptoEstatus>();
                }
            }
            catch
            {
                return lista;
            }

            return lista;
        }

        public BalãoMercadoriaInconsistente(Entidades.Mercadoria.Mercadoria mercadoria)
        {
            InitializeComponent();

            lblRef.Text = mercadoria.Referência;
            lblPeso.Text = mercadoria.PesoFormatado;
        }

        public int SP_SALVAR_PROGRAMAENGATE(Entidades.ProgramaEngate entidade)
        {
            int Codigo = 0;
            Queue<SqlParameter> qParameters = null;
            Database db = null;
            try
            {
                db = new Database();
                CreateParameters(ref qParameters,
                        new Property() { NomeCampo = "CodigoPrograma", Value = entidade.CodigoPrograma },
                        new Property() { NomeCampo = "Data", Value = entidade.Data },
                        new Property() { NomeCampo = "TipoEngate", Value = entidade.TipoEngate },
                       new Property() { NomeCampo = "UserID", Value = "Teste" }
                       // new Property() { NomeCampo = "UserID", Value = entidade.UserID }
                    );

                Codigo = db.ExecuteNonQuery("SP_SALVAR_PROGRAMAENGATE", ref qParameters);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (qParameters != null)
                    GC.SuppressFinalize(qParameters);
                if (db != null)
                    db.Dispose();
            }
            return Codigo;
        }

        public int SP_SALVAR_PROGRAMA(Entidades.Programa entidade)
        {
            int Codigo = 0;
            Queue<SqlParameter> qParameter = null;
            Database db = null;
            try
            {
                db = new Database();

                CreateParameters(ref qParameter,
                    new References.DAL.Property() { NomeCampo = "Codigo", Value = entidade.Codigo, Direction = ParameterDirection.Output },
                    new References.DAL.Property() { NomeCampo = "NomePrograma", Value = entidade.NomePrograma },
                    new References.DAL.Property() { NomeCampo = "Descricao", Value = entidade.Descricao },
                    new References.DAL.Property() { NomeCampo = "Ativo", Value = entidade.Ativo }
                );

                Codigo = db.ExecuteNonQuery("[dbo].[SP_SALVAR_PROGRAMA]", ref qParameter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (qParameter != null)
                    GC.SuppressFinalize(qParameter);
                if (db != null)
                    db.Dispose();
            }
            return Codigo;
        }

        public static List<Entidades.MarcaServidor> ObtenerMarcaServidor(Entidades.MarcaServidor ms)
        {
            List<Entidades.MarcaServidor> lista = new List<Entidades.MarcaServidor>();
            try
            {
                using (ISession session = NHibernateHelper.OpenSession())
                {
                    //Option
                    ICriteria crit = session.CreateCriteria(typeof(Entidades.MarcaServidor));
                    if (ms.IdMarca != 0 && ms.IdMarca.ToString() != "")
                        crit.Add(Restrictions.Eq("IdMarcas", ms.IdMarca));
                    if (!string.IsNullOrEmpty(ms.NombreMarca))
                        crit.Add(Restrictions.Like("NombreMarca", ms.NombreMarca));

                    crit.AddOrder(Order.Asc("NombreMarca"));

                    lista = (List<Entidades.MarcaServidor>)crit.List<Entidades.MarcaServidor>();
                }
            }
            catch
            {
                return lista;
            }

            return lista;
        }

 private void Copiar(DataRow Desde, Entidades.ReporteActividad Hasta)
 {
     Hasta.DescrEntidad = Convert.ToString(Desde["DescrEntidad"]);
     Hasta.Evento = Convert.ToString(Desde["Evento"]);
     Hasta.Estado = Convert.ToString(Desde["Estado"]);
     Hasta.Cantidad = Convert.ToInt32(Desde["Cantidad"]);
 }

        public static string editar(Entidades.Pieza pieza)
        {
            string retorno = "";
            try
            {
                var sql =
                    from c in db.Pieza
                    where c.pie_codigo == pieza.Codigo
                    select c;

                foreach (var s in sql)
                {
                    s.pie_baja = pieza.Baja;
                    s.pie_cantidad = pieza.Cantidad;
                    s.pie_codigo = pieza.Codigo;
                    s.pie_costo = Convert.ToDecimal(pieza.Costo);
                    s.pie_modelo = pieza.Modelo;
                    s.pie_tipo = pieza.Tipo;
                    db.SubmitChanges();
                    retorno = "exito";
                }
            }
            catch (Exception e)
            {
                retorno = e.Message;
            }
            return retorno;
        }

        public void AlmacenaPlantilla(Entidades.PlantillaEstadoCuenta plantilla)
        {
            string mensajeError = string.Empty;
            bool resultado = false;

            try
            {
                using (DaoEstadoCuenta daoEstadoCuenta = new DaoEstadoCuenta())
                {
                    daoEstadoCuenta.BaseDatos = "InformacionEstadoCuenta";
                    daoEstadoCuenta.Servidor = "http://Localhost:9090";

                    resultado = daoEstadoCuenta.InsertarEstadoCuenta(plantilla, out mensajeError);
                }
            }
            catch (ExcepcionDatosEstadoCuenta excepcion)
            {
                throw excepcion;
            }
            catch (Exception excepcion)
            {
                StringBuilder mensaje = new StringBuilder();
                mensaje.Append("Se presentó un error no controlado en la clase AlmacenaPlantilla ");
                mensaje.Append(" en el mètodo AlmacenaPlantilla(). Detalle del error: ");
                mensaje.Append(excepcion.Message);

                throw new ExcepcionLogicaEstadoCuenta(mensajeError.ToString(), excepcion);
            }
        }

        public static void Imprimir(Entidades.Álbum.Álbum álbum, ItensImpressão itens)
        {
            using (PrintDocument documento = new PrintDocument())
            {
                documento.DocumentName = "Álbum " + álbum.Nome;

                using (PrintDialog dlg = new PrintDialog())
                {
                    dlg.AllowCurrentPage = false;
                    dlg.AllowSelection = false;
                    dlg.AllowSomePages = true;
                    dlg.UseEXDialog = true;
                    dlg.Document = documento;

                    if (dlg.ShowDialog() == DialogResult.OK)
                    {
                        ControleImpressão ctrl = new ControleImpressão(álbum, itens);

                        ctrl.página = new Página(
                                documento.PrinterSettings.DefaultPageSettings.PrintableArea.Width / 100f,
                                documento.PrinterSettings.DefaultPageSettings.PrintableArea.Height / 100f,
                                4, 5);
            
                        ctrl.daPágina = dlg.PrinterSettings.FromPage;
                        ctrl.atéPágina = dlg.PrinterSettings.ToPage != 0 ?
                            dlg.PrinterSettings.ToPage : int.MaxValue;

                        documento.PrintPage += new PrintPageEventHandler(ctrl.ImprimirPágina);
                        documento.Print();
                    }
                }
            }
        }

        public ClienteDívida(Entidades.Pessoa.Pessoa cliente)
        {
            InitializeComponent();
            this.cliente = cliente;

            Carregar();
        }