Feedback

Een Windows PowerShell-inhoudsprovider maken

  • Artikel
  • 15 minuten om te lezen

In dit onderwerp wordt beschreven hoe u een Windows PowerShell maakt waarmee de gebruiker de inhoud van de items in een gegevensopslag kan bewerken. Als gevolg hiervan wordt een provider die de inhoud van items kan bewerken, aangeduid als een Windows PowerShell-inhoudsprovider.

Notitie

U kunt het C#-bronbestand (AccessDBSampleProvider06.cs) voor deze provider downloaden met behulp van de Microsoft Windows Software Development Kit voor Windows Vista en .NET Framework 3.0 Runtime Components. Zie How to Install Windows PowerShell and Download the Windows PowerShell SDK voor downloadinstructies. De gedownloade bronbestanden zijn beschikbaar in de <PowerShell Samples> map . Zie Uw Windows PowerShell provider ontwerpen voor meer informatie over andere implementaties van Windows PowerShell-provider.

De inhoudsklasse Windows PowerShell inhoudsprovider definiëren

Een Windows PowerShell-inhoudsprovider moet een .NET-klasse maken die ondersteuning biedt voor de interface System.Management.Automation.Provider.Icontentcmdletprovider. Hier is de klassedefinitie voor de itemprovider die in deze sectie wordt beschreven.

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

In deze klassedefinitie bevat het kenmerk System.Management.Automation.Provider.Cmdletproviderattribute twee parameters. Met de eerste parameter geeft u een gebruiksvriendelijke naam op voor de provider die wordt gebruikt door Windows PowerShell. Met de tweede parameter geeft u de Windows PowerShell mogelijkheden op die de provider tijdens de verwerking van de opdracht Windows PowerShell aan de Windows PowerShell de provider. Voor deze provider zijn er geen toegevoegde Windows PowerShell specifieke mogelijkheden.

De functionaliteit van de basisklasse definiëren

Zoals beschreven in Uw Windows PowerShell-providerontwerpen, is de klasse System.Management.Automation.Provider.Navigationcmdletprovider afgeleid van verschillende andere klassen die verschillende providerfunctionaliteit bieden. Een Windows PowerShell-inhoudsprovider definieert daarom doorgaans alle functionaliteit van deze klassen.

Zie Creating a Basic Windows PowerShell Providervoormeer informatie over het implementeren van functionaliteit voor het toevoegen van sessiespecifieke initialisatiegegevens en voor het vrijgeven van resources die worden gebruikt door de provider. De meeste providers, met inbegrip van de provider die hier wordt beschreven, kunnen echter gebruikmaken van de standaard implementatie van deze functionaliteit die wordt geleverd door Windows PowerShell.

Voor toegang tot het gegevensopslag moet de provider de methoden van de basisklasse System.Management.Automation.Provider.Drivecmdletprovider implementeren. Zie creating a Windows PowerShell Drive Provider voor meer informatie over het implementeren van deze methoden.

Als u de items van een gegevensopslag wilt bewerken, zoals het verkrijgen, instellen en wissen van items, moet de provider de methoden implementeren die worden geleverd door de basisklasse System.Management.Automation.Provider.Itemcmdletprovider. Zie Creating a Windows PowerShell Item Provider (Een provider voor Windows PowerShell item maken) voor meer informatie over het implementeren van deze methoden.

Als u wilt werken met gegevensopslag met meerdere lagen, moet de provider de methoden implementeren die worden geleverd door de basisklasse System.Management.Automation.Provider.Containercmdletprovider. Zie Creating a Windows PowerShell Container Provider voor meer informatie over het implementeren van deze methoden.

Ter ondersteuning van recursieve opdrachten, geneste containers en relatieve paden moet de provider de basisklasse System.Management.Automation.Provider.Navigationcmdletprovider implementeren. Bovendien kan deze Windows PowerShell-inhoudsprovider System.Management.Automation.Provider.Icontentcmdletprovider-interface koppelen aan de basisklasse System.Management.Automation.Provider.Navigationcmdletprovider en moeten daarom de methoden van die klasse worden geïmplementeerd. Zie Implementing a Navigation Windows PowerShell Provider (Een navigatieprovider implementeren) voor meer informatie.

Een inhoudslezer implementeren

Als u inhoud van een item wilt lezen, moet een provider een inhoudslezerklasse implementeren die is afgeleid van System.Management.Automation.Provider.Icontentreader. De inhoudslezer voor deze provider geeft toegang tot de inhoud van een rij in een gegevenstabel. De inhoudslezerklasse definieert een methode Read waarmee de gegevens uit de aangegeven rij worden opgehaald en een lijst met die gegevens wordt weergegeven, een Zoek-methode waarmee de inhoudslezer wordt verplaatst, een methode Close waarmee de inhoudslezer wordt gesloten en een Methode Van verwijderen wordt opgehaald.

public class AccessDBContentReader : IContentReader
{
    // A provider instance is required so as to get "content"
    private AccessDBProvider provider;
    private string path;
    private long currentOffset;

    internal AccessDBContentReader(string path, AccessDBProvider provider)
    {
        this.path = path;
        this.provider = provider;
    }

    /// <summary>
    /// Read the specified number of rows from the source.
    /// </summary>
    /// <param name="readCount">The number of items to 
    /// return.</param>
    /// <returns>An array of elements read.</returns>
    public IList Read(long readCount)
    {
        // Read the number of rows specified by readCount and increment
        // offset
        string tableName;
        int rowNumber;
        PathType type = provider.GetNamesFromPath(path, out tableName, out rowNumber);

        Collection<DatabaseRowInfo> rows =
            provider.GetRows(tableName);
        Collection<DataRow> results = new Collection<DataRow>();

        if (currentOffset < 0 || currentOffset >= rows.Count)
        {
            return null;
        }

        int rowsRead = 0;

        while (rowsRead < readCount && currentOffset < rows.Count)
        {
            results.Add(rows[(int)currentOffset].Data);
            rowsRead++;
            currentOffset++;
        }

        return results;
    } // Read

    /// <summary>
    /// Moves the content reader specified number of rows from the 
    /// origin
    /// </summary>
    /// <param name="offset">Number of rows to offset</param>
    /// <param name="origin">Starting row from which to offset</param>
    public void Seek(long offset, System.IO.SeekOrigin origin)
    {
        // get the number of rows in the table which will help in
        // calculating current position
        string tableName;
        int rowNumber;

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

        if (type == PathType.Invalid)
        {
            throw new ArgumentException("Path specified must represent a table or a row :" + path);
        }

        if (type == PathType.Table)
        {
            Collection<DatabaseRowInfo> rows = provider.GetRows(tableName);

            int numRows = rows.Count;

            if (offset > rows.Count)
            {
                throw new
                       ArgumentException(
                           "Offset cannot be greater than the number of rows available"
                                        );
            }

            if (origin == System.IO.SeekOrigin.Begin)
            {
                // starting from Beginning with an index 0, the current offset
                // has to be advanced to offset - 1
                currentOffset = offset - 1;
            }
            else if (origin == System.IO.SeekOrigin.End)
            {
                // starting from the end which is numRows - 1, the current
                // offset is so much less than numRows - 1
                currentOffset = numRows - 1 - offset;
            }
            else
            {
                // calculate from the previous value of current offset
                // advancing forward always
                currentOffset += offset;
            }
        } // if (type...
        else
        {
            // for row, the offset will always be set to 0
            currentOffset = 0;
        }

    } // Seek

    /// <summary>
    /// Closes the content reader, so all members are reset
    /// </summary>
    public void Close()
    {
        Dispose();
    } // Close

    /// <summary>
    /// Dispose any resources being used
    /// </summary>
    public void Dispose()
    {
        Seek(0, System.IO.SeekOrigin.Begin);
        
        GC.SuppressFinalize(this);
    } // Dispose
} // AccessDBContentReader

Een inhoudsschrijver implementeren

Als u inhoud naar een item wilt schrijven, moet een provider een inhoudsschrijverklasse implementeren die is afgeleid van System.Management.Automation.Provider.Icontentwriter. De inhoudsschrijverklasse definieert een schrijfmethode waarmee de opgegeven rijinhoud wordt geschreven, een Zoek-methode waarmee de inhoudsschrijver wordt verplaatst, een methode Close waarmee de inhoudsschrijver wordt gesloten en een methode Voor verwijderen.

public class AccessDBContentWriter : IContentWriter
{
    // A provider instance is required so as to get "content"
    private AccessDBProvider provider;
    private string path;
    private long currentOffset;

    internal AccessDBContentWriter(string path, AccessDBProvider provider)
    {
        this.path = path;
        this.provider = provider;
    }

    /// <summary>
    /// Write the specified row contents in the source
    /// </summary>
    /// <param name="content"> The contents to be written to the source.
    /// </param>
    /// <returns>An array of elements which were successfully written to 
    /// the source</returns>
    /// 
    public IList Write(IList content)
    {
        if (content == null)
        {
            return null;
        }

        // Get the total number of rows currently available it will 
        // determine how much to overwrite and how much to append at
        // the end
        string tableName;
        int rowNumber;
        PathType type = provider.GetNamesFromPath(path, out tableName, out rowNumber);

        if (type == PathType.Table)
        {
            OdbcDataAdapter da = provider.GetAdapterForTable(tableName);
            if (da == null)
            {
                return null;
            }

            DataSet ds = provider.GetDataSetForTable(da, tableName);
            DataTable table = provider.GetDataTable(ds, tableName);

            string[] colValues = (content[0] as string).Split(',');

            // set the specified row
            DataRow row = table.NewRow();

            for (int i = 0; i < colValues.Length; i++)
            {
                if (!String.IsNullOrEmpty(colValues[i]))
                {
                    row[i] = colValues[i];
                }
            }

            //table.Rows.InsertAt(row, rowNumber);
            // Update the table
            table.Rows.Add(row);
            da.Update(ds, tableName);
            
        }
        else 
        {
            throw new InvalidOperationException("Operation not supported. Content can be added only for tables");
        }

        return null;
    } // Write

    /// <summary>
    /// Moves the content reader specified number of rows from the 
    /// origin
    /// </summary>
    /// <param name="offset">Number of rows to offset</param>
    /// <param name="origin">Starting row from which to offset</param>
    public void Seek(long offset, System.IO.SeekOrigin origin)
    {
        // get the number of rows in the table which will help in
        // calculating current position
        string tableName;
        int rowNumber;

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

        if (type == PathType.Invalid)
        {
            throw new ArgumentException("Path specified should represent either a table or a row : " + path);
        }

        Collection<DatabaseRowInfo> rows =
               provider.GetRows(tableName);

        int numRows = rows.Count;

        if (offset > rows.Count)
        {
            throw new
                   ArgumentException(
                       "Offset cannot be greater than the number of rows available"
                                           );
        }

        if (origin == System.IO.SeekOrigin.Begin)
        {
            // starting from Beginning with an index 0, the current offset
            // has to be advanced to offset - 1
            currentOffset = offset - 1;
        }
        else if (origin == System.IO.SeekOrigin.End)
        {
            // starting from the end which is numRows - 1, the current
            // offset is so much less than numRows - 1
            currentOffset = numRows - 1 - offset;
        }
        else
        {
            // calculate from the previous value of current offset
            // advancing forward always
            currentOffset += offset;
        }

    } // Seek

    /// <summary>
    /// Closes the content reader, so all members are reset
    /// </summary>
    public void Close()
    {
        Dispose();
    } // Close

    /// <summary>
    /// Dispose any resources being used
    /// </summary>
    public void Dispose()
    {
        Seek(0, System.IO.SeekOrigin.Begin);

        GC.SuppressFinalize(this);
    } // Dispose
} // AccessDBContentWriter

Inhoudslezer ophalen

Om inhoud van een item op te halen, moet de provider system.Management.Automation.Provider.Icontentcmdletprovider.Getcontentreader* implementeren om de Get-Content cmdlet te ondersteunen. Deze methode retourneert de inhoudslezer voor het item dat zich op het opgegeven pad bevindt. Het object Reader kan vervolgens worden geopend om de inhoud te lezen.

Hier is de implementatie van System.Management.Automation.Provider.Icontentcmdletprovider.Getcontentreader* voor deze methode voor deze provider.

public IContentReader GetContentReader(string path)
{
    string tableName;
    int rowNumber;

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

    if (type == PathType.Invalid)
    {
        ThrowTerminatingInvalidPathException(path);
    }
    else if (type == PathType.Row)
    {
        throw new InvalidOperationException("contents can be obtained only for tables");
    }

    return new AccessDBContentReader(path, this);
} // GetContentReader

public IContentReader GetContentReader(string path)
{
    string tableName;
    int rowNumber;

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

    if (type == PathType.Invalid)
    {
        ThrowTerminatingInvalidPathException(path);
    }
    else if (type == PathType.Row)
    {
        throw new InvalidOperationException("contents can be obtained only for tables");
    }

    return new AccessDBContentReader(path, this);
} // GetContentReader

Dingen om te onthouden over het implementeren van GetContentReader

De volgende voorwaarden kunnen van toepassing zijn op een implementatie van System.Management.Automation.Provider.Icontentcmdletprovider.Getcontentreader*:

Dynamische parameters koppelen aan de Get-Content cmdlet

Voor Get-Content de cmdlet zijn mogelijk aanvullende parameters vereist die dynamisch worden opgegeven tijdens runtime. Om deze dynamische parameters op te geven, moet de Windows PowerShell de methode System.Management.Automation.Provider.Icontentcmdletprovider.Getcontentreaderdynamicparameters* implementeren. Deze methode haalt dynamische parameters op voor het item op het aangegeven pad en retourneert een object met eigenschappen en velden met parseerkenmerken die vergelijkbaar zijn met een cmdlet-klasse of een System.Management.Automation.Runtimedefinedparameterdictionary-object. De Windows PowerShell runtime gebruikt het geretourneerde object om de parameters toe te voegen aan de cmdlet .

Deze Windows PowerShell containerprovider implementeert deze methode niet. De volgende code is echter de standaard implementatie van deze methode.

public object GetContentReaderDynamicParameters(string path)
{
    return null;
}

public object GetContentReaderDynamicParameters(string path)
{
    return null;
}

Inhoudsschrijver ophalen

Als u inhoud naar een item wilt schrijven, moet de provider system.Management.Automation.Provider.Icontentcmdletprovider.Getcontentwriter* implementeren ter ondersteuning van de Set-Content Add-Content cmdlets en . Deze methode retourneert de inhoudsschrijver voor het item dat zich op het opgegeven pad bevindt.

Hier is de implementatie van System.Management.Automation.Provider.Icontentcmdletprovider.Getcontentwriter* voor deze methode.

public IContentWriter GetContentWriter(string path)
{
    string tableName;
    int rowNumber;

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

    if (type == PathType.Invalid)
    {
        ThrowTerminatingInvalidPathException(path);
    }
    else if (type == PathType.Row)
    {
        throw new InvalidOperationException("contents can be added only to tables");
    }

    return new AccessDBContentWriter(path, this);
}

public IContentWriter GetContentWriter(string path)
{
    string tableName;
    int rowNumber;

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

    if (type == PathType.Invalid)
    {
        ThrowTerminatingInvalidPathException(path);
    }
    else if (type == PathType.Row)
    {
        throw new InvalidOperationException("contents can be added only to tables");
    }

    return new AccessDBContentWriter(path, this);
}

Dingen om te onthouden over het implementeren van GetContentWriter

De volgende voorwaarden kunnen van toepassing zijn op uw implementatie van System.Management.Automation.Provider.Icontentcmdletprovider.Getcontentwriter*:

Dynamische parameters koppelen aan de Add-Content en Set-Content cmdlets

Voor Add-Content de Set-Content cmdlets en zijn mogelijk aanvullende dynamische parameters vereist die een runtime worden toegevoegd. Om deze dynamische parameters op te geven, moet de Windows PowerShell-inhoudsprovider de methode System.Management.Automation.Provider.Icontentcmdletprovider.Getcontentwriterdynamicparameters* implementeren om deze parameters te verwerken. Deze methode haalt dynamische parameters op voor het item op het aangegeven pad en retourneert een object met eigenschappen en velden met parseerkenmerken die vergelijkbaar zijn met een cmdlet-klasse of een System.Management.Automation.Runtimedefinedparameterdictionary-object. De Windows PowerShell runtime gebruikt het geretourneerde object om de parameters toe te voegen aan de cmdlets.

Deze Windows PowerShell containerprovider implementeert deze methode niet. De volgende code is echter de standaard implementatie van deze methode.

public object GetContentWriterDynamicParameters(string path)
{
    return null;
}

Inhoud wissen

Uw inhoudsprovider implementeert de methode System.Management.Automation.Provider.Icontentcmdletprovider.Clearcontent* ter ondersteuning van de Clear-Content cmdlet. Met deze methode wordt de inhoud van het item op het opgegeven pad verwijderd, maar blijft het item intact.

Hier is de implementatie van de methode System.Management.Automation.Provider.Icontentcmdletprovider.Clearcontent* voor deze provider.

public void ClearContent(string path)
{
    string tableName;
    int rowNumber;

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

    if (type != PathType.Table)
    {
        WriteError(new ErrorRecord(
            new InvalidOperationException("Operation not supported. Content can be cleared only for table"),
                "NotValidRow", ErrorCategory.InvalidArgument,
                    path));
        return;
    }

    OdbcDataAdapter da = GetAdapterForTable(tableName);

    if (da == null)
    {
        return;
    }

    DataSet ds = GetDataSetForTable(da, tableName);
    DataTable table = GetDataTable(ds, tableName);

    // Clear contents at the specified location
    for (int i = 0; i < table.Rows.Count; i++)
    {
        table.Rows[i].Delete();
    }

    if (ShouldProcess(path, "ClearContent"))
    {
        da.Update(ds, tableName);
    }

} // ClearContent

Dingen om te onthouden over het implementeren van ClearContent

De volgende voorwaarden kunnen van toepassing zijn op een implementatie van System.Management.Automation.Provider.Icontentcmdletprovider.Clearcontent*:

Dynamische parameters koppelen aan de Clear-Content cmdlet

De Clear-Content cmdlet vereist mogelijk aanvullende dynamische parameters die tijdens runtime worden toegevoegd. Om deze dynamische parameters op te geven, moet de Windows PowerShell-inhoudsprovider de methode System.Management.Automation.Provider.Icontentcmdletprovider.Clearcontentdynamicparameters* implementeren om deze parameters te verwerken. Met deze methode worden de parameters voor het item opgehaald op het aangegeven pad. Deze methode haalt dynamische parameters op voor het item op het aangegeven pad en retourneert een object met eigenschappen en velden met parseerkenmerken die vergelijkbaar zijn met een cmdlet-klasse of een System.Management.Automation.Runtimedefinedparameterdictionary-object. De Windows PowerShell runtime gebruikt het geretourneerde object om de parameters toe te voegen aan de cmdlet .

Deze Windows PowerShell containerprovider implementeert deze methode niet. De volgende code is echter de standaard implementatie van deze methode.

public object ClearContentDynamicParameters(string path)
{
    return null;
}

public object ClearContentDynamicParameters(string path)
{
    return null;
}

Codevoorbeeld

Zie AccessDbProviderSample06 Code Samplevoor de volledige voorbeeldcode.

Objecttypen en -opmaak definiëren

Bij het schrijven van een provider kan het nodig zijn om leden toe te voegen aan bestaande objecten of om nieuwe objecten te definiëren. Wanneer dit is gebeurd, moet u een bestand Typen maken dat Windows PowerShell kan gebruiken om de leden van het object te identificeren en een indelingsbestand dat definieert hoe het object wordt weergegeven. Zie Extending Object Types and Formatting (Objecttypen uitbreiden en formatteren) voor meer informatie.

De Windows PowerShell-provider bouwen

Zie Cmdlets, providers en hosttoepassingen registreren.

De Windows PowerShell-provider testen

Wanneer uw Windows PowerShell provider is geregistreerd bij Windows PowerShell, kunt u deze testen door de ondersteunde cmdlets uit te voeren op de opdrachtregel. Test bijvoorbeeld de voorbeeldinhoudsprovider.

Gebruik de cmdlet om de inhoud van het opgegeven item op te halen in de Get-Content databasetabel op het pad dat is opgegeven door de parameter Path . De parameter geeft het aantal items aan dat de ReadCount gedefinieerde inhoudslezer moet lezen (standaard 1). Met de volgende opdracht wordt met de cmdlet twee rijen (items) opgehaald uit de tabel en wordt de inhoud ervan weergegeven. In de volgende voorbeelduitvoer wordt een fictieve Access-database gebruikt.

Get-Content -Path mydb:\Customers -ReadCount 2

ID        : 1
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
ID        : 2
FirstName : Eva
LastName  : Corets
Email     : evacorets@cohowinery.com
Title     : Sales Representative
Company   : Coho Winery
WorkPhone : (360) 555-0100
Address   : 8910 Main Street
City      : Cabmerlot
State     : WA
Zip       : 98089
Country   : USA

Zie ook

Een Windows PowerShell maken

Uw Windows PowerShell ontwerpen

Objecttypen en -opmaak uitbreiden

Een navigatieprovider Windows PowerShell implementeren

Cmdlets, providers en hosttoepassingen registreren

Windows PowerShell SDK

Handleiding voor Windows PowerShell-programmeurs