TEMA
    Variables de preferencia

DESCRIPCIÓN BREVE
    Son variables que personalizan el comportamiento de Windows 
    PowerShell. 

DESCRIPCIÓN DETALLADA
    Windows PowerShell incluye un conjunto de variables que permiten 
    personalizar su comportamiento. Estas "variables de preferencia" 
    funcionan de la misma manera que las opciones en los sistemas 
    basados en GUI.

    Las variables de preferencia afectan al entorno operativo de 
    Windows PowerShell y a todos los comandos que se ejecutan en el 
    entorno. En muchos casos, los cmdlets tienen parámetros que se 
    pueden usar para invalidar el comportamiento de preferencia de un 
    comando concreto.

    En la tabla siguiente se muestran las variables de preferencia y 
    sus valores predeterminados.

    Variable                             Valor predeterminado
    --------                             -------------
    $ConfirmPreference                   High
    $DebugPreference                     SilentlyContinue
    $ErrorActionPreference               Continue
    $ErrorView                           NormalView
    $FormatEnumerationLimit              4
    $LogCommandHealthEvent               False (no se produce el registro)
    $LogCommandLifecycleEvent            False (no se produce el registro)
    $LogEngineHealthEvent                True (se produce el registro)
    $LogEngineLifecycleEvent             True (se produce el registro)
    $LogProviderLifecycleEvent           True (se produce el registro)
    $LogProviderHealthEvent              True (se produce el registro)
    $MaximumAliasCount                   4096
    $MaximumDriveCount                   4096
    $MaximumErrorCount                   256
    $MaximumFunctionCount                4096
    $MaximumHistoryCount                 64
    $MaximumVariableCount                4096
    $OFS                                 (Carácter de espacio (" "))
    $OutputEncoding		         Objeto ASCIIEncoding
    $ProgressPreference                  Continue
    $PSEmailServer                       (Ninguno)
    $PSSessionApplicationName            WSMAN
    $PSSessionConfigurationName          https://schemas.microsoft.com/powershell/microsoft.powershell 
    $PSSessionOption                     (Ver más abajo)
    $VerbosePreference                   SilentlyContinue
    $WarningPreference                   Continue
    $WhatIfPreference                    0


    Windows PowerShell también incluye las siguientes variables de 
    entorno que almacenan las preferencias del usuario. Para obtener 
    más información sobre las variables de entorno, vea 
    about_environment_variables.

    Variable                                         
    --------                         
    PSModulePath                        

USAR VARIABLES DE PREFERENCIA
    En este documento se describe cada una de las variables de 
    preferencia.

    Para mostrar el valor actual de una variable de preferencia 
    concreta, escriba el nombre de la variable. Windows PowerShell 
    proporcionará el valor. Por ejemplo, el comando siguiente muestra 
    el valor de la variable $ConfirmPreference.

        PS> $ConfirmPreference
        High

    Para cambiar el valor de una variable, use una instrucción de 
    asignación. Por ejemplo, la instrucción siguiente asigna el valor 
    "Medium" a la variable $ConfirmPreference.

        PS> $ConfirmPreference = "Medium"

    Al igual que todas las variables, los valores que se establecen 
    son específicos de la ventana actual de Windows PowerShell. Para 
    que se apliquen en todas las ventanas de Windows PowerShell, debe 
    agregarlos a su perfil de Windows PowerShell. Para obtener más 
    información, vea about_profiles.


TRABAJAR DE FORMA REMOTA
   Cuando se ejecutan comandos remotos en un equipo remoto, los 
   comandos remotos solo están sujetos al conjunto de preferencias en 
   el cliente de Windows PowerShell del equipo remoto. Por ejemplo, 
   cuando se ejecuta un comando remoto, el valor de la variable 
   $DebugPreference en el equipo remoto determina cómo Windows 
   PowerShell responde a los mensajes de depuración. 

   Para obtener más información sobre los comandos remotos, vea 
   about_remote.



$ConfirmPreference
------------------
    Determina qué acciones de cmdlet solicitan automáticamente la 
    confirmación del usuario antes de que se realicen. 
        
    Cuando el valor de $ConfirmPreference (High, Medium, Low, None) 
    es igual o mayor que el riesgo de la acción del cmdlet (High, 
    Medium, Low, None), Windows PowerShell solicita automáticamente 
    la confirmación del usuario antes de realizar la acción. 

    Se puede usar el parámetro Confirm de un cmdlet a fin de 
    invalidar la preferencia para un comando concreto.

        Valores válidos:
		None:     no se confirma automáticamente ninguna acción 
			  de cmdlet. Los usuarios deben utilizar el 
			  parámetro Confirm para solicitar la confirmación 
			  de comandos concretos.

		Low: 	  se confirman automáticamente las acciones de 
			  cmdlet con un riesgo bajo, medio o alto. 
			  Para suprimir la confirmación de un comando 
			  concreto, utilice -Confirm:$false.

		Medium:   se confirman automáticamente las acciones 
			  de cmdlet con un riesgo medio o alto. 
			  Para habilitar la confirmación de un comando 
			  concreto, utilice -confirm. Para suprimir 
			  la confirmación de un comando concreto, 
			  utilice -confirm:$false.

		High:	  se confirman automáticamente las 
	       (valor 	  acciones de cmdlet con un riesgo alto. 
	  predeterminado) Para habilitar la confirmación de 
			  un comando concreto, utilice -confirm. 
			  Para suprimir la confirmación de un comando 
			  concreto, utilice -confirm:$false.


    EXPLICACIÓN DETALLADA
        Cuando una acción de cmdlet afecta al sistema de manera 
        significativa (por ejemplo, eliminando datos o usando una 
        cantidad importante de recursos del sistema), Windows 
        PowerShell puede solicitar automáticamente la confirmación 
        antes de realizar la acción. 

        Por ejemplo:

	    PS> remove-item pref2.txt

            Confirmar
            ¿Está seguro de que desea realizar esta acción?
            Se está realizando la operación "Quitar archivo" en el 
            destino "C:\pref2.txt".
            [S] Sí [O] Sí a todo [N] No [T] No a todo [U] Suspender 
            [?] Ayuda (el valor predeterminado es "S"):

        La estimación del riesgo forma parte del cmdlet y se conoce 
        como "ConfirmImpact". No se puede cambiar.

        El cmdlet que podría suponer un riesgo para el sistema tiene 
        un parámetro Confirm que se puede usar para solicitar o 
        suprimir la confirmación de un comando concreto.

	Dado que la mayoría de los cmdlets utilizan el valor de riesgo 
	predeterminado Medium y el valor predeterminado de $ConfirmPreference
	es High, la confirmación automática se produce en raras ocasiones. 
	No obstante, se puede activar la confirmación automática cambiando 
	el valor de $ConfirmPreference a Medium o Low. 

    EJEMPLOS
      En este ejemplo se muestra el efecto del valor predeterminado 
      de $ConfirmPreference. El valor High solo confirma las acciones 
      de cmdlet de alto riesgo. Dado que la mayoría de las acciones 
      constituyen un riesgo medio, no se confirman automáticamente, 
      si bien se puede usar el parámetro Confirm del cmdlet para 
      solicitar la confirmación de un comando concreto.

          PS> $confirmpreference              #Obtener el valor 
          High				       actual de la variable. 
                    
	  PS> remove-item temp1.txt           #Eliminar un archivo.
          PS>                                 #Se ha eliminado sin confirmación. 
          PS> remove-item temp2.txt -confirm  #Usar el parámetro Confirm.

          Confirmar
          ¿Está seguro de que desea realizar esta acción?
          Se está realizando la operación "Quitar archivo" en el 
          destino "C:\temp2.txt".
          [S] Sí [O] Sí a todo [N] No [T] No a todo [U] Suspender 
	  [?] Ayuda (el valor predeterminado es "S"):


       En este ejemplo se muestra el efecto de cambiar el valor de 
       $ConfirmPreference a Medium. Dado que la mayoría de las 
       acciones de cmdlet constituyen un riesgo medio, se confirman 
       automáticamente y se ha de usar el parámetro Confirm con el 
       valor $false para suprimir la solicitud de confirmación de un 
       comando concreto.

            
          PS> $confirmpreference = "Medium" 
                                     # Cambiar el valor de $ConfirmPreference. 
          PS> remove-item temp2.txt
                                     # La eliminación de un archivo 
                                       desencadena la confirmación. 
          Confirmar
          ¿Está seguro de que desea realizar esta acción?
          Se está realizando la operación "Quitar archivo" en el 
          destino "C:\temp2.txt".
          [S] Sí [O] Sí a todo [N] No [T] No a todo [U] Suspender 
	  [?] Ayuda (el valor predeterminado es "S"):
	

          PS> remove-item temp3.txt -confirm:$false  #Usar el parámetro 
          					      Confirm para suprimir 
						      la confirmación 
          PS>

$DebugPreference
------------------
	Determina cómo Windows PowerShell responde a los mensajes de 
	depuración generados por un script, cmdlet o proveedor, 
	o bien, por un comando Write-Debug en la línea de comandos. 

        Algunos cmdlets muestran mensajes de depuración, que suelen 
        ser mensajes muy técnicos diseñados para programadores y 
        profesionales de soporte técnico. De forma predeterminada, no 
        se muestran los mensajes de depuración. Para mostrarlos, se 
        ha de cambiar el valor de $DebugPreference.
        
        Asimismo, se puede usar el parámetro común Debug de un cmdlet 
        para mostrar u ocultar los mensajes de depuración de un 
        comando concreto. Para obtener más información, 
	escriba "get-help about_commonparameters".

        Valores válidos:
	    Stop:               se muestra el mensaje de depuración 
	   			y se detiene la ejecución. 
				Se escribe un error en la consola.

     	    Inquire:            se muestra el mensaje de 
     	   			depuración y se pregunta 
				al usuario si desea continuar.

            Continue:           se muestra el mensaje de 
            			depuración y continúa la ejecución.

            SilentlyContinue	no produce ningún efecto. 
	(valor predeterminado): No se muestra el mensaje de depuración 
				y la ejecución continúa sin interrupción.
             

    EJEMPLOS
    
    En los ejemplos siguientes se muestra el efecto de cambiar los 
    valores de $DebugPreference cuando se escribe un comando 
    Write-Debug en la línea de comandos. El cambio afecta a todos los 
    mensajes de depuración, incluidos los generados por cmdlets 
    y scripts. En los ejemplos también se muestra el uso del parámetro 
    común Debug, que muestra u oculta los mensajes de depuración 
    relacionados con un comando concreto.

    En este ejemplo se muestra el efecto del valor predeterminado, 
    "SilentlyContinue". No se muestra el mensaje de depuración y 
    continúa el procesamiento. El comando final utiliza el parámetro 
    Debug a fin de invalidar la preferencia para un comando concreto.

        PS> $debugpreference                    # Obtener el valor actual de
        SilentlyContinue                          $DebugPreference

        PS> write-debug "Hola a todos"
        PS>                                     # No se muestra el mensaje 
						  de depuración.

        PS> write-debug "Hola a todos" -Debug  	# Usar el parámetro Debug.
        DEPURACIÓN: Hola a todos                # Se solicita el 
        					  mensaje de depuración.
        ¿Confirmar?
        ¿Desea continuar con la operación?
        [S] Sí [O] Sí a todo [I] Interrumpir comando [U] Suspender 
        [?] Ayuda (el valor predeterminado es "S"):

   
    En este ejemplo se muestra el efecto del valor "Continue". 
    El comando final utiliza el parámetro Debug con el valor $false 
    a fin de suprimir el mensaje para un comando concreto.

        PS> $debugpreference = "Continue"  # Cambiar el valor a "Continue".

        PS> write-debug "Hola a todos"
        DEPURACIÓN: Hola a todos           # Se muestra el mensaje de depuración 
        PS>				     y continúa el procesamiento.
        

        PS> write-debug "Hola a todos" -Debug:$false  
                                            # Usar el parámetro Debug 
                                              con el valor false.
        PS>                                 # No se muestra el mensaje 
					      de depuración.

        
    En este ejemplo se muestra el efecto del valor "Stop". El comando 
    final utiliza el parámetro Debug con el valor $false a fin de 
    suprimir el mensaje para un comando concreto.

        PS> $debugpreference = "Stop"       # Cambiar el valor a "Stop".
        PS> write-debug "Hola a todos"
        DEPURACIÓN: Hola a todos
        Write-Debug : Se detuvo la ejecución del comando porque la 
        variable de shell "DebugPreference" está establecida en Stop.
        En línea:1 carácter:12
        + write-debug <<<< "Hola a todos"

        PS> write-debug "Hola a todos" -Debug:$false  
                                            # Usar el parámetro Debug 
                                              con $false.
        PS>      			    # No se muestra el mensaje 
       					      de depuración y  no se detiene 
    					      el procesamiento.


    En este ejemplo se muestra el efecto del valor "Inquire". El 
    comando final utiliza el parámetro Debug con el valor $false 
    a fin de suprimir el mensaje para un comando concreto.

        PS> $debugpreference = "Inquire"
        PS> write-debug "Hola a todos"
        DEPURACIÓN: Hola a todos

        Confirmar
        ¿Desea continuar con la operación?
        [S] Sí [O] Sí a todo [I] Interrumpir comando [U] Suspender 
        [?] Ayuda (el valor predeterminado es "S"):

        PS> write-debug "Hola a todos" -Debug:$false  
                                            # Usar el parámetro Debug 
                                              con $false.
        PS>      			    # No se muestra el mensaje 
      					      de depuración y continúa 
					      el procesamiento sin interrupción.

$ErrorActionPreference
----------------------
	Determina cómo Windows PowerShell responde a un error que no es de 
	terminación (un error que no detiene el procesamiento del cmdlet) en 
	la línea de comandos o en un script, cmdlet o proveedor, como los 
	errores generados por el cmdlet Write-Error. 

        Asimismo, se puede usar el parámetro común ErrorAction de un 
        cmdlet a fin de invalidar la preferencia para un comando 
        concreto. Para obtener más información, escriba "get-help 
        about_commonparameters".


        Valores válidos:
	    Stop:               se muestra el mensaje de error y se 
	    			detiene la ejecución. 

     	    Inquire:            se muestra el mensaje de error y 
     	    			se pregunta al usuario si desea continuar.

            Continue:           se muestra el mensaje de error 
           			y continúa la ejecución.

            SilentlyContinue 
	(valor predeterminado): no produce ningún efecto. No se muestra 
				el mensaje de error y la ejecución 
           			continúa sin interrupción.


       $ErrorActionPreference y el parámetro común ErrorAction no 
       afectan a la forma en que Windows PowerShell responde a los 
       errores de terminación (errores que detienen el procesamiento 
       del cmdlet).

       Para obtener más información sobre el parámetro común 
       ErrorAction, escriba "get-help about_commonparameters".


    EJEMPLOS

    En estos ejemplos se muestra el efecto de los diferentes valores de 
    $ErrorActionPreference y el uso del parámetro común ErrorAction para 
    invalidar la preferencia para un comando concreto. El parámetro 
    ErrorAction tiene los mismos valores válidos que la variable 
    $ErrorActionPreference.
    
    En este ejemplo se muestra el efecto del valor Continue, que es 
    el valor predeterminado.

        PS> $erroractionpreference                      
        Continue		# Mostrar el valor de la preferencia.	
	           
        PS> write-error "Hola a todos"                  
                                # Generar un error de no terminación.

        write-error "Hola a todos" : Hola a todos        
				# Se muestra el mensaje de error 
				  y la ejecución continúa.

        PS> write-error "Hola a todos" -ErrorAction:SilentlyContinue
                                # Usar el parámetro ErrorAction con 
                                  el valor "SilentlyContinue".
        PS>                                             
                                # No se muestra el mensaje de error 
                                  y la ejecución continúa.

    En este ejemplo se muestra el efecto del valor SilentlyContinue.

        PS> $ErrorActionPreference = "SilentlyContinue"
                                # Cambiar el valor de la preferencia.

        PS> write-error "Hola a todos"                  
                                # Generar un mensaje de error.
        PS>                     
                                # Se suprime el mensaje de error.

        PS> write-error "Hola a todos" -erroraction:continue
                                # Usar el parámetro ErrorAction con 
                                  el valor "Continue".
        write-error "Hola a todos" -erroraction:continue : Hola a todos 
				# Se muestra el mensaje de error 
				  y la ejecución continúa.

       
    En este ejemplo se muestra el efecto de un error real. En este 
    caso, el comando obtiene un archivo no existente, nofile.txt. En 
    el ejemplo también se utiliza el parámetro común ErrorAction para 
    invalidar la preferencia.

        PS> $erroractionpreference                      
        SilentlyContinue        # Mostrar el valor de la preferencia.   

        PS> get-childitem -path nofile.txt
        PS>                     # Se suprime el mensaje de error.

        PS> $ErrorActionPreference = "Continue" 
                                # Cambiar el valor a Continue.

        PS> get-childitem -path nofile.txt
        Get-ChildItem : No se encuentra la ruta de acceso 
        'C:\nofile.txt' porque no existe.
        En línea:1 carácter:4
        + get-childitem  <<<< nofile.txt

        PS> get-childitem -path nofile.txt -erroraction SilentlyContinue
                                # Usar el parámetro ErrorAction. 
        PS>                       
				# Se suprime el mensaje de error.
  
        PS> $ErrorActionPreference = "Inquire"          
                                # Cambiar el valor a Inquire.
        PS> get-childitem -path nofile.txt

        Confirmar
        No se encuentra la ruta de acceso 'C:\nofile.txt' 
	porque no existe.
        [S] Sí [O] Sí a todo [I] Interrumpir comando [S] Suspender 
        [?] Ayuda (el valor predeterminado es "S"): s 

        Get-ChildItem : No se encuentra la ruta de acceso 
        'C:\nofile.txt' porque no existe.
        En línea:1 carácter:4
        + get-childitem  <<<< nofile.txt

        PS> $ErrorActionPreference = "Continue"                  
                                # Cambiar el valor a Continue.
        PS> Get-Childitem nofile.txt -erroraction "Inquire"   
                                # Usar el parámetro ErrorAction para 
                                  invalidar el valor de preferencia.

        Confirmar
        No se encuentra la ruta de acceso 'C:\nofile.txt' porque no 
        existe.          
	[S] Sí [O] Sí a todo [I] Interrumpir comando [U] Suspender 
	[?] Ayuda (el valor predeterminado es "S"):


$ErrorView
----------
        Determina el formato en el que se muestran los mensajes de 
        error en Windows PowerShell. 

        Valores válidos:	es una vista detallada diseñada para la 
	    NormalView 		mayoría de los usuarios. Consta de 
	    (valor 		una descripción del error, 
	    predeterminado):    el nombre del objeto implicado en el      
	    			error y flechas (<<<<) que apuntan
	     			a las palabras en el comando 
	    			que causó el error.

     	    CategoryView:       es una vista estructurada y concisa 
     	    			diseñada para los entornos de producción. 
     	   			El formato es: {Categoría}: 
				({nombreDelDestino}:{tipoDelDestino}):[{Actividad}], {Razón}

        Para obtener más información sobre los campos de CategoryView, 
        vea la clase ErrorCategoryInfo en el SDK de Windows PowerShell.
        
    EJEMPLOS

    En estos ejemplos se muestra el efecto de los valores de ErrorView.

    En este ejemplo se muestra cómo aparece un error cuando el valor 
    de $ErrorView es NormalView. En este caso, se usa el comando 
    Get-ChildItem para obtener un archivo no existente.

        PS> $ErrorView                         # Comprobar el valor.
        NormalView

        PS> get-childitem nofile.txt           # Obtener un 
        					 archivo no existente.
        Get-ChildItem : No se encuentra la ruta de acceso 
        'C:\nofile.txt' porque no existe.
        En línea:1 carácter:14
        + get-childitem <<<< nofile.txt

    En este ejemplo se muestra cómo aparece el mismo error cuando el 
    valor de $ErrorView es CategoryView.

        PS> $ErrorView = "CategoryView"        # Cambiar el valor a 
                                                 CategoryView

        PS> get-childitem nofile.txt
        ObjectNotFound: (C:\nofile.txt:String) [Get-ChildItem], 
        ItemNotFoundException

 
   En este ejemplo se muestra que el valor de ErrorView afecta 
   únicamente a la forma en que se muestra el error; no cambia la 
   estructura del objeto de error almacenado en la variable 
   automática $error. Para obtener información sobre la variable 
   automática $error, vea about_automatic_variables.

   Este comando toma el objeto ErrorRecord asociado al error más 
   reciente en la matriz de errores (elemento 0) y da formato de 
   lista a todas las propiedades del objeto de error.
           
        PS> $error[0] | format-list -property * -force

        Exception    : System.Management.Automation.ItemNotFoundException: 
		       No se encuentra la ruta de acceso 'C:\nofile.txt' porque 
      		       no existe. 
		       at System.Management.Automation.SessionStateInternal.GetChildItems(String
		       path, Boolean recurse, CmdletProviderContext context) 
		       at System.Management.Automation.ChildItemCmdletProviderIntrinsics.Get(String path, 
		       Boolean recurse, CmdletProviderContext context) 
		       at Microsoft.PowerShell.Commands.GetChildItemCommand.ProcessRecord() 
	TargetObject	      : C:\nofile.txt
        CategoryInfo          : ObjectNotFound: (C:\nofile.txt:String) [Get-ChildItem], 
				ItemNotFoundException 
	FullyQualifiedErrorId : PathNotFound,Microsoft.PowerShell.Commands.GetChildItemCommand :
        ErrorDetails          :
	InvocationInfo        : System.Management.Automation.InvocationInfo


$FormatEnumerationLimit
-----------------------
        Determina el número de elementos enumerados que se muestran. 
        Esta variable no afecta a los objetos subyacentes; 
        simplemente afecta a la presentación.
        Cuando el valor de $FormatEnumerationLimit es menor que el 
        número de elementos enumerados, Windows PowerShell agrega 
        puntos suspensivos (...) para indicar los elementos que no 
        se muestran.

        Valores válidos: enteros (Int32)
        Valor predeterminado: 4

    EJEMPLOS

        En este ejemplo se muestra cómo usar la variable 
        $FormatEnumerationLimit para mejorar la presentación de los 
        elementos enumerados. 

        El comando en este ejemplo genera una tabla en la que se 
        muestran todos los servicios que se ejecutan en el equipo en 
        dos grupos; uno para los servicios que se están ejecutando y 
        otro para los servicios que se han detenido. Utiliza un 
        comando Get-Service para obtener todos los servicios y, a 
        continuación, enviar los resultados a través de la 
        canalización al cmdlet Group-Object, que agrupa los 
        resultados según el estado del servicio. 

        Como resultado, se muestra una tabla en la que se indica el 
        estado en la columna Name y se especifican los procesos con 
        ese estado en la columna Group. (Para cambiar las etiquetas 
        de las columnas, utilice una tabla hash. Para obtener más 
        información, vea los ejemplos en "get-help format-table 
        -examples".) 

        Hay un máximo de 4 servicios en la columna Group por cada 
        estado. Para incrementar el número de elementos mostrados, 
        aumente el valor de $FormatEnumerationLimit hasta 1000.

        Como resultado, la lista en la columna Group está limitada 
        ahora por la longitud de las líneas. En el comando final del 
        ejemplo, utilice el parámetro Wrap de Format-Table para 
        mostrar todos los procesos en cada grupo de estado.
         

        PS> $formatenumerationlimit         # Obtener el valor actual.
        4
        
        PS> get-service | group-object -property status           
                                            # Mostrar todos los servicios 
                                              agrupados por estado.

        Count Name                      Group
        ----- ----                      -----
           60 Running                   {AdtAgent, ALG, Ati HotKey Poller, AudioSrv...}   
           41 Stopped                   {Alerter, AppMgmt, aspnet_state, ATI Smart...}

                                           # La lista se trunca después de 
					     4 elementos.


        PS> $formatenumerationlimit = 1000
                                           # Aumentar el límite hasta 1000.
        
        PS> get-service | group-object -property status           
                                           # Repetir el comando.

        Count Name   Group
        ----- ----   -----
           60 Running {AdtAgent, ALG, Ati HotKey Poller, AudioSrv, BITS, CcmExec...
           41 Stopped {Alerter, AppMgmt, aspnet_state, ATI Smart, Browser, CiSvc...


        PS> get-service | group-object -property status | format-table -wrap
                                           # Agregar el parámetro Wrap.

        Count Name       Group
        ----- ----       -----
           60 Running    {AdtAgent, ALG, Ati HotKey Poller, AudioSrv, BITS, CcmExec, 
           		 Client for NFS, CryptSvc, DcomLaunch, Dhcp, dmserver, 
           		 Dnscache, ERSvc, Eventlog, EventSystem, FwcAgent, helpsvc, 
           		 HidServ, IISADMIN, InoRPC, InoRT, InoTask, lanmanserver, 
            		 lanmanworkstation, LmHosts, MDM, Netlogon, Netman,  
           		 Nla, NtLmSsp, PlugPlay, PolicyAgent, ProtectedStorage, 
           		 RasMan, RemoteRegistry, RpcSs, SamSs, Schedule, seclogon, 
           		 SENS, SharedAccess, ShellHWDetection, SMT PSVC, Spooler, 
           		 srservice, SSDPSRV, stisvc, TapiSrv, TermService, 
           		 Themes, TrkWks, UMWdf, W32Time, W3SVC, WebClient, 
           		 winmgmt, wscsvc, wuauserv, WZCSVC, zzInterix}

           41 Stopped    {Alerter, AppMgmt, aspnet_state, ATI Smart, 
           		 Browser, CiSvc, ClipSrv, clr_optimization_v2.0.50727_32, 
           		 COMSysApp, CronService, dmadmin, FastUserSwitchingCompatibi
           		 lity, HTTPFilter, ImapiService, Mapsvc, Messenger, 
          		 mnmsrvc, MSDTC, MSIServer, msvsmon80, NetDDE, NetDDEdsdm, 
         		 NtmsSvc, NVSvc, ose, RasAuto, RDSessMgr, RemoteAccess, 
          		 RpcLocator, RSVP, SCardSvr, SwPrv, SysmonLog, TlntSvr, 
          		 upnphost, UPS, VSS, WmdmPmSN, Wmi, WmiApSrv, xmlprov}


$Log*Event
----------
        Las variables de preferencia Log*Event determinan los tipos 
        de eventos que se escriben en el registro de eventos de 
        Windows PowerShell en el Visor de eventos. De forma 
        predeterminada, se registran únicamente los eventos del motor 
        y de los proveedores, pero se pueden usar las variables de 
        preferencia Log*Event para personalizar el registro, por 
        ejemplo, para que se registren los eventos de los comandos.   

        Las variables de preferencia Log*Event son las siguientes:

            $LogCommandHealthEvent: registra los errores y excepciones 
            	que se producen durante la inicialización y el procesamiento 
            	de los comandos. El valor predeterminado es $false 
            	(no se produce el registro).

            $LogCommandLifecycleEvent: 
                registra el inicio y la detención de los comandos y 
                canalizaciones de comandos así como las excepciones 
                de seguridad en la detección de comandos. El valor 
                predeterminado es $false (no se produce el registro).

            $LogEngineHealthEvent: registra los errores de las 
            	sesiones. El valor predeterminado es 
            	$true (se produce el registro).

            $LogEngineLifecycleEvent: registra la apertura y el 
            	cierre de las sesiones. El valor 
            	predeterminado es $true (se produce el registro).

            $LogProviderHealthEvent: registra los errores de los 
            	proveedores, como errores de lectura y escritura, errores 
            	de búsqueda y errores de invocación. El valor 
            	predeterminado es $true (se produce el registro).

            $LogProviderLifecycleEvent: registra la adición y la 
            	eliminación de proveedores de Windows PowerShell.
                El valor predeterminado es $true (se produce el 
                registro). (Para obtener información sobre los 
                proveedores de Windows PowerShell, escriba:
                "get-help about_provider".


        Para habilitar una variable Log*Event, escriba la variable 
        con el valor $true. Por ejemplo:

            $LogCommandLifeCycleEvent

            - o bien,

            $LogCommandLifeCycleEvent = $true


        Para deshabilitar un tipo de evento, escriba la variable con 
        el valor $false. Por ejemplo:

            $LogCommandLifeCycleEvent = $false

        Los eventos habilitados se aplican únicamente a la consola 
        actual de Windows PowerShell. Para aplicar la configuración a 
        todas las consolas, guarde la configuración de la variable en 
        su perfil de Windows PowerShell.


$MaximumAliasCount
------------------
        Determina el número de alias que se permiten en una sesión de 
        Windows PowerShell. El valor predeterminado, 4096, debería 
        ser suficiente en la mayoría de los casos, pero puede 
        ajustarlo según sus necesidades.

        Valores válidos: 1024 - 32768 (Int32)
        Valor predeterminado: 4096
      
        Para determinar el número de alias en el sistema, escriba: 

		(get-alias).count

$MaximumDriveCount
------------------
        Determina el número de unidades de Windows PowerShell que se 
        permiten en una sesión concreta. Incluye las unidades del 
        sistema de archivos y los almacenes de datos que los 
        proveedores de Windows PowerShell exponen y que aparecen como 
        unidades, como las unidades Alias: y HKLM:.

        Valores válidos: 1024 - 32768 (Int32)
        Valor predeterminado: 4096
      
        Para determinar el número de unidades en el sistema, escriba: 

		(get-psdrive).count



$MaximumErrorCount
------------------
        Determina el número de errores que se guardan en el historial 
        de errores de la sesión. 

        Valores válidos: 256 - 32768 (Int32)
        Valor predeterminado: 256

        Los objetos que representan los errores se almacenan en la 
        variable automática $Error. Esta variable contiene una matriz 
        de objetos de registro de error, uno por cada error. El error 
        más reciente es el primer objeto de la matriz ($Error[0]).
      
        Para determinar el número de errores en el sistema, utilice 
        la propiedad Count de la matriz $Error. Escriba:
		
		$Error.count

        Para mostrar un error concreto, utilice la notación de 
        matriz. Por ejemplo, para ver el error más reciente, escriba:

                $Error[0]

        Para mostrar el error más antiguo que se ha guardado, escriba:

                $Error[($Error.Count -1]

        Para mostrar las propiedades del objeto ErrorRecord, escriba:

                $Error[0] | format-list -property * -force

        En este comando, el parámetro Force invalida el formato 
        especial de los objetos ErrorRecord y restablece el formato 
        convencional.

        Para eliminar todos los errores del historial de errores, 
        utilice el método Clear de la matriz de errores.

               PS> $Error.count
               17
               PS> $Error.clear()
               PS>
               PS> $Error.count
               0

       Para obtener todos los métodos y propiedades de una matriz 
       de errores, utilice el cmdlet Get-Member con el parámetro 
       InputObject. Cuando se canaliza una colección de objetos 
       a Get-Member, este cmdlet muestra las propiedades y los métodos 
       de los objetos de la colección. Cuando se usa el parámetro 
       InputObject de Get-Member, este cmdlet muestra las propiedades 
       y los métodos de la colección.


$MaximumFunctionCount
------------------
        Determina el número de funciones que se permiten en una 
        sesión concreta. 

        Valores válidos: 1024 - 32768 (Int32)
        Valor predeterminado: 4096

        Para ver las funciones de la sesión, utilice la unidad 
        Function: de Windows PowerShell expuesta por el proveedor 
        Function de Windows PowerShell. (Para obtener más información 
        sobre el proveedor Function, escriba "get-help function").

        Para obtener las funciones de la sesión actual, escriba:

            get-childitem function:

        Para determinar el número de funciones en la sesión actual, 
        escriba:

            (get-childitem function:).count


$MaximumHistoryCount
------------------
        Determina el número de comandos guardados en el historial de 
        comandos de la sesión actual. 

        Valores válidos: 1 - 32768 (Int32)
        Valor predeterminado: 64

        Para determinar el número de comandos actualmente guardados 
        en el historial de comandos, escriba:
 
            (get-history).count

        Para ver los comandos guardados en el historial de la sesión, 
        utilice el cmdlet Get-History. Para obtener más información, 
        escriba "get-help about_history".



$MaximumVariableCount
------------------
        Determina el número de variables que se permiten en una 
        sesión concreta, incluidas las variables automáticas, las 
        variables de preferencia y las variables que se crean en 
        comandos y scripts. 

        Valores válidos: 1024 - 32768 (Int32)
        Valor predeterminado: 4096

        Para ver las variables de la sesión, utilice el cmdlet 
        Get-Variable y las características de la unidad Variable: de 
        Windows PowerShell así como del proveedor Variable de Windows 
        PowerShell. Para obtener información sobre el proveedor 
        Variable, escriba "get-help variable".

        Para obtener el número actual de variables en el sistema, escriba:

            (get-variable).count



$OFS
----
        Separador de campos de salida. Especifica el carácter que 
        separa los elementos de una matriz cuando esta se convierte 
        en una cadena. 

        Valores válidos: cualquier cadena.
        Valor predeterminado: un espacio

        De forma predeterminada, la variable $OFS no existe y el 
        separador de campos de salida es un espacio, pero se puede 
        agregar esta variable y establecer su valor en cualquier cadena.

    EJEMPLOS

    En este ejemplo se muestra que se usa un espacio para separar los 
    valores cuando se convierte una matriz en una cadena. En este 
    caso, se almacena una matriz de enteros en una variable y, 
    a continuación, se convierte la variable en una cadena.

       PS> $array = 1,2,3                 # Almacenar una matriz de enteros.       

       PS> [string]$array                 # Convertir la matriz en una cadena.
       1 2 3                              # Los elementos están separados 
					    por espacios.


    Para cambiar el separador, agregue la variable $OFS asignándole 
    un valor. Para que funcione correctamente, la variable debe 
    denominarse $OFS. 

       PS> $OFS = "+"                     # Crear $OFS y asignarle "+".

       PS> [string]$array                 # Repetir el comando.
       1+2+3                              # Los elementos están separados por 
       					    signos más.


    Para restaurar el comportamiento predeterminado, puede asignar un 
    espacio (" ") al valor de $OFS o eliminar la variable. Este 
    comando elimina la variable y, a continuación, comprueba que el 
    separador es un espacio.
        
       PS> Remove-Variable OFS            # Eliminar $OFS.
       PS>

       PS> [string]$array                 # Repetir el comando.
       1 2 3                              # Los elementos están separados por 
       espacios. 

$OutputEncoding
---------------
       Determina el método de codificación de caracteres utilizado 
       por Windows PowerShell cuando envía texto a otras 
       aplicaciones. Por ejemplo, si una aplicación devuelve cadenas 
       Unicode a Windows PowerShell, es posible que haya que cambiar 
       el valor para que se envíen correctamente los caracteres.

        Valores válidos: objetos derivados de una clase de codificación, 
			 como ASCIIEncoding, SBCSCodePageEncoding, 
			 UTF7Encoding, UTF8Encoding, UTF32Encoding 
			 y UnicodeEncoding.

        Valor predeterminado: objeto ASCIIEncoding 
	(System.Text.ASCIIEncoding)

    EJEMPLOS

       En este ejemplo, se muestra cómo proceder para que el comando 
       FINDSTR de Windows funcione en una versión de Windows 
       PowerShell localizada en un idioma que usa caracteres Unicode, 
       como el chino. 

       El primer comando busca el valor de $OutputEncoding. Dado que 
       el valor es un objeto de codificación, se muestra únicamente 
       su propiedad EncodingName.
         
          PS> $OutputEncoding.EncodingName # Obtener el valor actual.
          US-ASCII

       En este ejemplo, se usa un comando FINDSTR para buscar dos 
       caracteres chinos en el archivo Test.txt. Cuando se ejecuta 
       este comando FINDSTR en el símbolo del sistema de Windows 
       (Cmd.exe), FINDSTR encuentra los caracteres en el archivo de 
       texto. Sin embargo, cuando se ejecuta el mismo comando FINDSTR 
       en Windows PowerShell, no se encuentran los caracteres porque 
       Windows PowerShell los envía a FINDSTR en texto ASCII, en 
       lugar de enviarlos en texto Unicode.

          PS> findstr <Caracteres Unicode> # Usar findstr para 
          				     realizar la búsqueda.
          PS>                              # No se ha encontrado 
					     ningún carácter.

        
       Para que el comando funcione en Windows PowerShell, establezca 
       el valor de $OutputEncoding en el valor de la propiedad 
       OutputEncoding de la consola, el cual se basa en la 
       configuración regional seleccionada para Windows. Dado que 
       OutputEncoding es una propiedad estática de la consola, 
       utilice dos puntos dobles (::) en el comando.

          PS> $OutputEncoding = [console]::outputencoding
          PS>                              # Establecer el valor en el 
					     valor de la propiedad 
                                             OutputEncoding de la 
                                             consola.
          PS> $OutputEncoding.EncodingName               
          OEM United States
                                           # Obtener el valor resultante.
     
       Como resultado de este cambio, el comando FINDSTR encuentra 
       los caracteres.

          PS> findstr <caracteres Unicode>               
          test.txt:         <Caracteres Unicode>        

					# Usar findstr para realizar la búsqueda. 
                                          Se encuentran los caracteres en el 
                                          archivo de texto.



$ProgressPreference
-------------------
	Determina la forma en que Windows PowerShell responde a las 
	actualizaciones de progreso generadas por un script, cmdlet o 
	proveedor, como las barras de progreso generadas por el cmdlet 
	Write-Progress. El cmdlet Write-Progress crea barras de progreso que 
	reflejan el estado de un comando.

        Valores válidos:
	    Stop:               no se muestra la barra de progreso. En su 
	    			lugar, se muestra un mensaje de error 
				y se detiene la ejecución.

     	    Inquire:            no se muestra la barra de progreso. 
     	    			Se pregunta al usuario si desea continuar. 
     	    			Si el usuario responde Sí o Sí a todo, 
     	    			se muestra la barra de progreso.

            Continue 		se muestra la barra de progreso 
	    (valor 		y continúa la ejecución.
	    predeterminado):           

            SilentlyContinue: 	se ejecuta el comando, pero no se 
            			muestra la barra de progreso.


$PSEmailServer
--------------
       Especifica el servidor de correo electrónico predeterminado 
       que se utiliza para enviar los mensajes de correo electrónico. 
       Esta variable de preferencia la utilizan los cmdlets que 
       envían correo electrónico, como el cmdlet Send-MailMessage. 


$PSSessionApplicationName
---------------------------
       Especifica el nombre de aplicación predeterminado para un 
       comando remoto que utiliza la tecnología WS-Management.

       El nombre de aplicación predeterminado del sistema es WSMAN, 
       pero se puede utilizar esta variable de preferencia para 
       cambiar el nombre predeterminado. 

       El nombre de aplicación es el último nodo en un identificador 
       URI de conexión. Por ejemplo, el nombre de aplicación en el 
       siguiente identificador URI de ejemplo es WSMAN.

           http://Server01:8080/WSMAN


       Se utiliza el nombre de aplicación predeterminado cuando el 
       comando remoto no especifica ningún identificador URI de 
       conexión o ningún nombre de aplicación.  

       El servicio WinRM utiliza el nombre de aplicación para 
       seleccionar un agente de escucha a fin de atender la solicitud 
       de conexión. El valor de este parámetro debe coincidir con el 
       valor de la propiedad URLPrefix de un agente de escucha en el 
       equipo remoto.

       Para invalidar el valor predeterminado del sistema y el valor 
       de esta variable y seleccionar otro nombre de aplicación para 
       una sesión concreta, utilice el parámetro ApplicationName o 
       ConnectionURI del cmdlet New-PSSession, Enter-PSSession o 
       Invoke-Command.   

       Esta variable de preferencia se establece en el equipo local, 
       pero especifica un agente de escucha en el equipo remoto. Si 
       el nombre de aplicación especificado no existe en el equipo 
       remoto, el comando para establecer la sesión generará un error.



$PSSessionConfigurationName
---------------------------
       Especifica la configuración de sesión predeterminada que se 
       usa para las PSSessions creadas en la sesión actual.

       Esta variable de preferencia se establece en el equipo local, 
       pero especifica una configuración de sesión en el equipo remoto. 

       El valor de la variable $PSSessionConfigurationName es un 
       identificador URI de recurso completo. 

       El valor predeterminado: 

         https://schemas.microsoft.com/powershell/microsoft.powershell 

       indica la configuración de sesión Microsoft.PowerShell en el 
       equipo remoto. 

       Si se especifica únicamente un nombre de configuración, se 
       antepone el siguiente identificador URI de esquema:

           https://schemas.microsoft.com/powershell/

             
       Se puede invalidar el valor predeterminado y seleccionar otra 
       configuración de sesión para una sesión concreta mediante el 
       parámetro ConfigurationName del cmdlet New-PSSession, 
       Enter-PSSession o Invoke-Command.   

       El valor de esta variable se puede modificar en cualquier 
       momento. Si lo cambia, recuerde que la configuración de sesión 
       que seleccione debe existir en el equipo remoto. De lo 
       contrario, el comando para crear una sesión que use la 
       configuración de sesión generará un error.

       Esta variable de preferencia no determina qué configuraciones 
       de sesión locales se usan cuando los usuarios remotos crean 
       una sesión que se conecta a este equipo. Sin embargo, se 
       pueden usar los permisos de las configuraciones de sesión 
       locales para determinar los usuarios que pueden utilizarlas.


$PSSessionOption
----------------
        Establece los valores predeterminados de las opciones de 
        usuario avanzadas en una sesión remota. Estas preferencias 
        invalidan los valores predeterminados del sistema para las 
        opciones de sesión. 

        Asimismo, se pueden establecer opciones personalizadas para 
        una sesión remota concreta mediante el parámetro 
        SessionOption en los cmdlets que crean una sesión, como 
        New-PSSession, Enter-PSSession e Invoke-Command. El valor del 
        parámetro SessionOption tiene precedencia sobre los valores 
        predeterminados del sistema y los valores predeterminados que 
        se establecen en esta variable.

        La variable $PSSessionOption contiene un objeto PSSessionOption        
        (System.Management.Automation.Remoting.PSSessionObject). Cada 
	propiedad del objeto representa una opción de sesión. Por ejemplo, 
	la propiedad NoCompression desactiva la compresión de datos 
	durante la sesión.

        Para crear la variable de preferencia $PSSessionOption, 
        utilice el cmdlet New-PSSessionOption. Guarde el resultado en 
        una variable denominada $PSSessionOption. 

        Por ejemplo:

            $PSSessionOption = New-PSSessionOption -NoCompression 

        Para poder usar la variable de preferencia $PSSessionOption 
        en todas las sesiones de Windows PowerShell, agregue a su 
        perfil de Windows PowerShell un comando New-PSSessionOption 
        que cree la variable $PSSessionOption.

        Para obtener más información sobre el cmdlet New-PSSessionOpti
        on, vea el tema de Ayuda correspondiente a New-PSSessionOption. 
        Para obtener más información sobre los comandos remotos 
        y las sesiones, vea about_Remote y about_PSSessions.
        Para obtener más información sobre cómo usar un perfil, vea 
        about_Profiles.




$VerbosePreference
------------------
       	Determina la forma en que Windows PowerShell responde 
       	a los mensajes detallados generados por un script, cmdlet 
       	o proveedor, como los mensajes generados por el cmdlet 
       	Write-Verbose. Los mensajes detallados suelen describir las 
       	acciones que se realizan para ejecutar un comando. 

        De forma predeterminada, no se muestran los mensajes 
        detallados, pero se puede modificar este comportamiento 
        cambiando el valor de $VerbosePreference.

        Asimismo, se puede utilizar el parámetro común Verbose de un 
        cmdlet para mostrar u ocultar los mensajes detallados de un 
        comando concreto. Para obtener más información, escriba "get-help 
        about_commonparameters".


        Valores válidos:
	    Stop:               se muestran el mensaje detallado y un 
	    			mensaje de error y, a continuación, 
				se detiene la ejecución.

     	    Inquire:            se muestra el mensaje detallado y, 
     	    			a continuación, se pregunta al 
				usuario si desea continuar.

            Continue:           se muestra el mensaje detallado 
            			y, después, continúa la ejecución.

            SilentlyContinue 	no se muestra el mensaje detallado. 
	    (valor 		Continúa la ejecución.
	    predeterminado): 

    EJEMPLOS

    En estos ejemplos se muestra el efecto de los diferentes valores de 
    $VerbosePreference y del uso del parámetro común Verbose para 
    invalidar el valor de preferencia.
    
    En este ejemplo se muestra el efecto del valor SilentlyContinue, 
    que es el valor predeterminado.

        PS> $VerbosePreference             # Obtener el valor actual.
        SilentlyContinue

        PS> Write-Verbose "Prueba de mensaje detallado."              
        PS>                                # Escribir un mensaje detallado.
                                           # No se muestra el mensaje.

        PS> Write-Verbose "Prueba de mensaje detallado." -verbose   
        DETALLADO: Prueba de mensaje detallado.
	                                   # Usar el parámetro Verbose.


    En este ejemplo se muestra el efecto del valor Continue.

        PS> $VerbosePreference = "Continue"                    
                                           # Cambiar el valor a Continue.
        PS> Write-Verbose "Prueba de mensaje detallado."              
                                           # Escribir un mensaje detallado.
        DETALLADO: Prueba de mensaje detallado.       
        			  	   # Se muestra el mensaje.

        PS> Write-Verbose "Prueba de mensaje detallado." -verbose:$false
                                           # Usar el parámetro 
                                             Verbose con el valor $false.
        PS>                                  
                                           # No se muestra el mensaje.


    En este ejemplo se muestra el efecto del valor Stop.

        PS> $VerbosePreference = "Stop"                        
                                           # Cambiar el valor a Stop.
        PS> Write-Verbose "Prueba de mensaje detallado."              
                                           # Escribir un mensaje 
                                             detallado.
        DETALLADO: Prueba de mensaje detallado.
        Write-Verbose : Se detuvo la ejecución del comando porque la 
        variable de shell "VerbosePreference" está establecida en Stop.
        En línea:1 carácter:14
        + Write-Verbose <<<< "Prueba de mensaje detallado."

       PS> Write-Verbose "Prueba de mensaje detallado." -verbose:$false
                                          # Usar el parámetro Verbose 
                                            con el valor $false. 
       PS>                                 
					  # No se muestra el mensaje.

    En este ejemplo se muestra el efecto del valor Inquire.

       PS> $VerbosePreference = "Inquire"                      
                                         # Cambiar el valor a Inquire.
       PS> Write-Verbose "Prueba de mensaje detallado."               
       DETALLADO: Prueba de mensaje detallado.
                                         # Escribir un mensaje detallado.
       Confirmar
       ¿Desea continuar con la operación?
       [S] Sí [O] Sí a todo [I] Interrumpir comando [S] Suspender [?] 
       Ayuda (el valor predeterminado es "S"): s 
       PS>

       PS> Write-Verbose "Prueba de mensaje detallado." -verbose:$false
                                        # Usar el parámetro Verbose.
       PS>                              
                                        # No se muestra el mensaje.


    
$WarningPreference
------------------
        Determina la forma en que Windows PowerShell responde a los 
        mensajes de advertencia generados por un script, cmdlet o 
        proveedor, como los mensajes generados por el cmdlet 
        Write-Warning.

        De forma predeterminada, se muestran los mensajes de 
        advertencia y continúa la ejecución, pero se puede modificar 
        este comportamiento cambiando el valor de $WarningPreference.

        Asimismo, se puede usar el parámetro común WarningAction de 
        un cmdlet para determinar la forma en que Windows PowerShell 
        responde a las advertencias de un comando concreto. Para 
        obtener más información, escriba "get-help about_commonparameters".


        Valores válidos:
	    Stop:               se muestran el mensaje de advertencia y un 
	    			mensaje de error y, a continuación, 
				se detiene la ejecución.

     	    Inquire:            se muestra el mensaje de advertencia y, 
     	    			a continuación, se pregunta al usuario si 
     	    			desea continuar. 

            Continue 		se muestra el mensaje de advertencia y, 
	    (valor 		después, continúa la ejecución.
	    predeterminado):           

            SilentlyContinue: 	no se muestra el mensaje de 
            			advertencia. Continúa la ejecución.

    EJEMPLOS

    En estos ejemplos se muestra el efecto de los diferentes valores de 
    $WarningPreference y del uso del parámetro común WarningAction para 
    invalidar el valor de preferencia.

    
    En este ejemplo se muestra el efecto del valor Continue, que es 
    el valor predeterminado.

            PS> $WarningPreference    # Obtener el valor actual.                           
            Continue                  

                                      # Escribir un mensaje de advertencia.
            PS> Write-Warning "Esta acción puede eliminar datos."   
            ADVERTENCIA: Esta acción puede eliminar datos.
                                      	
                                      # Usar el parámetro WarningAction a fin de 
				      # suprimir la advertencia para este comando.
	    PS> Write-Warning "Esta acción puede eliminar datos." -warningaction 
	    silentlycontinue   



   En este ejemplo se muestra el efecto del valor SilentlyContinue.

            PS> $WarningPreference = "SilentlyContinue"           
                                      # Cambiar el valor a SilentlyContinue.
 
            PS> Write-Warning "Esta acción puede eliminar datos."   
            PS>                       # Escribir un mensaje de advertencia.

       
            PS> Write-Warning "Esta acción puede eliminar datos." -warningaction stop   
                                      # Usar el parámetro WarningAction para 
                                      #	que se detenga el 
                                      #	procesamiento cuando este 
                                      #	comando genere una advertencia.
	    ADVERTENCIA: Esta acción puede eliminar datos.
            Write-Warning : Se detuvo la ejecución del comando porque 
            la variable de shell "WarningPreference" está establecida en Stop.
            En línea:1 carácter:14
            + Write-Warning <<<< "Esta acción puede eliminar datos." -warningaction stop 


    En este ejemplo se muestra el efecto del valor Inquire.

           PS> $WarningPreference = "Inquire"                    
                                      # Cambiar el valor a Inquire.
           PS> Write-Warning "Esta acción puede eliminar datos."  
                                      # Escribir un mensaje de advertencia.   
           ADVERTENCIA: Esta acción puede eliminar datos.

           Confirmar
           ¿Desea continuar con la operación?
           [S] Sí [O] Sí a todo [I] Interrumpir comando [S] Suspender 
           [?] Ayuda (el valor predeterminado es "S"): s 

           PS> Write-Warning "Esta acción puede eliminar datos." 
           -warningaction silentlycontinue
           PS>                         # Usar el parámetro WarningAction para cambiar la
                                       # respuesta a una advertencia para el comando actual.



     En este ejemplo se muestra el efecto del valor Stop.

           PS> $WarningPreference = "Stop"                       
                                     # Cambiar el valor a Stop.

           PS> Write-Warning "Esta acción puede eliminar datos."   
                                     # Escribir un mensaje de advertencia.
           ADVERTENCIA: Esta acción puede eliminar datos.
           Write-Warning : Se detuvo la ejecución del comando porque 
           la variable de shell "WarningPreference" está establecida 
           en Stop.
           En línea:1 carácter:14
           + Write-Warning <<<< "Esta acción puede eliminar datos."


           PS> Write-Warning "Esta acción puede eliminar datos." 
           -warningaction inquire
           ADVERTENCIA: Esta acción puede eliminar datos.

           Confirmar
           ¿Desea continuar con la operación?
           [S] Sí [O] Sí a todo [I] Interrumpir comando [U] Suspender 
           [?] Ayuda (el valor predeterminado es "S"):                         
					# Usar el parámetro WarningAction para cambiar la 
           				# respuesta a una advertencia para el comando actual.


$WhatIfPreference
------------------
       	Determina si se habilita automáticamente WhatIf para cada 
       	comando que lo admite. Cuando WhatIf está habilitado, el 
       	cmdlet informa del efecto esperado del comando, pero no 
       	ejecuta el comando. 

        Valores válidos:
	    0:			    WhatIf no se habilita automáticamente. 
	    (valor predeterminado)  Para habilitarlo manualmente, utilice el 
	    			    parámetro WhatIf del comando.
            

     	    1:                 	    WhatIf se habilita automáticamente en 
     	    			    cualquier comando que lo admita. 
     	    			    Se puede usar el comando WhatIf con el 
     	    			    valor False para deshabilitarlo 
				    manualmente (WhatIf:$false).
    EXPLICACIÓN DETALLADA

        Cuando un cmdlet admite WhatIf, el cmdlet informa del efecto 
        esperado del comando, en lugar de ejecutar el comando. Por 
        ejemplo, en lugar de eliminar el archivo test.txt en 
        respuesta a un comando Remove-Item, Windows PowerShell 
        informa de lo que eliminaría. Un comando Get-Childitem 
        subsiguiente confirma que no se eliminó el archivo.

              PS> remove-item test.txt
              What if: Se está realizando la operación "Remove-Item" 
              en el destino "Item: C:\test.txt.
              PS> get-childitem test.txt

              Directorio: Microsoft.PowerShell.Core\FileSystem::C:


              Mode                LastWriteTime     Length     Name
              ----                -------------     ------     ----
              -a---         29/7/2006   19:15         84     test.txt



    EJEMPLOS

    En estos ejemplos, se muestra el efecto de los diferentes valores de 
    $WhatIfPreference. También se muestra cómo usar el parámetro de 
    cmdlet WhatIf a fin de invalidar el valor de preferencia para un 
    comando concreto.
    
    En este ejemplo, se muestra el efecto del valor predeterminado 0 
    (WhatIf no está habilitado).

             PS> $whatifpreference                     
             0                         # Comprobar el valor actual.

             PS> get-childitem test.txt | format-list FullName
             FullName : C:\test.txt
                                       # Comprobar que el archivo existe.

             PS> remove-item test.txt                  
             PS>                       # Eliminar el archivo.

             PS> get-childitem test.txt | format-list -property FullName
                                       # Comprobar que el archivo se 
                                         ha eliminado.

             Get-ChildItem : No se encuentra la ruta de acceso 
             'C:\test.txt' porque no existe.
             En línea:1 carácter:14
             + get-childitem <<<< test.txt | format-list fullname


     En este ejemplo, se muestra el efecto del parámetro WhatIf 
     cuando el valor de $WhatIfPreference es 0.

             PS> get-childitem test2.txt | format-list -property FullName 
             FullName : C:\test2.txt
                                      # Comprobar que el archivo existe.

             PS> remove-item test2.txt -whatif         
             What if: Se está realizando la operación "Quitar 
             archivo" en el destino "C:\test2.txt".
                                      # Usar el parámetro WhatIf.

             PS> get-childitem test2.txt | format-list -property FullName
             FullName : C:\test2.txt
                                      # Comprobar que el archivo no 
                                        se ha eliminado. 

    En este ejemplo, se muestra el efecto del valor 1 (WhatIf está 
    habilitado). Cuando se usa Remove-Item para eliminar un cmdlet, 
    Remove-Item muestra la ruta de acceso al archivo que eliminaría, 
    pero no elimina el archivo.

             PS> $whatifpreference = 1                 
             PS> $whatifpreference
             1                        # Cambiar el valor.
                                      
             PS> remove-item test.txt                  
             What if: Se está realizando la operación "Quitar 
             archivo" en el destino "C:\test.txt".
                                      # Intentar eliminar un archivo.

             PS> get-childitem test.txt | format-list FullName
             FullName : C:\test.txt
                                      # Comprobar que el archivo existe.

     En este ejemplo, se muestra cómo eliminar un archivo cuando el 
     valor de $WhatIfPreference es 1. Se utiliza el parámetro WhatIf 
     con el valor $false.

             PS> remove-item test.txt -whatif:$false
                                      # Usar el parámetro WhatIf con 
                                        $false.

     En este ejemplo, se muestra que algunos cmdlets admiten el 
     comportamiento de WhatIf mientras que otros no lo admiten. En 
     este ejemplo, donde el valor de $WhatIfPreference es 1 
     (habilitado), se ejecuta un comando Get-Process, que no admite 
     WhatIf, pero un comando Stop-Process realiza el comportamiento 
     de WhatIf. Se puede invalidar el comportamiento de WhatIf del comando 
     Stop-Process usando el parámetro WhatIf con el valor $false.

            PS> $whatifpreference = 1                  
                                     # Cambiar el valor a 1.
                                                      
            PS> get-process winword 
                                     # Se completa un comando Get-Process.

            Handles NPM(K)  PM(K)   WS(K) VM(M)  CPU(s)   Id ProcessName
            ------- ------   -----   ----- -----  ------   -- -----------
            		8   6324     15060  154   0.36     2312 WINWORD


           PS> stop-process -name winword
           What if: Se está realizando la operación "Stop-Process" en 
           el destino "WINWORD (2312)".
                                    # Un comando Stop-Process utiliza 
                                    WhatIf.

           PS> stop-process -name winword -whatif:$false
           PS>                      # WhatIf:$false invalida la preferencia.
           
           PS> get-process winword                     
           Get-Process : No se encuentra ningún proceso con el nombre 
           'winword'. Compruebe el nombre del proceso y ejecute de 
           nuevo el cmdlet.
           En línea:1 carácter:12
           + get-process <<<< winword
                                    # Comprobar que el proceso se ha 
                                      detenido.





VEA TAMBIÉN
    about_Automatic_Variables
    about_CommonParameters
    about_Environment_Variables
    about_Profiles
    about_Remote
    about_Scopes
    about_Variables




Tabla de contenido