Дизъюнктное объединение в C#

Вы можете экспортировать функцию сопоставления псевдошаблонов, как я использую для типа Either в моей библиотеке Sasa . В настоящее время существуют накладные расходы времени выполнения, но в конечном итоге я планирую добавить анализ CIL, чтобы встроить всех делегатов в истинный оператор case.

Вы можете генерировать исключения при попытке доступа к переменным, которые не были инициализированы, то есть, если они были созданы с параметром A, а затем произошла попытка доступа к B или C, это могло вызвать, скажем, исключение UnsupportedOperationException. Однако вам понадобится геттер, чтобы он работал.

Невозможно использовать именно тот синтаксис, который вы использовали, но с большей детализацией и копированием / вставкой легко заставить разрешение перегрузки сделать эту работу за вас:

// this code is ok
var u = new Union("");
if (u.Value(Is.OfType()))
{
    u.Value(Get.ForType());
}

// and this one will not compile
if (u.Value(Is.OfType()))
{
    u.Value(Get.ForType());
}

К настоящему времени должно быть довольно очевидно, как реализовать это:

    public class Union
    {
        private readonly Type type;
        public readonly A a;
        public readonly B b;
        public readonly C c;

        public Union(A a)
        {
            type = typeof(A);
            this.a = a;
        }

        public Union(B b)
        {
            type = typeof(B);
            this.b = b;
        }

        public Union(C c)
        {
            type = typeof(C);
            this.c = c;
        }

        public bool Value(TypeTestSelector _)
        {
            return typeof(A) == type;
        }

        public bool Value(TypeTestSelector _)
        {
            return typeof(B) == type;
        }

        public bool Value(TypeTestSelector _)
        {
            return typeof(C) == type;
        }

        public A Value(GetValueTypeSelector _)
        {
            return a;
        }

        public B Value(GetValueTypeSelector _)
        {
            return b;
        }

        public C Value(GetValueTypeSelector _)
        {
            return c;
        }
    }

    public static class Is
    {
        public static TypeTestSelector OfType()
        {
            return null;
        }
    }

    public class TypeTestSelector
    {
    }

    public static class Get
    {
        public static GetValueTypeSelector ForType()
        {
            return null;
        }
    }

    public class GetValueTypeSelector
    {
    }

Нет никаких проверок для извлечения значения неправильного типа, например:

var u = Union(10);
string s = u.Value(Get.ForType());

Так что вы можете подумать о добавлении необходимых проверок и выбросить исключения в таких случаях.

char foo = 'B';

bool bar = foo is int;

Это приводит к предупреждению, а не к ошибке. Если вы ищете, чтобы ваши функции Is и As были аналогами операторов C #, то вам не следует ограничивать их таким образом.

Я не уверен, что полностью понимаю вашу цель. В языке C объединение - это структура, которая использует одни и те же области памяти для более чем одного поля. Например:

typedef union
{
    float real;
    int scalar;
} floatOrScalar;

Объединение floatOrScalar может использоваться как float, так и int, но оба они занимают одно и то же пространство памяти. Изменение одного из них приводит к изменению другого. Того же можно добиться с помощью struct в C#:

[StructLayout(LayoutKind.Explicit)]
struct FloatOrScalar
{
    [FieldOffset(0)]
    public float Real;
    [FieldOffset(0)]
    public int Scalar;
}

Приведенная выше структура использует 32 бита, а не 64 бита. Это возможно только со структурой. Ваш пример выше - это класс, и, учитывая природу CLR, он не дает никаких гарантий относительно эффективности использования памяти. Если вы изменяете Union от одного типа к другому, вы не обязательно повторно используете память... скорее всего, вы выделяете новый тип на куче и бросаете другой указатель в поле backing object. В отличие от настоящего союза, ваш подход может привести к большему переполнению кучи, чем если бы вы не использовали тип Union.

Вот моя попытка. Он выполняет проверку типов во время компиляции с использованием общих ограничений типа.

class Union {
    public interface AllowedType<T> { };

    internal object val;

    internal System.Type type;
}

static class UnionEx {
    public static T As<U,T>(this U x) where U : Union, Union.AllowedType<T> {
        return x.type == typeof(T) ?(T)x.val : default(T);
    }

    public static void Set<U,T>(this U x, T newval) where U : Union, Union.AllowedType<T> {
        x.val = newval;
        x.type = typeof(T);
    }

    public static bool Is<U,T>(this U x) where U : Union, Union.AllowedType<T> {
        return x.type == typeof(T);
    }
}

class MyType : Union, Union.AllowedType<int>, Union.AllowedType<string> {}

class TestIt
{
    static void Main()
    {
        MyType bla = new MyType();
        bla.Set(234);
        System.Console.WriteLine(bla.As<MyType,int>());
        System.Console.WriteLine(bla.Is<MyType,string>());
        System.Console.WriteLine(bla.Is<MyType,int>());

        bla.Set("test");
        System.Console.WriteLine(bla.As<MyType,string>());
        System.Console.WriteLine(bla.Is<MyType,string>());
        System.Console.WriteLine(bla.Is<MyType,int>());

        // compile time errors!
        // bla.Set('a'); 
        // bla.Is<MyType,char>()
    }
}

Это может потребовать некоторого прихорашивания. В частности, я не мог понять, как избавиться от параметров типа As / Is / Set (разве нет способа указать один параметр типа и позволить C # определять другой?)

Если вы разрешаете множественные типы, вы не можете достичь безопасности типов (если только типы не связаны).

Вы не можете и не сможете добиться никакой безопасности типов, вы можете добиться только безопасности байт-значений, используя FieldOffset.

Гораздо логичнее иметь общий ValueWrapper с T1 ValueA и T2 ValueB, ...

P.S.: говоря о безопасности типов, я имею в виду безопасность типов во время компиляции.

Если вам нужна обертка кода (выполнение бизнес-логики на модификациях, вы можете использовать что-то вроде:

public class Wrapper
{
    public ValueHolder<int> v1 = 5;
    public ValueHolder<byte> v2 = 8;
}

public struct ValueHolder<T>
    where T : struct
{
    private T value;

    public ValueHolder(T value) { this.value = value; }

    public static implicit operator T(ValueHolder<T> valueHolder) { return valueHolder.value; }
    public static implicit operator ValueHolder<T>(T value) { return new ValueHolder<T>(value); }
}

Для простого выхода вы можете использовать (это имеет проблемы с производительностью, но это очень просто):

public class Wrapper
{
    private object v1;
    private object v2;

    public T GetValue1<T>() { if (v1.GetType() != typeof(T)) throw new InvalidCastException(); return (T)v1; }
    public void SetValue1<T>(T value) { v1 = value; }

    public T GetValue2<T>() { if (v2.GetType() != typeof(T)) throw new InvalidCastException(); return (T)v2; }
    public void SetValue2<T>(T value) { v2 = value; }
}

//usage:
Wrapper wrapper = new Wrapper();
wrapper.SetValue1("aaaa");
wrapper.SetValue2(456);

string s = wrapper.GetValue1<string>();
DateTime dt = wrapper.GetValue1<DateTime>();//InvalidCastException