Partager via

Ajouter et exécuter des scripts C# avec des flux de travail Standard dans Azure Logic Apps

S’applique à : Azure Logic Apps (Standard)

Pour effectuer des tâches d’intégration personnalisées en ligne avec votre flux de travail Standard dans Azure Logic Apps, vous pouvez ajouter et exécuter directement des scripts C# à partir de votre flux de travail. Pour cette tâche, utilisez l’action Code Inline nommée Exécuter le code de script CSharp. Cette action retourne les résultats de votre script afin de vous permettre d’utiliser cette sortie dans les actions suivantes de votre flux de travail.

Cette fonctionnalité offre les avantages suivants :

  • Écrivez vos propres scripts dans le Concepteur de flux de travail afin de pouvoir résoudre des problèmes d’intégration plus complexes sans avoir à utiliser Azure Functions. Aucun autre plan de service n’est nécessaire.

    Cet avantage simplifie le développement de flux de travail et réduit la complexité et le coût de la gestion d’un plus grand nombre de services.

  • Générez un fichier de code dédié, qui fournit un espace de script personnalisé dans votre flux de travail.

  • Déployez des scripts en même temps que vos flux de travail.

Ce guide montre comment ajouter l’action dans votre flux de travail et ajouter le code de script C# que vous souhaitez exécuter.

Prérequis

  • Un compte et un abonnement Azure. Obtenez un compte Azure gratuit.

  • Flux de travail d’application logique standard dans lequel vous souhaitez ajouter votre script C#. Le workflow doit déjà commencer par un déclencheur. Pour plus d’informations, consultez Créer des exemples de flux de travail d’application logique standard.

    Vous pouvez utiliser n’importe quel déclencheur pour votre scénario, mais, par exemple, ce guide utilise le déclencheur de requête nommé Lorsqu’une requête HTTP est reçue et également l’action Réponse . Le flux de travail s’exécute lorsqu’une autre application ou flux de travail envoie une requête à l’URL du point de terminaison du déclencheur. L’exemple de script retourne les résultats de l’exécution du code en tant que sortie que vous pouvez utiliser dans les actions suivantes.

Exemples de scénarios

La liste suivante décrit certains exemples de scénarios dans lesquels vous pouvez utiliser un script pour vous aider à effectuer certaines tâches d’intégration :

  • Analysez et effectuez des transformations ou des manipulations sur une charge utile au-delà des fonctionnalités intégrées des expressions et des opérations de données. Par exemple, vous pouvez utiliser un script pour retourner un schéma modifié pour le traitement en aval.

  • Gérez des ressources Azure telles que des machines virtuelles et démarrez-les ou effectuez des étapes en fonction d’une logique métier.

  • Exécutez une procédure stockée sur un serveur SQL qui doit s’exécuter selon une planification et stockez les résultats sur SharePoint.

  • Consignez les erreurs de flux de travail avec des informations détaillées en enregistrant dans Stockage Azure ou en envoyant un e-mail ou en informant votre équipe.

  • Chiffrer et déchiffrer les données pour se conformer aux normes de sécurité des API.

  • Transmettez un fichier dans le script pour compresser ou décompresser une requête HTTP.

  • Agréger des données provenant de diverses API et fichiers pour créer des rapports quotidiens

Considérations

  • Le portail Azure enregistre votre script en tant que fichier de script C# (.csx) dans le même dossier que votre fichier workflow.json, qui stocke la définition JSON de votre flux de travail et déploie le fichier dans votre ressource d’application logique, ainsi que la définition de flux de travail. Azure Logic Apps compile ce fichier pour préparer le script à l’exécution.

    Le format de fichier .csx vous permet d’écrire moins de « code réutilisable » et de vous concentrer sur l’écriture d’une fonction C#. Vous pouvez renommer le fichier .csx pour faciliter la gestion pendant le déploiement. Toutefois, chaque fois que vous renommez le script, la nouvelle version remplace la version précédente.

  • Le script est local dans le flux de travail. Pour utiliser le même script dans d’autres flux de travail, afficher le fichier de script dans la console KuduPlus, puis copier le script pour le réutiliser dans d’autres flux de travail.

Limites

Nom Limite Notes
Durée de l’exécution du script 10 minutes Si vous avez des scénarios qui nécessitent des durées plus longues, utilisez l’option de commentaires sur le produit pour fournir plus d’informations sur vos besoins.
Taille de sortie 100 Mo La taille de sortie dépend de la limite de taille de sortie pour les actions, qui est généralement de 100 Mo.

Ajouter l’action Exécuter le code de script CSharp

  1. Sur le portail Azure, ouvrez votre application logique Standard et votre flux de travail dans le concepteur.

  2. Dans le concepteur, suivez ces étapes générales pour ajouter l’action Opérations de code inline appelée Exécuter le code de script CSharp à votre flux de travail.

  3. Une fois le volet d’informations d’action ouvert, sous l’onglet Paramètres, dans la zone Fichier de code, mettez à jour l’exemple de code prérempli avec votre propre code de script.

    L’exemple suivant montre l’onglet Paramètres de l’action avec l’exemple de code de script :

    Capture d’écran montrant le portail Azure, le concepteur de flux de travail Standard, le déclencheur de requête, l’action Exécuter le code de script CSharp avec le volet d’informations ouvert et l’action Réponse. Le volet d’informations montre l’exemple de script C#.

    L’exemple suivant montre l’exemple de code de script :

    /// 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;}
}

    Pour plus d’informations, consultez « #r » - Référencer des assemblys externes.

  4. Lorsque vous avez terminé, enregistrez votre flux de travail.

Après avoir exécuté votre flux de travail, vous pouvez passer en revue la sortie du flux de travail dans Application Insights, s’il est activé. Pour plus d’informations, consultez Afficher les journaux dans Application Insights.

Importer des espaces de noms

Pour importer des espaces de noms, procédez ainsi avec la clause using comme d’habitude. La liste suivante inclut des espaces de noms importés automatiquement. Vous pouvez donc les inclure dans votre script :

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

Ajouter des références à des assemblys externes

Pour référencer des assemblys .NET Framework, utilisez la directive #r "<assembly-name>, par exemple :

/// 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
{
    <...>
}

La liste suivante inclut les assemblys automatiquement ajoutés par l’environnement d’hébergement Azure Functions :

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

Inclure d’autres fichiers .csx

Si vous avez des fichiers .csx existants, vous pouvez utiliser les classes et méthodes de ces fichiers dans votre action Exécuter le code de script CSharp . Pour cette tâche, vous pouvez utiliser la #load directive dans votre fichier execute_csharp_code.csx . Cette directive fonctionne uniquement avec les fichiers .csx, pas avec les fichiers .cs. Vous disposez des options suivantes :

  • Chargez un fichier .csx directement dans votre action.

    Le fichier .csx doit exister dans le même dossier que le workflow qui contient l’action Exécuter le code de script CSharp . Voir Charger .csx directement.

  • Référencez un fichier .csx qui existe dans un dossier partagé pour votre application logique.

    Le dossier partagé doit exister dans le chemin du site/wwwroot/ dossier de votre application logique. Consultez le fichier .csx de référence dans un dossier partagé.

Charger le fichier .csx directement

L’exemple suivant execute_csharp_code.csx montre comment charger un fichier de script nommé loadscript.csx dans une action Exécuter le code de script CSharp à l’aide de la #load directive :

// 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."
    };
}

Référencer le fichier .csx dans un dossier partagé

Vous pouvez utiliser la #load directive pour référencer un fichier .csx qui existe dans un dossier partagé pour votre ressource d’application logique. Ce dossier shared doit exister dans le chemin du dossier site/wwwroot/ de votre ressource d’application logique.

Pour ajouter le fichier de script au shared dossier, procédez comme suit :

  1. Dans le portail Azure, ouvrez votre ressource d’application logique Standard.

  2. Dans la barre latérale de l’application logique, sous Outils de développement, sélectionnez Outils avancés.

  3. Dans la page Outils avancés , sélectionnez Go, qui ouvre la console Kudu+ .

  4. Ouvrez le menu de la console de débogage, puis sélectionnez CMD.

  5. Accédez à l’emplacement racine de votre application logique : site/wwwroot

  6. Accédez au dossier partagé . Si ce dossier n’existe pas, créez le dossier.

    1. Dans la barre d’outils, en regard du nom du dossier, sélectionnez le signe plus (+), puis sélectionnez Nouveau dossier.

    2. Entrez shared comme nom du dossier.

    3. Ouvrez le nouveau shared dossier.

  7. Faites glisser le fichier de script pour l’importer dans le shared dossier.

L’exemple suivant execute_csharp_code.csx file montre comment référencer le fichier de script chargé nommé importcript.csx dans une action Exécuter le code de script CSharp à l’aide de la #load directive :

// 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." 
    }; 
}

Importer des packages NuGet

NuGet est un moyen pris en charge par Microsoft de créer, publier, héberger, découvrir, consommer et partager des bibliothèques de code .NET appelées packages. L’action Exécuter le code de script CSharp prend en charge la possibilité d’importer des packages NuGet à l’aide d’un fichier function.prof , situé à la racine du dossier de flux de travail, par exemple :

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

Par exemple, vous pouvez utiliser le fichier function.proj suivant pour importer des packages NuGet dans votre action Exécuter le code de script CSharp :

<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>

  • Pour un fichier de script C# (.csx), vous devez définir TargetFramework à netstandard2.0.

    Cette exigence ne signifie pas que les versions de package sont limitées à netstandard2.0. Vous pouvez toujours référencer des packages pour net6.0 et versions ultérieures.

  • Lorsque le fichier function.proj initialise, vous devez redémarrer l’application logique afin que le runtime Azure Logic Apps puisse reconnaître et consommer le fichier.

Une fois le redémarrage terminé, le runtime obtient automatiquement les assemblys requis de NuGet.org et place l’assembly dans le dossier approprié pour que votre script utilise. Bien que vous n’ayez pas besoin de charger manuellement ces assemblys, veillez à référencer directement les packages dans votre code à l’aide d’instructions standard using , par exemple :

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; }
}

Sortie du journal vers un flux

Dans votre méthode Run, incluez un paramètre avec type ILogger et log comme nom, par exemple :

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

Sortie de journal vers Application Insights

Pour créer des métriques personnalisées dans Application Insights, utilisez la méthode d’extension LogMetric sur ILogger.

L’exemple suivant montre un exemple d’appel de méthode :

logger.LogMetric("TestMetric", 1234);

Accéder aux sorties de déclencheur et d’action de flux de travail dans votre script

Pour accéder aux données à partir de votre flux de travail, utilisez les méthodes suivantes disponibles pour l’objet de contexte WorkflowContext :

  • Méthode GetTriggerResults

    Pour accéder aux sorties du déclencheur, utilisez cette méthode pour renvoyer un objet qui représente le déclencheur et ses sorties, qui sont disponibles via la propriété Outputs. Cet objet a le type JObject, et vous pouvez utiliser les crochets ([]) comme indexeur pour accéder à diverses propriétés dans les sorties du déclencheur.

    L’exemple suivant obtient les données de la propriété body dans les sorties du déclencheur :

    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
{
    <...>
}

  • Méthode GetActionResults

    Pour accéder aux sorties d’action, utilisez cette méthode pour renvoyer un objet qui représente l’action et ses sorties, qui sont disponibles via la propriété Outputs. Cette méthode accepte un nom d’action comme paramètre. L’exemple suivant obtient les données de la propriété body dans les sorties d’une action appelée nom-action :

    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
{
    <...>
}

Accéder aux variables d’environnement ou à la valeur du paramètre d’application

Pour obtenir une variable d’environnement ou une valeur de paramètre d’application, utilisez la méthode System.Environment.GetEnvironmentVariable, par exemple :

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);
}

Retourner des données à votre flux de travail

Pour cette tâche, implémentez votre méthode Run avec un type de retour et une instruction return. Si vous souhaitez une version asynchrone, implémentez la méthode Run avec un attribut Task<return-type> et le mot clé async. La valeur de retour est définie dans la propriété body des sorties de l’action de script, que toutes les actions de flux de travail suivantes peuvent ensuite référencer.

L’exemple suivant montre une méthode Run avec un attribut Task<Results>, le mot clé async et une instruction return :

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;}
}

Afficher le fichier de script

  1. Dans le portail Azure, ouvrez votre ressource d’application logique Standard avec le flux de travail souhaité.

  2. Dans la barre latérale de l’application logique, sous Outils de développement, sélectionnez Outils avancés.

  3. Dans la page Outils avancés, sélectionnez Go, qui ouvre la console KuduPlus.

  4. Ouvrez le menu de la console de débogage, puis sélectionnez CMD.

  5. Accédez à l’emplacement racine de votre application logique : site/wwwroot

  6. Accédez au dossier de votre workflow, qui contient le fichier .csx, le long de ce chemin : site/wwwroot/{workflow-name}

  7. En regard du nom de fichier, sélectionnez Modifier pour ouvrir et afficher le fichier.

Afficher les journaux d’activité dans Application Insights

  1. Dans le portail Azure, dans la barre latérale de l’application logique, sous Paramètres, sélectionnez Application Insights. Sélectionnez votre application logique.

  2. Dans la barre latérale Application Insights , sous Surveillance, sélectionnez Journaux.

  3. Créez une requête pour rechercher des traces ou des erreurs dans l’exécution de votre flux de travail, par exemple :

    union traces, errors
| project TIMESTAMP, message

Erreurs de compilation

Dans cette version, l’éditeur web inclut une prise en charge limitée d’IntelliSense, qui est toujours en cours d’amélioration. Toutes les erreurs de compilation sont détectées lorsque vous enregistrez votre flux de travail et que le runtime Azure Logic Apps compile votre script. Ces erreurs apparaissent dans les journaux d’erreurs de votre application logique.

Erreurs d’exécution

Si une erreur se produit lorsque votre script s’exécute, Azure Logic Apps effectue les étapes suivantes :

  • Transmet l’erreur à votre flux de travail.
  • Marque l’action de script comme Échec.
  • Fournit un objet d’erreur qui représente l’exception levée à partir de votre script.

L’exemple suivant illustre un exemple d’erreur :

La fonction « CSharp_MyLogicApp-InvalidAction_execute_csharp_script_code.csx » a échoué avec l’erreur « L’action "inexistante" n’existe pas dans le flux de travail. » lors de l’exécution. Vérifiez que le code de fonction est valide.

Exemples de scripts

Les exemples de scripts suivants effectuent différentes tâches que vous pouvez effectuer

Décompresser un fichier ZIP avec des fichiers texte d’une action HTTP dans un tableau de chaînes

// 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;
}

Chiffrer des données à l’aide d’une clé à partir des paramètres de l’application

// 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

Représente un contexte de flux de travail.

Méthodes

GetActionResult(string actionName)

Obtient le résultat d’une action spécifique dans le flux de travail.

La version asynchrone utilise Tâche<> comme type de retour, par exemple :

Task<WorkflowOperationResult> GetActionResult(string actionName)

Paramètres

actionName: nom de l’action.

Retours

La version asynchrone retourne un objet Task qui représente l’opération asynchrone. Le résultat de la tâche contient un objet WorkflowOperationResult. Pour plus d’informations sur les propriétés de l’objet WorkflowOperationResult, consultez classe WorkflowOperationResult.

RunTriggerResult()

Obtient le résultat du déclencheur dans le flux de travail.

La version asynchrone utilise Tâche<> comme type de retour, par exemple :

Task<WorkflowOperationResult> RunTriggerResult()

Paramètres

Aucun.

Retours

La version asynchrone retourne un objet Task qui représente l’opération asynchrone. Le résultat de la tâche contient un objet WorkflowOperationResult. Pour plus d’informations sur les propriétés de l’objet WorkflowOperationResult, consultez classe WorkflowOperationResult.

Classe WorkflowOperationResult

Représente le résultat d’une opération de flux de travail.

Propriétés

Nom Type Description
Nom String Obtient ou définit le nom de l’opération.
Entrées JToken Obtient ou définit les entrées d’exécution de l’opération.
Sorties JToken Obtient ou définit les sorties d’exécution de l’opération.
StartTime DateTime? Obtient ou définit l’heure de début de l’opération.
EndTime DateTime? Obtient ou définit l’heure de fin de l’opération.
OperationTrackingId String Obtient ou définit l’ID de suivi des opérations.
Code String Obtient ou définit le code d’état de l’action.
État String Obtient ou définit l’état de l’action.
Error JToken Obtient ou définit l’erreur pour l’action.
TrackedProperties JToken Obtient ou définit les propriétés suivies pour l’action.

Contenu connexe

Ajouter et exécuter des extraits de code JavaScript

  • Last updated on