Count Character or Substring Occurrences in a String in C#

By the end of this page, you will understand how to count the number of times a character or substring appears in a string in C#. You will learn simple approaches using Replace, loops, LINQ, and substring searching, plus when each option is appropriate.

In C#, counting occurrences in a string means checking how many times a specific value appears inside a larger piece of text.

This value can be:

• a single character, such as '/'
• a substring, such as "cat"

This matters because string processing is common in real programs. Developers often need to:

• count separators in file paths or URLs
• count words or tokens in input text
• validate data formats
• inspect logs or API responses
• parse structured text

A string in C# is immutable, which means methods like Replace do not change the original string. Instead, they create a new string. That is why this technique works:

int count = source.Length - source.Replace("/", "").Length;

The code removes all / characters, compares the old and new lengths, and uses the difference as the count.

This is clever and short, but it is not always the clearest or most efficient option, especially for longer strings or repeated operations. For single-character counting, a loop or LINQ is often easier to read. For substring counting, searching with IndexOf in a loop is usually a better general solution.

The main idea is:

• Character counting: inspect each character and compare it
• Substring counting: search for the target repeatedly until no more matches are found

Imagine a string as a long row of tiles.

• If you want to count a character, you walk across the tiles one by one and count every tile that matches.
• If you want to count a substring, you slide a small pattern across the row and check where it fits.

Another way to think about Replace is this:

• Start with a rope of a certain length
• Cut out every /
• Measure the rope again
• The missing length tells you how many characters were removed

That works well for simple counting, but if you want more control, walking through the string directly is often easier to understand.

1. Count a single character with a loop

string source = "/once/upon/a/time/";
int count = 0;

foreach (char c in source)
{
    if (c == '/')
    {
        count++;
    }
}

Console.WriteLine(count); // 4

This is beginner-friendly and very readable:

• loop through each character
• compare it to '/'
• increase the counter when it matches

2. Count a single character with LINQ

using System.Linq;

string source = "/once/upon/a/time/";
int count = source.Count(c => c == '/');

Console.WriteLine(count); // 4

This is short and expressive. It works well when you already use LINQ.

3. Count a substring with Replace

string haystack = "abc--def--ghi--";
string needle = "--";

int count = (haystack.Length - haystack.Replace(needle, ).Length) / needle.Length;

Console.WriteLine(count); 

Consider this example:

string text = "/a/b/c/";
int count = 0;

foreach (char c in text)
{
    if (c == '/')
    {
        count++;
    }
}

Step by step:

1. text is "/a/b/c/"
2. count starts at 0
3. The loop reads the first character: '/'
   • it matches
   • count becomes 1
4. The loop reads 'a'
   • no match
   • count stays 1
5. The loop reads '/'
   • match
   • count becomes 2
6. The loop reads

Counting characters and substrings appears in many practical tasks:

• URL parsing: count / characters to estimate path depth
• CSV or log processing: count separators like commas, tabs, or pipes
• Validation: ensure a format contains the expected number of delimiters
• Text analysis: count words, tags, mentions, or repeated markers
• Configuration parsing: count = or : characters in key-value data
• Chat and moderation tools: count forbidden words or repeated patterns
• File handling: count directory separators in paths

Example: validating a simple date format like yyyy-mm-dd

string input = "2026-06-10";
int dashCount = input.Count(c => c == '-');

if (dashCount != 2)
{
    Console.WriteLine("Invalid date format");
}

Example: counting occurrences of an error label in logs

string log = "INFO... ERROR... INFO... ERROR...";
string token = "ERROR";

int count = 0;
int index = ;

 ((index = log.IndexOf(token, index)) != )
{
    count++;
    index += token.Length;
}

Console.WriteLine(count);

In real codebases, developers usually choose the approach based on what they need:

For a single character

A loop or LINQ is common:

int slashCount = path.Count(c => c == '/');

This is readable and easy to maintain.

For a substring

IndexOf in a loop is a common pattern because it is explicit and flexible:

public static int CountOccurrences(string text, string value)
{
    if (string.IsNullOrEmpty(text) || string.IsNullOrEmpty(value))
    {
        return 0;
    }

    int count = 0;
    int index = 0;

    while ((index = text.IndexOf(value, index, StringComparison.Ordinal)) != -1)
    {
        count++;
        index += value.Length;
    }

    return count;
}

Common patterns in production code

1. Forgetting the difference between char and string

A character uses single quotes:

'/'

A string uses double quotes:

"/"

Broken example:

if (c == "/") // wrong
{
}

Correct:

if (c == '/')
{
}

2. Dividing incorrectly when using Replace for substrings

If the substring has length greater than 1, you must divide by needle.Length.

Broken:

string text = "abc--def--";
string needle = "--";
int count = text.Length - text.Replace(needle, "").Length; // wrong result

Correct:

Count a single character

int count = text.Count(c => c == '/');

or

int count = 0;
foreach (char c in text)
{
    if (c == '/') count++;
}

Count a substring with Replace

int count = (text.Length - text.Replace(value, "").Length) / value.Length;

Count a substring with IndexOf

int count = 0;
int index = 0;
while ((index = text.IndexOf(value, index, StringComparison.Ordinal)) != -1)
{
    count++;
    index += value.Length;
}

Count overlapping substrings

int count = ;
 index = ;
 ((index = text.IndexOf(, index, StringComparison.Ordinal)) != )
{
    count++;
    index += ;
}

What is the easiest way to count a character in a string in C#?

For a single character, a foreach loop or text.Count(c => c == '/') is usually the easiest to read.

Is using Replace to count occurrences valid in C#?

Yes. It works for many cases, especially simple one-off tasks. However, it creates a new string, so it is not always the clearest or most efficient choice.

How do I count a substring instead of a single character?

Use IndexOf in a loop or the Replace length-difference method divided by the substring length.

How do I count overlapping substring matches in C#?

Use IndexOf in a loop and increase the index by 1 after each match instead of needle.Length.

Should I use LINQ to count characters?

LINQ is a good option when you want concise code and are already using LINQ. A loop is still perfectly fine and often easier for beginners.

Does string counting handle case sensitivity automatically?

No. If case sensitivity matters, use methods like IndexOf with StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase.

string

Understanding how strings work in C# is essential because counting happens inside string data.

char

Counting a single character is simpler when you understand the char type.

foreach loop

A foreach loop is one of the clearest ways to inspect each character in a string.

LINQ Count

LINQ provides a concise way to count items that match a condition.

IndexOf

IndexOf is a core method for searching text and is very useful for counting substrings.

Replace

Replace helps with quick counting tricks and teaches string immutability.

String immutability

Knowing that strings cannot be changed in place explains why methods like Replace return new strings.

Regular expressions

Regex is related because it can count text patterns when fixed-string searching is not enough.