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
306 lines
12 KiB
C#
306 lines
12 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="LinqDataView.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
// <owner current="true" primary="true">[....]</owner>
|
|
// <owner current="true" primary="false">[....]</owner>
|
|
//------------------------------------------------------------------------------
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Diagnostics;
|
|
using System.ComponentModel;
|
|
using System.Data;
|
|
using System.Text;
|
|
using System.Data.DataSetExtensions;
|
|
|
|
namespace System.Data
|
|
{
|
|
/// <summary>
|
|
/// Represents a bindable, queryable DataView of DataRow, that can be created from from LINQ queries over DataTable
|
|
/// and from DataTable.
|
|
/// </summary>
|
|
internal class LinqDataView : DataView, IBindingList, IBindingListView
|
|
{
|
|
/// <summary>
|
|
/// A Comparer that compares a Key and a Row.
|
|
/// </summary>
|
|
internal Func<object, DataRow, int> comparerKeyRow; // comparer for DataView.Find(..
|
|
|
|
/// <summary>
|
|
/// Builds the sort expression in case multiple selector/comparers are added
|
|
/// </summary>
|
|
internal readonly SortExpressionBuilder<DataRow> sortExpressionBuilder;
|
|
|
|
/// <summary>
|
|
/// Constructs a LinkDataView and its parent DataView.
|
|
/// Does not create index on the DataView since filter and sort expressions are not yet provided.
|
|
/// </summary>
|
|
/// <param name="table">The input table from which LinkDataView is to be created.</param>
|
|
internal LinqDataView(DataTable table, SortExpressionBuilder<DataRow> sortExpressionBuilder)
|
|
: base(table)
|
|
{
|
|
Debug.Assert(table != null, "null DataTable");
|
|
this.sortExpressionBuilder = sortExpressionBuilder ?? new SortExpressionBuilder<DataRow>();
|
|
}
|
|
|
|
|
|
//I have two forms of predicate because I need to pass in null if predicate is null. Otherwise I need to convert it into delegate and pass it into
|
|
// data view's constructor. That logic for checking null can't be embedded in the base constructor call.
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="table">Table from which to create the view</param>
|
|
/// <param name="predicate_func">User-provided filter-predicate as a Func<DataRow>, bool>"/></param>
|
|
/// <param name="predicate_system">User-provided predicate but in the form of System.Predicate<DataRow>
|
|
/// Predicates are being replicated in different forms so that nulls can be passed in.
|
|
/// For e.g. when user provides null predicate, base.Predicate should be set to null. I cant do that in the constructor initialization
|
|
/// if I will have to create System.Predicate delegate from Func.
|
|
/// </param>
|
|
/// <param name="comparison">The comparer function of DataRow to be used for sorting. </param>
|
|
/// <param name="comparerKeyRow">A comparer function that compares a Key value to DataRow.</param>
|
|
/// <param name="isDescending">Whether sorting is ascending or descending.</param>
|
|
/// <param name="rowState">Row state filter. For the purpose of LinkDataView it should always be CurrentRows.</param>
|
|
internal LinqDataView(
|
|
DataTable table,
|
|
Func<DataRow, bool> predicate_func,
|
|
Predicate<DataRow> predicate_system,
|
|
Comparison<DataRow> comparison,
|
|
Func<object, DataRow, int> comparerKeyRow,
|
|
SortExpressionBuilder<DataRow> sortExpressionBuilder)
|
|
|
|
//Parent constructor
|
|
: base(table,
|
|
predicate_system,
|
|
comparison,
|
|
DataViewRowState.CurrentRows)
|
|
{
|
|
this.sortExpressionBuilder = (sortExpressionBuilder == null) ? this.sortExpressionBuilder : sortExpressionBuilder;
|
|
this.comparerKeyRow = comparerKeyRow;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the expression used to filter which rows are viewed in the LinqDataView
|
|
/// </summary>
|
|
public override string RowFilter
|
|
{
|
|
get
|
|
{
|
|
if (base.RowPredicate == null)//using string based filter or no filter
|
|
{
|
|
return base.RowFilter;
|
|
}
|
|
else //using expression based filter
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
base.RowPredicate = null;
|
|
base.RowFilter = String.Empty; //INDEX rebuild twice
|
|
}
|
|
else
|
|
{
|
|
base.RowFilter = value;
|
|
base.RowPredicate = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Find
|
|
|
|
/// <summary>
|
|
/// Searches the index and finds a single row where the sort-key matches the input key
|
|
/// </summary>
|
|
/// <param name="key">Value of the key to find</param>
|
|
/// <returns>Index of the first match of input key</returns>
|
|
internal override int FindByKey(object key)
|
|
{
|
|
/////////////// Preconditions ////////////////
|
|
//check that both string and expression based sort are never simultaneously set
|
|
Debug.Assert(base.Sort != null);
|
|
Debug.Assert(!(!String.IsNullOrEmpty(base.Sort) && base.SortComparison != null));
|
|
/////////////////////////////////////////////
|
|
|
|
if (!String.IsNullOrEmpty(base.Sort)) //use find for DV's sort string
|
|
{
|
|
return base.FindByKey(key);
|
|
}
|
|
else if (base.SortComparison == null) //neither string or expr set
|
|
{
|
|
//This is the exception message from DataView that we want to use
|
|
throw ExceptionBuilder.IndexKeyLength(0, 0);
|
|
}
|
|
else //find for expression based sort
|
|
{
|
|
if (sortExpressionBuilder.Count !=1)
|
|
throw DataSetUtil.InvalidOperation(Strings.LDV_InvalidNumOfKeys(sortExpressionBuilder.Count));
|
|
|
|
Index.ComparisonBySelector<object, DataRow> compareDelg =
|
|
new Index.ComparisonBySelector<object, DataRow>(comparerKeyRow);
|
|
|
|
List<object> keyList = new List<object>();
|
|
keyList.Add(key);
|
|
Range range = FindRecords<object, DataRow>(compareDelg, keyList);
|
|
|
|
return (range.Count == 0) ? -1 : range.Min;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Since LinkDataView does not support multiple selectors/comparers, it does not make sense for
|
|
/// them to Find using multiple keys.
|
|
/// This overriden method prevents users calling multi-key find on dataview.
|
|
/// </summary>
|
|
internal override int FindByKey(object[] key)
|
|
{
|
|
//---------Checks ----------------
|
|
//must have string or expression based sort specified
|
|
if (base.SortComparison == null && String.IsNullOrEmpty(base.Sort))
|
|
{
|
|
//This is the exception message from DataView that we want to use
|
|
throw ExceptionBuilder.IndexKeyLength(0, 0);
|
|
}
|
|
else if (base.SortComparison != null && key.Length != sortExpressionBuilder.Count)
|
|
{
|
|
throw DataSetUtil.InvalidOperation(Strings.LDV_InvalidNumOfKeys(sortExpressionBuilder.Count));
|
|
}
|
|
//--------------------------------
|
|
|
|
if (base.SortComparison == null)//using string to sort
|
|
return base.FindByKey(key);
|
|
else
|
|
{
|
|
Index.ComparisonBySelector<object, DataRow> compareDelg =
|
|
new Index.ComparisonBySelector<object, DataRow>(comparerKeyRow);
|
|
|
|
List<object> keyList = new List<object>();
|
|
foreach (object singleKey in key)
|
|
{
|
|
keyList.Add(singleKey);
|
|
}
|
|
Range range = FindRecords<object, DataRow>(compareDelg, keyList);
|
|
return (range.Count == 0) ? -1 : range.Min;
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Searches the index and finds rows where the sort-key matches the input key.
|
|
/// Since LinkDataView does not support multiple selectors/comparers, it does not make sense for
|
|
/// them to Find using multiple keys. This overriden method prevents users calling multi-key find on dataview.
|
|
/// </summary>
|
|
internal override DataRowView[] FindRowsByKey(object[] key)
|
|
{
|
|
//---------Checks ----------------
|
|
//must have string or expression based sort specified
|
|
if (base.SortComparison == null && String.IsNullOrEmpty(base.Sort))
|
|
{
|
|
//This is the exception message from DataView that we want to use
|
|
throw ExceptionBuilder.IndexKeyLength(0, 0);
|
|
}
|
|
else if (base.SortComparison != null && key.Length != sortExpressionBuilder.Count)
|
|
{
|
|
throw DataSetUtil.InvalidOperation(Strings.LDV_InvalidNumOfKeys(sortExpressionBuilder.Count));
|
|
}
|
|
//--------------------------------
|
|
|
|
if (base.SortComparison == null)//using string to sort
|
|
{
|
|
return base.FindRowsByKey(key);
|
|
}
|
|
else
|
|
{
|
|
Range range = FindRecords<object, DataRow>(
|
|
new Index.ComparisonBySelector<object, DataRow>(comparerKeyRow),
|
|
new List<object>(key));
|
|
return base.GetDataRowViewFromRange(range);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region Misc Overrides
|
|
/// <summary>
|
|
/// Overriding DataView's SetIndex to prevent users from setting RowState filter to anything other
|
|
/// than CurrentRows.
|
|
/// </summary>
|
|
internal override void SetIndex(string newSort, DataViewRowState newRowStates, IFilter newRowFilter)
|
|
{
|
|
//Throw only if expressions (filter or sort) are used and rowstate is not current rows
|
|
if ( (base.SortComparison != null || base.RowPredicate != null)
|
|
&& newRowStates != DataViewRowState.CurrentRows)
|
|
{
|
|
throw DataSetUtil.Argument(Strings.LDVRowStateError);
|
|
}
|
|
else
|
|
{
|
|
base.SetIndex(newSort, newRowStates, newRowFilter);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region IBindingList
|
|
|
|
/// <summary>
|
|
/// Clears both expression-based and DataView's string-based sorting.
|
|
/// </summary>
|
|
void IBindingList.RemoveSort()
|
|
{
|
|
base.Sort = String.Empty;
|
|
base.SortComparison = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overrides IBindingList's SortProperty so that it returns null if expression based sort
|
|
/// is used in the LinkDataView, otherwise it defers the result to DataView
|
|
/// </summary>
|
|
PropertyDescriptor IBindingList.SortProperty
|
|
{
|
|
get
|
|
{
|
|
return (base.SortComparison == null) ? base.GetSortProperty() : null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Overrides IBindingList's SortDescriptions so that it returns null if expression based sort
|
|
/// is used in the LinkDataView, otherwise it defers the result to DataView
|
|
/// </summary>
|
|
ListSortDescriptionCollection IBindingListView.SortDescriptions
|
|
{
|
|
get
|
|
{
|
|
if (base.SortComparison == null)
|
|
{
|
|
return base.GetSortDescriptions();
|
|
}
|
|
else
|
|
{
|
|
return new ListSortDescriptionCollection();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tells whether the LinqDataView is sorted or not
|
|
/// </summary>
|
|
bool IBindingList.IsSorted
|
|
{
|
|
get
|
|
{ //Sorted if either expression based sort or string based sort is set
|
|
return !(base.SortComparison == null && base.Sort.Length == 0);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|