> 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/da/udvikling/debugging-scripts.md).

# Fejlfinding af scripts

Fejlfind scripts i PowerShell Universal ved hjælp af Wait-Debugger, den integrerede debuggerkonsol eller Visual Studio Code på tværs af jobs, apps og API'er.

Scripts, der kører i Universal, kører i baggrundsprocesser eller runspaces, hvilket kan gøre det svært at fejlfinde, hvad der sker i et script. De kan bruge cmdlets som Write-Debug og Write-Verbose til at give flere oplysninger i logfiler for apps og job.

## Visual Studio Remote Debugger

Ved hjælp af PowerShell [Universal Visual Studio Code-udvidelsen](/powershell-universal/da/udvikling/visual-studio-code-extension.md) kan De oprette forbindelse direkte til Deres PowerShell-scripts, der kører i PowerShell Universal.

## Integreret debugger

{% hint style="warning" %}
Den integrerede debugger understøttes i PowerShell 7 og integrerede miljøer. Den understøttes ikke i Windows PowerShell.
{% endhint %}

Den integrerede debugger giver mulighed for adgang til en fejlfindingskonsol til kørsel af scripts. De kan inkludere cmdlet-opkaldet `Wait-Debugger` i Deres scripts, og de overgår til tilstanden In Breakpoint. Når dette finder sted, kan De få vist jobbet for at køre kommandoer mod scriptet.

### Scripts

PowerShell Universal integrerer direkte med PowerShell-debuggeren. De kan medtage `Wait-Debugger` i Deres scripts, så de sættes på pause.

Antag for eksempel, at De har et script med et inkluderet `Wait-Debugger`-kald. Den første linje udføres, og derefter sættes scriptet på pause, når det når den anden linje.

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

Når et script er sat på pause, vil De se en terminal til fejlfinding af scriptet.

De kan derefter bruge de indbyggede fejlfindingskommandoer til at gennemgå scriptet trin for trin.

### Apps

De kan bruge `Wait-Debugger` direkte i Deres PowerShell Universal Apps. De kan medtage denne kommando i hændelseshandlere og dynamics for at sætte appens udførelse på pause og evaluere scriptets aktuelle tilstand.

De kan f.eks. medtage `Wait-Debugger` i en dynamic.

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

Resultatet er, at appen vil vise indlæsningsskelettet, fordi PowerShell-fejlfindingsprogrammet er i et pausepunkt.

I admin console kan De klikke på fanen Debugger for at se de aktuelle pausepunkter, som appen venter på. Fejlfindingsprogrammet indeholder en terminal til evaluering af kommandoer mod runspacet. De kan bruge enhver standardkommando i PowerShell. De kan også bruge fejlfindingsværktøjerne, f.eks. trinvis kørsel og kildekodeliste. Der er knapper tilgængelige øverst i konsollen.

De kan bruge kommandoer som `Get-Variable` til at få oplysninger om variabeltilstand. Udfør `c` for at lade slutpunktet fortsætte udførelsen.

## Logning af scripts

Visse dele af Universal logger deres scripts automatisk. Andre funktioner kan kræve, at De selv logger.

### API'er

De kan bruge Live Log-visningen på fanen Log til at se loggene for den valgte API.

### Jobs

Jobs logger i stort omfang. De vil se konsol- og pipelineoutput. Hvis De angiver`$DebugPreference` eller `$VerbosePreference` , vil De også se disse strømme i konsoloutputtet. De kan tilføje yderligere logmeddelelser ved hjælp af `Write-Debug` eller `Write-Verbose` .

### Apps

Apps logger oplysende meddelelser, advarselsmeddelelser og fejlmeddelelser i deres log. Det anbefales at bruge logføring, når en app startes, frem for at forsøge at tilknytte en debugger. De kan også bruge variablen `$DebugPreference` til at få yderligere oplysninger under opstarten af Deres 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'
}
```

### Godkendelse og autorisation

De kan bruge Live Log-visningen på siderne for godkendelse og roller til at se output fra PowerShell-strømme.

## Fejlfinding af scripts fra en PowerShell-konsol

De kan fejlfinde ethvert script i Universal (eller enhver PowerShell-proces, faktisk) ved hjælp af de fejlfindings-cmdlets, der er tilgængelige i PowerShell. Disse cmdlets giver Dem mulighed for at oprette forbindelse til lokale PowerShell-processer, f.eks. Universal, og gennemgå Deres scripts trin for trin direkte i terminalen.

### Pausning af scriptet

Først skal De sikre, at scriptet venter på, at De tilslutter fejlfinderen, før det fortsætter. Det betyder, at De skal medtage en `Wait-Debugger`-kommando et sted i Deres script.

{% hint style="info" %}
Apps venter kun 10 sekunder under opstart, så det virker muligvis ikke at placere en Wait-Debugger i dem. De bør bruge $DebugPreference og Write-Debug til at diagnosticere problemer ved opstart af appen.
{% endhint %}

### Kørsel af Deres script

Nu hvor De har sat Deres script op, så det pauser og venter på fejlfinderen, bør De køre Deres script. For job skal De blot starte jobbet. For API'er skal De sende en anmodning til API'et via det slutpunkt, De forsøger at teste. For apps bør De indlæse siden i Deres browser. For godkendelse og autorisation bør De logge på.

### Sådan finder De Deres proces-id

Når De har Deres `Wait-Debugger`-kommando i det script, De vil fejlfinde, skal De starte scriptet og bestemme den proces, det kører i.

#### Jobs

Job kører i deres egen isolerede proces i Universal. De skal blot starte jobbet, så starter det processen og venter på Deres kommando `Wait-Debugger`. Når Deres job er startet, kan De bruge cmdlet'en `Get-UAJob` til at finde det pågældende jobs proces-id.

#### API'er

API'er kører i en enkelt PowerShell-proces. Der startes ikke en ny proces for hvert API-kald. De kan finde API-processen ved at finde den pwsh- eller PowerShell-proces, hvis kommandolinje indeholder `StartApi`.

#### Apps

Apps kører i deres egen isolerede PowerShell-proces. Proces-id'et vises i apptabellen i Admin Console.

#### Godkendelse og autorisation

Scripts til godkendelse og autorisation kører i Universal-serveren. De kan finde processen `Universal.Server.exe` og tilknytte den.

**Integreret miljø**

Enhver funktion, der kører i det integrerede miljø, kører i processen `Universal.Server.exe`. De skal tilknytte denne proces for at fejlfinde dem.

### Tilknytning til processen og fejlfinding af runspace

Når De har den proces, De vil tilknytte, kan De gøre det ved at bruge `Enter-PSHostProcess` . Angiv blot det proces-id, som De fandt i det forrige trin.

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

{% hint style="info" %}
Enter-PSHostProcess bruger navngivne pipes og kræver, at De har tilladelse til den proces, De tilgår. Hvis De kører Universal som en tjeneste, kan De få brug for at køre den som Deres lokale konto for at oprette korrekt forbindelse til processen.
{% endhint %}

Når De har tilsluttet Dem til processen, vil De nu gerne finde den runspace, hvor Deres kode kører. Det kan De gøre med cmdletten `Get-Runspace`. Den returnerer en liste over runspaces, der aktuelt er aktive i Deres proces. Se efter den runspace, der er markeret `InBreakpoint`. Det er den runspace, der venter på kommandoen `Wait-Debugger`.

Nu hvor De har fundet Deres runspace, brug `Debug-Runspace` til at tilknytte runspacet. De har nu mulighed for at udstede fejlfindingskommandoer mod det pågældende runspace. De kan få vist status for variabler, udstede kommandoer og endda gennemgå scriptet trin for trin.

For at få en fuldstændig liste over fejlfindingskommandoer kan De se [Microsoft-dokumentationen her](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_debuggers?view=powershell-7#starting-and-stopping-the-debugger).

### Eksempel på forbindelse til API-processen

Følgende er et eksempel på, hvordan De opretter forbindelse til en API-proces.

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

## Fejlfinding med Visual Studio Code

Hvis De vil fejlfinde et script, kan De bruge cmdlet'en Wait-Debugger i Deres script til at sætte scriptet på pause, indtil en debugger er tilknyttet. De kan derefter bruge en debugger, f.eks. VS Code, til at knytte til processen og runspace for at få vist variabler, gennemgå koden trin for trin og køre fejlfindingskommandoer.

De kan også fejlfinde scripts ved hjælp af de indbyggede cmdletter `Enter-PSHostProcess`, `Get-Runspace` og `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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.devolutions.net/powershell-universal/da/udvikling/debugging-scripts.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.