C# IFileService.GetFullPath方法代码示例

        /// <summary>
        /// Get the canonical volume root (e.g. the \\?\VolumeGuid format) for the given path. The path must not be relative.
        /// </summary>
        /// <exception cref="ArgumentException">Thrown if the path is relative or indeterminate.</exception>
        /// <exception cref="System.IO.IOException">Thrown if unable to get the root from the OS.</exception>
        public static string GetCanonicalRoot(this IExtendedFileService extendedFileService, IFileService fileService, string path)
        {
            if (Paths.IsRelative(path)) throw new ArgumentException();

            path = fileService.GetFullPath(path);
            int rootLength;
            var format = Paths.GetPathFormat(path, out rootLength);
            if (format == PathFormat.UnknownFormat) throw new ArgumentException();

            string root = path.Substring(0, rootLength);
            string simpleRoot = root;
            string canonicalRoot = root;

            switch (format)
            {
                case PathFormat.UniformNamingConventionExtended:
                    simpleRoot = @"\\" + root.Substring(Paths.ExtendedUncPrefix.Length);
                    goto case PathFormat.UniformNamingConvention;
                case PathFormat.UniformNamingConvention:
                    canonicalRoot = simpleRoot;
                    break;
                case PathFormat.VolumeAbsoluteExtended:
                case PathFormat.DriveAbsolute:
                    canonicalRoot = extendedFileService.GetVolumeName(root);
                    simpleRoot = extendedFileService.GetMountPoint(root);
                    break;
            }

            return canonicalRoot;
        }

        private static string[] SplitFiles(IFileService fileService, params string[] fileLists)
        {
            if (fileLists == null || fileLists.Length == 0 || fileLists[0] == null) return new string[0];

            List<string> files = new List<string>();
            foreach (string fileList in fileLists)
                foreach (string file in fileList.Split(';'))
                    files.Add(fileService.GetFullPath(file));
            return files.ToArray();
        }

        private static string[] SplitAndValidateDirectories(IFileService fileService, params string[] directoryLists)
        {
            if (directoryLists == null || directoryLists.Length == 0 || directoryLists[0] == null) return new string[0];

            List<string> directories = new List<string>();
            foreach (string directoryList in directoryLists)
                foreach (string directory in directoryList.Split(';'))
                {
                    string normalizedPath = fileService.GetFullPath(directory);
                    if (!fileService.DirectoryExists(normalizedPath))
                        throw new TaskArgumentException(XTaskStrings.ErrorDirectoryNotFound, directory);
                    directories.Add(normalizedPath);
                }
            return directories.ToArray();
        }

        /// <summary>
        /// Get the canonical volume root (e.g. the \\?\VolumeGuid format) for the given path. The path must not be relative.
        /// </summary>
        /// <exception cref="ArgumentException">Thrown if the path is relative or indeterminate.</exception>
        /// <exception cref="System.IO.IOException">Thrown if unable to get the root from the OS.</exception>
        public static string GetCanonicalRoot(this IExtendedFileService extendedFileService, IFileService fileService, string path)
        {
            if (Paths.IsPartiallyQualified(path)) throw new ArgumentException(nameof(path));

            path = fileService.GetFullPath(path);
            int rootLength;
            var format = Paths.GetPathFormat(path, out rootLength);
            if (format == PathFormat.UnknownFormat) throw new ArgumentException(nameof(format));

            string root = path.Substring(0, rootLength);
            string canonicalRoot = root;

            switch (format)
            {
                case PathFormat.UniformNamingConvention:
                    if (Paths.IsDevice(path)) canonicalRoot = @"\\" + root.Substring(Paths.ExtendedUncPrefix.Length);
                    break;
                case PathFormat.LocalFullyQualified:
                    canonicalRoot = extendedFileService.GetVolumeName(root);
                    break;
            }

            return canonicalRoot;
        }

        internal static IFileSystemInformation Create(string path, IFileService fileService)
        {
            path = fileService.GetFullPath(path);

            try
            {
                var findResult = NativeMethods.FileManagement.FindFirstFile(path, directoriesOnly: false, getAlternateName: false, returnNullIfNotFound: false);
                var info = Create(findResult, fileService);
                findResult.FindHandle.Close();
                return info;
            }
            catch (System.IO.IOException)
            {
                // Could be a root directory (e.g. C:), can't do FindFile
                if (Paths.IsPathRelative(path))
                {
                    throw;
                }

                System.IO.FileAttributes attributes = NativeMethods.FileManagement.GetFileAttributes(path);
                return Create(path, attributes, fileService);
            }
        }