Nota:
El acceso a esta página requiere autorización. Puede intentar iniciar sesión o cambiar directorios.
El acceso a esta página requiere autorización. Puede intentar cambiar los directorios.
En esta sección se describe cómo crear un cmdlet que acceda a los datos almacenados mediante un proveedor de Windows PowerShell. Este tipo de cmdlet usa la infraestructura del proveedor de Windows PowerShell del entorno de ejecución de Windows PowerShell y, por lo tanto, la clase de cmdlet debe derivar de la clase base System.Management.Automation.PSCmdlet.
El cmdlet Select-Str descrito aquí puede buscar y seleccionar cadenas en un archivo o objeto. Los patrones usados para identificar la cadena se pueden especificar explícitamente a través del parámetro Path del cmdlet o implícitamente a través del parámetro Script.
El cmdlet está diseñado para usar cualquier proveedor de Windows PowerShell que derive de System.Management.Automation.Provider.IContentCmdletProvider. Por ejemplo, el cmdlet puede especificar el proveedor FileSystem o el proveedor variable proporcionado por Windows PowerShell. Para obtener más información sobre los proveedores de PowerShell de Windows, consulte Diseño del proveedor de Windows PowerShell.
Definición de la clase de cmdlet
El primer paso en la creación de cmdlets siempre es asignar un nombre al cmdlet y declarar la clase .NET que implementa el cmdlet. Este cmdlet detecta determinadas cadenas, por lo que el nombre del verbo elegido aquí es "Select", definido por la clase System.Management.Automation.VerbsCommon. El nombre de nombre "Str" se usa porque el cmdlet actúa sobre cadenas. En la declaración siguiente, tenga en cuenta que el verbo del cmdlet y el nombre del nombre se reflejan en el nombre de la clase de cmdlet. Para obtener más información sobre los verbos de cmdlet aprobados, consulte Nombres de verbos de cmdlet.
La clase .NET para este cmdlet debe derivar de la clase base System.Management.Automation.PSCmdlet, ya que proporciona la compatibilidad necesaria para que el entorno de ejecución de Windows PowerShell exponga la infraestructura del proveedor de Windows PowerShell. Tenga en cuenta que este cmdlet también usa las clases de expresiones regulares de .NET Framework, como System.Text.RegularExpressions.Regex.
El código siguiente es la definición de clase para este cmdlet Select-Str.
[Cmdlet(VerbsCommon.Select, "Str", DefaultParameterSetName="PatternParameterSet")]
public class SelectStringCommand : PSCmdlet
Este cmdlet define un conjunto de parámetros predeterminado agregando la palabra clave de atributo DefaultParameterSetName a la declaración de clase. El conjunto de parámetros predeterminado PatternParameterSet se usa cuando no se especifica el parámetro Script. Para obtener más información sobre este conjunto de parámetros, consulte la Pattern y Script discusión de parámetros en la sección siguiente.
Definición de parámetros para el acceso a datos
Este cmdlet define varios parámetros que permiten al usuario acceder a los datos almacenados y examinarlos. Estos parámetros incluyen un parámetro Path que indica la ubicación del almacén de datos, un parámetro Pattern que especifica el patrón que se va a usar en la búsqueda y otros parámetros que admiten cómo se realiza la búsqueda.
Nota:
Para obtener más información sobre los conceptos básicos de definir parámetros, vea [Agregar parámetros que procesan la entrada de la línea de comandos][04].
Declaración del parámetro path
Para localizar el almacén de datos, este cmdlet debe usar una ruta de acceso de Windows PowerShell para identificar el proveedor de Windows PowerShell diseñado para acceder al almacén de datos. Por lo tanto, define un parámetro Path de la matriz de cadenas de tipo para indicar la ubicación del proveedor.
[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;
Tenga en cuenta que este parámetro pertenece a dos conjuntos de parámetros diferentes y que tiene un alias.
Dos atributos System.Management.Automation.ParameterAttribute declaran que el parámetro Path pertenece al ScriptParameterSet y al PatternParameterSet. Para obtener más información sobre los conjuntos de parámetros, vea Agregar conjuntos de parámetros a un cmdlet.
El atributo System.Management.Automation.AliasAttribute declara un alias PSPath para el parámetro Path. Declarar este alias es muy recomendable para la coherencia con otros cmdlets que acceden a proveedores de Windows PowerShell. Para obtener más información sobre las rutas de acceso de PowerShell de Windows, vea "Conceptos de ruta de acceso de PowerShell" en Funcionamiento de Windows PowerShell.
Declaración del parámetro pattern
Para especificar los patrones que se van a buscar, este cmdlet declara un parámetro Pattern que es una matriz de cadenas. Se devuelve un resultado positivo cuando se encuentra cualquiera de los patrones en el almacén de datos. Tenga en cuenta que estos patrones se pueden compilar en una matriz de expresiones regulares compiladas o en una matriz de patrones comodín usados para búsquedas literales.
[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;
Cuando se especifica este parámetro, el cmdlet usa el conjunto de parámetros predeterminado PatternParameterSet.
En este caso, el cmdlet usa los patrones especificados aquí para seleccionar cadenas. Por el contrario, el parámetro Script también se podría usar para proporcionar un script que contenga los patrones. Los parámetros Script y Pattern definen dos conjuntos de parámetros independientes, por lo que son mutuamente excluyentes.
Declaración de parámetros de compatibilidad de búsqueda
Este cmdlet define los siguientes parámetros de compatibilidad que se pueden usar para modificar las funcionalidades de búsqueda del cmdlet.
El parámetro Script especifica un bloque de script que se puede usar para proporcionar un mecanismo de búsqueda alternativo para el cmdlet. El script debe contener los patrones utilizados para buscar coincidencias y devolver un objeto System.Management.Automation.PSObject. Tenga en cuenta que este parámetro también es el parámetro único que identifica el conjunto de parámetros ScriptParameterSet. Cuando el entorno de ejecución de Windows PowerShell ve este parámetro, solo usa parámetros que pertenecen al conjunto de parámetros de ScriptParameterSet.
[Parameter(
Position = 1,
ParameterSetName = "ScriptParameterSet",
Mandatory = true)]
public ScriptBlock Script
{
set { script = value; }
get { return script; }
}
ScriptBlock script;
El parámetro SimpleMatch es un parámetro switch que indica si el cmdlet debe coincidir explícitamente con los patrones a medida que se proporcionan. Cuando el usuario especifica el parámetro en la línea de comandos (true), el cmdlet usa los patrones a medida que se proporcionan. Si no se especifica el parámetro (false), el cmdlet usa expresiones regulares. El valor predeterminado de este parámetro es false.
[Parameter]
public SwitchParameter SimpleMatch
{
get { return simpleMatch; }
set { simpleMatch = value; }
}
private bool simpleMatch;
El parámetro CaseSensitive es un parámetro switch que indica si se realiza una búsqueda que distingue mayúsculas de minúsculas. Cuando el usuario especifica el parámetro en la línea de comandos (true), el cmdlet comprueba si hay mayúsculas y minúsculas de caracteres al comparar patrones. Si no se especifica el parámetro (false), el cmdlet no distingue entre mayúsculas y minúsculas. Por ejemplo, "MyFile" y "myfile" se devolverían como aciertos positivos. El valor predeterminado de este parámetro es false.
[Parameter]
public SwitchParameter CaseSensitive
{
get { return caseSensitive; }
set { caseSensitive = value; }
}
private bool caseSensitive;
Los parámetros Exclude y Include identifican los elementos que se excluyen explícitamente de o se incluyen en la búsqueda. De forma predeterminada, el cmdlet buscará en todos los elementos del almacén de datos. Sin embargo, para limitar la búsqueda realizada por el cmdlet, estos parámetros se pueden usar para indicar explícitamente los elementos que se incluirán en la búsqueda o se omiten.
[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;
Declarar conjuntos de parámetros
Este cmdlet usa dos conjuntos de parámetros (ScriptParameterSet y PatternParameterSet, que es el valor predeterminado) como los nombres de dos conjuntos de parámetros usados en el acceso a datos.
PatternParameterSet es el conjunto de parámetros predeterminado y se usa cuando se especifica el parámetro Pattern.
ScriptParameterSet se usa cuando el usuario especifica un mecanismo de búsqueda alternativo a través del parámetro Script. Para obtener más información sobre los conjuntos de parámetros, vea Agregar conjuntos de parámetros a un cmdlet.
Invalidación de métodos de procesamiento de entrada
Los cmdlets deben invalidar uno o varios de los métodos de procesamiento de entrada para la clase System.Management.Automation.PSCmdlet. Para obtener más información sobre los métodos de procesamiento de entrada, vea Creating Your First Cmdlet.
Este cmdlet invalida el método System.Management.Automation.Cmdlet.BeginProcessing para compilar una matriz de expresiones regulares compiladas al inicio. Esto aumenta el rendimiento durante las búsquedas que no usan coincidencias simples.
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().
Este cmdlet también invalida el método System.Management.Automation.Cmdlet.ProcessRecord para procesar las selecciones de cadena que realiza el usuario en la línea de comandos. Escribe los resultados de la selección de cadenas en forma de objeto personalizado llamando a un método MatchString privado.
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().
Acceso al contenido
El cmdlet debe abrir el proveedor indicado por la ruta de acceso de Windows PowerShell para que pueda acceder a los datos. El objeto System.Management.Automation.SessionState del espacio de ejecución se usa para el acceso al proveedor, mientras que la propiedad System.Management.Automation.PSCmdlet.InvokeProvider* del cmdlet se usa para abrir el proveedor. El acceso al contenido se proporciona mediante la recuperación del objeto System.Management.Automation.ProviderIntrinsics para el proveedor abierto.
Este cmdlet de Select-Str de ejemplo usa la propiedad System.Management.Automation.ProviderIntrinsics.Content* para exponer el contenido que se va a examinar. A continuación, puede llamar al método System.Management.Automation.ContentCmdletProviderIntrinsics.GetReader*, pasando la ruta de acceso necesaria de Windows PowerShell.
Ejemplo de código
En el código siguiente se muestra la implementación de esta versión de este cmdlet Select-Str. Tenga en cuenta que este código incluye la clase de cmdlet, los métodos privados usados por el cmdlet y el código de complemento de Windows PowerShell que se usa para registrar el cmdlet. Para obtener más información sobre cómo registrar el cmdlet, consulte Building the Cmdlet.
//
// 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;
Compilación del cmdlet
Después de implementar un cmdlet, debe registrarlo con Windows PowerShell a través de un complemento de Windows PowerShell. Para obtener más información sobre el registro de cmdlets, consulte Registro de cmdlets, proveedores y aplicaciones host.
Prueba del cmdlet
Cuando el cmdlet se haya registrado con Windows PowerShell, puede probarlo ejecutándolo en la línea de comandos. El siguiente procedimiento se puede usar para probar el cmdlet Select-Str de ejemplo.
Inicie Windows PowerShell y busque en el archivo Notes las repeticiones de líneas con la expresión ".NET". Tenga en cuenta que las comillas alrededor del nombre de la ruta de acceso solo son necesarias si la ruta de acceso consta de más de una palabra.
Select-Str -Path "notes" -Pattern ".NET" -SimpleMatch=$falseAparece la salida siguiente.
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 : .NETBusque en el archivo Notes las repeticiones de líneas con la palabra "over", seguida de cualquier otro texto. El parámetro
SimpleMatchusa el valor predeterminado defalse. La búsqueda no distingue mayúsculas de minúsculas porque el parámetroCaseSensitiveestá establecido enfalse.Select-Str -Path notes -Pattern "over*" -SimpleMatch -CaseSensitive:$falseAparece la salida siguiente.
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*Busque en el archivo Notes con una expresión regular como patrón. El cmdlet busca caracteres alfabéticos y espacios en blanco entre paréntesis.
Select-Str -Path notes -Pattern "\([A-Za-z:blank:]" -SimpleMatch:$falseAparece la salida siguiente.
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:]Realice una búsqueda con distinción entre mayúsculas y minúsculas del archivo Notes para las apariciones de la palabra "Parameter".
Select-Str -Path notes -Pattern Parameter -CaseSensitiveAparece la salida siguiente.
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 : ParameterBusque variables que tengan valores numéricos de 0 a 9 en el proveedor de variables que se incluyen con Windows PowerShell.
Select-Str -Path * -Pattern "[0-9]"Aparece la salida siguiente.
IgnoreCase : True LineNumber : 1 Line : 64 Path : Variable:\MaximumHistoryCount Pattern : [0-9]Use un bloque de script para buscar el archivo SelectStrCommandSample.cs de la cadena "Pos". El operador
-cmatchrealiza una coincidencia de patrón que no distingue mayúsculas de minúsculas.Select-Str -Path "SelectStrCommandSample.cs" -Script { if ($args[0] -cmatch "Pos"){ return $true } return $false }Aparece la salida siguiente.
IgnoreCase : True LineNumber : 37 Line : Position = 0. Path : C:\PowerShell-Progs\workspace\Samples\SelectStr\SelectStrCommandSample.cs Pattern :
Véase también
Creación de un cmdlet de Windows PowerShell
Crear un cmdlet que modifique el sistema
diseñar el proveedor de Windows PowerShell
cómo funciona Windows PowerShell
Colaborar con nosotros en GitHub
El origen de este contenido se puede encontrar en GitHub, donde también puede crear y revisar problemas y solicitudes de incorporación de cambios. Para más información, consulte nuestra guía para colaboradores.
