How to select using LINQ with 2 tables?

Question

This is my select:

bd = new AcessoBancoDados();

bd.Conectar();
string cidade = "SELECT c.Nome FROM Cidade c join Estado e on c.EstadoId   = e.EstadoId WHERE  e.Sigla = '" + dto.Estado + "'";

dt = bd.RetornDataTable(cidade);

That in the register I select the state ai it filters in the bank all cities with id of the state that has the acronym selected, ai sends to Combobox the list of cities.

But now I’m wearing lambda, how do I do this research? I tried this way:

    private void cbxEstado_SelectedIndexChanged(object sender, EventArgs e)
        {
            cidBLL = new CidadeBLL();
            estBLL = new EstadoBLL();
            if (cbxEstado.SelectedIndex > -1)
            {
                cbxCidade.Enabled = true;
                int est;
                est =  Convert.ToInt32(cbxEstado.SelectedValue);
                cbxCidade.DataSource = cidBLL.Pesquisar_Cidade(est).ToList();
            }
        }


       namespace BLL
       {
       public class CidadeBLL
       {
        ICidadeRepositorio _cidadeRepositorio;
        public CidadeBLL()
        {
            _cidadeRepositorio = new CidadeRepositorio();
        }
        public List<CidadeDTO> Pesquisar_Cidade(int estadoID)
        {

            try
            {
                return _cidadeRepositorio.Get(c => c.estadoID == estadoID).ToList();

            }
            catch (Exception ex)
            {

                throw ex;
            }
        }

     }
     }

     namespace DAL.IRepositorio
     {
     public interface ICidadeRepositorio : IRepositorio<CidadeDTO>
    {
    }
    }

    namespace DAL.Repositorio
    {
    public class CidadeRepositorio : Repositorio<CidadeDTO>, ICidadeRepositorio
    {
    }
    }

    namespace DAL
    {
    public interface IRepositorio<T> where T : class
    {
        IQueryable<T> GetTodos();
        IQueryable<T> Get(Expression<Func<T, bool>> predicate);
        T Find(params object[] key);
        T First(Expression<Func<T, bool>> predicate);
        void Adicionar(T entity);
        void Atualizar(T entity);
        void Deletar(Func<T, bool> predicate);
        void Commit();
        void Dispose();
    }
    }

    namespace DAL
    {
    using System.Data.Entity;
    using System.Data.Entity.Infrastructure;
    using Model;

    public partial class NetunoEntities : DbContext
    {
        public NetunoEntities()
            : base("name=NetunoEntities")
        {
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            throw new UnintentionalCodeFirstException();
        }

        public virtual DbSet<AberturaCaixaDTO> AberturaCaixaDTOes { get; set; }
        public virtual DbSet<CategoriaDTO> CategoriaDTOes { get; set; }
        public virtual DbSet<CidadeDTO> CidadeDTOes { get; set; }
        public virtual DbSet<ClienteDTO> ClienteDTOes { get; set; }
        public virtual DbSet<ContaPagarDTO> ContaPagarDTOes { get; set; }
        public virtual DbSet<ContaReceberDTO> ContaReceberDTOes { get; set; }
        public virtual DbSet<ControleCompraDTO> ControleCompraDTOes { get; set; }
        public virtual DbSet<ControleVendaDTO> ControleVendaDTOes { get; set; }
        public virtual DbSet<CrediarioDTO> CrediarioDTOes { get; set; }
        public virtual DbSet<EmpresaDTO> EmpresaDTOes { get; set; }
        public virtual DbSet<EstadoDTO> EstadoDTOes { get; set; }
        public virtual DbSet<FechaCaixaDTO> FechaCaixaDTOes { get; set; }
        public virtual DbSet<FluxoCaixaDTO> FluxoCaixaDTOes { get; set; }
        public virtual DbSet<FormaPagDTO> FormaPagDTOes { get; set; }
        public virtual DbSet<FornecedorDTO> FornecedorDTOes { get; set; }
        public virtual DbSet<ItensVendaDTO> ItensVendaDTOes { get; set; }
        public virtual DbSet<MarcaDTO> MarcaDTOes { get; set; }
        public virtual DbSet<NaturezaOpeDTO> NaturezaOpeDTOes { get; set; }
        public virtual DbSet<NCMDTO> NCMDTOes { get; set; }
        public virtual DbSet<PlanoContaDTO> PlanoContaDTOes { get; set; }
        public virtual DbSet<ProdutoDTO> ProdutoDTOes { get; set; }
        public virtual DbSet<UnidadeMedidaDTO> UnidadeMedidaDTOes { get; set; }
        public virtual DbSet<UsuarioDTO> UsuarioDTOes { get; set; }
        public virtual DbSet<VendedorDTO> VendedorDTOes { get; set; }
     }
     }

     namespace DAL
     {
     public class Repositorio<T> : IRepositorio<T>, IDisposable where T : class
     {
        private NetunoEntities Context;

        protected Repositorio()
        {
            Context = new NetunoEntities();
        }

        public IQueryable<T> GetTodos()
        {
            return Context.Set<T>();
        }

        public IQueryable<T> Get(Expression<Func<T, bool>> predicate)
        {
            return Context.Set<T>().Where(predicate);
        }

        public T Find(params object[] key)
        {
            return Context.Set<T>().Find(key);
        }

        public T First(Expression<Func<T, bool>> predicate)
        {
            return Context.Set<T>().Where(predicate).FirstOrDefault();
        }

        public void Adicionar(T entity)
        {
            Context.Set<T>().Add(entity);
        }

        public void Atualizar(T entity)
        {
            Context.Entry(entity).State = EntityState.Modified;
        }

        public void Deletar(Func<T, bool> predicate)
        {
            Context.Set<T>()
           .Where(predicate).ToList()
           .ForEach(del => Context.Set<T>().Remove(del));
        }

        public void Commit()
        {
            Context.SaveChanges();
        }

        public void Dispose()
        {
            if (Context != null)
            {
                Context.Dispose();
            }
            GC.SuppressFinalize(this);
        }
    }
    }

    namespace Model
    {
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.ComponentModel.DataAnnotations.Schema;

    public partial class CidadeDTO
    {
        [Key]
        public int cidadeID { get; set; }
        public string nome { get; set; }
        public bool capital { get; set; }
        [ForeignKey("estadoID")]
        public int estadoID { get; set; }
        public virtual EstadoDTO EstadoDTOes { get; set; }
    }
    }                    
    namespace DAL.IRepositorio
{
    public interface IEstadoRepositorio : IRepositorio<EstadoDTO>
    {
    }
}
    namespace DAL.Repositorio
{
    public class EstadoRepositorio : Repositorio<EstadoDTO>, IEstadoRepositorio
    {
    }
}


   public partial class EstadoDTO
{
    [Key]
    public int estadoID { get; set; }
    public string sigla { get; set; }
    public virtual ICollection<CidadeDTO> CidadeDTOes { get; set; }
}

But returns the error;

Schema specified is not Valid. Errors: The Relationship 'Netunomodel.Statetocidadedto' was not Loaded because the type 'Netunomodel.Cidadedto' is not available. The following information may be Useful in resolving the Previous error: The required Property 'Estadodto' does not exist on the type 'Model.Cidadedto'.

ALREADY SOLVED Get(c => c.stateID == stateID). Tolist();

Answer 1

Have you ever tried using LINQ? would look something like this:

return _cidadeRepositorio.Where(c => c.estadoID == estadoID).ToList();

Or so:

return _cidadeRepositorio.Where(c => c.estadoID == EstadoID).ToFirst();

From what you posted about lambda it seems right, what you can do is add the property EstadoID the class CidadeDTO, for only in command of the lambda can’t find him.