Wie schreibe ich eine allgemeine Get und Delete Methoden mit Generics, für den Datenzugriff mit NHibernate?

In der aktuellen Anwendung gibt es zwei Gruppen von Objekten, die grundsätzlich als Domänen- und NHibernate-Objekte mit Schnittstellen verwendet werden. Domänenobjekte werden von den Präsentations- und Business-Schichten verwendet, wobei NHibernate-Objekte nur von Data Layer verwendet werden. Gegenwärtig übergibt die Business-Schicht für alle DB-Transaktionen die Domänenobjekte an die Datenschicht, die über Auto-Mapper intern in NHibernate konvertiert wird.Wie schreibe ich eine allgemeine Get und Delete Methoden mit Generics, für den Datenzugriff mit NHibernate?

Ich möchte gerne gemeinsame Speichern, Holen und Löschen Methoden implementieren. Ich habe generics, repository und reflection verwendet, um die allgemeine Save-Methode wie unten mit Schnittstellen zu implementieren.

Hat jemand einen Einblick in das Erstellen einer gemeinsamen Get und Delete-Methoden mit Generics und Reflektion für den Datenzugriff mit NHibernate?

Quelle

2011-01-01 sjjoshi

Hallo ich bin mir nicht sicher, ob das genau das ist, was Sie suchen, aber Sie können etwas wie das versuchen.

public abstract class BaseRepo<TIdType, TPersistentType> 
{ 
    protected ISession Session { get; private set; } 

    protected BaseRepo(ISession session) 
    { 
     Session = session; 
    } 

    public virtual void Save(TPersistentType request) 
    { 
     Session.Save(request); 
    } 

    public virtual TPersistentType GetById(TIdType id) 
    { 
     return (TPersistentType)Session.Load(typeof(TPersistentType), id); 
    } 

    public virtual IQueryable<TPersistentType> QueryList() 
    { 
     return Session.Linq<TPersistentType>(); 
    } 
}

Quelle

2011-01-01 21:41:18 Baz1nga

Ich dachte, das ist der Code, den Sie suchen:

Autor: BantenCity (http://84nt3nc1ty.blogspot.com/)
Erstellt am: April 13, 2010

Dateiname: GenericDao.cs

using System; 
using System.Collections; 
using System.Collections.Generic; 

using NHibernate; 
using NHibernate.Criterion; 

using Spring.Data.NHibernate.Generic.Support; 

namespace Mapits.Library.Dao 
{ 
public class GenericDao<T, ID> : HibernateDaoSupport, IGenericDao<T, ID> 
{ 
    #region Constants 
    private const string Asc = "Asc"; 
    private const string Desc = "Desc"; 
    #endregion 

    #region Update 
    /// <summary> 
    /// Update Entity 
    /// </summary> 
    /// <param name="entity"></param> 
    public void Update(T entity) 
    { 
     HibernateTemplate.Update(entity); 
    } 

    /// <summary> 
    /// Update List of Entity 
    /// </summary> 
    /// <param name="listEntity"></param> 
    public void Update(List<T> listEntity) 
    { 
     foreach (object entity in listEntity) 
     { 
      HibernateTemplate.Update(entity); 
     } 
    } 
    #endregion 

    #region Save 
    /// <summary> 
    /// Save Entity 
    /// </summary> 
    /// <param name="entity"></param> 
    public void Save(T entity) 
    { 
     HibernateTemplate.Save(entity); 
    } 

    /// <summary> 
    /// Save List of Entity 
    /// </summary> 
    /// <param name="listEntity"></param> 
    public void Save(List<T> listEntity) 
    { 
     foreach (object entity in listEntity) 
     { 
      HibernateTemplate.Save(entity); 
     } 
    } 
    #endregion 

    #region Delete 
    /// <summary> 
    /// Delete Entity 
    /// </summary> 
    /// <param name="entity"></param> 
    public void Delete(T entity) 
    { 
     HibernateTemplate.Delete(entity); 
    } 

    /// <summary> 
    /// Delete List of Entity 
    /// </summary> 
    /// <param name="listEntity"></param> 
    public void Delete(List<T> listEntity) 
    { 
     foreach (object entity in listEntity) 
     { 
      HibernateTemplate.Delete(entity); 
     } 
    } 
    #endregion 

    #region SaveOrUpdate 
    /// <summary> 
    /// Save or Update Entity 
    /// </summary> 
    /// <param name="entity"></param> 
    public void SaveOrUpdate(T entity) 
    { 
     HibernateTemplate.SaveOrUpdate(entity); 
    } 

    /// <summary> 
    /// Flush Entity from Hibernate Session 
    /// </summary> 
    public void Flush() 
    { 
     HibernateTemplate.Flush(); 
     //Session.Flush(); 
    } 

    /// <summary> 
    /// Evict Entity from Hibernate Session 
    /// </summary> 
    /// <param name="entity"></param> 
    public void Evict(T entity) 
    { 
     HibernateTemplate.Evict(entity); 
     //Session.Evict(entity); 
    } 

    /// <summary> 
    /// Save or Update List of Entity 
    /// </summary> 
    /// <param name="listEntity"></param> 
    public void SaveOrUpdate(List<T> listEntity) 
    { 
     foreach (object entity in listEntity) 
     { 
      HibernateTemplate.SaveOrUpdate(entity); 
     } 
    } 
    #endregion 

    #region GetList 
    /// <summary> 
    /// GetList by CreateByQuery 
    /// </summary> 
    /// <param name="query"></param> 
    /// <param name="param"></param> 
    /// <returns></returns> 
    public List<T> CreateByQuery(string query, Dictionary<List<string>, List<string>> param) 
    { 
     IQuery q = Session.CreateQuery(query); 
     SetString(q, param); 
     return (List<T>)q.List<T>(); 
    } 

    public IList GetListByCriteriaQuery(int minResult, int maxResult, ProjectionList projectionList, 
     ICriterion[] criterion, Dictionary<string, string> orders) 
    { 
     ICriteria crit = Session.CreateCriteria(typeof(T)); 

     crit.SetFirstResult(minResult); 
     if (maxResult != 0) crit.SetMaxResults(maxResult); 

     if (projectionList != null) 
     { 
      crit.SetProjection(projectionList); 
     } 

     if (criterion != null) 
     { 
      foreach (ICriterion iCrit in criterion) 
      { 
       crit.Add(iCrit); 
      } 
     } 

     if (orders != null) 
     { 
      foreach (KeyValuePair<string, string> order in orders) 
      { 
       if (order.Value == Asc) 
       { 
        crit.AddOrder(Order.Asc(order.Key)); 
       } 
       if (order.Value == Desc) 
       { 
        crit.AddOrder(Order.Desc(order.Key)); 
       } 
      } 
     } 

     IList list = crit.List(); 

     if (list.Count > 0) 
      return list; 

     return null; 
    } 
    /// <summary> 
    /// Get List By Criteria Query 
    /// </summary> 
    /// <param name="minResult"></param> 
    /// <param name="maxResult"></param> 
    /// <param name="projection"></param> 
    /// <param name="criterion"></param> 
    /// <param name="orders"></param> 
    /// <returns></returns> 
    public IList<T> GetListByCriteriaQuery(int minResult, int maxResult, 
     ICriterion[] criterion, Dictionary<string, string> orders) 
    { 
     ICriteria crit = Session.CreateCriteria(typeof(T)); 

     crit.SetFirstResult(minResult); 
     if (maxResult != 0) crit.SetMaxResults(maxResult); 

     if (criterion != null) 
     { 
      foreach (ICriterion iCrit in criterion) 
      { 
       crit.Add(iCrit); 
      } 
     } 

     if (orders != null) 
     { 
      foreach (KeyValuePair<string, string> order in orders) 
      { 
       if (order.Value == Asc) 
       { 
        crit.AddOrder(Order.Asc(order.Key)); 
       } 
       if (order.Value == Desc) 
       { 
        crit.AddOrder(Order.Desc(order.Key)); 
       } 
      } 
     } 

     IList<T> list = crit.List<T>(); 

     if (list.Count > 0) 
      return list; 

     return null; 
    } 

    /// <summary> 
    /// GetList by CreateByNamedQuery - Native SQL 
    /// </summary> 
    /// <param name="query"></param> 
    /// <param name="param"></param> 
    /// <returns></returns> 
    public List<T> CreateByNamedSQLQuery(string query, Dictionary<List<string>, List<string>> param) 
    { 
     IQuery q = Session.GetNamedQuery(query); 
     SetString(q, param); 
     return (List<T>)q.List<T>(); 
    } 

    /// <summary> 
    /// GetList by GetByNamedQuery - Native SQL 
    /// </summary> 
    /// <param name="query"></param> 
    /// <param name="param"></param> 
    /// <returns></returns> 
    public IList GetByNamedQuery(string query, Dictionary<List<string>, List<string>> param) 
    { 
     IQuery q = Session.GetNamedQuery(query); 
     SetString(q, param); 
     return q.List(); 
    } 
    #endregion 

    #region Miscellaneous 
    /// <summary> 
    /// 
    /// </summary> 
    /// <param name="id"></param> 
    /// <returns></returns> 
    public T Load(ID id) 
    { 
     return HibernateTemplate.Load<T>(id); 
    } 

    /// <summary> 
    /// Check if row exist by id 
    /// </summary> 
    /// <param name="id"></param> 
    /// <returns></returns> 
    public T Get(ID id) 
    { 
     T t = (T)Session.Get(typeof(T), id); 

     return t; 
    } 

    public T GetByInt(Int32 id) 
    { 
     T t = (T)Session.Get(typeof(T), id); 
     return t; 
    } 

    /// <summary> 
    /// Get Entity by Criteria 
    /// </summary> 
    /// <param name="fieldname"></param> 
    /// <param name="value"></param> 
    /// <returns></returns> 
    public T GetByCriteria(string fieldname, string value) 
    { 
     ICriteria crit = Session.CreateCriteria(typeof(T)); 
     crit.Add(Restrictions.Eq(fieldname, value)); 
     return (T)crit.UniqueResult(); 
    } 

    /// <summary> 
    /// Get ISQLQuery by CreateByISQLQuery - Native SQL 
    /// </summary> 
    /// <param name="query"></param> 
    /// <returns></returns> 
    public ISQLQuery CreateByISQLQuery(string query) 
    { 
     ISQLQuery q = Session.CreateSQLQuery(query); 

     return q; 
    } 

    #endregion 

    #region Private Methods... 

    private void SetString(IQuery q, Dictionary<List<string>, List<string>> param) 
    { 
     foreach (KeyValuePair<List<string>, List<string>> valuePair in param) 
     { 
      for (int i = 0; i < valuePair.Key.Count; i++) 
      { 
       q.SetString(valuePair.Key[i], valuePair.Value[i]); 
      } 
     } 
    } 

    #endregion 
}

}

Quelle

2011-01-07 07:46:34 BantenCity

Wie schreibe ich eine allgemeine Get und Delete Methoden mit Generics, für den Datenzugriff mit NHibernate?

Antwort

Verwandte Themen