C# String Array Contains Wildcard [With Examples]

In this tutorial, we will see in detail about, “C# String Array Contains Wildcard” with real examples.

Table of Contents

C# String Array Contains Wildcard

When working with arrays in C#, it’s often necessary to check whether a given array contains a particular element. The Array class in C# provides several useful methods like Array.Exists() to perform these checks. However, what if you want to find elements based on a pattern or wildcard? Unfortunately, the standard library doesn’t provide a built-in method to do this.

Let us see, how to achieve this.

Why Would You Need Wildcard Matching?

Let’s consider a simple scenario: you have an array of names and you want to find out if the array contains any names that start with the letter “J”. With standard C# methods, you’d have to loop through the array and manually check the start of each string, which is quite cumbersome.

Wouldn’t it be great if you could simply specify a wildcard pattern like “J*” and get the answer immediately?

The Basics: Using Regular Expressions

To implement wildcard matching, we can use regular expressions (regex). In C#, the System.Text.RegularExpressions namespace provides classes to work with regular expressions.

Here is a simple example that demonstrates how you can use regex to check if any string in the array matches a pattern:

using System;
using System.Text.RegularExpressions;

public class Program
{
    public static void Main()
    {
        string[] names = { "John", "Emily", "Jack", "Sophia" };
        string pattern = "^J.*"; // Starts with J

        bool isMatch = false;
        foreach (string name in names)
        {
            if (Regex.IsMatch(name, pattern))
            {
                isMatch = true;
                break;
            }
        }

        Console.WriteLine(isMatch ? "Pattern found" : "Pattern not found");
    }
}

In this example, the pattern ^J.* checks if a string starts with the letter “J”. The Regex.IsMatch() method returns true if a string matches the pattern. We break the loop as soon as we find a match.

Once you run the code, you can see the output below:

Creating an Extension Method

For convenience, let’s create an extension method for string arrays that lets us use wildcards directly. This way, you don’t have to loop through the array every time you want to check for a pattern.

Here is how you can do it:

using System;
using System.Text.RegularExpressions;

public static class StringArrayExtensions
{
    public static bool ContainsWildcard(this string[] array, string pattern)
    {
        foreach (string element in array)
        {
            if (Regex.IsMatch(element, pattern))
            {
                return true;
            }
        }

        return false;
    }
}

Now you can use this extension method like this:

using System;

public class Program
{
    public static void Main()
    {
        string[] usaNames = { "John", "Emily", "Jack", "Sophia", "Michael", "Emma" };
        string pattern = "^J.*"; // Starts with J

        bool isMatch = usaNames.ContainsWildcard(pattern);
        
        Console.WriteLine(isMatch ? "Pattern found" : "Pattern not found");
    }
}

Considerations

Performance: Be cautious when using regex with large arrays or complex patterns, as it can be computationally expensive.
Specificity: Make sure your pattern is specific enough to match what you intend to. For example, the pattern ".*" would match anything, which might not be what you want.
Case Sensitivity: By default, regex matching in C# is case-sensitive. If you want case-insensitive matching, you can modify the regex pattern or provide RegexOptions like RegexOptions.IgnoreCase.

Conclusion

In this tutorial, we’ve seen how to extend the capabilities of C# string arrays to support wildcard matching using regular expressions. We’ve covered a basic example and even wrapped the functionality into a convenient extension method. I hope you must like “c# string array contains wildcard“.