Not
Bu sayfaya erişim yetkilendirme gerektiriyor. Oturum açmayı veya dizinleri değiştirmeyi deneyebilirsiniz.
Bu sayfaya erişim yetkilendirme gerektiriyor. Dizinleri değiştirmeyi deneyebilirsiniz.
Bu bölümde, Bir Windows PowerShell sağlayıcısı aracılığıyla depolanan verilere erişen bir cmdlet'in nasıl oluşturulacağı açıklanmaktadır. Bu cmdlet türü, Windows PowerShell çalışma zamanının Windows PowerShell sağlayıcı altyapısını kullanır ve bu nedenle cmdlet sınıfının System.Management.Automation.PSCmdlet temel sınıfından türetilmiş olması gerekir.
Burada açıklanan Select-Str cmdlet'i bir dosya veya nesnedeki dizeleri bulabilir ve seçebilir. Dizeyi tanımlamak için kullanılan desenler, cmdlet'in Path parametresi aracılığıyla veya Script parametresi aracılığıyla örtük olarak belirtilebilir.
Cmdlet, System.Management.Automation.Provider.IContentCmdletProvider'den türetilen herhangi bir Windows PowerShell sağlayıcısını kullanacak şekilde tasarlanmıştır. Örneğin, cmdlet, Windows PowerShell tarafından sağlanan FileSystem sağlayıcısını veya Değişken sağlayıcısını belirtebilir. Windows PowerShell sağlayıcıları hakkında daha fazla bilgi için bkz. Windows PowerShell sağlayıcınızı tasarlama.
Cmdlet Sınıfını Tanımlama
Cmdlet oluşturmanın ilk adımı her zaman cmdlet'ini adlandırmak ve cmdlet'i uygulayan .NET sınıfını bildirmektir. Bu cmdlet belirli dizeleri algılar, dolayısıyla burada seçilen fiil adı System.Management.Automation.VerbsCommon sınıfı tarafından tanımlanan "Select" olur. Cmdlet dizeler üzerinde çalıştığından "Str" isim adı kullanılır. Aşağıdaki bildirimde, cmdlet fiilinin ve isim adının cmdlet sınıfının adına yansıtıldığını unutmayın. Onaylanan cmdlet fiilleri hakkında daha fazla bilgi için bkz. Cmdlet Fiil Adları.
Windows PowerShell sağlayıcı altyapısını kullanıma sunmak için Windows PowerShell çalışma zamanı tarafından gereken desteği sağladığından, bu cmdlet için .NET sınıfı System.Management.Automation.PSCmdlet temel sınıfından türetilmelidir. Bu cmdlet'in System.Text.RegularExpressions.Regexgibi .NET Framework normal ifade sınıflarını da kullandığını unutmayın.
Aşağıdaki kod, bu Select-Str cmdlet'i için sınıf tanımıdır.
[Cmdlet(VerbsCommon.Select, "Str", DefaultParameterSetName="PatternParameterSet")]
public class SelectStringCommand : PSCmdlet
Bu cmdlet, sınıf bildirimine DefaultParameterSetName öznitelik anahtar sözcüğünü ekleyerek varsayılan parametre kümesini tanımlar. varsayılan parametre kümesi PatternParameterSet, Script parametresi belirtilmediğinde kullanılır. Bu parametre kümesi hakkında daha fazla bilgi için aşağıdaki bölümdeki Pattern ve Script parametre tartışmasını inceleyin.
Veri Erişimi için Parametreleri Tanımlama
Bu cmdlet, kullanıcının depolanan verilere erişmesine ve verileri incelemesine olanak sağlayan çeşitli parametreler tanımlar. Bu parametreler, veri deposunun konumunu gösteren bir Path parametresi, aramada kullanılacak düzeni belirten bir Pattern parametresi ve aramanın nasıl gerçekleştirildiğini destekleyen diğer birkaç parametreyi içerir.
Uyarı
Parametre tanımlamanın temelleri hakkında daha fazla bilgi için bkz. Komut Satırı Girişini İşleyen Parametreler Ekleme.
Yol Parametresini Bildirme
Veri depoyu bulmak için bu cmdlet, veri deposuna erişmek üzere tasarlanmış Windows PowerShell sağlayıcısını tanımlamak için bir Windows PowerShell yolu kullanmalıdır. Bu nedenle, sağlayıcının konumunu belirtmek için dize dizisi türünde bir Path parametresi tanımlar.
[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;
Bu parametrenin iki farklı parametre kümesine ait olduğunu ve bir diğer adına sahip olduğunu unutmayın.
İki System.Management.Automation.ParameterAttribute öznitelikleri, Path parametresinin ScriptParameterSet ve PatternParameterSetait olduğunu bildirir. Parametre kümeleri hakkında daha fazla bilgi için bkz. Cmdlet'ine Parametre Kümeleri Ekleme.
System.Management.Automation.AliasAttribute özniteliği, Path parametresi için PSPath bir diğer ad bildirir. Bu diğer adın bildirilmesi, Windows PowerShell sağlayıcılarına erişen diğer cmdlet'lerle tutarlılık için kesinlikle önerilir. Windows PowerShell yolları hakkında daha fazla bilgi için Windows PowerShell'in nasıl çalıştığı 'deki "PowerShell Yol Kavramları" bölümüne bakın.
Desen Parametresini Bildirme
Aranacak desenleri belirtmek için, bu cmdlet dize dizisi olan bir Pattern parametresi bildirir. Veri deposunda desenlerden herhangi biri bulunduğunda olumlu bir sonuç döndürülür. Bu desenlerin derlenmiş normal ifadeler dizisi veya değişmez değer aramaları için kullanılan joker karakter desenleri dizisi olarak derlenebilir.
[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;
Bu parametre belirtildiğinde, cmdlet PatternParameterSetvarsayılan parametre kümesini kullanır. Bu durumda, cmdlet dizeleri seçmek için burada belirtilen desenleri kullanır. Buna karşılık, Script parametresi desenleri içeren bir betik sağlamak için de kullanılabilir.
Script ve Pattern parametreleri iki ayrı parametre kümesi tanımlar, bu nedenle bunlar birbirini dışlar.
Arama Desteği Parametrelerini Bildirme
Bu cmdlet, cmdlet'in arama özelliklerini değiştirmek için kullanılabilecek aşağıdaki destek parametrelerini tanımlar.
Script parametresi, cmdlet için alternatif bir arama mekanizması sağlamak için kullanılabilecek bir betik bloğu belirtir. Betik, eşleştirme için kullanılan desenleri içermeli ve bir System.Management.Automation.PSObject nesnesi döndürmelidir. Bu parametrenin aynı zamanda ScriptParameterSet parametre kümesini tanımlayan benzersiz parametre olduğunu unutmayın. Windows PowerShell çalışma zamanı bu parametreyi gördüğünde, yalnızca ScriptParameterSet parametre kümesine ait parametreleri kullanır.
[Parameter(
Position = 1,
ParameterSetName = "ScriptParameterSet",
Mandatory = true)]
public ScriptBlock Script
{
set { script = value; }
get { return script; }
}
ScriptBlock script;
SimpleMatch parametresi, cmdlet'in sağlanan desenleri açıkça eşleştirip eşleştirmediğini gösteren bir switch parametresidir. Kullanıcı komut satırında (true) parametresini belirttiğinde, cmdlet sağlandığında desenleri kullanır. Parametresi belirtilmezse (false), cmdlet normal ifadeler kullanır. Bu parametre için varsayılan değer false.
[Parameter]
public SwitchParameter SimpleMatch
{
get { return simpleMatch; }
set { simpleMatch = value; }
}
private bool simpleMatch;
CaseSensitive parametresi, büyük/küçük harfe duyarlı bir arama yapılıp yapılmadığını gösteren bir anahtar parametresidir. Kullanıcı komut satırında (true) parametresini belirttiğinde, cmdlet desenleri karşılaştırırken karakterlerin büyük ve küçük harflerini denetler. Parametre belirtilmezse (false), cmdlet büyük ve küçük harf arasında ayrım yapmaz. Örneğin, "MyFile" ve "myfile" her ikisi de pozitif isabet olarak döndürülür. Bu parametre için varsayılan değer false.
[Parameter]
public SwitchParameter CaseSensitive
{
get { return caseSensitive; }
set { caseSensitive = value; }
}
private bool caseSensitive;
Exclude ve Include parametreleri, açıkça aramanın dışında tutulan veya aramaya dahil edilen öğeleri tanımlar. Varsayılan olarak, cmdlet veri deposundaki tüm öğeleri arar. Ancak, cmdlet tarafından gerçekleştirilen aramayı sınırlamak için, bu parametreler aramaya dahil edilecek veya atlanacak öğeleri açıkça belirtmek için kullanılabilir.
[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;
Parametre Kümeleri Bildiriyor
Bu cmdlet, veri erişiminde kullanılan iki parametre kümesinin adı olarak iki parametre kümesi (ScriptParameterSet ve varsayılan olan PatternParameterSet) kullanır.
PatternParameterSet varsayılan parametre kümesidir ve Pattern parametresi belirtildiğinde kullanılır.
ScriptParameterSet, kullanıcı Script parametresi aracılığıyla alternatif bir arama mekanizması belirttiğinde kullanılır. Parametre kümeleri hakkında daha fazla bilgi için bkz. Cmdlet'ine Parametre Kümeleri Ekleme.
Giriş İşleme Yöntemlerini Geçersiz Kılma
Cmdlet'ler, System.Management.Automation.PSCmdlet sınıfı için bir veya daha fazla giriş işleme yöntemini geçersiz kılmalıdır. Giriş işleme yöntemleri hakkında daha fazla bilgi için bkz. İlk Cmdlet'inizi Oluşturma.
Bu cmdlet, başlangıçta derlenmiş normal ifadeler dizisi oluşturmak için System.Management.Automation.Cmdlet.BeginProcessing yöntemini geçersiz kılar. Bu, basit eşleştirme kullanmayan aramalar sırasında performansı artırır.
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().
Bu cmdlet, kullanıcının komut satırında yaptığı dize seçimlerini işlemek için System.Management.Automation.Cmdlet.ProcessRecord yöntemini de geçersiz kılar. Özel bir MatchString yöntemini çağırarak özel bir nesne biçiminde dize seçiminin sonuçlarını yazar.
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().
İçeriğe Erişme
Cmdlet'inizin verilere erişebilmesi için Windows PowerShell yolu tarafından belirtilen sağlayıcıyı açması gerekir. Sağlayıcıya erişim için runspace için System.Management.Automation.SessionState nesnesi kullanılırken, sağlayıcıyı açmak için cmdlet'in System.Management.Automation.PSCmdlet.InvokeProvider* özelliği kullanılır. İçeriğe erişim, açılan sağlayıcı için System.Management.Automation.ProviderIntrinsics nesnesi alınarak sağlanır.
Bu örnek Select-Str cmdlet'i, taranacak içeriği kullanıma açmak için System.Management.Automation.ProviderIntrinsics.Content* özelliğini kullanır. Ardından gerekli Windows PowerShell yolunu geçirerek System.Management.Automation.ContentCmdletProviderIntrinsics.GetReader* yöntemini çağırabilir.
Kod Örneği
Aşağıdaki kod, bu Select-Str cmdlet'in bu sürümünün uygulanmasını gösterir. Bu kodun cmdlet sınıfını, cmdlet tarafından kullanılan özel yöntemleri ve cmdlet'i kaydetmek için kullanılan Windows PowerShell ek bileşeni kodunu içerdiğini unutmayın. cmdlet'ini kaydetme hakkında daha fazla bilgi için bkz. Cmdlet'i oluşturma.
//
// 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;
Cmdlet'i oluşturma
Cmdlet'i uyguladıktan sonra, bir Windows PowerShell ek bileşeni aracılığıyla Windows PowerShell'e kaydetmeniz gerekir. Cmdlet'leri kaydetme hakkında daha fazla bilgi için bkz. Cmdlet'leri, Sağlayıcıları ve Konak Uygulamalarını Kaydetme.
Cmdlet'i test etme
Cmdlet'iniz Windows PowerShell'e kaydedildiğinde, komut satırında çalıştırarak bunu test edebilirsiniz. Örnek Select-Str cmdlet'ini test etmek için aşağıdaki yordam kullanılabilir.
Windows PowerShell'i başlatın ve Notlar dosyasında ".NET" ifadesiyle satırların oluşumlarını arayın. Yol adının etrafındaki tırnak işaretlerinin yalnızca yol birden fazla sözcükten oluşuyorsa gerekli olduğunu unutmayın.
Select-Str -Path "notes" -Pattern ".NET" -SimpleMatch=$falseAşağıdaki çıkış görüntülenir.
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 : .NETNotlar dosyasında "over" sözcüğünü ve ardından başka bir metni içeren satırların oluşumlarını arayın.
SimpleMatchparametresi varsayılanfalsedeğerini kullanıyor.CaseSensitiveparametresifalseolarak ayarlandığından arama büyük/küçük harfe duyarlı değildir.Select-Str -Path notes -Pattern "over*" -SimpleMatch -CaseSensitive:$falseAşağıdaki çıkış görüntülenir.
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*Normal ifadeyi desen olarak kullanarak Notlar dosyasında arama yapın. Cmdlet, alfabetik karakterleri ve parantez içine alınmış boş boşlukları arar.
Select-Str -Path notes -Pattern "\([A-Za-z:blank:]" -SimpleMatch:$falseAşağıdaki çıkış görüntülenir.
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:]"Parametre" sözcüğünün oluşumları için Notlar dosyasında büyük/küçük harfe duyarlı bir arama yapın.
Select-Str -Path notes -Pattern Parameter -CaseSensitiveAşağıdaki çıkış görüntülenir.
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 : ParameterWindows PowerShell ile birlikte gelen Değişken sağlayıcısında 0 ile 9 arasında sayısal değerlere sahip değişkenler arayın.
Select-Str -Path * -Pattern "[0-9]"Aşağıdaki çıkış görüntülenir.
IgnoreCase : True LineNumber : 1 Line : 64 Path : Variable:\MaximumHistoryCount Pattern : [0-9]Dosya SelectStrCommandSample.cs "Pos" dizesini aramak için bir betik bloğu kullanın.
-cmatchişleci büyük/küçük harfe duyarlı olmayan bir desen eşleşmesi gerçekleştirir.Select-Str -Path "SelectStrCommandSample.cs" -Script { if ($args[0] -cmatch "Pos"){ return $true } return $false }Aşağıdaki çıkış görüntülenir.
IgnoreCase : True LineNumber : 37 Line : Position = 0. Path : C:\PowerShell-Progs\workspace\Samples\SelectStr\SelectStrCommandSample.cs Pattern :
Ayrıca Bkz.
Windows PowerShell Cmdlet Oluşturma
Sistem Değiştiren Bir Cmdlet Oluşturma
Windows PowerShell Sağlayıcınızı Tasarlama
Windows PowerShell'in Nasıl Çalıştığını
Cmdlet'leri, Sağlayıcıları ve Konak Uygulamalarını Kaydetme
Windows PowerShell SDK
GitHub'da bizimle işbirliği yapın
Bu içeriğin kaynağı GitHub'da bulunabilir; burada ayrıca sorunları ve çekme isteklerini oluşturup gözden geçirebilirsiniz. Daha fazla bilgi için katkıda bulunan kılavuzumuzu inceleyin.
PowerShell