C# CmdletProviderContext.HasErrors方法代码示例

 private Collection<PSObject> GetChildNamesInDir(string dir, string leafElement, bool getAllContainers, CmdletProviderContext context, bool dirIsProviderPath, PSDriveInfo drive, ContainerCmdletProvider provider, out string modifiedDirPath)
 {
     string updatedPath = null;
     string updatedFilter = null;
     Collection<PSObject> collection4;
     string filter = context.Filter;
     bool flag = provider.ConvertPath(leafElement, context.Filter, ref updatedPath, ref updatedFilter, context);
     if (flag)
     {
         tracer.WriteLine("Provider converted path and filter.", new object[0]);
         tracer.WriteLine("Original path: " + leafElement, new object[0]);
         tracer.WriteLine("Converted path: " + updatedPath, new object[0]);
         tracer.WriteLine("Original filter: " + context.Filter, new object[0]);
         tracer.WriteLine("Converted filter: " + updatedFilter, new object[0]);
         leafElement = updatedPath;
         context.Filter = updatedFilter;
     }
     ReturnContainers returnAllContainers = ReturnContainers.ReturnAllContainers;
     if (!getAllContainers)
     {
         returnAllContainers = ReturnContainers.ReturnMatchingContainers;
     }
     CmdletProviderContext context2 = new CmdletProviderContext(context);
     context2.SetFilters(new Collection<string>(), new Collection<string>(), context.Filter);
     try
     {
         string path = null;
         modifiedDirPath = null;
         if (dirIsProviderPath)
         {
             modifiedDirPath = path = context.SuppressWildcardExpansion ? dir : RemoveGlobEscaping(dir);
         }
         else
         {
             modifiedDirPath = GetMshQualifiedPath(dir, drive);
             ProviderInfo info = null;
             CmdletProvider providerInstance = null;
             Collection<string> collection = this.GetGlobbedProviderPathsFromMonadPath(modifiedDirPath, false, context2, out info, out providerInstance);
             modifiedDirPath = context.SuppressWildcardExpansion ? modifiedDirPath : RemoveGlobEscaping(modifiedDirPath);
             if (collection.Count > 0)
             {
                 path = collection[0];
             }
             else
             {
                 if (flag)
                 {
                     context.Filter = filter;
                 }
                 return new Collection<PSObject>();
             }
         }
         if (provider.HasChildItems(path, context2))
         {
             provider.GetChildNames(path, returnAllContainers, context2);
         }
         if (context2.HasErrors())
         {
             Collection<ErrorRecord> accumulatedErrorObjects = context2.GetAccumulatedErrorObjects();
             if ((accumulatedErrorObjects != null) && (accumulatedErrorObjects.Count > 0))
             {
                 foreach (ErrorRecord record in accumulatedErrorObjects)
                 {
                     context.WriteError(record);
                 }
             }
         }
         Collection<PSObject> accumulatedObjects = context2.GetAccumulatedObjects();
         if (flag)
         {
             context.Filter = filter;
         }
         collection4 = accumulatedObjects;
     }
     finally
     {
         context2.RemoveStopReferral();
     }
     return collection4;
 }

 internal Collection<string> GetGlobbedProviderPathsFromProviderPath(string path, bool allowNonexistingPaths, string providerId, out CmdletProvider providerInstance)
 {
     providerInstance = null;
     if (path == null)
     {
         throw PSTraceSource.NewArgumentNullException("path");
     }
     CmdletProviderContext context = new CmdletProviderContext(this.sessionState.Internal.ExecutionContext);
     Collection<string> collection = this.GetGlobbedProviderPathsFromProviderPath(path, allowNonexistingPaths, providerId, context, out providerInstance);
     if (context.HasErrors())
     {
         ErrorRecord record = context.GetAccumulatedErrorObjects()[0];
         if (record != null)
         {
             throw record.Exception;
         }
     }
     return collection;
 }

 internal string GetProviderPath(string path, out ProviderInfo provider)
 {
     if (path == null)
     {
         throw PSTraceSource.NewArgumentNullException("path");
     }
     CmdletProviderContext context = new CmdletProviderContext(this.sessionState.Internal.ExecutionContext);
     PSDriveInfo drive = null;
     provider = null;
     string str = this.GetProviderPath(path, context, out provider, out drive);
     if (context.HasErrors())
     {
         Collection<ErrorRecord> accumulatedErrorObjects = context.GetAccumulatedErrorObjects();
         if ((accumulatedErrorObjects != null) && (accumulatedErrorObjects.Count > 0))
         {
             throw accumulatedErrorObjects[0].Exception;
         }
     }
     return str;
 }

        } // GetProviderPath


        /// <summary>
        /// Gets a provider specific path when given an Msh path without resolving the
        /// glob characters.
        /// </summary>
        /// 
        /// <param name="path">
        /// An Msh path.
        /// </param>
        /// 
        /// <param name="provider">
        /// The information of the provider that was used to resolve the path.
        /// </param>
        /// 
        /// <returns>
        /// A provider specific path that the Msh path represents.
        /// </returns>
        /// 
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="path"/> is null.
        /// </exception>
        /// 
        /// <exception cref="ProviderNotFoundException">
        /// If the path is a provider-qualified path for a provider that is
        /// not loaded into the system.
        /// </exception>
        /// 
        /// <exception cref="DriveNotFoundException">
        /// If the <paramref name="path"/> refers to a drive that could not be found.
        /// </exception>
        /// 
        /// <exception cref="ProviderInvocationException">
        /// If the provider used to build the path threw an exception.
        /// </exception>
        /// 
        /// <exception cref="NotSupportedException">
        /// If the provider that the <paramref name="path"/> represents is not a NavigationCmdletProvider
        /// or ContainerCmdletProvider.
        /// </exception>
        /// 
        /// <exception cref="InvalidOperationException">
        /// If the <paramref name="path"/> starts with "~" and the home location is not set for 
        /// the provider.
        /// </exception>
        /// 
        /// <exception cref="ProviderInvocationException">
        /// If the provider specified by <paramref name="provider"/> threw an
        /// exception when its GetParentPath or MakePath was called while
        /// processing the <paramref name="path"/>.
        /// </exception>
        /// 
        /// <exception>
        /// Any exception can be thrown by the provider that is called to build
        /// the provider path.
        /// </exception>
        /// 
        internal string GetProviderPath(string path, out ProviderInfo provider)
        {
            if (path == null)
            {
                throw PSTraceSource.NewArgumentNullException("path");
            }

            CmdletProviderContext context =
                new CmdletProviderContext(_sessionState.Internal.ExecutionContext);

            PSDriveInfo drive = null;
            provider = null;

            string result = GetProviderPath(path, context, out provider, out drive);

            if (context.HasErrors())
            {
                Collection<ErrorRecord> errors = context.GetAccumulatedErrorObjects();

                if (errors != null &&
                    errors.Count > 0)
                {
                    throw errors[0].Exception;
                }
            }

            return result;
        } // GetProviderPath

//.........这里部分代码省略.........
            getChildNamesContext.SetFilters(
                new Collection<string>(),
                new Collection<string>(),
                context.Filter);

            try
            {
                // Use the provider to get the children
                string unescapedDir = null;
                modifiedDirPath = null;

                if (dirIsProviderPath)
                {
                    modifiedDirPath = unescapedDir = context.SuppressWildcardExpansion ? dir : RemoveGlobEscaping(dir);
                }
                else
                {
                    Dbg.Diagnostics.Assert(
                        drive != null,
                        "Caller should verify that drive is not null when dirIsProviderPath is false");

                    // If the directory is an MSH path we must resolve it before calling GetChildNames()
                    // -- If the path is passed in by LiteralPath (context.SuppressWildcardExpansion == false), we surely should use 'dir' unchanged.
                    // -- If the path is passed in by Path (context.SuppressWildcardExpansion == true), we still should use 'dir' unchanged, in case that the special character
                    //    in 'dir' is escaped
                    modifiedDirPath = GetMshQualifiedPath(dir, drive);

                    ProviderInfo providerIgnored = null;
                    CmdletProvider providerInstanceIgnored = null;
                    Collection<string> resolvedPaths =
                        GetGlobbedProviderPathsFromMonadPath(
                            modifiedDirPath,
                            false,
                            getChildNamesContext,
                            out providerIgnored,
                            out providerInstanceIgnored);

                    // After resolving the path, we unescape the modifiedDirPath if necessary.
                    modifiedDirPath = context.SuppressWildcardExpansion
                                          ? modifiedDirPath
                                          : RemoveGlobEscaping(modifiedDirPath);
                    if (resolvedPaths.Count > 0)
                    {
                        unescapedDir = resolvedPaths[0];
                    }
                    else
                    {
                        // If there were no results from globbing but no
                        // exception was thrown, that means there was filtering.
                        // So return an empty collection and let the caller deal
                        // with it.

                        if (changedPathOrFilter)
                        {
                            context.Filter = originalFilter;
                        }

                        return new Collection<PSObject>();
                    }
                }

                if (provider.HasChildItems(unescapedDir, getChildNamesContext))
                {
                    provider.GetChildNames(
                        unescapedDir,
                        returnContainers,
                        getChildNamesContext);
                }

                // First check to see if there were any errors, and write them
                // to the real context if there are.

                if (getChildNamesContext.HasErrors())
                {
                    Collection<ErrorRecord> errors = getChildNamesContext.GetAccumulatedErrorObjects();

                    if (errors != null &&
                        errors.Count > 0)
                    {
                        foreach (ErrorRecord errorRecord in errors)
                        {
                            context.WriteError(errorRecord);
                        }
                    }
                }

                Collection<PSObject> childNamesObjectArray = getChildNamesContext.GetAccumulatedObjects();

                if (changedPathOrFilter)
                {
                    context.Filter = originalFilter;
                }

                return childNamesObjectArray;
            }
            finally
            {
                getChildNamesContext.RemoveStopReferral();
            }
        } // GetChildNamesInDir

//.........这里部分代码省略.........
                            currentPath = NormalizeRelativePath(resolvedPath.Path, CurrentDrive.Root, normalizePathContext);
                        }
                        catch (NotSupportedException)
                        {
                            // Since the provider does not support normalizing the path, just
                            // use the path we currently have.
                        }
                        catch (LoopFlowException)
                        {
                            throw;
                        }
                        catch (PipelineStoppedException)
                        {
                            throw;
                        }
                        catch (ActionPreferenceStopException)
                        {
                            throw;
                        }
                        catch (Exception e) // Catch-all OK, 3rd party callout
                        {
                            CommandProcessorBase.CheckForSevereException(e);

                            // Reset the drive to the previous drive and
                            // then rethrow the error

                            CurrentDrive = previousWorkingDrive;
                            throw;
                        }
                    }

                    // Now see if there was errors while normalizing the path

                    if (normalizePathContext.HasErrors())
                    {
                        // Set the current working drive back to the previous
                        // one in case it was changed.

                        CurrentDrive = previousWorkingDrive;

                        normalizePathContext.ThrowFirstErrorOrDoNothing();
                    }
                }
                finally
                {
                    normalizePathContext.RemoveStopReferral();
                }

                // Check to see if the path is a container

                bool isContainer = false;

                CmdletProviderContext itemContainerContext =
                    new CmdletProviderContext(context);
                itemContainerContext.SuppressWildcardExpansion = true;

                try
                {
                    isContainer =
                        IsItemContainer(
                            resolvedPath.Path,
                            itemContainerContext);

                    if (itemContainerContext.HasErrors())
                    {
                        // Set the current working drive back to the previous

//.........这里部分代码省略.........
            {
                // The path needs to be normalized to get rid of relative path tokens
                // so they don't interfere with our path comparisons below

                CmdletProviderContext normalizePathContext
                    = new CmdletProviderContext(context);

                try
                {
                    providerSpecificPath = NormalizeRelativePath(path, null, normalizePathContext);
                }
                catch (NotSupportedException)
                {
                    // Since the provider does not support normalizing the path, just
                    // use the path we currently have.
                }
                catch (LoopFlowException)
                {
                    throw;
                }
                catch (PipelineStoppedException)
                {
                    throw;
                }
                catch (ActionPreferenceStopException)
                {
                    throw;
                }
                finally
                {
                    normalizePathContext.RemoveStopReferral();
                }

                if (normalizePathContext.HasErrors())
                {
                    normalizePathContext.ThrowFirstErrorOrDoNothing();
                }

                s_tracer.WriteLine("Provider path = {0}", providerSpecificPath);

                // Get the current working directory provider specific path

                PSDriveInfo currentWorkingDrive = null;
                ProviderInfo currentDriveProvider = null;

                string currentWorkingPath =
                    Globber.GetProviderPath(
                        ".",
                        context,
                        out currentDriveProvider,
                        out currentWorkingDrive);

                Dbg.Diagnostics.Assert(
                    currentWorkingDrive == CurrentDrive,
                    "The current working drive should be the CurrentDrive.");

                s_tracer.WriteLine(
                    "Current working path = {0}",
                    currentWorkingPath);

                // See if the path is the current working directory or a parent
                // of the current working directory

                s_tracer.WriteLine(
                    "Comparing {0} to {1}",
                    providerSpecificPath,

 internal void RemoveDrive(PSDriveInfo drive, bool force, string scopeID)
 {
     if (drive == null)
     {
         throw PSTraceSource.NewArgumentNullException("drive");
     }
     CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
     this.RemoveDrive(drive, force, scopeID, context);
     if (context.HasErrors() && !force)
     {
         context.ThrowFirstErrorOrDoNothing();
     }
 }

//.........这里部分代码省略.........
                        catch (Exception exception2)
                        {
                            CommandProcessorBase.CheckForSevereException(exception2);
                            this.CurrentDrive = currentDrive;
                            throw;
                        }
                    }
                    try
                    {
                    	str4 = this.NormalizeRelativePath(info4.Path, this.CurrentDrive.Root, context2);
                    }
                    catch (NotSupportedException)
                    {
                    }
                    catch (LoopFlowException)
                    {
                        throw;
                    }
                    catch (PipelineStoppedException)
                    {
                        throw;
                    }
                    catch (ActionPreferenceStopException)
                    {
                        throw;
                    }
                    catch (Exception exception3)
                    {
                        CommandProcessorBase.CheckForSevereException(exception3);
                        this.CurrentDrive = currentDrive;
                        throw;
                    }
                Label_01DF:
                    if (context2.HasErrors())
                    {
                        this.CurrentDrive = currentDrive;
                        context2.ThrowFirstErrorOrDoNothing();
                    }
                }
                finally
                {
                    context2.RemoveStopReferral();
                }
                bool flag5 = false;
                CmdletProviderContext context3 = new CmdletProviderContext(context) {
                    SuppressWildcardExpansion = true
                };
                try
                {
                    flag5 = this.IsItemContainer(info4.Path, context3);
                    if (context3.HasErrors())
                    {
                        this.CurrentDrive = currentDrive;
                        context3.ThrowFirstErrorOrDoNothing();
                    }
                }
                catch (NotSupportedException)
                {
                    if (str4.Length == 0)
                    {
                        flag5 = true;
                    }
                }
                finally
                {
                    context3.RemoveStopReferral();

 internal bool IsCurrentLocationOrAncestor(string path, CmdletProviderContext context)
 {
     bool flag = false;
     if (path == null)
     {
         throw PSTraceSource.NewArgumentNullException("path");
     }
     PSDriveInfo drive = null;
     ProviderInfo provider = null;
     string strA = this.Globber.GetProviderPath(path, context, out provider, out drive);
     if (drive != null)
     {
         tracer.WriteLine("Tracing drive", new object[0]);
         drive.Trace();
     }
     if (drive != null)
     {
         context.Drive = drive;
     }
     if (drive == this.CurrentDrive)
     {
         CmdletProviderContext context2 = new CmdletProviderContext(context);
         try
         {
             strA = this.NormalizeRelativePath(path, null, context2);
         }
         catch (NotSupportedException)
         {
         }
         catch (LoopFlowException)
         {
             throw;
         }
         catch (PipelineStoppedException)
         {
             throw;
         }
         catch (ActionPreferenceStopException)
         {
             throw;
         }
         finally
         {
             context2.RemoveStopReferral();
         }
         if (context2.HasErrors())
         {
             context2.ThrowFirstErrorOrDoNothing();
         }
         tracer.WriteLine("Provider path = {0}", new object[] { strA });
         PSDriveInfo info3 = null;
         ProviderInfo info4 = null;
         string strB = this.Globber.GetProviderPath(".", context, out info4, out info3);
         tracer.WriteLine("Current working path = {0}", new object[] { strB });
         tracer.WriteLine("Comparing {0} to {1}", new object[] { strA, strB });
         if (string.Compare(strA, strB, true, Thread.CurrentThread.CurrentCulture) == 0)
         {
             tracer.WriteLine("The path is the current working directory", new object[0]);
             flag = true;
         }
         else
         {
             string str3 = strB;
             while (str3.Length > 0)
             {
                 str3 = this.GetParentPath(drive.Provider, str3, string.Empty, context);
                 tracer.WriteLine("Comparing {0} to {1}", new object[] { str3, strA });
                 if (string.Compare(str3, strA, true, Thread.CurrentThread.CurrentCulture) == 0)
                 {
                     tracer.WriteLine("The path is a parent of the current working directory: {0}", new object[] { str3 });
                     flag = true;
                     break;
                 }
             }
         }
     }
     else
     {
         tracer.WriteLine("Drives are not the same", new object[0]);
     }
     tracer.WriteLine("result = {0}", new object[] { flag });
     return flag;
 }

 internal string NormalizeRelativePath(string path, string basePath, CmdletProviderContext context)
 {
     string str2;
     if (path == null)
     {
         throw PSTraceSource.NewArgumentNullException("path");
     }
     CmdletProviderContext context2 = new CmdletProviderContext(context);
     try
     {
         PSDriveInfo drive = null;
         ProviderInfo provider = null;
         string str = this.Globber.GetProviderPath(path, context2, out provider, out drive);
         if (context2.HasErrors())
         {
             context2.WriteErrorsToContext(context);
             return null;
         }
         if ((str == null) || (provider == null))
         {
             Exception exception = PSTraceSource.NewArgumentException("path");
             context.WriteError(new ErrorRecord(exception, "NormalizePathNullResult", ErrorCategory.InvalidArgument, path));
             return null;
         }
         if (drive != null)
         {
             context.Drive = drive;
             if (((this.GetProviderInstance(provider) is NavigationCmdletProvider) && !string.IsNullOrEmpty(drive.Root)) && path.StartsWith(drive.Root, StringComparison.OrdinalIgnoreCase))
             {
                 str = path;
             }
         }
         str2 = this.NormalizeRelativePath(provider, str, basePath, context);
     }
     finally
     {
         context2.RemoveStopReferral();
     }
     return str2;
 }

 internal string GetParentPath(string path, string root, CmdletProviderContext context, bool useDefaultProvider)
 {
     string str4;
     if (path == null)
     {
         throw PSTraceSource.NewArgumentNullException("path");
     }
     CmdletProviderContext context2 = new CmdletProviderContext(context);
     try
     {
         PSDriveInfo drive = null;
         ProviderInfo provider = null;
         try
         {
             this.Globber.GetProviderPath(path, context2, out provider, out drive);
         }
         catch (System.Management.Automation.DriveNotFoundException)
         {
             if (!useDefaultProvider)
             {
                 throw;
             }
             provider = this.PublicSessionState.Internal.GetSingleProvider("FileSystem");
         }
         if (context2.HasErrors())
         {
             context2.WriteErrorsToContext(context);
             return null;
         }
         if (drive != null)
         {
             context.Drive = drive;
         }
         bool isProviderQualified = false;
         bool isDriveQualified = false;
         string qualifier = null;
         string str2 = this.RemoveQualifier(path, out qualifier, out isProviderQualified, out isDriveQualified);
         string str3 = this.GetParentPath(provider, str2, root, context);
         if (!string.IsNullOrEmpty(qualifier) && !string.IsNullOrEmpty(str3))
         {
             str3 = this.AddQualifier(str3, qualifier, isProviderQualified, isDriveQualified);
         }
         tracer.WriteLine("result = {0}", new object[] { str3 });
         str4 = str3;
     }
     finally
     {
         context2.RemoveStopReferral();
     }
     return str4;
 }

        private PSDriveInfo AutomountFileSystemDrive(DriveInfo systemDriveInfo)
        {
            PSDriveInfo newDrive = null;
            if (!this.IsProviderLoaded(this.ExecutionContext.ProviderNames.FileSystem))
            {
                tracer.WriteLine("The {0} provider is not loaded", new object[] { this.ExecutionContext.ProviderNames.FileSystem });
                return newDrive;
            }
            try
            {
                DriveCmdletProvider driveProviderInstance = this.GetDriveProviderInstance(this.ExecutionContext.ProviderNames.FileSystem);
                if (driveProviderInstance == null)
                {
                    return newDrive;
                }
				string name = OSHelper.IsUnix ? systemDriveInfo.Name : systemDriveInfo.Name.Substring(0, 1);
                string description = string.Empty;
                try
                {
                    description = systemDriveInfo.VolumeLabel;
                }
                catch (UnauthorizedAccessException)
                {
                }
                PSDriveInfo drive = new PSDriveInfo(name, driveProviderInstance.ProviderInfo, systemDriveInfo.RootDirectory.FullName, description, null) {
                    IsAutoMounted = true
                };
                CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);
                drive.DriveBeingCreated = true;
                newDrive = this.ValidateDriveWithProvider(driveProviderInstance, drive, context, false);
                drive.DriveBeingCreated = false;
                if ((newDrive != null) && !context.HasErrors())
                {
                    this._globalScope.NewDrive(newDrive);
                }
            }
            catch (LoopFlowException)
            {
                throw;
            }
            catch (PipelineStoppedException)
            {
                throw;
            }
            catch (ActionPreferenceStopException)
            {
                throw;
            }
            catch (Exception exception)
            {
                CommandProcessorBase.CheckForSevereException(exception);
                MshLog.LogProviderHealthEvent(this.ExecutionContext, this.ExecutionContext.ProviderNames.FileSystem, exception, Severity.Warning);
            }
            return newDrive;
        }

        } // AutomountFileSystemDrive

        private PSDriveInfo AutomountFileSystemDrive(System.IO.DriveInfo systemDriveInfo)
        {
            PSDriveInfo result = null;

            if (!IsProviderLoaded(this.ExecutionContext.ProviderNames.FileSystem))
            {
                s_tracer.WriteLine("The {0} provider is not loaded", this.ExecutionContext.ProviderNames.FileSystem);
                return null;
            }

            // Since the drive does exist, add it.

            try
            {
                // Get the FS provider

                DriveCmdletProvider driveProvider =
                    GetDriveProviderInstance(this.ExecutionContext.ProviderNames.FileSystem);

                if (driveProvider != null)
                {
                    // Create a new drive
                    string systemDriveName = systemDriveInfo.Name.Substring(0, 1);
                    string volumeLabel = String.Empty;
                    string displayRoot = null;

                    try
                    {
                        // When run in an AppContainer, we may not have access to the volume label.
                        volumeLabel = systemDriveInfo.VolumeLabel;
                    }
                    catch (UnauthorizedAccessException) { }

                    // Get the actual root path for Network type drives
                    if (systemDriveInfo.DriveType == DriveType.Network)
                    {
                        try
                        {
                            displayRoot = Microsoft.PowerShell.Commands.FileSystemProvider
                                            .GetRootPathForNetworkDriveOrDosDevice(systemDriveInfo);
                        }
                        // We want to get root path of the network drive as extra information to display to the user.
                        // It's okay we failed to get the root path for some reason. We don't want to throw exception
                        // here as it would break the current behavior.
                        catch (Win32Exception) { }
                        catch (InvalidOperationException) { }
                    }

                    PSDriveInfo newPSDriveInfo =
                        new PSDriveInfo(
                            systemDriveName,
                            driveProvider.ProviderInfo,
                            systemDriveInfo.RootDirectory.FullName,
                            volumeLabel,
                            null,
                            displayRoot);

                    newPSDriveInfo.IsAutoMounted = true;

                    CmdletProviderContext context = new CmdletProviderContext(this.ExecutionContext);

                    newPSDriveInfo.DriveBeingCreated = true;

                    // Validate the drive with the provider
                    result = ValidateDriveWithProvider(driveProvider, newPSDriveInfo, context, false);

                    newPSDriveInfo.DriveBeingCreated = false;

                    if (result != null && !context.HasErrors())
                    {
                        // Create the drive in the global scope.
                        GlobalScope.NewDrive(result);
                    }
                }
            }
            catch (LoopFlowException)
            {
                throw;
            }
            catch (PipelineStoppedException)
            {
                throw;
            }
            catch (ActionPreferenceStopException)
            {
                throw;
            }
            catch (Exception e)
            {
                CommandProcessorBase.CheckForSevereException(e);
                // Since the user isn't expecting this behavior, we don't
                // want to let errors find their way out. If there are any
                // failures we just don't mount the drive.


                MshLog.LogProviderHealthEvent(
                    this.ExecutionContext,
                    this.ExecutionContext.ProviderNames.FileSystem,
//.........这里部分代码省略.........

        } //NormalizeRelativePath

        /// <summary>
        /// Normalizes the path that was passed in and returns the normalized path
        /// as a relative path to the basePath that was passed.
        /// </summary>
        /// 
        /// <param name="path">
        /// An MSH path to an item. The item should exist
        /// or the provider should write out an error.
        /// </param>
        /// 
        /// <param name="basePath">
        /// The path that the return value should be relative to.
        /// </param>
        /// 
        /// <param name="context">
        /// The context under which the command is running.
        /// </param>
        /// 
        /// <returns>
        /// A normalized path that is relative to the basePath that was passed. 
        /// </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 NormalizeRelativePath(
            string path,
            string basePath,
            CmdletProviderContext context)
        {
            if (path == null)
            {
                throw PSTraceSource.NewArgumentNullException("path");
            }

            CmdletProviderContext getProviderPathContext =
                new CmdletProviderContext(context);

            try
            {
                PSDriveInfo drive = null;
                ProviderInfo provider = null;

                string workingPath = Globber.GetProviderPath(
                     path,
                     getProviderPathContext,
                     out provider,
                     out drive);

                if (getProviderPathContext.HasErrors())
                {
                    getProviderPathContext.WriteErrorsToContext(context);
                    return null;
                }

                if (workingPath == null ||
                    provider == null)
                {
                    // Since the provider didn't write an error, and we didn't get any
                    // results ourselves, we need to write out our own error.

                    Exception e = PSTraceSource.NewArgumentException("path");
                    context.WriteError(new ErrorRecord(e, "NormalizePathNullResult", ErrorCategory.InvalidArgument, path));
                    return null;
                }

                if (basePath != null)
                {
                    PSDriveInfo baseDrive = null;
                    ProviderInfo baseProvider = null;

                    Globber.GetProviderPath(
                         basePath,
                         getProviderPathContext,
                         out baseProvider,
                         out baseDrive);

                    if (drive != null && baseDrive != null)
                    {
                        if (!drive.Name.Equals(baseDrive.Name, StringComparison.OrdinalIgnoreCase))
                        {
                            // Make sure they are from physically different drives
                            // Doing StartsWith from both directions covers the following cases
                            // C:\ and C:\Temp
                            // C:\Temp and C:\
//.........这里部分代码省略.........