Combining URL Parts in C#: Uri and Safe URL Joining in .NET

By the end of this page, you will understand why Path.Combine() should not be used for URLs, how to combine URL parts correctly in C# with Uri, how leading and trailing slashes change the result, and how developers typically build safe URLs in real .NET applications.

In .NET, file paths and URLs are different things.

• Path.Combine() is designed for file system paths.
• URLs follow URI rules, not file path rules.
• File paths use operating-system-specific separators.
• URLs always use forward slashes / and have special rules for schemes, hosts, query strings, and relative paths.

Because of that, using Path.Combine() for URLs is the wrong tool. For example, on Windows it may produce backslashes, which are valid for file paths but not appropriate for web URLs.

The correct .NET concept is the Uri class.

A common pattern is:

var baseUri = new Uri("http://MyUrl.com/");
var fullUri = new Uri(baseUri, "Images/Image.jpg");

This produces:

http://MyUrl.com/Images/Image.jpg

This matters in real programming because applications often need to:

• build API endpoints
• link to static files
• create redirects
• generate image URLs
• combine base addresses with request paths

If URL parts are combined incorrectly, you can get:

• missing slashes
• double slashes
• overwritten path segments
• invalid URLs
• bugs that only appear in production

So the main lesson is: use Uri for URLs, not Path.Combine().

Think of a URL like a postal address, and a file path like a path inside a building.

• A file path says where something is stored on a computer.
• A URL says how to locate something on the web.

Path.Combine() is like a tool made for indoor hallway directions.

Uri is like a tool made for full mailing addresses.

If you use the hallway tool for mailing addresses, parts may be joined in the wrong format.

Another useful way to think about it:

• Path.Combine() understands disks and folders.
• Uri understands http://, domains, paths, queries, and fragments.

So when working with web addresses, always reach for the type that understands web address rules.

Core syntax

Use the Uri constructor that accepts a base URI and a relative URI:

var baseUri = new Uri("http://MyUrl.com/");
var fullUri = new Uri(baseUri, "Images/Image.jpg");

Console.WriteLine(fullUri.ToString());

Output:

http://myurl.com/Images/Image.jpg

Basic example

using System;

var baseUri = new Uri("http://MyUrl.com/");
var imageUri = new Uri(baseUri, "Images/Image.jpg");

Console.WriteLine(imageUri);

Why this works

• The first Uri is the base address.
• The second value is treated as a relative path.
• .NET resolves the second part against the base URL.

Important slash behavior

Example 1: Correct base + relative path

var baseUri = new Uri("http://example.com/");
var result = new Uri(baseUri, "images/photo.jpg");
Console.WriteLine(result);

Result:

http://example.com/images/photo.jpg

Example 2: Leading slash resets to site root

var baseUri = new Uri("http://example.com/app/");
var result = new Uri(baseUri, "/images/photo.jpg");
Console.WriteLine(result);

Result:

http://example.com/images/photo.jpg

Notice that /images/photo.jpg starts from the root of the site, so /app/ is not kept.

Example 3: No trailing slash means last segment may be treated like a file

var baseUri = new Uri("http://example.com/app");
var result = new Uri(baseUri, "images/photo.jpg");
Console.WriteLine(result);

Result:

http://example.com/images/photo.jpg

Because app is treated like the last resource segment, it gets replaced.

If you want to append under app, use a trailing slash:

var baseUri = new Uri("http://example.com/app/");
var result = new Uri(baseUri, "images/photo.jpg");
Console.WriteLine(result);

Result:

http://example.com/app/images/photo.jpg

Helper method example

If you want a reusable method:

using System;

public static class UrlHelper
{
    public static string Combine(string baseUrl, string relativePath)
    {
        var baseUri = new Uri(baseUrl.EndsWith("/") ? baseUrl : baseUrl + "/");
        var result = new Uri(baseUri, relativePath.TrimStart('/'));
        return result.ToString();
    }
}

Console.WriteLine(UrlHelper.Combine("http://MyUrl.com/", "/Images/Image.jpg"));

Output:

http://myurl.com/Images/Image.jpg

This helper normalizes the slashes so appending is more predictable.

Let's trace this example:

using System;

var baseUri = new Uri("http://example.com/app/");
var fullUri = new Uri(baseUri, "images/logo.png");

Console.WriteLine(fullUri);

Step 1: Create the base URI

var baseUri = new Uri("http://example.com/app/");

This represents:

• scheme: http
• host: example.com
• base path: /app/

Because the URL ends with /, .NET treats it like a directory base.

Step 2: Resolve the relative path

var fullUri = new Uri(baseUri, "images/logo.png");

Now .NET combines:

• base: http://example.com/app/
• relative: images/logo.png

Result:

http://example.com/app/images/logo.png

Step 3: Print the result

Console.WriteLine(fullUri);

This writes the final absolute URL.

What if the second part starts with /?

var fullUri = new Uri(baseUri, "/images/logo.png");

Now the leading slash means:

• ignore /app/
• start from the root of the domain

Result:

http://example.com/images/logo.png

That small slash changes the meaning completely, so it is one of the most important details to remember.

Common practical uses

Building API endpoints

var apiBase = new Uri("https://api.example.com/v1/");
var usersEndpoint = new Uri(apiBase, "users");

Used when an app has a configurable API base URL.

Generating image or asset links

var cdnBase = new Uri("https://cdn.example.com/assets/");
var imageUrl = new Uri(cdnBase, "products/shoe.png");

Useful in e-commerce, CMS systems, and media platforms.

Creating links in emails

var siteBase = new Uri("https://example.com/");
var resetLink = new Uri(siteBase, "account/reset-password");

This is common for password reset emails and account verification links.

Combining HttpClient base addresses

var client = new HttpClient
{
    BaseAddress = new Uri("https://api.example.com/")
};

Then requests like users/42 are resolved relative to the base address.

Multi-environment configuration

A project may use different base URLs in different environments:

• development: https://localhost:5001/
• staging: https://staging-api.example.com/
• production: https://api.example.com/

The code stays the same, and only the base URL changes.

In real projects, developers usually do not manually concatenate strings like this:

var url = baseUrl + "/images/" + fileName;

That approach often causes bugs.

Common patterns in production code

1. Store a base URL in configuration

var baseUrl = configuration["AppSettings:BaseUrl"];
var profileUrl = new Uri(new Uri(baseUrl), "users/profile");

This keeps environments flexible.

2. Normalize input with guard clauses

public static string CombineUrl(string baseUrl, string path)
{
    if (string.IsNullOrWhiteSpace(baseUrl))
        throw new ArgumentException("Base URL is required.", nameof(baseUrl));

    if (string.IsNullOrWhiteSpace(path))
        throw new ArgumentException("Path is required.", nameof(path));

    var baseUri = new Uri(baseUrl.EndsWith("/") ? baseUrl : baseUrl + "/");
    return new Uri(baseUri, path.TrimStart('/')).ToString();
}

Guard clauses make failures clear and early.

3. Use HttpClient.BaseAddress

var client = new HttpClient
{
    BaseAddress = new Uri("https://api.example.com/")
};

var response = await client.GetAsync("users");

This is a very common real-world pattern.

4. Validate before creating links

Developers often validate configuration at startup so invalid URLs fail fast.

if (!Uri.TryCreate(baseUrl, UriKind.Absolute, out var parsedBaseUri))
{
    throw new InvalidOperationException("Configured BaseUrl is invalid.");
}

5. Avoid accidental root resets

If a project wants path appending behavior, developers often remove leading slashes from relative paths before combining.

path = path.TrimStart('/');

That prevents /users from replacing the existing application path.

1. Using Path.Combine() for URLs

Broken example:

using System.IO;

var url = Path.Combine("http://example.com/", "images/photo.jpg");
Console.WriteLine(url);

Why it is wrong:

• Path.Combine() is for file system paths.
• It may use backslashes on Windows.
• It does not follow URL resolution rules.

Use this instead:

var url = new Uri(new Uri("http://example.com/"), "images/photo.jpg");

2. Forgetting the trailing slash on the base URL

Broken expectation:

var baseUri = new Uri("http://example.com/app");
var result = new Uri(baseUri, "images/photo.jpg");
Console.WriteLine(result);

Actual result:

http://example.com/images/photo.jpg

Why:

• app is treated like a file or final segment.
• The relative path replaces it.

Fix:

var baseUri = new Uri("http://example.com/app/");

3. Using a leading slash when you meant to append

Broken expectation:

var baseUri = new Uri("http://example.com/app/");
var result = new Uri(baseUri, "/images/photo.jpg");

Actual result:

http://example.com/images/photo.jpg

Why:

• A leading / means root-relative.

Fix:

var result = new Uri(baseUri, "images/photo.jpg");

4. Manual string concatenation

Broken example:

var url = baseUrl + "/" + path;

Problems:

• can create //
• can miss /
• does not handle URI semantics

Safer approach:

var url = new Uri(new Uri(baseUrl.EndsWith("/") ? baseUrl : baseUrl + "/"), path.TrimStart('/'));

5. Assuming Uri keeps original casing exactly

Hosts are case-insensitive and may appear normalized.

For example:

new Uri("http://MyUrl.com/")

may print as:

http://myurl.com/

This is normal and does not usually change meaning.

Path.Combine() vs Uri

Relative path vs root-relative path

Quick rules

• Use Uri, not Path.Combine(), for URLs.
• Base URL should usually end with / if you want to append under it.
• Relative path should usually not start with / if you want to append.
• A leading / means "start from the site root".
• Use Uri.TryCreate() to validate uncertain input.

Basic pattern

var baseUri = new Uri("https://example.com/app/");
var fullUri = new Uri(baseUri, "images/photo.jpg");

Append safely with a helper

public static string CombineUrl(string baseUrl, string path)
{
    var normalizedBase = baseUrl.EndsWith("/") ? baseUrl : baseUrl + "/";
    var normalizedPath = path.TrimStart('/');
    return new Uri(new Uri(normalizedBase), normalizedPath).ToString();
}

Slash rules

new Uri(new Uri("https://example.com/app/"), "users")
// https://example.com/app/users

new Uri(new Uri("https://example.com/app/"), "/users")
// https://example.com/users

new Uri(new Uri("https://example.com/app"), "users")
// https://example.com/users

Validation

if (Uri.TryCreate(baseUrl, UriKind.Absolute, out var uri))
{
    // valid absolute URL
}

Avoid

Path.Combine(...)
baseUrl + "/" + path

Is there a direct Url.Combine() method in .NET?

Not as a standard built-in method with that exact name. The usual built-in solution is Uri.

Why not use Path.Combine() for URLs?

Because it is designed for file system paths, not web addresses. It may use incorrect separators and does not apply URL rules.

How do I append a path to a base URL in C#?

Use:

new Uri(new Uri(baseUrl), relativePath)

Make sure your slash usage matches the behavior you want.

Why does a leading slash change the result?

In URLs, a leading slash means the path starts at the root of the domain, not relative to the current path.

Why does the trailing slash on the base URL matter?

Without a trailing slash, the last path segment may be treated as a file-like segment and replaced rather than appended to.

Can I use HttpClient.BaseAddress for this?

Yes. HttpClient.BaseAddress uses the same URI resolution behavior when you send relative requests.

How can I avoid double slashes in URLs?

Normalize inputs before combining, for example by ensuring the base ends with / and trimming leading / from the relative path when you want append behavior.

• Uri — The core .NET type for working with URLs and URI parsing.
• Path.Combine — Related because it is often confused with URL joining, but it is only for file paths.
• HttpClient.BaseAddress — Uses the same URI resolution rules in API calls.
• Relative vs absolute URLs — Important for understanding how combination works.
• Query strings — Often added after building the base path correctly.
• URL encoding — Important when path or query values contain spaces or special characters.
• Configuration in .NET — Base URLs are commonly stored in app settings.
• Input validation — Useful for checking whether a configured URL is valid before use.