Between, before, after

With extension methods, we easily locate Substrings. We search for substrings between two strings, before a string or after a string.

In these extension methods, we return relative substrings. This simplifies certain programs. We implement some logic with IndexOf and LastIndexOf.

Input and output

To begin, we show the input string, and our desired output when we call two arguments. Consider a simple language. We can parse a variable name this way (A).

Input = "DEFINE:A=TWO"

Between("DEFINE:", "=TWO") = "A"

Example

We see the SubstringExtensions static class. This contains the extension methods Between, Before and After. We call these methods in Main.

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);
    }
}
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("="));
    }
}
A
A
DEFINE
DEFINE:A
A=TWO
A=TWO
TWO

Use

Sometimes, a programmer decides a problem is best solved with a small language. However, often the requirements are not complex enough to warrant a full grammar and a parser engine.

We provided the implementations for Between, Before, and After extensions on the string type. These implementations are not fully compatible with all requirements.