Creare ed eseguire codice .NET dai flussi di lavoro Standard in App per la logica di Azure usando Visual Studio Code

Si applica a: App per la logica di Azure (Standard)

Quando lo scenario di integrazione richiede attività o logica personalizzate oltre le operazioni e i connettori predefiniti in App per la logica di Azure, creare ed eseguire codice .NET come funzioni custom nei flussi di lavoro Standard. Il flusso di lavoro può quindi eseguire attività come l'analisi personalizzata, la convalida o anche l'applicazione di regole business. Usando questa funzionalità, è possibile implementare scenari come le attività seguenti:

Personalizzare l'implementazione della logica di business.
Personalizzare l'analisi per estrarre informazioni da un messaggio in ingresso.
Eseguire la convalida dei dati e le trasformazioni semplici.
Eseguire calcoli.
Modellare i messaggi in uscita inviati a un altro sistema, ad esempio un'API.

Questa guida illustra come scrivere ed eseguire codice .NET direttamente nei flussi di lavoro Standard usando Visual Studio Code. Si apprenderà come creare, eseguire il debug e distribuire funzioni locali usando Visual Studio Code in modo da poter mantenere insieme codice personalizzato e orchestrazione del flusso di lavoro, eseguirne il debug in una sessione e distribuirli come singola soluzione.

Note

Il codice personalizzato .NET inline non è adatto per gli scenari seguenti:

Esecuzione di processi che potrebbero superare i 10 minuti.
Tentativo di effettuare trasformazioni di grandi dimensioni su messaggi e dati.
Esecuzione di scenari complessi di batching e debatching.
Uso dei componenti della pipeline di BizTalk Server che implementano lo streaming.

Per altre informazioni, vedere Limitazioni.

Prerequisiti

Un account e una sottoscrizione Azure. Get a free Azure account.
L'Visual Studio Code più recente con l'estensione App per la logica di Azure (Standard).

Per i prerequisiti, vedere Creare flussi di lavoro Standard in App per la logica di Azure a tenant singolo con Visual Studio Code.

L'estensione offre le funzionalità e i vantaggi seguenti:
- Scrivere codice personalizzato creando funzioni con flessibilità e controllo per risolvere i problemi di integrazione più complessi.
- Eseguire il debug del codice in locale in Visual Studio Code. Eseguire il codice e i flussi di lavoro nella stessa sessione di debug.
- Distribuire il codice insieme ai flussi di lavoro. Non sono necessari altri piani di servizio.
- Supportare gli scenari di migrazione di BizTalk Server in modo da consentire il trasferimento diretto di investimenti personalizzati .NET dall'ambiente locale al cloud.
Una cartella locale da usare per il progetto di sviluppo.

Limitazioni

È possibile usare la funzionalità delle funzioni personalizzate solo in Visual Studio Code in esecuzione in Windows. Questa funzionalità supporta l'uso di .NET Framework e .NET 8 per i flussi di lavoro delle app per la logica Standard distribuiti e ospitati in Azure.
Non è possibile usare la creazione di funzioni personalizzate sul portale di Azure. Tuttavia, per usare gli output delle funzioni personalizzate nel flusso di lavoro, seguire questa procedura:
1. Dopo aver distribuito le funzioni in Azure, seguire la procedura descritta in Callare il codice da un flusso di lavoro per il portale di Azure.
2. Aggiungere l'azione predefinita denominata Chiamare una funzione locale in questa app per la logica al flusso di lavoro. Selezionare le funzioni personalizzate distribuite desiderate ed eseguire il codice.
3. Utilizzare le azioni successive del flusso di lavoro per fare riferimento agli output delle funzioni personalizzate, proprio come in qualsiasi altro flusso di lavoro. È possibile visualizzare la cronologia di esecuzione, gli input e gli output dell'azione predefinita.

Per le limitazioni generali, vedere Limits e informazioni di riferimento sulla configurazione per App per la logica di Azure.

1: Creare un progetto di codice

L'estensione App per la logica di Azure (Standard) per Visual Studio Code include un modello di progetto di codice che offre un'esperienza semplificata per la scrittura, il debug e la distribuzione di codice personalizzato con i flussi di lavoro. Questo modello di progetto crea un file dell'area di lavoro e due progetti di esempio: un progetto per scrivere il codice e un altro progetto per creare i flussi di lavoro.

Note

Non è possibile usare la stessa cartella di progetto sia per il codice che per i flussi di lavoro.

Per creare un progetto di codice, seguire questa procedura:

In Visual Studio Code, accedi al tuo account Azure.

Se l'accesso richiede più tempo del solito, Visual Studio Code richiede di accedere tramite un sito Web di autenticazione Microsoft fornendo un codice del dispositivo. Per accedere usando invece il codice, seguire questa procedura:
1. Selezionare Usa codice dispositivo e quindi copia e apri.
2. Selezionare Apri collegamento per aprire una nuova finestra del browser e passare al sito Web di autenticazione.
3. Nella pagina Accesso all'account immettere il codice di autenticazione e selezionare Avanti.
Sulla barra delle attività selezionare l'icona Azure.
Nella finestra Azure passare alla sezione Workspace. Spostare il puntatore sull'area del titolo in modo che venga visualizzata la barra degli strumenti.
Dal menu App per la logica di Azure selezionare Crea nuova area di lavoro per l'app per la logica.
Nella finestra Seleziona cartella passare alla cartella del progetto locale, selezionare la cartella e quindi Selezionare.
Nella finestra Crea nuova area di lavoro per l'app logica, al prompt Nome area di lavoro, immettere un nome per l'area di lavoro e quindi premere INVIO.

Questo esempio usa weather-app come nome dell'area di lavoro:

In questo esempio viene weather-project usato come nome dell'area di lavoro.
Per il prompt Selezionare un modello per il nuovo progetto, selezionare App logica con codice personalizzato.
Per il prompt Selezionare un framework di destinazione, selezionare .NET Framework o .NET 8.

Seguire le istruzioni successive per fornire le informazioni seguenti:

Rapido	Valore di esempio
Nome dell'app per la logica	`weather-logic-app`
Nomefunzione per il progetto di funzioni di .NET	`WeatherForecast`
Namespace per il progetto di funzioni di .NET	`Contoso.Enterprise`
Selezionare un modello per il primo flusso di lavoro del progetto: - Flusso di lavoro con stato - Flusso di lavoro senza stato - Agente autonomo - Agente conversazionale - Ignorare per il momento	Flusso di lavoro con stato
Nome flusso di lavoro	`weather-workflow`

Per Selezionare la modalità di apertura del prompt del progetto , selezionare Apri nella finestra corrente.

Al termine di questo passaggio, Visual Studio Code crea l'area di lavoro, che include un progetto di funzioni .NET e un progetto di app per la logica, ad esempio:

Screenshot mostra l'area di lavoro creata con il progetto di app logica e il progetto di funzioni .NET.

Nella finestra Explorer prendere nota delle cartelle seguenti nell'area di lavoro:

Folder	Descrizione
< nome dell'area di lavoro>	Contiene sia il progetto di funzioni .NET che il progetto di flusso di lavoro dell'app logica.
< logic-app-name>	Contiene i file e altri elementi per il progetto dell'applicazione logica. Ad esempio, il file diworkflow.json è il file di definizione del flusso di lavoro in cui è possibile compilare il flusso di lavoro.
< function-name>	Contiene i file e altri artefatti per il progetto di funzioni .NET. Ad esempio, il <file function-name>.cs è il file di codice in cui è possibile creare il codice.

Per l'indicazione Abilita connettori per Azure per Logic Apps <logic-app-name>, selezionare Usa connettori da Azure.
Per il prompt Selezionare la sottoscrizione selezionare la sottoscrizione Azure desiderata.
Per il prompt Selezionare un gruppo di risorse per le nuove risorse , selezionare il gruppo di risorse desiderato o Crea nuovo gruppo di risorse.
Per il prompt Selezionare una posizione per le nuove risorse selezionare l'area Azure per la distribuzione.

Per il metodo di autenticazione Selezionare il metodo di autenticazione per i connettori Azure, selezionare il tipo di autenticazione da usare per le connessioni che richiedono l'autenticazione.

Tipo di autenticazione	Descrizione
Identità gestita	Selezionare Identità del servizio gestita per usare l'identità assegnata dal sistema o assegnata dall'utente nella risorsa dell'app per la logica. Per impostazione predefinita, le risorse dell'app per la logica Standard hanno già l'identità assegnata dal sistema abilitata. Tuttavia, è necessario configurare l'identità con l'accesso al ruolo nella risorsa di destinazione e qualsiasi altro requisito. Per altre informazioni, vedere Assegnare l'accesso basato sui ruoli a un'identità gestita.
Chiavi di connessione	Configurare l'accesso alla risorsa di destinazione usando stringhe di connessione e chiavi di accesso.

Tipo di autenticazione

Descrizione

Identità gestita

Selezionare Identità del servizio gestita per usare l'identità assegnata dal sistema o assegnata dall'utente nella risorsa dell'app per la logica.

Per impostazione predefinita, le risorse dell'app per la logica Standard hanno già l'identità assegnata dal sistema abilitata. Tuttavia, è necessario configurare l'identità con l'accesso al ruolo nella risorsa di destinazione e qualsiasi altro requisito.

Per altre informazioni, vedere Assegnare l'accesso basato sui ruoli a un'identità gestita.

Chiavi di connessione

Configurare l'accesso alla risorsa di destinazione usando stringhe di connessione e chiavi di accesso.

Dopo aver completato questi passaggi, passare alla sezione successiva in modo da poter creare il codice.

2: Scrivere il codice

Nella finestra Esplora file, espandere la cartella del progetto della funzione e aprire il file <function-name>.cs.

Questo file contiene codice di esempio ed elementi di codice specifici con valori specificati in precedenza.

In questo esempio, il file di funzione WeatherForecast.cs contiene questi elementi di codice con valori di esempio:

Elemento di codice	Valore
Nome spazio dei nomi	`Contoso.Enterprise`
Nome della classe	`WeatherForecast`
Nome della funzione	`WeatherForecast`
Parametri di funzione	`zipcode`, `temperatureScale`
Tipo restituito	`Task`
Tipo complesso	`Weather`

L'esempio seguente mostra il codice di esempio completo:

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------

namespace Contoso.Enterprise
{
    using System;
    using System.Collections.Generic;
    using System.Threading.Tasks;
    using Microsoft.Azure.Functions.Extensions.Workflows;
    using Microsoft.Azure.WebJobs;
    using Microsoft.Extensions.Logging;

    /// <summary>
    /// Represents the WeatherForecast flow invoked function.
    /// </summary>
    public class WeatherForecast
    {

        private readonly ILogger<WeatherForecast> logger;

        public WeatherForecast(ILoggerFactory loggerFactory)
        {
            logger = loggerFactory.CreateLogger<WeatherForecast>();
        }

        /// <summary>
        /// Executes the logic app workflow.
        /// </summary>
        /// <param name="zipCode">The zip code.</param>
        /// <param name="temperatureScale">The temperature scale (e.g., Celsius or Fahrenheit).</param>
        [FunctionName("WeatherForecast")]
        public Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale)
        {

            this.logger.LogInformation("Starting WeatherForecast with Zip Code: " + zipCode + " and Scale: " + temperatureScale);

            // Generate random temperature within a range based on the temperature scale
            Random rnd = new Random();
            var currentTemp = temperatureScale == "Celsius" ? rnd.Next(1, 30) : rnd.Next(40, 90);
            var lowTemp = currentTemp - 10;
            var highTemp = currentTemp + 10;

            // Create a Weather object with the temperature information
            var weather = new Weather()
            {
                ZipCode = zipCode,
                CurrentWeather = $"The current weather is {currentTemp} {temperatureScale}",
                DayLow = $"The low for the day is {lowTemp} {temperatureScale}",
                DayHigh = $"The high for the day is {highTemp} {temperatureScale}"
            };

            return Task.FromResult(weather);
        }

        /// <summary>
        /// Represents the weather information for WeatherForecast.
        /// </summary>
        public class Weather
        {
            /// <summary>
            /// Gets or sets the zip code.
            /// </summary>
            public int ZipCode { get; set; }

            /// <summary>
            /// Gets or sets the current weather.
            /// </summary>
            public string CurrentWeather { get; set; }

            /// <summary>
            /// Gets or sets the low temperature for the day.
            /// </summary>
            public string DayLow { get; set; }

            /// <summary>
            /// Gets or sets the high temperature for the day.
            /// </summary>
            public string DayHigh { get; set; }
        }
    }
}

La definizione della funzione include un metodo predefinito Run che è possibile usare per iniziare. Questo esempio Run metodo illustra alcune funzionalità disponibili con la funzionalità di funzioni personalizzate, ad esempio il passaggio di input e output diversi, inclusi i tipi di .NET complessi.

Il < file function-name>.cs include anche l'interfaccia ILogger che fornisce il supporto per la registrazione degli eventi in una risorsa di Application Insights. È possibile inviare informazioni di traccia ad Application Insights e archiviare tali informazioni con le informazioni di traccia dei flussi di lavoro, ad esempio:

private readonly ILogger<WeatherForecast> logger;

public WeatherForecast(ILoggerFactory loggerFactory)
{
    logger = loggerFactory.CreateLogger<WeatherForecast>();
}

[FunctionName("WeatherForecast")]
public Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale)
{

    this.logger.LogInformation("Starting WeatherForecast with Zip Code: " + zipCode + " and Scale: " + temperatureScale);

    <...>

}

Sostituire il codice della funzione di esempio con il proprio e modificare il metodo predefinito Run per gli scenari specifici. In alternativa, è possibile copiare la funzione, inclusa la dichiarazione [FunctionName("<function-name>")], e quindi rinominare la funzione con un nome univoco. È quindi possibile modificare la funzione rinominata per soddisfare le proprie esigenze.

Questo esempio continua con il codice di esempio originale, presupponendo che non vengano apportate modifiche.

3: Compilare e creare il codice

Dopo aver completato la scrittura del codice, compilarlo per assicurarsi che non esistano errori di compilazione. Il progetto di funzioni di .NET include automaticamente attività di compilazione, che compilano e aggiungono il codice alla cartella lib\custom nel progetto dell'app per la logica in cui i flussi di lavoro cercano funzioni personalizzate da eseguire. A seconda della versione .NET, queste attività inseriscono gli assembly nella cartella lib\custom\net472 o lib\custom\net8.

Segui questi passaggi:

Nella barra delle attività in Visual Studio Code selezionare Explorer.
Nella finestra Esplora risorse aprire il menu di scelta rapida per la cartella del progetto funzioni e selezionare Compila progetto funzioni.

L'attività di compilazione viene eseguita per il progetto delle funzioni. Se la compilazione ha esito positivo, nella finestra Terminale viene visualizzato un messaggio Di compilazione completata .
Verificare che nel progetto dell'app per la logica siano presenti gli elementi seguenti:
- Nell'area di lavoro, espandi le seguenti cartelle: <your-logic-app>>lib\custom>net472 o net8, in base alla versione .NET. Verificare che la sottocartella denominata net472 o net8 contenga i file assembly (DLL) necessari per eseguire il codice, incluso un file denominato <nome> funzione.dll.
- Nell'area di lavoro, espandi le cartelle seguenti: lib\customfunction-name della tua app per la logica. Verificare che la sottocartella denominata <function-name> contenga un file function.json, che include i metadati relativi al codice della funzione scritto. La finestra di progettazione del flusso di lavoro usa questo file per determinare gli input e gli output necessari quando si chiama il codice.
L'esempio seguente mostra gli assembly di esempio generati e altri file nel progetto dell'app per la logica:

4: Chiamare il codice da un flusso di lavoro

Dopo aver verificato che il codice sia compilato e che il progetto dell'applicazione logica contenga i file necessari affinché il codice possa essere eseguito, configurare il flusso di lavoro per invocare il codice.

Nella finestra Explorer espandere <workspace-name>, <logic-app-name> e quindi <workflow-name>.

Aprire il menu di scelta rapida per workflow.jsone selezionare Apri finestra di progettazione.

La finestra di progettazione del flusso di lavoro viene aperta e mostra il flusso di lavoro predefinito con il trigger e le azioni seguenti:

Operation	Descrizione
Attivatore	Trigger di richiesta predefinito denominato Quando viene ricevuta una richiesta HTTP.
Action	Azione predefinita denominata Chiamare una funzione locale in questa app per la logica.
Action	Azione di risposta predefinita denominata Response usata per rispondere al chiamante solo quando si usa il trigger Richiesta .

Nella finestra di progettazione, selezionare l'azione denominata Chiama una funzione locale in questa logic app.

Viene aperto il riquadro informazioni dell'azione in modo da poter configurare la chiamata di funzione personalizzata, ad esempio:
Verificare e verificare che il valore del parametro Nome funzione sia impostato sulla funzione da eseguire. Esaminare o modificare qualsiasi altro valore di parametro usato dalla funzione.

5: Eseguire il debug del codice e del flusso di lavoro

Per ognuno dei servizi di Archiviazione di Azure seguenti, avviare l'emulatore di archiviazione Azurite:
- Servizio Blob di Azure
- servizio di coda di Azure
- Servizio Tabelle di Azure
1. Dal menu Visual Studio Code View selezionare Riquadro comandi.
2. Al prompt visualizzato selezionare Azurite: Avvia servizio BLOB dall'elenco.
3. Nell'elenco delle directory di lavoro visualizzato, selezionare l'applicazione logica.
4. Ripetere questi passaggi per Azurite: Avvia Servizio di accodamento e Azurite: Avvia Servizio tabelle.
Se l'operazione ha esito positivo, la barra delle applicazioni Visual Studio Code nella parte inferiore della schermata mostra i tre servizi di archiviazione in esecuzione.
Collegare il debugger al progetto dell'app logica e al progetto di funzioni .NET seguendo questi passaggi:
1. Nella barra delle attività in Visual Studio Code selezionare Esegui e debug (tastiera: CTRL+MAIUSC+D).
2. Nell'elenco Esegui e debug selezionare Esegui/debug app per la logica con funzione locale (la tua app per la logica) e quindi selezionare Avvia (freccia verde).
  
  Si verificano gli eventi seguenti:
  - Viene visualizzata la finestra Terminale e viene visualizzato il processo di debug avviato.
  - La finestra Console di debug viene aperta e mostra lo stato di debug.
  - Nella parte inferiore di Visual Studio Code la barra delle applicazioni diventa arancione, a indicare che il debugger .NET è caricato.
Per impostare eventuali punti di interruzione, nella definizione della funzione (<nome-funzione>.cs) o nella definizione del flusso di lavoro (workflow.json), trovare il numero di riga in cui si desidera il punto di interruzione e selezionare la colonna adiacente, ad esempio:
Per eseguire manualmente il trigger Richiesta nel flusso di lavoro, aprire la pagina Panoramica del flusso di lavoro:
1. Dal progetto del Logic App, apri il menu di scelta rapida del file workflow.json e seleziona quindi Panoramica.
  
  Nella pagina Panoramica del flusso di lavoro, il pulsante Esegui trigger è disponibile per quando si vuole avviare manualmente il flusso di lavoro. In Proprietà flusso di lavoro, il valore dell'URL di callback è l'URL di un endpoint chiamabile creato dal trigger Richiesta nel flusso di lavoro. È possibile inviare richieste a questo URL per attivare il flusso di lavoro da altre app, inclusi altri flussi di lavoro dell'app per la logica.
2. Nella barra degli strumenti della pagina Panoramica, selezionare Esegui trigger.
  
  Dopo l'avvio dell'esecuzione del flusso di lavoro, il debugger attiva il primo punto di interruzione.
3. Nel menu Esegui o nella barra degli strumenti del debugger, selezionare un' azione di debug.
Al termine dell'esecuzione del flusso di lavoro, la pagina Panoramica mostra l'esecuzione completata e i dettagli di base sull'esecuzione.
Per esaminare altre informazioni sull'esecuzione del flusso di lavoro, selezionare l'esecuzione completata. In alternativa, nell'elenco accanto alla colonna Durata, selezionare Mostra esecuzione.

La screenshot mostra Visual Studio Code e l'esecuzione del flusso di lavoro completata.

6: Distribuire il codice

Distribuire le funzioni personalizzate nello stesso modo in cui si distribuisce il progetto di app per la logica. Indipendentemente dal fatto che si distribuisca da Visual Studio Code o si usi un processo DevOps CI/CD, assicurarsi di compilare il codice prima di distribuirlo. Assicurarsi inoltre che tutti gli assembly dipendenti esistano nella seguente cartella del progetto dell'app per la logica prima della distribuzione:

.NET 4.7.2: cartella lib/custom/net472
.NET 8: cartella lib/custom/net8

Per altre informazioni, vedere flussi di lavoro Deploy Standard da Visual Studio Code a Azure.

Risolvere i problemi

Errore del riquadro informazioni azione

Nella finestra di progettazione del flusso di lavoro, quando si seleziona l'azione predefinita denominata Chiamare una funzione locale in questa app per la logica, il riquadro delle informazioni dell'azione mostra il messaggio seguente:

Failed to retrieve dynamic inputs. Error details:

In questo scenario controllare il progetto dell'app per la logica per verificare se la cartella LogicApp\lib\custom è vuota. Se è vuoto, dal menu Terminale selezionare Esegui attività>Compila funzioni.

Attualmente non sono in esecuzione processi con il nome specificato

Se viene visualizzato questo messaggio di errore quando si esegue il flusso di lavoro, è probabile che il processo del debugger sia collegato a funzioni di .NET anziché all'app per la logica.

Per risolvere il problema, dall'elenco Avvia ed esegui debug, selezionare Collega all'app per la logica (LogicApp) e quindi selezionare Riproduci (triangolo verde).

Pacchetto non importato correttamente

Se nella finestra Output viene visualizzato un errore simile al messaggio seguente, assicurarsi di avere almeno .NET 6.0 installato. Se questa versione è installata, provare a disinstallare e reinstallare.

C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.targets(83,5): warning : The ExtensionsMetadataGenerator package was not imported correctly. Are you missing 'C:\Users\yourUserName\.nuget\packages\microsoft.azure.webjobs.script.extensionsmetadatagenerator\4.0.1\build\Microsoft.Azure.WebJobs.Script.ExtensionsMetadataGenerator.targets' or 'C:\Users\yourUserName\.nuget\packages\microsoft.azure.webjobs.script.extensionsmetadatagenerator\4.0.1\build\Microsoft.Azure.WebJobs.Script.ExtensionsMetadataGenerator.props'? [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] WeatherForecast -> C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\\bin\Debug\net472\WeatherForecast.dll C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : It was not possible to find any compatible framework version [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : The specified framework 'Microsoft.NETCore.App', version '6.0.0' was not found. [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj] C:\Users\yourUserName\.nuget\packages\microsoft.net.sdk.functions\4.2.0\build\Microsoft.NET.Sdk.Functions.Build.targets(32,5): error : - Check application dependencies and target a framework version installed at: [C:\Desktop\...\custom-code-project\MyLogicAppWorkspace\Function\WeatherForecast.csproj]

Errori di compilazione

Se la funzione non include variabili e si compila il codice, la finestra Output potrebbe mostrare i messaggi di errore seguenti:

C:\Users\yourUserName\...\custom-code-project\Function\func.cs (24,64): error CS1031: Type expected [C:\Users\yourUserName\...\custom-code-project\Function\func.csproj]
C:\Users\yourUserName\...\custom-code-project\Function\func.cs (24,64): error CS1001: Identifier expected [C:\Users\yourUserName\...\custom-code-project\Function\func.csproj]

Build FAILED.

0 Warning(s)
2 Error(s)

Per risolvere questo problema, nel metodo Run del codice, aggiungere il parametro seguente:

string parameter1 = null

L'esempio seguente mostra come viene visualizzata la firma del metodo Run:

public static Task<Weather> Run([WorkflowActionTrigger] int zipCode, string temperatureScale, string parameter1 = null)

Creare flussi di lavoro per applicazioni logiche standard con Visual Studio Code

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-04-08