nhibernate + generic dao

Nickemannen skrev:

Det beror på var du har interface't

Här kommer något som jag (heller) inte greppat än. Med just interface. :)

Min kod är rätt orörd från erkas första exempel ovan.
Det enda interface jag har är public interface IGenericDao<T> : IDisposable och det ligger tillsammans med NHibernateGenericDao. (som ovan)

Har jag fattat rätt om IGenericDao<T> som erka skrev bara är ett exempel och borde i mitt fall egentligen heta ex. IProductDao<T>?
Eller fyller det någon funktion som det ser ut ovan?

Nää, så kan det ju inte heller vara!?
NHibernateGenericDao<T> ärver ju IGenericDao<T> så det måste ju finnas kvar som det är!

Hmm, mitt produktdao ser ut så här just nu:

public class ProductDao : BaseDao.NHibernateGenericDao<Product>, BaseDao.IGenericDao<Product>
{
        public Product GetProduct(int id)
        {
            try
            {
                return GetObject(Expression.IdEq(id));
            }
            catch (Exception)
            {
                throw;
            }
        }
}

Är det arvet här som är galet?
Borde jag även ha ett interface IProduct?

Du måste ha en referens till den assemblie där interfacet ligger.

Ligger IGenericDao i samma assemblie som ProductDao så behöver du inte referensen.

Nickemannen skrev:

Ligger IGenericDao i samma assemblie som ProductDao så behöver du inte referensen.

Nej, de ligger inte i samma och helst vill jag inte ha de i samma heller.
Min tanke var att ha NHibernateGenericDao + IGenericDao i helt eget assambly så jag enkelt kan kopiera det till nästa projekt för återanvändning.

Jag har alltså inte gjort några "direkta" fel i mitt tänk då?
Jag får helt enkelt bara leva med att ha en referens till BaseDao ifrån mitt webbprojekt?!

Du har fattat det fel.

IGenericDao är ju ett generiskt dao dit du kan skicka vilken typ som helst, använder det bara för hantera listor och skit i applikationen för att slippa funktionstesta en miljon olika daos,som alla har samma funktionalitet. Enkla objekt. Tanken med ett generiskt dao är ju att du ska slippa massa daos, men har du komplexa dao så är det ju inte vägen att gå.

Det jag skrev använder jag i ett generiskt serviceinterface vilket i praktiken innebär att generiska daos skapas upp av typ

IGenericDao<Company> dao = CreateDaoFactory().CreateGenericDao<Company>();

och på det dao har jag all funktionalitet som är specad i mitt IGenericDao och implementerat i GenericDao

Jag tolkade som du ville ha ett generiskt dao, och det var det jag skrev :) Vad är det du vill åstakomma?

Jag förstår inte vad du vill åstakomma med
BaseDao.NHibernateGenericDao<Product>, BaseDao.IGenericDao<Product>

erka skrev:

Jag förstår inte vad du vill åstakomma med
BaseDao.NHibernateGenericDao<Product>, BaseDao.IGenericDao<Product>

Nej, inte jag heller! :OO
Koden hamnade där bara för att det gick att kompilera så och för att jag inte förstår bättre! :r

erka skrev:

Vad är det du vill åstakomma?

Det börjar klarna men det som känns otydligt i mitt huvud nu är kopplingen från aspxsidan till IGenericDao<T>

Är CreateDaoFactory() en statisk klass och CreateGenericDao<T>() en statisk metod som du använder för att skapa dina daos?

Har du lite exempelkod ur denna klass som du vill dela med dig av? :D

doggelito, läs följande artikel:
http://www.codeproject.com/KB/architecture/NHibernateBestPractices.aspx

Använder sig av GenericDAO och det finns källkod att ladda hem.

Compusa skrev:

doggelito, läs följande artikel:

Det var där jag började. :)
Men det är så himla många filer och kodrader så man vet varken ut eller in!
Jag ka ta det som helglektyr kanske! ;)

Det är bara en vanlig factoryklass för skapa mina olika DAOs.

Kopplingen från aspx sidan är att du gör som jag gjorde ovan
IGenericDao<Company> dao = new NHibernateGenericDao<Company>();

Eller att skapa en factoryklass

  /// <summary>
    /// Defines all data access objects that can be created.
    /// </summary>
    public interface IDaoFactory
    {
   
        /// <summary>
        /// Creates a AnotherDao.
        /// </summary>
        /// <returns></returns>
        IAnotherDao CreateAnotherDao();

        /// <summary>
        /// Creates a generic Dao.
        /// </summary>
        /// <returns></returns>
        IGenericDao<T> CreateGenericDao<T>();
    }

    /// <summary>
    /// This class handles the creation of all NHibernate related data access objects.
    /// </summary>
    public class NHibernateDaoFactory : IDaoFactory
    {
        /// <summary>
        /// Creates an instance of the NHibernateAnotherDao.
        /// </summary>
        /// <returns></returns>
        public IAnotherDao CreateAnotherDao()
        {
            return new NHibernateAnotherDao();
        }

       

        /// <summary>
        /// Creates an instance of the NhibernateGenericDao.
        /// </summary>
        /// <returns></returns>
        public IGenericDao<T> CreateGenericDao<T>()
        {
            return new NHibernateGenericDao<T>();
        }
    }