Compartilhar via

Criando um provedor de contêiner do Windows PowerShell

  • Artigo

Este tópico descreve como criar um provedor do Windows PowerShell que pode funcionar em armazenamentos de dados de várias camadas. Para esse tipo de armazenamento de dados, o nível superior do repositório contém os itens raiz e cada nível subsequente é conhecido como um nó de itens filho. Ao permitir que o usuário trabalhe nesses nós filho, um usuário pode interagir hierarquicamente por meio do armazenamento de dados.

Provedores que podem trabalhar em repositórios de dados de vários níveis são chamados de provedores de contêiner do Windows PowerShell. No entanto, lembre-se de que um provedor de contêiner do Windows PowerShell só pode ser usado quando houver um contêiner (nenhum contêiner aninhado) com itens nele. Se houver contêineres aninhados, você deverá implementar um provedor de navegação do Windows PowerShell. Para obter mais informações sobre como implementar o provedor de navegação do Windows PowerShell, consulte Criando um provedor de navegação do Windows PowerShell.

Observação

Você pode baixar o arquivo de origem C# (AccessDBSampleProvider04.cs) para esse provedor usando o Kit de Desenvolvimento de Software do Microsoft Windows para Windows Vista e componentes de runtime do .NET Framework 3.0. Para obter instruções de download, consulte Como instalar o Windows PowerShell e baixar o SDK do Windows PowerShell. Os arquivos de origem baixados estão disponíveis no diretório><exemplos do PowerShell. Para obter mais informações sobre outras implementações de provedor do Windows PowerShell, consulte Criando seu provedor do Windows PowerShell.

O provedor de contêineres do Windows PowerShell descrito aqui define o banco de dados como seu único contêiner, com as tabelas e linhas do banco de dados definidas como itens do contêiner.

Cuidado

Lembre-se de que esse design pressupõe um banco de dados que tenha um campo com a ID do nome e que o tipo do campo é LongInteger.

Definindo uma classe de provedor de contêiner do Windows PowerShell

Um provedor de contêineres do Windows PowerShell deve definir uma classe .NET que deriva da classe base System.Management.Automation.Provider.ContainerCmdletProvider. Esta é a definição de classe para o provedor de contêineres do Windows PowerShell descrito nesta seção.

[CmdletProvider("AccessDB", ProviderCapabilities.None)]
public class AccessDBProvider : ContainerCmdletProvider

Observe que, nesta definição de classe, o atributo System.Management.Automation.Provider.CmdletProviderAttribute inclui dois parâmetros. O primeiro parâmetro especifica um nome amigável para o provedor que é usado pelo Windows PowerShell. O segundo parâmetro especifica os recursos específicos do Windows PowerShell que o provedor expõe ao runtime do Windows PowerShell durante o processamento de comandos. Para esse provedor, não há recursos específicos do Windows PowerShell adicionados.

Definindo a funcionalidade base

Conforme descrito em a criação de seu provedor do Windows PowerShell, a classe System.Management.Automation.Provider.ContainerCmdletProvider deriva de várias outras classes que forneceram funcionalidades de provedor diferentes. Um provedor de contêineres do Windows PowerShell, portanto, precisa definir todas as funcionalidades fornecidas por essas classes.

Para implementar a funcionalidade para adicionar informações de inicialização específicas da sessão e para liberar recursos usados pelo provedor, consulte Criando um provedor básico do Windows PowerShell. No entanto, a maioria dos provedores (incluindo o provedor descrito aqui) pode usar a implementação padrão dessa funcionalidade fornecida pelo Windows PowerShell.

Para obter acesso ao armazenamento de dados, o provedor deve implementar os métodos da classe base System.Management.Automation.Provider.DriveCmdletProvider. Para obter mais informações sobre como implementar esses métodos, consulte Criando um provedor de unidade do Windows PowerShell.

Para manipular os itens de um armazenamento de dados, como obter, definir e limpar itens, o provedor deve implementar os métodos fornecidos pela classe base System.Management.Automation.Provider.ItemCmdletProvider. Para obter mais informações sobre como implementar esses métodos, consulte Criando um provedor de itens do Windows PowerShell.

Recuperando itens filho

Para recuperar um item filho, o provedor de contêineres do Windows PowerShell deve substituir o método System.Management.Automation.Provider.ContainerCmdletProvider.GetChildItems* para dar suporte a chamadas do cmdlet Get-ChildItem. Esse método recupera itens filho do armazenamento de dados e os grava no pipeline como objetos. Se o parâmetro recurse do cmdlet for especificado, o método recuperará todos os filhos, independentemente do nível em que estão. Se o parâmetro recurse não for especificado, o método recuperará apenas um único nível de filhos.

Aqui está a implementação do método System.Management.Automation.Provider.ContainerCmdletProvider.GetChildItems* para esse provedor. Observe que esse método recupera os itens filho em todas as tabelas de banco de dados quando o caminho indica o banco de dados do Access e recupera os itens filho das linhas dessa tabela se o caminho indicar uma tabela de dados.

protected override void GetChildItems(string path, bool recurse)
{
    // If path represented is a drive then the children in the path are 
    // tables. Hence all tables in the drive represented will have to be
    // returned
    if (PathIsDrive(path))
    {
        foreach (DatabaseTableInfo table in GetTables())
        {
            WriteItemObject(table, path, true);

            // if the specified item exists and recurse has been set then 
            // all child items within it have to be obtained as well
            if (ItemExists(path) && recurse)
            {
                GetChildItems(path + pathSeparator + table.Name, recurse);
            }
        } // foreach (DatabaseTableInfo...
    } // if (PathIsDrive...
    else
    {
        // Get the table name, row number and type of path from the
        // path specified
        string tableName;
        int rowNumber;

        PathType type = GetNamesFromPath(path, out tableName, out rowNumber);

        if (type == PathType.Table)
        {
            // Obtain all the rows within the table
            foreach (DatabaseRowInfo row in GetRows(tableName))
            {
                WriteItemObject(row, path + pathSeparator + row.RowNumber,
                        false);
            } // foreach (DatabaseRowInfo...
        }
        else if (type == PathType.Row)
        {
            // In this case the user has directly specified a row, hence
            // just give that particular row
            DatabaseRowInfo row = GetRow(tableName, rowNumber);
            WriteItemObject(row, path + pathSeparator + row.RowNumber,
                        false);
        }
        else
        {
            // In this case, the path specified is not valid
            ThrowTerminatingInvalidPathException(path);
        }
    } // else
} // GetChildItems

Coisas para lembrar sobre a implementação de GetChildItems

As seguintes condições podem se aplicar à implementação de System.Management.Automation.Provider.ContainerCmdletProvider.GetChildItems*:

Anexando parâmetros dinâmicos ao cmdlet Get-ChildItem

Às vezes, o cmdlet Get-ChildItem que chama System.Management.Automation.Provider.ContainerCmdletProvider.GetChildItems* requer parâmetros adicionais especificados dinamicamente no runtime. Para fornecer esses parâmetros dinâmicos, o provedor de contêineres do Windows PowerShell deve implementar o método System.Management.Automation.Provider.ContainerCmdletProvider.GetChildItemsDynamicParameters*. Esse método recupera parâmetros dinâmicos para o item no caminho indicado e retorna um objeto que tem propriedades e campos com atributos de análise semelhantes a uma classe cmdlet ou um objeto System.Management.Automation.RuntimeDefinedParameterDictionary. O runtime do Windows PowerShell usa o objeto retornado para adicionar os parâmetros ao cmdlet Get-ChildItem.

Esse provedor de contêineres do Windows PowerShell não implementa esse método. No entanto, o código a seguir é a implementação padrão desse método.

Recuperando nomes de itens filho

Para recuperar os nomes de itens filho, o provedor de contêineres do Windows PowerShell deve substituir o método System.Management.Automation.Provider.ContainerCmdletProvider.GetChildNames* para dar suporte a chamadas do cmdlet Get-ChildItem quando seu parâmetro Name for especificado. Esse método recupera os nomes dos itens filho para o caminho especificado ou nomes de item filho para todos os contêineres se o parâmetro returnAllContainers do cmdlet for especificado. Um nome filho é a parte folha de um caminho. Por exemplo, o nome filho do caminho C:\windows\system32\abc.dll é "abc.dll". O nome filho do diretório C:\windows\system32 é "system32".

Aqui está a implementação do método System.Management.Automation.Provider.ContainerCmdletProvider.GetChildNames* para esse provedor. Observe que o método recupera nomes de tabela se o caminho especificado indicar o banco de dados do Access (unidade) e os números de linha se o caminho indicar uma tabela.

protected override void GetChildNames(string path,
                              ReturnContainers returnContainers)
{
    // If the path represented is a drive, then the child items are
    // tables. get the names of all the tables in the drive.
    if (PathIsDrive(path))
    {
        foreach (DatabaseTableInfo table in GetTables())
        {
            WriteItemObject(table.Name, path, true);
        } // foreach (DatabaseTableInfo...
    } // if (PathIsDrive...
    else
    {
        // Get type, table name and row number from path specified
        string tableName;
        int rowNumber;

        PathType type = GetNamesFromPath(path, out tableName, out rowNumber);

        if (type == PathType.Table)
        {
            // Get all the rows in the table and then write out the 
            // row numbers.
            foreach (DatabaseRowInfo row in GetRows(tableName))
            {
                WriteItemObject(row.RowNumber, path, false);
            } // foreach (DatabaseRowInfo...
        }
        else if (type == PathType.Row)
        {
            // In this case the user has directly specified a row, hence
            // just give that particular row
            DatabaseRowInfo row = GetRow(tableName, rowNumber);

            WriteItemObject(row.RowNumber, path, false);
        }
        else
        {
            ThrowTerminatingInvalidPathException(path);
        }
    } // else
} // GetChildNames

Coisas para lembrar sobre a implementação de GetChildNames

As seguintes condições podem se aplicar à implementação de System.Management.Automation.Provider.ContainerCmdletProvider.GetChildItems*:

Anexando parâmetros dinâmicos ao cmdlet Get-ChildItem (nome)

Às vezes, o cmdlet Get-ChildItem (com o parâmetro Name) requer parâmetros adicionais especificados dinamicamente no runtime. Para fornecer esses parâmetros dinâmicos, o provedor de contêineres do Windows PowerShell deve implementar o método System.Management.Automation.Provider.ContainerCmdletProvider.GetChildNamesDynamicParameters*. Esse método recupera os parâmetros dinâmicos do item no caminho indicado e retorna um objeto que tem propriedades e campos com atributos de análise semelhantes a uma classe de cmdlet ou um objeto System.Management.Automation.RuntimeDefinedParameterDictionary. O runtime do Windows PowerShell usa o objeto retornado para adicionar os parâmetros ao cmdlet Get-ChildItem.

Esse provedor não implementa esse método. No entanto, o código a seguir é a implementação padrão desse método.

Renomeando itens

Para renomear um item, um provedor de contêineres do Windows PowerShell deve substituir o método System.Management.Automation.Provider.ContainerCmdletProvider.RenameItem* para dar suporte a chamadas do cmdlet Rename-Item. Esse método altera o nome do item no caminho especificado para o novo nome fornecido. O novo nome deve ser sempre relativo ao item pai (contêiner).

Esse provedor não substitui o método System.Management.Automation.Provider.ContainerCmdletProvider.RenameItem*. No entanto, a seguinte é a implementação padrão.

Coisas para lembrar sobre a implementação de RenameItem

As seguintes condições podem se aplicar à implementação de System.Management.Automation.Provider.ContainerCmdletProvider.RenameItem*:

  • Ao definir a classe de provedor, um provedor de contêineres do Windows PowerShell pode declarar recursos de provedor de ExpandWildcards, Filter, Include ou Exclude, do System.Management.Automation.Provider.ProviderCapabilities enumeração. Nesses casos, a implementação do método System.Management.Automation.Provider.ContainerCmdletProvider.GetChildItems* precisa garantir que o caminho passado para o método atenda aos requisitos dos recursos especificados. Para fazer isso, o método deve acessar a propriedade apropriada, por exemplo, as propriedades System.Management.Automation.Provider.CmdletProvider.Exclude* e System.Management.Automation.Provider.CmdletProvider.Include*.

  • O método System.Management.Automation.Provider.ContainerCmdletProvider.RenameItem* destina-se à modificação do nome de um item somente e não para operações de movimentação. Sua implementação do método deve escrever um erro se o parâmetro newName contiver separadores de caminho ou, de outra forma, pode fazer com que o item altere seu local pai.

  • Por padrão, as substituições desse método não devem renomear objetos, a menos que a propriedade System.Management.Automation.Provider.CmdletProvider.Force* seja especificada. Se o caminho especificado indicar um contêiner, a propriedade System.Management.Automation.Provider.CmdletProvider.Force* não será necessária.

  • Sua implementação do método System.Management.Automation.Provider.ContainerCmdletProvider.RenameItem* deve chamar System.Management.Automation.Provider.CmdletProvider.ShouldProcess e verificar seu valor retornado antes de fazer alterações no armazenamento de dados. Esse método é usado para confirmar a execução de uma operação quando uma alteração é feita no estado do sistema, por exemplo, renomeando arquivos. System.Management.Automation.Provider.CmdletProvider.ShouldProcess envia o nome do recurso a ser alterado para o usuário, com o runtime do Windows PowerShell levando em conta quaisquer configurações de linha de comando ou variáveis de preferência para determinar o que deve ser exibido.

    Após a chamada para System.Management.Automation.Provider.CmdletProvider.ShouldProcess retorna true, o método System.Management.Automation.Provider.ContainerCmdletProvider.RenameItem* deve chamar o método System.Management.Automation.Provider.CmdletProvider.ShouldContinue método. Esse método envia uma mensagem de confirmação ao usuário para permitir comentários adicionais para dizer se a operação deve continuar. Um provedor deve chamar System.Management.Automation.Provider.CmdletProvider.ShouldContinue como uma verificação adicional para modificações potencialmente perigosas do sistema.

Anexando parâmetros dinâmicos ao cmdlet Rename-Item

Às vezes, o cmdlet Rename-Item requer parâmetros adicionais especificados dinamicamente no runtime. Para fornecer esses parâmetros dinâmicos, o provedor de contêineres do Windows PowerShell deve implementar o método System.Management.Automation.Provider.ContainerCmdletProvider.RenameItemDynamicParameters*. Esse método recupera os parâmetros do item no caminho indicado e retorna um objeto que tem propriedades e campos com atributos de análise semelhantes a uma classe cmdlet ou um objeto System.Management.Automation.RuntimeDefinedParameterDictionary. O runtime do Windows PowerShell usa o objeto retornado para adicionar os parâmetros ao cmdlet Rename-Item.

Esse provedor de contêiner não implementa esse método. No entanto, o código a seguir é a implementação padrão desse método.

Criando novos itens

Para criar novos itens, um provedor de contêiner deve implementar o método System.Management.Automation.Provider.ContainerCmdletProvider.NewItem* para dar suporte a chamadas do cmdlet New-Item. Esse método cria um item de dados localizado no caminho especificado. O parâmetro type do cmdlet contém o tipo definido pelo provedor para o novo item. Por exemplo, o provedor FileSystem usa um parâmetro type com um valor de "arquivo" ou "diretório". O parâmetro newItemValue do cmdlet especifica um valor específico do provedor para o novo item.

Aqui está a implementação do método System.Management.Automation.Provider.ContainerCmdletProvider.NewItem* para esse provedor.

protected override void NewItem( string path, string type, object newItemValue )
{
    // Create the new item here after
    // performing necessary validations
    //
    // WriteItemObject(newItemValue, path, false);

    // Example
    //
    // if (ShouldProcess(path, "new item"))
    // {
    //      // Create a new item and then call WriteObject
    //      WriteObject(newItemValue, path, false);
    // }

} // NewItem

{
    case 1:
        {
            string name = pathChunks[0];

            if (TableNameIsValid(name))
            {
                tableName = name;
                retVal = PathType.Table;
            }
        }
        break;

    case 2:
        {
            string name = pathChunks[0];

Coisas para lembrar sobre a implementação do NewItem

As seguintes condições podem se aplicar à implementação de System.Management.Automation.Provider.ContainerCmdletProvider.NewItem*:

  • O método System.Management.Automation.Provider.ContainerCmdletProvider.NewItem* deve executar uma comparação que não diferencia maiúsculas de minúsculas da cadeia de caracteres passada no parâmetro type. Também deve permitir correspondências menos ambíguas. Por exemplo, para os tipos "file" e "directory", somente a primeira letra é necessária para desambiguar. Se o parâmetro type indicar um tipo que seu provedor não pode criar, o método System.Management.Automation.Provider.ContainerCmdletProvider.NewItem* deve escrever um ArgumentException com uma mensagem indicando os tipos que o provedor pode criar.

  • Para o parâmetro newItemValue, a implementação do método System.Management.Automation.Provider.ContainerCmdletProvider.NewItem* é recomendada para aceitar cadeias de caracteres no mínimo. Ele também deve aceitar o tipo de objeto recuperado pelo método System.Management.Automation.Provider.ItemCmdletProvider.GetItem* para o mesmo caminho. O método System.Management.Automation.Provider.ContainerCmdletProvider.NewItem* pode usar o método System.Management.Automation.LanguagePrimitives.ConvertTo* para converter tipos no tipo desejado.

  • Sua implementação do método System.Management.Automation.Provider.ContainerCmdletProvider.NewItem* deve chamar System.Management.Automation.Provider.CmdletProvider.ShouldProcess e verificar seu valor retornado antes de fazer alterações no armazenamento de dados. Após a chamada para System.Management.Automation.Provider.CmdletProvider.ShouldProcess retorna true, o método System.Management.Automation.Provider.ContainerCmdletProvider.NewItem* deve chamar o método System.Management.Automation.Provider.CmdletProvider.ShouldContinue como uma verificação adicional para modificações potencialmente perigosas do sistema.

Anexando parâmetros dinâmicos ao cmdlet New-Item

Às vezes, o cmdlet New-Item requer parâmetros adicionais especificados dinamicamente no runtime. Para fornecer esses parâmetros dinâmicos, o provedor de contêiner deve implementar o método System.Management.Automation.Provider.ContainerCmdletProvider.NewItemDynamicParameters*. Esse método recupera os parâmetros do item no caminho indicado e retorna um objeto que tem propriedades e campos com atributos de análise semelhantes a uma classe cmdlet ou um objeto System.Management.Automation.RuntimeDefinedParameterDictionary. O runtime do Windows PowerShell usa o objeto retornado para adicionar os parâmetros ao cmdlet New-Item.

Esse provedor não implementa esse método. No entanto, o código a seguir é a implementação padrão desse método.

Removendo itens

Para remover itens, o provedor do Windows PowerShell deve substituir o método System.Management.Automation.Provider.ContainerCmdletProvider.RemoveItem* para dar suporte a chamadas do cmdlet Remove-Item. Esse método exclui um item do armazenamento de dados no caminho especificado. Se o parâmetro recurse do cmdlet Remove-Item for definido como true, o método removerá todos os itens filho, independentemente de seu nível. Se o parâmetro for definido como false, o método removerá apenas um único item no caminho especificado.

Esse provedor não dá suporte à remoção de item. No entanto, o código a seguir é a implementação padrão de System.Management.Automation.Provider.ContainerCmdletProvider.RemoveItem*.

Coisas para lembrar sobre a implementação de RemoveItem

As seguintes condições podem se aplicar à implementação de System.Management.Automation.Provider.ContainerCmdletProvider.NewItem*:

Anexando parâmetros dinâmicos ao cmdlet Remove-Item

Às vezes, o cmdlet Remove-Item requer parâmetros adicionais especificados dinamicamente no runtime. Para fornecer esses parâmetros dinâmicos, o provedor de contêiner deve implementar o método System.Management.Automation.Provider.ContainerCmdletProvider.RemoveItemDynamicParameters* para lidar com esses parâmetros. Esse método recupera os parâmetros dinâmicos do item no caminho indicado e retorna um objeto que tem propriedades e campos com atributos de análise semelhantes a uma classe de cmdlet ou um objeto System.Management.Automation.RuntimeDefinedParameterDictionary. O runtime do Windows PowerShell usa o objeto retornado para adicionar os parâmetros ao cmdlet Remove-Item.

Esse provedor de contêiner não implementa esse método. No entanto, o código a seguir é a implementação padrão de System.Management.Automation.Provider.ContainerCmdletProvider.RemoveItemDynamicParameters*.

Consultando itens filho

Para verificar se os itens filho existem no caminho especificado, o provedor de contêineres do Windows PowerShell deve substituir o método System.Management.Automation.Provider.ContainerCmdletProvider.HasChildItems*. Esse método retornará true se o item tiver filhos e false caso contrário. Para um caminho nulo ou vazio, o método considera todos os itens no armazenamento de dados filhos e retorna true.

Aqui está a substituição do método System.Management.Automation.Provider.ContainerCmdletProvider.HasChildItems*. Se houver mais de duas partes de caminho criadas pelo método auxiliar ChunkPath, o método retornará false, pois apenas um contêiner de banco de dados e um contêiner de tabela serão definidos. Para obter mais informações sobre esse método auxiliar, consulte o método ChunkPath discutido em Criando um provedor de itens do Windows PowerShell.

protected override bool HasChildItems( string path )
{
    return false;
} // HasChildItems

        ErrorCategory.InvalidOperation, tableName));
}

return results;

Coisas para lembrar sobre a implementação de HasChildItems

As seguintes condições podem se aplicar à implementação de System.Management.Automation.Provider.ContainerCmdletProvider.HasChildItems*:

Copiando itens

Para copiar itens, o provedor de contêiner deve implementar o método System.Management.Automation.Provider.ContainerCmdletProvider.CopyItem para dar suporte a chamadas do cmdlet Copy-Item. Esse método copia um item de dados do local indicado pelo parâmetro path do cmdlet para o local indicado pelo parâmetro copyPath. Se o parâmetro recurse for especificado, o método copiará todos os subconsultos. Se o parâmetro não for especificado, o método copiará apenas um único nível de itens.

Esse provedor não implementa esse método. No entanto, o código a seguir é a implementação padrão de System.Management.Automation.Provider.ContainerCmdletProvider.CopyItem.

Coisas a serem lembradas sobre a implementação do CopyItem

As seguintes condições podem se aplicar à implementação de System.Management.Automation.Provider.ContainerCmdletProvider.CopyItem:

Anexando parâmetros dinâmicos ao cmdlet Copy-Item

Às vezes, o cmdlet Copy-Item requer parâmetros adicionais especificados dinamicamente no runtime. Para fornecer esses parâmetros dinâmicos, o provedor de contêineres do Windows PowerShell deve implementar o método System.Management.Automation.Provider.ContainerCmdletProvider.CopyItemDynamicParameters* para lidar com esses parâmetros. Esse método recupera os parâmetros do item no caminho indicado e retorna um objeto que tem propriedades e campos com atributos de análise semelhantes a uma classe cmdlet ou um objeto System.Management.Automation.RuntimeDefinedParameterDictionary. O runtime do Windows PowerShell usa o objeto retornado para adicionar os parâmetros ao cmdlet Copy-Item.

Esse provedor não implementa esse método. No entanto, o código a seguir é a implementação padrão de System.Management.Automation.Provider.ContainerCmdletProvider.CopyItemDynamicParameters*.

Exemplo de código

Para obter o código de exemplo completo, consulte de exemplo de código AccessDbProviderSample04.

Criando o provedor do Windows PowerShell

Consulte Como registrar cmdlets, provedores e aplicativos host.

Testando o provedor do Windows PowerShell

Quando o provedor do Windows PowerShell tiver sido registrado no Windows PowerShell, você poderá testá-lo executando os cmdlets com suporte na linha de comando. Lembre-se de que a saída de exemplo a seguir usa um banco de dados do Access fictício.

  1. Execute o cmdlet Get-ChildItem para recuperar a lista de itens filho de uma tabela Customers no banco de dados do Access.

    Get-ChildItem mydb:customers

    A saída a seguir é exibida.

    PSPath        : AccessDB::customers
PSDrive       : mydb
PSProvider    : System.Management.Automation.ProviderInfo
PSIsContainer : True
Data          : System.Data.DataRow
Name          : Customers
RowCount      : 91
Columns       :

  2. Execute o cmdlet Get-ChildItem novamente para recuperar os dados de uma tabela.

    (Get-ChildItem mydb:customers).Data

    A saída a seguir é exibida.

    TABLE_CAT   : C:\PS\northwind
TABLE_SCHEM :
TABLE_NAME  : Customers
TABLE_TYPE  : TABLE
REMARKS     :

  3. Agora, use o cmdlet Get-Item para recuperar os itens na linha 0 na tabela de dados.

    Get-Item mydb:\customers\0

    A saída a seguir é exibida.

    PSPath        : AccessDB::customers\0
PSDrive       : mydb
PSProvider    : System.Management.Automation.ProviderInfo
PSIsContainer : False
Data          : System.Data.DataRow
RowNumber     : 0

  4. Reutilize Get-Item para recuperar os dados dos itens na linha 0.

    (Get-Item mydb:\customers\0).Data

    A saída a seguir é exibida.

    CustomerID   : 1234
CompanyName  : Fabrikam
ContactName  : Eric Gruber
ContactTitle : President
Address      : 4567 Main Street
City         : Buffalo
Region       : NY
PostalCode   : 98052
Country      : USA
Phone        : (425) 555-0100
Fax          : (425) 555-0101

  5. Agora, use o cmdlet New-Item para adicionar uma linha a uma tabela existente. O parâmetro Path especifica o caminho completo para a linha e deve indicar um número de linha maior que o número existente de linhas na tabela. O parâmetro Type indica Row para especificar esse tipo de item a ser adicionado. Por fim, o parâmetro Value especifica uma lista delimitada por vírgulas de valores de coluna para a linha.

    New-Item -Path mydb:\Customers\3 -ItemType "Row" -Value "3,CustomerFirstName,CustomerLastName,CustomerEmailAddress,CustomerTitle,CustomerCompany,CustomerPhone, CustomerAddress,CustomerCity,CustomerState,CustomerZip,CustomerCountry"

  6. Verifique a correção da nova operação de item da seguinte maneira.

    PS mydb:\> cd Customers
PS mydb:\Customers> (Get-Item 3).Data

    A saída a seguir é exibida.

    ID        : 3
FirstName : Eric
LastName  : Gruber
Email     : ericgruber@fabrikam.com
Title     : President
Company   : Fabrikam
WorkPhone : (425) 555-0100
Address   : 4567 Main Street
City      : Buffalo
State     : NY
Zip       : 98052
Country   : USA

Consulte Também

criando provedores do Windows PowerShell

criando seu provedor do Windows PowerShell

implementando um provedor do Windows PowerShell de item

implementando um provedor do Windows PowerShell de navegação

como registrar cmdlets, provedores e aplicativos host

do SDK do Windows PowerShell

guia do programador do Windows PowerShell