Cmdlet Overview (Cmdlet: Descrição Geral)

  • Artigo

Um cmdlet é um comando leve que é usado no ambiente PowerShell. O tempo de execução PowerShell invoca estes cmdlets no contexto dos scripts de automatização fornecidos na linha de comando. O tempo de execução PowerShell também os invoca programáticamente através de ApIs PowerShell.

Cmdlets

Os cmdlets executam uma ação e normalmente devolvem um objeto Microsoft .NET ao comando seguinte no oleoduto. Um cmdlet é um único comando que participa na semântica de gasoduto de PowerShell. Isto inclui cmdlets binários (C#), funções avançadas de script, CDXML e Fluxos de Trabalho.

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

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

  • Declare um atributo que identifique a classe derivada como um cmdlet.
  • Defina imóveis públicos que são decorados com atributos que identificam os imóveis públicos como parâmetros cmdlet.
  • Substitua um ou mais dos métodos de processamento de entrada para processar registos.

Pode carregar o conjunto que contém a classe diretamente utilizando o cmdlet do Módulo de Importação, ou pode criar uma aplicação de anfitrião que carrega o conjunto utilizando o System.Management.Automation.Runspaces.Initialsessionstate API. Ambos os métodos fornecem acesso programático e de linha de comando à funcionalidade do cmdlet.

Termos Cmdlet

Os seguintes termos são usados frequentemente na documentação do cmdlet PowerShell:

Atributo Cmdlet

Um atributo .NET que é utilizado para declarar uma classe cmdlet como cmdlet. Embora o PowerShell utilize vários outros atributos que são opcionais, o atributo Cmdlet é necessário. Para obter mais informações sobre este atributo, consulte a Declaração de Atributos Cmdlet.

Parâmetro de cmdlet

Os imóveis públicos que definem os parâmetros que estão disponíveis para o utilizador ou para a aplicação que está a executar o cmdlet. Os cmdlets podem ter exigido, nomeados, parâmetros posicionais e comutadores. Os parâmetros do comutação permitem definir parâmetros que só são avaliados se os parâmetros forem especificados na chamada. Para obter mais informações sobre os diferentes tipos de parâmetros, consulte os Parâmetros Cmdlet.

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 múltiplos parâmetros conjuntos, mas cada conjunto de parâmetros deve ter pelo menos um parâmetro que é único. Um bom design de cmdlet sugere fortemente que o parâmetro único também seja um parâmetro necessário. Para obter mais informações sobre os conjuntos de parâmetros, consulte os conjuntos de parâmetros do Cmdlet.

Parâmetro dinâmico

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

Métodos de processamento de entradas

A classe System.Management.Automation.Cmdlet fornece os seguintes métodos virtuais que são utilizados para processar registos. Todas as classes de cmdlet derivadas devem sobrepor-se a um ou mais dos três primeiros métodos:

Para obter mais informações sobre estes métodos, consulte os Métodos de Processamento de Entradas Cmdlet.

Quando implementar um cmdlet, deve sobrepor-se a pelo menos um destes métodos de processamento de entrada. Tipicamente, o ProcessRecord() é o método que se sobrepõe porque é chamado para cada registo que o cmdlet processa. Em contrapartida, o método BeginProcessing() e o método EndProcessing() são chamados uma vez para efetuar o pré-processamento ou pós-processamento dos registos. Para obter mais informações sobre estes métodos, consulte métodos de processamento de entradas.

Deve Processar funcionalidade

O PowerShell permite-lhe criar cmdlets que solicitam ao utilizador o feedback antes que o cmdlet faça uma alteração no sistema. Para utilizar esta função, o cmdlet deve declarar que suporta a ShouldProcess função quando declara o atributo Cmdlet, e o cmdlet deve chamar o Sistema.Management.Automation.Cmdlet.ShouldProcess and System.Management.Automation.Automation.Cmdlet.ShouldContinue os métodos de processamento de entrada. Para obter mais informações sobre como suportar a ShouldProcess funcionalidade, consulte Solicitação de Confirmação.

Transação

Um grupo lógico de comandos que são tratados como uma única tarefa. A tarefa falha automaticamente se algum comando no grupo falhar, e o utilizador tem a opção de aceitar ou rejeitar as ações realizadas dentro da transação. Para participar numa transação, o cmdlet deve declarar que suporta transações quando o atributo Cmdlet é declarado. O apoio às transações foi introduzido no Windows PowerShell 2.0. Para obter mais informações sobre transações, consulte Como Apoiar As Transações.

Como os Comandantes diferem dos comandos

Os comandantes diferem dos comandos de outros ambientes de comando-shell das seguintes formas:

  • Os cmdlets são exemplos de classes .NET; não são executáveis autónomos.
  • Os comandantes podem ser criados a partir de apenas uma dúzia de linhas de código.
  • Os cmdlets geralmente não fazem a sua própria análise, apresentação de erros ou formatação de saída. A análise, a apresentação de erros e a formatação de saída são manuseadas pelo tempo de funcionamento powerShell.
  • Os cmdlets processam os objetos de entrada do oleoduto e não a partir de fluxos de texto, e os cmdlets normalmente entregam objetos como saída para o oleoduto.
  • Os comandantes são orientados para registos porque processam um único objeto de cada vez.

Cmdlet Base Classes

Windows PowerShell suporta cmdlets derivados das duas classes base seguintes.

  • A maioria dos cmdlets baseia-se em classes .NET que derivam da classe base System.Management.Automation.Cmdlet. Derivado desta classe permite que um cmdlet utilize o conjunto mínimo de dependências no tempo de execução Windows PowerShell. Isto tem dois benefícios. O primeiro benefício é que os objetos cmdlet são menores, e é menos provável que seja afetado por alterações no tempo de funcionamento do PowerShell. O segundo benefício é que, se for preciso, pode criar diretamente uma instância do objeto cmdlet e, em seguida, invocá-lo diretamente em vez de invocá-lo através do tempo de execução powerShell.

  • Os cmdlets mais complexos baseiam-se em classes .NET que derivam da classe base System.Management.Automation.PSCmdlet. Derivado desta aula dá-lhe muito mais acesso ao tempo de execução powerShell. Este acesso permite ao seu cmdlet ligar para scripts, aceder a fornecedores e aceder ao estado atual da sessão. (Para aceder ao estado atual da sessão, obtém e define variáveis e preferências de sessão.) No entanto, derivar desta classe aumenta o tamanho do objeto cmdlet, e significa que o seu cmdlet está mais bem acoplado à versão atual do tempo de execução PowerShell.

Em geral, a menos que necessite do acesso alargado ao tempo de funcionação powerShell, deverá derivar da classe System.Management.Automation.Cmdlet. No entanto, o tempo de execução powerShell tem extensas capacidades de registo para a execução de cmdlets. Se o seu modelo de auditoria depender desta exploração madeireira, pode impedir a execução do 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 utilizados para gerir cmdlets e especificar a funcionalidade comum que é fornecida pelo PowerShell e que pode ser exigida pelo cmdlet. Por exemplo, os atributos são usados para designar uma classe como cmdlet, para especificar os parâmetros do cmdlet, e para solicitar a validação da entrada para que os desenvolvedores de cmdlet não tenham que implementar essa funcionalidade no seu código cmdlet. Para obter mais informações sobre atributos, consulte Atributos PowerShell.

Nomes do Cmdlet

PowerShell usa um par de nomes verbo-e-substantivo para nomear cmdlets. Por exemplo, o Get-Command cmdlet incluído no PowerShell é utilizado para obter todos os cmdlets que estão registados na concha de comando. O verbo identifica a ação que o cmdlet executa, e o substantivo identifica o recurso em que o cmdlet realiza a sua ação.

Estes nomes são especificados quando a classe .NET é declarada como cmdlet. Para obter mais informações sobre como declarar uma classe .NET como cmdlet, consulte a Declaração de Atributos Cmdlet.

Código cmdlet de escrita

Este documento fornece duas formas de descobrir como o código cmdlet é escrito. Se preferir ver o código sem grande explicação, consulte exemplos de Código Cmdlet. Se preferir mais explicações sobre o código, consulte o Tutorial GetProc, StopProc Tutorialou Temas Tutoriais SelectStr.

Para obter mais informações sobre as diretrizes para a escrita de cmdlets, consulte as Diretrizes de Desenvolvimento do Cmdlet.

Consulte também

Conceitos de Cmdlet do PowerShell

Escrever um Cmdlet do PowerShell

SDK do PowerShell