Manipulando eventos programaticamente
se aplica a:SQL Server SSIS Integration Runtime no Azure Data Factory
O tempo de execução do SSIS fornece uma coleção de eventos que ocorrem antes, durante e depois da validação e execução de um pacote. Esses eventos podem ser capturados de duas maneiras. O primeiro método é implementando a interface IDTSEvents em uma classe e fornecendo a classe como um parâmetro para os métodos Execute e Validate do pacote. O segundo método é criando objetos DtsEventHandler, que podem conter outros objetos SSIS, como tarefas e loops, que são executados quando ocorre um evento em IDTSEvents. Esta seção descreve esses dois métodos e fornece exemplos de código para demonstrar seu uso.
Recebendo retornos de chamada IDTSEvents
Os desenvolvedores que criam e executam pacotes programaticamente podem receber notificações de eventos durante o processo de validação e execução usando a interface IDTSEvents. Isso é feito criando uma classe que implementa a interface IDTSEvents e fornecendo essa classe como um parâmetro para os métodos Validate e Execute de um pacote. Os métodos da classe são então chamados pelo mecanismo de tempo de execução quando os eventos ocorrem.
A classe DefaultEvents é uma classe que já implementa a interface IDTSEvents; Portanto, outra alternativa à implementação direta de IDTSEvents é derivar de DefaultEvents e substituir os eventos específicos aos quais você deseja responder. Em seguida, você fornece sua classe como um parâmetro para os métodos Validate e Execute do Package para receber retornos de chamada de eventos.
O exemplo de código a seguir demonstra uma classe que deriva de DefaultEventse substitui o método OnPreExecute. A classe é então fornecida como um parâmetro para os métodos Validate e Execute do pacote.
using System;
using Microsoft.SqlServer.Dts.Runtime;
namespace Microsoft.SqlServer.Dts.Samples
{
class Program
{
static void Main(string[] args)
{
Package p = new Package();
MyEventsClass eventsClass = new MyEventsClass();
p.Validate(null, null, eventsClass, null);
p.Execute(null, null, eventsClass, null, null);
Console.Read();
}
}
class MyEventsClass : DefaultEvents
{
public override void OnPreExecute(Executable exec, ref bool fireAgain)
{
// TODO: Add custom code to handle the event.
Console.WriteLine("The PreExecute event of the " +
exec.ToString() + " has been raised.");
}
}
}
Imports Microsoft.SqlServer.Dts.Runtime
Module Module1
Sub Main()
Dim p As Package = New Package()
Dim eventsClass As MyEventsClass = New MyEventsClass()
p.Validate(Nothing, Nothing, eventsClass, Nothing)
p.Execute(Nothing, Nothing, eventsClass, Nothing, Nothing)
Console.Read()
End Sub
End Module
Class MyEventsClass
Inherits DefaultEvents
Public Overrides Sub OnPreExecute(ByVal exec As Executable, ByRef fireAgain As Boolean)
' TODO: Add custom code to handle the event.
Console.WriteLine("The PreExecute event of the " & _
exec.ToString() & " has been raised.")
End Sub
End Class
Criando objetos DtsEventHandler
O mecanismo de tempo de execução fornece um sistema robusto e altamente flexível de manipulação e notificação de eventos através do objeto DtsEventHandler. Esses objetos permitem que você projete fluxos de trabalho inteiros dentro do manipulador de eventos, que são executados somente quando ocorre o evento ao qual o manipulador de eventos pertence. O objeto DtsEventHandler é um contêiner que é executado quando o evento correspondente em seu objeto pai é acionado. Essa arquitetura permite criar fluxos de trabalho isolados que são executados em resposta a eventos que ocorrem em um contêiner. Como DtsEventHandler objetos são síncronos, a execução não é retomada até que os manipuladores de eventos anexados ao evento retornem.
O código a seguir demonstra como criar um objeto DtsEventHandler. O código adiciona um FileSystemTask à coleção Executables do pacote e, em seguida, cria um objeto DtsEventHandler para o evento OnError da tarefa. Um FileSystemTask é adicionado ao manipulador de eventos, que é executado quando o evento OnError ocorre pela primeira FileSystemTask. Este exemplo pressupõe que você tenha um arquivo chamado C:\Windows\Temp\DemoFile.txt para teste. A primeira vez que você executar o exemplo, se copia o arquivo com êxito e o manipulador de eventos não é chamado. Na segunda vez que você executar o exemplo, a primeira FileSystemTask falha ao copiar o arquivo (porque o valor de OverwriteDestinationFile é falso), o manipulador de eventos é chamado, o segundo FileSystemTask exclui o arquivo de origem e o pacote relata falha devido ao erro que ocorreu.
Exemplo
using System;
using System.IO;
using Microsoft.SqlServer.Dts.Runtime;
using Microsoft.SqlServer.Dts.Tasks.FileSystemTask;
namespace Microsoft.SqlServer.Dts.Samples
{
class Program
{
static void Main(string[] args)
{
string f = "DemoFile.txt";
Executable e;
TaskHost th;
FileSystemTask fst;
Package p = new Package();
p.Variables.Add("sourceFile", true, String.Empty,
@"C:\Windows\Temp\" + f);
p.Variables.Add("destinationFile", true, String.Empty,
Path.Combine(Directory.GetCurrentDirectory(), f));
// Create a first File System task and add it to the package.
// This task tries to copy a file from one folder to another.
e = p.Executables.Add("STOCK:FileSystemTask");
th = e as TaskHost;
th.Name = "FileSystemTask1";
fst = th.InnerObject as FileSystemTask;
fst.Operation = DTSFileSystemOperation.CopyFile;
fst.OverwriteDestinationFile = false;
fst.Source = "sourceFile";
fst.IsSourcePathVariable = true;
fst.Destination = "destinationFile";
fst.IsDestinationPathVariable = true;
// Add an event handler for the FileSystemTask's OnError event.
DtsEventHandler ehOnError = (DtsEventHandler)th.EventHandlers.Add("OnError");
// Create a second File System task and add it to the event handler.
// This task deletes the source file if the event handler is called.
e = ehOnError.Executables.Add("STOCK:FileSystemTask");
th = e as TaskHost;
th.Name = "FileSystemTask2";
fst = th.InnerObject as FileSystemTask;
fst.Operation = DTSFileSystemOperation.DeleteFile;
fst.Source = "sourceFile";
fst.IsSourcePathVariable = true;
DTSExecResult vr = p.Validate(null, null, null, null);
Console.WriteLine("ValidationResult = " + vr.ToString());
if (vr == DTSExecResult.Success)
{
DTSExecResult er = p.Execute(null, null, null, null, null);
Console.WriteLine("ExecutionResult = " + er.ToString());
if (er == DTSExecResult.Failure)
if (!File.Exists(@"C:\Windows\Temp\" + f))
Console.WriteLine("Source file has been deleted by the event handler.");
}
Console.Read();
}
}
}
Imports System.IO
Imports Microsoft.SqlServer.Dts.Runtime
Imports Microsoft.SqlServer.Dts.Tasks.FileSystemTask
Module Module1
Sub Main()
Dim f As String = "DemoFile.txt"
Dim e As Executable
Dim th As TaskHost
Dim fst As FileSystemTask
Dim p As Package = New Package()
p.Variables.Add("sourceFile", True, String.Empty, _
"C:\Windows\Temp\" & f)
p.Variables.Add("destinationFile", True, String.Empty, _
Path.Combine(Directory.GetCurrentDirectory(), f))
' Create a first File System task and add it to the package.
' This task tries to copy a file from one folder to another.
e = p.Executables.Add("STOCK:FileSystemTask")
th = CType(e, TaskHost)
th.Name = "FileSystemTask1"
fst = CType(th.InnerObject, FileSystemTask)
fst.Operation = DTSFileSystemOperation.CopyFile
fst.OverwriteDestinationFile = False
fst.Source = "sourceFile"
fst.IsSourcePathVariable = True
fst.Destination = "destinationFile"
fst.IsDestinationPathVariable = True
' Add an event handler for the FileSystemTask's OnError event.
Dim ehOnError As DtsEventHandler = CType(th.EventHandlers.Add("OnError"), DtsEventHandler)
' Create a second File System task and add it to the event handler.
' This task deletes the source file if the event handler is called.
e = ehOnError.Executables.Add("STOCK:FileSystemTask")
th = CType(e, TaskHost)
th.Name = "FileSystemTask1"
fst = CType(th.InnerObject, FileSystemTask)
fst.Operation = DTSFileSystemOperation.DeleteFile
fst.Source = "sourceFile"
fst.IsSourcePathVariable = True
Dim vr As DTSExecResult = p.Validate(Nothing, Nothing, Nothing, Nothing)
Console.WriteLine("ValidationResult = " + vr.ToString())
If vr = DTSExecResult.Success Then
Dim er As DTSExecResult = p.Execute(Nothing, Nothing, Nothing, Nothing, Nothing)
Console.WriteLine("ExecutionResult = " + er.ToString())
If er = DTSExecResult.Failure Then
If Not File.Exists("C:\Windows\Temp\" + f) Then
Console.WriteLine("Source file has been deleted by the event handler.")
End If
End If
End If
Console.Read()
End Sub
End Module
Ver também
de manipuladores de eventos do
Adicionar um manipulador de eventos a um pacote