mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
472 lines
11 KiB
C#
472 lines
11 KiB
C#
//
|
|
// System.Data.DataTableCollection.cs
|
|
//
|
|
// Authors:
|
|
// Christopher Podurgiel ([email protected])
|
|
// Tim Coleman <[email protected]>
|
|
//
|
|
// (C) Chris Podurgiel
|
|
// (C) Copyright 2002 Tim Coleman
|
|
//
|
|
|
|
//
|
|
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Globalization;
|
|
|
|
namespace System.Data {
|
|
/// <summary>
|
|
/// Represents the collection of tables for the DataSet.
|
|
/// </summary>
|
|
[Editor ("Microsoft.VSDesigner.Data.Design.TablesCollectionEditor, " + Consts.AssemblyMicrosoft_VSDesigner,
|
|
"System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
|
|
[DefaultEvent ("CollectionChanged")]
|
|
[ListBindable (false)]
|
|
#if !NET_2_0
|
|
[Serializable]
|
|
#endif
|
|
public
|
|
#if NET_2_0
|
|
sealed
|
|
#endif
|
|
class DataTableCollection : InternalDataCollectionBase
|
|
{
|
|
DataSet dataSet;
|
|
DataTable[] mostRecentTables;
|
|
#region Constructors
|
|
|
|
internal DataTableCollection (DataSet dataSet)
|
|
: base ()
|
|
{
|
|
this.dataSet = dataSet;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Properties
|
|
|
|
public DataTable this[int index] {
|
|
get {
|
|
if (index < 0 || index >= List.Count)
|
|
throw new IndexOutOfRangeException(String.Format("Cannot find table {0}", index));
|
|
return (DataTable)(List[index]);
|
|
}
|
|
}
|
|
|
|
public DataTable this[string name] {
|
|
get {
|
|
int index = IndexOf (name, true);
|
|
return index < 0 ? null : (DataTable) List[index];
|
|
}
|
|
}
|
|
|
|
#if NET_2_0
|
|
public DataTable this [string name, string tbNamespace] {
|
|
get {
|
|
int index = IndexOf (name, tbNamespace, true);
|
|
return index < 0 ? null : (DataTable) List[index];
|
|
}
|
|
}
|
|
#endif
|
|
|
|
protected override ArrayList List {
|
|
get { return base.List; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
public
|
|
#if !NET_2_0
|
|
virtual
|
|
#endif
|
|
DataTable Add ()
|
|
{
|
|
DataTable Table = new DataTable ();
|
|
Add (Table);
|
|
return Table;
|
|
}
|
|
|
|
public
|
|
#if !NET_2_0
|
|
virtual
|
|
#endif
|
|
void Add (DataTable table)
|
|
{
|
|
OnCollectionChanging (new CollectionChangeEventArgs (CollectionChangeAction.Add, table));
|
|
// check if the reference is a null reference
|
|
if(table == null)
|
|
throw new ArgumentNullException("table");
|
|
|
|
// check if the list already contains this tabe.
|
|
if(List.Contains(table))
|
|
throw new ArgumentException("DataTable already belongs to this DataSet.");
|
|
|
|
// check if table is part of another DataSet
|
|
if (table.DataSet != null && table.DataSet != this.dataSet)
|
|
throw new ArgumentException ("DataTable already belongs to another DataSet");
|
|
|
|
// if the table name is null or empty string.
|
|
// give her a name.
|
|
if (table.TableName == null || table.TableName == string.Empty)
|
|
NameTable (table);
|
|
|
|
// check if the collection has a table with the same name.
|
|
#if !NET_2_0
|
|
int tmp = IndexOf (table.TableName);
|
|
#else
|
|
int tmp = IndexOf (table.TableName, table.Namespace);
|
|
#endif
|
|
// if we found a table with same name we have to check
|
|
// that it is the same case.
|
|
// indexof can return a table with different case letters.
|
|
if (tmp != -1)
|
|
{
|
|
if(table.TableName == this[tmp].TableName)
|
|
throw new DuplicateNameException("A DataTable named '" + table.TableName + "' already belongs to this DataSet.");
|
|
}
|
|
|
|
List.Add (table);
|
|
table.dataSet = dataSet;
|
|
OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Add, table));
|
|
}
|
|
|
|
public
|
|
#if !NET_2_0
|
|
virtual
|
|
#endif
|
|
DataTable Add (string name)
|
|
{
|
|
DataTable table = new DataTable (name);
|
|
this.Add (table);
|
|
return table;
|
|
}
|
|
|
|
#if NET_2_0
|
|
public DataTable Add (string name, string tbNamespace)
|
|
{
|
|
DataTable table = new DataTable (name, tbNamespace);
|
|
this.Add (table);
|
|
return table;
|
|
}
|
|
#endif
|
|
|
|
public void AddRange (DataTable[] tables)
|
|
{
|
|
if (dataSet != null && dataSet.InitInProgress) {
|
|
mostRecentTables = tables;
|
|
return;
|
|
}
|
|
|
|
if (tables == null)
|
|
return;
|
|
|
|
foreach (DataTable table in tables) {
|
|
if (table == null)
|
|
continue;
|
|
Add (table);
|
|
}
|
|
}
|
|
|
|
internal void PostAddRange ()
|
|
{
|
|
if (mostRecentTables == null)
|
|
return;
|
|
|
|
foreach (DataTable table in mostRecentTables){
|
|
if (table == null)
|
|
continue;
|
|
Add (table);
|
|
}
|
|
mostRecentTables = null;
|
|
}
|
|
|
|
public bool CanRemove (DataTable table)
|
|
{
|
|
return CanRemove(table, false);
|
|
}
|
|
|
|
public void Clear ()
|
|
{
|
|
List.Clear ();
|
|
}
|
|
|
|
public bool Contains (string name)
|
|
{
|
|
return (-1 != IndexOf (name, false));
|
|
}
|
|
|
|
#if NET_2_0
|
|
public bool Contains (string name, string tableNamespace)
|
|
{
|
|
return (IndexOf (name, tableNamespace) != -1) ;
|
|
}
|
|
#endif
|
|
|
|
public void CopyTo (DataTable [] array, int index)
|
|
{
|
|
CopyTo ((Array) array, index);
|
|
}
|
|
|
|
public
|
|
#if !NET_2_0
|
|
virtual
|
|
#endif
|
|
int IndexOf (DataTable table)
|
|
{
|
|
return List.IndexOf (table);
|
|
}
|
|
|
|
public
|
|
#if !NET_2_0
|
|
virtual
|
|
#endif
|
|
int IndexOf (string name)
|
|
{
|
|
return IndexOf (name, false);
|
|
}
|
|
|
|
#if NET_2_0
|
|
public int IndexOf (string name, string tableNamespace)
|
|
{
|
|
if (tableNamespace == null)
|
|
throw new ArgumentNullException ("'tableNamespace' argument cannot be null.",
|
|
"tableNamespace");
|
|
return IndexOf (name, tableNamespace, false);
|
|
}
|
|
#endif
|
|
|
|
public void Remove (DataTable table)
|
|
{
|
|
OnCollectionChanging (new CollectionChangeEventArgs (CollectionChangeAction.Remove, table));
|
|
if (CanRemove(table, true))
|
|
table.dataSet = null;
|
|
|
|
List.Remove(table);
|
|
table.dataSet = null;
|
|
OnCollectionChanged (new CollectionChangeEventArgs (CollectionChangeAction.Remove, table));
|
|
}
|
|
|
|
public void Remove (string name)
|
|
{
|
|
int index = IndexOf (name, false);
|
|
if (index == -1)
|
|
throw new ArgumentException ("Table " + name + " does not belong to this DataSet");
|
|
RemoveAt (index);
|
|
}
|
|
|
|
#if NET_2_0
|
|
public void Remove (string name, string tableNamespace)
|
|
{
|
|
int index = IndexOf (name, tableNamespace, true);
|
|
if (index == -1)
|
|
throw new ArgumentException ("Table " + name + " does not belong to this DataSet");
|
|
|
|
RemoveAt (index);
|
|
}
|
|
#endif
|
|
|
|
public void RemoveAt (int index)
|
|
{
|
|
Remove(this[index]);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Protected methods
|
|
|
|
|
|
#if !NET_2_0
|
|
protected internal virtual
|
|
#else
|
|
internal
|
|
#endif
|
|
void OnCollectionChanging (CollectionChangeEventArgs Args)
|
|
{
|
|
if (CollectionChanging != null)
|
|
CollectionChanging (this, Args);
|
|
}
|
|
|
|
|
|
#if !NET_2_0
|
|
protected virtual
|
|
#else
|
|
internal
|
|
#endif
|
|
void OnCollectionChanged (CollectionChangeEventArgs Args)
|
|
{
|
|
if (CollectionChanged != null)
|
|
CollectionChanged (this, Args);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Private methods
|
|
#if NET_2_0
|
|
private int IndexOf (string name, string ns, bool error)
|
|
{
|
|
int index = -1, count = 0, match = -1;
|
|
do {
|
|
index = IndexOf (name, error, index+1);
|
|
|
|
if (index == -1)
|
|
break;
|
|
|
|
if (ns == null) {
|
|
if (count > 1)
|
|
break;
|
|
count++;
|
|
match = index;
|
|
} else if (this [index].Namespace.Equals (ns))
|
|
return index;
|
|
|
|
} while (index != -1 && index < Count);
|
|
|
|
if (count == 1)
|
|
return match;
|
|
|
|
if (count == 0 || !error)
|
|
return -1;
|
|
|
|
throw new ArgumentException ("The given name '" + name + "' matches atleast two names" +
|
|
"in the collection object with different namespaces");
|
|
}
|
|
#endif
|
|
|
|
private int IndexOf (string name, bool error)
|
|
{
|
|
#if NET_2_0
|
|
return IndexOf (name, null, error);
|
|
# else
|
|
return IndexOf (name, error, 0);
|
|
#endif
|
|
}
|
|
|
|
private int IndexOf (string name, bool error, int start)
|
|
{
|
|
int count = 0, match = -1;
|
|
for (int i = start; i < List.Count; i++)
|
|
{
|
|
String name2 = ((DataTable) List[i]).TableName;
|
|
if (String.Compare (name, name2, false) == 0)
|
|
return i;
|
|
if (String.Compare (name, name2, true) == 0) {
|
|
match = i;
|
|
count++;
|
|
}
|
|
}
|
|
if (count == 1)
|
|
return match;
|
|
if (count > 1 && error)
|
|
throw new ArgumentException ("There is no match for the name in the same case and there are multiple matches in different case.");
|
|
return -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// gives name to Table (Table1, Table2, Table3,...)
|
|
/// </summary>
|
|
private void NameTable (DataTable Table)
|
|
{
|
|
string Name = "Table";
|
|
int i = 1;
|
|
while (Contains (Name + i))
|
|
i++;
|
|
|
|
Table.TableName = Name + i;
|
|
}
|
|
|
|
// check if a table can be removed from this collectiuon.
|
|
// if the table can not be remved act according to throwException parameter.
|
|
// if it is true throws an Exception, else return false.
|
|
private bool CanRemove(DataTable table, bool throwException)
|
|
{
|
|
|
|
// check if table is null reference
|
|
if (table == null) {
|
|
if(throwException)
|
|
throw new ArgumentNullException("table");
|
|
return false;
|
|
}
|
|
|
|
// check if the table has the same DataSet as this collection.
|
|
if(table.DataSet != this.dataSet) {
|
|
if(!throwException)
|
|
return false;
|
|
throw new ArgumentException("Table " + table.TableName + " does not belong to this DataSet.");
|
|
}
|
|
|
|
// check the table has a relation attached to it.
|
|
if (table.ParentRelations.Count > 0 || table.ChildRelations.Count > 0) {
|
|
if(!throwException)
|
|
return false;
|
|
throw new ArgumentException("Cannot remove a table that has existing relations. Remove relations first.");
|
|
}
|
|
|
|
// now we check if any ForeignKeyConstraint is referncing 'table'.
|
|
foreach (Constraint c in table.Constraints) {
|
|
UniqueConstraint uc = c as UniqueConstraint;
|
|
if (uc != null) {
|
|
if (uc.ChildConstraint == null)
|
|
continue;
|
|
|
|
if (!throwException)
|
|
return false;
|
|
RaiseForeignKeyReferenceException (table.TableName, uc.ChildConstraint.ConstraintName);
|
|
}
|
|
|
|
ForeignKeyConstraint fc = c as ForeignKeyConstraint;
|
|
if (fc == null)
|
|
continue;
|
|
|
|
if (!throwException)
|
|
return false;
|
|
RaiseForeignKeyReferenceException (table.TableName, fc.ConstraintName);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private void RaiseForeignKeyReferenceException (string table, string constraint)
|
|
{
|
|
throw new ArgumentException (String.Format ("Cannot remove table {0}, because it is referenced" +
|
|
" in ForeignKeyConstraint {1}. Remove the constraint first.",
|
|
table, constraint));
|
|
}
|
|
|
|
#endregion // Private methods
|
|
|
|
#region Events
|
|
|
|
[ResDescriptionAttribute ("Occurs whenever this collection's membership changes.")]
|
|
public event CollectionChangeEventHandler CollectionChanged;
|
|
|
|
public event CollectionChangeEventHandler CollectionChanging;
|
|
|
|
#endregion
|
|
}
|
|
}
|