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:

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();
 result =  Uri(baseUri, );
Console.WriteLine(result);

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

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 =  Uri()
};

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.", (path));

     baseUri =  Uri(baseUrl.EndsWith() ? baseUrl : baseUrl + );
      Uri(baseUri, path.TrimStart()).ToString();
}

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:

Path.Combine() vs Uri

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  Uri( Uri(normalizedBase), normalizedPath).ToString();
}

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.