.NET- en COM-objecten (Nieuw Object) makenCreating .NET and COM Objects (New-Object)

Er zijn softwareonderdelen met .NET Framework en COM-interfaces waarmee u veel system-beheertaken uitvoeren.There are software components with .NET Framework and COM interfaces that enable you to perform many system administration tasks. Windows PowerShell kunt u deze onderdelen te gebruiken zodat u niet beperkt tot de taken die kunnen worden uitgevoerd zijn met behulp van cmdlets.Windows PowerShell lets you use these components, so you are not limited to the tasks that can be performed by using cmdlets. Veel van de cmdlets in de initiële versie van Windows PowerShell werkt niet op externe computers.Many of the cmdlets in the initial release of Windows PowerShell do not work against remote computers. Wordt gedemonstreerd hoe u deze beperking omzeilen bij het beheren van gebeurtenislogboeken met behulp van .NET Framework System.Diagnostics.EventLog klasse rechtstreeks vanuit Windows PowerShell.We will demonstrate how to get around this limitation when managing event logs by using the .NET Framework System.Diagnostics.EventLog class directly from Windows PowerShell.

Nieuw Object gebruiken voor gebeurtenislogboek-toegangUsing New-Object for Event Log Access

.NET Framework Class Library bevat een klasse met de naam System.Diagnostics.EventLog die kunnen worden gebruikt voor het beheren van gebeurtenislogboeken.The .NET Framework Class Library includes a class named System.Diagnostics.EventLog that can be used to manage event logs. U kunt een nieuw exemplaar van een .NET Framework-klasse maken met behulp van de New-Object cmdlet uit met de TypeName parameter.You can create a new instance of a .NET Framework class by using the New-Object cmdlet with the TypeName parameter. De volgende opdracht maakt bijvoorbeeld een verwijzing naar een gebeurtenislogboek:For example, the following command creates an event log reference:

PS> New-Object -TypeName System.Diagnostics.EventLog

  Max(K) Retain OverflowAction        Entries Name
  ------ ------ --------------        ------- ----

Hoewel de opdracht een instantie van de klasse EventLog gemaakt heeft, bevatten het exemplaar geen gegevens.Although the command has created an instance of the EventLog class, the instance does not include any data. Dat komt doordat er een bepaald gebeurtenislogboek niet is opgegeven.That is because we did not specify a particular event log. Hoe krijg ik een echte gebeurtenislogboek?How do you get a real event log?

Met behulp van Constructors met nieuw ObjectUsing Constructors with New-Object

Om te verwijzen naar een specifiek gebeurtenislogboek, moet u de naam van het logboek opgeven.To refer to a specific event log, you need to specify the name of the log. Nieuw Object heeft een ArgumentList parameter.New-Object has an ArgumentList parameter. De argumenten die u aan deze parameter als waarden doorgeven worden gebruikt door een speciale opstartmethode van het object.The arguments you pass as values to this parameter are used by a special startup method of the object. De methode wordt aangeroepen een constructor omdat deze wordt gebruikt om het object te maken.The method is called a constructor because it is used to construct the object. Bijvoorbeeld als u een verwijzing naar het toepassingslogboek, geeft u de tekenreeks 'Toepassing' als een argument:For example, to get a reference to the Application log, you specify the string 'Application' as an argument:

PS> New-Object -TypeName System.Diagnostics.EventLog -ArgumentList Application

Max(K) Retain OverflowAction        Entries Name
------ ------ --------------        ------- ----
16,384      7 OverwriteOlder          2,160 Application

Notitie

Aangezien de meeste van de .NET Framework core-klassen zijn opgenomen in de naamruimte System, probeert Windows PowerShell automatisch te vinden van de klassen die u in de naamruimte System opgeeft als er een overeenkomst voor de typename die u opgeeft geen gevonden.Since most of the .NET Framework core classes are contained in the System namespace, Windows PowerShell will automatically attempt to find classes you specify in the System namespace if it cannot find a match for the typename you specify. Dit betekent dat u Diagnostics.EventLog in plaats van System.Diagnostics.EventLog kunt opgeven.This means that you can specify Diagnostics.EventLog instead of System.Diagnostics.EventLog.

Opslaan van objecten in variabelenStoring Objects in Variables

Het is raadzaam voor het opslaan van een verwijzing naar een object, zodat u deze in de huidige shell gebruiken kunt.You might want to store a reference to an object, so you can use it in the current shell. Hoewel Windows PowerShell u veel work met pijplijnen kunt, vermindering van de noodzaak van variabelen, maakt soms verwijzingen naar objecten opslaan in variabelen het eenvoudiger om deze objecten te bewerken.Although Windows PowerShell lets you do a lot of work with pipelines, lessening the need for variables, sometimes storing references to objects in variables makes it more convenient to manipulate those objects.

Windows PowerShell kunt u variabelen maken die in principe zijn benoemde objecten.Windows PowerShell lets you create variables that are essentially named objects. De uitvoer van een geldige Windows PowerShell-opdracht kan worden opgeslagen in een variabele.The output from any valid Windows PowerShell command can be stored in a variable. Namen van variabelen beginnen altijd met $.Variable names always begin with $. Als u wilt de verwijzing van het logboek Application opslaat in een variabele met de naam $AppLog, typ de naam van wordt de variabele, gevolgd door een gelijkteken en typ de opdracht die wordt gebruikt voor het maken van het toepassingsobject logboek:If you want to store the Application log reference in a variable named $AppLog, type the name of the variable, followed by an equal sign and then type the command used to create the Application log object:

PS> $AppLog = New-Object -TypeName System.Diagnostics.EventLog -ArgumentList Application

Als u vervolgens $AppLog typt, ziet u dat deze het toepassingslogboek bevat:If you then type $AppLog, you can see that it contains the Application log:

PS> $AppLog

  Max(K) Retain OverflowAction        Entries Name
  ------ ------ --------------        ------- ----
  16,384      7 OverwriteOlder          2,160 Application

Toegang tot een externe Nieuw Object-gebeurtenislogboekAccessing a Remote Event Log with New-Object

De opdrachten in de vorige sectie gericht op de lokale computer; de Get EventLog cmdlet kunt dit doen.The commands used in the preceding section target the local computer; the Get-EventLog cmdlet can do that. Voor toegang tot het toepassingslogboek op een externe computer, moet u zowel de naam van het logboek en een computernaam (of IP-adres) opgeven als argumenten.To access the Application log on a remote computer, you must supply both the log name and a computer name (or IP address) as arguments.

PS> $RemoteAppLog = New-Object -TypeName System.Diagnostics.EventLog Application,192.168.1.81
PS> $RemoteAppLog

  Max(K) Retain OverflowAction        Entries Name
  ------ ------ --------------        ------- ----
     512      7 OverwriteOlder            262 Application

Nu dat we een verwijzing naar een gebeurtenislogboek opgeslagen in de variabele $RemoteAppLog hebben, welke taken kunnen we op uitvoeren?Now that we have a reference to an event log stored in the $RemoteAppLog variable, what tasks can we perform on it?

Wissen van een gebeurtenislogboek met objectmethodenClearing an Event Log with Object Methods

Objecten hebben vaak methoden die kunnen worden aangeroepen als taken wilt uitvoeren.Objects often have methods that can be called to perform tasks. U kunt Get-lid om de methoden die zijn gekoppeld aan een object weer te geven.You can use Get-Member to display the methods associated with an object. De volgende opdracht en de geselecteerde uitvoer zijn voorbeelden de methoden van de EventLog-klasse:The following command and selected output show some the methods of the EventLog class:

PS> $RemoteAppLog | Get-Member -MemberType Method

   TypeName: System.Diagnostics.EventLog

Name                      MemberType Definition
----                      ---------- ----------
...
Clear                     Method     System.Void Clear()
Close                     Method     System.Void Close()
...
GetType                   Method     System.Type GetType()
...
ModifyOverflowPolicy      Method     System.Void ModifyOverflowPolicy(Overfl...
RegisterDisplayName       Method     System.Void RegisterDisplayName(String ...
...
ToString                  Method     System.String ToString()
WriteEntry                Method     System.Void WriteEntry(String message),...
WriteEvent                Method     System.Void WriteEvent(EventInstance in...

De Clear() methode kan worden gebruikt om te wissen van het gebeurtenislogboek.The Clear() method can be used to clear the event log. Wanneer u een methode aanroept, moet u altijd de methodenaam volgen door haakjes, zelfs als de methode geen argumenten vereist.When calling a method, you must always follow the method name by parentheses, even if the method does not require arguments. Hiermee kunt Windows PowerShell onderscheid maken tussen de methode en een mogelijke eigenschap met dezelfde naam.This lets Windows PowerShell distinguish between the method and a potential property with the same name. Typ het volgende aan te roepen de wissen methode:Type the following to call the Clear method:

PS> $RemoteAppLog.Clear()

Typ het volgende om het logboek weer te geven.Type the following to display the log. U ziet dat het gebeurtenislogboek is uitgeschakeld en nu 0 vermeldingen in plaats van 262 is:You will see that the event log was cleared, and now has 0 entries instead of 262:

PS> $RemoteAppLog

  Max(K) Retain OverflowAction        Entries Name
  ------ ------ --------------        ------- ----
     512      7 OverwriteOlder              0 Application

COM-objecten maken met een nieuw ObjectCreating COM Objects with New-Object

U kunt New-Object werken met onderdelen van de Component Object Model (COM).You can use New-Object to work with Component Object Model (COM) components. Het bereik van de onderdelen van de verschillende bibliotheken opgenomen ActiveX-toepassingen zoals Internet Explorer die zijn geïnstalleerd op de meeste systemen met Windows Script Host (WSH).Components range from the various libraries included with Windows Script Host (WSH) to ActiveX applications such as Internet Explorer that are installed on most systems.

Nieuw Object gebruikmaakt van .NET Framework Runtime-Callable-Wrappers COM-objecten te maken, zodat deze dezelfde beperkingen als .NET Framework biedt heeft bij het aanroepen van COM-objecten.New-Object uses .NET Framework Runtime-Callable Wrappers to create COM objects, so it has the same limitations that .NET Framework does when calling COM objects. Voor het maken van een COM-object, moet u opgeven de ComObject parameter met de programma-id of ProgId van de COM-klasse die u wilt gebruiken.To create a COM object, you need to specify the ComObject parameter with the Programmatic Identifier or ProgId of the COM class you want to use. Een uitgebreide bespreking van de beperkingen van de COM-gebruik en het bepalen van wat ProgID's zijn beschikbaar op een systeem valt buiten het bereik van deze handleiding, maar het meest bekende objecten uit omgevingen zoals WSH kunnen worden gebruikt in Windows PowerShell.A complete discussion of the limitations of COM use and determining what ProgIds are available on a system is beyond the scope of this user's guide, but most well-known objects from environments such as WSH can be used within Windows PowerShell.

U kunt de objecten WSH maken door op te geven deze ProgID: instantie, WScript.Network, Scripting.Dictionary, en Scripting.FileSystemObject.You can create the WSH objects by specifying these progids: WScript.Shell, WScript.Network, Scripting.Dictionary, and Scripting.FileSystemObject. De volgende opdrachten maakt deze objecten:The following commands create these objects:

New-Object -ComObject WScript.Shell
New-Object -ComObject WScript.Network
New-Object -ComObject Scripting.Dictionary
New-Object -ComObject Scripting.FileSystemObject

Hoewel de meeste functionaliteit van deze klassen beschikbaar zijn op andere manieren in Windows PowerShell wordt gemaakt, zijn een paar taken, zoals het maken van snelkoppeling nog steeds gemakkelijker te doen met behulp van de klassen WSH.Although most of the functionality of these classes is made available in other ways in Windows PowerShell, a few tasks such as shortcut creation are still easier to do using the WSH classes.

Maken van een snelkoppeling op het bureaublad met instantieCreating a Desktop Shortcut with WScript.Shell

Een taak die snel kan worden uitgevoerd met een COM-object met het maken van een snelkoppeling.One task that can be performed quickly with a COM object is creating a shortcut. Stel dat u wilt een snelkoppeling op het bureaublad maken die verwijst naar de basismap voor Windows PowerShell.Suppose you want to create a shortcut on your desktop that links to the home folder for Windows PowerShell. U moet eerst maakt u een verwijzing naar instantie, die wordt opgeslagen in een variabele met de naam $WshShell:You first need to create a reference to WScript.Shell, which we will store in a variable named $WshShell:

$WshShell = New-Object -ComObject WScript.Shell

Get-lid werkt met COM-objecten, zodat u op de leden van het object door te typen vindt:Get-Member works with COM objects, so you can explore the members of the object by typing:

PS> $WshShell | Get-Member

   TypeName: System.__ComObject#{41904400-be18-11d3-a28b-00104bd35090}

Name                     MemberType            Definition
----                     ----------            ----------
AppActivate              Method                bool AppActivate (Variant, Va...
CreateShortcut           Method                IDispatch CreateShortcut (str...
...

Get-lid is een optionele InputObject parameter kunt u in plaats van piping om te voorzien van gegevens Get-lid.Get-Member has an optional InputObject parameter you can use instead of piping to provide input to Get-Member. Krijgt u hetzelfde uitvoer zoals hierboven als u in plaats daarvan de opdracht gebruikt lid zijn van Get - InputObject $WshShell.You would get the same output as shown above if you instead used the command Get-Member -InputObject $WshShell. Als u InputObject, worden behandeld als het argument als één item.If you use InputObject, it treats its argument as a single item. Dit betekent dat als er meerdere objecten in een variabele, Get-lid ze worden beschouwd als een matrix met objecten.This means that if you have several objects in a variable, Get-Member treats them as an array of objects. Bijvoorbeeld:For example:

PS> $a = 1,2,"three"
PS> Get-Member -InputObject $a
TypeName: System.Object[]
Name               MemberType    Definition
----               ----------    ----------
Count              AliasProperty Count = Length
...

De instantie CreateShortcut methode accepteert één argument, het pad naar het snelkoppelingsbestand maken.The WScript.Shell CreateShortcut method accepts a single argument, the path to the shortcut file to create. We kunnen typt in het volledige pad naar het bureaublad, maar er is een eenvoudigere manier.We could type in the full path to the desktop, but there is an easier way. Het bureaublad wordt normaal gesproken vertegenwoordigd door een map met de naam Desktop binnen de basismap van de huidige gebruiker.The desktop is normally represented by a folder named Desktop inside the home folder of the current user. Windows PowerShell is een variabele $Home die het pad naar deze map bevat.Windows PowerShell has a variable $Home that contains the path to this folder. We kunnen het pad naar de basismap opgeven met behulp van deze variabele en voeg vervolgens de naam van de map bureaublad en de naam voor de snelkoppeling maken door te typen:We can specify the path to the home folder by using this variable, and then add the name of the Desktop folder and the name for the shortcut to create by typing:

$lnk = $WshShell.CreateShortcut("$Home\Desktop\PSHome.lnk")

Wanneer u iets dat op de naam van een variabele binnen dubbele aanhalingstekens lijkt gebruikt, wordt Windows PowerShell probeert te vervangen door een overeenkomende waarde.When you use something that looks like a variable name inside double-quotes, Windows PowerShell tries to substitute a matching value. Als u één aanhalingstekens gebruikt, probeert Windows PowerShell niet vervangen door de variabele waarde.If you use single-quotes, Windows PowerShell does not try to substitute the variable value. Probeer bijvoorbeeld de volgende opdrachten te typen:For example, try typing the following commands:

PS> "$Home\Desktop\PSHome.lnk"
C:\Documents and Settings\aka\Desktop\PSHome.lnk
PS> '$Home\Desktop\PSHome.lnk'
$Home\Desktop\PSHome.lnk

We hebt nu een variabele met de naam $lnk die een nieuwe snelkoppeling-verwijzing bevat.We now have a variable named $lnk that contains a new shortcut reference. Als u zien van de leden wilt, kunt u het doorsluizen naar Get-lid.If you want to see its members, you can pipe it to Get-Member. De onderstaande uitvoer ziet u de leden moeten we onze snelkoppeling gebruiken:The output below shows the members we need to use to finish creating our shortcut:

PS> $lnk | Get-Member
TypeName: System.__ComObject#{f935dc23-1cf0-11d0-adb9-00c04fd58a0b}
Name             MemberType   Definition
----             ----------   ----------
...
Save             Method       void Save ()
...
TargetPath       Property     string TargetPath () {get} {set}

Moeten we geven de TargetPath, dit is de toepassingsmap voor Windows PowerShell en sla de snelkoppeling $lnk door het aanroepen van de opslaan methode.We need to specify the TargetPath, which is the application folder for Windows PowerShell, and then save the shortcut $lnk by calling the Save method. Het pad van de Windows PowerShell-toepassing wordt opgeslagen in de variabele $PSHome, zodat we dit door te typen doen kunt:The Windows PowerShell application folder path is stored in the variable $PSHome, so we can do this by typing:

$lnk.TargetPath = $PSHome
$lnk.Save()

Met behulp van Internet Explorer vanuit Windows PowerShellUsing Internet Explorer from Windows PowerShell

Veel toepassingen (met inbegrip van de Microsoft Office-familie van toepassingen en Internet Explorer) kunnen worden geautomatiseerd met behulp van COM.Many applications (including the Microsoft Office family of applications and Internet Explorer) can be automated by using COM. Internet Explorer ziet u enkele van de gangbare technieken en problemen die zijn betrokken bij het werken met COM gebaseerde toepassingen.Internet Explorer illustrates some of the typical techniques and issues involved in working with COM-based applications.

U een exemplaar van Internet Explorer maken door de Internet Explorer ProgId InternetExplorer.Application:You create an Internet Explorer instance by specifying the Internet Explorer ProgId, InternetExplorer.Application:

$ie = New-Object -ComObject InternetExplorer.Application

Met deze opdracht Start Internet Explorer, maar is niet zichtbaar maken.This command starts Internet Explorer, but does not make it visible. Als u een Get-Process typt, ziet u dat een proces met de naam iexplore wordt uitgevoerd.If you type Get-Process, you can see that a process named iexplore is running. Zelfs als u Windows PowerShell afsluit, blijft het proces actief.In fact, if you exit Windows PowerShell, the process will continue to run. U moet de computer opnieuw opstarten of een hulpprogramma zoals Taakbeheer gebruiken om de iexplore proces te beëindigen.You must reboot the computer or use a tool like Task Manager to end the iexplore process.

Notitie

COM-objecten die worden gestart als afzonderlijke processen genoemd uitvoerbare bestanden ActiveX, kan of kunnen niet een gebruikersinterface-venster weergeven wanneer deze opgestart worden.COM objects that start as separate processes, commonly called ActiveX executables, may or may not display a user interface window when they start up. Als ze geen venster maken, maar maak niet wordt weergegeven, zoals Internet Explorer, de focus in het algemeen wordt verplaatst naar het Windows-bureaublad en moet u het venster zichtbaar ermee te maken.If they create a window but do not make it visible, like Internet Explorer, the focus will generally move to the Windows desktop and you must make the window visible to interact with it.

Door te typen $ie | Get-lid, kunt u eigenschappen en methoden voor Internet Explorer weergeven.By typing $ie | Get-Member, you can view properties and methods for Internet Explorer. Stel de eigenschap Visible op $true door te voeren overzicht van de Internet Explorer-venster:To see the Internet Explorer window, set the Visible property to $true by typing:

$ie.Visible = $true

U kunt vervolgens naar een specifieke webadres navigeren met behulp van de methode navigeren:You can then navigate to a specific Web address by using the Navigate method:

$ie.Navigate("http://www.microsoft.com/technet/scriptcenter/default.mspx")

Met andere leden van het Internet Explorer-objectmodel, is het mogelijk tekstinhoud ophalen van de webpagina.Using other members of the Internet Explorer object model, it is possible to retrieve text content from the Web page. De volgende opdracht worden de HTML-tekst in de hoofdtekst van de huidige webpagina weergegeven:The following command will display the HTML text in the body of the current Web page:

$ie.Document.Body.InnerText

Roep de methode Quit() Internet Explorer uit in PowerShell om af te sluiten:To close Internet Explorer from within PowerShell, call its Quit() method:

$ie.Quit()

Deze toepassing nu afsluiten.This will force it to close. Een geldige verwijzing naar bevat de ie-variabele $ niet langer zelfs als deze nog steeds lijkt te zijn van een COM-object.The $ie variable no longer contains a valid reference even though it still appears to be a COM object. Als u probeert te gebruiken, krijgt u een automatiseringsfout:If you attempt to use it, you will get an automation error:

PS> $ie | Get-Member
Get-Member : Exception retrieving the string representation for property "Appli
cation" : "The object invoked has disconnected from its clients. (Exception fro
m HRESULT: 0x80010108 (RPC_E_DISCONNECTED))"
At line:1 char:16
+ $ie | Get-Member <<<<

U kunt een verwijderen ie naar de resterende verwijzen met een opdracht zoals $ = $null of volledig verwijderen van de variabele door te typen:You can either remove the remaining reference with a command like $ie = $null, or completely remove the variable by typing:

Remove-Variable ie

Notitie

Er is geen algemene standaard voor uitvoerbare bestanden ActiveX sluiten of worden uitgevoerd wanneer u een verwijzing naar een verwijdert.There is no common standard for whether ActiveX executables exit or continue to run when you remove a reference to one. Afhankelijk van de omstandigheden zoals bepaalt of de toepassing zichtbaar is, of een bewerkte document erin wordt uitgevoerd en zelfs of Windows PowerShell wordt nog steeds uitgevoerd, wordt de toepassing kan of kan niet worden afgesloten.Depending on circumstances such as whether the application is visible, whether an edited document is running in it, and even whether Windows PowerShell is still running, the application may or may not exit. Daarom moet u beëindiging gedrag testen voor elke ActiveX uitvoerbare dat u wilt gebruiken in Windows PowerShell.For this reason, you should test termination behavior for each ActiveX executable you want to use in Windows PowerShell.

Waarschuwingen over .NET Framework ingepakt COM-objectenGetting Warnings About .NET Framework-Wrapped COM Objects

In sommige gevallen kan een COM-object een bijbehorende .NET Framework wellicht Runtime-Callable Wrapper RCW en dit wordt gebruikt door New-Object.In some cases, a COM object might have an associated .NET Framework Runtime-Callable Wrapper or RCW, and this will be used by New-Object. Omdat het gedrag van de RCW van het gedrag van het normale COM-object afwijken kan New-Object heeft een Strict parameter om u te waarschuwen over RCW toegang.Since the behavior of the RCW may be different from the behavior of the normal COM object, New-Object has a Strict parameter to warn you about RCW access. Als u opgeeft de Strict parameter en maak vervolgens een COM-object dat gebruikmaakt van een RCW, wordt er een waarschuwing weergegeven:If you specify the Strict parameter and then create a COM object that uses an RCW, you get a warning message:

PS> $xl = New-Object -ComObject Excel.Application -Strict
New-Object : The object written to the pipeline is an instance of the type "Mic
rosoft.Office.Interop.Excel.ApplicationClass" from the component's primary inte
rop assembly. If this type exposes different members than the IDispatch members
, scripts written to work with this object might not work if the primary intero
p assembly is not installed.
At line:1 char:17
+ $xl = New-Object  <<<< -ComObject Excel.Application -Strict

Hoewel het object nog steeds gemaakt is, wordt u gewaarschuwd dat het niet standaard COM-object is.Although the object is still created, you are warned that it is not a standard COM object.