データストアにアクセスするためのコマンドレットを作成する

2025-03-25

このセクションでは、Windows PowerShell プロバイダーを使用して格納されているデータにアクセスするコマンドレットを作成する方法について説明します。この種類のコマンドレットは、Windows PowerShell ランタイムの Windows PowerShell プロバイダーインフラストラクチャを使用するため、コマンドレットクラスは System.Management.Automation.PSCmdlet 基本クラスから派生する必要があります。

ここで説明する Select-Str コマンドレットは、ファイルまたはオブジェクト内の文字列を検索して選択できます。文字列の識別に使用するパターンは、コマンドレットの Path パラメーターを使用して明示的に指定することも、Script パラメーターを使用して暗黙的に指定することもできます。

このコマンドレットは、System.Management.Automation.Provider.IContentCmdletProviderから派生した任意の Windows PowerShell プロバイダーを使用するように設計されています。たとえば、このコマンドレットでは、Windows PowerShell によって提供される FileSystem プロバイダーまたは変数プロバイダーを指定できます。 Windows PowerShell プロバイダーの詳細については、「Windows PowerShell プロバイダーの設計」を参照してください。

コマンドレットクラスの定義

コマンドレットの作成の最初の手順は、常にコマンドレットに名前を付け、コマンドレットを実装する .NET クラスを宣言することです。このコマンドレットは特定の文字列を検出するため、ここで選択した動詞名は "Select" であり、System.Management.Automation.VerbsCommon クラスによって定義されます。コマンドレットが文字列に対して機能するため、名詞名 "Str" が使用されます。以下の宣言では、コマンドレットの動詞と名詞名がコマンドレットクラスの名前に反映されることに注意してください。承認されたコマンドレット動詞の詳細については、「コマンドレットの動詞名を参照してください。

このコマンドレットの .NET クラスは、System.Management.Automation.PSCmdlet 基本クラスから派生する必要があります。これは、Windows PowerShell プロバイダーインフラストラクチャを公開するために Windows PowerShell ランタイムが必要とするサポートを提供するためです。このコマンドレットでは、System.Text.RegularExpressions.Regex などの .NET Framework 正規表現クラスも使用注意してください。

次のコードは、この Select-Str コマンドレットのクラス定義です。

[Cmdlet(VerbsCommon.Select, "Str", DefaultParameterSetName="PatternParameterSet")]
public class SelectStringCommand : PSCmdlet

このコマンドレットは、DefaultParameterSetName 属性キーワードをクラス宣言に追加することで、既定のパラメーターセットを定義します。既定のパラメーターセット PatternParameterSet は、Script パラメーターが指定されていない場合に使用されます。このパラメーターセットの詳細については、次のセクションの Pattern および Script パラメーターの説明を参照してください。

データアクセスのパラメーターの定義

このコマンドレットでは、ユーザーが格納されているデータにアクセスして調べることができるように、いくつかのパラメーターを定義します。これらのパラメーターには、データストアの場所を示す Path パラメーター、検索で使用するパターンを指定する Pattern パラメーター、および検索の実行方法をサポートするその他のいくつかのパラメーターが含まれます。

注

パラメーターの定義の基本の詳細については、「コマンドライン入力を処理するパラメーターの追加」を参照してください。

Path パラメーターの宣言

データストアを見つけるには、このコマンドレットで Windows PowerShell パスを使用して、データストアにアクセスするように設計された Windows PowerShell プロバイダーを識別する必要があります。そのため、プロバイダーの場所を示す文字列配列型の Path パラメーターを定義します。

[Parameter(
           Position = 0,
           ParameterSetName = "ScriptParameterSet",
           Mandatory = true)]
[Parameter(
           Position = 0,
           ParameterSetName = "PatternParameterSet",
           ValueFromPipeline = true,
           Mandatory = true)]
           [Alias("PSPath")]
public string[] Path
{
  get { return paths; }
  set { paths = value; }
}
private string[] paths;

このパラメーターは 2 つの異なるパラメーターセットに属し、エイリアスを持つ点に注意してください。

2 つの System.Management.Automation.ParameterAttribute 属性は、Path パラメーターが ScriptParameterSet と PatternParameterSetに属することを宣言します。パラメーターセットの詳細については、「コマンドレットへのパラメーターセットの追加」を参照してください。

System.Management.Automation.AliasAttribute 属性は、Path パラメーターの PSPath エイリアスを宣言します。 Windows PowerShell プロバイダーにアクセスする他のコマンドレットとの一貫性を確保するために、このエイリアスを宣言することを強くお勧めします。 Windows PowerShell パスの詳細については、「Windows PowerShell ののしくみ」の「PowerShell パスの概念」を参照してください。

パターンパラメーターの宣言

検索するパターンを指定するために、このコマンドレットは文字列の配列である Pattern パラメーターを宣言します。データストアにパターンのいずれかが見つかると、正の結果が返されます。これらのパターンは、コンパイルされた正規表現の配列またはリテラル検索に使用されるワイルドカードパターンの配列にコンパイルできることに注意してください。

[Parameter(
           Position = 1,
           ParameterSetName = "PatternParameterSet",
           Mandatory = true)]
public string[] Pattern
{
  get { return patterns; }
  set { patterns = value; }
}
private string[] patterns;
private Regex[] regexPattern;
private WildcardPattern[] wildcardPattern;

このパラメーターを指定すると、コマンドレットは既定のパラメーターセット PatternParameterSet使用します。この場合、コマンドレットはここで指定したパターンを使用して文字列を選択します。これに対し、Script パラメーターを使用して、パターンを含むスクリプトを提供することもできます。 Script パラメーターと Pattern パラメーターは、2 つの個別のパラメーターセットを定義するため、相互に排他的です。

検索サポートパラメーターの宣言

このコマンドレットは、コマンドレットの検索機能を変更するために使用できる次のサポートパラメーターを定義します。

Script パラメーターは、コマンドレットの代替検索メカニズムを提供するために使用できるスクリプトブロックを指定します。スクリプトには、一致に使用するパターンが含まれている必要があり、System.Management.Automation.PSObject オブジェクトを返します。このパラメーターは、ScriptParameterSet パラメーターセットを識別する一意のパラメーターでもあります。 Windows PowerShell ランタイムでこのパラメーターが表示されると、ScriptParameterSet パラメーターセットに属するパラメーターのみが使用されます。

[Parameter(
           Position = 1,
           ParameterSetName = "ScriptParameterSet",
           Mandatory = true)]
public ScriptBlock Script
{
  set { script = value; }
  get { return script; }
}
ScriptBlock script;

SimpleMatch パラメーターは、コマンドレットが指定されたパターンと明示的に一致するかどうかを示す switch パラメーターです。ユーザーがコマンドライン (true) でパラメーターを指定すると、コマンドレットは指定されたパターンを使用します。パラメーターが指定されていない場合 (false)、コマンドレットは正規表現を使用します。このパラメーターの既定値は falseです。

[Parameter]
public SwitchParameter SimpleMatch
{
  get { return simpleMatch; }
  set { simpleMatch = value; }
}
private bool simpleMatch;

CaseSensitive パラメーターは、大文字と小文字を区別する検索が実行されるかどうかを示す switch パラメーターです。ユーザーがコマンドライン (true) でパラメーターを指定すると、パターンを比較するときに、大文字と小文字がチェックされます。パラメーターが指定されていない場合 (false)、コマンドレットは大文字と小文字を区別しません。たとえば、"MyFile" と "myfile" の両方が正のヒットとして返されます。このパラメーターの既定値は falseです。

[Parameter]
public SwitchParameter CaseSensitive
{
  get { return caseSensitive; }
  set { caseSensitive = value; }
}
private bool caseSensitive;

Exclude パラメーターと Include パラメーターは、検索から明示的に除外されたアイテムまたは検索に含まれているアイテムを識別します。既定では、コマンドレットはデータストア内のすべての項目を検索します。ただし、コマンドレットによって実行される検索を制限するために、これらのパラメーターを使用して、検索に含める項目または省略する項目を明示的に示すことができます。

[Parameter]
public SwitchParameter CaseSensitive
{
  get { return caseSensitive; }
  set { caseSensitive = value; }
}
private bool caseSensitive;

[Parameter]
[ValidateNotNullOrEmpty]
public string[] Include
{
  get
  {
    return includeStrings;
  }
  set
  {
    includeStrings = value;

    this.include = new WildcardPattern[includeStrings.Length];
    for (int i = 0; i < includeStrings.Length; i++)
    {
      this.include[i] = new WildcardPattern(includeStrings[i], WildcardOptions.IgnoreCase);
    }
  }
}

internal string[] includeStrings = null;
internal WildcardPattern[] include = null;

パラメーターセットの宣言

このコマンドレットでは、データアクセスで使用される 2 つのパラメーターセットの名前として、2 つのパラメーターセット (ScriptParameterSet と PatternParameterSetが既定値) を使用します。 PatternParameterSet は既定のパラメーターセットであり、Pattern パラメーターを指定するときに使用されます。 ScriptParameterSet は、ユーザーが Script パラメーターを使用して代替検索メカニズムを指定するときに使用されます。パラメーターセットの詳細については、「コマンドレットへのパラメーターセットの追加」を参照してください。

入力処理メソッドのオーバーライド

コマンドレットは、System.Management.Automation.PSCmdlet クラスの 1 つ以上の入力処理メソッドをオーバーライドする必要があります。入力処理メソッドの詳細については、「最初のコマンドレットの作成」を参照してください。

このコマンドレットは、System.Management.Automation.Cmdlet.BeginProcessing メソッドをオーバーライドして、起動時にコンパイルされた正規表現の配列を構築します。これにより、単純な照合を使用しない検索中のパフォーマンスが向上します。

protected override void BeginProcessing()
{
  WriteDebug("Validating patterns.");
  if (patterns != null)
  {
    foreach(string pattern in patterns)
    {
      if (pattern == null)
      ThrowTerminatingError(new ErrorRecord(
                            new ArgumentNullException(
                            "Search pattern cannot be null."),
                            "NullSearchPattern",
                            ErrorCategory.InvalidArgument,
                            pattern)
                            );
    }

    WriteVerbose("Search pattern(s) are valid.");

    // If a simple match is not specified, then
    // compile the regular expressions once.
    if (!simpleMatch)
    {
      WriteDebug("Compiling search regular expressions.");

      RegexOptions regexOptions = RegexOptions.Compiled;
      if (!caseSensitive)
         regexOptions |= RegexOptions.Compiled;
      regexPattern = new Regex[patterns.Length];

      for (int i = 0; i < patterns.Length; i++)
      {
        try
        {
          regexPattern[i] = new Regex(patterns[i], regexOptions);
        }
        catch (ArgumentException ex)
        {
          ThrowTerminatingError(new ErrorRecord(
                        ex,
                        "InvalidRegularExpression",
                        ErrorCategory.InvalidArgument,
                        patterns[i]
                     ));
        }
      } //Loop through patterns to create RegEx objects.

      WriteVerbose("Pattern(s) compiled into regular expressions.");
    }// If not a simple match.

    // If a simple match is specified, then compile the
    // wildcard patterns once.
    else
    {
      WriteDebug("Compiling search wildcards.");

      WildcardOptions wildcardOptions = WildcardOptions.Compiled;

      if (!caseSensitive)
      {
        wildcardOptions |= WildcardOptions.IgnoreCase;
      }

      wildcardPattern = new WildcardPattern[patterns.Length];
      for (int i = 0; i < patterns.Length; i++)
      {
        wildcardPattern[i] =
                     new WildcardPattern(patterns[i], wildcardOptions);
      }

      WriteVerbose("Pattern(s) compiled into wildcard expressions.");
    }// If match is a simple match.
  }// If valid patterns are available.
}// End of function BeginProcessing().

このコマンドレットは、System.Management.Automation.Cmdlet.ProcessRecord メソッドをオーバーライドして、ユーザーがコマンドラインで行う文字列の選択を処理します。プライベート MatchString メソッドを呼び出して、文字列選択の結果をカスタムオブジェクトの形式で書き込みます。

protected override void ProcessRecord()
{
  UInt64 lineNumber = 0;
  MatchInfo result;
  ArrayList nonMatches = new ArrayList();

  // Walk the list of paths and search the contents for
  // any of the specified patterns.
  foreach (string psPath in paths)
  {
    // Once the filepaths are expanded, we may have more than one
    // path, so process all referenced paths.
    foreach(PathInfo path in
            SessionState.Path.GetResolvedPSPathFromPSPath(psPath)
           )
    {
      WriteVerbose("Processing path " + path.Path);

      // Check if the path represents one of the items to be
      // excluded. If so, continue to next path.
      if (!MeetsIncludeExcludeCriteria(path.ProviderPath))
         continue;

      // Get the content reader for the item(s) at the
      // specified path.
      Collection<IContentReader> readerCollection = null;
      try
      {
        readerCollection =
                    this.InvokeProvider.Content.GetReader(path.Path);
      }
      catch (PSNotSupportedException ex)
      {
        WriteError(new ErrorRecord(ex,
                   "ContentAccessNotSupported",
                    ErrorCategory.NotImplemented,
                    path.Path)
                   );
        return;
      }

      foreach(IContentReader reader in readerCollection)
      {
        // Reset the line number for this path.
        lineNumber = 0;

        // Read in a single block (line in case of a file)
        // from the object.
        IList items = reader.Read(1);

        // Read and process one block(line) at a time until
        // no more blocks(lines) exist.
        while (items != null && items.Count == 1)
        {
          // Increment the line number each time a line is
          // processed.
          lineNumber++;

          String message = String.Format("Testing line {0} : {1}",
                                        lineNumber, items[0]);

          WriteDebug(message);

          result = SelectString(items[0]);

          if (result != null)
          {
            result.Path = path.Path;
            result.LineNumber = lineNumber;

            WriteObject(result);
          }
          else
          {
            // Add the block(line) that did not match to the
            // collection of non matches , which will be stored
            // in the SessionState variable $NonMatches
            nonMatches.Add(items[0]);
          }

          // Get the next line from the object.
          items = reader.Read(1);

        }// While loop for reading one line at a time.
      }// Foreach loop for reader collection.
    }// Foreach loop for processing referenced paths.
  }// Foreach loop for walking of path list.

  // Store the list of non-matches in the
  // session state variable $NonMatches.
  try
  {
    this.SessionState.PSVariable.Set("NonMatches", nonMatches);
  }
  catch (SessionStateUnauthorizedAccessException ex)
  {
    WriteError(new ErrorRecord(ex,
               "CannotWriteVariableNonMatches",
               ErrorCategory.InvalidOperation,
               nonMatches)
              );
  }

}// End of protected override void ProcessRecord().

コンテンツへのアクセス

データにアクセスできるように、コマンドレットで Windows PowerShell パスで示されているプロバイダーを開く必要があります。実行空間の System.Management.Automation.SessionState オブジェクトはプロバイダーへのアクセスに使用され、コマンドレットの System.Management.Automation.PSCmdlet.InvokeProvider* プロパティを使用してプロバイダーを開きます。コンテンツへのアクセスは、開かれたプロバイダーの System.Management.Automation.ProviderIntrinsics オブジェクトを取得することによって提供されます。

このサンプル Select-Str コマンドレットでは、System.Management.Automation.ProviderIntrinsics.Content* プロパティを使用して、スキャンするコンテンツを公開します。その後、System.Management.Automation.ContentCmdletProviderIntrinsics.GetReader* メソッドを呼び出し、必要な Windows PowerShell パスを渡すことができます。

コードサンプル

次のコードは、この Select-Str コマンドレットのこのバージョンの実装を示しています。このコードには、コマンドレットクラス、コマンドレットで使用されるプライベートメソッド、およびコマンドレットの登録に使用される Windows PowerShell スナップインコードが含まれていることに注意してください。コマンドレットの登録の詳細については、「コマンドレットのビルド」を参照してください。

//
// Copyright (c) 2006 Microsoft Corporation. All rights reserved.
//
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
using System;
using System.Text.RegularExpressions;
using System.Collections;
using System.Collections.ObjectModel;
using System.Management.Automation;
using System.Management.Automation.Provider;
using System.ComponentModel;

namespace Microsoft.Samples.PowerShell.Commands
{
  #region SelectStringCommand
  /// <summary>
  /// This cmdlet searches through PSObjects for particular patterns.
  /// </summary>
  /// <remarks>
  /// This cmdlet can be used to search any object, such as a file or a
  /// variable, whose provider exposes methods for reading and writing
  /// content.
  /// </remarks>
  [Cmdlet(VerbsCommon.Select, "Str", DefaultParameterSetName="PatternParameterSet")]
  public class SelectStringCommand : PSCmdlet
  {
    #region Parameters
    /// <summary>
    /// Declare a Path parameter that specifies where the data is stored.
    /// This parameter must specify a PowerShell that indicates the
    /// PowerShell provider that is used to access the objects to be
    /// searched for matching patterns. This parameter should also have
    /// a PSPath alias to provide consistency with other cmdlets that use
    /// PowerShell providers.
    /// </summary>
    /// <value>Path of the object(s) to search.</value>
    [Parameter(
               Position = 0,
               ParameterSetName = "ScriptParameterSet",
               Mandatory = true)]
    [Parameter(
               Position = 0,
               ParameterSetName = "PatternParameterSet",
               ValueFromPipeline = true,
               Mandatory = true)]
               [Alias("PSPath")]
    public string[] Path
    {
      get { return paths; }
      set { paths = value; }
    }
    private string[] paths;

    /// <summary>
    /// Declare a Pattern parameter that specifies the pattern(s)
    /// used to find matching patterns in the string representation
    /// of the objects. A positive result will be returned
    /// if any of the patterns are found in the objects.
    /// </summary>
    /// <remarks>
    /// The patterns will be compiled into an array of wildcard
    /// patterns for a simple match (literal string matching),
    /// or the patterns will be converted into an array of compiled
    /// regular expressions.
    /// </remarks>
    /// <value>Array of patterns to search.</value>
    [Parameter(
               Position = 1,
               ParameterSetName = "PatternParameterSet",
               Mandatory = true)]
    public string[] Pattern
    {
      get { return patterns; }
      set { patterns = value; }
    }
    private string[] patterns;
    private Regex[] regexPattern;
    private WildcardPattern[] wildcardPattern;

    /// <summary>
    /// Declare a Script parameter that specifies a script block
    /// that is called to perform the matching operations
    /// instead of the matching performed by the cmdlet.
    /// </summary>
    /// <value>Script block that will be called for matching</value>
    [Parameter(
               Position = 1,
               ParameterSetName = "ScriptParameterSet",
               Mandatory = true)]
    public ScriptBlock Script
    {
      set { script = value; }
      get { return script; }
    }
    ScriptBlock script;

    /// <summary>
    /// Declare a switch parameter that specifies if the pattern(s) are used
    /// literally. If not (default), searching is
    /// done using regular expressions.
    /// </summary>
    /// <value>If True, a literal pattern is used.</value>
    [Parameter]
    public SwitchParameter SimpleMatch
    {
      get { return simpleMatch; }
      set { simpleMatch = value; }
    }
    private bool simpleMatch;

    /// <summary>
    /// Declare a switch parameter that specifies if a case-sensitive
    /// search is performed.  If not (default), a case-insensitive search
    /// is performed.
    /// </summary>
    /// <value>If True, a case-sensitive search is made.</value>
    [Parameter]
    public SwitchParameter CaseSensitive
    {
      get { return caseSensitive; }
      set { caseSensitive = value; }
    }
    private bool caseSensitive;

    /// <summary>
    /// Declare an Include parameter that species which
    /// specific items are searched.  When this parameter
    /// is used, items that are not listed here are omitted
    /// from the search.
    /// </summary>
    [Parameter]
    [ValidateNotNullOrEmpty]
    public string[] Include
    {
      get
      {
        return includeStrings;
      }
      set
      {
        includeStrings = value;

        this.include = new WildcardPattern[includeStrings.Length];
        for (int i = 0; i < includeStrings.Length; i++)
        {
          this.include[i] = new WildcardPattern(includeStrings[i], WildcardOptions.IgnoreCase);
        }
      }
    }

    internal string[] includeStrings = null;
    internal WildcardPattern[] include = null;

    /// <summary>
    /// Declare an Exclude parameter that species which
    /// specific items are omitted from the search.
    /// </summary>
    ///
    [Parameter]
    [ValidateNotNullOrEmpty]
    public string[] Exclude
    {
      get
      {
        return excludeStrings;
      }
      set
      {
        excludeStrings = value;

        this.exclude = new WildcardPattern[excludeStrings.Length];
        for (int i = 0; i < excludeStrings.Length; i++)
        {
          this.exclude[i] = new WildcardPattern(excludeStrings[i], WildcardOptions.IgnoreCase);
        }
      }
    }
    internal string[] excludeStrings;
    internal WildcardPattern[] exclude;

    #endregion Parameters

    #region Overrides
    /// <summary>
    /// If regular expressions are used for pattern matching,
    /// then build an array of compiled regular expressions
    /// at startup. This increases performance during scanning
    /// operations when simple matching is not used.
    /// </summary>
    protected override void BeginProcessing()
    {
      WriteDebug("Validating patterns.");
      if (patterns != null)
      {
        foreach(string pattern in patterns)
        {
          if (pattern == null)
          ThrowTerminatingError(new ErrorRecord(
                                new ArgumentNullException(
                                "Search pattern cannot be null."),
                                "NullSearchPattern",
                                ErrorCategory.InvalidArgument,
                                pattern)
                                );
        }

        WriteVerbose("Search pattern(s) are valid.");

        // If a simple match is not specified, then
        // compile the regular expressions once.
        if (!simpleMatch)
        {
          WriteDebug("Compiling search regular expressions.");

          RegexOptions regexOptions = RegexOptions.Compiled;
          if (!caseSensitive)
             regexOptions |= RegexOptions.Compiled;
          regexPattern = new Regex[patterns.Length];

          for (int i = 0; i < patterns.Length; i++)
          {
            try
            {
              regexPattern[i] = new Regex(patterns[i], regexOptions);
            }
            catch (ArgumentException ex)
            {
              ThrowTerminatingError(new ErrorRecord(
                            ex,
                            "InvalidRegularExpression",
                            ErrorCategory.InvalidArgument,
                            patterns[i]
                         ));
            }
          } //Loop through patterns to create RegEx objects.

          WriteVerbose("Pattern(s) compiled into regular expressions.");
        }// If not a simple match.

        // If a simple match is specified, then compile the
        // wildcard patterns once.
        else
        {
          WriteDebug("Compiling search wildcards.");

          WildcardOptions wildcardOptions = WildcardOptions.Compiled;

          if (!caseSensitive)
          {
            wildcardOptions |= WildcardOptions.IgnoreCase;
          }

          wildcardPattern = new WildcardPattern[patterns.Length];
          for (int i = 0; i < patterns.Length; i++)
          {
            wildcardPattern[i] =
                         new WildcardPattern(patterns[i], wildcardOptions);
          }

          WriteVerbose("Pattern(s) compiled into wildcard expressions.");
        }// If match is a simple match.
      }// If valid patterns are available.
    }// End of function BeginProcessing().

    /// <summary>
    /// Process the input and search for the specified patterns.
    /// </summary>
    protected override void ProcessRecord()
    {
      UInt64 lineNumber = 0;
      MatchInfo result;
      ArrayList nonMatches = new ArrayList();

      // Walk the list of paths and search the contents for
      // any of the specified patterns.
      foreach (string psPath in paths)
      {
        // Once the filepaths are expanded, we may have more than one
        // path, so process all referenced paths.
        foreach(PathInfo path in
                SessionState.Path.GetResolvedPSPathFromPSPath(psPath)
               )
        {
          WriteVerbose("Processing path " + path.Path);

          // Check if the path represents one of the items to be
          // excluded. If so, continue to next path.
          if (!MeetsIncludeExcludeCriteria(path.ProviderPath))
             continue;

          // Get the content reader for the item(s) at the
          // specified path.
          Collection<IContentReader> readerCollection = null;
          try
          {
            readerCollection =
                        this.InvokeProvider.Content.GetReader(path.Path);
          }
          catch (PSNotSupportedException ex)
          {
            WriteError(new ErrorRecord(ex,
                       "ContentAccessNotSupported",
                        ErrorCategory.NotImplemented,
                        path.Path)
                       );
            return;
          }

          foreach(IContentReader reader in readerCollection)
          {
            // Reset the line number for this path.
            lineNumber = 0;

            // Read in a single block (line in case of a file)
            // from the object.
            IList items = reader.Read(1);

            // Read and process one block(line) at a time until
            // no more blocks(lines) exist.
            while (items != null && items.Count == 1)
            {
              // Increment the line number each time a line is
              // processed.
              lineNumber++;

              String message = String.Format("Testing line {0} : {1}",
                                            lineNumber, items[0]);

              WriteDebug(message);

              result = SelectString(items[0]);

              if (result != null)
              {
                result.Path = path.Path;
                result.LineNumber = lineNumber;

                WriteObject(result);
              }
              else
              {
                // Add the block(line) that did not match to the
                // collection of non matches , which will be stored
                // in the SessionState variable $NonMatches
                nonMatches.Add(items[0]);
              }

              // Get the next line from the object.
              items = reader.Read(1);

            }// While loop for reading one line at a time.
          }// Foreach loop for reader collection.
        }// Foreach loop for processing referenced paths.
      }// Foreach loop for walking of path list.

      // Store the list of non-matches in the
      // session state variable $NonMatches.
      try
      {
        this.SessionState.PSVariable.Set("NonMatches", nonMatches);
      }
      catch (SessionStateUnauthorizedAccessException ex)
      {
        WriteError(new ErrorRecord(ex,
                   "CannotWriteVariableNonMatches",
                   ErrorCategory.InvalidOperation,
                   nonMatches)
                  );
      }

    }// End of protected override void ProcessRecord().
    #endregion Overrides

    #region PrivateMethods
    /// <summary>
    /// Check for a match using the input string and the pattern(s)
    /// specified.
    /// </summary>
    /// <param name="input">The string to test.</param>
    /// <returns>MatchInfo object containing information about
    /// result of a match</returns>
    private MatchInfo SelectString(object input)
    {
      string line = null;

      try
      {
        // Convert the object to a string type
        // safely using language support methods
        line = (string)LanguagePrimitives.ConvertTo(
                                                    input,
                                                    typeof(string)
                                                    );
        line = line.Trim(' ','\t');
      }
      catch (PSInvalidCastException ex)
      {
        WriteError(new ErrorRecord(
                   ex,
                   "CannotCastObjectToString",
                   ErrorCategory.InvalidOperation,
                   input)
                   );

        return null;
      }

      MatchInfo result = null;

      // If a scriptblock has been specified, call it
      // with the path for processing.  It will return
      // one object.
      if (script != null)
      {
        WriteDebug("Executing script block.");

        Collection<PSObject> psObjects =
                             script.Invoke(
                                           line,
                                           simpleMatch,
                                           caseSensitive
                                          );

        foreach (PSObject psObject in psObjects)
        {
          if (LanguagePrimitives.IsTrue(psObject))
          {
            result = new MatchInfo();
            result.Line = line;
            result.IgnoreCase = !caseSensitive;

            break;
          } //End of If.
        } //End ForEach loop.
      } // End of If if script exists.

      // If script block exists, see if this line matches any
      // of the match patterns.
      else
      {
        int patternIndex = 0;

        while (patternIndex < patterns.Length)
        {
          if ((simpleMatch &&
              wildcardPattern[patternIndex].IsMatch(line))
              || (regexPattern != null
              && regexPattern[patternIndex].IsMatch(line))
             )
          {
            result = new MatchInfo();
            result.IgnoreCase = !caseSensitive;
            result.Line = line;
            result.Pattern = patterns[patternIndex];

            break;
          }

          patternIndex++;

        }// While loop through patterns.
      }// Else for no script block specified.

      return result;

    }// End of SelectString

    /// <summary>
    /// Check whether the supplied name meets the include/exclude criteria.
    /// That is - it's on the include list if the include list was
    /// specified, and not on the exclude list if the exclude list was specified.
    /// </summary>
    /// <param name="path">path to validate</param>
    /// <returns>True if the path is acceptable.</returns>
    private bool MeetsIncludeExcludeCriteria(string path)
    {
      bool ok = false;

      // See if the file is on the include list.
      if (this.include != null)
      {
        foreach (WildcardPattern patternItem in this.include)
        {
          if (patternItem.IsMatch(path))
          {
            ok = true;
            break;
          }
        }
      }
      else
      {
        ok = true;
      }

      if (!ok)
         return false;

      // See if the file is on the exclude list.
      if (this.exclude != null)
      {
        foreach (WildcardPattern patternItem in this.exclude)
        {
          if (patternItem.IsMatch(path))
          {
            ok = false;
            break;
          }
        }
      }

      return ok;
    } //MeetsIncludeExcludeCriteria
    #endregion Private Methods

  }// class SelectStringCommand

  #endregion SelectStringCommand

  #region MatchInfo

  /// <summary>
  /// Class representing the result of a pattern/literal match
  /// that is passed through the pipeline by the Select-Str cmdlet.
  /// </summary>
  public class MatchInfo
  {
    /// <summary>
    /// Indicates if the match was done ignoring case.
    /// </summary>
    /// <value>True if case was ignored.</value>
    public bool IgnoreCase
    {
      get { return ignoreCase; }
      set { ignoreCase = value; }
    }
    private bool ignoreCase;

    /// <summary>
    /// Specifies the number of the matching line.
    /// </summary>
    /// <value>The number of the matching line.</value>
    public UInt64 LineNumber
    {
      get { return lineNumber; }
      set { lineNumber = value; }
    }
    private UInt64 lineNumber;

    /// <summary>
    /// Specifies the text of the matching line.
    /// </summary>
    /// <value>The text of the matching line.</value>
    public string Line
    {
      get { return line; }
      set { line = value; }
    }
    private string line;

    /// <summary>
    /// Specifies the full path of the object(file) containing the
    /// matching line.
    /// </summary>
    /// <remarks>
    /// It will be "inputStream" if the object came from the input
    /// stream.
    /// </remarks>
    /// <value>The path name</value>
    public string Path
    {
      get { return path; }
      set
      {
        pathSet = true;
        path = value;
      }
    }
    private string path;
    private bool pathSet;

    /// <summary>
    /// Specifies the pattern that was used in the match.
    /// </summary>
    /// <value>The pattern string</value>
    public string Pattern
    {
      get { return pattern; }
      set { pattern = value; }
    }
    private string pattern;

    private const string MatchFormat = "{0}:{1}:{2}";

    /// <summary>
    /// Returns the string representation of this object. The format
    /// depends on whether a path has been set for this object or
    /// not.
    /// </summary>
    /// <remarks>
    /// If the path component is set, as would be the case when
    /// matching in a file, ToString() returns the path, line
    /// number and line text.  If path is not set, then just the
    /// line text is presented.
    /// </remarks>
    /// <returns>The string representation of the match object.</returns>
    public override string ToString()
    {
      if (pathSet)
         return String.Format(
         System.Threading.Thread.CurrentThread.CurrentCulture,
         MatchFormat,
         this.path,
         this.lineNumber,
         this.line
         );
      else
         return this.line;
    }
  }// End class MatchInfo

  #endregion

  #region PowerShell snap-in

  /// <summary>
  /// Create a PowerShell snap-in for the Select-Str cmdlet.
  /// </summary>
  [RunInstaller(true)]
  public class SelectStringPSSnapIn : PSSnapIn
  {
    /// <summary>
    /// Create an instance of the SelectStrPSSnapin class.
    /// </summary>
    public SelectStringPSSnapIn()
           : base()
    {
    }

    /// <summary>
    /// Specify the name of the PowerShell snap-in.
    /// </summary>
    public override string Name
    {
      get
      {
        return "SelectStrPSSnapIn";
      }
    }

    /// <summary>
    /// Specify the vendor of the PowerShell snap-in.
    /// </summary>
    public override string Vendor
    {
      get
      {
        return "Microsoft";
      }
    }

    /// <summary>
    /// Specify the localization resource information for the vendor.
    /// Use the format: SnapinName,VendorName.
    /// </summary>
    public override string VendorResource
    {
      get
      {
        return "SelectStrSnapIn,Microsoft";
      }
    }

    /// <summary>
    /// Specify the description of the PowerShell snap-in.
    /// </summary>
    public override string Description
    {
      get
        {
          return "This is a PowerShell snap-in for the Select-Str cmdlet.";
        }
    }

    /// <summary>
    /// Specify the localization resource information for the description.
    /// Use the format: SnapinName,Description.

    /// </summary>
    public override string DescriptionResource
    {
      get
      {
          return "SelectStrSnapIn,This is a PowerShell snap-in for the Select-Str cmdlet.";
      }
    }
  }
  #endregion PowerShell snap-in

} //namespace Microsoft.Samples.PowerShell.Commands;

コマンドレットのビルド

コマンドレットを実装したら、Windows PowerShell スナップインを使用して Windows PowerShell に登録する必要があります。コマンドレットの登録の詳細については、「コマンドレット、プロバイダー、およびホストアプリケーションを登録する方法」を参照してください。

コマンドレットのテスト

コマンドレットが Windows PowerShell に登録されたら、コマンドラインで実行してテストできます。次の手順を使用して、サンプル Select-Str コマンドレットをテストできます。

Windows PowerShell を起動し、ノートファイルを検索して、".NET" という式で行の出現箇所を検索します。パスの名前を囲む引用符は、パスが複数の単語で構成されている場合にのみ必要であることに注意してください。

Select-Str -Path "notes" -Pattern ".NET" -SimpleMatch=$false

次の出力が表示されます。

IgnoreCase   : True
LineNumber   : 8
Line         : Because Windows PowerShell works directly with .NET objects, there is often a .NET object
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\notes
Pattern      : .NET
IgnoreCase   : True
LineNumber   : 21
Line         : You should normally define the class for a cmdlet in a .NET namespace
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\notes
Pattern      : .NET

ノートファイルで、"over" という単語の後に他のテキストが続く行の出現箇所を検索します。 SimpleMatch パラメーターは、既定値の falseを使用しています。 CaseSensitive パラメーターが falseに設定されているため、検索では大文字と小文字が区別されません。

Select-Str -Path notes -Pattern "over*" -SimpleMatch -CaseSensitive:$false

次の出力が表示されます。

IgnoreCase   : True
LineNumber   : 45
Line         : Override StopProcessing
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\notes
Pattern      : over*
IgnoreCase   : True
LineNumber   : 49
Line         : overriding the StopProcessing method
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\notes
Pattern      : over*

パターンとして正規表現を使用して Notes ファイルを検索します。このコマンドレットは、かっこで囲まれたアルファベット文字と空白文字を検索します。

Select-Str -Path notes -Pattern "\([A-Za-z:blank:]" -SimpleMatch:$false

次の出力が表示されます。

IgnoreCase   : True
LineNumber   : 1
Line         : Advisory Guidelines (Consider Following)
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\notes
Pattern      : \([A-Za-z:blank:]
IgnoreCase   : True
LineNumber   : 53
Line         : If your cmdlet has objects that are not disposed of (written to the pipeline)
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\notes
Pattern      : \([A-Za-z:blank:]

"Parameter" という単語が出現する場合は、Notes ファイルの大文字と小文字を区別して検索を実行します。

Select-Str -Path notes -Pattern Parameter -CaseSensitive

次の出力が表示されます。

IgnoreCase   : False
LineNumber   : 6
Line         : Support an InputObject Parameter
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\notes
Pattern      : Parameter
IgnoreCase   : False
LineNumber   : 30
Line         : Support Force Parameter
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\notes
Pattern      : Parameter

Windows PowerShell に付属の変数プロバイダーで、0 から 9 までの数値を持つ変数を検索します。

Select-Str -Path * -Pattern "[0-9]"

次の出力が表示されます。

IgnoreCase   : True
LineNumber   : 1
Line         : 64
Path         : Variable:\MaximumHistoryCount
Pattern      : [0-9]

スクリプトブロックを使用して、ファイル SelectStrCommandSample.csで文字列 "Pos" を検索します。 -cmatch 演算子は、大文字と小文字を区別しないパターン一致を実行します。

Select-Str -Path "SelectStrCommandSample.cs" -Script { if ($args[0] -cmatch "Pos"){ return $true } return $false }

次の出力が表示されます。

IgnoreCase   : True
LineNumber   : 37
Line         :    Position = 0.
Path         : C:\PowerShell-Progs\workspace\Samples\SelectStr\SelectStrCommandSample.cs
Pattern      :

こちらもご覧ください

Windows PowerShell コマンドレットを作成する方法

最初のコマンドレットを作成する

システムを変更するコマンドレットの作成

Windows PowerShell プロバイダーのを設計する

Windows PowerShell のしくみ

コマンドレット、プロバイダー、およびホストアプリケーションを登録する方法

Windows PowerShell SDK の

次の方法で共有

データ ストアにアクセスするためのコマンドレットを作成する

コマンドレット クラスの定義

データ アクセスのパラメーターの定義

Path パラメーターの宣言

パターン パラメーターの宣言

検索サポート パラメーターの宣言

パラメーター セットの宣言

入力処理メソッドのオーバーライド

コンテンツへのアクセス

コード サンプル

コマンドレットのビルド

コマンドレットのテスト

こちらもご覧ください

その他のリソース

データストアにアクセスするためのコマンドレットを作成する

コマンドレットクラスの定義

データアクセスのパラメーターの定義

パターンパラメーターの宣言

検索サポートパラメーターの宣言

パラメーターセットの宣言

コードサンプル