> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/it/sviluppo/debugging-scripts.md).

# Debug degli script

Esegua il debug degli script di PowerShell Universal utilizzando Wait-Debugger, la console del debugger integrata o Visual Studio Code tra job, app e API.

Gli script eseguiti all'interno di Universal vengono eseguiti all'interno di processi in background o runspace, il che può rendere difficile il debug di ciò che accade all'interno di uno script. È possibile utilizzare cmdlet come Write-Debug e Write-Verbose per fornire maggiori informazioni nei log per app e job.

## Debugger remoto di Visual Studio

Utilizzando l'[estensione PowerShell Universal per Visual Studio Code](/powershell-universal/it/sviluppo/visual-studio-code-extension.md), è possibile connettersi direttamente agli script PowerShell in esecuzione in PowerShell Universal.

## Debugger integrato

{% hint style="warning" %}
Il debugger integrato è supportato in PowerShell 7 e negli ambienti integrati. Non è supportato in Windows PowerShell.
{% endhint %}

Il debugger integrato consente di accedere a una console di debug per gli script in esecuzione. È possibile includere la chiamata al cmdlet `Wait-Debugger` negli script e questi passeranno allo stato In Breakpoint. Una volta che ciò avviene, è possibile visualizzare il Job per eseguire comandi sullo script.

### Script

PowerShell Universal si integra direttamente con il debugger di PowerShell. È possibile includere `Wait-Debugger` negli script per farli mettere in pausa.

Ad esempio, si supponga di avere uno script che include una chiamata `Wait-Debugger`. La prima riga verrà eseguita e poi lo script si metterà in pausa una volta raggiunta la seconda riga.

<pre class="language-powershell"><code class="lang-powershell"><strong>$Processes = Get-Process
</strong><strong>Wait-Debugger
</strong></code></pre>

Una volta che uno script è in pausa, verrà visualizzato un terminale per il debug dello script.

È quindi possibile utilizzare i comandi di debug integrati per procedere passo a passo nello script.

### App

È possibile utilizzare `Wait-Debugger` direttamente nelle app di PowerShell Universal. È possibile includere questo comando in gestori di eventi e dinamiche per mettere in pausa l'esecuzione dell'app e valutare lo stato corrente dello script.

Ad esempio, è possibile includere `Wait-Debugger` in una dinamica.

```powershell
New-UDApp -Title 'PowerShell Universal' -Content {
     New-UDDynamic -Id 'dynamic' -Content {
        Wait-Debugger
        New-UDTypography "Loaded"
    } -LoadingComponent {
        New-UDSkeleton
    }
}
```

Il risultato è che l'app visualizzerà lo scheletro di caricamento perché il debugger di PowerShell si trova in un breakpoint.

All'interno della console di amministrazione, è possibile fare clic sulla scheda Debugger per visualizzare i breakpoint correnti su cui l'app è in attesa. Il debugger fornisce un terminale per valutare comandi sul runspace. È possibile utilizzare qualsiasi comando PowerShell standard. È inoltre possibile utilizzare gli strumenti di debug come l'esecuzione passo a passo e l'elenco del codice sorgente. Nella parte superiore della console sono disponibili alcuni pulsanti.

È possibile utilizzare comandi come `Get-Variable` per ottenere informazioni sullo stato delle variabili. Eseguire `c` per consentire all'endpoint di continuare l'esecuzione.

## Registrazione degli script

Alcuni aspetti di Universal registrano automaticamente i propri script. Altre funzionalità potrebbero richiedere di effettuare la registrazione manualmente.

### API

È possibile utilizzare la vista Live Log nella scheda Log per visualizzare i log dell'API selezionata.

### Job

I job registrano in modo estensivo. Verranno visualizzati l'output della console e della pipeline. Se si impostano `$DebugPreference` o `$VerbosePreference`, tali stream verranno visualizzati anche nell'output della console. È possibile aggiungere ulteriori messaggi di log utilizzando `Write-Debug` o `Write-Verbose`.

### App

Le app registrano nel proprio log messaggi informativi, di avviso e di errore. Si consiglia di utilizzare la registrazione all'avvio di un'app piuttosto che tentare di collegare un debugger. È inoltre possibile utilizzare la variabile `$DebugPreference` per ottenere informazioni aggiuntive durante l'avvio dell'app.

```powershell
$DebugPreference = 'Continue'

New-UDApp -Title 'Test' -Content {
    Write-Debug "My app is loading. I have am $user with $roles"

    New-UDTypography -Text 'Hello, world'
}
```

### Autenticazione e autorizzazione

È possibile utilizzare la vista Live Log nelle pagine di autenticazione e dei ruoli per visualizzare l'output degli stream di PowerShell.

## Debug degli script da una console PowerShell

È possibile eseguire il debug di qualsiasi script all'interno di Universal (o di qualsiasi processo PowerShell, in realtà) utilizzando i cmdlet di debug disponibili in PowerShell. Questi cmdlet consentono di connettersi a processi PowerShell locali, come Universal, e di procedere passo a passo negli script direttamente nel terminale.

### Messa in pausa dello script

Innanzitutto, è necessario assicurarsi che lo script attenda il collegamento del debugger prima di continuare. Ciò significa che sarà necessario includere un comando `Wait-Debugger` da qualche parte nello script.

{% hint style="info" %}
Le app attendono solo 10 secondi durante l'avvio, pertanto inserire un Wait-Debugger al loro interno potrebbe non funzionare. È opportuno affidarsi all'uso di $DebugPreference e Write-Debug per diagnosticare i problemi di avvio delle app.
{% endhint %}

### Esecuzione dello script

Ora che lo script è configurato per mettersi in pausa e attendere il debugger, si vorrà eseguire lo script. Per i job, è sufficiente avviare il job. Per le API, sarà necessario effettuare una richiesta all'API tramite l'endpoint che si desidera testare. Per le app, sarà necessario caricare la pagina nel browser. Per l'autenticazione e l'autorizzazione, sarà necessario effettuare l'accesso.

### Individuazione dell'ID del processo

Una volta inserito il comando `Wait-Debugger` nello script di cui si desidera eseguire il debug, sarà necessario avviare lo script e determinare il processo all'interno del quale è in esecuzione.

#### Job

I job vengono eseguiti nel proprio processo isolato all'interno di Universal. È sufficiente avviare il job: verrà avviato il processo che attenderà in corrispondenza del comando `Wait-Debugger`. Una volta avviato il job, è possibile utilizzare il cmdlet `Get-UAJob` per individuare l'ID del processo di tale job.

#### API

Le API vengono eseguite in un unico processo PowerShell. Non viene avviato un nuovo processo per ogni chiamata API. È possibile individuare il processo dell'API cercando il processo pwsh o PowerShell la cui riga di comando include `StartApi`.

#### App

Le app vengono eseguite in un proprio processo PowerShell isolato. L'ID del processo è elencato nella tabella delle app all'interno della console di amministrazione.

#### Autenticazione e autorizzazione

Gli script di autenticazione e autorizzazione vengono eseguiti all'interno del server Universal. È possibile individuare il processo `Universal.Server.exe` e collegarsi a quello.

**Ambiente integrato**

Qualsiasi funzionalità in esecuzione all'interno dell'ambiente integrato verrà eseguita all'interno del processo `Universal.Server.exe`. Sarà necessario collegarsi a questo processo per eseguirne il debug.

### Collegamento al processo e debug del runspace

Una volta individuato il processo al quale si desidera collegarsi, è possibile farlo utilizzando `Enter-PSHostProcess`. È sufficiente specificare l'ID del processo individuato nel passaggio precedente.

```powershell
Enter-PSHostProcess -id 1231
```

{% hint style="info" %}
Enter-PSHostProcess utilizza named pipe e richiede di disporre dell'autorizzazione per il processo al quale si accede. Se si esegue Universal come servizio, potrebbe essere necessario eseguirlo con il proprio account locale per connettersi correttamente al processo.
{% endhint %}

Una volta collegati al processo, si vorrà individuare il runspace in cui è in esecuzione il codice. Per farlo, è possibile utilizzare il cmdlet `Get-Runspace`. Questo restituirà un elenco dei runspace attualmente attivi nel processo. Cercare il runspace contrassegnato come `InBreakpoint`. Si tratta del runspace in attesa in corrispondenza del comando `Wait-Debugger`.

Ora che è stato individuato il runspace, utilizzare `Debug-Runspace` per collegarsi al runspace. Si avrà quindi la possibilità di impartire comandi di debug su tale runspace. È possibile visualizzare lo stato delle variabili, impartire comandi e persino procedere passo a passo nello script.

Per un elenco completo dei comandi di debug, è possibile consultare la [documentazione Microsoft qui](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_debuggers?view=powershell-7#starting-and-stopping-the-debugger).

### Esempio di connessione a un processo API

Di seguito è riportato un esempio di come connettersi a un processo API.

```powershell
$Process = Get-Process pwsh | Where-Object { $_.CommandLine.Contains('StartApi') }
Enter-PSHostProcess -Id $Process.Id
Get-Runspace
Debug-Runspace -Id 2
```

## Debug con Visual Studio Code

Per eseguire il debug di uno script, è possibile utilizzare il cmdlet Wait-Debugger all'interno dello script per mettere in pausa lo script fino al collegamento di un debugger. È quindi possibile utilizzare un debugger, come VS Code, per collegarsi al processo e al runspace al fine di visualizzare le variabili, procedere passo a passo nel codice ed eseguire comandi di debug.

È inoltre possibile eseguire il debug degli script utilizzando i cmdlet integrati `Enter-PSHostProcess`, `Get-Runspace` e `Debug-Runspace`.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.devolutions.net/powershell-universal/it/sviluppo/debugging-scripts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.