mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
978 lines
42 KiB
C#
978 lines
42 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="LinqDataSourceView.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.UI.WebControls {
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.Data.Linq;
|
|
using System.Data.Linq.Mapping;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Web.Compilation;
|
|
using System.Web.Query.Dynamic;
|
|
using System.Web.Resources;
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
using DynamicValidatorEventArgs = System.Web.DynamicData.DynamicValidatorEventArgs;
|
|
using DynamicDataSourceOperation = System.Web.DynamicData.DynamicDataSourceOperation;
|
|
|
|
public partial class LinqDataSourceView : ContextDataSourceView {
|
|
private static readonly object EventDeleted = new object();
|
|
private static readonly object EventDeleting = new object();
|
|
private static readonly object EventException = new object();
|
|
private static readonly object EventInserted = new object();
|
|
private static readonly object EventInserting = new object();
|
|
private static readonly object EventUpdated = new object();
|
|
private static readonly object EventUpdating = new object();
|
|
|
|
private HttpContext _context;
|
|
private Type _contextType;
|
|
private string _contextTypeName;
|
|
private LinqDataSource _owner;
|
|
private List<ContextDataSourceContextData> _selectContexts;
|
|
private bool _enableDelete;
|
|
private bool _enableInsert;
|
|
private bool _enableObjectTracking = true;
|
|
private bool _enableUpdate;
|
|
private bool _isNewContext;
|
|
private ILinqToSql _linqToSql;
|
|
private bool _reuseSelectContext;
|
|
private bool _storeOriginalValuesInViewState = true;
|
|
private bool _storeOriginalValues;
|
|
private object _selectResult;
|
|
|
|
public LinqDataSourceView(LinqDataSource owner, string name, HttpContext context)
|
|
: this(owner, name, context, new DynamicQueryableWrapper(), new LinqToSqlWrapper()) {
|
|
}
|
|
|
|
// internal constructor that takes mocks for unit tests.
|
|
internal LinqDataSourceView(LinqDataSource owner, string name, HttpContext context,
|
|
IDynamicQueryable dynamicQueryable, ILinqToSql linqToSql)
|
|
: base(owner, name, context, dynamicQueryable) {
|
|
_context = context;
|
|
_owner = owner;
|
|
_linqToSql = linqToSql;
|
|
}
|
|
|
|
public override bool CanDelete {
|
|
get {
|
|
return EnableDelete;
|
|
}
|
|
}
|
|
|
|
public override bool CanInsert {
|
|
get {
|
|
return EnableInsert;
|
|
}
|
|
}
|
|
|
|
// When AutoPage is false the user should manually page in the Selecting event.
|
|
public override bool CanPage {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// When AutoPage is false the user must set the total row count in the Selecting event.
|
|
public override bool CanRetrieveTotalRowCount {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// When AutoSort is false the user should manually sort in the Selecting event.
|
|
public override bool CanSort {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public override bool CanUpdate {
|
|
get {
|
|
return EnableUpdate;
|
|
}
|
|
}
|
|
|
|
public override Type ContextType {
|
|
[SecuritySafeCritical]
|
|
get {
|
|
if (_contextType == null) {
|
|
string typeName = ContextTypeName;
|
|
if (String.IsNullOrEmpty(typeName)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_ContextTypeNameNotSpecified, _owner.ID));
|
|
}
|
|
try {
|
|
_contextType = BuildManager.GetType(typeName, /*throwOnFail*/true, /*ignoreCase*/true);
|
|
}
|
|
catch (Exception e) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_ContextTypeNameNotFound, _owner.ID), e);
|
|
}
|
|
}
|
|
return _contextType;
|
|
}
|
|
}
|
|
|
|
public override string ContextTypeName {
|
|
get {
|
|
return _contextTypeName ?? String.Empty;
|
|
}
|
|
set {
|
|
if (_contextTypeName != value) {
|
|
if (_reuseSelectContext) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_ContextTypeNameChanged, _owner.ID));
|
|
}
|
|
_contextTypeName = value;
|
|
_contextType = null;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool EnableDelete {
|
|
get {
|
|
return _enableDelete;
|
|
}
|
|
set {
|
|
if (_enableDelete != value) {
|
|
_enableDelete = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool EnableInsert {
|
|
get {
|
|
return _enableInsert;
|
|
}
|
|
set {
|
|
if (_enableInsert != value) {
|
|
_enableInsert = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool EnableObjectTracking {
|
|
get {
|
|
return _enableObjectTracking;
|
|
}
|
|
set {
|
|
if (_enableObjectTracking != value) {
|
|
if (_reuseSelectContext) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_EnableObjectTrackingChanged, _owner.ID));
|
|
}
|
|
_enableObjectTracking = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool EnableUpdate {
|
|
get {
|
|
return _enableUpdate;
|
|
}
|
|
set {
|
|
if (_enableUpdate != value) {
|
|
_enableUpdate = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool StoreOriginalValuesInViewState {
|
|
get {
|
|
return _storeOriginalValuesInViewState;
|
|
}
|
|
set {
|
|
if (_storeOriginalValuesInViewState != value) {
|
|
_storeOriginalValuesInViewState = value;
|
|
OnDataSourceViewChanged(EventArgs.Empty);
|
|
}
|
|
}
|
|
}
|
|
|
|
public string TableName {
|
|
get {
|
|
return EntitySetName;
|
|
}
|
|
set {
|
|
if (EntitySetName != value) {
|
|
if (_reuseSelectContext) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_TableNameChanged, _owner.ID));
|
|
}
|
|
EntitySetName = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceStatusEventArgs> ContextCreated {
|
|
add {
|
|
Events.AddHandler(EventContextCreated, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventContextCreated, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceContextEventArgs> ContextCreating {
|
|
add {
|
|
Events.AddHandler(EventContextCreating, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventContextCreating, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceDisposeEventArgs> ContextDisposing {
|
|
add {
|
|
Events.AddHandler(EventContextDisposing, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventContextDisposing, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceStatusEventArgs> Deleted {
|
|
add {
|
|
Events.AddHandler(EventDeleted, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventDeleted, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceDeleteEventArgs> Deleting {
|
|
add {
|
|
Events.AddHandler(EventDeleting, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventDeleting, value);
|
|
}
|
|
}
|
|
|
|
internal event EventHandler<DynamicValidatorEventArgs> Exception {
|
|
add {
|
|
Events.AddHandler(EventException, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventException, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceStatusEventArgs> Inserted {
|
|
add {
|
|
Events.AddHandler(EventInserted, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventInserted, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceInsertEventArgs> Inserting {
|
|
add {
|
|
Events.AddHandler(EventInserting, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventInserting, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceStatusEventArgs> Selected {
|
|
add {
|
|
Events.AddHandler(EventSelected, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventSelected, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceSelectEventArgs> Selecting {
|
|
add {
|
|
Events.AddHandler(EventSelecting, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventSelecting, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceStatusEventArgs> Updated {
|
|
add {
|
|
Events.AddHandler(EventUpdated, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventUpdated, value);
|
|
}
|
|
}
|
|
|
|
public event EventHandler<LinqDataSourceUpdateEventArgs> Updating {
|
|
add {
|
|
Events.AddHandler(EventUpdating, value);
|
|
}
|
|
remove {
|
|
Events.RemoveHandler(EventUpdating, value);
|
|
}
|
|
}
|
|
|
|
protected virtual object CreateContext(Type contextType) {
|
|
return DataSourceHelper.CreateObjectInstance(contextType);
|
|
}
|
|
|
|
protected override ContextDataSourceContextData CreateContext(DataSourceOperation operation) {
|
|
if (operation == DataSourceOperation.Select) {
|
|
return CreateContextAndTableForSelect();
|
|
}
|
|
return CreateContextAndTableForEdit(operation);
|
|
}
|
|
|
|
private ContextDataSourceContextData CreateContextAndTable(DataSourceOperation operation) {
|
|
ContextDataSourceContextData contextData = null;
|
|
bool eventFired = false;
|
|
try {
|
|
LinqDataSourceContextEventArgs contextEventArgs = new LinqDataSourceContextEventArgs(operation);
|
|
OnContextCreating(contextEventArgs);
|
|
|
|
contextData = new ContextDataSourceContextData(contextEventArgs.ObjectInstance);
|
|
Type contextType = null;
|
|
MemberInfo tableMemberInfo = null;
|
|
if (contextData.Context == null) {
|
|
// construct the context unless accessing a static table for Select.
|
|
contextType = ContextType;
|
|
tableMemberInfo = GetTableMemberInfo(contextType);
|
|
if (tableMemberInfo != null) {
|
|
if (MemberIsStatic(tableMemberInfo)) {
|
|
if (operation != DataSourceOperation.Select) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_TableCannotBeStatic, TableName, contextType.Name, _owner.ID));
|
|
}
|
|
}
|
|
else {
|
|
contextData.Context = CreateContext(contextType);
|
|
_isNewContext = true;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// use the manually constructed context.
|
|
tableMemberInfo = GetTableMemberInfo(contextData.Context.GetType());
|
|
}
|
|
|
|
// fetch the table from the context.
|
|
if (tableMemberInfo != null) {
|
|
FieldInfo field = tableMemberInfo as FieldInfo;
|
|
if (field != null) {
|
|
contextData.EntitySet = field.GetValue(contextData.Context);
|
|
}
|
|
PropertyInfo property = tableMemberInfo as PropertyInfo;
|
|
if (property != null) {
|
|
contextData.EntitySet = property.GetValue(contextData.Context, null);
|
|
}
|
|
}
|
|
if (contextData.EntitySet == null) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_TableNameNotFound, TableName, contextType.Name, _owner.ID));
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
eventFired = true;
|
|
LinqDataSourceStatusEventArgs createdEventArgs = new LinqDataSourceStatusEventArgs(e);
|
|
OnContextCreated(createdEventArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.ContextCreate));
|
|
// CreateContextAndTable will return null if this exception is handled.
|
|
if (!createdEventArgs.ExceptionHandled) {
|
|
throw;
|
|
}
|
|
}
|
|
finally {
|
|
if (!eventFired) {
|
|
// contextData can be null if exception thrown from ContextCreating handler.
|
|
object context = (contextData == null) ? null : contextData.Context;
|
|
LinqDataSourceStatusEventArgs createdEventArgs = new LinqDataSourceStatusEventArgs(context);
|
|
OnContextCreated(createdEventArgs);
|
|
}
|
|
}
|
|
return contextData;
|
|
}
|
|
|
|
private ContextDataSourceContextData CreateContextAndTableForEdit(DataSourceOperation operation) {
|
|
ContextDataSourceContextData contextData = CreateContextAndTable(operation);
|
|
// context data may be null or incomplete if an exception was handled
|
|
if (contextData != null) {
|
|
if (contextData.Context == null) {
|
|
return null;
|
|
}
|
|
if (contextData.EntitySet == null) {
|
|
DisposeContext(contextData.Context);
|
|
return null;
|
|
}
|
|
ValidateContextType(contextData.Context.GetType(), false);
|
|
ValidateTableType(contextData.EntitySet.GetType(), false);
|
|
}
|
|
return contextData;
|
|
}
|
|
|
|
private ContextDataSourceContextData CreateContextAndTableForSelect() {
|
|
_isNewContext = false;
|
|
|
|
if (_selectContexts == null) {
|
|
_selectContexts = new List<ContextDataSourceContextData>();
|
|
}
|
|
else if (_reuseSelectContext && _selectContexts.Count > 0) {
|
|
return _selectContexts[_selectContexts.Count - 1];
|
|
}
|
|
|
|
// context data may be null if an exception was handled
|
|
ContextDataSourceContextData contextData = CreateContextAndTable(DataSourceOperation.Select);
|
|
if (contextData != null) {
|
|
if (contextData.Context != null) {
|
|
ValidateContextType(contextData.Context.GetType(), true);
|
|
}
|
|
if (contextData.EntitySet != null) {
|
|
ValidateTableType(contextData.EntitySet.GetType(), true);
|
|
}
|
|
|
|
_selectContexts.Add(contextData);
|
|
|
|
// context may not be dlinq context or may be null if table was static.
|
|
DataContext dlinqContext = contextData.Context as DataContext;
|
|
if ((dlinqContext != null) && _isNewContext) {
|
|
dlinqContext.ObjectTrackingEnabled = EnableObjectTracking;
|
|
}
|
|
// don't reuse dlinq contexts that cache data or exterior changes will not be reflected.
|
|
_reuseSelectContext = (dlinqContext == null) || !EnableObjectTracking;
|
|
}
|
|
return contextData;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "object",
|
|
Justification = "Names are consistent with those used in the ObjectDataSource classes")]
|
|
protected virtual void DeleteDataObject(object dataContext, object table, object oldDataObject) {
|
|
_linqToSql.Attach((ITable)table, oldDataObject);
|
|
_linqToSql.Remove((ITable)table, oldDataObject);
|
|
_linqToSql.SubmitChanges((DataContext)dataContext);
|
|
}
|
|
|
|
protected override int DeleteObject(object oldEntity) {
|
|
LinqDataSourceDeleteEventArgs deleteEventArgs = new LinqDataSourceDeleteEventArgs(oldEntity);
|
|
OnDeleting(deleteEventArgs);
|
|
if (deleteEventArgs.Cancel) {
|
|
return -1;
|
|
}
|
|
|
|
LinqDataSourceStatusEventArgs deletedEventArgs = null;
|
|
try {
|
|
DeleteDataObject(Context, EntitySet, deleteEventArgs.OriginalObject);
|
|
}
|
|
catch (Exception e) {
|
|
// allow user to handle dlinq exceptions including OnValidate validation.
|
|
deletedEventArgs = new LinqDataSourceStatusEventArgs(e);
|
|
OnDeleted(deletedEventArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Delete));
|
|
if (deletedEventArgs.ExceptionHandled) {
|
|
return -1;
|
|
}
|
|
throw;
|
|
}
|
|
deletedEventArgs = new LinqDataSourceStatusEventArgs(deleteEventArgs.OriginalObject);
|
|
OnDeleted(deletedEventArgs);
|
|
|
|
return 1;
|
|
}
|
|
|
|
protected override void DisposeContext(object dataContext) {
|
|
if (dataContext != null) {
|
|
LinqDataSourceDisposeEventArgs disposingEventArgs = new LinqDataSourceDisposeEventArgs(dataContext);
|
|
OnContextDisposing(disposingEventArgs);
|
|
if (!disposingEventArgs.Cancel) {
|
|
base.DisposeContext(dataContext);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override int ExecuteDelete(IDictionary keys, IDictionary oldValues) {
|
|
ValidateDeleteSupported(keys, oldValues);
|
|
return base.ExecuteDelete(keys, oldValues);
|
|
}
|
|
|
|
protected override int ExecuteInsert(IDictionary values) {
|
|
ValidateInsertSupported(values);
|
|
return base.ExecuteInsert(values);
|
|
}
|
|
|
|
protected override int ExecuteUpdate(IDictionary keys, IDictionary values, IDictionary oldValues) {
|
|
ValidateUpdateSupported(keys, values, oldValues);
|
|
return base.ExecuteUpdate(keys, values, oldValues);
|
|
}
|
|
|
|
protected internal override IEnumerable ExecuteSelect(DataSourceSelectArguments arguments) {
|
|
ClearOriginalValues();
|
|
|
|
QueryContext queryContext = CreateQueryContext(arguments);
|
|
object table = GetSource(queryContext);
|
|
IList result = null;
|
|
|
|
if (_selectResult != null) {
|
|
try {
|
|
IQueryable query = QueryableDataSourceHelper.AsQueryable(_selectResult);
|
|
query = ExecuteQuery(query, queryContext);
|
|
|
|
Type dataObjectType = GetDataObjectType(query.GetType());
|
|
result = query.ToList(dataObjectType);
|
|
|
|
if (_storeOriginalValues) {
|
|
ITable dlinqTable = table as ITable;
|
|
// We can store original values if the type is exact or derived
|
|
if ((dlinqTable != null) && dataObjectType.IsAssignableFrom(EntityType)) {
|
|
StoreOriginalValues(result);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e) {
|
|
result = null;
|
|
LinqDataSourceStatusEventArgs selectedEventArgs = new LinqDataSourceStatusEventArgs(e);
|
|
OnSelected(selectedEventArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Select));
|
|
if (!selectedEventArgs.ExceptionHandled) {
|
|
throw;
|
|
}
|
|
}
|
|
finally {
|
|
if (result != null) {
|
|
int totalRowCount = -1; // paging performed, but row count not available.
|
|
if (arguments.RetrieveTotalRowCount) {
|
|
totalRowCount = arguments.TotalRowCount;
|
|
}
|
|
else if (!AutoPage) {
|
|
totalRowCount = result.Count;
|
|
}
|
|
LinqDataSourceStatusEventArgs selectedEventArgs = new LinqDataSourceStatusEventArgs(result, totalRowCount);
|
|
OnSelected(selectedEventArgs);
|
|
}
|
|
}
|
|
// Null out the select context
|
|
Context = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
protected override object GetSource(QueryContext context) {
|
|
LinqDataSourceSelectEventArgs selectEventArgs = new LinqDataSourceSelectEventArgs(
|
|
context.Arguments,
|
|
context.WhereParameters,
|
|
context.OrderByParameters,
|
|
context.GroupByParameters,
|
|
context.OrderGroupsByParameters,
|
|
context.SelectParameters);
|
|
|
|
OnSelecting(selectEventArgs);
|
|
if (selectEventArgs.Cancel) {
|
|
return null;
|
|
}
|
|
|
|
_selectResult = selectEventArgs.Result;
|
|
object table = _selectResult;
|
|
|
|
// Original values should only be stored for valid delete and update scenarios.
|
|
_storeOriginalValues = StoreOriginalValuesInViewState && (CanDelete || CanUpdate) &&
|
|
String.IsNullOrEmpty(GroupBy) && String.IsNullOrEmpty(SelectNew);
|
|
|
|
if (_selectResult == null) {
|
|
table = base.GetSource(context);
|
|
_selectResult = table;
|
|
}
|
|
// If the provided select result was not a DLinq table and we need to store
|
|
// original values then we must get the table and create a new data context
|
|
// instance so that we can access the column metadata.
|
|
else if (!(table is ITable) && _storeOriginalValues) {
|
|
table = base.GetSource(context);
|
|
}
|
|
|
|
return table;
|
|
}
|
|
|
|
protected virtual MemberInfo GetTableMemberInfo(Type contextType) {
|
|
string tableName = TableName;
|
|
if (String.IsNullOrEmpty(tableName)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_TableNameNotSpecified, _owner.ID));
|
|
}
|
|
|
|
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, tableName, StringComparison.OrdinalIgnoreCase)) {
|
|
return members[i];
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private ReadOnlyCollection<MetaDataMember> GetTableMetaDataMembers(ITable table, Type dataObjectType) {
|
|
DataContext context = ((ITable)table).Context;
|
|
MetaModel contextMetaData = context.Mapping;
|
|
MetaTable tableMetaData = contextMetaData.GetTable(dataObjectType);
|
|
MetaType rowMetaData = tableMetaData.Model.GetMetaType(dataObjectType);
|
|
return rowMetaData.DataMembers;
|
|
}
|
|
|
|
protected override void HandleValidationErrors(IDictionary<string, Exception> errors, DataSourceOperation operation) {
|
|
LinqDataSourceValidationException exception = new LinqDataSourceValidationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_ValidationFailed,
|
|
EntityType, errors.Values.First().Message),
|
|
errors);
|
|
|
|
bool exceptionHandled = false;
|
|
|
|
switch (operation) {
|
|
case DataSourceOperation.Delete:
|
|
LinqDataSourceDeleteEventArgs deleteEventArgs = new LinqDataSourceDeleteEventArgs(exception);
|
|
OnDeleting(deleteEventArgs);
|
|
OnException(new DynamicValidatorEventArgs(exception, DynamicDataSourceOperation.Delete));
|
|
exceptionHandled = deleteEventArgs.ExceptionHandled;
|
|
break;
|
|
|
|
case DataSourceOperation.Insert:
|
|
LinqDataSourceInsertEventArgs insertEventArgs = new LinqDataSourceInsertEventArgs(exception);
|
|
OnInserting(insertEventArgs);
|
|
OnException(new DynamicValidatorEventArgs(exception, DynamicDataSourceOperation.Insert));
|
|
exceptionHandled = insertEventArgs.ExceptionHandled;
|
|
break;
|
|
case DataSourceOperation.Update:
|
|
// allow user to handle conversion or dlinq property validation exceptions.
|
|
LinqDataSourceUpdateEventArgs updateEventArgs = new LinqDataSourceUpdateEventArgs(exception);
|
|
OnUpdating(updateEventArgs);
|
|
OnException(new DynamicValidatorEventArgs(exception, DynamicDataSourceOperation.Update));
|
|
exceptionHandled = updateEventArgs.ExceptionHandled;
|
|
break;
|
|
}
|
|
|
|
if (!exceptionHandled) {
|
|
throw exception;
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "object",
|
|
Justification = "Names are consistent with those used in the ObjectDataSource classes")]
|
|
protected virtual void InsertDataObject(object dataContext, object table, object newDataObject) {
|
|
_linqToSql.Add((ITable)table, newDataObject);
|
|
_linqToSql.SubmitChanges((DataContext)dataContext);
|
|
}
|
|
|
|
protected override int InsertObject(object newEntity) {
|
|
LinqDataSourceInsertEventArgs insertEventArgs = new LinqDataSourceInsertEventArgs(newEntity);
|
|
OnInserting(insertEventArgs);
|
|
if (insertEventArgs.Cancel) {
|
|
return -1;
|
|
}
|
|
|
|
LinqDataSourceStatusEventArgs insertedEventArgs = null;
|
|
try {
|
|
InsertDataObject(Context, EntitySet, insertEventArgs.NewObject);
|
|
}
|
|
catch (Exception e) {
|
|
// allow user to handle dlinq exceptions including OnValidate validation.
|
|
insertedEventArgs = new LinqDataSourceStatusEventArgs(e);
|
|
OnInserted(insertedEventArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Insert));
|
|
if (insertedEventArgs.ExceptionHandled) {
|
|
return -1;
|
|
}
|
|
throw;
|
|
}
|
|
insertedEventArgs = new LinqDataSourceStatusEventArgs(insertEventArgs.NewObject);
|
|
OnInserted(insertedEventArgs);
|
|
|
|
return 1;
|
|
}
|
|
|
|
private static bool MemberIsStatic(MemberInfo member) {
|
|
FieldInfo field = member as FieldInfo;
|
|
if (field != null) {
|
|
return field.IsStatic;
|
|
}
|
|
PropertyInfo property = member as PropertyInfo;
|
|
if (property != null) {
|
|
MethodInfo propertyGetter = property.GetGetMethod();
|
|
return ((propertyGetter != null) && propertyGetter.IsStatic);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnContextCreated(LinqDataSourceStatusEventArgs e) {
|
|
EventHandler<LinqDataSourceStatusEventArgs> handler = (EventHandler<LinqDataSourceStatusEventArgs>)Events[EventContextCreated];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnContextCreating(LinqDataSourceContextEventArgs e) {
|
|
EventHandler<LinqDataSourceContextEventArgs> handler = (EventHandler<LinqDataSourceContextEventArgs>)Events[EventContextCreating];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnContextDisposing(LinqDataSourceDisposeEventArgs e) {
|
|
EventHandler<LinqDataSourceDisposeEventArgs> handler = (EventHandler<LinqDataSourceDisposeEventArgs>)Events[EventContextDisposing];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnDeleted(LinqDataSourceStatusEventArgs e) {
|
|
EventHandler<LinqDataSourceStatusEventArgs> handler =
|
|
(EventHandler<LinqDataSourceStatusEventArgs>)Events[EventDeleted];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnDeleting(LinqDataSourceDeleteEventArgs e) {
|
|
EventHandler<LinqDataSourceDeleteEventArgs> handler =
|
|
(EventHandler<LinqDataSourceDeleteEventArgs>)Events[EventDeleting];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnException(DynamicValidatorEventArgs e) {
|
|
EventHandler<DynamicValidatorEventArgs> handler = (EventHandler<DynamicValidatorEventArgs>)Events[EventException];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnInserted(LinqDataSourceStatusEventArgs e) {
|
|
EventHandler<LinqDataSourceStatusEventArgs> handler =
|
|
(EventHandler<LinqDataSourceStatusEventArgs>)Events[EventInserted];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnInserting(LinqDataSourceInsertEventArgs e) {
|
|
EventHandler<LinqDataSourceInsertEventArgs> handler =
|
|
(EventHandler<LinqDataSourceInsertEventArgs>)Events[EventInserting];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnSelected(LinqDataSourceStatusEventArgs e) {
|
|
EventHandler<LinqDataSourceStatusEventArgs> handler =
|
|
(EventHandler<LinqDataSourceStatusEventArgs>)Events[EventSelected];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnSelecting(LinqDataSourceSelectEventArgs e) {
|
|
EventHandler<LinqDataSourceSelectEventArgs> handler =
|
|
(EventHandler<LinqDataSourceSelectEventArgs>)Events[EventSelecting];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnUpdated(LinqDataSourceStatusEventArgs e) {
|
|
EventHandler<LinqDataSourceStatusEventArgs> handler =
|
|
(EventHandler<LinqDataSourceStatusEventArgs>)Events[EventUpdated];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2109:ReviewVisibleEventHandlers", MessageId = "0#")]
|
|
protected virtual void OnUpdating(LinqDataSourceUpdateEventArgs e) {
|
|
EventHandler<LinqDataSourceUpdateEventArgs> handler =
|
|
(EventHandler<LinqDataSourceUpdateEventArgs>)Events[EventUpdating];
|
|
if (handler != null) {
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
internal void ReleaseSelectContexts() {
|
|
if (_selectContexts != null) {
|
|
foreach (ContextDataSourceContextData contextData in _selectContexts) {
|
|
DisposeContext(contextData.Context);
|
|
}
|
|
}
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters",
|
|
Justification = "Names are consistent with those used in the ObjectDataSource classes")]
|
|
protected virtual void ResetDataObject(object table, object dataObject) {
|
|
// DevDiv Bugs 187705, and 114508: Resetting is no longer necessary because
|
|
// select has it's own context, but this method is kept for compatibility purposes.
|
|
|
|
// no-op
|
|
}
|
|
|
|
public IEnumerable Select(DataSourceSelectArguments arguments) {
|
|
return ExecuteSelect(arguments);
|
|
}
|
|
|
|
private Dictionary<string, Exception> SetDataObjectProperties(object oldDataObject, object newDataObject) {
|
|
Dictionary<string, Exception> validateExceptions = null;
|
|
|
|
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(oldDataObject);
|
|
foreach (PropertyDescriptor property in properties) {
|
|
if (property.PropertyType.IsSerializable && !property.IsReadOnly) {
|
|
object newValue = property.GetValue(newDataObject);
|
|
try {
|
|
property.SetValue(oldDataObject, newValue);
|
|
}
|
|
catch (Exception e) {
|
|
if (validateExceptions == null) {
|
|
validateExceptions = new Dictionary<string, Exception>(StringComparer.OrdinalIgnoreCase);
|
|
}
|
|
validateExceptions[property.Name] = e;
|
|
}
|
|
}
|
|
}
|
|
|
|
return validateExceptions;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Security", "CA2116:AptcaMethodsShouldOnlyCallAptcaMethods",
|
|
Justification = "System.Data.Linq assembly will be changing to support partial trust.")]
|
|
protected override void StoreOriginalValues(IList results) {
|
|
Type entityType = EntityType;
|
|
IDictionary<string, MetaDataMember> columns = GetTableMetaDataMembers((ITable)EntitySet, entityType).ToDictionary(c => c.Member.Name);
|
|
|
|
StoreOriginalValues(results, p => columns.ContainsKey(p.Name) &&
|
|
(columns[p.Name].IsPrimaryKey ||
|
|
columns[p.Name].IsVersion ||
|
|
(columns[p.Name].UpdateCheck != UpdateCheck.Never)));
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Naming", "CA1720:AvoidTypeNamesInParameters",
|
|
Justification = "Names are consistent with those used in the ObjectDataSource classes")]
|
|
protected virtual void UpdateDataObject(object dataContext, object table,
|
|
object oldDataObject, object newDataObject) {
|
|
_linqToSql.Attach((ITable)table, oldDataObject);
|
|
Dictionary<string, Exception> validateExceptions = SetDataObjectProperties(oldDataObject, newDataObject);
|
|
|
|
// package up dlinq validation exceptions into single exception.
|
|
if (validateExceptions != null) {
|
|
throw new LinqDataSourceValidationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_ValidationFailed, oldDataObject.GetType(), validateExceptions.Values.First().Message), validateExceptions);
|
|
}
|
|
|
|
_linqToSql.SubmitChanges((DataContext)dataContext);
|
|
}
|
|
|
|
protected override int UpdateObject(object oldEntity, object newEntity) {
|
|
LinqDataSourceUpdateEventArgs updateEventArgs = new LinqDataSourceUpdateEventArgs(oldEntity, newEntity);
|
|
OnUpdating(updateEventArgs);
|
|
if (updateEventArgs.Cancel) {
|
|
return -1;
|
|
}
|
|
|
|
LinqDataSourceStatusEventArgs updatedEventArgs = null;
|
|
try {
|
|
UpdateDataObject(Context, EntitySet, updateEventArgs.OriginalObject, updateEventArgs.NewObject);
|
|
}
|
|
catch (Exception e) {
|
|
ResetDataObject(EntitySet, updateEventArgs.OriginalObject);
|
|
// allow user to handle dlinq exceptions including OnValidate validation.
|
|
updatedEventArgs = new LinqDataSourceStatusEventArgs(e);
|
|
OnUpdated(updatedEventArgs);
|
|
OnException(new DynamicValidatorEventArgs(e, DynamicDataSourceOperation.Update));
|
|
if (updatedEventArgs.ExceptionHandled) {
|
|
return -1;
|
|
}
|
|
throw;
|
|
}
|
|
updatedEventArgs = new LinqDataSourceStatusEventArgs(updateEventArgs.NewObject);
|
|
OnUpdated(updatedEventArgs);
|
|
|
|
return 1;
|
|
}
|
|
|
|
protected virtual void ValidateContextType(Type contextType, bool selecting) {
|
|
if (!selecting && !typeof(DataContext).IsAssignableFrom(contextType)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_InvalidContextType, _owner.ID));
|
|
}
|
|
}
|
|
|
|
protected virtual void ValidateDeleteSupported(IDictionary keys, IDictionary oldValues) {
|
|
if (!CanDelete) {
|
|
throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_DeleteNotSupported, _owner.ID));
|
|
}
|
|
ValidateEditSupported();
|
|
}
|
|
|
|
protected virtual void ValidateEditSupported() {
|
|
if (!String.IsNullOrEmpty(GroupBy)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_GroupByNotSupportedOnEdit, _owner.ID));
|
|
}
|
|
if (!String.IsNullOrEmpty(SelectNew)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_SelectNewNotSupportedOnEdit, _owner.ID));
|
|
}
|
|
}
|
|
|
|
protected virtual void ValidateInsertSupported(IDictionary values) {
|
|
if (!CanInsert) {
|
|
throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_InsertNotSupported, _owner.ID));
|
|
}
|
|
ValidateEditSupported();
|
|
if ((values == null) || (values.Count == 0)) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_InsertRequiresValues, _owner.ID));
|
|
}
|
|
}
|
|
|
|
protected virtual void ValidateTableType(Type tableType, bool selecting) {
|
|
if (!selecting) {
|
|
if (!(tableType.IsGenericType && tableType.GetGenericArguments().Length == 1 && typeof(ITable).IsAssignableFrom(tableType))) {
|
|
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_InvalidTablePropertyType, _owner.ID));
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void ValidateUpdateSupported(IDictionary keys, IDictionary values, IDictionary oldValues) {
|
|
if (!CanUpdate) {
|
|
throw new NotSupportedException(String.Format(CultureInfo.InvariantCulture,
|
|
AtlasWeb.LinqDataSourceView_UpdateNotSupported, _owner.ID));
|
|
}
|
|
ValidateEditSupported();
|
|
}
|
|
}
|
|
|
|
}
|
|
|