Check if full path given

C# Problem Overview

Is there a method to check if given path is full path? Right now im doing this:

if (template.Contains(":\\")) //full path already given
{
}
else //calculate the path from local assembly
{
}

But there must be more elegant way for checking this?

C# Solutions

Solution 1 - C#

Try using System.IO.Path.IsPathRooted? It also returns true for absolute paths.

System.IO.Path.IsPathRooted(@"c:\foo"); // true
System.IO.Path.IsPathRooted(@"\foo"); // true
System.IO.Path.IsPathRooted("foo"); // false

System.IO.Path.IsPathRooted(@"c:1\foo"); // surprisingly also true
System.IO.Path.GetFullPath(@"c:1\foo");// returns "[current working directory]\1\foo"

Solution 2 - C#

Path.IsPathRooted(path)
&& !Path.GetPathRoot(path).Equals(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)

The above condition:

does not require file system permissions
returns false in most cases where the format of path is invalid (rather than throwing an exception)
returns true only if path includes the volume

In scenarios like the one the OP posed, it may therefore be more suitable than the conditions in the earlier answers. Unlike the above condition:

path == System.IO.Path.GetFullPath(path) throws exceptions rather than returning false in these scenarios:
The caller does not have the required permissions
The system could not retrieve the absolute path
path contains a colon (":") that is not part of a volume identifier
The specified path, file name, or both exceed the system-defined maximum length
System.IO.Path.IsPathRooted(path) returns true if path begins with a single directory separator.

Finally, here is a method that wraps the above condition and also forecloses the remaining possible exceptions:

public static bool IsFullPath(string path) {
	return !String.IsNullOrWhiteSpace(path)
		&& path.IndexOfAny(System.IO.Path.GetInvalidPathChars().ToArray()) == -1
		&& Path.IsPathRooted(path)
		&& !Path.GetPathRoot(path).Equals(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal);
}

EDIT: EM0 made a good comment and alternative answer addressing the curious case of paths like C: and C:dir. To help decide how you may want to handle such paths, you may want to take deep dive to MSDN --> Windows desktop applications --> Develop --> Desktop technologies --> Data Access and Storage --> Local File Systems --> File Management --> About File Management --> Creating, Deleting, and Maintaining Files --> Naming Files, Paths, and Namespaces --> Fully Qualified vs. Relative Paths

> For Windows API functions that manipulate files, file names can often > be relative to the current directory, while some APIs require a fully > qualified path. A file name is relative to the current directory if it > does not begin with one of the following: > > - A UNC name of any format, which always start with two backslash characters ("\"). For more information, see the next section. > - A disk designator with a backslash, for example "C:" or "d:". > - A single backslash, for example, "\directory" or "\file.txt". This is also referred to as an absolute path. > > If a file name begins with only a disk designator but not the > backslash after the colon, it is interpreted as a relative path to the > current directory on the drive with the specified letter. Note that > the current directory may or may not be the root directory depending > on what it was set to during the most recent "change directory" > operation on that disk. Examples of this format are as follows: > > - "C:tmp.txt" refers to a file named "tmp.txt" in the current directory on drive C. > - "C:tempdir\tmp.txt" refers to a file in a subdirectory to the current directory on drive C. > > [...]

Solution 3 - C#

Building on weir's answer: this does not throw for invalid paths, but also returns false for paths like "C:", "C:dirname" and "\path".

public static bool IsFullPath(string path)
{
    if (string.IsNullOrWhiteSpace(path) || path.IndexOfAny(Path.GetInvalidPathChars()) != -1 || !Path.IsPathRooted(path))
        return false;
    
    string pathRoot = Path.GetPathRoot(path);
    if (pathRoot.Length <= 2 && pathRoot != "/") // Accepts X:\ and \\UNC\PATH, rejects empty string, \ and X:, but accepts / to support Linux
        return false;

    if (pathRoot[0] != '\\' || pathRoot[1] != '\\')
        return true; // Rooted and not a UNC path

    return pathRoot.Trim('\\').IndexOf('\\') != -1; // A UNC server name without a share name (e.g "\\NAME" or "\\NAME\") is invalid
}

Note that this returns different results on Windows and Linux, e.g. "/path" is absolute on Linux, but not on Windows.

Unit test:

[Test]
public void IsFullPath()
{
    bool isWindows = Environment.OSVersion.Platform.ToString().StartsWith("Win"); // .NET Framework
    // bool isWindows = System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(OSPlatform.Windows); // .NET Core

    // These are full paths on Windows, but not on Linux
    TryIsFullPath(@"C:\dir\file.ext", isWindows);
    TryIsFullPath(@"C:\dir\", isWindows);
    TryIsFullPath(@"C:\dir", isWindows);
    TryIsFullPath(@"C:\", isWindows);
    TryIsFullPath(@"\\unc\share\dir\file.ext", isWindows);
    TryIsFullPath(@"\\unc\share", isWindows);

    // These are full paths on Linux, but not on Windows
    TryIsFullPath(@"/some/file", !isWindows);
    TryIsFullPath(@"/dir", !isWindows);
    TryIsFullPath(@"/", !isWindows);

    // Not full paths on either Windows or Linux
    TryIsFullPath(@"file.ext", false);
    TryIsFullPath(@"dir\file.ext", false);
    TryIsFullPath(@"\dir\file.ext", false);
    TryIsFullPath(@"C:", false);
    TryIsFullPath(@"C:dir\file.ext", false);
    TryIsFullPath(@"\dir", false); // An "absolute", but not "full" path

    // Invalid on both Windows and Linux
    TryIsFullPath(null, false, false);
    TryIsFullPath("", false, false);
    TryIsFullPath("   ", false, false);
    TryIsFullPath(@"C:\inval|d", false, false);
    TryIsFullPath(@"\\is_this_a_dir_or_a_hostname", false, false);
    TryIsFullPath(@"\\is_this_a_dir_or_a_hostname\", false, !isWindows);
    TryIsFullPath(@"\\is_this_a_dir_or_a_hostname\\", false, !isWindows);
}

private static void TryIsFullPath(string path, bool expectedIsFull, bool expectedIsValid = true)
{
    Assert.AreEqual(expectedIsFull, PathUtils.IsFullPath(path), "IsFullPath('" + path + "')");

    if (expectedIsFull)
    {
        Assert.AreEqual(path, Path.GetFullPath(path));
    }
    else if (expectedIsValid)
    {
        Assert.AreNotEqual(path, Path.GetFullPath(path));
    }
    else
    {
        Assert.That(() => Path.GetFullPath(path), Throws.Exception);
    }
}

Solution 4 - C#

Try

System.IO.Path.IsPathRooted(template)

Works for UNC paths as well as local ones.

E.g.

Path.IsPathRooted(@"\\MyServer\MyShare\MyDirectory")  // returns true
Path.IsPathRooted(@"C:\\MyDirectory")  // returns true

Solution 5 - C#

Old question, but one more applicable answer. If you need to ensure the volume is included in a local path, you can use System.IO.Path.GetFullPath() like this:

if (template == System.IO.Path.GetFullPath(template))
{
    ; //template is full path including volume or full UNC path
}
else
{
    if (useCurrentPathAndVolume)
        template = System.IO.Path.GetFullPath(template);
    else
        template = Assembly.GetExecutingAssembly().Location
}

Solution 6 - C#

On .NET Core 2.1+ and .NET

You can use Path.IsFullyQualified (source).

On .NET Framework

You can implement the definition of fully qualified (MS Docs). For example:

public static bool IsPathFullyQualified(string path)
{
    var root = Path.GetPathRoot(path);
    return root.StartsWith(@"\\") || root.EndsWith(@"\");
}

Solution 7 - C#

As of .NET Core 2.1/NET Standard 2.1, you can call the following method:

Path.IsPathFullyQualified(@"c:\foo")

MSDN doc: Path.IsPathFullyQualified Method

The useful cite from MSDN doc follows:

> This method handles paths that use the alternate directory separator. > It's a frequent mistake to assume that rooted paths > (IsPathRooted(String)) aren't relative. For example, "C:a" is drive > relative, that is, it's resolved against the current directory for C: > (rooted, but relative). "C:\a" is rooted and not relative, that is, > the current directory isn't used to modify the path.

Solution 8 - C#

This is the solution I use

public static bool IsFullPath(string path)
{
    try
    {
        return Path.GetFullPath(path) == path;
    }
    catch
    {
        return false;
    }
}

It works the following way:

IsFullPath(@"c:\foo"); // true
IsFullPath(@"C:\foo"); // true
IsFullPath(@"c:\foo\"); // true
IsFullPath(@"c:/foo"); // false
IsFullPath(@"\foo"); // false
IsFullPath(@"foo"); // false
IsFullPath(@"c:1\foo\"); // false

Solution 9 - C#

I'm not really sure what you mean by full path (though assuming from the example you mean non-relative from the root onwards), well, you can use the Path class to aid you in working with physical filesystem paths, which should cover you for most eventualities.

Content Type	Original Author	Original Content on Stackoverflow
Question	hs2d	View Question on Stackoverflow
Solution 1 - C#	detaylor	View Answer on Stackoverflow
Solution 2 - C#	weir	View Answer on Stackoverflow
Solution 3 - C#	EM0	View Answer on Stackoverflow
Solution 4 - C#	Joe	View Answer on Stackoverflow
Solution 5 - C#	GreggD	View Answer on Stackoverflow
Solution 6 - C#	William	View Answer on Stackoverflow
Solution 7 - C#	sergtk	View Answer on Stackoverflow
Solution 8 - C#	Mykhailo Seniutovych	View Answer on Stackoverflow
Solution 9 - C#	Grant Thomas	View Answer on Stackoverflow