Adicione e execute scripts C# com fluxos de trabalho padrão no Azure Logic Apps

Aplica-se a: Aplicativos Lógicos do Azure (Padrão)

Para executar tarefas de integração personalizadas em linha com seu fluxo de trabalho padrão nos Aplicativos Lógicos do Azure, você pode adicionar e executar scripts C# diretamente de dentro do seu fluxo de trabalho. Para esta tarefa, use a ação Código inline denominada Executar código de script CSharp. Essa ação retorna os resultados do script para que você possa usar essa saída nas ações subsequentes do fluxo de trabalho.

Esse recurso oferece os seguintes benefícios:

• Escreva seus próprios scripts no designer de fluxo de trabalho para que você possa resolver desafios de integração mais complexos sem precisar usar o Funções do Azure. Não são necessários outros planos de serviço.

  Esse benefício simplifica o desenvolvimento do fluxo de trabalho e reduz a complexidade e o custo com o gerenciamento de mais serviços.

• Gere um arquivo de código dedicado, que fornece um espaço de script personalizado em seu fluxo de trabalho.

• Implante scripts junto com seus fluxos de trabalho.

Este guia mostra como adicionar a ação em seu fluxo de trabalho e adicionar o código de script C# que você deseja executar.

Pré-requisitos

• Uma conta do Azure e uma subscrição. Crie uma conta Azure gratuita.

• O fluxo de trabalho do aplicativo lógico padrão onde você deseja adicionar seu script C#. O fluxo de trabalho já deve começar com um gatilho. Para obter mais informações, consulte Criar exemplos de fluxos de trabalho de aplicativos lógicos padrão.

  Pode usar qualquer gatilho para o seu cenário, mas, por exemplo, este guia utiliza o gatilho de Pedido chamado Quando um pedido HTTP é recebido e também a ação de Resposta . O fluxo de trabalho é executado quando outro aplicativo ou fluxo de trabalho envia uma solicitação para a URL do ponto de extremidade do gatilho. O script de exemplo retorna os resultados da execução de código como saída que você pode usar em ações subsequentes.

Cenários de exemplo

A lista a seguir descreve alguns cenários de exemplo em que você pode usar um script para ajudar com determinadas tarefas de integração:

• Analise e efetue transformações ou manipulações num payload para além das expressões incorporadas e das capacidades de operações de dados. Por exemplo, você pode usar um script para retornar um esquema modificado para processamento downstream.

• Gerencie recursos do Azure, como máquinas virtuais, e inicie-os ou execute-os, com base em alguma lógica de negócios.

• Execute um procedimento armazenado em um servidor SQL que precisa ser executado em uma agenda e armazenar os resultados no SharePoint.

• Registre erros de fluxo de trabalho com informações detalhadas salvando no Armazenamento do Azure ou enviando um email ou notificando sua equipe.

• Criptografe e descriptografe dados para estar em conformidade com os padrões de segurança da API.

• Passe um arquivo para o script para compactar ou descompactar para uma solicitação HTTP.

• Agregar dados de várias APIs e arquivos para criar relatórios diários

Considerações

• O portal do Azure salva seu script como um arquivo de script C# (.csx) na mesma pasta que o arquivo workflow.json , que armazena a definição JSON para seu fluxo de trabalho e implanta o arquivo no recurso do aplicativo lógico junto com a definição do fluxo de trabalho. Os Aplicativos Lógicos do Azure compilam esse arquivo para tornar o script pronto para execução.

  O formato de arquivo .csx permite que você escreva menos "clichê" e se concentre apenas em escrever uma função C#. Você pode renomear o arquivo .csx para facilitar o gerenciamento durante a implantação. No entanto, cada vez que você renomeia o script, a nova versão substitui a versão anterior.

• O script é local para o fluxo de trabalho. Para usar o mesmo script em outros fluxos de trabalho, exiba o arquivo de script no console do KuduPlus e copie o script para reutilizar em outros fluxos de trabalho.

Limitações

Adicionar a ação Executar código de script CSharp

1. No portal do Azure, abra o recurso da aplicação lógica Standard e o respetivo fluxo de trabalho no estruturador.

2. No designer, siga estas etapas gerais para adicionar a ação Inline Code Operations chamada Executar código de script CSharp ao seu fluxo de trabalho.

3. Depois de abrir o painel de informações da ação, no separador Parâmetros, na caixa Ficheiro de código, substitua o código de exemplo pré-preenchido pelo código do seu próprio script.

   • Na parte superior do script, importe os namespaces necessários e adicione todas as referências de assembly necessárias como de costume.

   • Implemente o Run método:

     • O Run nome do método é predefinido e seu fluxo de trabalho é executado somente chamando esse método Run em tempo de execução.

     • Para acessar dados provenientes do seu fluxo de trabalho, o Run método aceita esses dados por meio de um parâmetro com o tipo WorkflowContext . Você pode usar o objeto WorkflowContext para as seguintes tarefas:

       • Acesse as saídas de gatilho, as saídas de ação anteriores e seu fluxo de trabalho.

       • Acesse variáveis de ambiente e valores de configuração de aplicativo lógico.

     • Para retornar os resultados do script ou outros dados ao seu fluxo de trabalho, implemente o Run método com um tipo de retorno. Para obter mais informações, consulte Retornar dados ao seu fluxo de trabalho.

     • Para registrar a saída do script em C#, implemente o Run método para aceitar um registrador de funções por meio de um parâmetro com ILogger tipo e use log como o nome do argumento para facilitar a identificação. Evite incluir Console.Write no seu script.

       Importante

       Se você tiver um script de longa execução que exija terminação normal caso o host da função seja desligado, inclua um token de cancelamento, que é necessário, com seu registrador de funções.

       Para obter mais informações, consulte as seguintes seções:

       • Registre a saída em um fluxo.

       • Registre a saída para o Application Insights.

   O exemplo seguinte mostra o separador Parâmetros da ação com o código de script de exemplo:

   

   O exemplo a seguir mostra o código de script de exemplo:

   /// Add the required libraries.
   #r "Newtonsoft.Json"
   #r "Microsoft.Azure.Workflows.Scripting"
   using Microsoft.AspNetCore.Mvc;
   using Microsoft.Extensions.Primitives;
   using Microsoft.Extensions.Logging;
   using Microsoft.Azure.Workflows.Scripting;
   using Newtonsoft.Json.Linq;
   
   /// <summary>
   /// Executes the inline C# code.
   /// </summary>
   /// <param name="context">The workflow context.</param>
   /// <remarks> The entry-point to your code. The function signature should remain unchanged.</remarks>
   public static async Task<Results> Run(WorkflowContext context, ILogger log)
   {
       var triggerOutputs = (await context.GetTriggerResults().ConfigureAwait(false)).Outputs;
   
       /// Dereferences the 'name' property from the trigger payload.
       var name = triggerOutputs?["body"]?["name"]?.ToString();
   
       /// To get the outputs from a preceding action, you can uncomment and repurpose the following code.
       // var actionOutputs = (await context.GetActionResults("<action-name>").ConfigureAwait(false)).Outputs;
   
       /// The following logs appear in the Application Insights traces table.
       // log.LogInformation("Outputting results.");
       // var name = null;
   
       return new Results
       {
           Message = !string.IsNullOrEmpty(name) ? $"Hello {name} from CSharp action" : "Hello from CSharp action."
       };
   }
   
   public class Results
   {
       public string Message {get; set;}
   }
   

   Para obter mais informações, consulte "#r" - Referenciar assemblies externos.

4. Quando terminar, salve seu fluxo de trabalho.

Depois de executar o fluxo de trabalho, você pode revisar a saída do fluxo de trabalho no Application Insights, se habilitado. Para obter mais informações, consulte Ver os registos no Application Insights.

Importar espaços de nomes

Para importar namespaces, faça isso com a using cláusula como de costume. A lista a seguir inclui namespaces importados automaticamente, portanto, eles são opcionais para você incluir no script:

System
System.Collections.Generic
System.IO
System.Linq
System.Net.Http
System.Threading.Tasks
Microsoft.Azure.WebJobs
Microsoft.Azure.WebJobs.Host

Adicionar referências a assemblagens externas

Para referenciar assemblies do .NET Framework, utilize a diretiva #r "<assembly-name>, por exemplo:

/// Add the required libraries.
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Extensions.Logging;
using Microsoft.Azure.Workflows.Scripting;
using Newtonsoft.Json.Linq;

public static async Task<Results> Run(WorkflowContext context)
{
    <...>
}

public class Results
{
    <...>
}

A lista a seguir inclui assemblies adicionados automaticamente pelo ambiente de hospedagem do Funções do Azure:

mscorlib
System
System.Core
System.Xml
System.Net.Http
Microsoft.Azure.WebJobs
Microsoft.Azure.WebJobs.Host
Microsoft.Azure.WebJobs.Extensions
System.Web.Http
System.Net.Http.Formatting
Newtonsoft.Json

Incluir outros ficheiros .csx

Se tiveres ficheiros .csx existentes, podes usar as classes e métodos desses ficheiros na tua ação Executar Código CSharp Script . Para esta tarefa, pode usar a #load diretiva no seu ficheiro execute_csharp_code.csx . Esta diretiva funciona apenas com ficheiros .csx, não com ficheiros .cs. Você tem as seguintes opções:

• Carrega um ficheiro .csx diretamente na tua ação.

  O ficheiro .csx deve existir na mesma pasta do fluxo de trabalho que contém a ação Executar Código de Script CSharp . Consulte Carregar .csx diretamente.

• Referencia um ficheiro .csx que existe numa pasta partilhada para a tua aplicação lógica.

  A pasta partilhada deve existir no site/wwwroot/ caminho da pasta da sua aplicação lógica. Ver ficheiro .csx de referência numa pasta partilhada.

Carregar o ficheiro .csx diretamente

O seguinte exemplo de ficheiro execute_csharp_code.csx mostra como carregar um ficheiro de script chamado loadscript.csx numa ação Executar CSharp Script Code usando a #load diretiva:

// Add the required libraries
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
#load "loadscript.csx"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Extensions.Logging;
using Microsoft.Azure.Workflows.Scripting;
using Newtonsoft.Json.Linq;

/// <summary>
/// Execute the inline C# code.
/// </summary>
/// <param name="context">The workflow context.</param>
/// <remarks> This is the entry-point to your code. The function signature should remain unchanged.</remarks>
public static async Task<Results> Run(WorkflowContext context, ILogger log)
{
    var name = RunScript().ToString();
    return new Results
    {
        Message = !string.IsNullOrEmpty(name) ? $"Hello {name} from CSharp action" : "Hello from CSharp action."
    };
}

Referenciar ficheiro .csx numa pasta partilhada

Podes usar a #load diretiva para referenciar um ficheiro .csx que existe numa pasta partilhada para o recurso da tua aplicação lógica. Esta shared pasta deve existir no caminho da pasta site/wwwroot/ para o recurso da sua aplicação lógica.

Para adicionar o ficheiro script à shared pasta, siga estes passos:

1. No portal do Azure, abra seu recurso de aplicativo lógico padrão.

2. Na barra lateral da aplicação lógica, em Ferramentas de Desenvolvimento, selecione Ferramentas Avançadas.

3. Na página de Ferramentas Avançadas , selecione Go, que abre a consola Kudu+ .

4. Abra o menu Consola de depuração e selecione CMD.

5. Aceda à localização raiz da sua aplicação lógica: site/wwwroot

6. Vai à pasta partilhada. Se esta pasta não existir, cria a pasta.

   1. Na barra de ferramentas, ao lado do nome da pasta, selecione o sinal de mais (+), depois selecione Nova pasta.

   2. Insera shared para o nome da pasta.

   3. Abre a nova shared pasta.

7. Arrasta o ficheiro de script para importar para a shared pasta.

O seguinte exemplo de ficheiro execute_csharp_code.csx mostra como referenciar o ficheiro de script carregado chamado importcript.csx numa ação Executar Código de Script CSharp usando a #load diretiva:

// Add the required libraries
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
#load "..\shared\importscript.csx"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Extensions.Logging;
using Microsoft.Azure.Workflows.Scripting;
using Newtonsoft.Json.Linq;

/// <summary>
/// Execute the inline C# code.
/// </summary>
/// <param name="context">The workflow context.</param>
/// <remarks> This is the entry-point to your code. The function signature should remain unchanged.</remarks>
public static async Task<Results> Run(WorkflowContext context, ILogger log)
{
    var name = RunScript().ToString();
    return new Results
    {
        Message = !string.IsNullOrEmpty(name) ? $"Hello {name} from CSharp action" : "Hello from CSharp action." 
    }; 
} 

Importar pacotes NuGet

O NuGet é uma forma suportada pela Microsoft de criar, publicar, alojar, descobrir, consumir e partilhar bibliotecas de código .NET chamadas pacotes. A ação Executar Código de Script CSharp suporta a capacidade de importar pacotes NuGet usando um ficheiro functions.proj , localizado na raiz da pasta do workflow, por exemplo:

site/wwwroot/<workflow-name>/workflow.json
site/wwwroot/<workflow-name>/functions.proj

Por exemplo, pode utilizar o seguinte ficheiro functions.proj para importar pacotes NuGet para a sua ação Execute CSharp Script Code:

<Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
       <TargetFramework>netstandard2.0</TargetFramework>
    </PropertyGroup>
    <ItemGroup>
        <PackageReference Include="Serilog" Version="4.3.0" />
        <PackageReference Include="Serilog.Sinks.Console" Version="6.0.0" />
        <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
     </ItemGroup>
</Project>

• Para um ficheiro de script C# (.csx), deve definir TargetFramework para netstandard2.0.

  Este requisito não significa que as versões dos pacotes estejam limitadas a netstandard2.0. Ainda podes consultar pacotes para net6.0 e versões subsequentes.

• Quando o ficheiro functions.proj se inicializa, deve reiniciar a aplicação lógica para que o runtime do Azure Logic Apps possa reconhecer e consumir o ficheiro.

Depois de concluído o reinício, o runtime obtém automaticamente as bibliotecas necessárias da NuGet.org e coloca a biblioteca na pasta apropriada para uso pelo seu script. Embora não seja necessário carregar manualmente estes assemblies, certifique-se de referenciar diretamente os pacotes no seu código usando instruções padrão using , por exemplo:

using System.Net;
using Newtonsoft.Json;
using Serilog;

public static async Task<Output> Run(WorkflowContext context)
{
    Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.Console()
    .CreateLogger();

    // Write log messages
    Log.Information("Hello, Serilog with Console sink!");
    Log.Warning("This is a warning message.");

    var outputReturn = new Output()
    { 
        Message = "Utilizing my serilog logger."
    }; 

    return outputReturn;
} 

public class Output
{ 
    public string Message { get; set; }
} 

Registrar saída em um fluxo

No seu método Run, inclua um parâmetro do tipo ILogger com o nome log, por exemplo:

public static void Run(WorkflowContext context, ILogger log)
{
    log.LogInformation($"C# script successfully executed.");
}

Saída de log para o Application Insights

Para criar métricas personalizadas no Application Insights, use o LogMetric método de extensão em ILogger.

O exemplo a seguir mostra um exemplo de chamada de método:

logger.LogMetric("TestMetric", 1234);

Acesse o gatilho do fluxo de trabalho e as saídas de ação em seu script

Para acessar dados do seu fluxo de trabalho, use os seguintes métodos disponíveis para o WorkflowContext objeto de contexto:

• GetTriggerResults método

  Para acessar saídas de gatilho, use esse método para retornar um objeto que representa o gatilho e suas saídas, que estão disponíveis através da Outputs propriedade. Este objeto tem o tipo JObject e você pode usar os colchetes ([]) como um indexador para acessar várias propriedades nas saídas do gatilho.

  O exemplo seguinte obtém os dados da propriedade body nos resultados do acionador:

  public static async Task<Results> Run(WorkflowContext context, ILogger log)
  {
  
      var triggerOutputs = (await context.GetTriggerResults().ConfigureAwait(false)).Outputs;
      var body = triggerOutputs["body"];
  
      return new Results;
  
  }
  
  public class Results
  {
      <...>
  }
  

• GetActionResults método

  Para acessar saídas de ação, use esse método para retornar um objeto que representa a ação e suas saídas, que estão disponíveis por meio da Outputs propriedade. Este método aceita um nome de ação como um parâmetro. O exemplo a seguir obtém os dados da body propriedade nas saídas de uma ação chamada action-name:

  public static async Task<Results> Run(WorkflowContext context, ILogger log)
  {
  
      var actionOutputs = (await context.GetActionResults("action-name").ConfigureAwait(false)).Outputs;
      var body = actionOutputs["body"];
  
      return new Results;
  
  }
  
  public class Results
  {
      <...>
  }
  

Variáveis de ambiente do Access ou valor de configuração do aplicativo

Para obter uma variável de ambiente ou um valor de configuração de aplicativo, use o System.Environment.GetEnvironmentVariable método, por exemplo:

public static void Run(WorkflowContext context, ILogger log)
{
    log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
    log.LogInformation(GetEnvironmentVariable("AzureWebJobsStorage"));
    log.LogInformation(GetEnvironmentVariable("WEBSITE_SITE_NAME"));
}

public static string GetEnvironmentVariable(string name)
{
    return name + ": " +
    System.Environment.GetEnvironmentVariable(name, EnvironmentVariableTarget.Process);
}

Retornar dados ao seu fluxo de trabalho

Para esta tarefa, implemente o método Run com um tipo de retorno e a instrução return. Se você quiser uma versão assíncrona, implemente o Run método com um Task<return-type> atributo e a async palavra-chave. O valor de retorno é definido como a propriedade de saídas da ação de script body, à qual qualquer ação de fluxo de trabalho subsequente pode fazer referência.

O exemplo a seguir mostra um Run método com um Task<Results> atributo, a async palavra-chave e uma return instrução:

public static async Task<Results> Run(WorkflowContext context, ILogger log)
{
    return new Results
    {
        Message = !string.IsNullOrEmpty(name) ? $"Returning results with status message."
    };
}

public class Results
{
    public string Message {get; set;}
}

Exibir o arquivo de script

1. No portal do Azure, abra seu recurso de aplicativo lógico padrão que tem o fluxo de trabalho desejado.

2. Na barra lateral da aplicação lógica, em Ferramentas de Desenvolvimento, selecione Ferramentas Avançadas.

3. Na página Ferramentas Avançadas, selecione Ir, que abre o console KuduPlus.

4. Abra o menu Consola de depuração e selecione CMD.

5. Aceda à localização raiz da sua aplicação lógica: site/wwwroot

6. Vá para a pasta do seu fluxo de trabalho, que contém o arquivo .csx, ao longo deste caminho: site/wwwroot/{workflow-name}

7. Ao lado do nome do arquivo, selecione Editar para abrir e exibir o arquivo.

Ver registos no Application Insights

1. No portal Azure, na barra lateral da app Logic, em Definições, selecione Application Insights. Selecione a sua Logic App.

2. Na painel lateral do Application Insights, em Monitorização, selecione Logs.

3. Crie uma consulta para localizar quaisquer vestígios ou erros da execução do fluxo de trabalho, por exemplo:

   union traces, errors
   | project TIMESTAMP, message
   

Erros de compilação

Nesta versão, o editor baseado na Web inclui suporte limitado ao IntelliSense, que ainda está em melhoria. Quaisquer erros de compilação são detetados quando você salva seu fluxo de trabalho, e o tempo de execução dos Aplicativos Lógicos do Azure compila seu script. Esses erros aparecem nos logs de erros do seu aplicativo lógico.

Erros de tempo de execução

Se ocorrer um erro quando o script for executado, os Aplicativos Lógicos do Azure executarão estas etapas:

• Passa o erro de volta para o seu fluxo de trabalho.
• Marca a ação de script como Falha.
• Fornece um objeto de erro que representa a exceção gerada pelo seu script.

O exemplo a seguir mostra um erro de exemplo:

A função 'CSharp_MyLogicApp-InvalidAction_execute_csharp_script_code.csx' falhou com o erro 'A ação 'inexistente' não existe no fluxo de trabalho'. ao executar. Verifique se o código da função é válido.

Scripts de exemplo

Os scripts de exemplo a seguir executam várias tarefas que você pode

Descompactar um arquivo ZIP com arquivos de texto de uma ação HTTP em uma matriz de cadeia de caracteres

// Add the required libraries.
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Azure.Workflows.Scripting;
using System;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Collections.Generic;

/// <summary>
/// Executes the inline C# code.
/// </summary>
/// <param name="context">The workflow context.</param>
public static async Task<List<string>> Run(WorkflowContext context)
{

    var outputs = (await context.GetActionResults("HTTP_1").ConfigureAwait(false)).Outputs;
    var base64zipFileContent = outputs["body"]["$content"].ToString();

    // Decode base64 to bytes.
    byte[] zipBytes = Convert.FromBase64String(base64zipFileContent);

    List<string> fileContents = new List<string>();

    // Creates an in-memory stream from the zip bytes.
    using (MemoryStream zipStream = new MemoryStream(zipBytes))
    {

        // Extracts files from the zip archive.
        using (ZipArchive zipArchive = new ZipArchive(zipStream))
        {

            foreach (ZipArchiveEntry entry in zipArchive.Entries)
            {

                // Read each file's content.
                using (StreamReader reader = new StreamReader(entry.Open()))
                {
                    string fileContent = reader.ReadToEnd();
                    fileContents.Add(fileContent);
                }
            }
        }
    }

    return fileContents;
}

Criptografar dados usando uma chave das configurações do aplicativo

// Add the required libraries.
#r "Newtonsoft.Json"
#r "Microsoft.Azure.Workflows.Scripting"
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Primitives;
using Microsoft.Azure.Workflows.Scripting;
using Newtonsoft.Json.Linq;
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

/// <summary>
/// Executes the inline csharp code.
/// </summary>
/// <param name="context">The workflow context.</param>
public static async Task<string> Run(WorkflowContext context)
{

    var compose = (await context.GetActionResults("compose").ConfigureAwait(false)).Outputs;
    var text = compose["sampleData"].ToString();

    return EncryptString(text);

}

public static string EncryptString(string plainText)
{

    var key = Environment.GetEnvironmentVariable("app-setting-key");
    var iv = Environment.GetEnvironmentVariable("app-setting-iv");

    using (Aes aesAlg = Aes.Create())
    {

        aesAlg.Key = Encoding.UTF8.GetBytes(key);
        aesAlg.IV = Encoding.UTF8.GetBytes(iv);
        ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

        using (MemoryStream msEncrypt = new MemoryStream())
        {

            using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
            {

                using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                {
                    swEncrypt.Write(plainText);
                }

            }

             return Convert.ToBase64String(msEncrypt.ToArray());

        }
    }
}

Classe WorkflowContext

Representa um contexto de fluxo de trabalho.

Métodos

GetActionResult(string actionName)

Obtém o resultado de uma ação específica no fluxo de trabalho.

A versão assíncrona usa Task<> como o tipo de retorno, por exemplo:

Task<WorkflowOperationResult> GetActionResult(string actionName)

Parâmetros

actionName: O nome da ação.

Devoluções

A versão assíncrona retorna um Task objeto que representa a operação assíncrona. O resultado da tarefa contém um WorkflowOperationResult objeto. Para obter informações sobre as propriedades do objeto WorkflowOperationResult , consulte Classe WorkflowOperationResult.

RunTriggerResult()

Obtém o resultado do gatilho no fluxo de trabalho.

A versão assíncrona usa Task<> como o tipo de retorno, por exemplo:

Task<WorkflowOperationResult> RunTriggerResult()

Parâmetros

Nenhum.

Devoluções

A versão assíncrona retorna um Task objeto que representa a operação assíncrona. O resultado da tarefa contém um WorkflowOperationResult objeto. Para obter informações sobre as propriedades do objeto WorkflowOperationResult , consulte Classe WorkflowOperationResult.

Classe WorkflowOperationResult

Representa o resultado de uma operação de fluxo de trabalho.

Propriedades

Conteúdos relacionados

Adicionar e executar trechos de código JavaScript