public Context(CmdletProvider provider, string path, PSDriveInfo drive, IPathNodeProcessor pathProcessor, object dynamicParameters, Version topology, bool recurse)
 {
     _pathProcessor = pathProcessor;
     DynamicParameters = dynamicParameters;
     _provider = provider;
     _path = path;
     _drive = drive;
     _recurse = recurse;
     PathTopologyVersion = topology;
 }

 public ProviderContext(CmdletProvider provider, string path, PSDriveInfo drive, IPathResolver pathProcessor, object dynamicParameters, Version topology, bool recurse)
 {
     this.pathProcessor = pathProcessor;
     DynamicParameters = dynamicParameters;
     this.provider = provider;
     this.path = path;
     this.drive = drive;
     this.recurse = recurse;
     PathTopologyVersion = topology;
 }

        protected ItemContentReaderWriterBase(CmdletProvider provider, Item item,
            FileSystemCmdletProviderEncoding encoding, bool raw)
        {
            Item = item;
            Provider = provider;
            Raw = raw;

            if (encoding == FileSystemCmdletProviderEncoding.Unknown)
            {
                encoding = FileSystemCmdletProviderEncoding.Byte;
            }
            Encoding = new FileSystemContentWriterDynamicParameters() {Encoding = encoding}.EncodingType;
        }

 public ItemContentWriter(CmdletProvider provider, Item item, string path,  FileSystemCmdletProviderEncoding encoding, string extension, bool raw, bool fileBased, bool versioned, string language)
     : base(provider, item, encoding, raw)
 {
     if (Encoding != null && !Raw)
     {
         encoder = Encoding.GetEncoder();
     }
     if (!string.IsNullOrEmpty(extension))
     {
         this.extension = extension.StartsWith(".") ? extension : "." + extension;
     }
     this.fileBased = fileBased;
     this.path = path;
     this.versioned = versioned;
     this.language = language ?? Item?.Language?.Name;
     database = Item?.Database?.Name ?? PathUtilities.GetDrive(path, "master");
 }

        internal Collection<string> GetGlobbedProviderPaths(string path, ProviderRuntime runtime, bool itemMustExist,
                                                            out CmdletProvider provider)
        {
            var results = new Collection<string>();
            ProviderInfo providerInfo;

            // get internal path, resolve home path and set provider info and drive info (if resolved)
            path = GetProviderSpecificPath(path, runtime, out providerInfo);
            provider = _sessionState.Provider.GetInstance(providerInfo);

            if (!ShouldGlob(path, runtime))
            {
                // Although even ItemCmdletProvider supports ItemExists, PS doesn't seem
                // to throw errors when resolving paths with ItemProviders, only for ContainerProviders or higher
                // this behavior can be seen in the tests
                var containerProvider = provider as ContainerCmdletProvider;
                if (itemMustExist && containerProvider != null && !containerProvider.ItemExists(path, runtime))
                {
                    var msg = String.Format("An item with path {0} doesn't exist", path);
                    runtime.WriteError(new ItemNotFoundException(msg).ErrorRecord);
                    return results;
                }
                results.Add(path);
                return results;
            }

            if (providerInfo.Capabilities.HasFlag(ProviderCapabilities.ExpandWildcards))
            {
                var filter = new IncludeExcludeFilter(runtime.Include, runtime.Exclude, runtime.IgnoreFiltersForGlobbing);
                foreach (var expanded in CmdletProvider.As<ItemCmdletProvider>(provider).ExpandPath(path, runtime))
                {
                    if (filter.Accepts(expanded))
                    {
                        results.Add(expanded);
                    }
                }
            }
            else
            {
                results = BuiltInGlobbing(provider, path, runtime);
            }

            return results;
        }

        /// <summary>
        /// Gets an instance of an ISecurityDescriptorCmdletProvider given the provider ID.
        /// </summary>
        /// 
        /// <param name="providerInstance">
        /// An instance of a CmdletProvider.
        /// </param>
        /// 
        /// <returns>
        /// An instance of a ISecurityDescriptorCmdletProvider for the specified provider ID.
        /// </returns>
        /// 
        /// <throws>
        /// ArgumentNullException if providerId is null.
        /// NotSupportedException if the providerId is not for a provider
        /// that is derived from ISecurityDescriptorCmdletProvider.
        /// </throws>
        /// 
        internal static ISecurityDescriptorCmdletProvider GetPermissionProviderInstance(CmdletProvider providerInstance)
        {
            if (providerInstance == null)
            {
                throw PSTraceSource.NewArgumentNullException("providerInstance");
            }

            ISecurityDescriptorCmdletProvider permissionCmdletProvider =
                providerInstance as ISecurityDescriptorCmdletProvider;

            if (permissionCmdletProvider == null)
            {
                throw
                    PSTraceSource.NewNotSupportedException(
                        ProviderBaseSecurity.ISecurityDescriptorCmdletProvider_NotSupported);
            }

            return permissionCmdletProvider;
        } // GetPermissionProviderInstance

 public FileSystemContentReaderWriter(string path, string streamName, FileMode mode, FileAccess access, FileShare share, Encoding encoding, bool usingByteEncoding, bool waitForChanges, CmdletProvider provider, bool isRawStream)
 {
     this.delimiter = "\n";
     if (string.IsNullOrEmpty(path))
     {
         throw PSTraceSource.NewArgumentNullException("path");
     }
     tracer.WriteLine("path = {0}", new object[] { path });
     tracer.WriteLine("mode = {0}", new object[] { mode });
     tracer.WriteLine("access = {0}", new object[] { access });
     this.path = path;
     this.streamName = streamName;
     this.mode = mode;
     this.access = access;
     this.share = share;
     this.encoding = encoding;
     this.usingByteEncoding = usingByteEncoding;
     this.waitForChanges = waitForChanges;
     this.provider = provider;
     this.isRawStream = isRawStream;
     this.CreateStreams(path, streamName, mode, access, share, encoding);
 }

        private bool IsItemContainer(CmdletProvider provider, string path, ProviderRuntime providerRuntime)
        {
            NavigationCmdletProvider navigationProvider = provider as NavigationCmdletProvider;

            if (navigationProvider == null)
                return false;

            return navigationProvider.IsItemContainer(path, providerRuntime);
        }

 internal Collection<string> GetGlobbedProviderPathsFromMonadPath(string path, bool allowNonexistingPaths, out ProviderInfo provider, out CmdletProvider providerInstance)
 {
     providerInstance = null;
     if (path == null)
     {
         throw PSTraceSource.NewArgumentNullException("path");
     }
     CmdletProviderContext context = new CmdletProviderContext(this.sessionState.Internal.ExecutionContext);
     return this.GetGlobbedProviderPathsFromMonadPath(path, allowNonexistingPaths, context, out provider, out providerInstance);
 }

 internal Collection<PathInfo> GetGlobbedMonadPathsFromMonadPath(string path, bool allowNonexistingPaths, out CmdletProvider providerInstance)
 {
     CmdletProviderContext context = new CmdletProviderContext(this.sessionState.Internal.ExecutionContext);
     return this.GetGlobbedMonadPathsFromMonadPath(path, allowNonexistingPaths, context, out providerInstance);
 }

        /// <summary>
        /// Constructor for the content stream
        /// </summary>
        /// 
        /// <param name="path">
        /// The path to the file to get the content from.
        /// </param>
        /// 
        /// <param name="streamName">
        /// The name of the Alternate Data Stream to get the content from. If null or empty, returns
        /// the file's primary content.
        /// </param>
        /// 
        /// <param name="mode">
        /// The file mode to open the file with.
        /// </param>
        /// 
        /// <param name="access">
        /// The file access requested in the file.
        /// </param>
        /// 
        /// <param name="share">
        /// The file share to open the file with
        /// </param>
        ///
        /// <param name="encoding">
        /// The encoding of the file to be read or written.
        /// </param>
        /// 
        /// <param name="usingByteEncoding">
        /// If true, bytes will be read from the file. If false, the specified encoding
        /// will be used to read the file.
        /// </param>
        /// 
        /// <param name="waitForChanges">
        /// If true, we will perform blocking reads on the file, waiting for new content to be appended
        /// </param>
        /// 
        /// <param name="provider">
        /// The CmdletProvider invoking this stream
        /// </param>
        /// 
        /// <param name="isRawStream">
        /// Indicates raw stream.
        /// </param>
        /// 
        public FileSystemContentReaderWriter(
            string path, string streamName, FileMode mode, FileAccess access, FileShare share,
            Encoding encoding, bool usingByteEncoding, bool waitForChanges, CmdletProvider provider,
            bool isRawStream)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw PSTraceSource.NewArgumentNullException("path");
            }

            if (s_tracer.IsEnabled)
            {
                s_tracer.WriteLine("path = {0}", path);
                s_tracer.WriteLine("mode = {0}", mode);
                s_tracer.WriteLine("access = {0}", access);
            }

            _path = path;
            _streamName = streamName;
            _mode = mode;
            _access = access;
            _share = share;
            _encoding = encoding;
            _usingByteEncoding = usingByteEncoding;
            _waitForChanges = waitForChanges;
            _provider = provider;
            _isRawStream = isRawStream;

            CreateStreams(path, streamName, mode, access, share, encoding);
        }

        internal string GenerateRelativePath(PSDriveInfo drive, string path, bool escapeCurrentLocation, CmdletProvider providerInstance, CmdletProviderContext context)
        {
            if (path == null)
            {
                throw PSTraceSource.NewArgumentNullException("path");
            }
            if (drive == null)
            {
                throw PSTraceSource.NewArgumentNullException("drive");
            }
            string currentLocation = drive.CurrentLocation;
			bool flag1 = OSHelper.IsUnix && drive.Root.StartsWith ("/");
			if (!flag1 && !string.IsNullOrEmpty(currentLocation) && currentLocation.StartsWith(drive.Root, StringComparison.Ordinal))
            {
                currentLocation = currentLocation.Substring(drive.Root.Length);
            }
            if (escapeCurrentLocation)
            {
                currentLocation = WildcardPattern.Escape(currentLocation);
            }
            if (!string.IsNullOrEmpty(path))
            {
				var flag6 = OSHelper.IsUnix;
				var flag7 = flag6;
				if (!flag6) flag6 = (path[0] != '/');
                if ((path[0] != '\\') && flag6)
                {
                Label_024B:
                    if ((path.Length > 0) && this.HasRelativePathTokens(path))
                    {
                        if (context.Stopping)
                        {
                            throw new PipelineStoppedException();
                        }
                        bool flag = false;
                        bool flag2 = path.StartsWith("..", StringComparison.Ordinal);
                        bool flag3 = path.Length == 2;
                        bool flag4 = (path.Length > 2) && ((path[2] == '\\') || (path[2] == '/'));
						if (flag7) flag4 = flag7;
                        if (flag2 && (flag3 || flag4))
                        {
                            if (!string.IsNullOrEmpty(currentLocation))
                            {
                                currentLocation = this.sessionState.Internal.GetParentPath(providerInstance, currentLocation, drive.Root, context);
                            }
                            tracer.WriteLine("Parent path = {0}", new object[] { currentLocation });
                            path = path.Substring(2);
                            tracer.WriteLine("path = {0}", new object[] { path });
                            flag = true;
                            if (path.Length != 0)
                            {
								if (!flag7) {
	                                if ((path[0] == '\\') || (path[0] == '/'))
	                                {
	                                    path = path.Substring(1);
	                                }
								}
                                tracer.WriteLine("path = {0}", new object[] { path });
                                if (path.Length != 0)
                                {
                                    goto Label_024B;
                                }
                            }
                            goto Label_0260;
                        }
                        if (path.Equals(".", StringComparison.OrdinalIgnoreCase))
                        {
                            flag = true;
                            path = string.Empty;
                            goto Label_0260;
                        }
                        if (path.StartsWith(@".\", StringComparison.Ordinal) || path.StartsWith("./", StringComparison.Ordinal))
                        {
                            path = path.Substring(@".\".Length);
                            flag = true;
                            tracer.WriteLine("path = {0}", new object[] { path });
                            if (path.Length == 0)
                            {
                                goto Label_0260;
                            }
                        }
                        if ((path.Length == 0) || !flag)
                        {
                            goto Label_0260;
                        }
                        goto Label_024B;
                    }
                }
                else
                {
                    currentLocation = string.Empty;
                    path = path.Substring(1);
                    tracer.WriteLine("path = {0}", new object[] { path });
                }
            }
        Label_0260:
            if (!string.IsNullOrEmpty(path))
            {
                currentLocation = this.sessionState.Internal.MakePath(providerInstance, currentLocation, path, context);
            }
//.........这里部分代码省略.........

        internal string GetDriveRootRelativePathFromPSPath (string path, CmdletProviderContext context, bool escapeCurrentLocation, out PSDriveInfo workingDriveForPath, out CmdletProvider providerInstance)
		{
			if (path == null) {
				throw PSTraceSource.NewArgumentNullException ("path");
			}
			if (OSHelper.IsUnix) {
				int index = path.IndexOf ("::");
				if (index != -1)
				{
					path = path.Substring (index + 2);
				}
			}
            workingDriveForPath = null;
            string driveName = null;
            if (this.sessionState.Drive.Current != null)
            {
                driveName = this.sessionState.Drive.Current.Name;
            }
            bool flag = false;
            if (this.IsAbsolutePath(path, out driveName))
            {
                tracer.WriteLine("Drive Name: {0}", new object[] { driveName });
                try
                {
                    workingDriveForPath = this.sessionState.Drive.Get(driveName);
                }
                catch (DriveNotFoundException)
                {
                    if (this.sessionState.Drive.Current == null)
                    {
                        throw;
                    }
					if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix)
					{
						flag = path.StartsWith ("/", StringComparison.OrdinalIgnoreCase);
						workingDriveForPath = this.sessionState.Drive.Current;
					}
					else
					{
						string str2 = OSHelper.IsUnix ? this.sessionState.Drive.Current.Root : this.sessionState.Drive.Current.Root.Replace('/', '\\');
						string tempPath = OSHelper.IsUnix ? path : path.Replace('/', '\\');
	                    if ((str2.IndexOf(":", StringComparison.CurrentCulture) >= 0) && tempPath.StartsWith(str2, StringComparison.OrdinalIgnoreCase))
	                    {
	                        flag = true;
							if (!OSHelper.IsUnix) {
		                        path = path.Substring(str2.Length);
		                        path = path.TrimStart(new char[] { '\\' });
		                        path = '\\' + path;
							}
	                        workingDriveForPath = this.sessionState.Drive.Current;
	                    }
	                    if (!flag)
	                    {
	                        throw;
	                    }
					}
                }
				if (!flag) /* && !OSHelper.IsUnix */
                {
                    path = path.Substring(driveName.Length + 1);
                }
            }
            else
            {
                workingDriveForPath = this.sessionState.Drive.Current;
            }
            if (workingDriveForPath == null)
            {
                ItemNotFoundException exception = new ItemNotFoundException(path, "PathNotFound", SessionStateStrings.PathNotFound);
                pathResolutionTracer.TraceError("Item does not exist: {0}", new object[] { path });
                throw exception;
            }
            try
            {
                providerInstance = this.sessionState.Internal.GetContainerProviderInstance(workingDriveForPath.Provider);
                context.Drive = workingDriveForPath;
                return this.GenerateRelativePath(workingDriveForPath, path, escapeCurrentLocation, providerInstance, context);
            }
            catch (PSNotSupportedException)
            {
                providerInstance = null;
                return "";
            }
        }

 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;
 }

 private Collection<PathInfo> ResolveDriveQualifiedPath(string path, CmdletProviderContext context, bool allowNonexistingPaths, out CmdletProvider providerInstance)
 {
     providerInstance = null;
     PSDriveInfo workingDriveForPath = null;
     Collection<PathInfo> collection = new Collection<PathInfo>();
     pathResolutionTracer.WriteLine("Path is DRIVE-QUALIFIED", new object[0]);
     string str = this.GetDriveRootRelativePathFromPSPath(path, context, true, out workingDriveForPath, out providerInstance);
     pathResolutionTracer.WriteLine("DRIVE-RELATIVE path: {0}", new object[] { str });
     pathResolutionTracer.WriteLine("Drive: {0}", new object[] { workingDriveForPath.Name });
     pathResolutionTracer.WriteLine("Provider: {0}", new object[] { workingDriveForPath.Provider });
     context.Drive = workingDriveForPath;
     providerInstance = this.sessionState.Internal.GetContainerProviderInstance(workingDriveForPath.Provider);
     ContainerCmdletProvider provider = providerInstance as ContainerCmdletProvider;
     ItemCmdletProvider provider2 = providerInstance as ItemCmdletProvider;
     ProviderInfo providerInfo = providerInstance.ProviderInfo;
     string item = null;
     string providerPath = null;
     if (workingDriveForPath.Hidden)
     {
         item = GetProviderQualifiedPath(str, providerInfo);
         providerPath = str;
     }
     else
     {
         item = GetDriveQualifiedPath(str, workingDriveForPath);
         providerPath = this.GetProviderPath(path, context);
     }
     pathResolutionTracer.WriteLine("PROVIDER path: {0}", new object[] { providerPath });
     Collection<string> collection2 = new Collection<string>();
     if (!context.SuppressWildcardExpansion)
     {
         if (CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.ExpandWildcards, providerInfo))
         {
             pathResolutionTracer.WriteLine("Wildcard matching is being performed by the provider.", new object[0]);
             if ((provider2 != null) && WildcardPattern.ContainsWildcardCharacters(str))
             {
                 foreach (string str4 in provider2.ExpandPath(providerPath, context))
                 {
                     collection2.Add(this.GetDriveRootRelativePathFromProviderPath(str4, workingDriveForPath, context));
                 }
             }
             else
             {
                 collection2.Add(this.GetDriveRootRelativePathFromProviderPath(providerPath, workingDriveForPath, context));
             }
         }
         else
         {
             pathResolutionTracer.WriteLine("Wildcard matching is being performed by the engine.", new object[0]);
             collection2 = this.ExpandMshGlobPath(str, allowNonexistingPaths, workingDriveForPath, provider, context);
         }
     }
     else if (provider2 != null)
     {
         if (allowNonexistingPaths || provider2.ItemExists(providerPath, context))
         {
             collection2.Add(item);
         }
     }
     else
     {
         collection2.Add(item);
     }
     if ((((!allowNonexistingPaths && (collection2.Count < 1)) && !WildcardPattern.ContainsWildcardCharacters(path)) && ((context.Include == null) || (context.Include.Count == 0))) && ((context.Exclude == null) || (context.Exclude.Count == 0)))
     {
         ItemNotFoundException exception = new ItemNotFoundException(path, "PathNotFound", SessionStateStrings.PathNotFound);
         pathResolutionTracer.TraceError("Item does not exist: {0}", new object[] { path });
         throw exception;
     }
     foreach (string str5 in collection2)
     {
         if (context.Stopping)
         {
             throw new PipelineStoppedException();
         }
         item = null;
         if (workingDriveForPath.Hidden)
         {
             if (IsProviderDirectPath(str5))
             {
                 item = str5;
             }
             else
             {
                 item = GetProviderQualifiedPath(str5, providerInfo);
             }
         }
         else
         {
             item = GetDriveQualifiedPath(str5, workingDriveForPath);
         }
         collection.Add(new PathInfo(workingDriveForPath, providerInfo, item, this.sessionState));
         pathResolutionTracer.WriteLine("RESOLVED PATH: {0}", new object[] { item });
     }
     return collection;
 }

        private void InitializeProvider(CmdletProvider providerInstance, ProviderInfo provider)
        {
            List<PSDriveInfo> drives = new List<PSDriveInfo>();
            DriveCmdletProvider driveProvider = providerInstance as DriveCmdletProvider;

            if (driveProvider != null)
            {
                Collection<PSDriveInfo> collection = driveProvider.DoInitializeDefaultDrives();
                if ((collection != null) && (collection.Count > 0))
                {
                    drives.AddRange(collection);
                    _providersCurrentDrive[provider] = collection[0];
                }
            }

            if (drives.Count > 0)
            {
                foreach (PSDriveInfo driveInfo in drives)
                {
                    if (driveInfo != null)
                    {
                        // TODO: need to set driveInfo.Root

                        driveProvider.DoNewDrive(driveInfo);

                        try
                        {
                            _drives.Add(driveInfo.Name, driveInfo);
                        }
                        catch
                        {
                            // TODO: What should we do if the drive name is not unique?
                        }
                    }
                }
            }
        }

 private Collection<string> ResolveProviderPathFromProviderPath(string providerPath, string providerId, bool allowNonexistingPaths, CmdletProviderContext context, out CmdletProvider providerInstance)
 {
     providerInstance = this.sessionState.Internal.GetProviderInstance(providerId);
     ContainerCmdletProvider containerProvider = providerInstance as ContainerCmdletProvider;
     ItemCmdletProvider provider2 = providerInstance as ItemCmdletProvider;
     Collection<string> collection = new Collection<string>();
     if (!context.SuppressWildcardExpansion)
     {
         if (CmdletProviderManagementIntrinsics.CheckProviderCapabilities(ProviderCapabilities.ExpandWildcards, providerInstance.ProviderInfo))
         {
             pathResolutionTracer.WriteLine("Wildcard matching is being performed by the provider.", new object[0]);
             if ((provider2 != null) && WildcardPattern.ContainsWildcardCharacters(providerPath))
             {
                 collection = new Collection<string>(provider2.ExpandPath(providerPath, context));
             }
             else
             {
                 collection.Add(providerPath);
             }
         }
         else
         {
             pathResolutionTracer.WriteLine("Wildcard matching is being performed by the engine.", new object[0]);
             if (containerProvider != null)
             {
                 collection = this.GetGlobbedProviderPathsFromProviderPath(providerPath, allowNonexistingPaths, containerProvider, context);
             }
             else
             {
                 collection.Add(providerPath);
             }
         }
     }
     else if (provider2 != null)
     {
         if (allowNonexistingPaths || provider2.ItemExists(providerPath, context))
         {
             collection.Add(providerPath);
         }
     }
     else
     {
         collection.Add(providerPath);
     }
     if (((allowNonexistingPaths || (collection.Count >= 1)) || WildcardPattern.ContainsWildcardCharacters(providerPath)) || ((context.Include != null) && (context.Include.Count != 0)))
     {
         return collection;
     }
     if ((context.Exclude != null) && (context.Exclude.Count != 0))
     {
         return collection;
     }
     ItemNotFoundException exception = new ItemNotFoundException(providerPath, "PathNotFound", SessionStateStrings.PathNotFound);
     pathResolutionTracer.TraceError("Item does not exist: {0}", new object[] { providerPath });
     throw exception;
 }

        private bool ItemExists(CmdletProvider provider, string path, ProviderRuntime providerRuntime)
        {
            ItemCmdletProvider itemProvider = provider as ItemCmdletProvider;

            if (itemProvider == null)
                return false;

            return itemProvider.ItemExists(path, providerRuntime);
        }

 private Collection<PathInfo> ResolvePSPathFromProviderPath(string path, CmdletProviderContext context, bool allowNonexistingPaths, bool isProviderDirectPath, bool isProviderQualifiedPath, out CmdletProvider providerInstance)
 {
     Collection<PathInfo> collection = new Collection<PathInfo>();
     providerInstance = null;
     string providerId = null;
     PSDriveInfo drive = null;
     string providerPath = null;
     if (isProviderDirectPath)
     {
         pathResolutionTracer.WriteLine("Path is PROVIDER-DIRECT", new object[0]);
         providerPath = path;
         providerId = this.sessionState.Path.CurrentLocation.Provider.Name;
     }
     else if (isProviderQualifiedPath)
     {
         pathResolutionTracer.WriteLine("Path is PROVIDER-QUALIFIED", new object[0]);
         providerPath = ParseProviderPath(path, out providerId);
     }
     pathResolutionTracer.WriteLine("PROVIDER-INTERNAL path: {0}", new object[] { providerPath });
     pathResolutionTracer.WriteLine("Provider: {0}", new object[] { providerId });
     Collection<string> collection2 = this.ResolveProviderPathFromProviderPath(providerPath, providerId, allowNonexistingPaths, context, out providerInstance);
     drive = providerInstance.ProviderInfo.HiddenDrive;
     foreach (string str3 in collection2)
     {
         string str4 = str3;
         if (context.Stopping)
         {
             throw new PipelineStoppedException();
         }
         string str5 = null;
         if (IsProviderDirectPath(str4))
         {
             str5 = str4;
         }
         else
         {
             str5 = string.Format(CultureInfo.InvariantCulture, "{0}::{1}", new object[] { providerId, str4 });
         }
         collection.Add(new PathInfo(drive, providerInstance.ProviderInfo, str5, this.sessionState));
         pathResolutionTracer.WriteLine("RESOLVED PATH: {0}", new object[] { str5 });
     }
     return collection;
 }

        public Context( IContext context, object dynamicParameters )
        {
            Context c = context as Context;
            if( null == c )
            {
                throw new ArgumentException( "the context provided is of an incompatible type");
            }

            _provider = c._provider;
            PathProcessor = c.PathProcessor;
            DynamicParameters = dynamicParameters;
        }