PrecedenceConstraintEnumerator.Current Propriedade

public:
 property Microsoft::SqlServer::Dts::Runtime::PrecedenceConstraint ^ Current { Microsoft::SqlServer::Dts::Runtime::PrecedenceConstraint ^ get(); };

public Microsoft.SqlServer.Dts.Runtime.PrecedenceConstraint Current { get; }

member this.Current : Microsoft.SqlServer.Dts.Runtime.PrecedenceConstraint

Public ReadOnly Property Current As PrecedenceConstraint

Valor da propriedade

PrecedenceConstraint

O objeto PrecedenceConstraint atual.

Exemplos

O exemplo de código a seguir cria duas restrições de precedência. Em seguida, ele usa Contains para verificar a existência de uma restrição específica, conta o número de restrições antes e depois do uso do Remove método e mostra como usar a GetEnumerator para iterar sobre a coleção, usando a Item[] sintaxe de pConsts[i].ID retornar a ID restrição.

using System;  
using System.Collections.Generic;  
using System.Text;  
using Microsoft.SqlServer.Dts.Runtime;  
using Microsoft.SqlServer.Dts.Tasks.FileSystemTask;  
using Microsoft.SqlServer.Dts.Tasks.BulkInsertTask;  

namespace PrecedenceConst  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Package pkg = new Package();  
            // Add a File System task.  
            Executable eFileTask1 = pkg.Executables.Add("STOCK:FileSystemTask");  
            TaskHost thFileTask1 = eFileTask1 as TaskHost;  

            // Add a second File System task.  
            Executable eFileTask2 = pkg.Executables.Add("STOCK:FileSystemTask");  
            TaskHost thFileTask2 = eFileTask2 as TaskHost;  

            // Add a Bulk Insert task.  
            Executable eBulkInsert = pkg.Executables.Add("STOCK:BulkInsertTask");  
            TaskHost thBulkInsert = eBulkInsert as TaskHost;  

            // Add a precedence constraint between eFileTask1 and eFileTask2.  
            // Set the constraint to be that eFileTask2 cannot run   
            // until eFileTask1 completes.  
            PrecedenceConstraint pcFileTasks = pkg.PrecedenceConstraints.Add(eFileTask1, eFileTask2);  
            pcFileTasks.Name = "constraint between File System Tasks";  

            // Add another precedence constraint. Add it between eFileTask2 and BulkInsert.  
            // Again, set the constraint to be that BulkInsert cannot run   
            // until eFileTask2 completes.  
            PrecedenceConstraint pcFiletoBulk = pkg.PrecedenceConstraints.Add(eFileTask2, eBulkInsert);  
            pcFileTasks.Name = "constraint between File System and Bulk Insert Tasks";  

            // Obtain the precedence constraint collection.  
            PrecedenceConstraints pConsts = pkg.PrecedenceConstraints;  
            Boolean containsConstraint = pkg.PrecedenceConstraints.Contains("constraint between File System and Bulk Insert Tasks");  
            Console.WriteLine("Contains the constraint between File System and Bulk Insert Tasks? {0}", containsConstraint);  

            // Create the enumerator.  
            PrecedenceConstraintEnumerator myEnumerator = pConsts.GetEnumerator();  
            // Iterate over the collection, and remove the Bulk Insert task.  
            int i = 0;  
            while ((myEnumerator.MoveNext()) && (myEnumerator.Current != null))  
            {  
                Console.WriteLine("ID {0}", pConsts[i].ID);  
            }  

            Console.WriteLine("Number of constraints {0}", pConsts.Count);  
            // Remove the second contstraint.  
            pConsts.Remove(1);  
            // Verify that one has been removed.  
            Console.WriteLine("Number of constraints {0}", pConsts.Count);  

            Console.WriteLine();  
        }  
    }  
}  

Imports System  
Imports System.Collections.Generic  
Imports System.Text  
Imports Microsoft.SqlServer.Dts.Runtime  
Imports Microsoft.SqlServer.Dts.Tasks.FileSystemTask  
Imports Microsoft.SqlServer.Dts.Tasks.BulkInsertTask  

Namespace PrecedenceConst  
    Class Program  
        Shared  Sub Main(ByVal args() As String)  
            Dim pkg As Package =  New Package()   
            ' Add a File System task.  
            Dim eFileTask1 As Executable =  pkg.Executables.Add("STOCK:FileSystemTask")   
            Dim thFileTask1 As TaskHost =  eFileTask1 as TaskHost   

            ' Add a second File System task.  
            Dim eFileTask2 As Executable =  pkg.Executables.Add("STOCK:FileSystemTask")   
            Dim thFileTask2 As TaskHost =  eFileTask2 as TaskHost   

            ' Add a Bulk Insert task.  
            Dim eBulkInsert As Executable =  pkg.Executables.Add("STOCK:BulkInsertTask")   
            Dim thBulkInsert As TaskHost =  eBulkInsert as TaskHost   

            ' Add a precedence constraint between eFileTask1 and eFileTask2.  
            ' Set the constraint to be that eFileTask2 cannot run   
            ' until eFileTask1 completes.  
            Dim pcFileTasks As PrecedenceConstraint =  pkg.PrecedenceConstraints.Add(eFileTask1,eFileTask2)   
            pcFileTasks.Name = "constraint between File System Tasks"  

            ' Add another precedence constraint. Add it between eFileTask2 and BulkInsert.  
            ' Again, set the constraint to be that BulkInsert cannot run   
            ' until eFileTask2 completes.  
            Dim pcFiletoBulk As PrecedenceConstraint =  pkg.PrecedenceConstraints.Add(eFileTask2,eBulkInsert)   
            pcFileTasks.Name = "constraint between File System and Bulk Insert Tasks"  

            ' Obtain the precedence constraint collection.  
            Dim pConsts As PrecedenceConstraints =  pkg.PrecedenceConstraints   
            Dim containsConstraint As Boolean =  pkg.PrecedenceConstraints.Contains("constraint between File System and Bulk Insert Tasks")   
            Console.WriteLine("Contains the constraint between File System and Bulk Insert Tasks? {0}", containsConstraint)  

            ' Create the enumerator.  
            Dim myEnumerator As PrecedenceConstraintEnumerator =  pConsts.GetEnumerator()   
            ' Iterate over the collection, and remove the Bulk Insert task.  
            Dim i As Integer =  0   
            While (myEnumerator.MoveNext()) &&(myEnumerator.Current <> Nothing)  
                Console.WriteLine("ID {0}", pConsts(i).ID)  
            End While  

            Console.WriteLine("Number of constraints {0}", pConsts.Count)  
            ' Remove the second contstraint.  
            pConsts.Remove(1)  
            ' Verify that one has been removed.  
            Console.WriteLine("Number of constraints {0}", pConsts.Count)  

            Console.WriteLine()  
        End Sub  
    End Class  
End Namespace  

Saída de exemplo:

Contém a restrição entre o Sistema de Arquivos e as Tarefas de Inserção em Massa? True

ID {BA42AF32-3AC1-4CB6-85A2-289760ADBFA4}

ID {BA42AF32-3AC1-4CB6-85A2-289760ADBFA4}

Número de restrições 2

Número de restrições 1

Comentários

Depois que um enumerador é criado ou após uma chamada para o Reset método, o MoveNext método deve ser chamado para avançar o enumerador para o primeiro elemento da coleção antes que o enumerador possa ler o valor da Current propriedade; caso contrário, Current é indefinido e gera uma exceção.

Current também gerará uma exceção se a última chamada for MoveNext retornada false, o que indica o fim da coleção.

Current não move a posição do enumerador e chamadas consecutivas para Current retornar o mesmo objeto até que seja MoveNext chamado ou Reset chamado.

Um enumerador permanece válido desde que a coleção permaneça inalterada. Se forem feitas alterações na coleção, como adicionar, modificar ou excluir elementos, o enumerador será invalidado e se tornará irrecuperável; assim, a próxima chamada para MoveNext ou Reset gera um InvalidOperationException. Se a coleção for modificada entre chamadas e MoveNextCurrentretornar Current o elemento ao qual ela está definida, mesmo que o enumerador tenha sido invalidado.

Aplica-se a