Fluent NHibernate, erro na classe se SessionFactory?

Bom dia amigos;

Sou novo com o Fluent NHibernate e criei está Sesseão Factory

public class SessionFactory
    {
        private static ISessionFactory session;
        public static ISessionFactory CriarSession()
        {
            string stringConn = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=pdv;Integrated Security=True;"
                + "Connect Timeout=30;Encrypt=False;TrustServerCertificate=True;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";

            if (session != null)
                return session;

            IPersistenceConfigurer configDB = (MsSqlConfiguration.MsSql2012.ConnectionString(stringConn).ShowSql());

            var configMap = Fluently.Configure().Database(configDB)
                .Mappings(M => M.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()))
                .BuildSessionFactory();

            return session;
        }
        public static ISession AbrirSession()
        {
            return CriarSession().OpenSession();
        }
    }

ele acusa o erro no “var configMap” ele é o seguinte.:

Citar

An invalid or incomplete configuration was used while creating a SessionFactory. Check Potential Reasons collection, and InnerException for more detail.

estou procurando na internet, e revendo alguns vidios, mas não consegui resolver o problema ainda. Bom o resto de minhas classes são.:

public class ProdutoMap : ClassMap<Produto>
    {
        public ProdutoMap()
        {
            Table("PRODUTO");
            Id(p => p.Codigo);
            Map(p => p.Referencia);
            Map(p => p.CodBar);
            Map(p => p.TipoProduto);
            Map(p => p.NomeProduto);
            Map(p => p.ProdutoEcf);
            Map(p => p.CodigoFiscal);
            Map(p => p.TipoProduto);
            Map(p => p.PesoBruto);
            Map(p => p.PesoLiquido);
            Map(p => p.PromocaoAtivada);
            Map(p => p.PromocaoRedMargemLucro);
            Map(p => p.Margem01);
            Map(p => p.Preco01);
            Map(p => p.Desconto01);
            Map(p => p.Comissao01);
            Map(p => p.Margem01);
            Map(p => p.Preco01);
            Map(p => p.Desconto01);
            Map(p => p.Comissao01);
            Map(p => p.Margem02);
            Map(p => p.Preco02);
            Map(p => p.Desconto02);
            Map(p => p.Comissao02);
            Map(p => p.Margem03);
            Map(p => p.Preco03);
            Map(p => p.Desconto03);
            Map(p => p.Comissao03);
            Map(p => p.Margem04);
            Map(p => p.Preco04);
            Map(p => p.Desconto04);
            Map(p => p.Comissao04);
            Map(p => p.Margem05);
            Map(p => p.Preco05);
            Map(p => p.Desconto05);
            Map(p => p.Comissao05);
            Map(p => p.NCasaDecEnt);
            Map(p => p.NCasaDecSai);
            Map(p => p.Fracionado);
            Map(p => p.CaminhoImagem);
            Map(p => p.QtdAux);
        }
    }
public abstract class Repository<T>
    {
        public void Inserir(T entidade)
        {
            using (ISession session = SessionFactory.AbrirSession())
            {
                using (ITransaction transacao = session.BeginTransaction())
                {
                    try
                    {
                        session.Save(entidade);
                        transacao.Commit();
                    }
                    catch (Exception ex)
                    {
                        if (!transacao.WasCommitted)
                        {
                            transacao.Rollback();
                        }
                        throw new Exception("Erro ao inserir Cliente : " + ex.Message);
                    }
                }
            }
        }

        public void Alterar(T entidade)
        {
            using (ISession session = SessionFactory.AbrirSession())
            {
                using (ITransaction transacao = session.BeginTransaction())
                {
                    try
                    {
                        session.Update(entidade);
                        transacao.Commit();
                    }
                    catch (Exception ex)
                    {
                        if (!transacao.WasCommitted)
                        {
                            transacao.Rollback();
                        }
                        throw new Exception("Erro ao Alterar Cliente : " + ex.Message);
                    }
                }
            }
        }

        public void Excluir(T entidade)
        {
            using (ISession session = SessionFactory.AbrirSession())
            {
                using (ITransaction transacao = session.BeginTransaction())
                {
                    try
                    {
                        session.Delete(entidade);
                        transacao.Commit();
                    }
                    catch (Exception ex)
                    {
                        if (!transacao.WasCommitted)
                        {
                            transacao.Rollback();
                        }
                        throw new Exception("Erro ao Excluir Cliente : " + ex.Message);
                    }
                }
            }
        }

        public T RetornarPorId(int Id)
        {
            using (ISession session = SessionFactory.AbrirSession())
            {
                return session.Get<T>(Id);
            }
        }

        public IList<T> Consultar()
        {
            using (ISession session = SessionFactory.AbrirSession())
            {
                return (from c in session.Query<T>() select c).ToList();
            }
        }
    }
public class Produto
    {
        private double codigo;
        private string referencia;
        private string codBar;
        private string tipoProduto;
        private string nomeProduto;
        private string produtoEcf;
        private string unidadeVenda;
        private string codigoFiscal;
        private string tipoTribPadrao;
        private double pesoBruto;
        private double pesoLiquido;
        private char promocaoAtivada;
        private double promocaoRedMargemLucro;
        private double margem01;
        private double preco01;
        private double desconto01;
        private double comissao01;
        private double margem02;
        private double preco02;
        private double desconto02;
        private double comissao02;
        private double margem03;
        private double preco03;
        private double desconto03;
        private double comissao03;
        private double margem04;
        private double preco04;
        private double desconto04;
        private double comissao04;
        private double margem05;
        private double preco05;
        private double desconto05;
        private double comissao05;
        private char nCasaDecEnt;
        private char nCasaDecSai; // qtas cadas decimais do preco
        private char fracionado; // quando iqual a 1 vai ser fracionado 3 casas apos a virgula na qtd.
        private string caminhoImagem;
        private char inativo;
        private double qtdAux; // quantidade utilizada para auxiliar no desenvolvimento

        public virtual double Codigo
        {
            get
            {
                return codigo;
            }

            set
            {
                codigo = value;
            }
        }

        public virtual string Referencia
        {
            get
            {
                return referencia;
            }

            set
            {
                referencia = value;
            }
        }

        public virtual string CodBar
        {
            get
            {
                return codBar;
            }

            set
            {
                codBar = value;
            }
        }

        public virtual string TipoProduto
        {
            get
            {
                return tipoProduto;
            }

            set
            {
                tipoProduto = value;
            }
        }

        public virtual string NomeProduto
        {
            get
            {
                return nomeProduto;
            }

            set
            {
                nomeProduto = value;
            }
        }

        public virtual string ProdutoEcf
        {
            get
            {
                return produtoEcf;
            }

            set
            {
                produtoEcf = value;
            }
        }

        public virtual string UnidadeVenda
        {
            get
            {
                return unidadeVenda;
            }

            set
            {
                unidadeVenda = value;
            }
        }

        public virtual string CodigoFiscal
        {
            get
            {
                return codigoFiscal;
            }

            set
            {
                codigoFiscal = value;
            }
        }

        public virtual double PesoBruto
        {
            get
            {
                return pesoBruto;
            }

            set
            {
                pesoBruto = value;
            }
        }

        public virtual double PesoLiquido
        {
            get
            {
                return pesoLiquido;
            }

            set
            {
                pesoLiquido = value;
            }
        }

        public virtual char PromocaoAtivada
        {
            get
            {
                return promocaoAtivada;
            }

            set
            {
                promocaoAtivada = value;
            }
        }

        public virtual double PromocaoRedMargemLucro
        {
            get
            {
                return promocaoRedMargemLucro;
            }

            set
            {
                promocaoRedMargemLucro = value;
            }
        }

        public virtual double Margem01
        {
            get
            {
                return margem01;
            }

            set
            {
                margem01 = value;
            }
        }

        public virtual double Preco01
        {
            get
            {
                return preco01;
            }

            set
            {
                preco01 = value;
            }
        }

        public virtual double Desconto01
        {
            get
            {
                return desconto01;
            }

            set
            {
                desconto01 = value;
            }
        }

        public virtual double Comissao01
        {
            get
            {
                return comissao01;
            }

            set
            {
                comissao01 = value;
            }
        }

        public virtual double Margem02
        {
            get
            {
                return margem02;
            }

            set
            {
                margem02 = value;
            }
        }

        public virtual double Preco02
        {
            get
            {
                return preco02;
            }

            set
            {
                preco02 = value;
            }
        }

        public virtual double Desconto02
        {
            get
            {
                return desconto02;
            }

            set
            {
                desconto02 = value;
            }
        }

        public virtual double Comissao02
        {
            get
            {
                return comissao02;
            }

            set
            {
                comissao02 = value;
            }
        }

        public virtual double Margem03
        {
            get
            {
                return margem03;
            }

            set
            {
                margem03 = value;
            }
        }

        public virtual double Preco03
        {
            get
            {
                return preco03;
            }

            set
            {
                preco03 = value;
            }
        }

        public virtual double Desconto03
        {
            get
            {
                return desconto03;
            }

            set
            {
                desconto03 = value;
            }
        }

        public virtual double Comissao03
        {
            get
            {
                return comissao03;
            }

            set
            {
                comissao03 = value;
            }
        }

        public virtual double Margem04
        {
            get
            {
                return margem04;
            }

            set
            {
                margem04 = value;
            }
        }

        public virtual double Preco04
        {
            get
            {
                return preco04;
            }

            set
            {
                preco04 = value;
            }
        }

        public virtual double Desconto04
        {
            get
            {
                return desconto04;
            }

            set
            {
                desconto04 = value;
            }
        }

        public virtual double Comissao04
        {
            get
            {
                return comissao04;
            }

            set
            {
                comissao04 = value;
            }
        }

        public virtual double Margem05
        {
            get
            {
                return margem05;
            }

            set
            {
                margem05 = value;
            }
        }

        public virtual double Preco05
        {
            get
            {
                return preco05;
            }

            set
            {
                preco05 = value;
            }
        }

        public virtual double Desconto05
        {
            get
            {
                return desconto05;
            }

            set
            {
                desconto05 = value;
            }
        }

        public virtual double Comissao05
        {
            get
            {
                return comissao05;
            }

            set
            {
                comissao05 = value;
            }
        }

        public virtual char NCasaDecEnt
        {
            get
            {
                return nCasaDecEnt;
            }

            set
            {
                nCasaDecEnt = value;
            }
        }

        public virtual char NCasaDecSai
        {
            get
            {
                return nCasaDecSai;
            }

            set
            {
                nCasaDecSai = value;
            }
        }

        public virtual char Fracionado
        {
            get
            {
                return fracionado;
            }

            set
            {
                fracionado = value;
            }
        }

        public virtual string CaminhoImagem
        {
            get
            {
                return caminhoImagem;
            }

            set
            {
                caminhoImagem = value;
            }
        }

        public virtual char Inativo
        {
            get
            {
                return inativo;
            }

            set
            {
                inativo = value;
            }
        }

        public virtual double QtdAux
        {
            get
            {
                return qtdAux;
            }

            set
            {
                qtdAux = value;
            }
        }

        public virtual string TipoTribPadrao
        {
            get
            {
                return tipoTribPadrao;
            }

            set
            {
                tipoTribPadrao = value;
            }
        }
    }
aqui estou tentando executar
`Produto p = new Produto
 {
  Codigo = 2,
  NomeProduto = "teste"
};

            produtosDal.Inserir(p);`

o banco.:
`CREATE TABLE [dbo].[Produto] (
    [Codigo]                 FLOAT (53)    NOT NULL,
    [Referencia]             VARCHAR (100) NULL,
    [CodBar]                 VARCHAR (20)  NULL,
    [TipoProduto]            VARCHAR (10)  NULL,
    [NomeProduto]            VARCHAR (150) NULL,
    [ProdutoEcf]             VARCHAR (50)  NULL,
    [UnidadeVenda]           VARCHAR (10)  NULL,
    [CodigoFiscal]           VARCHAR (20)  NULL,
    [TipoTribPadrao]         VARCHAR (10)  NULL,
    [PesoBruto]              FLOAT (53)    NULL,
    [PesoLiquido]            FLOAT (53)    NULL,
    [PromocaoAtivada]        CHAR (1)      NULL,
    [PromocaoRedMargemLucro] FLOAT (53)    NULL,
    [Margem01]               FLOAT (53)    NULL,
    [Preco01]                FLOAT (53)    NULL,
    [Desconto01]             FLOAT (53)    NULL,
    [Comissao01]             FLOAT (53)    NULL,
    [Margem02]               FLOAT (53)    NULL,
    [Preco02]                FLOAT (53)    NULL,
    [Desconto02]             FLOAT (53)    NULL,
    [Comissao02]             FLOAT (53)    NULL,
    [Margem03]               FLOAT (53)    NULL,
    [Preco03]                FLOAT (53)    NULL,
    [Desconto03]             FLOAT (53)    NULL,
    [Comissao03]             FLOAT (53)    NULL,
    [Margem04]               FLOAT (53)    NULL,
    [Preco04]                FLOAT (53)    NULL,
    [Desconto04]             FLOAT (53)    NULL,
    [Comissao04]             FLOAT (53)    NULL,
    [Margem05]               FLOAT (53)    NULL,
    [Preco05]                FLOAT (53)    NULL,
    [Desconto05]             FLOAT (53)    NULL,
    [Comissao05]             FLOAT (53)    NULL,
    [NCasaDecEnt]            CHAR (1)      NULL,
    [NCasaDecSai]            CHAR (1)      NULL,
    [Fracionado]             CHAR (1)      NULL,
    [CaminhoImagem]          TEXT          NULL,
    [Inativo]                CHAR (1)      NULL
);`

http://image.prntscr.com/image/d24cd171e05148c5b91da198b7ee42be.png

Tem configuração errada e a sua classe também está bem fora do padrão, não utilize métodos static, estou te enviando um exemplo:

using FluentNHibernate.Cfg;
using FluentNHibernate.Cfg.Db;
using NHibernate;
using System.Collections.Generic;
using System.Reflection;
namespace ConsoleApplication3
{
    public class Connection
    {
        private ISessionFactory sessionFactory;
        private ISession session;
        public Connection()
        {
            CriarSession();
        }

        public ISession Session()
        {
            return session;
        }
        public ISessionFactory SessionFactory()
        {
            return sessionFactory;
        }


        public T Add<T>(T model)
        {
            ITransaction trans = session.BeginTransaction();
            session.Save(model);
            trans.Commit();
            return model;       
        }

        public T Edit<T>(T model)
        {
            ITransaction trans = session.BeginTransaction();
            session.SaveOrUpdate(model);
            trans.Commit();
            return model;
        }

        public T Find<T>(object id)
        {
            return session.Get<T>(id);
        }

        public T Find<T>(object id, LockMode lockMode)
        {
            return session.Get<T>(id, lockMode);
        }

        public IList<T> ToList<T>()
            where T: class
        {
            
            return session.CreateCriteria(typeof(T))
                .List<T>();
        }
        private void CriarSession()
        {

            if (sessionFactory == null)
            {
                sessionFactory = Fluently.Configure()
                        .Database(
                            MsSqlConfiguration.MsSql2012.ConnectionString(c => c.FromConnectionStringWithKey("ConnSQLServer")))
                            .Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()))
                            .BuildSessionFactory();

                
                session = sessionFactory.OpenSession();
            }
        }
    }
}

No método private CriarSession(), foi feita algumas alterações principalmente na parte da connectionString que foi colocado dentro de um chave connectionStrings veja:

<connectionStrings>
  <add connectionString="Server=.\SQLExpress;Database=Tests;User Id=sa;Password=senha;"
     providerName="System.Data.SqlClient"
     name="ConnSQLServer" />
</connectionStrings>

Foram feitas várias alterações e ajustes nessa classe Connection:

Classe Itens e seu ClassMap:

public class Itens
{
	public virtual int Id { get; set; }
	public virtual string Nome { get; set; }
}

public class ItensMap: ClassMap<Itens>
{
	public ItensMap()
	{
		Table("Itens");

		Id(x => x.Id)
			.GeneratedBy
			.Identity();

		Map(x => x.Nome)                
			.Length(50)
			.Not.Nullable();
	}
}

Connection conn = new Connection();

//add
conn.Add(new Itens()
{
    Nome = "Osasco"
});

//busca por id
Itens item = conn.Find<Itens>(1005);
item.Nome += " São Paulo";

//alterando
conn.Edit(item);

//lista
var itens = conn.ToList<Itens>();

Para melhorar faça camadas de respository com métodos genérico, sendo essa classe quase com os métodos principais.

Outro ponto é que você fez a sua classe também fora do padrão, segue meu exemplo!

Opá vlw, eu fiz om um teste com minha classe da mesma forma, mas tudo em um único projeto e ele funcionou o que me levou a pensar que poderia ser algo em minha estrutura. Não tenho uma grande experiencia com C# ou com o Fluent então pensei em mostrar como estou fazendo.

Dei uma corrigida na SessionFactory que não estava atribuindo valor para a variável “session”.
E eu estava retornando ela…

Depois onde apenas crio a sessão?

Então para teste eu apenas criei este projeto e funcionou… olhe a estrutura do outro projeto:

Caro @eduardo.giullyanny

Nesse caso especifico, se o projeto for pequeno eu desenvolvo as camadas padrões, talvez seja isso que você não esteja conseguindo referenciar o modelo do seu projeto para que o FluentNhibernate consiga carregar, mas, também não pode ficar usando classes com modificador static de qualquer forma, utilize somente e casos especificos, nesse caso utilize as instâncias.

Bom faça o seguinte a camada Model (que são as classes do FluentNhibernate constituída pela classes de modelo, classes de mapeamento e conexão) tudo no projeto que vão executar. Crie um camada de repository em outro projeto e faça as referencias para o projeto principal. No projeto principal crie uma pasta e codifique as repository e assim todas repository.

Pastas:

Interfaces:

public interface IConnection : IDisposable
{
	T Add<T>(T model);
	T Edit<T>(T model);
	T Find<T>(object id);
	T Find<T>(object id, LockMode lockMode);
	IList<T> ToList<T>() where T : class;
	ISession Session();
	ISessionFactory SessionFactory();        
}

public interface ICrud<T>
	where T: class, new()
{
	IConnection Connection { get; }
	T Add(T model);
	T Edit(T model);
	T Find(object id);
	T Find(object id, LockMode lockMode);
	IList<T> ToList();
}

public interface IRepositoryItens: ICrud<Itens>        
{
}

Models.Map:

public class ItensMap : ClassMap<Itens>
{
	public ItensMap()
	{
		Table("Itens");

		Id(x => x.Id)
			.GeneratedBy
			.Identity();

		Map(x => x.Nome)
			.Length(50)
			.Not.Nullable();
	}
}

Models:

public class Itens
{
	public virtual int Id { get; set; }
	public virtual string Nome { get; set; }        
}

Repositories:

public class Connection : IConnection
{
	private ISessionFactory sessionFactory;
	private ISession session;
	public Connection()
	{
		CriarSession();
	}

	public ISession Session()
	{
		return session;
	}
	public ISessionFactory SessionFactory()
	{
		return sessionFactory;
	}


	public T Add<T>(T model)
	{
		ITransaction trans = session.BeginTransaction();
		session.Save(model);
		trans.Commit();
		return model;       
	}

	public T Edit<T>(T model)
	{
		ITransaction trans = session.BeginTransaction();
		session.SaveOrUpdate(model);
		trans.Commit();
		return model;
	}

	public T Find<T>(object id)
	{
		return session.Get<T>(id);
	}

	public T Find<T>(object id, LockMode lockMode)
	{
		return session.Get<T>(id, lockMode);
	}

	public IList<T> ToList<T>()
		where T: class
	{
		
		return session.CreateCriteria(typeof(T))
			.List<T>();
	}
	private void CriarSession()
	{

		if (sessionFactory == null)
		{
			sessionFactory = Fluently.Configure()
					.Database(
						MsSqlConfiguration.MsSql2012.ConnectionString(c => c.FromConnectionStringWithKey("ConnSQLServer")))
						.Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()))
						.BuildSessionFactory();

			sessionFactory.OpenSession();
			session = sessionFactory.OpenSession();
		}
	}
	public void Dispose()
	{
		session.Close();
		sessionFactory.Close();
		session.Dispose();
		sessionFactory.Dispose();
	}
}

public sealed class RepositoryItens : IRepositoryItens
{
	public IConnection Connection { get; private set; }
	public RepositoryItens(IConnection connection)
	{
		Connection = connection;
	}

	public Itens Add(Itens model)
	{
		Connection.Add(model);
		return model;
	}

	public Itens Edit(Itens model)
	{
		Connection.Edit(model);
		return model;
	}

	public Itens Find(object id)
	{
		return Connection.Find<Itens>(id);
	}

	public Itens Find(object id, LockMode lockMode)
	{
		return Connection.Find<Itens>(id, lockMode);
	}

	public IList<Itens> ToList()
	{
		return Connection.ToList<Itens>();
	}
}

Como usar?

IConnection conn = new Connection();
IRepositoryItens repItens = new RepositoryItens(conn);

var itens = repItens.ToList();

Eu usaria uma Injeção de dependência com um container, mas, foge um pouco da sua duvida.

Os outros métodos estão todos implementados e só utilizar. Como eu disse o comando Assembly.GetExecutingAssembly() está pegando dentro do Assemby Local e isso deve ser o erro.

Dragoon meu amigo;

Consegui entender agora, meu erro poderia ser a divisão em projetos.

Eu criei um projeto para logic um projeto para Interface outro projeto para outra coisa.

Isso estava dificultando muito minha cabeça, tinha vindo de outra linguagem e estava pouco acostumado Soluções.

Como vc disse que ID foge um pouco de minha dúvida, mas será que poderia me dar um exemplo prático.

Vou montar esta sua estrutura, mas ainda vem outra dúvida, quando eu referenciar isso, devo fazer para cada tabela no banco?

e meus outros projetos como por exemplo “windows” que são meus formulários?

Aproveitando poderia me dar dicas do uso de Soluções e projetos?.
E como eu posso gerar um app.config?

Você poderia abrir várias duvidas pequenas! porque, quando um pergunta vira o que essa está virando acaba confundindo a gente!

Faça pequenas perguntas para que possamos ajudar!

Só lembrando que eu dei um grande caminho pra você que ao meu ver está aprendendo C# e camadas de ORM!

Exatamente;

Eu venho de outras linguagens.
então iniciando:

Como vc disse que ID foge um pouco de minha dúvida, mas será que poderia me dar um exemplo prático.

Olá Dragoon;

fiz daquela forma que me mostrou, fiquei macetando ontem o resto do dis para identificar o erro.

que me parece que não identificou o meu app.config que adicionei.

certo… o que fiz exatamente?

reorganizei a estrutura, tudo dentro do DAL, onde é está add a referencia do Fluent

Bom, depois eu criei o app.config:

A string de conexão eu peguei aqui:

Depois somente para teste coloquei o seu modo de usar dentro do construtor de ProdutosDal

Todos estes exemplos ainda estão dentro de um Projeto com o nome DAL.

Depois eu crio uma instancia de ProdutosDAL, em um form (do windows form), em um outro projeto chamado SigmaPDV.

Quando tentei usar o seu exemplo direto no Projeto SigmaPDV dentro de um construtor de um form

fica aparecendo este erro

Me parece que quando tento integrar um projeto no outro dentro da solução fica dando estes problemas.
Sobre a conexão o erro é novo

Tentei com a string de conexão dentro do código.:

bom, ai voltou aquela informação anterior…

Eu tb fiz outra coisa, add a referencia do fluent nhibernate nos dois projetos(SigmaPDV e DAL)

Até acho que posso retirar a referencia do projeto SigmaPDV, pois são apenas formulários
outra coisa que ainda n disse, que DAL é apenas projeto de Class

O app.config tem que ser colocado no projeto que sobe a aplicação, acredito que esteja faltando isso.

Eu dei uma olhada nas imagens, o que era para ser bem estruturado ficou bagunçado,

Pergunto?

é um Projeto Windows Forms?

sim, mas ficou legal não.

Pelos nomes?

Não é pelos nome (apesar que também acho sem padrão, mas, é um parte minha isso), mas, não se dividi por achar que isso mantem um padrão, exemplo que eu fiz:


Olha que divisão bacana, aonde Models, seria todos os models do seu projeto, e Repositories toda a sua camada lógica, Forms sendo seu projeto que tem as duas referencias (Models e Repositories).

Form Principal:

using System.Windows.Forms;

namespace Forms
{
    public partial class Form1 : Form
    {

        private IConnection Connection { get; set; }
        private RepositoryItensImplementation RepItens { get; set; }

        public Form1()
        {

            InitializeComponent();

            Connection = new Connection();
            RepItens = new RepositoryItens(Connection);

        }

        private void Form1_Load(object sender, EventArgs e)
        {
            GridItens.DataSource = RepItens.ToList();
        }
    }
}

Então a divisão e a codificação fica em cada parte depois eu chama elas no principal e no principal a codificação fica bem clara e limpa!

1 curtida