I can not search the repository with Nhibernate C #

I'm new as a programmer, sorry if I can not explain clearly, but please tell me what I did wrong and if possible how to do better, I want to improve as a programmer and user here in StackOverflow I'm trying to create a criteria to be able to fetch some specific information from my database, we're using the default MVC and Nhibernate, Spring and I'm getting the following error:

  

Spring.Data.NHibernate.HibernateSystemException: 'Unable to perform   find [SQL: SQL not available]

With two exceptions:

  

1: ArgumentException: The value   "SGB.Services.Spec.DataTransferObjects.DTOCCompositeBeneficiary"   is not of the type "SGB.Domain.Entities.CompositoBeneficioBeneficiario" and   can not be used in this generic collection.

     

2: GenericADOException: Unable to perform find

Repository:

public DTOComposicaoBeneficioBeneficiario ObterBeneficioBeneficiarioOperadora(string codigoOperadora)
        {
            var criteria = DetachedCriteria.For<ComposicaoBeneficioBeneficiario>("cbb")
                .CreateCriteria("cbb.composicaoBeneficio", "cb", JoinType.InnerJoin);

            criteria
              .Add(Restrictions.Eq("cbb.identificadorOperadora", codigoOperadora));

            criteria.SetProjection(Projections.ProjectionList()
            .Add(Projections.Property("cbb.codigo").As("Codigo"))
            .Add(Projections.Property("cbb.identificadorOperadora").As("IdentificadorOperadora"))
            .Add(Projections.Property("cbb.nome").As("Nome"))
            .Add(Projections.Property("cbb.dependente").As("CodigoDependente"))
            .Add(Projections.Property("cbb.valorTotal").As("ValorTotal"))
            .Add(Projections.Property("cbb.valorFolha").As("ValorFolha"))
            .Add(Projections.Property("cb.codigo").As("CodigoComposicaoBeneficio")));

            criteria.SetResultTransformer(new NHibernate.Transform.AliasToBeanResultTransformer(typeof(DTOComposicaoBeneficioBeneficiario)));

            return List<ComposicaoBeneficioBeneficiario>(criteria).FirstOrDefault().Transform<DTOComposicaoBeneficioBeneficiario>();
        } 

DTO:

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.ComponentModel.DataAnnotations;
using SGB.Common;
using SQFramework.Core.Reflection;

namespace SGB.Services.Spec.DataTransferObjects
{
    [DataContract()]
    [Serializable()]
    public class DTOComposicaoBeneficioBeneficiario
    {
        [DataMember(), Key(), Required()]
        public int Codigo { get; set; }

        [DataMember()]
        public string Nome { get; set; }

        [DataMember()]
        public string IdentificadorOperadora { get; set; }

        [DataMember]
        public DateTime DataNascimento { get; set; }

        [DataMember()]
        public string FaixaEtaria { get; set; }

        [DataMember()]
        public int CodigoFaixaEtaria { get; set; }

        [DataMember()]
        public virtual int? CodigoDependente { get; set; }

        [DataMember(), Map("ComposicaoBeneficio.Codigo"), Required()]
        public int CodigoComposicaoBeneficio { get; set; }

        [DataMember(), Map("TipoAcomodacaoBeneficio.Codigo"), Required()]
        public int CodigoTipoAcomodacaoBeneficio { get; set; }

        [DataMember(), Required()]
        public int CodigoTipoAcomodacao { get; set; }

        [DataMember(), Required()]
        public List<DTOPlanoAdicionalComposicaoBeneficioBeneficiario> PlanoAdicionalComposicaoBeneficioBeneficiario { get; set; }

        [DataMember(), Required()]
        public List<DTOPlanoAdicionalBeneficio> PlanoAdicionalBeneficio { get; set; }

        [DataMember(), Required()]
        public List<DTOItensPrecoBeneficiario> ItensPrecoBeneficiario { get; set; }

        #region [ VALORES ]

        [DataMember(), Required()]
        public decimal ValorTotal { get; set; }

        [DataMember()]
        public string ValorTotalFormatado { get => ValorTotal > 0 ? ValorTotal.ToString("C2") : "0,00"; set { } }

        [DataMember]
        public decimal ValorPacote { get; set; }

        [DataMember]
        public string ValorPacoteFormatado { get => ValorPacote > 0 ? ValorPacote.ToString("C2") : "0,00"; set { } }

        [DataMember]
        public decimal ValorFolha { get; set; }

        [DataMember]
        public string ValorFolhaFormatado { get => ValorFolha > 0 ? ValorFolha.ToString("C2") : "0,00"; set { } }

        [DataMember()]
        public decimal? ValorPlano { get; set; }

        [DataMember]
        public string ValorPlanoFormatado { get => ValorPlano.HasValue && ValorPlano > 0 ? ValorPlano.Value.ToString("C2") : "0,00"; set { } }

        [DataMember]
        public decimal ValorColaborador { get; set; }

        [DataMember]
        public string ValorColaboradorFormatado { get => ValorColaborador > 0 ? ValorColaborador.ToString("C2") : "0,00"; set { } }

        [DataMember]
        public decimal ValorEmpresa { get; set; }

        [DataMember]
        public string ValorEmpresaFormatado { get => ValorEmpresa > 0 ? ValorEmpresa.ToString("C2") : "0,00"; set { } }

        #endregion

        [DataMember()]
        public FormaDesconto FormaDesconto { get; set; }

        [DataMember]
        public int NumeroDependente { get; set; }

        [DataMember(), Required()]
        public bool Optante { get; set; }

        [DataMember(), Required()]
        public bool Titular { get; set; }

        [DataMember(), Required()]
        public List<DTOFaturaBeneficiario> faturaBeneficiario { get; set; }
    }
}

Entities:

using System;
using SQFramework.Spring.Domain;
using SGB.Integration.Spec;
using System.Collections.Generic;
using SGB.Common;
using SGB.Services.Spec.DataTransferObjects;
using SQFramework.Core;

namespace SGB.Domain.Entities
{
    public partial class ComposicaoBeneficioBeneficiario : DomainBase<ComposicaoBeneficioBeneficiario, IComposicaoBeneficioBeneficiarioRepository<ComposicaoBeneficioBeneficiario>>
    {
        public ComposicaoBeneficioBeneficiario()
        {
        }

        public ComposicaoBeneficioBeneficiario(ComposicaoBeneficio composicaoBeneficio)
        {
            SetComposicaoBeneficio(composicaoBeneficio);
        }

        protected int codigo;
        protected string nome;
        protected DateTime dataNascimento;
        protected string identificadorOperadora;
        protected decimal valorPacote;
        protected decimal valorFolha;
        protected decimal valorTotal;
        protected bool titular;
        protected bool optante;
        protected int? dependente;
        protected FormaDesconto formaDesconto;
        protected IList<PlanoAdicionalComposicaoBeneficioBeneficiario> planoAdicionalComposicaoBeneficioBeneficiario;
        protected ComposicaoBeneficio composicaoBeneficio;
        protected TipoAcomodacaoBeneficio tipoAcomodacaoBeneficio;
        protected IList<ItensPrecoBeneficiario> itensPrecoBeneficiarios;
        protected IList<FaturaBeneficiario> faturaBeneficiario;

        public virtual int Codigo { get => codigo; set { } }
        public virtual string Nome { get => nome; set => nome = value; }
        public virtual DateTime DataNascimento { get => dataNascimento; set => dataNascimento = value; }
        public virtual string IdentificadorOperadora { get => identificadorOperadora; set => identificadorOperadora = value; }
        public virtual decimal ValorPacote { get => valorPacote; set => valorPacote = value; }
        public virtual decimal ValorFolha { get => valorFolha; set => valorFolha = value; }
        public virtual decimal ValorTotal { get => valorTotal; set => valorTotal = value; }
        public virtual bool Titular { get => titular; set => titular = value; }
        public virtual bool Optante { get => optante; set => optante = value; }
        public virtual int? CodigoDependente { get => dependente; set => dependente = value; }
        public virtual FormaDesconto FormaDesconto { get => formaDesconto; set => formaDesconto = value; }
        public virtual IList<PlanoAdicionalComposicaoBeneficioBeneficiario> PlanoAdicionalComposicaoBeneficioBeneficiario => (planoAdicionalComposicaoBeneficioBeneficiario ?? (planoAdicionalComposicaoBeneficioBeneficiario = new List<PlanoAdicionalComposicaoBeneficioBeneficiario>()));
        public virtual ComposicaoBeneficio ComposicaoBeneficio => composicaoBeneficio;
        public virtual TipoAcomodacaoBeneficio TipoAcomodacaoBeneficio { get => tipoAcomodacaoBeneficio; set => tipoAcomodacaoBeneficio = value; }
        public virtual IList<ItensPrecoBeneficiario> ItensPrecoBeneficiarios => (itensPrecoBeneficiarios ?? (itensPrecoBeneficiarios = new List<ItensPrecoBeneficiario>()));
        public virtual IList<FaturaBeneficiario> FaturaBeneficiario => (faturaBeneficiario ?? (faturaBeneficiario = new List<FaturaBeneficiario>()));

        public virtual void SetComposicaoBeneficio(ComposicaoBeneficio composicaoBeneficio)
        {
            this.composicaoBeneficio = composicaoBeneficio;
        }

        public virtual void SetTipoAcomodacaoBeneficio(TipoAcomodacaoBeneficio tipoAcomodacaoBeneficio)
        {
            this.tipoAcomodacaoBeneficio = tipoAcomodacaoBeneficio;
        }

        public virtual int SalvarComposicaoBeneficioBeneficiario()
        {
            Save();
            return codigo;
        }

        public virtual DTOComposicaoBeneficioBeneficiario ObterOperadora(string codigoOperadora)
        {
            var composicaoBeneficiarios = GetRepository().ListAll();
            ComposicaoBeneficioBeneficiario composicaoDesejada = new ComposicaoBeneficioBeneficiario();

            foreach (var composicao in composicaoBeneficiarios)
            {
                if (composicao.IdentificadorOperadora == codigoOperadora)
                {
                    composicaoDesejada = composicao;
                    break;
                }
            }

            return composicaoDesejada.Transform<DTOComposicaoBeneficioBeneficiario>();
        }

    }
}


using SGB.Common;
using SGB.Common.Resources;
using SGB.Integration.Spec;
using SQFramework.Spring.Domain;
using System;
using System.Collections.Generic;


namespace SGB.Domain.Entities
{
    public partial class ComposicaoBeneficio : DomainBase<ComposicaoBeneficio, IComposicaoBeneficioRepository<ComposicaoBeneficio>>
    {
        public ComposicaoBeneficio()
        {
        }

        public ComposicaoBeneficio(Beneficio beneficio, Colaborador colaborador)
        {
            SetBeneficio(beneficio);
            SetColaborador(colaborador);
        }

        protected int codigo;
        protected decimal valorPacote;
        protected decimal valorFolha;
        protected decimal valorTotal;
        protected bool ativo;
        protected Beneficio beneficio;
        protected Colaborador colaborador;
        protected IList<Lancamento> lancamentos;
        protected IList<Historico> historico;
        protected IList<FechamentoBeneficioColaborador> fechamentoBeneficioColaborador;
        protected IList<ComposicaoBeneficioBeneficiario> composicaoBeneficioBeneficiarios;

        public virtual int Codigo { get => codigo; set { } }
        public virtual decimal ValorPacote => valorPacote;
        public virtual decimal ValorFolha => valorFolha;
        public virtual decimal ValorTotal => valorTotal;
        public virtual bool Ativo => ativo;
        public virtual Beneficio Beneficio => beneficio;
        public virtual Colaborador Colaborador => colaborador;
        public virtual IList<Lancamento> Lancamentos => (lancamentos ?? (lancamentos = new List<Lancamento>()));
        public virtual IList<Historico> Historico => (historico ?? (historico = new List<Historico>()));
        public virtual IList<FechamentoBeneficioColaborador> FechamentoBeneficioColaborador => (fechamentoBeneficioColaborador ?? (fechamentoBeneficioColaborador = new List<FechamentoBeneficioColaborador>()));
        public virtual IList<ComposicaoBeneficioBeneficiario> ComposicaoBeneficioBeneficiarios => (composicaoBeneficioBeneficiarios ?? (composicaoBeneficioBeneficiarios = new List<ComposicaoBeneficioBeneficiario>()));

        public virtual void SetBeneficio(Beneficio pBeneficio) => beneficio = pBeneficio;
        public virtual void SetColaborador(Colaborador pColaborador) => colaborador = pColaborador;
        public virtual void SetValorFolha(decimal pValorFolha) => valorFolha = pValorFolha;
        public virtual void SetValorPacote(decimal pValorPacote) => valorPacote = pValorPacote;
        public virtual void SetValorTotal(decimal pValorTotal) => valorTotal = pValorTotal;
        public virtual void SetAtivo(bool pAtivo) => ativo = pAtivo;

        public virtual void RegistraHistorico(TipoHistorico tipoHistorico, decimal valorPacoteAnterior, decimal valorFolhaAnterior, decimal valorTotalAnterior, decimal valorPacoteAtual, decimal valorFolhaAtual, decimal valorTotalAtual, Reajuste reajuste, string loginResponsavel, string observacao)
        {
            var itemHistorico = new Historico(this)
            {
                Data = DateTime.Now,
                Tipo = tipoHistorico,
                ValorPacoteAnterior = valorPacoteAnterior,
                ValorFolhaAnterior = valorFolhaAnterior,
                ValorTotalAnterior = valorTotalAnterior,
                ValorPacoteAtual = valorPacoteAtual,
                ValorFolhaAtual = valorFolhaAtual,
                ValorTotalAtual = valorTotalAtual,

                LoginResponsavel = loginResponsavel,
                Observacao = observacao

            };

            if (reajuste != null)
            {
                itemHistorico.SetReajuste(reajuste);
            }

            if (valorPacoteAnterior != valorPacoteAtual || valorPacoteAnterior != valorFolhaAtual)
            {
                Historico.Add(itemHistorico);
            }
        }

        public virtual void ReativaComposicao(decimal novoValorPacote, decimal novoValorFolha, decimal novoValorTotal, string loginResponsavel, string observacao)
        {
            RegistraHistorico(TipoHistorico.Ativação, ValorPacote, ValorFolha, ValorTotal, novoValorPacote, novoValorFolha, novoValorTotal, null, loginResponsavel, observacao);
            ativo = true;
            valorPacote = novoValorPacote;
            valorFolha = novoValorFolha;
        }

        public virtual void AtivaComposicao(decimal novoValorPacote, decimal novoValorFolha, decimal novoValorTotal, string loginResponsavel, string observacao)
        {
            RegistraHistorico(TipoHistorico.Ativação, 0, 0, 0, novoValorPacote, novoValorFolha, novoValorTotal, null, loginResponsavel, observacao);
            ativo = true;
            this.valorPacote = novoValorPacote;
            this.valorFolha = novoValorFolha;
        }

        public virtual void InativaComposicao(string loginResponsavel, string observacao)
        {
            if (!Ativo)
            {
                throw new ArgumentException(SpecificMessageResource.MSES03);
            }

            RegistraHistorico(TipoHistorico.Desativação, ValorPacote, ValorFolha, ValorTotal, 0, 0, 0, null, loginResponsavel, observacao);
            ativo = false;
            this.valorPacote = 0;
            this.valorFolha = 0;

            Save();
        }

        public virtual void AlterarValorComposicao(decimal novoValorPacote, decimal novoValorFolha, decimal novoValorTotal, string loginResponsavel, string observacao)
        {
            if (novoValorPacote == ValorPacote && novoValorFolha == ValorFolha)
            {
                return;
            }

            if (!beneficio.Disponivel)
            {
                throw new ArgumentException(GenericMessageResource.MSGS11);
            }

            RegistraHistorico(TipoHistorico.Movimentação, this.valorPacote, this.valorFolha, this.valorTotal, novoValorPacote, novoValorFolha, novoValorTotal, null, loginResponsavel, observacao);
            this.valorPacote = novoValorPacote;
            this.valorFolha = novoValorFolha;
        }

        public virtual void ReajustaComposicao(decimal valorComposicao, Reajuste reajuste, string loginResponsavel, string observacao)
        {
            RegistraHistorico(valorComposicao == 0 ? TipoHistorico.Desativação : TipoHistorico.Reajuste, ValorPacote, 0, ValorTotal, valorComposicao, 0, valorComposicao, reajuste, loginResponsavel, observacao);
            SetValorPacote(valorComposicao);
            SetValorTotal(ValorFolha + ValorPacote);
        }

        public virtual void AssociaComposicaoBeneficio(decimal novoValorPacote, decimal novoValorFolha, decimal novoValorTotal, string loginResponsavel, string observacao)
        {
            if (string.IsNullOrWhiteSpace(loginResponsavel))
            {
                throw new ArgumentException(String.Format(GenericMessageResource.MSGS25, loginResponsavel));
            }

            if (string.IsNullOrWhiteSpace(observacao))
            {
                throw new ArgumentException(String.Format(GenericMessageResource.MSGS25, observacao));
            }

            if (Ativo && (ValorPacote >= 0 || ValorFolha >= 0))
            {
                if (novoValorPacote == 0 && novoValorFolha == 0)
                {
                    InativaComposicao(loginResponsavel, observacao);
                    DeletarComposicaoBeneficioBeneficiario(this.ComposicaoBeneficioBeneficiarios);
                }
                else
                {
                    AlterarValorComposicao(novoValorPacote, novoValorFolha, novoValorTotal, loginResponsavel, observacao);
                }
            }
            else if (!Ativo && (novoValorPacote != 0 || novoValorFolha != 0))
            {
                ReativaComposicao(novoValorPacote, novoValorFolha, novoValorTotal, loginResponsavel, observacao);
            }

            Save();
        }

        public virtual ComposicaoBeneficio AssociarValeRefeicaoColaborador(int? codigoConvencaoColetivaFaixaDesconto, decimal? jornadaTrabalho,
            string loginResponsavel, string observacao)
        {
            if (codigoConvencaoColetivaFaixaDesconto == null)
            {
                throw new ArgumentException("Faixa salarial inválida. Verifique a localidade cadastrada nos demais sistemas.");
            }

            if (jornadaTrabalho == null)
            {
                throw new ArgumentException("Jornada de trabalho inválida. Verifique a jornada cadastrada nos demais sistemas.");
            }

            ComposicaoBeneficio composicaoBeneficio = null;
            var codigoTipoColaborador = Colaborador.TipoColaborador.Codigo;

            if (codigoTipoColaborador == (int)Common.TipoColaborador.Funcionario || codigoTipoColaborador == (int)Common.TipoColaborador.Estagiario)
            {
                var calculo = new ComposicaoBeneficioValeRefeicao();
                var convencaoColetiva = ConvencaoColetiva.GetRepository().ObterConvencaoColetivaPorLocalidade(Colaborador.CodigoCidade);

                composicaoBeneficio = this;
                calculo.CalcularValoresComposicaoBeneficioValeRefeicaoPorColaborador(ref composicaoBeneficio, convencaoColetiva,
                    codigoConvencaoColetivaFaixaDesconto,
                    jornadaTrabalho, codigoTipoColaborador, loginResponsavel, observacao);
            }

            return composicaoBeneficio;
        }

        public virtual void DeletarComposicaoBeneficioBeneficiario(IList<ComposicaoBeneficioBeneficiario> beneficiarios)
        {
            foreach (var item in beneficiarios)
            {
                if (item == null)
                {
                    continue;
                }

                item.PlanoAdicionalComposicaoBeneficioBeneficiario.Clear();
                item.ItensPrecoBeneficiarios.Clear();
                item.Delete();
            }

            ComposicaoBeneficioBeneficiarios.Clear();
        }
    }
}

As I read in the error the DTO is not compatible with the entity, but I could not identify such incompatibility, could they help me?