PathOperations: заимствовано из VB.NET

Не знаю почему, но часть функционала, который мог бы быть полезен и пишущим на C#, досталась только одному VB.NET. По крайней мере, статические методы, приведенные мной ниже и предназначенные для работы с файловыми путями, изначально располагались в пространстве имен Microsoft.VisualBasic, а именно — в классе Microsoft.VisualBasic.FileIO.FileSystem.

C#:Select code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
using System;
using System.IO;
using System.Security;

namespace UsingsRU.Utils
{
    /// <summary>
    /// Класс, обеспечивающий ряд операций над строками, содержащими пути к файлам
    /// Является сокращенным вариантом стандартного класса пространства имен Microsoft.VisualBasic:
    /// Microsoft.VisualBasic.FileIO.FileSystem
    /// </summary>
    public static class PathOperations
    {

        #region Private methods
        private static string GetLongPath(string FullPath)
        {
            try
            {
                if (!IsRoot(FullPath))
                {
                    DirectoryInfo info = new DirectoryInfo(GetParentPath(FullPath));
                    if (File.Exists(FullPath))
                        return info.GetFiles(Path.GetFileName(FullPath))[0].FullName;
                    if (Directory.Exists(FullPath))
                        return info.GetDirectories(Path.GetFileName(FullPath))[0].FullName;
                }
                return FullPath;
            }
            catch (Exception exception)
            {
                if ((((!(exception is ArgumentException) && !(exception is ArgumentNullException)) && !(exception is PathTooLongException)) && (!(exception is NotSupportedException) && !(exception is DirectoryNotFoundException))) && (!(exception is SecurityException) && !(exception is UnauthorizedAccessException)))
                    throw;
                return FullPath;
            }
        }

        private static string RemoveEndingSeparator(string path)
        {
            if (Path.IsPathRooted(path) && path.Equals(Path.GetPathRoot(path), StringComparison.OrdinalIgnoreCase))
                return path;
            return path.TrimEnd(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
        }

        private static bool IsRoot(string path)
        {
            if (!Path.IsPathRooted(path))
                return false;
            path = path.TrimEnd(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
            return (string.Compare(path, Path.GetPathRoot(path), StringComparison.OrdinalIgnoreCase) == 0);
        }

        #endregion

        #region Public methods
        /// <summary>
        /// Вернуть путь к родительскому каталогу
        /// </summary>
        /// <param name="path">Путь к папке</param>
        /// <returns>Путь к родительскому каталогу</returns>
        public static string GetParentPath(string path)
        {
            Path.GetFullPath(path);
            if (IsRoot(path))
                throw new DirectoryNotFoundException("No parent path for \"" + path + "\"");
            return Path.GetDirectoryName(path.TrimEnd(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar }));
        }

        /// <summary>
        /// Вернуть путь к файлу в нормализованном виде: полный путь без завершающего '\'
        /// </summary>
        /// <param name="path">Путь к файлу</param>
        /// <returns>Путь к файлу в нормализованном виде</returns>
        public static string NormalizePath(string path)
        {
            return GetLongPath(RemoveEndingSeparator(Path.GetFullPath(path)));
        }

        /// <summary>
        /// Вернуть нормализованный путь, получаемый как суперпозиция пути относительно базовой папки
        /// </summary>
        /// <param name="baseDirectory">Базовая папка</param>
        /// <param name="relativePath">Относительный путь</param>
        /// <returns>Нормализованная комбинация путей</returns>
        public static string CombinePath(string baseDirectory, string relativePath)
        {
            if (baseDirectory.Length == 0)
                throw new ArgumentNullException("baseDirectory");
            if (relativePath.Length == 0)
                return baseDirectory;
            baseDirectory = Path.GetFullPath(baseDirectory);
            return NormalizePath(Path.Combine(baseDirectory, relativePath));
        }
        #endregion

    }
}

Эти методы мне приходилось частенько использовать, и хочется надеяться, что они пригодятся и Вам.

Обсуждение на форуме: http://usings.ru/forum/viewtopic.php?t=8

admin опубликовано 2009-6-18 Рубрика: Утилитарные классы | Метки: ,

3 ответов Оставить комментарий

  1. #1drinian @ 2009-9-17 15:23 Ответ

    Неплохо было бы реализовать класс, улучшающий стандартные операции со строками. Назвать его можно было бы StringOperations, строки передавать по ссылке, а операции делать в unsafe для быстроты и оптимальности.

  2. #2admin @ 2009-9-17 15:38 Ответ

    Уважаемый drinian!
    Я думал об этом, но решил пока не реализовывать, потому что это мало кому может быть полезно. Полезно это только тем, кто обрабатывает огромные массивы строк на C#, а таких, мягко говоря, немного.

  3. #3mogikanin @ 2009-9-17 21:49 Ответ

    Да, давно пора утереть мелкософту нос! Unsafe код рулит!

Ответить mogikanin

Отменить

(Ctrl + Enter)