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 #if NET_2_0
  32 using System.Collections;
  33 using System.Collections.Specialized;
  34 using System.ComponentModel;
  35 using System.IO;
  36 using System.Security.Permissions;
  37 using System.Drawing;
  38
  39 namespace System.Web.UI.WebControls
  40 {
  41
  42         [DefaultEventAttribute ("Selecting")]
  43         [DefaultPropertyAttribute ("TypeName")]
  44         [DesignerAttribute ("System.Web.UI.Design.WebControls.ObjectDataSourceDesigner, " + Consts.AssemblySystem_Design, "System.ComponentModel.Design.IDesigner")]
  45         [ParseChildrenAttribute (true)]
  46         [PersistChildrenAttribute (false)]
  47         [AspNetHostingPermissionAttribute (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  48         [AspNetHostingPermissionAttribute (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  49         [ToolboxBitmap ("bitmap file goes here")]
  50         public class ObjectDataSource : DataSourceControl
  51         {
  52                 static readonly string [] emptyNames = new string [] { "DefaultView" };
  53                 ObjectDataSourceView defaultView;
  54
  55                 int cacheDuration = 0;
  56                 bool enableCaching = false;
  57                 string cacheKeyDependency = null;
  58                 string sqlCacheDependency = null;
  59                 DataSourceCacheManager cache = null;
  60                 DataSourceCacheExpiry cacheExpirationPolicy = DataSourceCacheExpiry.Absolute;
  61
  62                 public ObjectDataSource ()
  63                 {
  64                 }
  65
  66                 public ObjectDataSource (string typeName, string selectMethod)
  67                 {
  68                         SelectMethod = selectMethod;
  69                         TypeName = typeName;
  70                 }
  71
  72                 ObjectDataSourceView DefaultView {
  73                         get {\r
  74                                 if (defaultView == null) {\r
  75                                         defaultView = new ObjectDataSourceView (this, emptyNames [0], Context);\r
  76                                         if (IsTrackingViewState)\r
  77                                                 ((IStateManager) defaultView).TrackViewState ();\r
  78                                 }
  79                                 return defaultView;
  80                         }
  81                 }
  82
  83                 public event ObjectDataSourceStatusEventHandler Deleted {
  84                         add { DefaultView.Deleted += value; }
  85                         remove { DefaultView.Deleted -= value; }
  86                 }
  87
  88                 public event ObjectDataSourceMethodEventHandler Deleting {
  89                         add { DefaultView.Deleting += value; }
  90                         remove { DefaultView.Deleting -= value; }
  91                 }
  92
  93                 public event ObjectDataSourceFilteringEventHandler Filtering {
  94                         add { DefaultView.Filtering += value; }
  95                         remove { DefaultView.Filtering -= value; }
  96                 }
  97
  98                 public event ObjectDataSourceStatusEventHandler Inserted {
  99                         add { DefaultView.Inserted += value; }
 100                         remove { DefaultView.Inserted -= value; }
 101                 }
 102
 103                 public event ObjectDataSourceMethodEventHandler Inserting {
 104                         add { DefaultView.Inserting += value; }
 105                         remove { DefaultView.Inserting -= value; }
 106                 }
 107
 108                 public event ObjectDataSourceObjectEventHandler ObjectCreated {
 109                         add { DefaultView.ObjectCreated += value; }
 110                         remove { DefaultView.ObjectCreated -= value; }
 111                 }
 112
 113                 public event ObjectDataSourceObjectEventHandler ObjectCreating {
 114                         add { DefaultView.ObjectCreating += value; }
 115                         remove { DefaultView.ObjectCreating -= value; }
 116                 }
 117
 118                 public event ObjectDataSourceDisposingEventHandler ObjectDisposing {
 119                         add { DefaultView.ObjectDisposing += value; }
 120                         remove { DefaultView.ObjectDisposing -= value; }
 121                 }
 122
 123                 /*              public event ObjectDataSourceResolvingMethodEventHandler ResolvingMethod {
 124                                 add { DefaultView.ResolvingMethod += value; }
 125                                 remove { DefaultView.ResolvingMethod -= value; }
 126                                 }
 127                 */
 128                 public event ObjectDataSourceStatusEventHandler Selected {
 129                         add { DefaultView.Selected += value; }
 130                         remove { DefaultView.Selected -= value; }
 131                 }
 132
 133                 public event ObjectDataSourceSelectingEventHandler Selecting {
 134                         add { DefaultView.Selecting += value; }
 135                         remove { DefaultView.Selecting -= value; }
 136                 }
 137
 138                 public event ObjectDataSourceStatusEventHandler Updated {
 139                         add { DefaultView.Updated += value; }
 140                         remove { DefaultView.Updated -= value; }
 141                 }
 142
 143                 public event ObjectDataSourceMethodEventHandler Updating {
 144                         add { DefaultView.Updating += value; }
 145                         remove { DefaultView.Updating -= value; }
 146                 }
 147
 148                 [DefaultValue (0)]
 149                 [TypeConverter ("System.Web.UI.DataSourceCacheDurationConverter, " + Consts.AssemblySystem_Web)]
 150                 public virtual int CacheDuration
 151                 {
 152                         get {
 153                                 return cacheDuration;
 154                         }
 155                         set {
 156                                 if (value < 0)
 157                                         throw new ArgumentOutOfRangeException ("value", "The duration must be non-negative");
 158
 159                                 cacheDuration = value;
 160                         }
 161                 }
 162
 163                 [DefaultValue (DataSourceCacheExpiry.Absolute)]
 164                 public virtual DataSourceCacheExpiry CacheExpirationPolicy
 165                 {
 166                         get {
 167                                 return cacheExpirationPolicy;
 168                         }
 169                         set {
 170                                 cacheExpirationPolicy = value;
 171                         }
 172                 }
 173
 174                 [DefaultValue ("")]
 175                 public virtual string CacheKeyDependency
 176                 {
 177                         get {
 178                                 return cacheKeyDependency != null ? cacheKeyDependency : string.Empty;
 179                         }
 180                         set {
 181                                 cacheKeyDependency = value;
 182                         }
 183                 }
 184
 185                 [WebCategoryAttribute ("Data")]
 186                 [DefaultValueAttribute (ConflictOptions.OverwriteChanges)]
 187                 public ConflictOptions ConflictDetection {
 188                         get { return DefaultView.ConflictDetection; }
 189                         set { DefaultView.ConflictDetection = value; }
 190                 }
 191
 192                 [DefaultValue (false)]
 193                 public bool ConvertNullToDBNull
 194                 {
 195                         get {
 196                                 return DefaultView.ConvertNullToDBNull;
 197                         }
 198                         set {
 199                                 DefaultView.ConvertNullToDBNull = value;
 200                         }
 201                 }
 202
 203                 [WebCategoryAttribute ("Data")]
 204                 [DefaultValueAttribute ("")]
 205                 public string DataObjectTypeName {
 206                         get { return DefaultView.DataObjectTypeName; }
 207                         set { DefaultView.DataObjectTypeName = value; }
 208                 }
 209
 210                 [WebCategoryAttribute ("Data")]
 211                 [DefaultValueAttribute ("")]
 212                 public string DeleteMethod {
 213                         get { return DefaultView.DeleteMethod; }
 214                         set { DefaultView.DeleteMethod = value; }
 215                 }
 216
 217                 [WebCategoryAttribute ("Data")]
 218                 [MergablePropertyAttribute (false)]
 219                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 220                 [DefaultValueAttribute (null)]
 221                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 222                 public ParameterCollection DeleteParameters {
 223                         get { return DefaultView.DeleteParameters; }
 224                 }
 225
 226                 [DefaultValue (false)]
 227                 public virtual bool EnableCaching {
 228                         get { return enableCaching; }
 229                         set { enableCaching = value; }
 230                 }
 231
 232                 [WebCategoryAttribute ("Paging")]
 233                 [DefaultValueAttribute (false)]
 234                 public bool EnablePaging {
 235                         get { return DefaultView.EnablePaging; }
 236                         set { DefaultView.EnablePaging = value; }
 237                 }
 238
 239                 [WebCategoryAttribute ("Data")]
 240                 [DefaultValueAttribute ("")]
 241                 public string FilterExpression {
 242                         get { return DefaultView.FilterExpression; }
 243                         set { DefaultView.FilterExpression = value; }
 244                 }
 245
 246                 [WebCategoryAttribute ("Data")]
 247                 [MergablePropertyAttribute (false)]
 248                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 249                 [DefaultValueAttribute (null)]
 250                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 251                 public ParameterCollection FilterParameters {
 252                         get { return DefaultView.FilterParameters; }
 253                 }
 254
 255                 [DefaultValueAttribute ("")]
 256                 [WebCategoryAttribute ("Data")]
 257                 public string InsertMethod {
 258                         get { return DefaultView.InsertMethod; }
 259                         set { DefaultView.InsertMethod = value; }
 260                 }
 261
 262                 [WebCategoryAttribute ("Data")]
 263                 [MergablePropertyAttribute (false)]
 264                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 265                 [DefaultValueAttribute (null)]
 266                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 267                 public ParameterCollection InsertParameters {
 268                         get { return DefaultView.InsertParameters; }
 269                 }
 270
 271                 [WebCategoryAttribute ("Paging")]
 272                 [DefaultValueAttribute ("maximumRows")]
 273                 public string MaximumRowsParameterName {
 274                         get { return DefaultView.MaximumRowsParameterName; }
 275                         set { DefaultView.MaximumRowsParameterName = value; }
 276                 }
 277
 278                 [WebCategoryAttribute ("Data")]
 279                 [DefaultValueAttribute ("{0}")]
 280                 public string OldValuesParameterFormatString {
 281                         get { return DefaultView.OldValuesParameterFormatString; }
 282                         set { DefaultView.OldValuesParameterFormatString = value; }
 283                 }
 284
 285                 [WebCategoryAttribute ("Paging")]
 286                 [DefaultValueAttribute ("")]
 287                 public string SelectCountMethod {
 288                         get { return DefaultView.SelectCountMethod; }
 289                         set { DefaultView.SelectCountMethod = value; }
 290                 }
 291
 292                 [DefaultValueAttribute ("")]
 293                 [WebCategoryAttribute ("Data")]
 294                 public string SelectMethod {
 295                         get { return DefaultView.SelectMethod; }
 296                         set { DefaultView.SelectMethod = value; }
 297                 }
 298
 299                 [WebCategoryAttribute ("Data")]
 300                 [MergablePropertyAttribute (false)]
 301                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 302                 [DefaultValueAttribute (null)]
 303                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 304                 public ParameterCollection SelectParameters {
 305                         get { return DefaultView.SelectParameters; }
 306                 }
 307
 308                 [DefaultValueAttribute ("")]
 309                 [WebCategoryAttribute ("Data")]
 310                 public string SortParameterName {
 311                         get { return DefaultView.SortParameterName; }
 312                         set { DefaultView.SortParameterName = value; }
 313                 }
 314
 315                 [MonoTODO ("SQLServer specific")]
 316                 [DefaultValue ("")]
 317                 public virtual string SqlCacheDependency {
 318                         get { return sqlCacheDependency != null ? sqlCacheDependency : string.Empty; }
 319                         set { sqlCacheDependency = value; }
 320                 }
 321
 322                 [WebCategoryAttribute ("Paging")]
 323                 [DefaultValueAttribute ("startRowIndex")]
 324                 public string StartRowIndexParameterName {
 325                         get { return DefaultView.StartRowIndexParameterName; }
 326                         set { DefaultView.StartRowIndexParameterName = value; }
 327                 }
 328
 329                 [DefaultValueAttribute ("")]
 330                 [WebCategoryAttribute ("Data")]
 331                 public string TypeName {
 332                         get { return DefaultView.TypeName; }
 333                         set { DefaultView.TypeName = value; }
 334                 }
 335
 336                 [DefaultValueAttribute ("")]
 337                 [WebCategoryAttribute ("Data")]
 338                 public string UpdateMethod {
 339                         get { return DefaultView.UpdateMethod; }
 340                         set { DefaultView.UpdateMethod = value; }
 341                 }
 342
 343                 [WebCategoryAttribute ("Data")]
 344                 [MergablePropertyAttribute (false)]
 345                 [EditorAttribute ("System.Web.UI.Design.WebControls.ParameterCollectionEditor, " + Consts.AssemblySystem_Design, "System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
 346                 [DefaultValueAttribute (null)]
 347                 [PersistenceModeAttribute (PersistenceMode.InnerProperty)]
 348                 public ParameterCollection UpdateParameters {
 349                         get { return DefaultView.UpdateParameters; }
 350                 }
 351
 352                 internal DataSourceCacheManager Cache {
 353                         get {
 354                                 if (cache == null)
 355                                         cache = new DataSourceCacheManager (CacheDuration, CacheKeyDependency, CacheExpirationPolicy, this, Context);
 356                                 return cache;
 357                         }
 358                 }
 359
 360                 protected override DataSourceView GetView (string viewName)
 361                 {
 362                         if (viewName == null)
 363                                 throw new ArgumentException ("viewName");
 364
 365                         return DefaultView;
 366                 }
 367
 368                 protected override ICollection GetViewNames ()
 369                 {
 370                         return emptyNames;
 371                 }
 372
 373                 public IEnumerable Select ()
 374                 {
 375                         return DefaultView.Select (DataSourceSelectArguments.Empty);
 376                 }
 377
 378                 public int Update ()
 379                 {
 380                         Hashtable empty = new Hashtable ();
 381                         return DefaultView.Update (empty, empty, null);
 382                 }
 383
 384                 public int Delete ()
 385                 {
 386                         Hashtable empty = new Hashtable ();
 387                         return DefaultView.Delete (empty, null);
 388                 }
 389
 390                 public int Insert ()
 391                 {
 392                         Hashtable empty = new Hashtable ();
 393                         return DefaultView.Insert (empty);
 394                 }
 395
 396                 protected internal override void OnInit (EventArgs e)
 397                 {
 398                         Page.LoadComplete += OnPageLoadComplete;
 399                 }
 400
 401                 void OnPageLoadComplete (object sender, EventArgs e)
 402                 {
 403                         FilterParameters.UpdateValues (Context, this);
 404                         SelectParameters.UpdateValues (Context, this);
 405                 }
 406
 407                 protected override void LoadViewState (object savedState)
 408                 {
 409                         if (savedState == null) {
 410                                 base.LoadViewState (null);
 411                                 ((IStateManager)DefaultView).LoadViewState (null);
 412                         } else {
 413                                 Pair p = (Pair) savedState;
 414                                 base.LoadViewState (p.First);
 415                                 ((IStateManager)DefaultView).LoadViewState (p.Second);
 416                         }
 417                 }
 418
 419                 protected override object SaveViewState()
 420                 {
 421                         object baseState = base.SaveViewState ();
 422                         object viewState = ((IStateManager)DefaultView).SaveViewState ();
 423                         if (baseState != null || viewState != null) return new Pair (baseState, viewState);
 424                         else return null;
 425                 }
 426
 427                 protected override void TrackViewState()
 428                 {
 429                         ((IStateManager)DefaultView).TrackViewState ();
 430                 }
 431         }
 432 }
 433 #endif
 434
 435