2008-09-18 Atsushi Enomoto <[email protected]>

	* LinqDataSource.cs, LinqDataSourceView.cs
	  LinqDataSourceContextEventArgs.cs
	  LinqDataSourceDeleteEventArgs.cs
	  LinqDataSourceDisposeEventArgs.cs
	  LinqDataSourceInsertEventArgs.cs
	  LinqDataSourceSelectEventArgs.cs
	  LinqDataSourceStatusEventArgs.cs
	  LinqDataSourceUpdateEventArgs.cs : easy implementation parts.


svn path=/trunk/mcs/; revision=113405

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/ChangeLog

@@ -1,3 +1,14 @@
+2008-09-18  Atsushi Enomoto  <[email protected]>
+
+	* LinqDataSource.cs, LinqDataSourceView.cs
+	  LinqDataSourceContextEventArgs.cs
+	  LinqDataSourceDeleteEventArgs.cs
+	  LinqDataSourceDisposeEventArgs.cs
+	  LinqDataSourceInsertEventArgs.cs
+	  LinqDataSourceSelectEventArgs.cs
+	  LinqDataSourceStatusEventArgs.cs
+	  LinqDataSourceUpdateEventArgs.cs : easy implementation parts.
+
 2008-09-18  Atsushi Enomoto  <[email protected]>
 
 	* LinqDataSource.cs, LinqDataSourceView.cs

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSource.cs

@@ -32,6 +32,7 @@ using System;
 using System.Collections;
 using System.ComponentModel;
 using System.Security.Permissions;
+using System.Web;
 using System.Web.DynamicData;
 using System.Web.UI;
 
@@ -42,172 +43,369 @@ namespace System.Web.UI.WebControls
 	[AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
 	public class LinqDataSource : DataSourceControl, IDynamicDataSource
 	{
+		static readonly string [] empty_names = new string [] { "DefaultView" };
+
 		public LinqDataSource ()
 		{
 		}
 
-		[MonoTODO]
-		protected virtual LinqDataSourceView CreateView ()
+		protected internal override void OnInit (EventArgs e)
 		{
-			throw new NotImplementedException ();
+			Page.LoadComplete += OnPageLoadComplete;
 		}
 
-		[MonoTODO]
-		public int Delete (IDictionary keys, IDictionary oldValues)
+		void OnPageLoadComplete (object sender, EventArgs e)
 		{
-			throw new NotImplementedException ();
+			SelectParameters.UpdateValues (Context, this);
+			WhereParameters.UpdateValues (Context, this);
+			GroupByParameters.UpdateValues (Context, this);
+			OrderByParameters.UpdateValues (Context, this);
+			OrderGroupsByParameters.UpdateValues (Context, this);
 		}
 
-		[MonoTODO]
-		protected override DataSourceView GetView (string viewName)
+		protected internal override void OnUnload (EventArgs e)
 		{
-			throw new NotImplementedException ();
+			base.OnUnload (e);
+
+			// no further things to do?
 		}
 
-		[MonoTODO]
-		protected override ICollection GetViewNames ()
-		{
-			throw new NotImplementedException ();
+		#region View
+
+		LinqDataSourceView view;
+		LinqDataSourceView View {
+			get {
+				if (view == null) {
+					view = CreateView ();
+					if (IsTrackingViewState)
+						((IStateManager) view).TrackViewState ();
+				}
+				return view;
+			}
 		}
 
-		[MonoTODO]
-		public int Insert (IDictionary values)
+		protected virtual LinqDataSourceView CreateView ()
 		{
-			throw new NotImplementedException ();
+			var view = new LinqDataSourceView (this, Guid.NewGuid ().ToString (), HttpContext.Current);
+			if (IsTrackingViewState)
+				((IStateManager) view).TrackViewState ();
+			return view;
 		}
 
-		[MonoTODO]
-		protected override void LoadViewState (object savedState)
+		protected override DataSourceView GetView (string viewName)
 		{
-			throw new NotImplementedException ();
+			if (String.IsNullOrEmpty (viewName) || (String.Compare (viewName, empty_names [0], StringComparison.InvariantCultureIgnoreCase) == 0))
+				return View;
+			throw new ArgumentException ("viewName must be 'DefaultView' in LinqDataSource");
 		}
 
-		[MonoTODO]
-		protected internal override void OnInit (EventArgs e)
+		protected override ICollection GetViewNames ()
 		{
-			throw new NotImplementedException ();
+			return empty_names;
 		}
 
-		[MonoTODO]
-		protected internal override void OnUnload (EventArgs e)
-		{
-			throw new NotImplementedException ();
+		#endregion
+
+		[Category ("Behavior")]
+		[DefaultValue (false)]
+		public bool AutoGenerateOrderByClause {
+			get { return View.AutoGenerateOrderByClause; }
+			set { View.AutoGenerateOrderByClause = value; }
 		}
 
-		[MonoTODO]
-		protected override object SaveViewState ()
-		{
-			throw new NotImplementedException ();
+		[Category ("Behavior")]
+		[DefaultValue (false)]
+		public bool AutoGenerateWhereClause {
+			get { return View.AutoGenerateWhereClause; }
+			set { View.AutoGenerateWhereClause = value; }
 		}
 
-		[MonoTODO]
-		protected override void TrackViewState ()
-		{
-			throw new NotImplementedException ();
+		[Category ("Behavior")]
+		[DefaultValue (true)]
+		public bool AutoPage {
+			get { return View.AutoPage; }
+			set { View.AutoPage = value; }
 		}
 
-		[MonoTODO]
-		public int Update (IDictionary keys, IDictionary values, IDictionary oldValues)
-		{
-			throw new NotImplementedException ();
-		}
-
-		[MonoTODO]
-		public bool AutoGenerateOrderByClause { get; set; }
-		[MonoTODO]
-		public bool AutoGenerateWhereClause { get; set; }
-		[MonoTODO]
-		public bool AutoPage { get; set; }
-		[MonoTODO]
-		public bool AutoSort { get; set; }
-		[MonoTODO]
-		public string ContextTypeName { get; set; }
-		[MonoTODO]
+		[Category ("Behavior")]
+		[DefaultValue (true)]
+		public bool AutoSort {
+			get { return View.AutoSort; }
+			set { View.AutoSort = value; }
+		}
+
+		[Category ("Data")]
+		[DefaultValue ("")]
+		[MonoTODO ("looks like we need System.Web.Query.Dynamic stuff or alternative")]
+		public string ContextTypeName {
+			get { throw new NotImplementedException (); }
+			set { throw new NotImplementedException (); }
+		}
+
+		[MonoTODO ("looks like we need System.Web.Query.Dynamic stuff or alternative")]
+		Type IDynamicDataSource.ContextType { get; set; }
+
+		string IDynamicDataSource.EntitySetName {
+			get { return TableName; }
+			set { TableName = value; }
+		}
+
+		[Category ("Data")]
+		[DefaultValue ("")]
+		public string TableName {
+			get { return View.TableName; }
+			set { View.TableName = value; }
+		}
+
+		[Category ("Behavior")]
+		[DefaultValue (false)]
+		public bool EnableDelete {
+			get { return View.EnableDelete; }
+			set { View.EnableDelete = value; }
+		}
+
+		[Category ("Behavior")]
+		[DefaultValue (false)]
+		public bool EnableInsert {
+			get { return View.EnableInsert; }
+			set { View.EnableInsert = value; }
+		}
+
+		[Category ("Behavior")]
+		[DefaultValue (false)]
+		public bool EnableObjectTracking {
+			get { return View.EnableObjectTracking; }
+			set { View.EnableObjectTracking = value; }
+		}
+
+		[Category ("Behavior")]
+		[DefaultValue (false)]
+		public bool EnableUpdate {
+			get { return View.EnableUpdate; }
+			set { View.EnableUpdate = value; }
+		}
+
+		[Category ("Data")]
+		[DefaultValue ("")]
+		public string GroupBy {
+			get { return View.GroupBy; }
+			set { View.GroupBy = value; }
+		}
+
+		[Category ("Data")]
+		[DefaultValue ("")]
+		public string OrderBy {
+			get { return View.OrderBy; }
+			set { View.OrderBy = value; }
+		}
+
+		[Category ("Data")]
+		[DefaultValue ("")]
+		public string OrderGroupsBy {
+			get { return View.OrderGroupsBy; }
+			set { View.OrderGroupsBy = value; }
+		}
+
+		[Category ("Data")]
+		[DefaultValue ("")]
+		public string Select {
+			get { return View.SelectNew; }
+			set { View.SelectNew = value; }
+		}
+
+		[Category ("Data")]
+		[DefaultValue ("")]
+		public string Where {
+			get { return View.Where; }
+			set { View.Where = value; }
+		}
+
+		[MergableProperty (false)]
+		[Category ("Data")]
+		[DefaultValue (null)]
 		[PersistenceMode (PersistenceMode.InnerProperty)]
 		[Browsable (false)]
-		public ParameterCollection DeleteParameters { get; private set; }
-		[MonoTODO]
-		public bool EnableDelete { get; set; }
-		[MonoTODO]
-		public bool EnableInsert { get; set; }
-		[MonoTODO]
-		public bool EnableObjectTracking { get; set; }
-		[MonoTODO]
-		public bool EnableUpdate { get; set; }
-		[MonoTODO]
-		public string GroupBy { get; set; }
-		[MonoTODO]
+		public ParameterCollection SelectParameters {
+			get { return View.SelectNewParameters; }
+		}
+
+		[MergableProperty (false)]
+		[Category ("Data")]
+		[DefaultValue (null)]
 		[Browsable (false)]
 		[PersistenceMode (PersistenceMode.InnerProperty)]
-		public ParameterCollection GroupByParameters { get; private set; }
-		[MonoTODO]
-		Type IDynamicDataSource.ContextType { get; set; }
-		[MonoTODO]
-		string IDynamicDataSource.EntitySetName { get; set; }
-		[MonoTODO]
-		[PersistenceMode (PersistenceMode.InnerProperty)]
+		public ParameterCollection WhereParameters {
+			get { return View.WhereParameters; }
+		}
+
+		[MergableProperty (false)]
+		[Category ("Data")]
+		[DefaultValue (null)]
 		[Browsable (false)]
-		public ParameterCollection InsertParameters { get; private set; }
-		[MonoTODO]
-		public string OrderBy { get; set; }
-		[MonoTODO]
+		[PersistenceMode (PersistenceMode.InnerProperty)]
+		public ParameterCollection GroupByParameters {
+			get { return View.GroupByParameters; }
+		}
+
+		[MergableProperty (false)]
+		[Category ("Data")]
+		[DefaultValue (null)]
 		[Browsable (false)]
 		[PersistenceMode (PersistenceMode.InnerProperty)]
-		public ParameterCollection OrderByParameters { get; private set; }
-		[MonoTODO]
-		public string OrderGroupsBy { get; set; }
-		[MonoTODO]
+		public ParameterCollection OrderByParameters {
+			get { return View.OrderByParameters; }
+		}
+
+		[MergableProperty (false)]
+		[Category ("Data")]
+		[DefaultValue (null)]
 		[PersistenceMode (PersistenceMode.InnerProperty)]
 		[Browsable (false)]
-		public ParameterCollection OrderGroupsByParameters { get; private set; }
-		[MonoTODO]
-		public string Select { get; set; }
-		[MonoTODO]
+		public ParameterCollection OrderGroupsByParameters {
+			get { return View.OrderGroupsByParameters; }
+		}
+
+		[MergableProperty (false)]
+		[Category ("Data")]
+		[DefaultValue (null)]
 		[PersistenceMode (PersistenceMode.InnerProperty)]
 		[Browsable (false)]
-		public ParameterCollection SelectParameters { get; private set; }
-		[MonoTODO]
-		public bool StoreOriginalValuesInViewState { get; set; }
-		[MonoTODO]
-		public string TableName { get; set; }
-		[MonoTODO]
+		public ParameterCollection DeleteParameters {
+			get { return View.DeleteParameters; }
+		}
+
+		[MergableProperty (false)]
+		[Category ("Data")]
+		[DefaultValue (null)]
 		[PersistenceMode (PersistenceMode.InnerProperty)]
 		[Browsable (false)]
-		public ParameterCollection UpdateParameters { get; private set; }
-		[MonoTODO]
-		public string Where { get; set; }
-		[MonoTODO]
-		[Browsable (false)]
+		public ParameterCollection InsertParameters {
+			get { return View.InsertParameters; }
+		}
+
+		[MergableProperty (false)]
+		[Category ("Data")]
+		[DefaultValue (null)]
 		[PersistenceMode (PersistenceMode.InnerProperty)]
-		public ParameterCollection WhereParameters { get; private set; }
-
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> ContextCreated;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceContextEventArgs> ContextCreating;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceDisposeEventArgs> ContextDisposing;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> Deleted;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceDeleteEventArgs> Deleting;
-		[MonoTODO]
+		[Browsable (false)]
+		public ParameterCollection UpdateParameters {
+			get { return View.UpdateParameters; }
+		}
+
+		public int Delete (IDictionary keys, IDictionary oldValues)
+		{
+			return View.Delete (keys, oldValues);
+		}
+
+		public int Insert (IDictionary values)
+		{
+			return View.Insert (values);
+		}
+
+		public int Update (IDictionary keys, IDictionary values, IDictionary oldValues)
+		{
+			return View.Update (keys, values, oldValues);
+		}
+
+		#region ViewState
+
+		[Category ("Behavior")]
+		[DefaultValue (true)]
+		public bool StoreOriginalValuesInViewState {
+			get { return View.StoreOriginalValuesInViewState; }
+			set { View.StoreOriginalValuesInViewState = value; }
+		}
+
+		protected override void LoadViewState (object savedState)
+		{
+			Pair p = savedState as Pair;
+			if (p != null) {
+				base.LoadViewState (p.First);
+				((IStateManager) View).LoadViewState (p.Second);
+			}
+		}
+
+		protected override object SaveViewState ()
+		{
+			object me = base.SaveViewState (), view = ((IStateManager) View).SaveViewState ();
+			if (me != null || view != null)
+				return new Pair (me, view);
+			else
+				return null;
+		}
+
+		protected override void TrackViewState ()
+		{
+			base.TrackViewState ();
+			if (view != null)
+				((IStateManager) view).TrackViewState ();
+		}
+
+		#endregion
+
+		#region Events (Dispatching)
+
+		public event EventHandler<LinqDataSourceStatusEventArgs> ContextCreated {
+			add { View.ContextCreated += value; }
+			remove { View.ContextCreated -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceContextEventArgs> ContextCreating {
+			add { View.ContextCreating += value; }
+			remove { View.ContextCreating -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceDisposeEventArgs> ContextDisposing {
+			add { View.ContextDisposing += value; }
+			remove { View.ContextDisposing -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceStatusEventArgs> Deleted {
+			add { View.Deleted += value; }
+			remove { View.Deleted -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceDeleteEventArgs> Deleting {
+			add { View.Deleting += value; }
+			remove { View.Deleting -= value; }
+		}
+
 		event EventHandler<DynamicValidatorEventArgs> IDynamicDataSource.Exception {
-			add { throw new NotImplementedException (); }
-			remove { throw new NotImplementedException (); }
-		}
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> Inserted;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceInsertEventArgs> Inserting;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> Selected;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceSelectEventArgs> Selecting;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> Updated;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceUpdateEventArgs> Updating;
+			add { View.Exception += value; }
+			remove { View.Exception -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceStatusEventArgs> Inserted {
+			add { View.Inserted += value; }
+			remove { View.Inserted -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceInsertEventArgs> Inserting {
+			add { View.Inserting += value; }
+			remove { View.Inserting -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceStatusEventArgs> Selected {
+			add { View.Selected += value; }
+			remove { View.Selected -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceSelectEventArgs> Selecting {
+			add { View.Selecting += value; }
+			remove { View.Selecting -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceStatusEventArgs> Updated {
+			add { View.Updated += value; }
+			remove { View.Updated -= value; }
+		}
+
+		public event EventHandler<LinqDataSourceUpdateEventArgs> Updating {
+			add { View.Updating += value; }
+			remove { View.Updating -= value; }
+		}
+
+		#endregion
 	}
 }
 #endif

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSourceContextEventArgs.cs

@@ -41,10 +41,9 @@ namespace System.Web.UI.WebControls
 	[AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
 	public class LinqDataSourceContextEventArgs : EventArgs
 	{
-		[MonoTODO]
 		public LinqDataSourceContextEventArgs ()
+			: this (DataSourceOperation.Select)
 		{
-			throw new NotImplementedException ();
 		}
 
 		public LinqDataSourceContextEventArgs (DataSourceOperation operation)
@@ -52,9 +51,8 @@ namespace System.Web.UI.WebControls
 			Operation = operation;
 		}
 
-		[MonoTODO]
 		public object ObjectInstance { get; set; }
-		[MonoTODO]
+
 		public DataSourceOperation Operation { get; private set; }
 	}
 }

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSourceDeleteEventArgs.cs

@@ -40,23 +40,20 @@ namespace System.Web.UI.WebControls
 	[AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
 	public class LinqDataSourceDeleteEventArgs : CancelEventArgs
 	{
-		[MonoTODO]
 		public LinqDataSourceDeleteEventArgs (object originalObject)
 		{
-			throw new NotImplementedException ();
+			OriginalObject = originalObject;
 		}
 
-		[MonoTODO]
 		public LinqDataSourceDeleteEventArgs (LinqDataSourceValidationException exception)
 		{
-			throw new NotImplementedException ();
+			Exception = exception;
 		}
 
-		[MonoTODO]
 		public LinqDataSourceValidationException Exception { get; private set; }
-		[MonoTODO]
+
 		public bool ExceptionHandled { get; set; }
-		[MonoTODO]
+
 		public object OriginalObject { get; private set; }
 	}
 }

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSourceDisposeEventArgs.cs

@@ -42,8 +42,6 @@ namespace System.Web.UI.WebControls
 	{
 		public LinqDataSourceDisposeEventArgs (object instance)
 		{
-			if (instance == null)
-				throw new ArgumentNullException ("instance");
 			ObjectInstance = instance;
 		}
 

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSourceInsertEventArgs.cs

@@ -42,23 +42,18 @@ namespace System.Web.UI.WebControls
 	{
 		public LinqDataSourceInsertEventArgs (object newObject)
 		{
-			if (newObject == null)
-				throw new ArgumentNullException ("newObject");
 			NewObject = newObject;
 		}
 
 		public LinqDataSourceInsertEventArgs (LinqDataSourceValidationException exception)
 		{
-			if (exception == null)
-				throw new ArgumentNullException ("exception");
 			Exception = exception;
 		}
 
-		[MonoTODO]
 		public LinqDataSourceValidationException Exception { get; private set; }
-		[MonoTODO]
+
 		public bool ExceptionHandled { get; set; }
-		[MonoTODO]
+
 		public object NewObject { get; private set; }
 	}
 }

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSourceSelectEventArgs.cs

@@ -41,7 +41,6 @@ namespace System.Web.UI.WebControls
 	[AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
 	public class LinqDataSourceSelectEventArgs : CancelEventArgs
 	{
-		[MonoTODO]
 		public LinqDataSourceSelectEventArgs (
 			DataSourceSelectArguments arguments,
 			IDictionary<string, object> whereParameters,
@@ -50,22 +49,27 @@ namespace System.Web.UI.WebControls
 			IDictionary<string, object> orderGroupsByParameters,
 			IDictionary<string, object> selectParameters)
 		{
-			throw new NotImplementedException ();
+			// all nullable.
+			Arguments = arguments;
+			WhereParameters = whereParameters;
+			OrderByParameters = orderByParameters;
+			GroupByParameters = groupByParameters;
+			OrderGroupsByParameters = orderGroupsByParameters;
+			SelectParameters = selectParameters;
 		}
 
-		[MonoTODO]
 		public DataSourceSelectArguments Arguments { get; private set; }
-		[MonoTODO]
+
 		public IDictionary<string, object> GroupByParameters { get; private set; }
-		[MonoTODO]
+
 		public IOrderedDictionary OrderByParameters { get; private set; }
-		[MonoTODO]
+
 		public IDictionary<string, object> OrderGroupsByParameters { get; private set; }
-		[MonoTODO]
+
 		public object Result { get; set; }
-		[MonoTODO]
+
 		public IDictionary<string, object> SelectParameters { get; private set; }
-		[MonoTODO]
+
 		public IDictionary<string, object> WhereParameters { get; private set; }
 	}
 }

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSourceStatusEventArgs.cs

@@ -40,29 +40,29 @@ namespace System.Web.UI.WebControls
 	[AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
 	public class LinqDataSourceStatusEventArgs : EventArgs
 	{
-		[MonoTODO]
 		public LinqDataSourceStatusEventArgs (Exception exception)
 		{
-			throw new NotImplementedException ();
+			Exception = exception;
 		}
-		[MonoTODO]
+
 		public LinqDataSourceStatusEventArgs (object result)
 		{
-			throw new NotImplementedException ();
+			Result = result;
 		}
-		[MonoTODO]
+
 		public LinqDataSourceStatusEventArgs (object result, int totalRowCount)
 		{
-			throw new NotImplementedException ();
+			Result = result;
+			// no range check
+			TotalRowCount = totalRowCount;
 		}
 
-		[MonoTODO]
 		public Exception Exception { get; private set; }
-		[MonoTODO]
+
 		public bool ExceptionHandled { get; set; }
-		[MonoTODO]
+
 		public object Result { get; private set; }
-		[MonoTODO]
+
 		public int TotalRowCount { get; private set; }
 	}
 }

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSourceUpdateEventArgs.cs

@@ -41,24 +41,24 @@ namespace System.Web.UI.WebControls
 	[AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
 	public class LinqDataSourceUpdateEventArgs : CancelEventArgs
 	{
-		[MonoTODO]
+
 		public LinqDataSourceUpdateEventArgs (LinqDataSourceValidationException exception)
 		{
-			throw new NotImplementedException ();
+			Exception = exception;
 		}
-		[MonoTODO]
+
 		public LinqDataSourceUpdateEventArgs (object originalObject, object newObject)
 		{
-			throw new NotImplementedException ();
+			OriginalObject = originalObject;
+			NewObject = newObject;
 		}
 
-		[MonoTODO]
 		public LinqDataSourceValidationException Exception { get; private set; }
-		[MonoTODO]
+
 		public bool ExceptionHandled { get; set; }
-		[MonoTODO]
+
 		public object NewObject { get; private set; }
-		[MonoTODO]
+
 		public object OriginalObject { get; private set; }
 	}
 }

mcs/class/System.Web.Extensions/System.Web.UI.WebControls/LinqDataSourceView.cs

@@ -30,6 +30,7 @@
 #if NET_3_5
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Reflection;
 using System.Security.Permissions;
@@ -42,35 +43,36 @@ namespace System.Web.UI.WebControls
 	[AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
 	public class LinqDataSourceView : DataSourceView, IStateManager
 	{
-		[MonoTODO]
 		public LinqDataSourceView (LinqDataSource owner, string name, HttpContext context)
 			: base (owner, name)
 		{
-			throw new NotImplementedException ();
+			source = owner;
 		}
 
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> ContextCreated;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceContextEventArgs> ContextCreating;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceDisposeEventArgs> ContextDisposing;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> Deleted;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceDeleteEventArgs> Deleting;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> Inserted;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceInsertEventArgs> Inserting;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> Selected;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceSelectEventArgs> Selecting;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceStatusEventArgs> Updated;
-		[MonoTODO]
-		public event EventHandler<LinqDataSourceUpdateEventArgs> Updating;
+		LinqDataSource source;
+
+		bool tracking;
+		ParameterCollection delete_parameters,
+			insert_parameters,
+			select_new_parameters,
+			update_parameters;
+		ParameterCollection group_by_parameters,
+			order_by_parameters,
+			order_group_by_parameters,
+			where_parameters;
+
+		IEnumerable<ParameterCollection> AllParameters {
+			get {
+				yield return delete_parameters;
+				yield return insert_parameters;
+				yield return select_new_parameters;
+				yield return update_parameters;
+				yield return group_by_parameters;
+				yield return order_by_parameters;
+				yield return order_group_by_parameters;
+				yield return where_parameters;
+			}
+		}
 
 		[MonoTODO]
 		public bool AutoGenerateOrderByClause { get; set; }
@@ -80,40 +82,40 @@ namespace System.Web.UI.WebControls
 		public bool AutoPage { get; set; }
 		[MonoTODO]
 		public bool AutoSort { get; set; }
-		[MonoTODO]
+
 		public override bool CanDelete {
-			get { throw new NotImplementedException (); }
+			get { return EnableDelete; }
 		}
-		[MonoTODO]
+
 		public override bool CanInsert {
-			get { throw new NotImplementedException (); }
+			get { return EnableInsert; }
 		}
-		[MonoTODO]
+
 		public override bool CanPage {
-			get { throw new NotImplementedException (); }
+			get { return true; }
 		}
-		[MonoTODO]
+
 		public override bool CanRetrieveTotalRowCount {
-			get { throw new NotImplementedException (); }
+			get { return true; }
 		}
-		[MonoTODO]
+
 		public override bool CanSort {
-			get { throw new NotImplementedException (); }
+			get { return true; }
 		}
-		[MonoTODO]
+
 		public override bool CanUpdate {
-			get { throw new NotImplementedException (); }
+			get { return EnableUpdate; }
 		}
-		[MonoTODO]
+
 		protected virtual Type ContextType {
-			get { throw new NotImplementedException (); }
+			get { return ((IDynamicDataSource) source).ContextType; }
 		}
-		[MonoTODO]
-		public virtual string ContextTypeName { get; set; }
-		[MonoTODO]
-		public ParameterCollection DeleteParameters {
-			get { throw new NotImplementedException (); }
+
+		public virtual string ContextTypeName {
+			get { return source.ContextTypeName; }
+			set { source.ContextTypeName = value; }
 		}
+
 		[MonoTODO]
 		public bool EnableDelete { get; set; }
 		[MonoTODO]
@@ -122,257 +124,371 @@ namespace System.Web.UI.WebControls
 		public bool EnableObjectTracking { get; set; }
 		[MonoTODO]
 		public bool EnableUpdate { get; set; }
+
 		[MonoTODO]
-		public string GroupBy { get; set; }
-		[MonoTODO]
-		public ParameterCollection GroupByParameters {
-			get { throw new NotImplementedException (); }
-		}
-		[MonoTODO]
-		public ParameterCollection InsertParameters {
-			get { throw new NotImplementedException (); }
-		}
-		[MonoTODO]
-		bool IStateManager.IsTrackingViewState {
-			get { throw new NotImplementedException (); }
-		}
+		public string TableName { get; set; }
+
 		[MonoTODO]
-		protected bool IsTrackingViewState {
-			get { throw new NotImplementedException (); }
-		}
+		public string GroupBy { get; set; }
+
 		[MonoTODO]
 		public string OrderBy { get; set; }
-		[MonoTODO]
-		public ParameterCollection OrderByParameters {
-			get { throw new NotImplementedException (); }
-		}
+
 		[MonoTODO]
 		public string OrderGroupsBy { get; set; }
-		[MonoTODO]
-		public ParameterCollection OrderGroupsByParameters {
-			get { throw new NotImplementedException (); }
-		}
+
 		[MonoTODO]
 		public string SelectNew { get; set; }
+
 		[MonoTODO]
-		public ParameterCollection SelectNewParameters {
-			get { throw new NotImplementedException (); }
+		public string Where { get; set; }
+
+		public ParameterCollection DeleteParameters {
+			get { return GetParameterCollection (ref delete_parameters, false, false); }
 		}
-		[MonoTODO]
-		public bool StoreOriginalValuesInViewState { get; set; }
-		[MonoTODO]
-		public string TableName { get; set; }
-		[MonoTODO]
+
+		public ParameterCollection InsertParameters {
+			get { return GetParameterCollection (ref insert_parameters, false, false); }
+		}
+
 		public ParameterCollection UpdateParameters {
-			get { throw new NotImplementedException (); }
+			get { return GetParameterCollection (ref update_parameters, true, true); }
 		}
-		[MonoTODO]
-		public string Where { get; set; }
-		[MonoTODO]
+
+		public ParameterCollection SelectNewParameters {
+			get { return GetParameterCollection (ref select_new_parameters, false, false); }
+		}
+
 		public ParameterCollection WhereParameters {
-			get { throw new NotImplementedException (); }
+			get { return GetParameterCollection (ref where_parameters, true, true); }
 		}
 
-		[MonoTODO]
-		protected virtual object CreateContext (Type contextType)
+		public ParameterCollection GroupByParameters {
+			get { return GetParameterCollection (ref group_by_parameters, true, true); }
+		}
+
+		public ParameterCollection OrderByParameters {
+			get { return GetParameterCollection (ref order_by_parameters, true, true); }
+		}
+
+		public ParameterCollection OrderGroupsByParameters {
+			get { return GetParameterCollection (ref order_group_by_parameters, true, true); }
+		}
+
+		ParameterCollection GetParameterCollection (ref ParameterCollection output, bool propagateTrackViewState, bool subscribeChanged)
+		{
+			if (output != null)
+				return output;
+			
+			output = new ParameterCollection ();
+			if (subscribeChanged)
+				output.ParametersChanged += new EventHandler (ParametersChanged);
+			
+			if (IsTrackingViewState && propagateTrackViewState)
+				((IStateManager) output).TrackViewState ();
+			
+			return output;
+		}
+
+		void ParametersChanged (object source, EventArgs args)
 		{
-			throw new NotImplementedException ();
+			OnDataSourceViewChanged (EventArgs.Empty);
 		}
-		[MonoTODO]
+
 		public int Delete (IDictionary keys, IDictionary oldValues)
 		{
-			throw new NotImplementedException ();
+			return ExecuteDelete (keys, oldValues);
 		}
-		[MonoTODO]
-		protected virtual void DeleteDataObject (object dataContext, object table, object oldDataObject)
+
+		public int Insert (IDictionary values)
 		{
-			throw new NotImplementedException ();
+			return ExecuteInsert (values);
 		}
-		[MonoTODO]
-		protected override int ExecuteDelete (IDictionary keys, IDictionary oldValues)
+
+		public IEnumerable Select (DataSourceSelectArguments arguments)
 		{
-			throw new NotImplementedException ();
+			return ExecuteSelect (arguments);
 		}
-		[MonoTODO]
-		protected override int ExecuteInsert (IDictionary values)
+
+		public int Update (IDictionary keys, IDictionary values, IDictionary oldValues)
 		{
-			throw new NotImplementedException ();
+			return ExecuteUpdate (keys, values, oldValues);
 		}
+
 		[MonoTODO]
-		protected internal override IEnumerable ExecuteSelect (DataSourceSelectArguments arguments)
+		protected override int ExecuteDelete (IDictionary keys, IDictionary oldValues)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		protected override int ExecuteUpdate (IDictionary keys, IDictionary values, IDictionary oldValues)
+		protected override int ExecuteInsert (IDictionary values)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		protected virtual Type GetDataObjectType (Type tableType)
+		protected override int ExecuteUpdate (IDictionary keys, IDictionary values, IDictionary oldValues)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		protected virtual MemberInfo GetTableMemberInfo (Type contextType)
+		protected internal override IEnumerable ExecuteSelect (DataSourceSelectArguments arguments)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		public int Insert (IDictionary values)
+		protected virtual void DeleteDataObject (object dataContext, object table, object oldDataObject)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
 		protected virtual void InsertDataObject (object dataContext, object table, object newDataObject)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		void IStateManager.LoadViewState (object savedState)
+		protected virtual void ResetDataObject (object table, object dataObject)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		object IStateManager.SaveViewState ()
+		protected virtual void UpdateDataObject (object dataContext, object table, object oldDataObject, object newDataObject)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		void IStateManager.TrackViewState ()
+		protected virtual object CreateContext (Type contextType)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		protected virtual void LoadViewState (object savedState)
+		protected virtual Type GetDataObjectType (Type tableType)
 		{
 			throw new NotImplementedException ();
 		}
+
 		[MonoTODO]
-		protected virtual void OnContextCreated (LinqDataSourceStatusEventArgs e)
+		protected virtual MemberInfo GetTableMemberInfo (Type contextType)
 		{
 			throw new NotImplementedException ();
 		}
+
+		#region Validation
+
 		[MonoTODO]
-		protected virtual void OnContextCreating (LinqDataSourceContextEventArgs e)
+		protected virtual void ValidateContextType (Type contextType, bool selecting)
 		{
 			throw new NotImplementedException ();
 		}
 		[MonoTODO]
-		protected virtual void OnContextDisposing (LinqDataSourceDisposeEventArgs e)
+		protected virtual void ValidateDeleteSupported (IDictionary keys, IDictionary oldValues)
 		{
 			throw new NotImplementedException ();
 		}
 		[MonoTODO]
-		protected virtual void OnDeleted (LinqDataSourceStatusEventArgs e)
+		protected virtual void ValidateInsertSupported (IDictionary values)
 		{
 			throw new NotImplementedException ();
 		}
 		[MonoTODO]
-		protected virtual void OnDeleting (LinqDataSourceDeleteEventArgs e)
+		protected virtual void ValidateOrderByParameter (string name, string value)
 		{
 			throw new NotImplementedException ();
 		}
 		[MonoTODO]
-		protected virtual void OnException (DynamicValidatorEventArgs e)
+		protected virtual void ValidateParameterName (string name)
 		{
 			throw new NotImplementedException ();
 		}
 		[MonoTODO]
-		protected virtual void OnInserted (LinqDataSourceStatusEventArgs e)
+		protected virtual void ValidateTableType (Type tableType, bool selecting)
 		{
 			throw new NotImplementedException ();
 		}
 		[MonoTODO]
-		protected virtual void OnInserting (LinqDataSourceInsertEventArgs e)
+		protected virtual void ValidateUpdateSupported (IDictionary keys, IDictionary values, IDictionary oldValues)
 		{
 			throw new NotImplementedException ();
 		}
-		[MonoTODO]
-		protected virtual void OnSelected (LinqDataSourceStatusEventArgs e)
-		{
-			throw new NotImplementedException ();
+
+		#endregion
+
+		#region ViewState
+
+		bool IStateManager.IsTrackingViewState {
+			get { return IsTrackingViewState; }
 		}
+
+		protected bool IsTrackingViewState {
+			get { return tracking; }
+		}
+
 		[MonoTODO]
-		protected virtual void OnSelecting (LinqDataSourceSelectEventArgs e)
+		public bool StoreOriginalValuesInViewState { get; set; }
+
+		void IStateManager.LoadViewState (object savedState)
 		{
-			throw new NotImplementedException ();
+			LoadViewState (savedState);
 		}
-		[MonoTODO]
-		protected virtual void OnUpdated (LinqDataSourceStatusEventArgs e)
+
+		object IStateManager.SaveViewState ()
 		{
-			throw new NotImplementedException ();
+			return SaveViewState ();
 		}
-		[MonoTODO]
-		protected virtual void OnUpdating (LinqDataSourceUpdateEventArgs e)
+
+		void IStateManager.TrackViewState ()
 		{
-			throw new NotImplementedException ();
+			TrackViewState ();
 		}
-		[MonoTODO]
-		protected virtual void ResetDataObject (object table, object dataObject)
+
+		protected virtual void LoadViewState (object savedState)
 		{
-			throw new NotImplementedException ();
+			object [] vs = savedState as object [];
+			if (vs == null)
+				return;
+			int i = 0;
+			foreach (var p in AllParameters) {
+				if (vs [i] != null)
+					((IStateManager) p).LoadViewState (vs [i]);
+				i++;
+			}
 		}
-		[MonoTODO]
+
 		protected virtual object SaveViewState ()
 		{
-			throw new NotImplementedException ();
+			object [] vs = new object [8];
+			int i = 0;
+			foreach (var p in AllParameters) {
+				if (p != null)
+					vs [i] = ((IStateManager) p).SaveViewState ();
+				i++;
+			}
+
+			foreach (object o in vs)
+				if (o != null)
+					return vs;
+			return null;
 		}
-		[MonoTODO]
-		public IEnumerable Select (DataSourceSelectArguments arguments)
+
+		protected virtual void TrackViewState ()
 		{
-			throw new NotImplementedException ();
+			tracking = true;
+
+			foreach (var p in AllParameters)
+				if (p != null)
+					((IStateManager) p).TrackViewState ();
 		}
+
+		#endregion
+
+		#region Events and Overridable Event Handler Invocations
+
 		[MonoTODO]
-		protected virtual void TrackViewState ()
+		public event EventHandler<LinqDataSourceStatusEventArgs> ContextCreated;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceContextEventArgs> ContextCreating;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceDisposeEventArgs> ContextDisposing;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceStatusEventArgs> Deleted;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceDeleteEventArgs> Deleting;
+		[MonoTODO]
+		internal event EventHandler<DynamicValidatorEventArgs> Exception;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceStatusEventArgs> Inserted;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceInsertEventArgs> Inserting;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceStatusEventArgs> Selected;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceSelectEventArgs> Selecting;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceStatusEventArgs> Updated;
+		[MonoTODO]
+		public event EventHandler<LinqDataSourceUpdateEventArgs> Updating;
+
+		protected virtual void OnContextCreated (LinqDataSourceStatusEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (ContextCreated != null)
+				ContextCreated (this, e);
 		}
-		[MonoTODO]
-		public int Update (IDictionary keys, IDictionary values, IDictionary oldValues)
+
+		protected virtual void OnContextCreating (LinqDataSourceContextEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (ContextCreating != null)
+				ContextCreating (this, e);
 		}
-		[MonoTODO]
-		protected virtual void UpdateDataObject (object dataContext, object table, object oldDataObject, object newDataObject)
+
+		protected virtual void OnContextDisposing (LinqDataSourceDisposeEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (ContextDisposing != null)
+				ContextDisposing (this, e);
 		}
-		[MonoTODO]
-		protected virtual void ValidateContextType (Type contextType, bool selecting)
+
+		protected virtual void OnDeleted (LinqDataSourceStatusEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (Deleted != null)
+				Deleted (this, e);
 		}
-		[MonoTODO]
-		protected virtual void ValidateDeleteSupported (IDictionary keys, IDictionary oldValues)
+
+		protected virtual void OnDeleting (LinqDataSourceDeleteEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (Deleting != null)
+				Deleting (this, e);
 		}
-		[MonoTODO]
-		protected virtual void ValidateInsertSupported (IDictionary values)
+
+		protected virtual void OnException (DynamicValidatorEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (Exception != null)
+				Exception (this, e);
 		}
-		[MonoTODO]
-		protected virtual void ValidateOrderByParameter (string name, string value)
+
+		protected virtual void OnInserted (LinqDataSourceStatusEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (Inserted != null)
+				Inserted (this, e);
 		}
-		[MonoTODO]
-		protected virtual void ValidateParameterName (string name)
+
+		protected virtual void OnInserting (LinqDataSourceInsertEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (Inserting != null)
+				Inserting (this, e);
 		}
-		[MonoTODO]
-		protected virtual void ValidateTableType (Type tableType, bool selecting)
+
+		protected virtual void OnSelected (LinqDataSourceStatusEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (Selected != null)
+				Selected (this, e);
 		}
-		[MonoTODO]
-		protected virtual void ValidateUpdateSupported (IDictionary keys, IDictionary values, IDictionary oldValues)
+
+		protected virtual void OnSelecting (LinqDataSourceSelectEventArgs e)
 		{
-			throw new NotImplementedException ();
+			if (Selecting != null)
+				Selecting (this, e);
 		}
+
+		protected virtual void OnUpdated (LinqDataSourceStatusEventArgs e)
+		{
+			if (Updated != null)
+				Updated (this, e);
+		}
+
+		protected virtual void OnUpdating (LinqDataSourceUpdateEventArgs e)
+		{
+			if (Updating != null)
+				Updating (this, e);
+		}
+
+		#endregion
 	}
 }
 #endif