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
281 lines
12 KiB
C#
281 lines
12 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="DataTableExtenstions.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.Generic;
|
|
using System.Linq;
|
|
using System.Xml;
|
|
using System.Linq.Expressions;
|
|
using System.Globalization;
|
|
using System.Diagnostics;
|
|
using System.Data.DataSetExtensions;
|
|
|
|
namespace System.Data
|
|
{
|
|
|
|
/// <summary>
|
|
/// This static class defines the DataTable extension methods.
|
|
/// </summary>
|
|
public static class DataTableExtensions
|
|
{
|
|
|
|
/// <summary>
|
|
/// This method returns a IEnumerable of Datarows.
|
|
/// </summary>
|
|
/// <param name="source">
|
|
/// The source DataTable to make enumerable.
|
|
/// </param>
|
|
/// <returns>
|
|
/// IEnumerable of datarows.
|
|
/// </returns>
|
|
public static EnumerableRowCollection<DataRow> AsEnumerable(this DataTable source)
|
|
{
|
|
DataSetUtil.CheckArgumentNull(source, "source");
|
|
return new EnumerableRowCollection<DataRow>(source);
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method takes an input sequence of DataRows and produces a DataTable object
|
|
/// with copies of the source rows.
|
|
/// Also note that this will cause the rest of the query to execute at this point in time
|
|
/// (e.g. there is no more delayed execution after this sequence operator).
|
|
/// </summary>
|
|
/// <param name="source">
|
|
/// The input sequence of DataRows
|
|
/// </param>
|
|
/// <returns>
|
|
/// DataTable containing copies of the source DataRows.
|
|
/// Properties for the DataTable table will be taken from first DataRow in the source.
|
|
/// </returns>
|
|
/// <exception cref="ArgumentNullException">if source is null</exception>
|
|
/// <exception cref="InvalidOperationException">if source is empty</exception>
|
|
public static DataTable CopyToDataTable<T>(this IEnumerable<T> source)
|
|
where T : DataRow
|
|
{
|
|
DataSetUtil.CheckArgumentNull(source, "source");
|
|
return LoadTableFromEnumerable(source, null, null, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// delegates to other CopyToDataTable overload with a null FillErrorEventHandler.
|
|
/// </summary>
|
|
public static void CopyToDataTable<T>(this IEnumerable<T> source, DataTable table, LoadOption options)
|
|
where T : DataRow
|
|
{
|
|
DataSetUtil.CheckArgumentNull(source, "source");
|
|
DataSetUtil.CheckArgumentNull(table, "table");
|
|
LoadTableFromEnumerable(source, table, options, null);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// This method takes an input sequence of DataRows and produces a DataTable object
|
|
/// with copies of the source rows.
|
|
/// Also note that this will cause the rest of the query to execute at this point in time
|
|
/// (e.g. there is no more delayed execution after this sequence operator).
|
|
/// </summary>
|
|
/// <param name="source">
|
|
/// The input sequence of DataRows
|
|
///
|
|
/// CopyToDataTable uses DataRowVersion.Default when retrieving values from source DataRow
|
|
/// which will include proposed values for DataRow being edited.
|
|
///
|
|
/// Null DataRow in the sequence are skipped.
|
|
/// </param>
|
|
/// <param name="table">
|
|
/// The target DataTable to load.
|
|
/// </param>
|
|
/// <param name="options">
|
|
/// The target DataTable to load.
|
|
/// </param>
|
|
/// <param name="errorHandler">
|
|
/// Error handler for recoverable errors.
|
|
/// Recoverable errors include:
|
|
/// A source DataRow is in the deleted or detached state state.
|
|
/// DataTable.LoadDataRow threw an exception, i.e. wrong # of columns in source row
|
|
/// Unrecoverable errors include:
|
|
/// exceptions from IEnumerator, DataTable.BeginLoadData or DataTable.EndLoadData
|
|
/// </param>
|
|
/// <returns>
|
|
/// DataTable containing copies of the source DataRows.
|
|
/// </returns>
|
|
/// <exception cref="ArgumentNullException">if source is null</exception>
|
|
/// <exception cref="ArgumentNullException">if table is null</exception>
|
|
/// <exception cref="InvalidOperationException">if source DataRow is in Deleted or Detached state</exception>
|
|
public static void CopyToDataTable<T>(this IEnumerable<T> source, DataTable table, LoadOption options, FillErrorEventHandler errorHandler)
|
|
where T : DataRow
|
|
{
|
|
DataSetUtil.CheckArgumentNull(source, "source");
|
|
DataSetUtil.CheckArgumentNull(table, "table");
|
|
LoadTableFromEnumerable(source, table, options, errorHandler);
|
|
}
|
|
|
|
private static DataTable LoadTableFromEnumerable<T>(IEnumerable<T> source, DataTable table, LoadOption? options, FillErrorEventHandler errorHandler)
|
|
where T : DataRow
|
|
{
|
|
if (options.HasValue) {
|
|
switch(options.Value) {
|
|
case LoadOption.OverwriteChanges:
|
|
case LoadOption.PreserveChanges:
|
|
case LoadOption.Upsert:
|
|
break;
|
|
default:
|
|
throw DataSetUtil.InvalidLoadOption(options.Value);
|
|
}
|
|
}
|
|
|
|
|
|
using (IEnumerator<T> rows = source.GetEnumerator())
|
|
{
|
|
// need to get first row to create table
|
|
if (!rows.MoveNext())
|
|
{
|
|
if (table == null)
|
|
{
|
|
throw DataSetUtil.InvalidOperation(Strings.DataSetLinq_EmptyDataRowSource);
|
|
}
|
|
else
|
|
{
|
|
return table;
|
|
}
|
|
}
|
|
|
|
DataRow current;
|
|
if (table == null)
|
|
{
|
|
current = rows.Current;
|
|
if (current == null)
|
|
{
|
|
throw DataSetUtil.InvalidOperation(Strings.DataSetLinq_NullDataRow);
|
|
}
|
|
|
|
table = new DataTable();
|
|
table.Locale = CultureInfo.CurrentCulture;
|
|
// We do not copy the same properties that DataView.ToTable does.
|
|
// If user needs that functionality, use other CopyToDataTable overloads.
|
|
// The reasoning being, the IEnumerator<DataRow> can be sourced from
|
|
// different DataTable, so we just use the "Default" instead of resolving the difference.
|
|
|
|
foreach (DataColumn column in current.Table.Columns)
|
|
{
|
|
table.Columns.Add(column.ColumnName, column.DataType);
|
|
}
|
|
}
|
|
|
|
table.BeginLoadData();
|
|
try
|
|
{
|
|
do
|
|
{
|
|
current = rows.Current;
|
|
if (current == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
object[] values = null;
|
|
try
|
|
{ // 'recoverable' error block
|
|
switch(current.RowState)
|
|
{
|
|
case DataRowState.Detached:
|
|
if (!current.HasVersion(DataRowVersion.Proposed))
|
|
{
|
|
throw DataSetUtil.InvalidOperation(Strings.DataSetLinq_CannotLoadDetachedRow);
|
|
}
|
|
goto case DataRowState.Added;
|
|
case DataRowState.Unchanged:
|
|
case DataRowState.Added:
|
|
case DataRowState.Modified:
|
|
values = current.ItemArray;
|
|
if (options.HasValue)
|
|
{
|
|
table.LoadDataRow(values, options.Value);
|
|
}
|
|
else
|
|
{
|
|
table.LoadDataRow(values, true);
|
|
}
|
|
break;
|
|
case DataRowState.Deleted:
|
|
throw DataSetUtil.InvalidOperation(Strings.DataSetLinq_CannotLoadDeletedRow);
|
|
default:
|
|
throw DataSetUtil.InvalidDataRowState(current.RowState);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (!DataSetUtil.IsCatchableExceptionType(e))
|
|
{
|
|
throw;
|
|
}
|
|
|
|
FillErrorEventArgs fillError = null;
|
|
if (null != errorHandler)
|
|
{
|
|
fillError = new FillErrorEventArgs(table, values);
|
|
fillError.Errors = e;
|
|
errorHandler.Invoke(rows, fillError);
|
|
}
|
|
if (null == fillError) {
|
|
throw;
|
|
}
|
|
else if (!fillError.Continue)
|
|
{
|
|
if (Object.ReferenceEquals(fillError.Errors ?? e, e))
|
|
{ // if user didn't change exception to throw (or set it to null)
|
|
throw;
|
|
}
|
|
else
|
|
{ // user may have changed exception to throw in handler
|
|
throw fillError.Errors;
|
|
}
|
|
}
|
|
}
|
|
} while (rows.MoveNext());
|
|
}
|
|
finally
|
|
{
|
|
table.EndLoadData();
|
|
}
|
|
}
|
|
Debug.Assert(null != table, "null DataTable");
|
|
return table;
|
|
}
|
|
|
|
#region Methods to Create LinqDataView
|
|
|
|
/// <summary>
|
|
/// Creates a LinkDataView of DataRow over the input table.
|
|
/// </summary>
|
|
/// <param name="table">DataTable that the view is over.</param>
|
|
/// <returns>An instance of LinkDataView.</returns>
|
|
public static DataView AsDataView(this DataTable table)
|
|
{
|
|
DataSetUtil.CheckArgumentNull<DataTable>(table, "table");
|
|
return new LinqDataView(table, null);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Creates a LinqDataView from EnumerableDataTable
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of the row in the table. Must inherit from DataRow</typeparam>
|
|
/// <param name="source">The enumerable-datatable over which view must be created.</param>
|
|
/// <returns>Generated LinkDataView of type T</returns>
|
|
public static DataView AsDataView<T>(this EnumerableRowCollection<T> source) where T : DataRow
|
|
{
|
|
DataSetUtil.CheckArgumentNull<EnumerableRowCollection<T>>(source, "source");
|
|
return source.GetLinqDataView();
|
|
}
|
|
|
|
#endregion LinqDataView
|
|
|
|
}
|
|
}
|