ASP.NET NHibernateDataSource

   1: [ParseChildren(true)]

   2:publicclass NHibernateDataSource : QueryableDataSource

   3: {

   4:public NHibernateDataSource()

   5:     {

   6:this.SelectParameters = new ParameterCollection();

   7:this.InsertParameters = new ParameterCollection();

   8:this.UpdateParameters = new ParameterCollection();

   9:this.DeleteParameters = new ParameterCollection();

  10:     }

  11:  

  12:     [Description("Raised when a session factory is built")]

  13:publicevent EventHandler<BuildSessionFactoryEventArgs> BuildSessionFactory;

  14:     [Description("Raised when a configuration instance is created")]

  15:publicevent EventHandler<ConfigureEventArgs> Configure;

  16:     [Description("Raised when an entity is created for inserts or updates")]

  17:publicevent EventHandler<CreateInstanceEventArgs> CreateInstance;

  18:  

  19:     [Description("Raised after an entity is inserted")]

  20:publicevent EventHandler<EntityEventArgs> EntityInserted;

  21:     [Description("Raised after an entity is deleted")]

  22:publicevent EventHandler<EntityEventArgs> EntityDeleted;

  23:     [Description("Raised after an entity is updated")]

  24:publicevent EventHandler<EntityEventArgs> EntityUpdated;

  25:     [Description("Raised after a query is executed")]

  26:publicevent EventHandler<EntitiesSelectedEventArgs> EntitiesSelected;

  27:     [Description("Raised when an operation completes (select, insert, update or delete)")]

  28:publicevent EventHandler<OperationCompletedEventArgs> OperationCompleted;

  29:  

  30:     [Description("Raised before a select is made")]

  31:publicevent EventHandler<EntitiesSelectingEventArgs> EntitiesSelecting;

  32:     [Description("Raised before an entity is inserted")]

  33:publicevent EventHandler<EntityEventArgs> EntityInserting;

  34:     [Description("Raised before an entity is deleted")]

  35:publicevent EventHandler<EntityEventArgs> EntityDeleting;

  36:     [Description("Raised before an entity is updated")]

  37:publicevent EventHandler<EntityEventArgs> EntityUpdating;

  38:  

  39:     [Description("The entity name to update, delete or insert")]

  40:     [DefaultValue("")]

  41:public String EntityName

  42:     {

  43:         get;

  44:         set;

  45:     }

  46:  

  47:     [Description("The HQL to use for selecting records, when mode Hql is selected")]

  48:     [DefaultValue("")]

  49:public String Hql

  50:     {

  51:         get;

  52:         set;

  53:     }

  54:  

  55:     [Description("The maximum number of records to retrieve, if paging is not used")]

  56:     [DefaultValue(0)]

  57:public Int32 MaximumRecords

  58:     {

  59:         get;

  60:         set;

  61:     }

  62:  

  63:     [Description("The page size to retrieve")]

  64:     [DefaultValue(0)]

  65:public Int32 PageSize

  66:     {

  67:         get;

  68:         set;

  69:     }

  70:  

  71:     [Description("The page index to retrieve")]

  72:     [DefaultValue(0)]

  73:public Int32 PageIndex

  74:     {

  75:         get;

  76:         set;

  77:     }

  78:  

  79:     [Description("Use HQL or EntityName for selecting")]

  80:     [DefaultValue(NHibernateDataSourceMode.Linq)]

  81:public NHibernateDataSourceMode Mode

  82:     {

  83:         get;

  84:         set;

  85:     }

  86:  

  87:     [Description("Whether to merge the entity before updating or deleting or not")]

  88:     [DefaultValue(false)]

  89:public Boolean RefreshBeforeUpdate

  90:     {

  91:         get;

  92:         set;

  93:     }

  94:  

  95:     [Description("Parameters that will be used for the HQL query")]

  96:public ParameterCollection SelectParameters

  97:     {

  98:         get;

  99:private set;

 100:     }

 101:  

 102:     [Description("Parameters that will be used for inserting a new entity")]

 103:public ParameterCollection InsertParameters

 104:     {

 105:         get;

 106:private set;

 107:     }

 108:  

 109:     [Description("Parameters that will be used for updating an existing entity")]

 110:public ParameterCollection UpdateParameters

 111:     {

 112:         get;

 113:private set;

 114:     }

 115:  

 116:     [Description("Parameters that will be used for deleting an existing entity")]

 117:public ParameterCollection DeleteParameters

 118:     {

 119:         get;

 120:private set;

 121:     }

 122:  

 123:     [Browsable(false)]

 124:public ISessionFactory SessionFactory

 125:     {

 126:         get;

 127:         set;

 128:     }

 129:  

 130:internalstatic ISessionFactory InternalSessionFactory

 131:     {

 132:         get;

 133:         set;

 134:     }

 135:  

 136:internal ISessionFactory EffectiveSessionFactory

 137:     {

 138:         get

 139:         {

 140:             var sessionFactory = this.SessionFactory ?? InternalSessionFactory;

 141:             var sfArgs = new BuildSessionFactoryEventArgs() { SessionFactory = sessionFactory };

 142:  

 143:this.OnBuildSessionFactory(sfArgs);

 144:  

 145:if (sfArgs.SessionFactory == null)

 146:             {

 147:                 var cfg = new Configuration().Configure();

 148:  

 149:                 var cfgArgs = new ConfigureEventArgs() { Configuration =  cfg };

 150:  

 151:this.OnConfigure(cfgArgs);

 152:  

 153:                 cfg = cfgArgs.Configuration;

 154:  

 155:                 sessionFactory = cfg.BuildSessionFactory();

 156:  

 157:if (InternalSessionFactory == null)

 158:                 {

 159:                     InternalSessionFactory = sessionFactory;

 160:                 }

 161:             }

 162:else

 163:             {

 164:                 sessionFactory = sfArgs.SessionFactory;

 165:             }

 166:  

 167:return (sessionFactory);

 168:         }

 169:     }

 170:  

 171:protectedvirtualvoid OnBuildSessionFactory(BuildSessionFactoryEventArgs e)

 172:     {

 173:         var handler = this.BuildSessionFactory;

 174:  

 175:if (handler != null)

 176:         {

 177:             handler(this, e);

 178:         }

 179:     }

 180:  

 181:protectedvirtualvoid OnConfigure(ConfigureEventArgs e)

 182:     {

 183:         var handler = this.Configure;

 184:  

 185:if (handler != null)

 186:         {

 187:             handler(this, e);

 188:         }

 189:     }

 190:  

 191:protectedvirtualvoid OnCreateInstance(CreateInstanceEventArgs e)

 192:     {

 193:         var handler = this.CreateInstance;

 194:  

 195:if (handler != null)

 196:         {

 197:             handler(this, e);

 198:         }

 199:     }

 200:  

 201:protectedvirtualvoid OnEntitiesSelecting(EntitiesSelectingEventArgs e)

 202:     {

 203:         var handler = this.EntitiesSelecting;

 204:  

 205:if (handler != null)

 206:         {

 207:             handler(this, e);

 208:         }

 209:     }

 210:  

 211:protectedvirtualvoid OnEntityInserted(EntityEventArgs e)

 212:     {

 213:         var handler = this.EntityInserted;

 214:  

 215:if (handler != null)

 216:         {

 217:             handler(this, e);

 218:         }

 219:     }

 220:  

 221:protectedvirtualvoid OnEntityDeleted(EntityEventArgs e)

 222:     {

 223:         var handler = this.EntityDeleted;

 224:  

 225:if (handler != null)

 226:         {

 227:             handler(this, e);

 228:         }

 229:     }

 230:  

 231:protectedvirtualvoid OnEntityUpdated(EntityEventArgs e)

 232:     {

 233:         var handler = this.EntityUpdated;

 234:  

 235:if (handler != null)

 236:         {

 237:             handler(this, e);

 238:         }

 239:     }

 240:  

 241:protectedvirtualvoid OnEntityInserting(EntityEventArgs e)

 242:     {

 243:         var handler = this.EntityInserting;

 244:  

 245:if (handler != null)

 246:         {

 247:             handler(this, e);

 248:         }

 249:     }

 250:  

 251:protectedvirtualvoid OnEntityDeleting(EntityEventArgs e)

 252:     {

 253:         var handler = this.EntityDeleting;

 254:  

 255:if (handler != null)

 256:         {

 257:             handler(this, e);

 258:         }

 259:     }

 260:  

 261:protectedvirtualvoid OnEntityUpdating(EntityEventArgs e)

 262:     {

 263:         var handler = this.EntityUpdating;

 264:  

 265:if (handler != null)

 266:         {

 267:             handler(this, e);

 268:         }

 269:     }

 270:  

 271:publicvirtualvoid OnEntitiesSelected(EntitiesSelectedEventArgs e)

 272:     {

 273:         var handler = this.EntitiesSelected;

 274:  

 275:if (handler != null)

 276:         {

 277:             handler(this, e);

 278:         }

 279:     }

 280:  

 281:publicvirtualvoid OnOperationCompleted(OperationCompletedEventArgs e)

 282:     {

 283:         var handler = this.OperationCompleted;

 284:  

 285:if (handler != null)

 286:         {

 287:             handler(this, e);

 288:         }

 289:     }

 290:  

 291:public Int32 Insert()

 292:     {

 293:if (String.IsNullOrWhiteSpace(this.EntityName) == true)

 294:         {

 295:throw (new InvalidOperationException("The EntityName property cannot be empty."));

 296:         }

 297:  

 298:if (this.InsertParameters.Count == 0)

 299:         {

 300:throw (new InvalidOperationException("Missing InsertParameters."));

 301:         }

 302:  

 303:using (var session = this.EffectiveSessionFactory.OpenStatelessSession())

 304:using (session.BeginTransaction())

 305:         {

 306:             var args = new EntityEventArgs(this.CreateInstanceAndSetParameters(this.InsertParameters));

 307:  

 308:this.OnEntityInserting(args);

 309:  

 310:if (args.Cancel == true)

 311:             {

 312:return (0);

 313:             }

 314:  

 315:             session.Insert(args.Entity);

 316:             session.Transaction.Commit();

 317:  

 318:this.OnEntityInserted(args);

 319:this.OnOperationCompleted(new OperationCompletedEventArgs(DataSourceOperation.Insert, args.Entity));

 320:         }

 321:  

 322:return (1);

 323:     }

 324:  

 325:public Int32 Update()

 326:     {

 327:if (String.IsNullOrWhiteSpace(this.EntityName) == true)

 328:         {

 329:throw (new InvalidOperationException("The EntityName property cannot be empty."));

 330:         }

 331:  

 332:if (this.UpdateParameters.Count == 0)

 333:         {

 334:throw (new InvalidOperationException("Missing UpdateParameters."));

 335:         }

 336:  

 337:using (var session = this.EffectiveSessionFactory.OpenStatelessSession())

 338:using (session.BeginTransaction())

 339:         {

 340:             var args = new EntityEventArgs(this.CreateInstanceAndSetParameters(this.UpdateParameters));

 341:  

 342:this.OnEntityUpdating(args);

 343:  

 344:if (args.Cancel == true)

 345:             {

 346:return (0);

 347:             }

 348:  

 349:if (this.RefreshBeforeUpdate == true)

 350:             {

 351:this.Refresh(args.Entity);

 352:             }

 353:  

 354:             session.Update(args.Entity);

 355:             session.Transaction.Commit();

 356:  

 357:this.OnEntityUpdated(args);

 358:this.OnOperationCompleted(new OperationCompletedEventArgs(DataSourceOperation.Update, args.Entity));

 359:  

 360:return (1);

 361:         }

 362:     }

 363:  

 364:public Int32 Delete()

 365:     {

 366:if (String.IsNullOrWhiteSpace(this.EntityName) == true)

 367:         {

 368:throw (new InvalidOperationException("The EntityName property cannot be empty."));

 369:         }

 370:  

 371:using (var session = this.EffectiveSessionFactory.OpenStatelessSession())

 372:using (session.BeginTransaction())

 373:         {

 374:             var args = new EntityEventArgs(this.CreateInstanceAndSetParameters(this.DeleteParameters));

 375:  

 376:this.OnEntityDeleting(args);

 377:  

 378:if (args.Cancel == true)

 379:             {

 380:return (0);

 381:             }

 382:  

 383:if (this.RefreshBeforeUpdate == true)

 384:             {

 385:this.Refresh(args.Entity);

 386:             }

 387:  

 388:             session.Delete(args.Entity);

 389:             session.Transaction.Commit();

 390:  

 391:this.OnEntityDeleted(args);

 392:this.OnOperationCompleted(new OperationCompletedEventArgs(DataSourceOperation.Delete, args.Entity));

 393:  

 394:return (1);

 395:         }

 396:     }

 397:  

 398:protectedvoid Refresh(Object entity)

 399:     {

 400:using (var session = this.EffectiveSessionFactory.OpenSession())

 401:         {

 402:             session.DefaultReadOnly = true;

 403:             session.FlushMode = FlushMode.Never;

 404:  

 405:             var metadata = this.GetMetadata(this.EntityName);

 406:             var propertiesToLoad = new List<String>();

 407:  

 408:for (var i = 0; i < metadata.PropertyNames.Length; ++i)

 409:             {

 410:if (metadata.GetPropertyValue(entity, metadata.PropertyNames[i], EntityMode.Poco) == null)

 411:                 {

 412:if (metadata.PropertyTypes[i].IsEntityType == false)

 413:                     {

 414:                         propertiesToLoad.Add(metadata.PropertyNames[i]);

 415:                     }

 416:else

 417:                     {

 418:                         propertiesToLoad.Add(String.Concat(metadata.PropertyNames[i], ".id"));

 419:                     }

 420:                 }

 421:             }

 422:  

 423:             var hql = new StringBuilder();

 424:             hql.Append("select ");

 425:             hql.Append(String.Join(", ", propertiesToLoad));

 426:             hql.AppendFormat(" from {0} where id = :id", entity.GetType().FullName);

 427:  

 428:             var query = session.CreateQuery(hql.ToString());

 429:             query.SetParameter("id", metadata.GetIdentifier(entity, EntityMode.Poco));

 430:  

 431:             var result = query.UniqueResult();

 432:             var values = (result as Object[]) ?? new Object[] { result };

 433:  

 434:for (var i = 0; i < propertiesToLoad.Count; ++i)

 435:             {

 436:                 var parts = propertiesToLoad[i].Split('.');

 437:                 var value = values[i];

 438:                 var propertyName = parts.First();

 439:  

 440:if (parts.Length > 1)

 441:                 {

 442:                     var propertyIndex = Array.IndexOf(metadata.PropertyNames, propertyName);

 443:                     var propertyType = metadata.PropertyTypes[propertyIndex].ReturnedClass;

 444:  

 445:value = session.Load(propertyType, values[i]);

 446:                 }

 447:  

 448:                 metadata.SetPropertyValue(entity, propertyName, value, EntityMode.Poco);

 449:             }

 450:         }

 451:     }

 452:  

 453:protectedinternal IDictionary<String, Object> GetParameters(ParameterCollection parameters)

 454:     {

 455:return (parameters.GetValues(this.Context, this).OfType<DictionaryEntry>().ToDictionary(x => x.Key.ToString(), x => x.Value));

 456:     }

 457:  

 458:protectedvoid SetParameterValues(Object instance, IClassMetadata metadata, IDictionary<String, Object> parameters)

 459:     {

 460:foreach (var parameter in parameters)

 461:         {

 462:if (metadata.PropertyNames.Contains(parameter.Key) == true)

 463:             {

 464:                 metadata.SetPropertyValue(instance, parameter.Key, parameter.Value, EntityMode.Poco);

 465:             }

 466:elseif (metadata.IdentifierPropertyName == parameter.Key)

 467:             {

 468:                 metadata.SetIdentifier(instance, parameter.Value, EntityMode.Poco);

 469:             }

 470:         }

 471:     }

 472:  

 473:protected Object CreateInstanceAndSetParameters(ParameterCollection parameters)

 474:     {

 475:         var metadata = this.GetMetadata(this.EntityName);

 476:  

 477:if (metadata == null)

 478:         {

 479:throw (new InvalidOperationException("Entity could not be found."));

 480:         }

 481:  

 482:         var entityType = metadata.GetMappedClass(EntityMode.Poco);

 483:  

 484:         var ciArgs = new CreateInstanceEventArgs(entityType, null);

 485:  

 486:this.OnCreateInstance(ciArgs);

 487:  

 488:if (ciArgs.Instance == null)

 489:         {

 490:             ciArgs.Instance = Activator.CreateInstance(entityType);

 491:         }

 492:  

 493:this.SetParameterValues(ciArgs.Instance, metadata, this.GetParameters(parameters));

 494:  

 495:return (ciArgs.Instance);

 496:     }

 497:  

 498:protectedinternal IClassMetadata GetMetadata(String entityName)

 499:     {

 500:         var metadata = this.EffectiveSessionFactory.GetAllClassMetadata().Where(x => x.Key.EndsWith(entityName)).Select(x => x.Value).SingleOrDefault();

 501:  

 502:return (metadata);

 503:     }

 504:  

 505:protectedinternalvoid ProcessEntitiesSelecting(EntitiesSelectingEventArgs e)

 506:     {

 507:this.OnEntitiesSelecting(e);

 508:     }

 509:  

 510:protectedinternalvoid ProcessEntitiesSelected(EntitiesSelectedEventArgs e)

 511:     {

 512:this.OnEntitiesSelected(e);

 513:this.OnOperationCompleted(new OperationCompletedEventArgs(DataSourceOperation.Select, e.Results));

 514:     }

 515:  

 516:protectedoverride QueryableDataSourceView CreateQueryableView()

 517:     {

 518:return (new NHibernateDataSourceView(this, "DefaultView", this.Context) as QueryableDataSourceView);

 519:     }

 520: }

   1:publicclass NHibernateDataSourceView : QueryableDataSourceView

   2: {

   3:privatestaticreadonly MethodInfo queryMethod = typeof (LinqExtensionMethods).GetMethod("Query", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(IStatelessSession) }, null );

   4:privatestaticreadonly MethodInfo toListMethod = typeof(Enumerable).GetMethod("ToList", BindingFlags.Public | BindingFlags.Static);

   5:  

   6:public NHibernateDataSourceView(NHibernateDataSource dataSource, String viewName, HttpContext context) : base(dataSource, viewName, context)

   7:     {

   8:this.DataSource = dataSource;

   9:     }

  10:  

  11:protected NHibernateDataSource DataSource

  12:     {

  13:         get;

  14:private set;

  15:     }

  16:  

  17:protectedoverride IEnumerable ExecuteSelect(DataSourceSelectArguments arguments)

  18:     {

  19:using (var session = this.DataSource.EffectiveSessionFactory.OpenStatelessSession())

  20:         {

  21:             var results = nullas IList;

  22:  

  23:switch (this.DataSource.Mode)

  24:             {

  25:case NHibernateDataSourceMode.Hql:

  26:                 {

  27:if (String.IsNullOrWhiteSpace(this.DataSource.Hql) == true)

  28:                     {

  29:throw (new InvalidOperationException("The Hql property cannot be empty."));

  30:                     }

  31:  

  32:                     var hql = this.DataSource.Hql;

  33:                     var parameters = this.DataSource.GetParameters(this.DataSource.SelectParameters);

  34:                     var args = new EntitiesSelectingEventArgs(hql, parameters, this.DataSource.PageSize, this.DataSource.PageIndex, this.DataSource.MaximumRecords);

  35:  

  36:this.DataSource.ProcessEntitiesSelecting(args);

  37:  

  38:                     var query = session.CreateQuery(args.Hql);

  39:  

  40:foreach (var param in args.SelectParameters)

  41:                     {

  42:if (!(param.Value is IEnumerable) || (param.Value is String) || (param.Value is Byte[]))

  43:                         {

  44:                             query.SetParameter(param.Key, param.Value);

  45:                         }

  46:else

  47:                         {

  48:                             query.SetParameterList(param.Key, param.Value as IEnumerable);

  49:                         }

  50:                     }

  51:  

  52:if (args.PageSize != 0)

  53:                     {

  54:                         query.SetMaxResults(args.PageSize);

  55:                         query.SetFirstResult(Math.Max((args.PageIndex * args.PageSize) - 1, 0));

  56:                         arguments.MaximumRows = args.PageSize;

  57:                     }

  58:  

  59:if (args.MaximumRecords != 0)

  60:                     {

  61:                         query.SetMaxResults(args.MaximumRecords);

  62:                         arguments.MaximumRows = args.MaximumRecords;

  63:                     }

  64:  

  65:                     results = query.List();

  66:  

  67:                     arguments.AddSupportedCapabilities(DataSourceCapabilities.Page);

  68:  

  69:if (args.PageSize != 0)

  70:                     {

  71:                         arguments.StartRowIndex = Math.Max((args.PageIndex * args.PageSize) - 1, 0);

  72:                     }

  73:  

  74:break;

  75:                 }

  76:  

  77:case NHibernateDataSourceMode.Linq:

  78:                 {

  79:if (String.IsNullOrWhiteSpace(this.DataSource.EntityName) == true)

  80:                     {

  81:throw (new InvalidOperationException("The EntityName property cannot be empty."));

  82:                     }

  83:  

  84:                     var query = queryMethod.MakeGenericMethod(this.EntityType).Invoke(null, new Object[] { session }) as IQueryable;

  85:  

  86:                     var qcea = new QueryCreatedEventArgs(query);

  87:  

  88:this.OnQueryCreated(qcea);

  89:  

  90:                     var esaea = new EntitiesSelectingEventArgs(qcea.Query);

  91:  

  92:this.DataSource.ProcessEntitiesSelecting(esaea);

  93:  

  94:                     results = toListMethod.MakeGenericMethod(this.EntityType).Invoke(null, new Object[] { esaea.Query }) as IList;

  95:  

  96:                     arguments.AddSupportedCapabilities(DataSourceCapabilities.Page | DataSourceCapabilities.Sort);

  97:  

  98:break;

  99:                 }

 100:             }

 101:  

 102:             var entitiesSelectedArgs = new EntitiesSelectedEventArgs(results);

 103:  

 104:this.DataSource.ProcessEntitiesSelected(entitiesSelectedArgs);

 105:  

 106:return (entitiesSelectedArgs.Results);

 107:         }

 108:     }

 109:  

 110:protectedoverride Type EntityType

 111:     {

 112:         get

 113:         {

 114:return (this.DataSource.GetMetadata(this.DataSource.EntityName).GetMappedClass(EntityMode.Poco));

 115:         }

 116:     }

 117:  

 118:protectedoverride Object GetSource(QueryContext context)

 119:     {

 120:thrownew NotImplementedException();

 121:     }

 122:  

 123:protectedoverridevoid HandleValidationErrors(IDictionary<String, Exception> errors, DataSourceOperation operation)

 124:     {

 125:     }

 126: }

   1:publicenum NHibernateDataSourceMode

   2: {

   3:     Linq,

   4:     Hql

   5: }

   1: [Serializable]

   2:publicsealedclass BuildSessionFactoryEventArgs : EventArgs

   3: {

   4:public ISessionFactory SessionFactory

   5:     {

   6:         get;

   7:         set;

   8:     }

   9: }

  10:  

  11: [Serializable]

  12:publicsealedclass ConfigureEventArgs : EventArgs

  13: {

  14:public Configuration Configuration

  15:     {

  16:         get;

  17:         set;

  18:     }

  19: }

  20:  

  21: [Serializable]

  22:publicsealedclass CreateInstanceEventArgs : EventArgs

  23: {

  24:public CreateInstanceEventArgs(Type type, Object instance)

  25:     {

  26:this.Type = type;

  27:this.Instance = instance;

  28:     }

  29:  

  30:public Type Type

  31:     {

  32:         get;

  33:private set;

  34:     }

  35:  

  36:public Object Instance

  37:     {

  38:         get;

  39:         set;

  40:     }

  41: }

  42:  

  43: [Serializable]

  44:publicsealedclass EntitiesSelectedEventArgs : EventArgs

  45: {

  46:public EntitiesSelectedEventArgs(IList results)

  47:     {

  48:this.Results = results;

  49:     }

  50:  

  51:public IList Results

  52:     {

  53:         get;

  54:         set;

  55:     }

  56: }

  57:  

  58: [Serializable]

  59:publicsealedclass EntitiesSelectingEventArgs : EventArgs

  60: {

  61:public EntitiesSelectingEventArgs(IQueryable query)

  62:     {

  63:this.Query = query;

  64:     }

  65:  

  66:public EntitiesSelectingEventArgs(String hql, IDictionary<String, Object> selectParameters, Int32 pageSize, Int32 pageIndex, Int32 maximumRecords)

  67:     {

  68:this.Hql = hql;

  69:this.SelectParameters = selectParameters;

  70:this.PageSize = pageSize;

  71:this.PageIndex = pageIndex;

  72:this.MaximumRecords = maximumRecords;

  73:     }

  74:  

  75:public IQueryable Query

  76:     {

  77:         get;

  78:         set;

  79:     }

  80:  

  81:public String Hql

  82:     {

  83:         get;

  84:         set;

  85:     }

  86:  

  87:public IDictionary<String, Object> SelectParameters

  88:     {

  89:         get;

  90:private set;

  91:     }

  92:  

  93:public Int32 PageSize

  94:     {

  95:         get;

  96:         set;

  97:     }

  98:  

  99:public Int32 PageIndex

 100:     {

 101:         get;

 102:         set;

 103:     }

 104:  

 105:public Int32 MaximumRecords

 106:     {

 107:         get;

 108:         set;

 109:     }

 110: }

 111:  

 112: [Serializable]

 113:publicsealedclass EntityEventArgs : CancelEventArgs

 114: {

 115:public EntityEventArgs(Object entity)

 116:     {

 117:this.Entity = entity;

 118:     }

 119:  

 120:public Object Entity

 121:     {

 122:         get; 

 123:         set;

 124:     }

 125: }

 126:  

 127: [Serializable]

 128:publicsealedclass OperationCompletedEventArgs : EventArgs

 129: {

 130:public OperationCompletedEventArgs(DataSourceOperation operation, Object entity)

 131:     {

 132:this.Entity = entity;

 133:this.Operation = operation;

 134:     }

 135:  

 136:public OperationCompletedEventArgs(DataSourceOperation operation, IList results)

 137:     {

 138:this.Results = results;

 139:this.Operation = operation;

 140:     }

 141:  

 142:public DataSourceOperation Operation

 143:     {

 144:         get;

 145:private set;

 146:     }

 147:  

 148:public Object Entity

 149:     {

 150:         get;

 151:protected set;

 152:     }

 153:  

 154:public IList Results

 155:     {

 156:         get;

 157:private set;

 158:     }

 159: }

   1:<nh:NHibernateDataSourcerunat="server"ID="nhds"RefreshBeforeUpdate="true"EntityName="Product"Mode="Hql"Hql="fromProductpwheresize(p.OrderDetails) > :size">

   2:<SelectParameters>

   3:<asp:ParameterName="size"DefaultValue="1"Type="Int32"/>

   4:</SelectParameters>

   5:<InsertParameters>

   6:<asp:ParameterName="Name"DefaultValue="Some Name"Type="String"/>

   7:<asp:ParameterName="Price"DefaultValue="100"Type="Decimal"/>

   8:</InsertParameters>

   9:<UpdateParameters>

  10:<asp:QueryStringParameterName="ProductId"QueryStringField="ProductId"Type="Int32"/>

  11:<asp:QueryStringParameterName="Price"DefaultValue="50"Type="Decimal"/>

  12:</UpdateParameters>

  13:<DeleteParameters>

  14:<asp:QueryStringParameterName="ProductId"QueryStringField="ProductId"Type="Int32"/>

  15:</DeleteParameters>

  16:</nh:NHibernateDataSource>

   1:publicsealedclass EntityParameter : Parameter

   2: {

   3:public EntityParameter()

   4:     {

   5:this.Lazy = true;

   6:     }

   7:  

   8:public String EntityName

   9:     {

  10:         get;

  11:         set;

  12:     }

  13:  

  14:public Object Id

  15:     {

  16:         get;

  17:         set;

  18:     }

  19:  

  20:public Boolean Lazy

  21:     {

  22:         get;

  23:         set;

  24:     }

  25:  

  26:protectedoverride Parameter Clone()

  27:     {

  28:return (new EntityParameter(){ EntityName = this.EntityName, Id = this.Id });

  29:     }

  30:  

  31:protectedoverride Object Evaluate(HttpContext context, Control control)

  32:     {

  33:         var dataSource = control as NHibernateDataSource;

  34:  

  35:if (dataSource == null)

  36:         {

  37:throw (new InvalidOperationException("EntityParameter can only be used with NHibernateDataSource."));

  38:         }

  39:  

  40:using (var session = dataSource.EffectiveSessionFactory.OpenStatelessSession())

  41:         {

  42:             var metadata = dataSource.GetMetadata(this.EntityName);

  43:  

  44:if (metadata == null)

  45:             {

  46:throw (new InvalidOperationException("Entity could not be found."));

  47:             }

  48:  

  49:             var entityType = metadata.GetMappedClass(EntityMode.Poco);

  50:             var idType = metadata.IdentifierType.ReturnedClass;

  51:             var id = Convert.ChangeType(this.Id, idType);

  52:             var entity = (this.Lazy == true) ? (metadata as IEntityPersister).CreateProxy(id, session.GetSessionImplementation()) : session.Get(entityType.FullName, id);

  53:  

  54:return (entity);

  55:         }

  56:     }

  57: }

   1:<asp:TextBoxrunat="server"ID="name"/>

   2:  

   3:<asp:QueryExtenderrunat="server"TargetControlID="nhds">

   4:<asp:SearchExpressionDataFields="Name"SearchType="StartsWith">

   5:<asp:ControlParameterControlID="name"/>

   6:</asp:SearchExpression>

   7:<asp:OrderByExpressionDataField="Price"Direction="Descending"/>

   8:</asp:QueryExtender>

   9:  

  10:<nh:NHibernateDataSourcerunat="server"ID="nhds"RefreshBeforeUpdate="true"EntityName="Product"Mode="Linq">

  11:<InsertParameters>

  12:<asp:ParameterName="Name"DefaultValue="Some Name"Type="String"/>

  13:<asp:ParameterName="Price"DefaultValue="100"Type="Decimal"/>

  14:</InsertParameters>

  15:<UpdateParameters>

  16:<asp:QueryStringParameterQueryStringField="ProductId"Name="ProductId"Type="Int32"/>

  17:<asp:ParameterName="Price"DefaultValue="50"Type="Decimal"/>

  18:</UpdateParameters>

  19:<DeleteParameters>

  20:<asp:QueryStringParameterQueryStringField="ProductId"Name="ProductId"Type="Int32"/>

  21:</DeleteParameters>

  22:</nh:NHibernateDataSource>