protected QueryableDataSourceEditData BuildInsertObject(IDictionary values, IDictionary <string, Exception> validationErrors)
{
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
InsertParameters,
InsertParameters.GetValues(_context, _owner),
caseInsensitiveNewValues,
validationErrors))
{
return(editData);
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
InsertParameters,
values,
caseInsensitiveNewValues, validationErrors))
{
return(editData);
}
editData.NewDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveNewValues, validationErrors);
return(editData);
}
protected virtual void TrackViewState()
{
_isTracking = true;
DataSourceHelper.TrackViewState(_whereParameters);
DataSourceHelper.TrackViewState(_orderByParameters);
DataSourceHelper.TrackViewState(_groupByParameters);
DataSourceHelper.TrackViewState(_orderGroupsByParameters);
DataSourceHelper.TrackViewState(_selectNewParameters);
}
DataSourceView IDataSource.GetView(string viewName)
{
IDataSource source = this._dataSource as IDataSource;
if (source != null)
{
return(source.GetView(viewName));
}
return(new ReadOnlyDataSourceView(this, this._dataMember, DataSourceHelper.GetResolvedDataSource(this._dataSource, this._dataMember)));
}
/// <devdoc>
/// Check for IDataSource, IListSource, and IEnumerable, and return an
/// approprite DataSourceView.
/// </devdoc>
DataSourceView IDataSource.GetView(string viewName)
{
// Check first for IDataSource
IDataSource ds = _dataSource as IDataSource;
if (ds != null)
{
return(ds.GetView(viewName));
}
IEnumerable enumerable = DataSourceHelper.GetResolvedDataSource(_dataSource, _dataMember);
return(new ReadOnlyDataSourceView(this, _dataMember, enumerable));
}
protected virtual object SaveViewState()
{
object[] myState = new object[6];
myState[0] = DataSourceHelper.SaveViewState(_whereParameters);
myState[1] = DataSourceHelper.SaveViewState(_orderByParameters);
myState[2] = DataSourceHelper.SaveViewState(_groupByParameters);
myState[3] = DataSourceHelper.SaveViewState(_orderGroupsByParameters);
myState[4] = DataSourceHelper.SaveViewState(_selectNewParameters);
if ((_originalValues != null) && (_originalValues.Count > 0))
{
myState[5] = _originalValues;
}
return(myState);
}
@"(\s+(asc|ascending|desc|descending))?\s*$", RegexOptions.IgnoreCase); // order operators
internal static IQueryable AsQueryable(object o)
{
IQueryable oQueryable = o as IQueryable;
if (oQueryable != null)
{
return(oQueryable);
}
// Wrap strings in IEnumerable<string> instead of treating as IEnumerable<char>.
string oString = o as string;
if (oString != null)
{
return(Queryable.AsQueryable(new string[] { oString }));
}
IEnumerable oEnumerable = o as IEnumerable;
if (oEnumerable != null)
{
// IEnumerable<T> can be directly converted to an IQueryable<T>.
Type genericType = FindGenericEnumerableType(o.GetType());
if (genericType != null)
{
// The non-generic Queryable.AsQueryable gets called for array types, executing
// the FindGenericType logic again. Might want to investigate way to avoid this.
return(Queryable.AsQueryable(oEnumerable));
}
// Wrap non-generic IEnumerables in IEnumerable<object>.
List <object> genericList = new List <object>();
foreach (object item in oEnumerable)
{
genericList.Add(item);
}
return(Queryable.AsQueryable(genericList));
}
// Wrap non-IEnumerable types in IEnumerable<T>.
Type listType = typeof(List <>).MakeGenericType(o.GetType());
IList list = (IList)DataSourceHelper.CreateObjectInstance(listType);
list.Add(o);
return(Queryable.AsQueryable(list));
}
protected QueryableDataSourceEditData BuildDeleteObject(IDictionary keys, IDictionary oldValues, IDictionary <string, Exception> validationErrors)
{
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary originalValues = GetOriginalValues(keys);
ParameterCollection deleteParameters = DeleteParameters;
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
keys,
caseInsensitiveOldValues,
validationErrors))
{
return(editData);
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
oldValues,
caseInsensitiveOldValues,
validationErrors))
{
return(editData);
}
if (originalValues != null)
{
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
deleteParameters,
originalValues,
caseInsensitiveOldValues,
validationErrors))
{
return(editData);
}
}
editData.OriginalDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveOldValues, validationErrors);
return(editData);
}
protected virtual object CreateContext(Type contextType)
{
return(DataSourceHelper.CreateObjectInstance(contextType));
}
protected QueryableDataSourceEditData BuildUpdateObjects(IDictionary keys, IDictionary values, IDictionary oldValues, IDictionary <string, Exception> validationErrors)
{
QueryableDataSourceEditData editData = new QueryableDataSourceEditData();
Type dataObjectType = EntityType;
IDictionary caseInsensitiveNewValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary caseInsensitiveOldValues = new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
IDictionary originalValues = GetOriginalValues(keys);
// We start out with the old values, just to pre-populate the list with items
// that might not have corresponding new values. For example if a GridView has
// a read-only field, there will be an old value, but no new value. The data object
// still has to have *some* value for a given field, so we just use the old value.
ParameterCollection updateParameters = UpdateParameters;
// If we have validation errors bail out while merging bailout
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
oldValues,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors))
{
return(editData);
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
keys,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors))
{
return(editData);
}
if (originalValues != null)
{
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
originalValues,
caseInsensitiveOldValues,
caseInsensitiveNewValues,
validationErrors))
{
return(editData);
}
}
if (!DataSourceHelper.MergeDictionaries(dataObjectType,
updateParameters,
values,
caseInsensitiveNewValues,
validationErrors))
{
return(editData);
}
editData.NewDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveNewValues, validationErrors);
if (editData.NewDataObject != null)
{
editData.OriginalDataObject = DataSourceHelper.BuildDataObject(dataObjectType, caseInsensitiveOldValues, validationErrors);
}
return(editData);
}
/// <include file='doc\ListControl.uex' path='docs/doc[@for="ListControl.OnDataBinding"]/*' />
/// <internalonly/>
/// <devdoc>
/// </devdoc>
protected override void OnDataBinding(EventArgs e)
{
base.OnDataBinding(e);
// create items using the datasource
IEnumerable dataSource = DataSourceHelper.GetResolvedDataSource(this.DataSource, this.DataMember);
if (dataSource != null)
{
bool fieldsSpecified = false;
bool formatSpecified = false;
string textField = DataTextField;
string valueField = DataValueField;
string textFormat = DataTextFormatString;
Items.Clear();
ICollection collection = dataSource as ICollection;
if (collection != null)
{
Items.Capacity = collection.Count;
}
if ((textField.Length != 0) || (valueField.Length != 0))
{
fieldsSpecified = true;
}
if (textFormat.Length != 0)
{
formatSpecified = true;
}
foreach (object dataItem in dataSource)
{
ListItem item = new ListItem();
if (fieldsSpecified)
{
if (textField.Length > 0)
{
item.Text = DataBinder.GetPropertyValue(dataItem, textField, textFormat);
}
if (valueField.Length > 0)
{
item.Value = DataBinder.GetPropertyValue(dataItem, valueField, null);
}
}
else
{
if (formatSpecified)
{
item.Text = String.Format(textFormat, dataItem);
}
else
{
item.Text = dataItem.ToString();
}
item.Value = dataItem.ToString();
}
Items.Add(item);
}
}
// try to apply the cached SelectedIndex and SelectedValue now
if (cachedSelectedValue != null)
{
int cachedSelectedValueIndex = -1;
cachedSelectedValueIndex = Items.FindByValueInternal(cachedSelectedValue);
if (-1 == cachedSelectedValueIndex)
{
throw new ArgumentOutOfRangeException("value");
}
if ((cachedSelectedIndex != -1) && (cachedSelectedIndex != cachedSelectedValueIndex))
{
throw new ArgumentException(HttpRuntime.FormatResourceString(SR.Attributes_mutually_exclusive, "SelectedIndex", "SelectedValue"));
}
SelectedIndex = cachedSelectedValueIndex;
cachedSelectedValue = null;
cachedSelectedIndex = -1;
}
else
{
if (cachedSelectedIndex != -1)
{
SelectedIndex = cachedSelectedIndex;
cachedSelectedIndex = -1;
}
}
}
/// <include file='doc\Repeater.uex' path='docs/doc[@for="Repeater.CreateControlHierarchy"]/*' />
/// <devdoc>
/// A protected method. Creates a control
/// hierarchy, with or without the data source as specified.
/// </devdoc>
protected virtual void CreateControlHierarchy(bool useDataSource)
{
IEnumerable dataSource = null;
int count = -1;
if (itemsArray != null)
{
itemsArray.Clear();
}
else
{
itemsArray = new ArrayList();
}
if (useDataSource == false)
{
// ViewState must have a non-null value for ItemCount because we check for
// this in CreateChildControls
count = (int)ViewState[ItemCountViewStateKey];
if (count != -1)
{
dataSource = new DummyDataSource(count);
itemsArray.Capacity = count;
}
}
else
{
dataSource = DataSourceHelper.GetResolvedDataSource(this.DataSource, this.DataMember);
ICollection collection = dataSource as ICollection;
if (collection != null)
{
itemsArray.Capacity = collection.Count;
}
}
if (dataSource != null)
{
ControlCollection controls = Controls;
RepeaterItem item;
ListItemType itemType;
int index = 0;
bool hasSeparators = (separatorTemplate != null);
count = 0;
if (headerTemplate != null)
{
CreateItem(-1, ListItemType.Header, useDataSource, null);
}
foreach (object dataItem in dataSource)
{
// rather than creating separators after the item, we create the separator
// for the previous item in all iterations of this loop.
// this is so that we don't create a separator for the last item
if (hasSeparators && (count > 0))
{
CreateItem(index - 1, ListItemType.Separator, useDataSource, null);
}
itemType = (index % 2 == 0) ? ListItemType.Item : ListItemType.AlternatingItem;
item = CreateItem(index, itemType, useDataSource, dataItem);
itemsArray.Add(item);
count++;
index++;
}
if (footerTemplate != null)
{
CreateItem(-1, ListItemType.Footer, useDataSource, null);
}
}
if (useDataSource)
{
// save the number of items contained in the repeater for use in round-trips
ViewState[ItemCountViewStateKey] = ((dataSource != null) ? count : -1);
}
}
