Partilhar via

Cmdlet Overview (Cmdlet: Descrição Geral)

Um cmdlet é um comando leve usado no ambiente do PowerShell. O tempo de execução do PowerShell invoca esses cmdlets dentro do contexto de scripts de automação fornecidos na linha de comando. O tempo de execução do PowerShell também os invoca programaticamente por meio de APIs do PowerShell.

Cmdlets

Os cmdlets executam uma ação e normalmente retornam um objeto do Microsoft .NET para o próximo comando no pipeline. Um cmdlet é um único comando que participa da semântica de pipeline do PowerShell. Isso inclui cmdlets binários (C#), funções de script avançadas, CDXML e fluxos de trabalho.

Esta documentação do SDK descreve como criar cmdlets binários escritos em C#. Para obter informações sobre cmdlets baseados em script, consulte:

Para criar um cmdlet binário, você deve implementar uma classe de cmdlet que derive de uma das duas classes base de cmdlet especializadas. A classe derivada deve:

  • Declare um atributo que identifique a classe derivada como um cmdlet.
  • Defina propriedades públicas decoradas com atributos que identificam as propriedades públicas como parâmetros de cmdlet.
  • Substitua um ou mais dos métodos de processamento de entrada para processar registros.

Você pode carregar o assembly que contém a classe diretamente usando o cmdlet Import-Module ou pode criar um aplicativo host que carregue o assembly usando o System.Management.Automation.Runspaces.InitialSessionState API. Ambos os métodos fornecem acesso programático e de linha de comando à funcionalidade do cmdlet.

Termos do cmdlet

Os seguintes termos são usados com freqüência na documentação do cmdlet do PowerShell:

Atributo do cmdlet

Um atributo .NET que é usado para declarar uma classe de cmdlet como um cmdlet. Embora o PowerShell use vários outros atributos que são opcionais, o atributo Cmdlet é necessário. Para obter mais informações sobre esse atributo, consulte Cmdlet Attribute Declaration.

Parâmetro do cmdlet

As propriedades públicas que definem os parâmetros disponíveis para o usuário ou para o aplicativo que está executando o cmdlet. Os cmdlets podem ter parâmetros obrigatórios, nomeados, posicionais e alternar parâmetros. Os parâmetros de switch permitem definir parâmetros que são avaliados somente se os parâmetros forem especificados na chamada. Para obter mais informações sobre os diferentes tipos de parâmetros, consulte Cmdlet Parameters.

Conjunto de parâmetros

Um grupo de parâmetros que podem ser usados no mesmo comando para executar uma ação específica. Um cmdlet pode ter vários conjuntos de parâmetros, mas cada conjunto de parâmetros deve ter pelo menos um parâmetro exclusivo. Um bom design de cmdlet sugere fortemente que o parâmetro exclusivo também seja um parâmetro necessário. Para obter mais informações sobre conjuntos de parâmetros, consulte Cmdlet Parameter Sets.

Parâmetro dinâmico

Um parâmetro que é adicionado ao cmdlet em tempo de execução. Normalmente, os parâmetros dinâmicos são adicionados ao cmdlet quando outro parâmetro é definido como um valor específico. Para obter mais informações sobre parâmetros dinâmicos, consulte Cmdlet Dynamic Parameters.

Métodos de processamento de entrada

A classe System.Management.Automation.Cmdlet do fornece os seguintes métodos virtuais que são usados para processar registros. Todas as classes de cmdlet derivadas devem substituir um ou mais dos três primeiros métodos:

Para obter mais informações sobre esses métodos, consulte Cmdlet Input Processing Methods.

Ao implementar um cmdlet, você deve substituir pelo menos um desses métodos de processamento de entrada. Normalmente, o ProcessRecord() é o método que você substitui porque é chamado para cada registro que o cmdlet processa. Por outro lado, o método BeginProcessing() e o método EndProcessing() são chamados uma vez para executar o pré-processamento ou pós-processamento dos registros. Para obter mais informações sobre esses métodos, consulte Input Processing Methods.

Recurso ShouldProcess

O PowerShell permite que você crie cmdlets que solicitam comentários ao usuário antes que o cmdlet faça uma alteração no sistema. Para usar esse recurso, o cmdlet deve declarar que oferece suporte ao recurso ShouldProcess quando você declara o atributo Cmdlet, e o cmdlet deve chamar o System.Management.Automation.Cmdlet.ShouldProcess e System.Management.Automation.Cmdlet.ShouldContinue métodos de dentro de um método de processamento de entrada. Para obter mais informações sobre como dar suporte à funcionalidade ShouldProcess, consulte Solicitando confirmação.

Transação

Um grupo lógico de comandos que são tratados como uma única tarefa. A tarefa falha automaticamente se qualquer comando no grupo falhar, e o usuário tem a opção de aceitar ou rejeitar as ações executadas dentro da transação. Para participar de uma transação, o cmdlet deve declarar que oferece suporte a transações quando o atributo Cmdlet é declarado. O suporte para transações foi introduzido no Windows PowerShell 2.0. Para obter mais informações sobre transações, consulte Como dar suporte a transações.

Como os cmdlets diferem dos comandos

Os cmdlets diferem dos comandos em outros ambientes de shell de comando das seguintes maneiras:

  • Os cmdlets são instâncias de classes .NET; eles não são executáveis autônomos.
  • Os cmdlets podem ser criados a partir de apenas uma dúzia de linhas de código.
  • Os cmdlets geralmente não fazem sua própria análise, apresentação de erro ou formatação de saída. A análise, a apresentação de erros e a formatação de saída são tratadas pelo tempo de execução do PowerShell.
  • Os cmdlets processam objetos de entrada do pipeline em vez de fluxos de texto, e os cmdlets normalmente entregam objetos como saída para o pipeline.
  • Os cmdlets são orientados a registros porque processam um único objeto de cada vez.

Cmdlet Base Classes

O Windows PowerShell dá suporte a cmdlets derivados das duas classes base a seguir.

  • A maioria dos cmdlets é baseada em classes .NET que derivam do System.Management.Automation.Cmdlet classe base. Derivar dessa classe permite que um cmdlet use o conjunto mínimo de dependências no tempo de execução do Windows PowerShell. Isto tem duas vantagens. O primeiro benefício é que os objetos de cmdlet são menores e é menos provável que você seja afetado por alterações no tempo de execução do PowerShell. O segundo benefício é que, se necessário, você pode criar diretamente uma instância do objeto de cmdlet e, em seguida, invocá-la diretamente em vez de invocá-la por meio do tempo de execução do PowerShell.

  • Os cmdlets mais complexos são baseados em classes .NET que derivam do System.Management.Automation.PSCmdlet classe base. Derivar dessa classe lhe dá muito mais acesso ao tempo de execução do PowerShell. Esse acesso permite que seu cmdlet chame scripts, acesse provedores e acesse o estado da sessão atual. (Para acessar o estado atual da sessão, você obtém e define variáveis e preferências de sessão.) No entanto, derivar dessa classe aumenta o tamanho do objeto de cmdlet e significa que seu cmdlet está mais firmemente acoplado à versão atual do tempo de execução do PowerShell.

Em geral, a menos que você precise do acesso estendido ao tempo de execução do PowerShell, você deve derivar da classe System.Management.Automation.Cmdlet. No entanto, o tempo de execução do PowerShell tem amplos recursos de log para a execução de cmdlets. Se seu modelo de auditoria depender desse log, você poderá impedir a execução de seu cmdlet dentro de outro cmdlet derivando da classe System.Management.Automation.PSCmdlet.

Cmdlet Attributes (Atributos de Cmdlet)

O PowerShell define vários atributos .NET que são usados para gerenciar cmdlets e especificar funcionalidades comuns fornecidas pelo PowerShell e que podem ser exigidas pelo cmdlet. Por exemplo, os atributos são usados para designar uma classe como um cmdlet, para especificar os parâmetros do cmdlet e para solicitar a validação da entrada para que os desenvolvedores do cmdlet não precisem implementar essa funcionalidade em seu código de cmdlet. Para obter mais informações sobre atributos, consulte PowerShell Attributes.

Nomes de cmdlets

O PowerShell usa um par de nomes verbais e substantivos para nomear cmdlets. Por exemplo, o cmdlet Get-Command incluído no PowerShell é usado para obter todos os cmdlets registrados no shell de comando. O verbo identifica a ação que o cmdlet executa e o substantivo identifica o recurso no qual o cmdlet executa sua ação.

Esses nomes são especificados quando a classe .NET é declarada como um cmdlet. Para obter mais informações sobre como declarar uma classe .NET como um cmdlet, consulte Cmdlet Attribute Declaration.

Escrevendo código de cmdlet

Este documento fornece duas maneiras de descobrir como o código do cmdlet é escrito. Se preferir ver o código sem muitas explicações, consulte Exemplos de código de cmdlet. Se preferir mais explicações sobre o código, consulte o GetProc Tutorial, Tutorial StopProcou SelectStr Tutorial tópicos.

Para obter mais informações sobre as diretrizes para escrever cmdlets, consulte Diretrizes de desenvolvimento de cmdlets.

Ver também

Conceitos de cmdlet do PowerShell

Escrevendo um cmdlet do PowerShell

SDK do PowerShell

  • Last updated on