C# Automation.CmdletProviderContext类代码示例

 internal CmdletProviderContext(CmdletProviderContext contextToCopyFrom)
 {
     this.credentials = PSCredential.Empty;
     this._origin = CommandOrigin.Internal;
     this.accumulatedObjects = new Collection<PSObject>();
     this.accumulatedErrorObjects = new Collection<ErrorRecord>();
     this.stopReferrals = new Collection<CmdletProviderContext>();
     if (contextToCopyFrom == null)
     {
         throw PSTraceSource.NewArgumentNullException("contextToCopyFrom");
     }
     this.executionContext = contextToCopyFrom.ExecutionContext;
     this.command = contextToCopyFrom.command;
     if (contextToCopyFrom.Credential != null)
     {
         this.credentials = contextToCopyFrom.Credential;
     }
     this.drive = contextToCopyFrom.Drive;
     this.force = (bool) contextToCopyFrom.Force;
     this.CopyFilters(contextToCopyFrom);
     this.suppressWildcardExpansion = contextToCopyFrom.SuppressWildcardExpansion;
     this.dynamicParameters = contextToCopyFrom.DynamicParameters;
     this._origin = contextToCopyFrom._origin;
     this.stopping = contextToCopyFrom.Stopping;
     contextToCopyFrom.StopReferrals.Add(this);
     this.copiedContext = contextToCopyFrom;
 }

 internal MamlCommandHelpInfo GetProviderSpecificHelpInfo(string helpItemName)
 {
     ProviderInfo info = null;
     PSDriveInfo drive = null;
     string str = null;
     CmdletProviderContext context = new CmdletProviderContext(this._executionContext);
     try
     {
         string str2 = this._requestedPath;
         if (string.IsNullOrEmpty(this._requestedPath))
         {
             str2 = this._pathIntrinsics.CurrentLocation.Path;
         }
         str = this._executionContext.LocationGlobber.GetProviderPath(str2, context, out info, out drive);
     }
     catch (ArgumentNullException)
     {
     }
     catch (ProviderNotFoundException)
     {
     }
     catch (DriveNotFoundException)
     {
     }
     catch (ProviderInvocationException)
     {
     }
     catch (NotSupportedException)
     {
     }
     catch (InvalidOperationException)
     {
     }
     catch (ItemNotFoundException)
     {
     }
     if (info == null)
     {
         return null;
     }
     CmdletProvider provider = info.CreateInstance();
     ICmdletProviderSupportsHelp help = provider as ICmdletProviderSupportsHelp;
     if (help == null)
     {
         return null;
     }
     if (str == null)
     {
         throw new ItemNotFoundException(this._requestedPath, "PathNotFound", SessionStateStrings.PathNotFound);
     }
     provider.Start(info, context);
     string path = str;
     string helpMaml = help.GetHelpMaml(helpItemName, path);
     if (string.IsNullOrEmpty(helpMaml))
     {
         return null;
     }
     return MamlCommandHelpInfo.Load(InternalDeserializer.LoadUnsafeXmlDocument(helpMaml, false, null).DocumentElement, HelpCategory.Provider);
 }

 internal PSDriveInfo NewDrive(PSDriveInfo drive, CmdletProviderContext context)
 {
     base.Context = context;
     if (((drive.Credential != null) && (drive.Credential != PSCredential.Empty)) && !CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.Credentials, base.ProviderInfo))
     {
         throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "NewDriveCredentials_NotSupported", new object[0]);
     }
     return this.NewDrive(drive);
 }

 internal void CopyProperty(string sourcePath, string sourceProperty, string destinationPath, string destinationProperty, CmdletProviderContext cmdletProviderContext)
 {
     this.Context = cmdletProviderContext;
     IDynamicPropertyCmdletProvider provider = this as IDynamicPropertyCmdletProvider;
     if (provider == null)
     {
         throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "IDynamicPropertyCmdletProvider_NotSupported", new object[0]);
     }
     provider.CopyProperty(sourcePath, sourceProperty, destinationPath, destinationProperty);
 }

 internal object ClearPropertyDynamicParameters(string path, Collection<string> providerSpecificPickList, CmdletProviderContext cmdletProviderContext)
 {
     this.Context = cmdletProviderContext;
     IPropertyCmdletProvider provider = this as IPropertyCmdletProvider;
     if (provider == null)
     {
         return null;
     }
     return provider.ClearPropertyDynamicParameters(path, providerSpecificPickList);
 }

 internal void ClearProperty(string path, Collection<string> propertyName, CmdletProviderContext cmdletProviderContext)
 {
     this.Context = cmdletProviderContext;
     IPropertyCmdletProvider provider = this as IPropertyCmdletProvider;
     if (provider == null)
     {
         throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "IPropertyCmdletProvider_NotSupported", new object[0]);
     }
     provider.ClearProperty(path, propertyName);
 }

 internal object ClearContentDynamicParameters(string path, CmdletProviderContext cmdletProviderContext)
 {
     this.Context = cmdletProviderContext;
     IContentCmdletProvider provider = this as IContentCmdletProvider;
     if (provider == null)
     {
         return null;
     }
     return provider.ClearContentDynamicParameters(path);
 }

 internal void ClearContent(string path, CmdletProviderContext cmdletProviderContext)
 {
     this.Context = cmdletProviderContext;
     IContentCmdletProvider provider = this as IContentCmdletProvider;
     if (provider == null)
     {
         throw PSTraceSource.NewNotSupportedException("SessionStateStrings", "IContentCmdletProvider_NotSupported", new object[0]);
     }
     provider.ClearContent(path);
 }

		internal override object GetDynamicParameters(CmdletProviderContext context)
		{
			if (!(this.Path != null & (int)this.Path.Length > 0))
			{
				return base.InvokeProvider.Property.CopyPropertyDynamicParameters(".", this.property, this.Destination, this.property, context);
			}
			else
			{
				return base.InvokeProvider.Property.CopyPropertyDynamicParameters(this.Path[0], this.property, this.Destination, this.property, context);
			}
		}

		internal override object GetDynamicParameters(CmdletProviderContext context)
		{
			if (this.Path == null)
			{
				return base.InvokeProvider.Property.RenamePropertyDynamicParameters(".", this.Name, this.NewName, context);
			}
			else
			{
				return base.InvokeProvider.Property.RenamePropertyDynamicParameters(this.Path, this.Name, this.NewName, context);
			}
		}

		internal override object GetDynamicParameters(CmdletProviderContext context)
		{
			if (this.Path == null || (int)this.Path.Length <= 0)
			{
				return base.InvokeProvider.Property.GetPropertyDynamicParameters(".", SessionStateUtilities.ConvertArrayToCollection<string>(this.property), context);
			}
			else
			{
				return base.InvokeProvider.Property.GetPropertyDynamicParameters(this.Path[0], SessionStateUtilities.ConvertArrayToCollection<string>(this.property), context);
			}
		}

		internal override object GetDynamicParameters(CmdletProviderContext context)
		{
			if (base.Path == null || (int)base.Path.Length <= 0)
			{
				return base.InvokeProvider.Content.GetContentReaderDynamicParameters(".", context);
			}
			else
			{
				return base.InvokeProvider.Content.GetContentReaderDynamicParameters(base.Path[0], context);
			}
		}

		internal override object GetDynamicParameters(CmdletProviderContext context)
		{
			Collection<string> strs = new Collection<string>();
			strs.Add(this.property);
			if (this.Path == null || (int)this.Path.Length <= 0)
			{
				return base.InvokeProvider.Property.ClearPropertyDynamicParameters(".", strs, context);
			}
			else
			{
				return base.InvokeProvider.Property.ClearPropertyDynamicParameters(this.Path[0], strs, context);
			}
		}

		private string[] GetAcceptedPaths(string[] unfilteredPaths, CmdletProviderContext currentContext)
		{
			Collection<PathInfo> pathInfos = base.ResolvePaths(unfilteredPaths, true, false, currentContext);
			ArrayList arrayLists = new ArrayList();
			foreach (PathInfo pathInfo in pathInfos)
			{
				if (!this.CallShouldProcess(pathInfo.Path))
				{
					continue;
				}
				arrayLists.Add(pathInfo.Path);
			}
			return (string[])arrayLists.ToArray(typeof(string));
		}

        /// <summary>
        /// Gets the path to the parent object for the given object
        /// </summary>
        /// 
        /// <param name="path">
        /// The path to the object to get the parent path from
        /// </param>
        /// 
        /// <param name="root">
        /// The root of the drive.
        /// </param>
        /// 
        /// <returns>
        /// The path to the parent object
        /// </returns>
        /// 
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="path"/> is null.
        /// </exception>
        /// 
        /// <exception cref="NotSupportedException">
        /// If the <paramref name="providerInstance"/> does not support this operation.
        /// </exception>
        /// 
        /// <exception cref="PipelineStoppedException">
        /// If the pipeline is being stopped while executing the command.
        /// </exception>
        /// 
        /// <exception cref="ProviderInvocationException">
        /// If the provider threw an exception.
        /// </exception>
        /// 
        internal string GetParentPath(string path, string root)
        {
            if (path == null)
            {
                throw PSTraceSource.NewArgumentNullException("path");
            }

            CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);

            string result = GetParentPath(path, root, context);

            context.ThrowFirstErrorOrDoNothing();

            return result;
        } //GetParentPath