GetProcessSample05-Beispiel
In diesem Beispiel wird eine vollständige Version des Cmdlets Get-Proc gezeigt.
Erstellen des Beispiels mithilfe Visual Studio.
Öffnen Windows Explorer, und navigieren Sie im Verzeichnis Beispiele zum Verzeichnis GetProcessSample05.
Wenn das Windows PowerShell 2.0 SDK installiert ist, navigieren Sie zum Ordner GetProcessSample05. Der Standardspeicherort ist C:\Programme (x86)\Microsoft SDKs\Windows\v7.0\Samples\sysmgmt\WindowsPowerShell\csharp\GetProcessSample05.
Doppelklicken Sie auf das Symbol für die Projektmappendatei (SLN). Dadurch wird das Beispielprojekt in Visual Studio.
Wählen Sie im Menü Erstellen die Option Projektmappe erstellen aus.
Die Bibliothek für das Beispiel wird in den Standardverzeichnissen \bin oder \bin\debug erstellt.
Ausführen des Beispiels
Erstellen Sie den folgenden Modulordner:
[user]/documents/windowspowershell/modules/GetProcessSample05Kopieren Sie die Beispiel-Assembly in den Modulordner.
Starten Sie Windows PowerShell.
Führen Sie den folgenden Befehl aus, um die Assembly in Windows PowerShell:
Import-module getprossessample05Führen Sie den folgenden Befehl aus, um das Cmdlet auszuführen:
get-proc
Anforderungen
Dieses Beispiel erfordert Windows PowerShell 2.0.
Zeigt
In diesem Beispiel wird Folgendes veranschaulicht:
Deklarieren einer Cmdlet-Klasse mithilfe des Cmdlet-Attributs.
Deklarieren eines Cmdlet-Parameters mit dem Parameterattribut.
Angeben von Positionen für Parameter.
Angeben, dass Parameter Eingaben aus der Pipeline übernehmen können. Die Eingabe kann aus einem Objekt oder einem Wert aus einer Eigenschaft eines Objekts übernommen werden, dessen Eigenschaftenname mit dem Parameternamen identisch ist.
Deklarieren eines Validierungsattributs für die Parametereingabe.
Behandeln von Fehlern und Ausnahmen.
Schreiben von Debugmeldungen.
Beispiel
In diesem Beispiel wird gezeigt, wie Sie ein Cmdlet erstellen, das eine Liste der angegebenen Prozesse anzeigt.
namespace Microsoft.Samples.PowerShell.Commands
{
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Management.Automation; // Windows PowerShell namespace.
using System.Security.Permissions;
using Win32Exception = System.ComponentModel.Win32Exception;
#region GetProcCommand
/// <summary>
/// This class implements the get-proc cmdlet.
/// </summary>
[Cmdlet(VerbsCommon.Get, "Proc",
DefaultParameterSetName = "ProcessName")]
public class GetProcCommand : PSCmdlet
{
#region Fields
/// <summary>
/// The names of the processes to act on.
/// </summary>
private string[] processNames;
/// <summary>
/// The identifiers of the processes to act on.
/// </summary>
private int[] processIds;
/// <summary>
/// The process objects to act on.
/// </summary>
private Process[] inputObjects;
#endregion Fields
#region Parameters
/// <summary>
/// Gets or sets the list of process names on
/// which the Get-Proc cmdlet will work.
/// </summary>
[Parameter(
Position = 0,
ParameterSetName = "ProcessName",
ValueFromPipeline = true,
ValueFromPipelineByPropertyName = true)]
[ValidateNotNullOrEmpty]
public string[] Name
{
get { return this.processNames; }
set { this.processNames = value; }
}
/// <summary>
/// Gets or sets the list of process identifiers on
/// which the Get-Proc cmdlet will work.
/// </summary>
[Parameter(
ParameterSetName = "Id",
Mandatory = true,
ValueFromPipeline = true,
ValueFromPipelineByPropertyName = true,
HelpMessage = "The unique id of the process to get.")]
public int[] Id
{
get { return this.processIds; }
set { this.processIds = value; }
}
/// <summary>
/// Gets or sets Process objects directly. If the input is a
/// stream of [collection of] Process objects, the cmdlet bypasses the
/// ProcessName and Id parameters and reads the Process objects
/// directly. This allows the cmdlet to deal with processes that have
/// wildcard characters in their name.
/// <value>Process objects</value>
/// </summary>
[Parameter(
ParameterSetName = "InputObject",
Mandatory = true,
ValueFromPipeline = true)]
public Process[] Input
{
get { return this.inputObjects; }
set { this.inputObjects = value; }
}
#endregion Parameters
#region Cmdlet Overrides
/// <summary>
/// The ProcessRecord method calls the Process.GetProcesses
/// method to retrieve the processes. Then, the WriteObject
/// method writes the associated processes to the pipeline.
/// </summary>
protected override void ProcessRecord()
{
List<Process> matchingProcesses;
WriteDebug("Obtaining the list of matching process objects.");
switch (ParameterSetName)
{
case "Id":
matchingProcesses = this.GetMatchingProcessesById();
break;
case "ProcessName":
matchingProcesses = this.GetMatchingProcessesByName();
break;
case "InputObject":
matchingProcesses = this.GetProcessesByInput();
break;
default:
ThrowTerminatingError(
new ErrorRecord(
new ArgumentException("Bad ParameterSetName"),
"UnableToAccessProcessList",
ErrorCategory.InvalidOperation,
null));
return;
} // switch (ParameterSetName)
WriteDebug("Outputting the matching process objects.");
matchingProcesses.Sort(ProcessComparison);
foreach (Process process in matchingProcesses)
{
WriteObject(process);
}
} // ProcessRecord
#endregion Overrides
#region protected Methods and Data
/// <summary>
/// Retrieves the list of all processes matching the ProcessName
/// parameter and generates a nonterminating error for each
/// specified process name which is not found even though the name
/// contains no wildcards.
/// </summary>
/// <returns>The matching processes.</returns>
[EnvironmentPermissionAttribute(
SecurityAction.LinkDemand,
Unrestricted = true)]
private List<Process> GetMatchingProcessesByName()
{
new EnvironmentPermission(
PermissionState.Unrestricted).Assert();
List<Process> allProcesses =
new List<Process>(Process.GetProcesses());
// The keys dictionary is used for rapid lookup of
// processes that are already in the matchingProcesses list.
Dictionary<int, byte> keys = new Dictionary<int, byte>();
List<Process> matchingProcesses = new List<Process>();
if (null == this.processNames)
{
matchingProcesses.AddRange(allProcesses);
}
else
{
foreach (string pattern in this.processNames)
{
WriteVerbose("Finding matches for process name \""
+ pattern + "\".");
// WildCard search on the available processes
WildcardPattern wildcard =
new WildcardPattern(
pattern,
WildcardOptions.IgnoreCase);
bool found = false;
foreach (Process process in allProcesses)
{
if (!keys.ContainsKey(process.Id))
{
string processName = SafeGetProcessName(process);
// Remove the process from the allProcesses list
// so that it is not tested again.
if (processName.Length == 0)
{
allProcesses.Remove(process);
}
// Perform a wildcard search on this particular
// process name and check whether it matches the
// pattern specified.
if (!wildcard.IsMatch(processName))
{
continue;
}
WriteDebug("Found matching process id "
+ process.Id + ".");
// A match is found.
found = true;
// Store the process identifier so that the same process
// is not added twice.
keys.Add(process.Id, 0);
// Add the process to the processes list.
matchingProcesses.Add(process);
}
} // foreach (Process...
if (!found &&
!WildcardPattern.ContainsWildcardCharacters(pattern))
{
WriteError(new ErrorRecord(
new ArgumentException("Cannot find process name "
+ "\"" + pattern + "\"."),
"ProcessNameNotFound",
ErrorCategory.ObjectNotFound,
pattern));
}
} // foreach (string...
} // if (null...
return matchingProcesses;
} // GetMatchingProcessesByName
/// <summary>
/// Returns the name of a process. If an error occurs, a blank
/// string is returned.
/// </summary>
/// <param name="process">The process whose name is
/// returned.</param>
/// <returns>The name of the process.</returns>
[EnvironmentPermissionAttribute(
SecurityAction.LinkDemand, Unrestricted = true)]
protected static string SafeGetProcessName(Process process)
{
new EnvironmentPermission(PermissionState.Unrestricted).Assert();
string name = String.Empty;
if (process != null)
{
try
{
return process.ProcessName;
}
catch (Win32Exception)
{
}
catch (InvalidOperationException)
{
}
}
return name;
} // SafeGetProcessName
#endregion Cmdlet Overrides
#region Private Methods
/// <summary>
/// Function to sort by process name first, and then by
/// the process identifier.
/// </summary>
/// <param name="x">First process object.</param>
/// <param name="y">Second process object.</param>
/// <returns>
/// Returns less than zero if x is less than y,
/// greater than 0 if x is greater than y, and 0 if x == y.
/// </returns>
private static int ProcessComparison(Process x, Process y)
{
int diff = String.Compare(
SafeGetProcessName(x),
SafeGetProcessName(y),
StringComparison.CurrentCultureIgnoreCase);
if (0 != diff)
{
return diff;
}
else
{
return x.Id.CompareTo(y.Id);
}
}
/// <summary>
/// Retrieves the list of all processes matching the Id
/// parameter and generates a nonterminating error for
/// each specified process identifier which is not found.
/// </summary>
/// <returns>
/// An array of processes that match the given identifier.
/// </returns>
[EnvironmentPermissionAttribute(
SecurityAction.LinkDemand,
Unrestricted = true)]
private List<Process> GetMatchingProcessesById()
{
new EnvironmentPermission(
PermissionState.Unrestricted).Assert();
List<Process> matchingProcesses = new List<Process>();
if (null != this.processIds)
{
// The keys dictionary is used for rapid lookup of the
// processes already in the matchingProcesses list.
Dictionary<int, byte> keys = new Dictionary<int, byte>();
foreach (int processId in this.processIds)
{
WriteVerbose("Finding match for process id "
+ processId + ".");
if (!keys.ContainsKey(processId))
{
Process process;
try
{
process = Process.GetProcessById(processId);
}
catch (ArgumentException ex)
{
WriteError(new ErrorRecord(
ex,
"ProcessIdNotFound",
ErrorCategory.ObjectNotFound,
processId));
continue;
}
WriteDebug("Found matching process.");
matchingProcesses.Add(process);
keys.Add(processId, 0);
}
}
}
return matchingProcesses;
} // GetMatchingProcessesById
/// <summary>
/// Retrieves the list of all processes matching the InputObject
/// parameter.
/// </summary>
/// <returns>The matching processes.</returns>
[EnvironmentPermissionAttribute(
SecurityAction.LinkDemand,
Unrestricted = true)]
private List<Process> GetProcessesByInput()
{
new EnvironmentPermission(
PermissionState.Unrestricted).Assert();
List<Process> matchingProcesses = new List<Process>();
if (null != this.Input)
{
// The keys dictionary is used for rapid lookup of the
// processes already in the matchingProcesses list.
Dictionary<int, byte> keys = new Dictionary<int, byte>();
foreach (Process process in this.Input)
{
WriteVerbose("Refreshing process object.");
if (!keys.ContainsKey(process.Id))
{
try
{
process.Refresh();
}
catch (Win32Exception)
{
}
catch (InvalidOperationException)
{
}
matchingProcesses.Add(process);
}
}
}
return matchingProcesses;
} // GetProcessesByInput
#endregion Private Methods
} // End GetProcCommand class.
#endregion GetProcCommand
}
Weitere Informationen
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für