Checking for Substring Presence within a String Array in C#

Identifying Substrings in a String Array

This tutorial explains how to efficiently determine if a given string contains any of the substrings present within a string array in C#. This is a common task in text processing, data validation, and search functionality. We’ll explore several approaches, ranging from simple iteration to using LINQ for concise and readable code.

The Problem

Imagine you have a main string and a list of potential substrings. The goal is to check if any of the substrings exist within the main string. For instance, given the string "This is a sample text" and the array {"sample", "another", "text"}, you want to confirm if "sample" or "text" exists within the main string.

Method 1: Iterative Approach

The most straightforward method involves iterating through the string array and, for each substring, using the string.Contains() method to check if the main string contains it.

using System;

public class SubstringChecker
{
    public static bool ContainsAnySubstring(string mainString, string[] substrings)
    {
        foreach (string substring in substrings)
        {
            if (mainString.Contains(substring))
            {
                return true; // Found a substring, no need to continue
            }
        }
        return false; // No substrings found
    }

    public static void Main(string[] args)
    {
        string mainString = "This is a sample text";
        string[] substrings = { "sample", "another", "text" };

        bool containsAny = ContainsAnySubstring(mainString, substrings);

        Console.WriteLine($"The main string contains any of the substrings: {containsAny}"); // Output: True
    }
}

This approach is easy to understand and implement. However, for larger arrays, it might not be the most performant solution, as it iterates through the entire array even after finding a match.

Method 2: Using LINQ’s Any()

LINQ (Language Integrated Query) provides a more concise and readable way to achieve the same result. The Any() method allows you to check if any element in a sequence satisfies a given condition.

using System;
using System.Linq;

public class SubstringChecker
{
    public static bool ContainsAnySubstringLinq(string mainString, string[] substrings)
    {
        return substrings.Any(mainString.Contains);
    }

    public static void Main(string[] args)
    {
        string mainString = "This is a sample text";
        string[] substrings = { "sample", "another", "text" };

        bool containsAny = ContainsAnySubstringLinq(mainString, substrings);

        Console.WriteLine($"The main string contains any of the substrings: {containsAny}"); // Output: True
    }
}

This code snippet is significantly shorter and more expressive. substrings.Any(mainString.Contains) effectively checks if any element in the substrings array satisfies the condition mainString.Contains(element). LINQ’s Any() method also has the benefit of potentially short-circuiting the evaluation (stopping the iteration) as soon as a match is found, which can improve performance in some cases.

Method 3: Checking for All Substrings

If your requirement is to determine if the main string contains all of the substrings in the array, you can use the All() method from LINQ.

using System;
using System.Linq;

public class SubstringChecker
{
    public static bool ContainsAllSubstrings(string mainString, string[] substrings)
    {
        return substrings.All(mainString.Contains);
    }

    public static void Main(string[] args)
    {
        string mainString = "This is a sample text";
        string[] substrings = { "sample", "text" };

        bool containsAll = ContainsAllSubstrings(mainString, substrings);

        Console.WriteLine($"The main string contains all of the substrings: {containsAll}"); // Output: True

        string[] substrings2 = { "sample", "another" };
        bool containsAll2 = ContainsAllSubstrings(mainString, substrings2);
        Console.WriteLine($"The main string contains all of the substrings: {containsAll2}"); // Output: False
    }
}

Choosing the Right Method

• For simple cases or when readability is paramount, the iterative approach is a good choice.
• When conciseness and functional programming style are preferred, LINQ’s Any() or All() methods offer elegant solutions.
• Consider performance implications when dealing with very large arrays. In most cases, the difference will be negligible, but benchmarking can help determine the optimal approach for your specific use case.