Introduction

Path.Combine in .NET does not convert forward slashes (/) to backslashes (\). If one of the input strings contains forward slashes, they remain in the output as-is. To normalize path separators, call Path.GetFullPath() on the result (on Windows this converts forward slashes to backslashes) or manually replace / with Path.DirectorySeparatorChar. Understanding how Path.Combine handles separators prevents cross-platform path bugs.

The Problem

1string result = Path.Combine("C:\\Users", "docs/reports/file.txt");
2Console.WriteLine(result);
3// Output: C:\Users\docs/reports/file.txt
4// Mixed separators — forward slashes NOT converted

Path.Combine inserts the platform separator between segments but does not modify separators within segments.

Fix 1: Path.GetFullPath()

Path.GetFullPath() resolves the full path and normalizes separators on Windows:

1string combined = Path.Combine("C:\\Users", "docs/reports/file.txt");
2string normalized = Path.GetFullPath(combined);
3Console.WriteLine(normalized);
4// Output: C:\Users\docs\reports\file.txt  (on Windows)

On Linux/macOS, Path.GetFullPath() keeps forward slashes since / is the native separator.

Fix 2: String.Replace()

Explicitly replace forward slashes with the platform-appropriate separator:

1string combined = Path.Combine("C:\\Users", "docs/reports/file.txt");
2string normalized = combined.Replace('/', Path.DirectorySeparatorChar);
3Console.WriteLine(normalized);
4// Output: C:\Users\docs\reports\file.txt  (on Windows)
5// Output: C:/Users/docs/reports/file.txt  (on Linux — '/' stays as '/')

For cross-platform code, replace both separators with the platform one:

1string NormalizePath(string path)
2{
3    return path
4        .Replace('/', Path.DirectorySeparatorChar)
5        .Replace('\\', Path.DirectorySeparatorChar);
6}

Fix 3: Split and Recombine

Split the path by both separators and recombine using Path.Combine:

1string input = "docs/subfolder\\file.txt";
2string[] parts = input.Split('/', '\\');
3string normalized = Path.Combine(parts);
4Console.WriteLine(normalized);
5// Output: docs\subfolder\file.txt  (on Windows)

This also removes empty segments and handles edge cases cleanly.

How Path.Combine Actually Works

1// Path.Combine concatenates segments with the platform separator
2Path.Combine("a", "b", "c");        // a\b\c (Windows) or a/b/c (Linux)
3
4// If a segment starts with a separator, it becomes the new root
5Path.Combine("C:\\Users", "/docs");  // /docs (!) — second arg is treated as absolute
6Path.Combine("C:\\Users", "\\docs"); // \docs (!) — same behavior
7
8// Empty strings are ignored
9Path.Combine("a", "", "b");         // a\b
10
11// Trailing separators in earlier segments are preserved
12Path.Combine("a\\", "b");           // a\b (no double separator)

The critical gotcha: if any segment starts with / or \, Path.Combine discards all previous segments.

Cross-Platform Best Practices

1// Use Path.Combine instead of string concatenation
2// BAD:
3string path = baseDir + "\\" + fileName;
4
5// GOOD:
6string path = Path.Combine(baseDir, fileName);
7
8// Use Path.DirectorySeparatorChar for platform-specific separators
9Console.WriteLine(Path.DirectorySeparatorChar);
10// '\' on Windows, '/' on Linux/macOS
11
12// Use Path.AltDirectorySeparatorChar
13Console.WriteLine(Path.AltDirectorySeparatorChar);
14// '/' on Windows, '/' on Linux/macOS (same as primary)

On Windows, both / and \ work in most APIs. On Linux, only / works. Write code that uses Path.Combine and Path.DirectorySeparatorChar to stay portable.

.NET 6+ Path Helpers

1// Path.Join (does NOT discard segments for rooted paths)
2Path.Join("C:\\Users", "/docs");     // C:\Users\/docs (keeps both)
3// vs
4Path.Combine("C:\\Users", "/docs");  // /docs (discards first segment)
5
6// Path.TrimEndingDirectorySeparator
7Path.TrimEndingDirectorySeparator("C:\\Users\\");  // C:\Users
8
9// Path.EndsInDirectorySeparator
10Path.EndsInDirectorySeparator("C:\\Users\\");       // true
11
12// Path.GetRelativePath
13Path.GetRelativePath("C:\\Users", "C:\\Users\\docs\\file.txt");
14// docs\file.txt

Path.Join is safer than Path.Combine when you do not want rooted segments to reset the path.

Common Pitfalls

• Expecting Path.Combine to normalize separators: It does not. Path.Combine("a", "b/c") produces a\b/c on Windows. Call Path.GetFullPath() or replace manually afterward.
• Second argument starting with / or \: Path.Combine("C:\\base", "/relative") returns /relative, discarding the base path entirely. Trim leading separators from relative segments or use Path.Join instead.
• Hardcoding \\ in paths: This breaks on Linux/macOS. Use Path.Combine or Path.DirectorySeparatorChar to build paths portably.
• Using Path.GetFullPath on relative paths: Path.GetFullPath("docs/file.txt") resolves relative to the current working directory, which may not be what you expect. Pass an absolute base path when possible.
• Assuming URI paths and file paths use the same separators: URIs always use forward slashes (https://example.com/path). Converting a URI path to a file path requires replacing / with the platform separator. Do not use Path.Combine for URIs — use the Uri class instead.

Summary

• Path.Combine does not convert forward slashes to backslashes (or vice versa)
• Use Path.GetFullPath() to normalize separators on the current platform
• Use string.Replace('/', Path.DirectorySeparatorChar) for explicit conversion
• Watch for segments starting with / or \ — Path.Combine treats them as absolute and discards prior segments
• Use Path.Join (.NET Core 3.0+) as a safer alternative that preserves all segments
• Always use Path.Combine or Path.DirectorySeparatorChar instead of hardcoded separator characters