mcs/class/System.Web/System.Web.UI.WebControls/ObjectDataSource.cs

   1 //
   2 // System.Web.UI.WebControls.ObjectDataSource
   3 //
   4 // Authors:
   5 //  Lluis Sanchez Gual (lluis@novell.com)
   6 //
   7 // (C) 2005 Novell, Inc. (http://www.novell.com)
   8 //
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 using System.Collections;
  32 using System.Collections.Specialized;
  33 using System.ComponentModel;
  34 using System.IO;
  35 using System.Security.Permissions;
  36 using System.Drawing;
  37
  38 namespace System.Web.UI.WebControls
  39 {
  40
  41         [DefaultEventAttribute ("Selecting")]
  42         [DefaultPropertyAttribute ("TypeName")]
  43         [DesignerAttribute ("System.Web.UI.Design.WebControls.ObjectDataSourceDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  44         [ParseChildrenAttribute (true)]
  45         [PersistChildrenAttribute (false)]
  46         [AspNetHostingPermissionAttribute (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  47         [AspNetHostingPermissionAttribute (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  48         [ToolboxBitmap ("bitmap file goes here")]
  49         public class ObjectDataSource : DataSourceControl
  50         {
  51                 static readonly string [] emptyNames = new string [] { "DefaultView" };
  52                 ObjectDataSourceView defaultView;
  53
  54                 int cacheDuration = 0;
  55                 bool enableCaching = false;
  56                 string cacheKeyDependency = null;
  57                 string sqlCacheDependency = null;
  58                 DataSourceCacheManager cache = null;
  59                 DataSourceCacheExpiry cacheExpirationPolicy = DataSourceCacheExpiry.Absolute;
  60
  61                 public ObjectDataSource ()
  62                 {
  63                 }
  64
  65                 public ObjectDataSource (string typeName, string selectMethod)
  66                 {
  67                         SelectMethod = selectMethod;
  68                         TypeName = typeName;
  69                 }
  70
  71                 ObjectDataSourceView DefaultView {
  72                         get {
  73                                 if (defaultView == null) {
  74                                         defaultView = new ObjectDataSourceView (this, emptyNames [0], Context);
  75                                         if (IsTrackingViewState)
  76                                                 ((IStateManager) defaultView).TrackViewState ();
  77                                 }
  78                                 return defaultView;
  79                         }
  80                 }
  81
  82                 public event ObjectDataSourceStatusEventHandler Deleted {
  83                         add { DefaultView.Deleted += value; }
  84                         remove { DefaultView.Deleted -= value; }
  85                 }
  86
  87                 public event ObjectDataSourceMethodEventHandler Deleting {
  88                         add { DefaultView.Deleting += value; }
  89                         remove { DefaultView.Deleting -= value; }
  90                 }
  91
  92                 public event ObjectDataSourceFilteringEventHandler Filtering {
  93                         add { DefaultView.Filtering += value; }
  94                         remove { DefaultView.Filtering -= value; }
  95                 }
  96
  97                 public event ObjectDataSourceStatusEventHandler Inserted {
  98                         add { DefaultView.Inserted += value; }
  99                         remove { DefaultView.Inserted -= value; }
 100                 }
 101
 102                 public event ObjectDataSourceMethodEventHandler Inserting {
 103                         add { DefaultView.Inserting += value; }
 104                         remove { DefaultView.Inserting -= value; }
 105                 }
 106
 107                 public event ObjectDataSourceObjectEventHandler ObjectCreated {
 108                         add { DefaultView.ObjectCreated += value; }
 109                         remove { DefaultView.ObjectCreated -= value; }
 110                 }
 111
 112                 public event ObjectDataSourceObjectEventHandler ObjectCreating {
 113                         add { DefaultView.ObjectCreating += value; }
 114                         remove { DefaultView.ObjectCreating -= value; }
 115                 }
 116
 117                 public event ObjectDataSourceDisposingEventHandler ObjectDisposing {
 118                         add { DefaultView.ObjectDisposing += value; }
 119                         remove { DefaultView.ObjectDisposing -= value; }
 120                 }
 121
 122                 /*              public event ObjectDataSourceResolvingMethodEventHandler ResolvingMethod {
 123                                 add { DefaultView.ResolvingMethod += value; }
 124                                 remove { DefaultView.ResolvingMethod -= value; }
 125                                 }
 126                 */
 127                 public event ObjectDataSourceStatusEventHandler Selected {
 128                         add { DefaultView.Selected += value; }
 129                         remove { DefaultView.Selected -= value; }
 130                 }
 131
 132                 public event ObjectDataSourceSelectingEventHandler Selecting {
 133                         add { DefaultView.Selecting += value; }
 134                         remove { DefaultView.Selecting -= value; }
 135                 }
 136
 137                 public event ObjectDataSourceStatusEventHandler Updated {
 138                         add { DefaultView.Updated += value; }
 139                         remove { DefaultView.Updated -= value; }
 140                 }
 141
 142                 public event ObjectDataSourceMethodEventHandler Updating {
 143                         add { DefaultView.Updating += value; }
 144                         remove { DefaultView.Updating -= value; }
 145                 }
 146
 147                 [DefaultValue (0)]
 148                 [TypeConverter (typeof (DataSourceCacheDurationConverter))]
 149                 public virtual int CacheDuration
 150                 {
 151                         get {
 152                                 return cacheDuration;
 153                         }
 154                         set {
 155                                 if (value < 0)
 156                                         throw new ArgumentOutOfRangeException ("value", "The duration must be non-negative");
 157
 158                                 cacheDuration = value;
 159                         }
 160                 }
 161
 162                 [DefaultValue (DataSourceCacheExpiry.Absolute)]
 163                 public virtual DataSourceCacheExpiry CacheExpirationPolicy
 164                 {
 165                         get {
 166                                 return cacheExpirationPolicy;
 167                         }
 168                         set {
 169                                 cacheExpirationPolicy = value;
 170                         }
 171                 }
 172
 173                 [DefaultValue ("")]
 174                 public virtual string CacheKeyDependency
 175                 {
 176                         get {
 177                                 return cacheKeyDependency != null ? cacheKeyDependency : string.Empty;
 178                         }
 179                         set {
 180                                 cacheKeyDependency = value;
 181                         }
 182                 }
 183
 184                 [WebCategoryAttribute ("Data")]
 185                 [DefaultValueAttribute (ConflictOptions.OverwriteChanges)]
 186                 public ConflictOptions ConflictDetection {
 187                         get { return DefaultView.ConflictDetection; }
 188                         set { DefaultView.ConflictDetection = value; }
 189                 }
 190
 191                 [DefaultValue (false)]
 192                 public bool ConvertNullToDBNull
 193                 {
 194                         get {
 195                                 return DefaultView.ConvertNullToDBNull;
 196                         }
 197                         set {
 198                                 DefaultView.ConvertNullToDBNull = value;
 199                         }
 200                 }
 201
 202                 [WebCategoryAttribute ("Data")]
 203                 [DefaultValueAttribute ("")]
 204                 public string DataObjectTypeName {
 205                         get { return DefaultView.DataObjectTypeName; }
 206                         set { DefaultView.DataObjectTypeName = value; }
 207                 }
 208
 209                 [WebCategoryAttribute ("Data")]
 210                 [DefaultValueAttribute ("")]
 211                 public string DeleteMethod {
 212                         get { return DefaultView.DeleteMethod; }
 213                         set { DefaultView.DeleteMethod = value; }
 214                 }
 215
 216                 [WebCategoryAttribute ("Data")]
 217                 [MergablePropertyAttribute (false)]
 218                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 219                 [DefaultValueAttribute (null)]
 220                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 221                 public ParameterCollection DeleteParameters {
 222                         get { return DefaultView.DeleteParameters; }
 223                 }
 224
 225                 [DefaultValue (false)]
 226                 public virtual bool EnableCaching {
 227                         get { return enableCaching; }
 228                         set { enableCaching = value; }
 229                 }
 230
 231                 [WebCategoryAttribute ("Paging")]
 232                 [DefaultValueAttribute (false)]
 233                 public bool EnablePaging {
 234                         get { return DefaultView.EnablePaging; }
 235                         set { DefaultView.EnablePaging = value; }
 236                 }
 237
 238                 [WebCategoryAttribute ("Data")]
 239                 [DefaultValueAttribute ("")]
 240                 public string FilterExpression {
 241                         get { return DefaultView.FilterExpression; }
 242                         set { DefaultView.FilterExpression = value; }
 243                 }
 244
 245                 [WebCategoryAttribute ("Data")]
 246                 [MergablePropertyAttribute (false)]
 247                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 248                 [DefaultValueAttribute (null)]
 249                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 250                 public ParameterCollection FilterParameters {
 251                         get { return DefaultView.FilterParameters; }
 252                 }
 253
 254                 [DefaultValueAttribute ("")]
 255                 [WebCategoryAttribute ("Data")]
 256                 public string InsertMethod {
 257                         get { return DefaultView.InsertMethod; }
 258                         set { DefaultView.InsertMethod = value; }
 259                 }
 260
 261                 [WebCategoryAttribute ("Data")]
 262                 [MergablePropertyAttribute (false)]
 263                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 264                 [DefaultValueAttribute (null)]
 265                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 266                 public ParameterCollection InsertParameters {
 267                         get { return DefaultView.InsertParameters; }
 268                 }
 269
 270                 [WebCategoryAttribute ("Paging")]
 271                 [DefaultValueAttribute ("maximumRows")]
 272                 public string MaximumRowsParameterName {
 273                         get { return DefaultView.MaximumRowsParameterName; }
 274                         set { DefaultView.MaximumRowsParameterName = value; }
 275                 }
 276
 277                 [WebCategoryAttribute ("Data")]
 278                 [DefaultValueAttribute ("{0}")]
 279                 public string OldValuesParameterFormatString {
 280                         get { return DefaultView.OldValuesParameterFormatString; }
 281                         set { DefaultView.OldValuesParameterFormatString = value; }
 282                 }
 283
 284                 [WebCategoryAttribute ("Paging")]
 285                 [DefaultValueAttribute ("")]
 286                 public string SelectCountMethod {
 287                         get { return DefaultView.SelectCountMethod; }
 288                         set { DefaultView.SelectCountMethod = value; }
 289                 }
 290
 291                 [DefaultValueAttribute ("")]
 292                 [WebCategoryAttribute ("Data")]
 293                 public string SelectMethod {
 294                         get { return DefaultView.SelectMethod; }
 295                         set { DefaultView.SelectMethod = value; }
 296                 }
 297
 298                 [WebCategoryAttribute ("Data")]
 299                 [MergablePropertyAttribute (false)]
 300                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 301                 [DefaultValueAttribute (null)]
 302                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 303                 public ParameterCollection SelectParameters {
 304                         get { return DefaultView.SelectParameters; }
 305                 }
 306
 307                 [DefaultValueAttribute ("")]
 308                 [WebCategoryAttribute ("Data")]
 309                 public string SortParameterName {
 310                         get { return DefaultView.SortParameterName; }
 311                         set { DefaultView.SortParameterName = value; }
 312                 }
 313
 314                 [MonoTODO ("SQLServer specific")]
 315                 [DefaultValue ("")]
 316                 public virtual string SqlCacheDependency {
 317                         get { return sqlCacheDependency != null ? sqlCacheDependency : string.Empty; }
 318                         set { sqlCacheDependency = value; }
 319                 }
 320
 321                 [WebCategoryAttribute ("Paging")]
 322                 [DefaultValueAttribute ("startRowIndex")]
 323                 public string StartRowIndexParameterName {
 324                         get { return DefaultView.StartRowIndexParameterName; }
 325                         set { DefaultView.StartRowIndexParameterName = value; }
 326                 }
 327
 328                 [DefaultValueAttribute ("")]
 329                 [WebCategoryAttribute ("Data")]
 330                 public string TypeName {
 331                         get { return DefaultView.TypeName; }
 332                         set { DefaultView.TypeName = value; }
 333                 }
 334
 335                 [DefaultValueAttribute ("")]
 336                 [WebCategoryAttribute ("Data")]
 337                 public string UpdateMethod {
 338                         get { return DefaultView.UpdateMethod; }
 339                         set { DefaultView.UpdateMethod = value; }
 340                 }
 341
 342                 [WebCategoryAttribute ("Data")]
 343                 [MergablePropertyAttribute (false)]
 344                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 345                 [DefaultValueAttribute (null)]
 346                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 347                 public ParameterCollection UpdateParameters {
 348                         get { return DefaultView.UpdateParameters; }
 349                 }
 350
 351                 internal DataSourceCacheManager Cache {
 352                         get {
 353                                 if (cache == null)
 354                                         cache = new DataSourceCacheManager (CacheDuration, CacheKeyDependency, CacheExpirationPolicy, this, Context);
 355                                 return cache;
 356                         }
 357                 }
 358
 359                 protected override DataSourceView GetView (string viewName)
 360                 {
 361                         if (viewName == null)
 362                                 throw new ArgumentException ("viewName");
 363
 364                         return DefaultView;
 365                 }
 366
 367                 protected override ICollection GetViewNames ()
 368                 {
 369                         return emptyNames;
 370                 }
 371
 372                 public IEnumerable Select ()
 373                 {
 374                         return DefaultView.Select (DataSourceSelectArguments.Empty);
 375                 }
 376
 377                 public int Update ()
 378                 {
 379                         Hashtable empty = new Hashtable ();
 380                         return DefaultView.Update (empty, empty, null);
 381                 }
 382
 383                 public int Delete ()
 384                 {
 385                         Hashtable empty = new Hashtable ();
 386                         return DefaultView.Delete (empty, null);
 387                 }
 388
 389                 public int Insert ()
 390                 {
 391                         Hashtable empty = new Hashtable ();
 392                         return DefaultView.Insert (empty);
 393                 }
 394
 395                 protected internal override void OnInit (EventArgs e)
 396                 {
 397                         Page.LoadComplete += OnPageLoadComplete;
 398                 }
 399
 400                 void OnPageLoadComplete (object sender, EventArgs e)
 401                 {
 402                         FilterParameters.UpdateValues (Context, this);
 403                         SelectParameters.UpdateValues (Context, this);
 404                 }
 405
 406                 protected override void LoadViewState (object savedState)
 407                 {
 408                         if (savedState == null) {
 409                                 base.LoadViewState (null);
 410                                 ((IStateManager)DefaultView).LoadViewState (null);
 411                         } else {
 412                                 Pair p = (Pair) savedState;
 413                                 base.LoadViewState (p.First);
 414                                 ((IStateManager)DefaultView).LoadViewState (p.Second);
 415                         }
 416                 }
 417
 418                 protected override object SaveViewState()
 419                 {
 420                         object baseState = base.SaveViewState ();
 421                         object viewState = ((IStateManager)DefaultView).SaveViewState ();
 422                         if (baseState != null || viewState != null) return new Pair (baseState, viewState);
 423                         else return null;
 424                 }
 425
 426                 protected override void TrackViewState()
 427                 {
 428                         ((IStateManager)DefaultView).TrackViewState ();
 429                 }
 430         }
 431 }
 432
 433