NormalizeLongPath() public static method

public static NormalizeLongPath ( string path ) : string
path string
return string
Beispiel #1
0
        /// <summary>
        ///     Copies the specified file to a specified new file, indicating whether to overwrite an existing file.
        /// </summary>
        /// <param name = "sourcePath">
        ///     A <see cref = "String" /> containing the path of the file to copy.
        /// </param>
        /// <param name = "destinationPath">
        ///     A <see cref = "String" /> containing the new path of the file.
        /// </param>
        /// <param name = "overwrite">
        ///     <see langword = "true" /> if <paramref name = "destinationPath" /> should be overwritten
        ///     if it refers to an existing file, otherwise, <see langword = "false" />.
        /// </param>
        /// <exception cref = "ArgumentNullException">
        ///     <paramref name = "sourcePath" /> and/or <paramref name = "destinationPath" /> is
        ///     <see langword = "null" />.
        /// </exception>
        /// <exception cref = "ArgumentException">
        ///     <paramref name = "sourcePath" /> and/or <paramref name = "destinationPath" /> is
        ///     an empty string (""), contains only white space, or contains one or more
        ///     invalid characters as defined in <see cref = "System.IO.Path.GetInvalidPathChars()" />.
        ///     <para>
        ///         -or-
        ///     </para>
        ///     <paramref name = "sourcePath" /> and/or <paramref name = "destinationPath" />
        ///     contains one or more components that exceed the drive-defined maximum length.
        ///     For example, on Windows-based platforms, components must not exceed 255 characters.
        /// </exception>
        /// <exception cref = "PathTooLongException">
        ///     <paramref name = "sourcePath" /> and/or <paramref name = "destinationPath" />
        ///     exceeds the system-defined maximum length. For example, on Windows-based platforms,
        ///     paths must not exceed 32,000 characters.
        /// </exception>
        /// <exception cref = "FileNotFoundException">
        ///     <paramref name = "sourcePath" /> could not be found.
        /// </exception>
        /// <exception cref = "DirectoryNotFoundException">
        ///     One or more directories in <paramref name = "sourcePath" /> and/or
        ///     <paramref name = "destinationPath" /> could not be found.
        /// </exception>
        /// <exception cref = "UnauthorizedAccessException">
        ///     The caller does not have the required access permissions.
        ///     <para>
        ///         -or-
        ///     </para>
        ///     <paramref name = "overwrite" /> is true and <paramref name = "destinationPath" /> refers to a
        ///     file that is read-only.
        /// </exception>
        /// <exception cref = "IOException">
        ///     <paramref name = "overwrite" /> is false and <paramref name = "destinationPath" /> refers to
        ///     a file that already exists.
        ///     <para>
        ///         -or-
        ///     </para>
        ///     <paramref name = "sourcePath" /> and/or <paramref name = "destinationPath" /> is a
        ///     directory.
        ///     <para>
        ///         -or-
        ///     </para>
        ///     <paramref name = "overwrite" /> is true and <paramref name = "destinationPath" /> refers to
        ///     a file that already exists and is in use.
        ///     <para>
        ///         -or-
        ///     </para>
        ///     <paramref name = "sourcePath" /> refers to a file that is in use.
        ///     <para>
        ///         -or-
        ///     </para>
        ///     <paramref name = "sourcePath" /> and/or <paramref name = "destinationPath" /> specifies
        ///     a device that is not ready.
        /// </exception>
        public static void Copy(Path sourcePath, Path destinationPath, bool overwrite)
        {
            var normalizedSourcePath      = LongPathCommon.NormalizeLongPath(sourcePath.FullPath, "sourcePath");
            var normalizedDestinationPath = LongPathCommon.NormalizeLongPath(destinationPath.FullPath, "destinationPath");

            if (!NativeMethods.CopyFile(normalizedSourcePath, normalizedDestinationPath, !overwrite))
            {
                throw LongPathCommon.GetExceptionFromLastWin32Error();
            }
        }
Beispiel #2
0
        private static IEnumerable <Path> EnumerateFileSystemEntries(Path path, string searchPattern,
                                                                     bool includeDirectories, bool includeFiles)
        {
            var normalizedSearchPattern = LongPathCommon.NormalizeSearchPattern(searchPattern);
            var normalizedPath          = LongPathCommon.NormalizeLongPath(path.FullPath);

            // First check whether the specified path refers to a directory and exists
            FileAttributes attributes;
            var            errorCode = LongPathCommon.TryGetDirectoryAttributes(normalizedPath, out attributes);

            if (errorCode != 0)
            {
                throw LongPathCommon.GetExceptionFromWin32Error(errorCode);
            }

            return(EnumerateFileSystemIterator(normalizedPath, normalizedSearchPattern,
                                               includeDirectories,
                                               includeFiles));
        }