ConstraintCollection Třída

Definice

Představuje kolekci omezení pro DataTable.Represents a collection of constraints for a DataTable.

public ref class ConstraintCollection sealed : System::Data::InternalDataCollectionBase
public sealed class ConstraintCollection : System.Data.InternalDataCollectionBase
[System.Serializable]
public sealed class ConstraintCollection : System.Data.InternalDataCollectionBase
type ConstraintCollection = class
    inherit InternalDataCollectionBase
Public NotInheritable Class ConstraintCollection
Inherits InternalDataCollectionBase
Dědičnost
ConstraintCollection
Atributy

Příklady

První příklad vytvoří DataTablea přidá DataColumn (s vlastností Unique nastavenou na true) do DataColumnCollection.The first example creates a DataTable, and adds a DataColumn (with its Unique property set to true) to the DataColumnCollection. Druhý příklad vytvoří DataSet, dva objekty DataTable, čtyři sloupce a DataRelation.The second example creates a DataSet, two DataTable objects, four columns, and a DataRelation. Počet omezení se pak vytiskne tak, aby se vytvořily ForeignKeyConstraint a UniqueConstraint, když se do DataRelationCollectioného objektu DataSet přidá DataRelation.The count of constraints is then printed to show that a ForeignKeyConstraint and a UniqueConstraint are created when a DataRelation is added to the DataSet object's DataRelationCollection.

   private void MakeTableWithUniqueConstraint()
   {
       DataTable table = new DataTable("table");
       DataColumn column = new DataColumn("UniqueColumn");
       column.Unique=true;
       table.Columns.Add(column);

       // Print count, name, and type.
       Console.WriteLine("Constraints.Count " 
           + table.Constraints.Count);
       Console.WriteLine(table.Constraints[0].ConstraintName);
       Console.WriteLine(table.Constraints[0].GetType() );

       // Add a second unique column.
       column = new DataColumn("UniqueColumn2");
       column.Unique=true;
       table.Columns.Add(column);

       // Print info again.
       Console.WriteLine("Constraints.Count " 
           + table.Constraints.Count);
       Console.WriteLine(table.Constraints[1].ConstraintName);
       Console.WriteLine(table.Constraints[1].GetType() );
   }
    
   private void MakeTableWithForeignConstraint()
   {
       // Create a DataSet.
       DataSet dataSet = new DataSet("dataSet");

       // Make two tables.
       DataTable customersTable= new DataTable("Customers");
       DataTable ordersTable = new DataTable("Orders");

       // Create four columns, two for each table.
       DataColumn name = new DataColumn("Name");
       DataColumn id = new DataColumn("ID");
       DataColumn orderId = new DataColumn("OrderID");
       DataColumn cDate = new DataColumn("OrderDate");

       // Add columns to tables.
       customersTable.Columns.Add(name);
       customersTable.Columns.Add(id);
       ordersTable.Columns.Add(orderId);
       ordersTable.Columns.Add(cDate);

       // Add tables to the DataSet.
       dataSet.Tables.Add(customersTable);
       dataSet.Tables.Add(ordersTable); 

       // Create a DataRelation for two of the columns.
       DataRelation myRelation = new 
           DataRelation("CustomersOrders",id,orderId,true);
       dataSet.Relations.Add(myRelation);

       // Print TableName, Constraints.Count, 
       // ConstraintName and Type.
       foreach(DataTable t in dataSet.Tables)
       {
           Console.WriteLine(t.TableName);
           Console.WriteLine("Constraints.Count " 
               + t.Constraints.Count);
           Console.WriteLine("ParentRelations.Count " 
               + t.ParentRelations.Count);
           Console.WriteLine("ChildRelations.Count " 
               + t.ChildRelations.Count);
           foreach(Constraint cstrnt in t.Constraints)
           {
               Console.WriteLine(cstrnt.ConstraintName);
               Console.WriteLine(cstrnt.GetType());
           }
       }
   }
Private Sub MakeTableWithUniqueConstraint()

    Dim table As New DataTable("table")
    Dim column As New DataColumn("UniqueColumn")
    column.Unique = True
    table.Columns.Add(column)

    ' Print count, name, and type.
    Console.WriteLine("Constraints.Count " _
       + table.Constraints.Count.ToString())
    Console.WriteLine(table.Constraints(0).ConstraintName)
    Console.WriteLine( _
        table.Constraints(0).GetType().ToString())

    ' Add a second unique column.
    column = New DataColumn("UniqueColumn2")
    column.Unique = True
    table.Columns.Add(column)

    ' Print info again.
    Console.WriteLine("Constraints.Count " _
       + table.Constraints.Count.ToString())
    Console.WriteLine(table.Constraints(1).ConstraintName)
    Console.WriteLine( _
        table.Constraints(1).GetType().ToString())
End Sub

Private Sub MakeTableWithForeignConstraint()

    ' Create a DataSet.
    Dim dataSet As New DataSet("dataSet")

    ' Make two tables.
    Dim customersTable As New DataTable("Customers")
    Dim ordersTable As New DataTable("Orders")

    ' Create four columns, two for each table.
    Dim name As New DataColumn("Name")
    Dim id As New DataColumn("ID")
    Dim orderId As New DataColumn("OrderID")
    Dim orderDate As New DataColumn("OrderDate")
    
    ' Add columns to tables.
    customersTable.Columns.Add(name)
    customersTable.Columns.Add(id)
    ordersTable.Columns.Add(orderId)
    ordersTable.Columns.Add(orderDate)
    
    ' Add tables to the DataSet.
    dataSet.Tables.Add(customersTable)
    dataSet.Tables.Add(ordersTable)

    ' Create a DataRelation for two of the columns.
    Dim myRelation As New DataRelation _
       ("CustomersOrders", id, orderId, True)
    dataSet.Relations.Add(myRelation)

    ' Print TableName, Constraints.Count, 
    ' ConstraintName and Type.
    Dim t As DataTable
    For Each t In  dataSet.Tables
        Console.WriteLine(t.TableName)
        Console.WriteLine("Constraints.Count " _
           + t.Constraints.Count.ToString())
        Console.WriteLine("ParentRelations.Count " _
           + t.ParentRelations.Count.ToString())
        Console.WriteLine("ChildRelations.Count " _
           + t.ChildRelations.Count.ToString())
        Dim cstrnt As Constraint
        For Each cstrnt In  t.Constraints
            Console.WriteLine(cstrnt.ConstraintName)
            Console.WriteLine(cstrnt.GetType())
        Next cstrnt
    Next t
End Sub

Poznámky

K ConstraintCollection je k dispozici prostřednictvím vlastnosti DataTable.Constraints.The ConstraintCollection is accessed through the DataTable.Constraints property.

ConstraintCollection může obsahovat objekty UniqueConstraint a ForeignKeyConstraint pro DataTable.The ConstraintCollection can contain both UniqueConstraint and ForeignKeyConstraint objects for the DataTable. Objekt UniqueConstraint zajišťuje, aby data v konkrétním sloupci byla vždycky jedinečná, aby se zajistila integrita dat.A UniqueConstraint object makes sure that data in a specific column is always unique to preserve the data integrity. ForeignKeyConstraint určuje, co se objeví v souvisejících tabulkách, když se data v DataTable aktualizují nebo odstraní.The ForeignKeyConstraint determines what will occur in related tables when data in the DataTable is either updated or deleted. Například pokud je řádek odstraněn, ForeignKeyConstraint určí, zda jsou související řádky odstraněny také (v kaskádě) nebo v jiném postupu.For example, if a row is deleted, the ForeignKeyConstraint will determine whether the related rows are also deleted (a cascade), or some other course of action.

Poznámka

Když přidáte DataRelation, která vytvoří relaci mezi dvěma DataSettabulkami, automaticky se vytvoří ForeignKeyConstraint i UniqueConstraint.When you add a DataRelation that creates a relationship between two tables to a DataSet, both a ForeignKeyConstraint and a UniqueConstraint are created automatically. UniqueConstraint se aplikuje na sloupec primárního klíče v nadřazeném DataTablea omezení se přidá do ConstraintCollectiontéto tabulky.The UniqueConstraint is applied to the primary key column in the parent DataTable, and the constraint is added to that table's ConstraintCollection. ForeignKeyConstraint se použije pro sloupec primárního klíče a sloupec cizího klíče a omezení se přidá do ConstraintCollectionpodřízené tabulky.The ForeignKeyConstraint is applied to the primary key column and the foreign key column, and the constraint is added to the child table's ConstraintCollection.

ConstraintCollection používá standardní metody kolekce jako Add, Cleara Remove.The ConstraintCollection uses standard collection methods such as Add, Clear, and Remove. Kromě toho lze metodu Contains použít k vyhledání existence konkrétního omezení v kolekci.In addition, the Contains method can be used to look for the existence of a particular constraint in the collection.

UniqueConstraint se vytvoří, když se do DataTable DataColumnCollectionobjektu přidá DataColumn s vlastností Unique nastavenou na true.A UniqueConstraint is created when a DataColumn with its Unique property set to true is added to a DataTable object's DataColumnCollection.

ForeignKeyConstraint se vytvoří, když se do DataRelationCollectionDataSet objektu přidá DataRelation.A ForeignKeyConstraint is created when a DataRelation is added to a DataSet object's DataRelationCollection.

Vlastnosti

Count

Získá celkový počet prvků v kolekci.Gets the total number of elements in a collection.

(Zděděno od InternalDataCollectionBase)
IsReadOnly

Získá hodnotu, která označuje, zda je InternalDataCollectionBase jen pro čtení.Gets a value that indicates whether the InternalDataCollectionBase is read-only.

(Zděděno od InternalDataCollectionBase)
IsSynchronized

Získá hodnotu, která označuje, zda je InternalDataCollectionBase synchronizována.Gets a value that indicates whether the InternalDataCollectionBase is synchronized.

(Zděděno od InternalDataCollectionBase)
Item[Int32]

Získá Constraint z kolekce v zadaném indexu.Gets the Constraint from the collection at the specified index.

Item[String]

Získá Constraint z kolekce se zadaným názvem.Gets the Constraint from the collection with the specified name.

List

Načte položky kolekce jako seznam.Gets the items of the collection as a list.

(Zděděno od InternalDataCollectionBase)
SyncRoot

Získá objekt, který lze použít k synchronizaci kolekce.Gets an object that can be used to synchronize the collection.

(Zděděno od InternalDataCollectionBase)

Metody

Add(Constraint)

Přidá zadaný objekt Constraint do kolekce.Adds the specified Constraint object to the collection.

Add(String, DataColumn, Boolean)

Vytvoří novou UniqueConstraint se zadaným názvem, DataColumna hodnotou, která označuje, zda je sloupec primárním klíčem, a přidá jej do kolekce.Constructs a new UniqueConstraint with the specified name, DataColumn, and value that indicates whether the column is a primary key, and adds it to the collection.

Add(String, DataColumn, DataColumn)

Vytvoří nový ForeignKeyConstraint se zadaným názvem, nadřazeným sloupcem a podřízeným sloupcem a přidá omezení do kolekce.Constructs a new ForeignKeyConstraint with the specified name, parent column, and child column, and adds the constraint to the collection.

Add(String, DataColumn[], Boolean)

Vytvoří novou UniqueConstraint se zadaným názvem, polem DataColumn objektů a hodnotou, která označuje, zda je sloupec primárním klíčem, a přidá jej do kolekce.Constructs a new UniqueConstraint with the specified name, array of DataColumn objects, and value that indicates whether the column is a primary key, and adds it to the collection.

Add(String, DataColumn[], DataColumn[])

Vytvoří nový ForeignKeyConstraintse zadanými poli nadřazených sloupců a podřízených sloupců a přidá omezení do kolekce.Constructs a new ForeignKeyConstraint, with the specified arrays of parent columns and child columns, and adds the constraint to the collection.

AddRange(Constraint[])

Zkopíruje prvky zadaného pole ConstraintCollection na konec kolekce.Copies the elements of the specified ConstraintCollection array to the end of the collection.

CanRemove(Constraint)

Určuje, zda lze odebrat Constraint.Indicates whether a Constraint can be removed.

Clear()

Vymaže kolekci libovolných Constraint objektů.Clears the collection of any Constraint objects.

Contains(String)

Uvádí, zda Constraint objekt určený názvem v kolekci existuje.Indicates whether the Constraint object specified by name exists in the collection.

CopyTo(Array, Int32)

Zkopíruje všechny prvky aktuálního InternalDataCollectionBase k jednorozměrnému Arraypočínaje zadaným indexem InternalDataCollectionBase.Copies all the elements of the current InternalDataCollectionBase to a one-dimensional Array, starting at the specified InternalDataCollectionBase index.

(Zděděno od InternalDataCollectionBase)
CopyTo(Constraint[], Int32)

Zkopíruje objekty kolekce do jednorozměrné instance Array počínaje zadaným indexem.Copies the collection objects to a one-dimensional Array instance starting at the specified index.

Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetEnumerator()

Získá IEnumerator pro kolekci.Gets an IEnumerator for the collection.

(Zděděno od InternalDataCollectionBase)
GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Zděděno od Object)
IndexOf(Constraint)

Získá index určeného Constraint.Gets the index of the specified Constraint.

IndexOf(String)

Získá index Constraint určený podle názvu.Gets the index of the Constraint specified by name.

MemberwiseClone()

Vytvoří kopii aktuálního Objectbez podstruktury.Creates a shallow copy of the current Object.

(Zděděno od Object)
Remove(Constraint)

Odstraní zadaný Constraint z kolekce.Removes the specified Constraint from the collection.

Remove(String)

Odebere objekt Constraint určený názvem z kolekce.Removes the Constraint object specified by name from the collection.

RemoveAt(Int32)

Odebere objekt Constraint v zadaném indexu z kolekce.Removes the Constraint object at the specified index from the collection.

ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Události

CollectionChanged

Vyvolá se vždy, když se změní ConstraintCollection, protože se přidávají nebo odebírají objekty Constraint.Occurs whenever the ConstraintCollection is changed because of Constraint objects being added or removed.

Metody rozšíření

Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable na zadaný typ.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsQueryable(IEnumerable)

Převede IEnumerable na IQueryable.Converts an IEnumerable to an IQueryable.

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro operace čtení ve více vláknech.This type is safe for multithreaded read operations. Je nutné synchronizovat všechny operace zápisu.You must synchronize any write operations.

Viz také