Creazione di un cmdlet per accedere a un archivio dati
Questa sezione descrive come creare un cmdlet che accede ai dati archiviati tramite un provider Windows PowerShell dati. Questo tipo di cmdlet usa l'infrastruttura del provider Windows PowerShell del runtime di Windows PowerShell e, pertanto, la classe del cmdlet deve derivare dalla classe di base System.Management.Automation.PSCmdlet.
Il cmdlet Select-Str qui descritto può individuare e selezionare stringhe in un file o in un oggetto. I modelli usati per identificare la stringa possono essere specificati in modo esplicito tramite il parametro del cmdlet o Path in modo implicito tramite il Script parametro .
Il cmdlet è progettato per usare qualsiasi provider Windows PowerShell derivato da System.Management.Automation.Provider.Icontentcmdletprovider. Ad esempio, il cmdlet può specificare il provider FileSystem o il provider Variable fornito da Windows PowerShell. Per altre informazioni sui provider Windows PowerShell, vedere Designing Your Windows PowerShell provider.
Definizione della classe Cmdlet
Il primo passaggio nella creazione dei cmdlet consiste sempre nel denominare il cmdlet e dichiarare la classe .NET che implementa il cmdlet. Questo cmdlet rileva determinate stringhe, quindi il nome del verbo scelto qui è "Select", definito dalla classe System.Management.Automation.Verbscommon. Il nome sostantivo "Str" viene usato perché il cmdlet agisce sulle stringhe. Nella dichiarazione seguente si noti che il verbo del cmdlet e il nome del sostantivo si riflettono nel nome della classe del cmdlet. Per altre informazioni sui verbi dei cmdlet approvati, vedere Nomi dei verbi dei cmdlet.
La classe .NET per questo cmdlet deve derivare dalla classe di base System.Management.Automation.PSCmdlet, perché fornisce il supporto necessario al runtime di Windows PowerShell per esporre l'infrastruttura del provider Windows PowerShell. Si noti che questo cmdlet usa anche le .NET Framework di espressioni regolari, ad esempio System.Text.Regularexpressions.Regex.
Il codice seguente è la definizione della classe per questo cmdlet Select-Str.
[Cmdlet(VerbsCommon.Select, "Str", DefaultParameterSetName="PatternParameterSet")]
public class SelectStringCommand : PSCmdlet
Questo cmdlet definisce un set di parametri predefinito aggiungendo la parola DefaultParameterSetName chiave attribute alla dichiarazione di classe. Il set di parametri PatternParameterSet predefinito viene utilizzato quando il parametro non è Script specificato. Per altre informazioni su questo set di parametri, vedere la Pattern discussione sui parametri e nella sezione Script seguente.
Definizione dei parametri per l'accesso ai dati
Questo cmdlet definisce diversi parametri che consentono all'utente di accedere ai dati archiviati ed esaminarne i dati. Questi parametri includono un parametro che indica la posizione dell'archivio dati, un parametro che specifica il criterio da usare nella ricerca e diversi altri parametri che supportano la modalità di esecuzione Path Pattern della ricerca.
Nota
Per altre informazioni sulle nozioni di base della definizione dei parametri, vedere Aggiunta di parametri che elaborano l'input della riga di comando.
Dichiarazione del parametro Path
Per individuare l'archivio dati, questo cmdlet deve usare un percorso Windows PowerShell per identificare il provider Windows PowerShell progettato per accedere all'archivio dati. Pertanto, definisce un parametro Path di tipo matrice di stringhe per indicare la posizione del provider.
[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;
Si noti che questo parametro appartiene a due set di parametri diversi e ha un alias.
Due attributi System.Management.Automation.Parameterattribute dichiarano che il Path parametro appartiene a e ScriptParameterSet PatternParameterSet . Per altre informazioni sui set di parametri, vedere Aggiunta di set di parametri a un cmdlet.
L'attributo System.Management.Automation.Aliasattribute dichiara un PSPath alias per il parametro Path . La dichiarazione di questo alias è fortemente consigliata per coerenza con altri cmdlet che accedono Windows PowerShell provider. Per altre informazioni sui percorsi di Windows PowerShell, vedere "PowerShell Path Concepts" in How Windows PowerShell Works.
Dichiarazione del parametro pattern
Per specificare i criteri da cercare, questo cmdlet dichiara un Pattern parametro che è una matrice di stringhe. Quando uno dei modelli viene trovato nell'archivio dati, viene restituito un risultato positivo. Si noti che questi modelli possono essere compilati in una matrice di espressioni regolari compilate o in una matrice di modelli con caratteri jolly usati per le ricerche letterali.
[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;
Quando questo parametro viene specificato, il cmdlet usa il set di parametri predefinito PatternParameterSet . In questo caso, il cmdlet usa i modelli specificati qui per selezionare le stringhe. Al contrario, il Script parametro può essere usato anche per fornire uno script che contiene i modelli. I Script parametri e definiscono due set di parametri Pattern separati, quindi si escludono a vicenda.
Dichiarazione dei parametri di supporto della ricerca
Questo cmdlet definisce i parametri di supporto seguenti che possono essere usati per modificare le funzionalità di ricerca del cmdlet.
Il Script parametro specifica un blocco di script che può essere usato per fornire un meccanismo di ricerca alternativo per il cmdlet. Lo script deve contenere i modelli usati per la corrispondenza e restituire un oggetto System.Management.Automation.PSObject. Si noti che questo parametro è anche il parametro univoco che identifica il ScriptParameterSet set di parametri. Quando il Windows PowerShell runtime visualizza questo parametro, usa solo i parametri che appartengono al ScriptParameterSet set di parametri.
[Parameter(
Position = 1,
ParameterSetName = "ScriptParameterSet",
Mandatory = true)]
public ScriptBlock Script
{
set { script = value; }
get { return script; }
}
ScriptBlock script;
Il parametro è un parametro switch che indica se il cmdlet deve corrispondere in modo SimpleMatch esplicito ai modelli specificati. Quando l'utente specifica il parametro nella riga di comando ( ), il true cmdlet usa i modelli così come vengono forniti. Se il parametro non è specificato ( false ), il cmdlet usa espressioni regolari. Il valore predefinito per questo parametro è false .
[Parameter]
public SwitchParameter SimpleMatch
{
get { return simpleMatch; }
set { simpleMatch = value; }
}
private bool simpleMatch;
Il parametro è un parametro switch che indica se viene eseguita CaseSensitive una ricerca con distinzione tra maiuscole e minuscole. Quando l'utente specifica il parametro nella riga di comando ( ), il cmdlet verifica la presenza di caratteri maiuscoli e minuscoli durante true il confronto dei modelli. Se il parametro non è specificato ( ), il cmdlet non distingue tra maiuscole false e minuscole. Ad esempio, "MyFile" e "myfile" verrebbero entrambi restituiti come riscontri positivi. Il valore predefinito per questo parametro è false .
[Parameter]
public SwitchParameter CaseSensitive
{
get { return caseSensitive; }
set { caseSensitive = value; }
}
private bool caseSensitive;
I Exclude parametri Include e identificano gli elementi esplicitamente esclusi o inclusi nella ricerca. Per impostazione predefinita, il cmdlet cerca tutti gli elementi nell'archivio dati. Tuttavia, per limitare la ricerca eseguita dal cmdlet, questi parametri possono essere usati per indicare in modo esplicito gli elementi da includere nella ricerca o omessi.
[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;
Dichiarazione di set di parametri
Questo cmdlet usa due set di parametri ( e , che è l'impostazione predefinita) come nomi di due set ScriptParameterSet PatternParameterSet di parametri usati nell'accesso ai dati. PatternParameterSet è il set di parametri predefinito e viene usato quando viene Pattern specificato il parametro . ScriptParameterSet viene usato quando l'utente specifica un meccanismo di ricerca alternativo tramite il Script parametro . Per altre informazioni sui set di parametri, vedere Aggiunta di set di parametri a un cmdlet.
Override dei metodi di elaborazione dell'input
I cmdlet devono eseguire l'override di uno o più metodi di elaborazione dell'input per la classe System.Management.Automation.PSCmdlet. Per altre informazioni sui metodi di elaborazione dell'input, vedere Creazione del primo cmdlet.
Questo cmdlet esegue l'override del metodo System.Management.Automation.Cmdlet.BeginProcessing per compilare una matrice di espressioni regolari compilate all'avvio. In questo modo si aumentano le prestazioni durante le ricerche che non usano la corrispondenza semplice.
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().
Questo cmdlet esegue anche l'override del metodo System.Management.Automation.Cmdlet.ProcessRecord per elaborare le selezioni di stringhe che l'utente esegue nella riga di comando. Scrive i risultati della selezione di stringhe sotto forma di oggetto personalizzato chiamando un metodo MatchString privato.
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().
Accesso al contenuto
Il cmdlet deve aprire il provider indicato dal Windows PowerShell in modo che possa accedere ai dati. L'oggetto System.Management.Automation.Sessionstate per lo spazio di esecuzione viene usato per l'accesso al provider, mentre la proprietà System.Management.Automation.PSCmdlet.Invokeprovider* del cmdlet viene usata per aprire il provider. L'accesso al contenuto viene fornito mediante il recupero dell'oggetto System.Management.Automation.Providerintrinsics per il provider aperto.
Questo cmdlet Select-Str esempio usa la proprietà System.Management.Automation.Providerintrinsics.Content* per esporre il contenuto da analizzare. Può quindi chiamare il metodo System.Management.Automation.Contentcmdletproviderintrinsics.Getreader* passando il percorso Windows PowerShell necessario.
Codice di esempio
Il codice seguente illustra l'implementazione di questa versione Select-Str cmdlet . Si noti che questo codice include la classe del cmdlet, i metodi privati usati dal cmdlet e il codice dello snap-in Windows PowerShell usato per registrare il cmdlet. Per altre informazioni sulla registrazione del cmdlet, vedere Compilazione del 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;
Compilazione del cmdlet
Dopo aver implementato un cmdlet, è necessario registrarlo con Windows PowerShell tramite Windows PowerShell snap-in. Per altre informazioni sulla registrazione dei cmdlet, vedere How to Register Cmdlets, Providers, and Host Applications.
Test del cmdlet
Dopo aver registrato il cmdlet con Windows PowerShell, è possibile testarlo eseguendolo nella riga di comando. La procedura seguente può essere usata per testare il cmdlet Select-Str esempio.
Avviare Windows PowerShell e cercare nel file Notes le occorrenze delle righe con l'espressione ".NET". Si noti che le virgolette che circondano il nome del percorso sono necessarie solo se il percorso è costituito da più di una parola.
select-str -Path "notes" -Pattern ".NET" -SimpleMatch=$falseViene visualizzato l'output seguente.
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 : .NETCercare nel file Notes le occorrenze delle righe con la parola "over", seguite da qualsiasi altro testo. Il
SimpleMatchparametro usa il valore predefinito difalse. La ricerca non fa distinzione tra maiuscole e minuscole perchéCaseSensitiveil parametro è impostato sufalse.select-str -Path notes -Pattern "over*" -SimpleMatch -CaseSensitive:$falseViene visualizzato l'output seguente.
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*Cercare il file Notes usando un'espressione regolare come criterio. Il cmdlet cerca i caratteri alfabetici e gli spazi vuoti racchiusi tra parentesi.
select-str -Path notes -Pattern "\([A-Za-z:blank:]" -SimpleMatch:$falseViene visualizzato l'output seguente.
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:]Eseguire una ricerca con distinzione tra maiuscole e minuscole nel file Notes per le occorrenze della parola "Parameter".
select-str -Path notes -Pattern Parameter -CaseSensitiveViene visualizzato l'output seguente.
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 : ParameterCercare nel provider di variabili fornito con Windows PowerShell le variabili con valori numerici da 0 a 9.
select-str -Path * -Pattern "[0-9]"Viene visualizzato l'output seguente.
IgnoreCase : True LineNumber : 1 Line : 64 Path : Variable:\MaximumHistoryCount Pattern : [0-9]Usare un blocco di script per cercare nel file SelectStrCommandSample.cs la stringa "Pos". La funzione cmatch per lo script esegue una corrispondenza di criteri senza distinzione tra maiuscole e minuscole.
select-str -Path "SelectStrCommandSample.cs" -Script { if ($args[0] -cmatch "Pos"){ return $true } return $false }Viene visualizzato l'output seguente.
IgnoreCase : True LineNumber : 37 Line : Position = 0. Path : C:\PowerShell-Progs\workspace\Samples\SelectStr\SelectStrCommandSample.cs Pattern :
Vedere anche
Come creare un cmdlet Windows PowerShell
Creazione di un cmdlet che modifica il sistema
Progettare il provider di Windows PowerShell
Funzionamento Windows PowerShell