Introduction

In JavaScript, encodeURIComponent() is the standard tool for escaping a single URL component such as a query value or path segment. In C#, the closest equivalent is usually Uri.EscapeDataString, but there are a few related APIs and the right one depends on whether you are encoding a URL component or form data.

The Closest Match in C#

For most cases, this is the direct translation:

1using System;
2
3string value = "c# tips & tricks";
4string encoded = Uri.EscapeDataString(value);
5
6Console.WriteLine(encoded);

The output is percent-encoded text that is safe to insert into a URL component. This is the closest conceptual match to JavaScript encodeURIComponent(), because it is designed for a single component rather than a full URL.

For example, building a query string manually:

1using System;
2
3string baseUrl = "https://example.com/search";
4string query = Uri.EscapeDataString("c# tips & tricks");
5string url = $"{baseUrl}?q={query}";
6
7Console.WriteLine(url);

That produces a URL whose query value is safely escaped without mangling the whole URL structure.

Use It for Components, Not Whole URLs

This distinction is the most important part of the topic. encodeURIComponent() in JavaScript is not for encoding https://example.com/?q=test as one giant string. It is for encoding the individual pieces that may contain unsafe characters.

The same is true in C#. If you pass an entire URL into Uri.EscapeDataString, characters such as :, /, ?, and & can be escaped in ways you did not intend. Build the URL structure first, and escape only the user-provided or dynamic components.

Compare It with Form Encoding APIs

Another common C# option is WebUtility.UrlEncode or HttpUtility.UrlEncode. These are useful, but they are not a perfect semantic match for encodeURIComponent() because they follow HTML form-style encoding conventions.

1using System;
2using System.Net;
3
4string value = "c# tips & tricks";
5string formEncoded = WebUtility.UrlEncode(value);
6
7Console.WriteLine(formEncoded);

One key difference is space handling. Form-style encoding often turns spaces into +, while Uri.EscapeDataString uses %20. Both can be correct depending on context, but they are not interchangeable in every system.

Prefer URL Builders When Possible

For anything more than a toy example, it is cleaner to let a URI builder assemble the final address around already-encoded values.

1using System;
2
3string host = "https://example.com/search";
4string q = Uri.EscapeDataString("c# tips & tricks");
5string page = Uri.EscapeDataString("1");
6
7string url = $"{host}?q={q}&page={page}";
8Console.WriteLine(url);

In ASP.NET or HTTP client code, helper types that build query strings can reduce mistakes even further. The important rule is unchanged: encode each value, not the whole finished URL.

Decode with the Matching Semantics

If you later need to reverse the encoding, use the corresponding decode API for the kind of data you encoded:

1using System;
2
3string encoded = "c%23%20tips%20%26%20tricks";
4string decoded = Uri.UnescapeDataString(encoded);
5
6Console.WriteLine(decoded);

For form-encoded data, use the matching form decoder instead of mixing URL-component and form semantics without thinking about the difference.

Common Pitfalls

The most common mistake is encoding the full URL instead of the component that needs escaping. That often produces broken links because separators such as ? and & get encoded too.

Another pitfall is mixing Uri.EscapeDataString with form-style encoders and then wondering why spaces become %20 in one place and + in another. The difference comes from the encoding model, not from a random runtime bug.

It is also easy to double-encode data. If a string is already escaped and you run it through EscapeDataString again, % characters are encoded a second time and the result becomes incorrect.

Finally, avoid older or broader APIs when you really need component-level encoding. The safest mental model is that Uri.EscapeDataString is for individual dynamic pieces of a URI, which is exactly the role encodeURIComponent() plays in JavaScript.

Summary

• In C#, Uri.EscapeDataString is the closest equivalent to JavaScript encodeURIComponent().
• Use it for a single URL component such as a query value or path segment.
• Do not encode an entire URL as one string unless that is truly what you intend.
• 'WebUtility.UrlEncode is useful for form-style encoding, but it is not identical in behavior.'
• Watch for double-encoding and space-handling differences when mixing APIs.