Типобезопасные размеченные объединения в C #, или: Как ограничить количество реализаций интерфейса?

Во-первых, извините за пространный пост. По сути, мой вопрос таков:

Я пытаюсь воспроизвести следующий размеченный тип объединения F # в C #:

type Relation =
     | LessThan of obj * obj
     | EqualTo of obj * obj
     | GreaterThan of obj * obj

Может ли кто-нибудь предложить более простое решение на основе интерфейса, чем следующее?

interface IRelation // concrete types represent ◊ in the expression "Subject ◊ Object"
{
    object Subject { get; }
    object Object  { get; }
}

struct LessThanRelation    : IRelation { … }
struct EqualToRelation     : IRelation { … }
struct GreaterThanRelation : IRelation { … }

Все мои алгоритмы распознают эти три типа отношений, и только они, поэтому мне нужно предотвратить дальнейшие реализации IRelation третьими сторонами (то есть другими сборками).

_{Сноска: Некоторым может случиться так, что если я получу свой интерфейс и алгоритмы прямо в с точки зрения объектной ориентации / полиморфизма, не имеет значения, что сторонняя реализация вводится в мои методы алгоритма, если интерфейс реализован правильно. Это обоснованная критика. Но давайте просто предположим, что на данный момент я предпочитаю стиль функционального программирования строгой объектной ориентации в этом случае.}

Моя лучшая идея - объявить все вышеперечисленные типы как внутренние (т.е. они никогда не будут видны напрямую посторонним) и создать прокси-тип Relation , который будет единственным видимым типом для третьих лиц: { вернуть новое отношение {значение = новое значение LessThanRelation {…}}; }

 public… ExposedAlgorithm (это IEnumerable  отношения)
{
 // пересылаем развернутые объекты IRelation во внутренний метод алгоритма:
 вернуть InternalAlgorithm (из отношения в отношениях выберите отношение. значение);
}