从文件路径中删除“head”目录

Question

In .NET (VB or C#) Does anyone know a simple way to remove the 'head' directory from a file path String, meaning if I have path that looks something like this: Directory1/Directory2/Directory3 I want to get Directory2/Directory3 back. I know there are some ways to do it, like split it into an array, and then starting with the second element concatenate it all back, I just feel like that, that's its an extremely inefficient way of doing it and was wondering if there is a better way to do this.

Answer 1

It depends on what you're looking for. If you know that things are in the form dir1/dir2/dir3/dir4... , then you can just look for the first / and take everything after that:

string dir = "dir1/dir2/dir3";
var pos = dir.IndexOf('/');
if (pos != -1)
{
    result = dir.Substring(pos+1);
}

If you can also accept full path names of the form c:\\dir\\dir\\file.ext or \\\\server\\dir\\dir\\file.ext , then you'll probably want to make sure that you make any relative paths into full paths first. Then use the methods in the System.IO.Path class to extract the drive or server names before using something like the IndexOf trick above.

Answer 2

Look at the System.IO.Path class. It has a number of useful methods for this kind of thing.

For example, you might use it's GetPathRoot() method as part of a call to String.Replace() like so:

public string RemoveHead(string path)
{
    return path.Replace(Path.GetPathRoot(path), "");
}

I don't have Visual Studio handy, so that likely needs some tweaks to account for separator characters or Drive letters, but it should give you the idea.

Answer 3

If you want correctness and efficiency,

string path=@"dir1/dir2/dir3";
path=path.Substring(path.IndexOf(System.IO.Path.DirectorySeparatorChar)+1);

only 1 new string is created.

Answer 4

        /// <summary>
    /// Removes head.
    /// </summary>
    /// <param name="path">The path to drop head.</param>
    /// <param name="retainSeparator">If to retain separator before next folder when deleting head.</param>
    /// <returns>New path.</returns>
    public static string GetPathWithoutHead (string path, bool retainSeparator = false)
    {
        if (path == null) 
        {
            return path;
        }
        if (string.IsNullOrWhiteSpace (path)) 
        {
             throw new ArgumentException(path, "The path is not of a legal form.");
        }

        var root = System.IO.Path.GetPathRoot (path);
        if (!string.IsNullOrEmpty(root) && !StartsWithAny(root,System.IO.Path.DirectorySeparatorChar,System.IO.Path.AltDirectorySeparatorChar))
        {               
            return path.Remove(0,root.Length);
        }

        var sep = path.IndexOf(System.IO.Path.DirectorySeparatorChar);
        var altSep = path.IndexOf(System.IO.Path.AltDirectorySeparatorChar);
        var pos = MaxPositiveOrMinusOne (sep, altSep);
        if (pos == -1)
        {
            return string.Empty;
        }

        if (pos == 0) 
        {
            return GetPathWithoutHead(path.Substring(pos+1), retainSeparator);
        }

        var eatSeparator = !retainSeparator ? 1 : 0;
        return path.Substring(pos+eatSeparator);
    }

    /// <summary>
    /// Startses the with.
    /// </summary>
    /// <returns><c>true</c>, if with was startsed, <c>false</c> otherwise.</returns>
    /// <param name="val">Value.</param>
    /// <param name="maxLength">Max length.</param>
    /// <param name="chars">Chars.</param>
    private static bool StartsWithAny(string value, params char[] chars)
    {
        foreach (var c in chars) 
        {
            if (value[0] == c) 
            {
                return true;
            }
        }
        return false;
    }

    /// <summary>
    /// Maxs the positive or minus one.
    /// </summary>
    /// <returns>The positive or minus one.</returns>
    /// <param name="val1">Val1.</param>
    /// <param name="val2">Val2.</param>
    private static int MaxPositiveOrMinusOne(int val1, int val2)
    {
        if (val1 < 0 && val2 < 0)
        {
            return -1;
        }
        return Math.Max(val1,val2: val2);
    }

Several unit tests are here