SafePath.cs

using System.Linq;
using System.IO;
using System;
using System.Runtime.InteropServices;

namespace Rampastring.Tools
{

    /// <summary>
    /// Provides safe cross platform Path handling.
    /// </summary>
    public static class SafePath
    {
        /// <summary>
        /// Safely combines multiple directory paths for all platforms.
        /// The first path can be a relative or absolute path.
        /// </summary>
        /// <param name="paths">Ordered list of directory paths.</param>
        /// <returns>The combined directory path of all <paramref name="paths"/>, with trailing separator character and with leading separator character if the path has a root.</returns>
        public static string CombineDirectoryPath(params string[] paths)
        {
            return Combine(true, paths);
        }

        /// <summary>
        /// Safely combines multiple directory paths with a file name for all platforms.
        /// The first path can be a relative or absolute path.
        /// </summary>
        /// <param name="paths">Ordered list of directory paths with a file name.</param>
        /// <returns>The combined directory path and file name of all <paramref name="paths"/> with leading separator character if the path has a root.</returns>
        public static string CombineFilePath(params string[] paths)
        {
            return Combine(false, paths);
        }

        /// <summary>
        /// Safely combines multiple directory paths for all platforms.
        /// The first path can be a relative or absolute path.
        /// </summary>
        /// <param name="paths">Ordered list of directory paths.</param>
        /// <returns>A <see cref="DirectoryInfo"/> instance representing the combined directory path of all <paramref name="paths"/>.</returns>
        public static DirectoryInfo GetDirectory(params string[] paths)
        {
            return new DirectoryInfo(CombineDirectoryPath(paths));
        }

        /// <summary>
        /// Safely combines multiple directory paths with a file name for all platforms.
        /// The first path can be a relative or absolute path.
        /// </summary>
        /// <param name="paths">Ordered list of directory paths with a file name.</param>
        /// <returns>A <see cref="FileInfo"/> instance representing the combined directory path and file name of all <paramref name="paths"/>.</returns>
        public static FileInfo GetFile(params string[] paths)
        {
            return new FileInfo(CombineFilePath(paths));
        }

        /// <summary>
        /// Safely delete a file represented by multiple directory paths with a file name for all platforms.
        /// Does not throw an exception if the file or directory path does not exist.
        /// </summary>
        /// <param name="paths">Ordered list of directory paths with a file name.</param>
        public static void DeleteFileIfExists(params string[] paths)
        {
            var fileInfo = new FileInfo(CombineFilePath(paths));

            if (fileInfo.Exists)
                fileInfo.Delete();
        }

        /// <summary>
        /// Safely delete a directory represented by multiple directory paths for all platforms.
        /// Does not throw an exception if the directory path does not exist.
        /// </summary>
        /// <param name="recursive">true to remove directories, subdirectories, and files in path; otherwise, false.</param>
        /// <param name="paths">Ordered list of directory paths.</param>
        public static void DeleteDirectoryIfExists(bool recursive, params string[] paths)
        {
            var directoryInfo = new DirectoryInfo(CombineFilePath(paths));

            if (directoryInfo.Exists)
                directoryInfo.Delete(recursive);
        }

        /// <summary>
        /// Safely retrieves the name of a directory represented by multiple directory paths and a file name for all platforms.
        /// </summary>
        /// <param name="paths">Ordered list of directory paths and a file name.</param>
        /// <returns>The name (not path) of the directory a given file resides in.</returns>
        public static string GetFileDirectoryName(params string[] paths)
        {
            var fileInfo = new FileInfo(CombineFilePath(paths));

            return fileInfo.DirectoryName;
        }

        private static string Combine(bool isDirectoryPath, params string[] paths)
        {
            if (paths is null)
                return null;

            paths = paths.Where(p => !string.IsNullOrWhiteSpace(p)).ToArray();

            if (!paths.Any())
                return null;

            if (paths.Length == 1)
                paths = new[] { paths[0], null };

            string combinedPath = paths.Aggregate((x, y) => y is null ? GetPath(x) : Path.Combine(GetPath(x), GetPath(y)))
                .TrimStart(Path.DirectorySeparatorChar)
                .TrimStart(Path.AltDirectorySeparatorChar)
                .TrimEnd(Path.DirectorySeparatorChar)
                .TrimEnd(Path.AltDirectorySeparatorChar);

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                if (paths[0].Length > 1 && paths[0][1] == Path.VolumeSeparatorChar)
                    return FormattableString.Invariant($"{combinedPath}{(isDirectoryPath ? Path.DirectorySeparatorChar : null)}");

                return FormattableString.Invariant($"{(Path.IsPathRooted(paths[0]) ? Path.DirectorySeparatorChar : null)}{combinedPath}{(isDirectoryPath ? Path.DirectorySeparatorChar : null)}");
            }

            return FormattableString.Invariant($"{(Path.IsPathRooted(paths[0]) ? Path.DirectorySeparatorChar : null)}{combinedPath}{(isDirectoryPath ? Path.DirectorySeparatorChar : null)}");
        }

        private static string GetPath(string path)
        {
            return FormattableString.Invariant($"{path ?
                .Replace("///", "/")
                .Replace("//", "/")
                .Replace('/', Path.DirectorySeparatorChar)
                .Replace("\\\\\\", "\\")
                .Replace("\\\\", "\\")
                .Replace('\\', Path.DirectorySeparatorChar)
                .TrimStart(Path.DirectorySeparatorChar)
                .TrimStart(Path.AltDirectorySeparatorChar)
                .TrimEnd(Path.DirectorySeparatorChar)
                .TrimEnd(Path.AltDirectorySeparatorChar)}{Path.DirectorySeparatorChar
    }");
    }
}
}