Parametro Model

Question

Boa tarde senhores.

Senhores poderiam me ajudar em um dúvida. Gostaria de criar uma função com passagem de parâmetro uma model.

exemplo: public void GetDatas(MODEL TB_Banco, string nome, int id){}

Alguma sugestão??

Agradeço a atenção e desculpe pelo incomodo.

Answer 1

Não consegui entender teu problema, por um acaso seria enviar uma model por parâmetro e recuperar no método de destino? Enviar classes via parâmetro é como qualquer outro tipo de parâmetro

public void GetDatas(MODEL TB_Banco)
{
  string nome = TB_Banco.nome;
  int id = TB_Banco.id
}

Não entendi se você enviar para o banco ou recuperar do banco???

---

Gilson Joanelo - Desenvolvedor Web

Answer 2

Se estiver utilizando ASP.NET MVC basta adicionar o Model no seu parâmetro e passar as propriedades seja GET ou POST (por exemplo), com os mesmos nomes dos atributos. 

Ex: 

Model

public class MeuModelo {

 	public string Nome {get; set;}
	public int Idade {get; set;}
}

Controller:

public ActionResult ObterDados(MeuModelo modelo){
    return Content("Meu nome é " + modelo.Nome + ", tenho "+ modelo.Idade + "anos");
}

Quem faz todo esse trabalho é o Binder Default do MVC, pra isso os seus parâmetros passados pelo browser devem ter o mesmo nome dos atributos da sua classe modelo.

Answer 3

Bom dia Gilson.

Minha questão é a seguinte, tenho um banco mapeado com entityframework. Gostaria de uma função onde eu passaria qualquer tabela(model) para usar tratar.

public void GetDatas(Entities db){

var lista = db.ToList();

}

Algo semelhante a isto. Poderia retornar qualquer tabela.

Answer 4

Bom dia.

Minha questão é a seguinte, tenho um banco mapeado com entityframework. Gostaria de uma função onde eu passaria qualquer tabela(model) para usar tratar.

public void GetDatas(Entities db){

var lista = db.ToList();

}

Algo semelhante a isto. Poderia retornar qualquer tabela.

Answer 5

Utilizo o padrão Code First em meus mapeamentos, segue o meu modelo de código genérico para trabalhar com qualquer tabela

Classe Base

using System;
using System.ComponentModel.DataAnnotations.Schema;

namespace DataCempro.Persistencia.Base
{
    public class ModelBase
    {
        private DateTime fDataAlteracao;
        private DateTime fDataInclusao;

        public ModelBase()
        {
            fDataAlteracao = DateTime.MinValue;
            fDataInclusao = DateTime.MinValue;
        }

        public int ID { get; set; }

        public DateTime DataAlteracao
        {
            get { return fDataAlteracao; }
            set { fDataAlteracao = value; }
        }

        public DateTime DataInclusao
        {
            get { return fDataInclusao; }
            set { fDataInclusao = value; }
        }
    }
}

Classe de Contexto

using System;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using DataCempro.ClassLibraryUtil;
using DataCempro.Persistencia.Base;
using System.Data.SqlClient;
using DataCempro.Persistencia.Database.Entity.WebSharing;
using System.Data.Entity.ModelConfiguration.Conventions;

namespace DataCempro.Persistencia.Contexto
{
    public class WebSharingContext : DbContext
    {
        public static SqlConnection connection
        {
            get
            {
                var vConStr = new SqlConnectionStringBuilder(ConfiguracaoAmbiente.Instance.FuncoesBancoDados.RetornarStringConexao(NomeConexao.WebSharing));
                return new SqlConnection(vConStr.ToString());
            }
        }

        public WebSharingContext() : base(connection, true)
        {
            this.Configuration.LazyLoadingEnabled = true;
            //((IObjectContextAdapter)this).ObjectContext.SavingChanges += Persistencia.Util.Generator.WebSharingObjectContext_SavingChanges;
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Configurations.Add(new Site.SiteConfiguration());
            base.OnModelCreating(modelBuilder);
        }

        #region IDbContext Members

        public T Add<T>() where T : ModelBase
        {
            T vObjeto = Activator.CreateInstance<T>();
            return base.Set<T>().Add(vObjeto);
        }

        public T Add<T>(T entidade) where T : ModelBase
        {
            return base.Set<T>().Add(entidade);
        }

        public void Attach<T>(T entidade) where T : ModelBase
        {
            if (base.Entry(entidade).State == System.Data.Entity.EntityState.Detached)
            {
                base.Set<T>().Attach(entidade);
            }
            base.Entry<T>(entidade).State = System.Data.Entity.EntityState.Modified;
        }

        public void Delete<T>(T entidade) where T : ModelBase
        {
            if (base.Entry(entidade).State == System.Data.Entity.EntityState.Detached)
            {
                base.Set<T>().Attach(entidade);
            }
            base.Entry<T>(entidade).State = System.Data.Entity.EntityState.Deleted;
        }

        public T FindById<T>(int id) where T : ModelBase
        {
            return Set<T>().FirstOrDefault<T>(p => p.ID == id);
        }

        #endregion

        #region Override

        public new System.Linq.IQueryable<T> Set<T>() where T : ModelBase
        {
            return base.Set<T>();
        }

        public new bool SaveChanges()
        {
            return (base.SaveChanges() > 0);
        }

        #endregion
    }
}

Entidade e Configuration

using DataCempro.Persistencia.Base;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
using System.Data.Entity.ModelConfiguration;

namespace DataCempro.Persistencia.Database.Entity.WebSharing
{
    public partial class Site : ModelBase
    {
        #region	Campos privados

        private string fNome;

        private int? fSiteCategoriaID;

        private string fDescricao;

        private string fMetaDescription;

        private string fMetaKeyword;

        private bool fAtivo;

        private bool fExcluido;

        #endregion

        #region	Construtor

        public Site()
        {
            fNome = string.Empty;

            fSiteCategoriaID = null;
        }

        #endregion

        #region Propriedades

        public string Nome
        {
            get { return fNome; }
            set
            {
                if (value.IsValid() && value.TrimDTC().Length > 150)
                {
                    throw new ArgumentOutOfRangeException(String.Format("Valor nulo nao e permitido para Nome. MaxLength DB: 150. MaxLength recebido: {0}", value.TrimDTC().Length), value, value);
                }
                fNome = value;
            }
        }

        private int? SiteCategoriaID
        {
            get { return fSiteCategoriaID; }
            set { fSiteCategoriaID = value; }
        }

        [ForeignKey("SiteCategoriaID")]
        public virtual SiteCategoria SiteCategoria { get; set; }

        #endregion

        #region Configuration

        public class SiteConfiguration : EntityTypeConfiguration<Site>
        {
            public SiteConfiguration()
            {
                this.HasKey(p => p.ID);
                this.Property(p => p.ID).IsRequired();
                this.Property(p => p.Nome).HasMaxLength(80);
                this.Property(p => p.SiteCategoriaID);
                this.HasOptional<SiteCategoria>(p=>p.SiteCategoria).WithMany(t => t.Sites).WillCascadeOnDelete(false);
            }
        }

        #endregion
    }
}

Exemplo

public IEnumerable<Site> GetAll() 
{
	using(var Contexto = new WebSharingContext())
	{
		var list = Contexto.Set<Site>().ToList();
	}
}

public Site GetItem(int id) 
{
	using(var Contexto = new WebSharingContext())
	{
		var item = Contexto.FindById<Site>(ID);
	}
}

public bool Excluir() 
{
	using(var Contexto = new WebSharingContext())
	{
		var item = Contexto.FindById<Site>(ID);
		Contexto.Delete<Site>(item);
		return Contexto.SaveChanges();
	}
}

public bool Novo(Site item) 
{
	using(var Contexto = new WebSharingContext())
	{
		Contexto.Add<Site>(item);
		return Contexto.SaveChanges();
	}
}

public bool ModificarItem(Site item) 
{
	using(var Contexto = new WebSharingContext())
	{
		Contexto.Attach<Site>(item);
		return Contexto.SaveChanges();
	}
}

---

Gilson Joanelo - Desenvolvedor Web