Как я могу объявить производные классы «оболочки», которые ничего не делают, кроме переименования?

У меня есть два разных типа строк, которые я передаю и использую в своем коде, и они тесно связаны, но их не следует путать друг с другом. Я подумал, что смогу избежать ошибок, если у меня есть два класса, которые являются просто строками, но с разными именами, чтобы сигнатуры методов (и несовместимость типов в целом) обеспечивали семантическое значение двух разных типов строк. В то же время мне не хотелось проводить рефакторинг с something="foo";на something.Value = "foo";в сотне мест.

Первая мысль:

private class FirstKind : string { }
private class SecondKind : string { }

Идея в том, что если у меня есть

void MyMethod(FirstKind varOne, SecondKind varTwo) {...}

, а затем я попытаюсь вызвать его с помощью MyMethod(secondKindVar, firstKindVar);, я получу ошибку компилятора.

Стена, которую я ударил: строказапечатана.

Вторая мысль: создать универсальный класс KindOf, который бы ничего не делал, кроме как принимал и выдавал бы значение с помощью операторов неявного преобразования. Например:

private class KindOf<T>
{
    public T Value { get; set; }
    public KindOf() { Value = default(T); }
    public KindOf(T val) { Value = val; }
    public static implicit operator T(KindOf<T> kindOf) { return kindOf.Value; }
    public static implicit operator KindOf<T>(T value) { return new KindOf<T>(value); }
}

Таким образом, я мог бы сделать что-то вроде этого:

private class FirstKind : KindOf<string> { }
private class SecondKind : KindOf<string> { }

Стена, в которую я попал: ничего из класса KindOfне наследуется: в производных типах не существует ни конструкторов, ни операторов, это означает, что я должен повторно реализовать практически весь базовый класс в производных классах. Копирование кода. Фу.

Так что я чувствую, что упускаю здесь что-то основное, и, возможно, я запутался. Есть идеи, что я пытаюсь сделать?