Как написать общие методы Get и Delete с использованием обобщений для доступа к данным с помощью NHibernate?

Question

В текущем приложении есть два набора объектов, в основном используемых как объекты Domain и NHibernate, с интерфейсами. Доменные объекты используются на презентационном и бизнес-уровнях, а в качестве объектов NHibernate используется только Уровень данных. В настоящее время для любой транзакции БД бизнес-уровень передает объекты домена на уровень данных, который внутренне преобразуется в NHibernate с помощью автоматического сопоставления.

Я хотел бы реализовать общие методы Save, Get и Delete. Я использовал обобщения, репозиторий и рефлексию для реализации общего метода Save, как показано ниже, с интерфейсами.

Есть ли у кого-нибудь понимание того, как создать общие методы Get и Delete с использованием обобщений и отражений для доступа к данным с помощью NHibernate?

Answer 1

Я думал, что это код, который вы ищете:

• Автор: BantenCity (http://84nt3nc1ty.blogspot.com/)
• Дата создания: 13 апреля 2010 г.

• Имя файла: 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
  }
  

  }

Answer 2

Привет, я не уверен, что это именно то, что вы ищете, но вы можете попробовать что-то вроде этого.

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>();
    }
}