Building a directory string from component parts in C#

Question

If i have lots of directory names either as literal strings or contained in variables, what is the easiest way of combining these to make a complete path?

I know of

Path.Combine

but this only takes 2 string parameters, i need a solution that can take any number number of directory parameters.

e.g:

string folder1 = "foo";
string folder2 = "bar";

CreateAPath("C:", folder1, folder2, folder1, folder1, folder2, "MyFile.txt")

Any ideas? Does C# support unlimited args in methods?

Thrombo

Answer 1

Does C# support unlimited args in methods?

Yes, have a look at the params keyword. Will make it easy to write a function that just calls Path.Combine the appropriate number of times, like this (untested):

string CombinePaths(params string[] parts) {
    string result = String.Empty;
    foreach (string s in parts) {
        result = Path.Combine(result, s);
    }
    return result;
}

Leanneleanor

@OregonGhost: +1, but switch "" to String.Empty. – Hadleigh

According to bytes.com/forum/thread453111.html , there is exactly no difference between the two and the Compiler will actually produce exactly the same IL for both. But for readability, I'll change it. – Leanneleanor

Answer 2

LINQ to the rescue again. The Aggregate extension function can be used to accomplish what you want. Consider this example:

string[] ary = new string[] { "c:\\", "Windows", "System" };
string path = ary.Aggregate((aggregation, val) => Path.Combine(aggregation, val));
Console.WriteLine(path); //outputs c:\Windows\System

Teeming

Nice. Way to know the available sequence operations! – Kronick

Microsoft did a really nice job with LINQ. Anytime I need to do something funky with a collection I immediately go look in the LINQ libraries. – Teeming

Answer 3

I prefer to use DirectoryInfo vs. the static methods on Directory, because I think it's better OO design. Here's a solution with DirectoryInfo + extension methods, that I think is quite nice to use:

    public static DirectoryInfo Subdirectory(this DirectoryInfo self, params string[] subdirectoryName)
    {
        Array.ForEach(
            subdirectoryName, 
            sn => self = new DirectoryInfo(Path.Combine(self.FullName, sn))
            );
        return self;
    }

I don't love the fact that I'm modifying self, but for this short method, I think it's cleaner than making a new variable.

The call site makes up for it, though:

        DirectoryInfo di = new DirectoryInfo("C:\\")
            .Subdirectory("Windows")
            .Subdirectory("System32");

        DirectoryInfo di2 = new DirectoryInfo("C:\\")
            .Subdirectory("Windows", "System32");

Adding a way to get a FileInfo is left as an exercise (for another SO question!).

Kronick

Could someone explain why my answer is voted down? Is there a problem I didn't see? – Kronick

Answer 4

Try this one:

public static string CreateDirectoryName(string fileName, params string[] folders)
{
    if(folders == null || folders.Length <= 0)
    {
        return fileName;
    }

    string directory = string.Empty;
    foreach(string folder in folders)
    {
        directory = System.IO.Path.Combine(directory, folder);
    }
    directory = System.IO.Path.Combine(directory, fileName);

    return directory;
}

The params makes it so that you can append an infinite amount of strings.

Path.Combine does is to make sure that the inputted strings does not begin with or ends with slashes and checks for any invalid characters.

Infeudation

Please, let System.IO.Path methods handle things like trimming or adding backslashes. – Leanneleanor

OK, I say it differently. Why re-invent the wheel? Does that hard-coded thing really look more clear to you? What if you're running on a *NIX system with the forward slash being the path separator? What if one of the paths is absolute? Path.Combine handles that as well. – Leanneleanor

Oh common, now you're really just re-inventing Path.Combine. It's there, so use it: weblogs.asp.net/rchartier/archive/2006/01/26/436584.aspx – Leanneleanor

Voted down because it is still wrong about Path.Combine, will still fail with absolute paths, handling of wildcards is not clear and is a potentially efficient, but complicated solution. – Leanneleanor

I'm sorry that I had to insist on this, but I didn't want to let it stand there incorrect. We're supposed to do that, right? My intention was not to hit you personally though. – Leanneleanor