> 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/fr/commandes-powershell/new-udform.md).

# New-UDForm

New-UDForm crée un formulaire PowerShell Universal contenant des contrôles de saisie qui rapportent leurs valeurs lorsque le bouton d'envoi est cliqué.

### Synopsis

Les formulaires peuvent contenir n'importe quel ensemble de contrôles de saisie. Chacun des contrôles rapporte sa valeur au formulaire lorsque le bouton d'envoi est cliqué.

### Syntaxe

```powershell
New-UDForm [-Id <String>] [-OnValidate <Endpoint>] [-SubmitText <String>] [-CancelText <String>] [-ButtonVariant <String>] [-ClassName <String>] [-DisableSubmitOnEnter] [-Script <String>] [-OutputType <String>] [-ShowBackButton] [<CommonParameters>]

New-UDForm [-Id <String>] -Children <ScriptBlock> -OnSubmit <Endpoint> [-OnValidate <Endpoint>] [-OnProcessing <ScriptBlock>] [-OnCancel <Endpoint>] [-SubmitText <String>] [-CancelText <String>] [-ButtonVariant <String>] [-ClassName <String>] [-DisableSubmitOnEnter] [<CommonParameters>]

New-UDForm [-Id <String>] -OnSubmit <Endpoint> [-ButtonVariant <String>] [-ClassName <String>] -Schema <Hashtable> [-UiSchema <Hashtable>] [-FormData <Hashtable>] [-DisableSubmitOnEnter] [<CommonParameters>]
```

### Description

Crée un nouveau formulaire. Les formulaires peuvent contenir n'importe quel ensemble de contrôles de saisie. Chacun des contrôles rapporte sa valeur au formulaire lorsque le bouton d'envoi est cliqué.

### Paramètres

#### -Id

L'ID du composant. Sa valeur par défaut est un GUID aléatoire.

```
Required?                    false
Position?                    named
Default value                [Guid]::NewGuid().ToString()
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -Children

Les contrôles qui composent ce formulaire. Il peut s'agir de n'importe quelle combinaison de contrôles. Les contrôles de saisie rapportent leur état au formulaire.

```
Required?                    true
Position?                    named
Default value
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -OnSubmit

Un bloc de script qui est exécuté lorsque le formulaire est envoyé. Vous pouvez retourner des contrôles à partir de ce bloc de script et le formulaire sera remplacé par le bloc de script. La variable $EventData contiendra une table de hachage de tous les champs de saisie et de leurs valeurs.

```
Required?                    true
Position?                    named
Default value
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -OnValidate

Un bloc de script qui valide le formulaire. Retourne le résultat d'un appel à New-UDFormValidationResult.

```
Required?                    false
Position?                    named
Default value
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -OnProcessing

Un bloc de script qui est appelé lorsque le formulaire commence le traitement. La valeur de retour de ce bloc de script doit être un composant qui affiche un dialogue de chargement. Le bloc de script recevra les données actuelles du formulaire.

```
Required?                    false
Position?                    named
Default value
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -OnCancel

Un bloc de script qui est appelé lorsqu'un formulaire est annulé. Utile pour fermer des formulaires dans des fenêtres modales.

```
Required?                    false
Position?                    named
Default value
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -SubmitText

Le texte à afficher dans le bouton d'envoi. La valeur par défaut est « Submit ».

```
Required?                    false
Position?                    named
Default value                Submit
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -CancelText

Le texte à afficher dans le bouton d'annulation. La valeur par défaut est « Cancel ».

```
Required?                    false
Position?                    named
Default value                Cancel
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -ButtonVariant

Le type de bouton à afficher. La valeur par défaut est text. Les valeurs valides sont contained, outlined, text.

```
Required?                    false
Position?                    named
Default value                text
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -ClassName

Une classe CSS à appliquer au formulaire.

```
Required?                    false
Position?                    named
Default value
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -Schema

Définit un formulaire à partir d'une table de hachage de schéma. Cette version des formulaires est basée sur react-jsonschema-form.

```
Required?                    true
Position?                    named
Default value
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -UiSchema

Utilisé pour modifier l'ordre des champs (voir la documentation)

```
Required?                    false
Position?                    named
Default value                @{}
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -FormData

```
Required?                    false
Position?                    named
Default value                @{}
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -DisableSubmitOnEnter

Désactive la fonctionnalité selon laquelle appuyer sur Entrée dans une zone de texte envoie le formulaire dont elle fait partie.

```
Required?                    false
Position?                    named
Default value                False
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -Script

Utilisé pour générer automatiquement des formulaires à partir des scripts de votre environnement PowerShell Universal. Les formulaires de script génèrent des composants de saisie à partir du bloc param. Les formulaires de script prennent automatiquement en charge la progression et la rétroaction.

```
Required?                    false
Position?                    named
Default value                None
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -OutputType

Le type de sortie à retourner à partir du script. Les valeurs valides sont : « Text », « Table »

```
Required?                    false
Position?                    named
Default value                Text
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### -ShowBackButton

Affiche un bouton de retour après l'envoi du formulaire. Ceci est utilisé uniquement pour les formulaires de script.

```
Required?                    false
Position?                    named
Default value                False
Accept pipeline input?       false
Aliases
Accept wildcard characters?  false
```

#### Paramètres communs

Cette applet de commande prend en charge les paramètres communs : Verbose, Debug, ErrorAction, ErrorVariable, WarningAction, WarningVariable, OutBuffer, PipelineVariable et OutVariable. Pour plus d'information, voir [about\_CommonParameters](https://go.microsoft.com/fwlink/?LinkID=113216).

### Sorties

### Exemples

#### Exemple 1 : De base

```powershell
New-UDForm -Id 'form1' -Content {
    New-UDTextbox -Id 'form1Textbox' -Label 'Name'
} -OnSubmit {
    Show-UDToast -Message ($EventData.form1Textbox)
}
```

Crée un formulaire de base.

#### Exemple 2 : Validation

```powershell
New-UDForm -Id 'form2' -Content {
    New-UDTextbox -Id 'form2Textbox' -Label 'Name'
} -OnSubmit {
    Show-UDToast -Message ($EventData.form2Textbox)
} -OnValidate {
    if ($EventData.form2Textbox -eq 'Bob') {
        New-UDValidationResult -ValidationError 'Bob is not allowed'
    }
    else {
        New-UDValidationResult -Valid
    }
}
```

Crée un formulaire avec validation.

#### Exemple 3 : Traitement

```powershell
New-UDForm -Id 'form3' -Content {
    New-UDTextbox -Id 'form3Textbox' -Label 'Name'
} -OnSubmit {
    Start-Sleep -Seconds 5
    Show-UDToast -Message ($EventData.form3Textbox)
} -OnProcessing {
    New-UDCard -Title 'Processing' -Content {
        New-UDProgress
    }
}
```

Crée un formulaire avec un dialogue de traitement.

#### Exemple 4 : Annulation

```powershell
New-UDForm -Id 'form4' -Content {
    New-UDTextbox -Id 'form4Textbox' -Label 'Name'
} -OnSubmit {
    Show-UDToast -Message ($EventData.form4Textbox)
} -OnCancel {
    Show-UDToast -Message 'Form was cancelled'
}
```

Crée un formulaire avec un bouton d'annulation.

#### Exemple 5 : Texte d'envoi et d'annulation

```powershell
New-UDForm -Id 'form5' -Content {
    New-UDTextbox -Id 'form5Textbox' -Label 'Name'
} -OnSubmit {
    Show-UDToast -Message ($EventData.form5Textbox)
} -SubmitText 'Save' -CancelText 'Close' -OnCancel {
    Show-UDToast -Message 'Form was cancelled'
}
```

Crée un formulaire avec des textes d'envoi et d'annulation personnalisés.

#### Exemple 6 : Variante de bouton

```powershell
New-UDForm -Id 'form6' -Content {
    New-UDTextbox -Id 'form6Textbox' -Label 'Name'
} -OnSubmit {
    Show-UDToast -Message ($EventData.form6Textbox)
} -ButtonVariant 'contained'
```

Crée un formulaire avec une variante de bouton contained.

#### Exemple 7 : Nom de classe

```powershell
New-UDForm -Id 'form7' -Content {
    New-UDTextbox -Id 'form7Textbox' -Label 'Name'
} -OnSubmit {
    Show-UDToast -Message ($EventData.form7Textbox)
} -ClassName 'my-form'
```

Crée un formulaire avec un nom de classe CSS personnalisé.

#### Exemple 8 : Schéma

```powershell
New-UDForm -Id 'form8' -Schema @{
    title = "Test Form"
    type = "object"
    properties = @{
       name = @{
           type = "string"
       }
       age = @{
           type = "number"
       }
    }
} -OnSubmit {
    Show-UDToast -Message ($EventData.name)
    Show-UDToast -Message ($EventData.age)
}
```

Crée un formulaire avec un schéma. Vous pouvez en apprendre plus sur JSON Schema ici : <https://rjsf-team.github.io/react-jsonschema-form/docs/>

#### Exemple 9 : Schéma d'interface

```powershell
New-UDForm -Id 'form9' -Schema @{
    title = "Test Form"
    type = "object"
    properties = @{
       name = @{
           type = "string"
       }
       age = @{
           type = "number"
       }
    }
} -uiSchema @{
	"ui:order" = @('age','name')
} -FormData @{ Name = "adam"; Age = 38 } -OnSubmit {
    Show-UDToast -Message ($EventData.name)
}
```

Crée un formulaire avec un schéma et un schéma d'interface. Vous pouvez en apprendre plus sur JSON Schema ici : <https://rjsf-team.github.io/react-jsonschema-form/docs/>

#### Exemple 10 : Script

```powershell
New-UDForm -Id 'form10' -Script "Script1.ps1" -OutputType "Table"
```

Crée un formulaire à partir d'un script. Les paramètres du script définiront le formulaire. La sortie du script sera affichée dans un tableau.

#### Exemple 11

```powershell
New-UDForm -Id 'form11' -Content {
   New-UDTextbox -Id 'form11Textbox' -Label 'Name'
} -OnSubmit {
    Show-UDToast -Message ($EventData.form11Textbox)
}
New-UDButton -Text "A submit button outside the form" -OnClick {
    Invoke-UDForm -Id "form11"
}

Invoke-UDForm|Creates a form with a submit button outside the form.
```

#### Exemple 12

```powershell
New-UDForm -Id 'form12' -Content {
   New-UDTextbox -Id 'form12Textbox' -Label 'Name'
} -OnSubmit {
    Show-UDToast -Message ($EventData.form12Textbox)
} -OnValidate {
    if ($EventData.form12Textbox -eq 'Hello') {
        New-UDValidationResult -Valid
    }
    else {
        New-UDValidationResult -ValidationError "Name must be 'Hello'"
    }
}
New-UDButton -Text "Validate form" -OnClick {
    Test-UDForm -Id "form12"
}

Test-UDForm|Creates a form with a validate button outside the form.
```


---

# 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/fr/commandes-powershell/new-udform.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.