Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web.Extensions/ui/WebControls/ContextDataSourceView.cs

@@ -0,0 +1,257 @@
+namespace System.Web.UI.WebControls {
+    using System;
+    using System.Collections;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Reflection;
+    using System.Security.Permissions;
+    using System.Web;
+    using System.Web.Compilation;
+    using System.Web.UI;
+
+    public abstract class ContextDataSourceView : QueryableDataSourceView {
+        private string _entitySetName;
+        private string _contextTypeName;
+
+        private Type _contextType;
+        private string _entityTypeName;
+        private Type _entityType;
+        private Type _entitySetType;
+
+        private Control _owner;
+
+        protected static readonly object EventContextCreating = new object();
+        protected static readonly object EventContextCreated = new object();
+        protected static readonly object EventContextDisposing = new object();
+
+        protected ContextDataSourceView(DataSourceControl owner, string viewName, HttpContext context)
+            : base(owner, viewName, context) {
+            _owner = owner;
+        }
+
+        internal ContextDataSourceView(DataSourceControl owner, string viewName, HttpContext context, IDynamicQueryable queryable)
+            : base(owner, viewName, context, queryable) {
+        }
+
+        public string EntitySetName {
+            get {
+                return _entitySetName ?? String.Empty;
+            }
+            set {
+                if (_entitySetName != value) {
+                    _entitySetName = value;
+                    _entitySetType = null;
+                    OnDataSourceViewChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+
+        public string EntityTypeName {
+            get {
+                return _entityTypeName ?? String.Empty;
+            }
+            set {
+                if (_entityTypeName != value) {
+                    _entityTypeName = value;
+                    _entityType = null;
+                    OnDataSourceViewChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        protected override Type EntityType {
+            get {
+                string typeName = EntityTypeName;
+                if (_entityType == null) {
+                    _entityType = GetDataObjectTypeByName(typeName) ?? GetDataObjectType(EntitySetType);
+                }
+                return _entityType;
+            }
+        }
+
+        public virtual string ContextTypeName {
+            get {
+                return _contextTypeName ?? String.Empty;
+            }
+            set {
+                if (_contextTypeName != value) {
+                    _contextTypeName = value;
+                    _contextType = null;
+                    OnDataSourceViewChanged(EventArgs.Empty);
+                }
+            }
+        }
+
+        public virtual Type ContextType {
+            get {
+                if (_contextType == null && !String.IsNullOrEmpty(ContextTypeName)) {
+                    _contextType = DataSourceHelper.GetType(ContextTypeName);
+                }
+                return _contextType;
+            }
+        }
+
+        /// <summary>
+        /// Current Context
+        /// </summary>
+        protected object Context {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Current EntitySet
+        /// </summary>
+        protected object EntitySet {
+            get;
+            private set;
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods",
+            Justification = "The result of GetEntitySetType() is cached unless the EntitySetTypeName changes.")]
+        protected Type EntitySetType {
+            get {
+                if (_entitySetType == null) {
+                    _entitySetType = GetEntitySetType();
+                }
+                return _entitySetType;
+            }
+        }
+
+        // Default implementation assumes the EntitySet is a property or field of the Context        
+        protected virtual Type GetEntitySetType() {
+            MemberInfo mi = GetEntitySetMember(ContextType);
+            if (mi.MemberType == MemberTypes.Property) {
+                return ((PropertyInfo)mi).PropertyType;
+            }
+            else if (mi.MemberType == MemberTypes.Field) {
+                return ((FieldInfo)mi).FieldType;
+            }
+            // 
+            throw new InvalidOperationException("EntitySet Type must be a field or property");
+        }
+
+        private MemberInfo GetEntitySetMember(Type contextType) {
+            string entitySetTypeName = EntitySetName;
+            if (String.IsNullOrEmpty(entitySetTypeName)) {
+                // 
+                return null;
+            }
+
+            MemberInfo[] members = contextType.FindMembers(MemberTypes.Field | MemberTypes.Property,
+                                                           BindingFlags.Public | BindingFlags.Instance |
+                                                           BindingFlags.Static, /*filter*/null, /*filterCriteria*/null);
+
+            for (int i = 0; i < members.Length; i++) {
+                if (String.Equals(members[i].Name, entitySetTypeName, StringComparison.OrdinalIgnoreCase)) {
+                    return members[i];
+                }
+            }
+            return null;
+        }
+
+        private static Type GetDataObjectTypeByName(string typeName) {
+            Type entityType = null;            
+            if (!String.IsNullOrEmpty(typeName)) {
+                entityType = BuildManager.GetType(typeName, /*throwOnFail*/ false, /*ignoreCase*/ true);
+            }
+            return entityType;
+        }
+
+        protected virtual Type GetDataObjectType(Type type) {
+            if (type.IsGenericType) {
+                Type[] genericTypes = type.GetGenericArguments();
+                if (genericTypes.Length == 1) {
+                    return genericTypes[0];
+                }
+            }
+            // 
+            return typeof(object);
+        }
+
+        protected virtual ContextDataSourceContextData CreateContext(DataSourceOperation operation) {
+            return null;
+        }
+
+        protected override object GetSource(QueryContext context) {
+            ContextDataSourceContextData contextData = CreateContext(DataSourceOperation.Select);
+            if (contextData != null) {
+                // Set the current context
+                Context = contextData.Context;
+                EntitySet = contextData.EntitySet;
+                return EntitySet;
+            }
+
+            return null;
+        }
+
+        protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) {
+            ContextDataSourceContextData contextData = null;
+            try {
+                contextData = CreateContext(DataSourceOperation.Update);
+                if (contextData != null) {
+                    // Set the current context
+                    Context = contextData.Context;
+                    EntitySet = contextData.EntitySet;
+                    return base.ExecuteUpdate(keys, values, oldValues);
+                }
+            }
+            finally {
+                DisposeContext();
+            }
+
+            return -1;
+        }
+
+        protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues) {
+            ContextDataSourceContextData contextData = null;
+            try {
+                contextData = CreateContext(DataSourceOperation.Delete);
+                if (contextData != null) {
+                    // Set the current context
+                    Context = contextData.Context;
+                    EntitySet = contextData.EntitySet;
+                    return base.ExecuteDelete(keys, oldValues);
+                }
+            }
+            finally {
+                DisposeContext();
+            }
+
+            return -1;
+        }
+
+        protected override int ExecuteInsert(IDictionary values) {
+            ContextDataSourceContextData contextData = null;
+            try {
+                contextData = CreateContext(DataSourceOperation.Insert);
+                if (contextData != null) {
+                    // Set the current context
+                    Context = contextData.Context;
+                    EntitySet = contextData.EntitySet;
+
+                    return base.ExecuteInsert(values);
+                }
+            }
+            finally {
+                DisposeContext();
+            }
+
+            return -1;
+        }
+
+        protected virtual void DisposeContext(object dataContext) {
+            if (dataContext != null) {
+                IDisposable disposableObject = dataContext as IDisposable;
+                if (disposableObject != null) {
+                    disposableObject.Dispose();
+                }
+                dataContext = null;
+            }
+        }
+
+        protected void DisposeContext() {
+            DisposeContext(Context);
+        }
+    }
+}