C# Between, Before and After Extensions

String type

You could benefit from some utility methods for strings in your C# program that will search for substrings between two strings, before a string, or after a string. With the Between, Before and After extension methods, you can reliably search for relative substrings.

This C# article introduces the Between, Before and After extension methods.

Implementation

Note

The first part of the code presents the SubstringExtensions static class. This contains the extension methods Between, Before, and After. The Between method accepts two strings (a and b) and locates each in the source string. Then, after some error checking, it returns the substring between them. The Before method and After method do similar tasks but with only one string parameter.

SubstringExtensions.cs implementation [C#]

static class SubstringExtensions
{
    /// <summary>
    /// Get string value between [first] a and [last] b.
    /// </summary>
    public static string Between(this string value, string a, string b)
    {
	int posA = value.IndexOf(a);
	int posB = value.LastIndexOf(b);
	if (posA == -1)
	{
	    return "";
	}
	if (posB == -1)
	{
	    return "";
	}
	int adjustedPosA = posA + a.Length;
	if (adjustedPosA >= posB)
	{
	    return "";
	}
	return value.Substring(adjustedPosA, posB - adjustedPosA);
    }

    /// <summary>
    /// Get string value after [first] a.
    /// </summary>
    public static string Before(this string value, string a)
    {
	int posA = value.IndexOf(a);
	if (posA == -1)
	{
	    return "";
	}
	return value.Substring(0, posA);
    }

    /// <summary>
    /// Get string value after [last] a.
    /// </summary>
    public static string After(this string value, string a)
    {
	int posA = value.LastIndexOf(a);
	if (posA == -1)
	{
	    return "";
	}
	int adjustedPosA = posA + a.Length;
	if (adjustedPosA >= value.Length)
	{
	    return "";
	}
	return value.Substring(adjustedPosA);
    }
}

Main method [C#]

using System;

class Program
{
    static void Main()
    {
	// Input.
	const string test = "DEFINE:A=TWO";

	// Test Between.
	Console.WriteLine(test.Between("DEFINE:", "="));
	Console.WriteLine(test.Between(":", "="));

	// Test Before.
	Console.WriteLine(test.Before(":"));
	Console.WriteLine(test.Before("="));

	// Test After.
	Console.WriteLine(test.After(":"));
	Console.WriteLine(test.After("DEFINE:"));
	Console.WriteLine(test.After("="));
    }
}

Output

A
A
DEFINE
DEFINE:A
A=TWO
A=TWO
TWO
Main method

Main method description. So how does the example code in the Main entry point work? An input string 'test' is declared. The extensions Between, Before, and After are used on it. You can see that the methods seem to be parsing a programming language syntax ("DEFINE:A=TWO"). The results are printed to the console after the parts are extracted.

Use

What practical use do these extension methods have? Sometimes, a programmer decides a problem domain is best solved with a small language. However, often the requirements are not complex enough to warrant a full grammar and a parser engine. You could use a simple loop along with these extensions to parse a small language.

Question and answer

Do they work? These extension methods are in use in a program I developed, and they seem to work correctly. There may be some errors in the error handling logic in some cases as this has not been studied.

Summary

Here, we provided the implementations for Between, Before, and After extensions on the string type in the C# language. These implementations are not fully compatible with all requirements because they only search for the first or last instance of the parameters. However, they are useful in simplifying parsing engines for simple custom languages.

Algorithms
.NET