Taken programmatisch toevoegen

Van toepassing op:SQL Server SSIS Integration Runtime in Azure Data Factory

Taken kunnen worden toegevoegd aan de volgende soorten objecten in de run-time engine:

• Package

• Sequence

• ForLoop

• ForEachLoop

• DtsEventHandler

Deze klassen worden als containers beschouwd en erven allemaal de Executables eigenschap. Containers kunnen een verzameling taken bevatten, die uitvoerbare objecten zijn die door de runtime worden verwerkt tijdens de uitvoering van de container. De volgorde van uitvoering van de objecten in de collectie wordt bepaald door elke PrecedenceConstraint set per taak in de containers. Precedentiebeperkingen maken uitvoeringsvertakkingen mogelijk op basis van het succes, falen of voltooien van een Executable in de collectie.

Elke container heeft een Executables collectie die de afzonderlijke Executable objecten bevat. Elke uitvoerbare taak erft en implementeert de Execute methode en Validate methode. Deze twee methoden worden door de runtime-engine aangeroepen om elke Executablete verwerken.

Om een taak aan een pakket toe te voegen, heb je een container nodig met een Executables bestaande collectie. Meestal is de taak die je aan de collectie toevoegt een pakket. Om het nieuwe taakuitvoerbare bestand toe te voegen aan de collectie van die container, roep je de Add methode aan . De methode heeft één parameter, een string, die de naam CLSID, PROGID, STOCK bevat, of CreationName van de taak die je toevoegt.

Taaknamen

Hoewel je een taak kunt specificeren op naam of ID, is de STOCK-naam de parameter die het vaakst in de Add methode wordt gebruikt. Om een taak toe te voegen aan een uitvoerbaar bestand dat wordt geïdentificeerd met de naam STOCK , gebruik je de volgende syntaxis:

Executable exec = package.Executables.Add("STOCK:BulkInsertTask");  
  

Dim exec As Executable = package.Executables.Add("STOCK:BulkInsertTask")  
  

De volgende lijst toont de namen voor elke taak die na de STOCK-naam wordt gebruikt.

• ActiveXScriptTask

• BulkInsertTask

• ExecuteProcessTask

• ExecutePackageTask

• Exec80PackageTask

• FileSystemTask

• FTPTask

• MSMQTask

• PipelineTask

• ScriptTask

• SendMailTask

• SQLTask

• TransferStoredProceduresTask

• TransferLoginsTask

• TransferErrorMessagesTask

• TransferJobsTask

• TransferObjectsTask

• TransferDatabaseTask

• WebServiceTask

• WmiDataReaderTask

• WmiEventWatcherTask

• XMLTask

Als je liever een explicietere syntaxis hebt, of als de taak die je wilt toevoegen geen STOCK-naam heeft, kun je de taak aan het uitvoerbare bestand toevoegen met de lange naam. Deze syntaxis vereist dat je ook het versienummer van de taak specificeert.

Executable exec = package.Executables.Add(  
  "Microsoft.SqlServer.Dts.Tasks.ScriptTask.ScriptTask, " +  
  "Microsoft.SqlServer.ScriptTask, Version=10.0.000.0, " +  
  "Culture=neutral, PublicKeyToken=89845dcd8080cc91");  

Dim exec As Executable = package.Executables.Add( _  
  "Microsoft.SqlServer.Dts.Tasks.ScriptTask.ScriptTask, " & _  
  "Microsoft.SqlServer.ScriptTask, Version=10.0.000.0, " & _  
  "Culture=neutral, PublicKeyToken=89845dcd8080cc91")  

Je kunt de lange naam van de taak programmatisch verkrijgen, zonder de taakversie te hoeven specificeren, door gebruik te maken van de AssemblyQualifiedName-eigenschap van de klasse, zoals getoond in het volgende voorbeeld. Dit voorbeeld vereist een verwijzing naar de Microsoft. SqlServer.SQLTask assembly.

using Microsoft.SqlServer.Dts.Tasks.ExecuteSQLTask;  
...  
      Executable exec = package.Executables.Add(  
        typeof(Microsoft.SqlServer.Dts.Tasks.ExecuteSQLTask.ExecuteSQLTask).AssemblyQualifiedName);  

Imports Microsoft.SqlServer.Dts.Tasks.ExecuteSQLTask  
...  
    Dim exec As Executable = package.Executables.Add( _  
      GetType(Microsoft.SqlServer.Dts.Tasks.ExecuteSQLTask.ExecuteSQLTask).AssemblyQualifiedName)  

Het volgende codevoorbeeld laat zien hoe je een Executables collectie aanmaakt vanuit een nieuw pakket, en vervolgens een File System-taak en een Bulk Insert-taak aan de collectie toevoegt met behulp van hun STOCK-namen . Dit voorbeeld vereist een verwijzing naar de Microsoft. SqlServer.FileSystemTask en Microsoft. SqlServer.BulkInsertTask-assemblies.

using System;  
using Microsoft.SqlServer.Dts.Runtime;  
using Microsoft.SqlServer.Dts.Tasks.FileSystemTask;  
using Microsoft.SqlServer.Dts.Tasks.BulkInsertTask;  
  
namespace Microsoft.SqlServer.Dts.Samples  
{  
  class Program  
  {  
    static void Main(string[] args)  
    {  
      Package p = new Package();  
      // Add a File System task to the package.  
      Executable exec1 = p.Executables.Add("STOCK:FileSystemTask");  
      TaskHost thFileSystemTask = exec1 as TaskHost;  
      // Add a Bulk Insert task to the package.  
      Executable exec2 = p.Executables.Add("STOCK:BulkInsertTask");  
      TaskHost thBulkInsertTask = exec2 as TaskHost;  
  
      // Iterate through the package Executables collection.  
      Executables pExecs = p.Executables;  
      foreach (Executable pExec in pExecs)  
      {  
        TaskHost taskHost = (TaskHost)pExec;  
        Console.WriteLine("Type {0}", taskHost.InnerObject.ToString());  
      }  
      Console.Read();  
    }  
  }  
}  

Imports Microsoft.SqlServer.Dts.Runtime  
Imports Microsoft.SqlServer.Dts.Tasks.FileSystemTask  
Imports Microsoft.SqlServer.Dts.Tasks.BulkInsertTask  
  
Module Module1  
  
  Sub Main()  
  
    Dim p As Package = New Package()  
    ' Add a File System task to the package.  
    Dim exec1 As Executable = p.Executables.Add("STOCK:FileSystemTask")  
    Dim thFileSystemTask As TaskHost = CType(exec1, TaskHost)  
    ' Add a Bulk Insert task to the package.  
    Dim exec2 As Executable = p.Executables.Add("STOCK:BulkInsertTask")  
    Dim thBulkInsertTask As TaskHost = CType(exec2, TaskHost)  
  
    ' Iterate through the package Executables collection.  
    Dim pExecs As Executables = p.Executables  
    Dim pExec As Executable  
    For Each pExec In pExecs  
      Dim taskHost As TaskHost = CType(pExec, TaskHost)  
      Console.WriteLine("Type {0}", taskHost.InnerObject.ToString())  
    Next  
    Console.Read()  
  
  End Sub  
  
End Module  

Voorbeelduitvoer:

Type Microsoft.SqlServer.Dts.Tasks.FileSystemTask.FileSystemTask

Type Microsoft.SqlServer.Dts.Tasks.BulkInsertTask.BulkInsertTask

TaskHost Container

De TaskHost klasse is een container die niet in de grafische gebruikersinterface voorkomt, maar erg belangrijk is in programmeren. Deze klasse is een wrapper voor elke taak. Taken die aan het pakket worden toegevoegd door de Add methode als Executable object te gebruiken, kunnen als object TaskHost worden gecast. Wanneer een taak als een TaskHostwordt gecast, kun je extra eigenschappen en methoden op de taak gebruiken. Ook kan de taak zelf worden benaderd via de InnerObject eigenschap van de TaskHost. Afhankelijk van je behoeften kun je ervoor kiezen de taak als object TaskHost te houden zodat je de eigenschappen van de taak via de Properties collectie kunt gebruiken. Het voordeel van het Properties gebruik is dat je meer generieke code kunt schrijven. Als je heel specifieke code nodig hebt voor een taak, dan moet je de taak naar het juiste object casten.

Het volgende codevoorbeeld laat zien hoe je een TaskHost, thBulkInsertTask, die een BulkInsertTaskbevat, naar een BulkInsertTask object kunt casten.

BulkInsertTask myTask = thBulkInsertTask.InnerObject as BulkInsertTask;  

Dim myTask As BulkInsertTask = CType(thBulkInsertTask.InnerObject, BulkInsertTask)  

Het volgende codevoorbeeld laat zien hoe je het uitvoerbare bestand naar een TaskHostcast, en vervolgens de InnerObject eigenschap gebruikt om te bepalen welk type uitvoerbaar bestand door de host wordt opgenomen.

using System;  
using Microsoft.SqlServer.Dts.Runtime;  
using Microsoft.SqlServer.Dts.Tasks.FileSystemTask;  
using Microsoft.SqlServer.Dts.Tasks.BulkInsertTask;  
  
namespace Microsoft.SqlServer.Dts.Samples  
{  
  class Program  
  {  
    static void Main(string[] args)  
    {  
      Package p = new Package();  
      // Add a File System task to the package.  
      Executable exec1 = p.Executables.Add("STOCK:FileSystemTask");  
      TaskHost thFileSystemTask1 = exec1 as TaskHost;  
      // Add a Bulk Insert task to the package.  
      Executable exec2 = p.Executables.Add("STOCK:BulkInsertTask");  
      TaskHost thFileSystemTask2 = exec2 as TaskHost;  
  
      // Iterate through the package Executables collection.  
      Executables pExecs = p.Executables;  
      foreach (Executable pExec in pExecs)  
      {  
        TaskHost taskHost = (TaskHost)pExec;  
        if (taskHost.InnerObject is Microsoft.SqlServer.Dts.Tasks.FileSystemTask.FileSystemTask)  
        {  
          // Do work with FileSystemTask here.  
          Console.WriteLine("Found task of type {0}", taskHost.InnerObject.ToString());  
        }  
        else if (taskHost.InnerObject is Microsoft.SqlServer.Dts.Tasks.BulkInsertTask.BulkInsertTask)  
        {  
          // Do work with BulkInsertTask here.  
          Console.WriteLine("Found task of type {0}", taskHost.InnerObject.ToString());  
        }  
        // Add additional statements to check InnerObject, if desired.  
      }  
      Console.Read();  
    }  
  }  
}  

Imports Microsoft.SqlServer.Dts.Runtime  
Imports Microsoft.SqlServer.Dts.Tasks.FileSystemTask  
Imports Microsoft.SqlServer.Dts.Tasks.BulkInsertTask  
  
Module Module1  
  
  Sub Main()  
  
    Dim p As Package = New Package()  
    ' Add a File System task to the package.  
    Dim exec1 As Executable = p.Executables.Add("STOCK:FileSystemTask")  
    Dim thFileSystemTask1 As TaskHost = CType(exec1, TaskHost)  
    ' Add a Bulk Insert task to the package.  
    Dim exec2 As Executable = p.Executables.Add("STOCK:BulkInsertTask")  
    Dim thFileSystemTask2 As TaskHost = CType(exec2, TaskHost)  
  
    ' Iterate through the package Executables collection.  
    Dim pExecs As Executables = p.Executables  
    Dim pExec As Executable  
    For Each pExec In pExecs  
      Dim taskHost As TaskHost = CType(pExec, TaskHost)  
      If TypeOf taskHost.InnerObject Is Microsoft.SqlServer.Dts.Tasks.FileSystemTask.FileSystemTask Then  
        ' Do work with FileSystemTask here.  
        Console.WriteLine("Found task of type {0}", taskHost.InnerObject.ToString())  
      ElseIf TypeOf taskHost.InnerObject Is Microsoft.SqlServer.Dts.Tasks.BulkInsertTask.BulkInsertTask Then  
        ' Do work with BulkInsertTask here.  
        Console.WriteLine("Found task of type {0}", taskHost.InnerObject.ToString())  
      End If  
      ' Add additional statements to check InnerObject, if desired.  
    Next  
    Console.Read()  
  
  End Sub  
  
End Module  

Voorbeelduitvoer:

Found task of type Microsoft.SqlServer.Dts.Tasks.FileSystemTask.FileSystemTask

Found task of type Microsoft.SqlServer.Dts.Tasks.BulkInsertTask.BulkInsertTask

De Add instructie retourneert een uitvoerbaar bestand dat vanuit het nieuw aangemaakte Executable object naar een TaskHost object wordt gecast.

Om eigenschappen in te stellen of methoden aan te roepen op het nieuwe object, heb je twee opties:

1. Gebruik de Properties verzameling van de TaskHost. Om bijvoorbeeld een eigenschap van het object te verkrijgen, gebruik th.Properties["propertyname"].GetValue(th))je . Om een eigenschap in te stellen, gebruik th.Properties["propertyname"].SetValue(th, <value>);je .

2. Spreek de InnerObject van de TaskHost naar de taakklasse. Bijvoorbeeld, om de Bulk Insert-taak naar een BulkInsertTask te casten nadat deze aan een pakket is toegevoegd als een Executable en vervolgens naar een TaskHost, gebruik BulkInsertTask myTask = th.InnerObject as BulkInsertTask;.

Het gebruik van de TaskHost klasse in code, in plaats van te casten naar de taakspecifieke klasse, heeft de volgende voordelen:

• De aanbieder TaskHostProperties vereist geen verwijzing naar de assembly in de code.

• Je kunt generieke routines programmeren die voor elke taak werken, omdat je de naam van de taak niet hoeft te weten bij het compileren tijd. Dergelijke generieke routines omvatten methoden waarbij je de naam van de taak aan de methode doorgeeft, en de methodcode werkt voor alle taken. Dit is een goede methode om testcode te schrijven.

Het uitwerpen van de TaskHost naar de taakspecifieke klasse heeft de volgende voordelen:

• Het Visual Studio-project geeft je statement-aanvulling (IntelliSense).

• De code kan sneller lopen.

• Taakspecifieke objecten maken vroege binding en de resulterende optimalisaties mogelijk. Voor meer informatie over vroege en late binding, zie het onderwerp "Early and Late Binding" in Visual Basic Language Concepts.

Het volgende codevoorbeeld bouwt het concept van het hergebruiken van taakcode verder uit. In plaats van taken naar hun specifieke klasse-equivalenten te casten, laat het codevoorbeeld zien hoe je het uitvoerbare bestand naar een TaskHostcast, en gebruikt vervolgens de Properties om generieke code te schrijven tegen alle taken.

using System;  
using Microsoft.SqlServer.Dts.Runtime;  
  
namespace Microsoft.SqlServer.Dts.Samples  
{  
  class Program  
  {  
    static void Main(string[] args)  
    {  
      Package package = new Package();  
  
      string[] tasks = { "STOCK:SQLTask", "STOCK:ScriptTask",   
        "STOCK:ExecuteProcessTask", "STOCK:PipelineTask",   
        "STOCK:FTPTask", "STOCK:SendMailTask", "STOCK:MSMQTask" };  
  
      foreach (string s in tasks)  
      {  
        TaskHost taskhost = package.Executables.Add(s) as TaskHost;  
        DtsProperties props = taskhost.Properties;  
        Console.WriteLine("Enumerating properties on " + taskhost.Name);  
        Console.WriteLine(" TaskHost.InnerObject is " + taskhost.InnerObject.ToString());  
        Console.WriteLine();  
  
        foreach (DtsProperty prop in props)  
        {  
          Console.WriteLine("Properties for " + prop.Name);  
          Console.WriteLine("Name : " + prop.Name);  
          Console.WriteLine("Type : " + prop.Type.ToString());  
          Console.WriteLine("Readable : " + prop.Get.ToString());  
          Console.WriteLine("Writable : " + prop.Set.ToString());  
          Console.WriteLine();  
        }  
      }  
      Console.Read();  
    }  
  }  
}  

Imports Microsoft.SqlServer.Dts.Runtime  
  
Module Module1  
  
  Sub Main()  
  
    Dim package As Package = New Package()  
  
    Dim tasks() As String = New String() {"STOCK:SQLTask", "STOCK:ScriptTask", _  
              "STOCK:ExecuteProcessTask", "STOCK:PipelineTask", _  
              "STOCK:FTPTask", "STOCK:SendMailTask", "STOCK:MSMQTask"}  
  
    For Each s As String In tasks  
  
      Dim taskhost As TaskHost = CType(package.Executables.Add(s), TaskHost)  
      Dim props As DtsProperties = taskhost.Properties  
      Console.WriteLine("Enumerating properties on " & taskhost.Name)  
      Console.WriteLine(" TaskHost.InnerObject is " & taskhost.InnerObject.ToString())  
      Console.WriteLine()  
  
      For Each prop As DtsProperty In props  
        Console.WriteLine("Properties for " + prop.Name)  
        Console.WriteLine(" Name : " + prop.Name)  
        Console.WriteLine(" Type : " + prop.Type.ToString())  
        Console.WriteLine(" Readable : " + prop.Get.ToString())  
        Console.WriteLine(" Writable : " + prop.Set.ToString())  
        Console.WriteLine()  
      Next  
  
    Next  
    Console.Read()  
  
  End Sub  
  
End Module  

Verwante onderwerpen

• EzAPI - Bijgewerkt voor SQL Server 2012
• Taken programmatisch verbinden