Дискриминационный союз в С#

[Примечание: этот вопрос имел исходное название " объединение стилей C (ish) в С#" но, как сказал мне отчет Джеффа, видимо, эта структура называется "дискриминационным союзом".

Извините многословие этого вопроса.

Есть несколько аналогичных звуковых вопросов для моего уже в SO, но они, похоже, концентрируются на преимуществах экономии памяти в союзе или использовании их для взаимодействия. Вот пример такого вопроса.

Мое желание иметь тип типа объединения несколько отличается.

Я пишу код в данный момент, который генерирует объекты, которые немного похожи на это

public class ValueWrapper
{
    public DateTime ValueCreationDate;
    // ... other meta data about the value

    public object ValueA;
    public object ValueB;
}

Довольно сложный материал, я думаю, вы согласитесь. Дело в том, что ValueA может быть только нескольких определенных типов (скажем, string, int и Foo (который является классом), а ValueB может быть другим небольшим набором типов. t нравится рассматривать эти значения как объекты (я хочу, чтобы теплое плотное чувство кодирования с некоторой степенью безопасности).

Итак, я подумал о том, чтобы написать тривиальный маленький класс-оболочку, чтобы выразить тот факт, что ValueA логически является ссылкой на конкретный тип. Я назвал класс Union, потому что то, что я пытаюсь достичь, напомнило мне концепцию объединения в C.

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

    public A A{get {return a;}}
    public B B{get {return b;}}
    public C C{get {return 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;
    }

    /// <summary>
    /// Returns true if the union contains a value of type T
    /// </summary>
    /// <remarks>The type of T must exactly match the type</remarks>
    public bool Is<T>()
    {
        return typeof(T) == type;
    }

    /// <summary>
    /// Returns the union value cast to the given type.
    /// </summary>
    /// <remarks>If the type of T does not exactly match either X or Y, then the value <c>default(T)</c> is returned.</remarks>
    public T As<T>()
    {
        if(Is<A>())
        {
            return (T)(object)a;    // Is this boxing and unboxing unavoidable if I want the union to hold value types and reference types? 
            //return (T)x;          // This will not compile: Error = "Cannot cast expression of type 'X' to 'T'."
        }

        if(Is<B>())
        {
            return (T)(object)b; 
        }

        if(Is<C>())
        {
            return (T)(object)c; 
        }

        return default(T);
    }
}

Использование этого класса ValueWrapper теперь выглядит следующим образом

public class ValueWrapper2
{
    public DateTime ValueCreationDate;
    public  Union<int, string, Foo> ValueA;
    public  Union<double, Bar, Foo> ValueB;
}

что-то вроде того, чего я хотел достичь, но у меня отсутствует один довольно важный элемент - это проверка принудительного типа компилятора при вызове функций Is и As, как показано в следующем коде

    public void DoSomething()
    {
        if(ValueA.Is<string>())
        {
            var s = ValueA.As<string>();
            // .... do somethng
        }

        if(ValueA.Is<char>()) // I would really like this to be a compile error
        {
            char c = ValueA.As<char>();
        }
    }

IMO Недействительно задавать ValueA, если это char, так как в его определении явно сказано, что это не так - это ошибка программирования, и я хотел бы, чтобы компилятор подхватил это. [И если я смогу получить это правильно, то (надеюсь), я тоже получу intellisense - что было бы благом.]

Чтобы достичь этого, я хотел бы сказать компилятору, что тип T может быть одним из A, B или C

    public bool Is<T>() where T : A 
                           or T : B // Yes I know this is not legal!
                           or T : C 
    {
        return typeof(T) == type;
    }

Кто-нибудь знает, возможно ли то, что я хочу достичь? Или я просто глупый для написания этого класса в первую очередь?

Спасибо заранее.

ОТВЕТЫ

Ответ 1

Мне не нравятся решения по проверке типов и типу, приведенные выше, поэтому здесь 100% -ный тип безопасного объединения, который будет генерировать ошибки компиляции, если вы попытаетесь использовать неправильный тип данных:

using System;

namespace Juliet
{
    class Program
    {
        static void Main(string[] args)
        {
            Union3<int, char, string>[] unions = new Union3<int,char,string>[]
                {
                    new Union3<int, char, string>.Case1(5),
                    new Union3<int, char, string>.Case2('x'),
                    new Union3<int, char, string>.Case3("Juliet")
                };

            foreach (Union3<int, char, string> union in unions)
            {
                string value = union.Match(
                    num => num.ToString(),
                    character => new string(new char[] { character }),
                    word => word);
                Console.WriteLine("Matched union with value '{0}'", value);
            }

            Console.ReadLine();
        }
    }

    public abstract class Union3<A, B, C>
    {
        public abstract T Match<T>(Func<A, T> f, Func<B, T> g, Func<C, T> h);
        // private ctor ensures no external classes can inherit
        private Union3() { } 

        public sealed class Case1 : Union3<A, B, C>
        {
            public readonly A Item;
            public Case1(A item) : base() { this.Item = item; }
            public override T Match<T>(Func<A, T> f, Func<B, T> g, Func<C, T> h)
            {
                return f(Item);
            }
        }

        public sealed class Case2 : Union3<A, B, C>
        {
            public readonly B Item;
            public Case2(B item) { this.Item = item; }
            public override T Match<T>(Func<A, T> f, Func<B, T> g, Func<C, T> h)
            {
                return g(Item);
            }
        }

        public sealed class Case3 : Union3<A, B, C>
        {
            public readonly C Item;
            public Case3(C item) { this.Item = item; }
            public override T Match<T>(Func<A, T> f, Func<B, T> g, Func<C, T> h)
            {
                return h(Item);
            }
        }
    }
}

Ответ 2

Мне нравится направление принятого решения, но оно недостаточно масштабируется для объединений из более чем трех элементов (например, для объединения из 9 элементов потребуется 9 определений классов).

Вот еще один подход, который также на 100% безопасен во время компиляции, но его легко развить до больших союзов.

public class UnionBase<A>
{
    dynamic value;

    public UnionBase(A a) { value = a; } 
    protected UnionBase(object x) { value = x; }

    protected T InternalMatch<T>(params Delegate[] ds)
    {
        var vt = value.GetType();    
        foreach (var d in ds)
        {
            var mi = d.Method;

            // These are always true if InternalMatch is used correctly.
            Debug.Assert(mi.GetParameters().Length == 1);
            Debug.Assert(typeof(T).IsAssignableFrom(mi.ReturnType));

            var pt = mi.GetParameters()[0].ParameterType;
            if (pt.IsAssignableFrom(vt))
                return (T)mi.Invoke(null, new object[] { value });
        }
        throw new Exception("No appropriate matching function was provided");
    }

    public T Match<T>(Func<A, T> fa) { return InternalMatch<T>(fa); }
}

public class Union<A, B> : UnionBase<A>
{
    public Union(A a) : base(a) { }
    public Union(B b) : base(b) { }
    protected Union(object x) : base(x) { }
    public T Match<T>(Func<A, T> fa, Func<B, T> fb) { return InternalMatch<T>(fa, fb); }
}

public class Union<A, B, C> : Union<A, B>
{
    public Union(A a) : base(a) { }
    public Union(B b) : base(b) { }
    public Union(C c) : base(c) { }
    protected Union(object x) : base(x) { }
    public T Match<T>(Func<A, T> fa, Func<B, T> fb, Func<C, T> fc) { return InternalMatch<T>(fa, fb, fc); }
}

public class Union<A, B, C, D> : Union<A, B, C>
{
    public Union(A a) : base(a) { }
    public Union(B b) : base(b) { }
    public Union(C c) : base(c) { }
    public Union(D d) : base(d) { }
    protected Union(object x) : base(x) { }
    public T Match<T>(Func<A, T> fa, Func<B, T> fb, Func<C, T> fc, Func<D, T> fd) { return InternalMatch<T>(fa, fb, fc, fd); }
}

public class Union<A, B, C, D, E> : Union<A, B, C, D>
{
    public Union(A a) : base(a) { }
    public Union(B b) : base(b) { }
    public Union(C c) : base(c) { }
    public Union(D d) : base(d) { }
    public Union(E e) : base(e) { }
    protected Union(object x) : base(x) { }
    public T Match<T>(Func<A, T> fa, Func<B, T> fb, Func<C, T> fc, Func<D, T> fd, Func<E, T> fe) { return InternalMatch<T>(fa, fb, fc, fd, fe); }
}

public class DiscriminatedUnionTest : IExample
{
    public Union<int, bool, string, int[]> MakeUnion(int n)
    {
        return new Union<int, bool, string, int[]>(n);
    }

    public Union<int, bool, string, int[]> MakeUnion(bool b)
    {
        return new Union<int, bool, string, int[]>(b);
    }

    public Union<int, bool, string, int[]> MakeUnion(string s)
    {
        return new Union<int, bool, string, int[]>(s);
    }

    public Union<int, bool, string, int[]> MakeUnion(params int[] xs)
    {
        return new Union<int, bool, string, int[]>(xs);
    }

    public void Print(Union<int, bool, string, int[]> union)
    {
        var text = union.Match(
            n => "This is an int " + n.ToString(),
            b => "This is a boolean " + b.ToString(),
            s => "This is a string" + s,
            xs => "This is an array of ints " + String.Join(", ", xs));
        Console.WriteLine(text);
    }

    public void Run()
    {
        Print(MakeUnion(1));
        Print(MakeUnion(true));
        Print(MakeUnion("forty-two"));
        Print(MakeUnion(0, 1, 1, 2, 3, 5, 8));
    }
}

Ответ 3

Я написал несколько сообщений в блоге на эту тему, которые могут быть полезны:

Допустим, у вас есть сценарий корзины покупок с тремя состояниями: "Пусто", "Активно" и "Оплачено", каждое с разным поведением.

  • Вы создаете интерфейс ICartState который ICartState все состояния (и это может быть просто пустой интерфейс маркера)
  • Вы создаете три класса, которые реализуют этот интерфейс. (Классы не должны быть в отношениях наследования)
  • Интерфейс содержит метод "сгиба", посредством которого вы передаете лямбду для каждого состояния или случая, который вам нужно обработать.

Вы можете использовать среду выполнения F # из С#, но в качестве более легкой альтернативы я написал небольшой шаблон T4 для генерации кода, подобного этому.

Вот интерфейс:

partial interface ICartState
{
  ICartState Transition(
        Func<CartStateEmpty, ICartState> cartStateEmpty,
        Func<CartStateActive, ICartState> cartStateActive,
        Func<CartStatePaid, ICartState> cartStatePaid
        );
}

А вот и реализация:

class CartStateEmpty : ICartState
{
  ICartState ICartState.Transition(
        Func<CartStateEmpty, ICartState> cartStateEmpty,
        Func<CartStateActive, ICartState> cartStateActive,
        Func<CartStatePaid, ICartState> cartStatePaid
        )
  {
        // I'm the empty state, so invoke cartStateEmpty 
      return cartStateEmpty(this);
  }
}

class CartStateActive : ICartState
{
  ICartState ICartState.Transition(
        Func<CartStateEmpty, ICartState> cartStateEmpty,
        Func<CartStateActive, ICartState> cartStateActive,
        Func<CartStatePaid, ICartState> cartStatePaid
        )
  {
        // I'm the active state, so invoke cartStateActive
      return cartStateActive(this);
  }
}

class CartStatePaid : ICartState
{
  ICartState ICartState.Transition(
        Func<CartStateEmpty, ICartState> cartStateEmpty,
        Func<CartStateActive, ICartState> cartStateActive,
        Func<CartStatePaid, ICartState> cartStatePaid
        )
  {
        // I'm the paid state, so invoke cartStatePaid
      return cartStatePaid(this);
  }
}

Теперь допустим, что вы расширяете CartStateEmpty и CartStateActive с помощью метода AddItem который не реализован в CartStatePaid.

А также допустим, что у CartStateActive есть метод Pay, которого нет в других штатах.

Тогда вот некоторый код, который показывает, что он используется - добавление двух товаров и затем оплата за корзину:

public ICartState AddProduct(ICartState currentState, Product product)
{
    return currentState.Transition(
        cartStateEmpty => cartStateEmpty.AddItem(product),
        cartStateActive => cartStateActive.AddItem(product),
        cartStatePaid => cartStatePaid // not allowed in this case
        );

}

public void Example()
{
    var currentState = new CartStateEmpty() as ICartState;

    //add some products 
    currentState = AddProduct(currentState, Product.ProductX);
    currentState = AddProduct(currentState, Product.ProductY);

    //pay 
    const decimal paidAmount = 12.34m;
    currentState = currentState.Transition(
        cartStateEmpty => cartStateEmpty,  // not allowed in this case
        cartStateActive => cartStateActive.Pay(paidAmount),
        cartStatePaid => cartStatePaid     // not allowed in this case
        );
}

Обратите внимание, что этот код полностью безопасен для типов - нигде нет приведения или условных выражений, и, скажем, ошибки компилятора, если вы пытаетесь заплатить за пустую корзину.

Ответ 4

Я написал библиотеку для этого в https://github.com/mcintyre321/OneOf

Установить пакет OneOf

Он имеет общие типы в нем для выполнения DU, например. OneOf<T0, T1> полностью OneOf<T0, ..., T9>. Каждый из них имеет оператор .Match и a .Switch, который вы можете использовать для безопасного типизированного поведения компилятора, например:

`` `

OneOf<string, ColorName, Color> backgroundColor = getBackground(); 
Color c = backgroundColor.Match(
    str => CssHelper.GetColorFromString(str),
    name => new Color(name),
    col => col
);

`` `

Ответ 5

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

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

Объединение floatOrScalar может использоваться как float или int, но они оба потребляют одно и то же пространство памяти. Изменение одного изменяет другое. Вы можете добиться того же, что и в структуре на С#:

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

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

Ответ 6

char foo = 'B';

bool bar = foo is int;

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

Ответ 7

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

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

Было бы гораздо разумнее иметь общий ValueWrapper<T1, T2> с 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

Ответ 8

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

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 (не существует способа указать один параметр типа и позволить С# отобразить другое?)

Ответ 9

Итак, я неоднократно сталкивался с этой проблемой, и я просто придумал решение, которое получает синтаксис, который я хочу (за счет некоторого уродства в реализации типа Union).

Напомним: мы хотим использовать этот вид на сайте вызова.

Union<int, string> u;

u = 1492;
int yearColumbusDiscoveredAmerica = u;

u = "hello world";
string traditionalGreeting = u;

var answers = new SortedList<string, Union<int, string, DateTime>>();
answers["life, the universe, and everything"] = 42;
answers["D-Day"] = new DateTime(1944, 6, 6);
answers["C#"] = "is awesome";

Мы хотим, чтобы приведенные ниже примеры не скомпилировались, поэтому мы получаем модификацию безопасности типов.

DateTime dateTimeColumbusDiscoveredAmerica = u;
Foo fooInstance = u;

Для дополнительного кредита пусть также не занимает больше места, чем нужно.

Со всем сказанным здесь моя реализация для двух типичных параметров типа. Реализация для трех, четырех и т.д. Параметров типа является прямой.

public abstract class Union<T1, T2>
{
    public abstract int TypeSlot
    {
        get;
    }

    public virtual T1 AsT1()
    {
        throw new TypeAccessException(string.Format(
            "Cannot treat this instance as a {0} instance.", typeof(T1).Name));
    }

    public virtual T2 AsT2()
    {
        throw new TypeAccessException(string.Format(
            "Cannot treat this instance as a {0} instance.", typeof(T2).Name));
    }

    public static implicit operator Union<T1, T2>(T1 data)
    {
        return new FromT1(data);
    }

    public static implicit operator Union<T1, T2>(T2 data)
    {
        return new FromT2(data);
    }

    public static implicit operator Union<T1, T2>(Tuple<T1, T2> data)
    {
        return new FromTuple(data);
    }

    public static implicit operator T1(Union<T1, T2> source)
    {
        return source.AsT1();
    }

    public static implicit operator T2(Union<T1, T2> source)
    {
        return source.AsT2();
    }

    private class FromT1 : Union<T1, T2>
    {
        private readonly T1 data;

        public FromT1(T1 data)
        {
            this.data = data;
        }

        public override int TypeSlot 
        { 
            get { return 1; } 
        }

        public override T1 AsT1()
        { 
            return this.data;
        }

        public override string ToString()
        {
            return this.data.ToString();
        }

        public override int GetHashCode()
        {
            return this.data.GetHashCode();
        }
    }

    private class FromT2 : Union<T1, T2>
    {
        private readonly T2 data;

        public FromT2(T2 data)
        {
            this.data = data;
        }

        public override int TypeSlot 
        { 
            get { return 2; } 
        }

        public override T2 AsT2()
        { 
            return this.data;
        }

        public override string ToString()
        {
            return this.data.ToString();
        }

        public override int GetHashCode()
        {
            return this.data.GetHashCode();
        }
    }

    private class FromTuple : Union<T1, T2>
    {
        private readonly Tuple<T1, T2> data;

        public FromTuple(Tuple<T1, T2> data)
        {
            this.data = data;
        }

        public override int TypeSlot 
        { 
            get { return 0; } 
        }

        public override T1 AsT1()
        { 
            return this.data.Item1;
        }

        public override T2 AsT2()
        { 
            return this.data.Item2;
        }

        public override string ToString()
        {
            return this.data.ToString();
        }

        public override int GetHashCode()
        {
            return this.data.GetHashCode();
        }
    }
}

Ответ 10

И моя попытка минимального, но расширяемого решения с использованием вложения Union/Либо типа. Также использование параметров по умолчанию в методе совпадения позволяет, естественно, сценарий "Либо X или по умолчанию".

using System;
using System.Reflection;
using NUnit.Framework;

namespace Playground
{
    [TestFixture]
    public class EitherTests
    {
        [Test]
        public void Test_Either_of_Property_or_FieldInfo()
        {
            var some = new Some(false);
            var field = some.GetType().GetField("X");
            var property = some.GetType().GetProperty("Y");
            Assert.NotNull(field);
            Assert.NotNull(property);

            var info = Either<PropertyInfo, FieldInfo>.Of(field);
            var infoType = info.Match(p => p.PropertyType, f => f.FieldType);

            Assert.That(infoType, Is.EqualTo(typeof(bool)));
        }

        [Test]
        public void Either_of_three_cases_using_nesting()
        {
            var some = new Some(false);
            var field = some.GetType().GetField("X");
            var parameter = some.GetType().GetConstructors()[0].GetParameters()[0];
            Assert.NotNull(field);
            Assert.NotNull(parameter);

            var info = Either<ParameterInfo, Either<PropertyInfo, FieldInfo>>.Of(parameter);
            var name = info.Match(_ => _.Name, _ => _.Name, _ => _.Name);

            Assert.That(name, Is.EqualTo("a"));
        }

        public class Some
        {
            public bool X;
            public string Y { get; set; }

            public Some(bool a)
            {
                X = a;
            }
        }
    }

    public static class Either
    {
        public static T Match<A, B, C, T>(
            this Either<A, Either<B, C>> source,
            Func<A, T> a = null, Func<B, T> b = null, Func<C, T> c = null)
        {
            return source.Match(a, bc => bc.Match(b, c));
        }
    }

    public abstract class Either<A, B>
    {
        public static Either<A, B> Of(A a)
        {
            return new CaseA(a);
        }

        public static Either<A, B> Of(B b)
        {
            return new CaseB(b);
        }

        public abstract T Match<T>(Func<A, T> a = null, Func<B, T> b = null);

        private sealed class CaseA : Either<A, B>
        {
            private readonly A _item;
            public CaseA(A item) { _item = item; }

            public override T Match<T>(Func<A, T> a = null, Func<B, T> b = null)
            {
                return a == null ? default(T) : a(_item);
            }
        }

        private sealed class CaseB : Either<A, B>
        {
            private readonly B _item;
            public CaseB(B item) { _item = item; }

            public override T Match<T>(Func<A, T> a = null, Func<B, T> b = null)
            {
                return b == null ? default(T) : b(_item);
            }
        }
    }
}

Ответ 11

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

Ответ 12

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

Ответ 13

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


// 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());

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

Ответ 14

Я использую собственный тип Union.

Рассмотрим пример, чтобы сделать его более понятным.

Представьте, что у нас есть класс Contact:

public class Contact 
{
    public string Name { get; set; }
    public string EmailAddress { get; set; }
    public string PostalAdrress { get; set; }
}

Все они определены как простые строки, но действительно ли они просто строки? Конечно нет. Имя может состоять из имени и фамилии. Или электронная почта просто набор символов? Я знаю, что по крайней мере он должен содержать @, и это обязательно.

Позвольте улучшить нашу модель домена

public class PersonalName 
{
    public PersonalName(string firstName, string lastName) { ... }
    public string Name() { return _fistName + " " _lastName; }
}

public class EmailAddress 
{
    public EmailAddress(string email) { ... } 
}

public class PostalAdrress 
{
    public PostalAdrress(string address, string city, int zip) { ... } 
}

В этом классе будут выполняться валидации во время создания, и в итоге у нас будут действующие модели. В классе Consturctor в PersonaName требуется имя FirstName и LastName одновременно. Это означает, что после создания он не может иметь недопустимое состояние.

И класс контакта соответственно

public class Contact 
{
    public PersonalName Name { get; set; }
    public EmailAdress EmailAddress { get; set; }
    public PostalAddress PostalAddress { get; set; }
}

В этом случае мы имеем ту же проблему, объект класса Contact может находиться в недействительном состоянии. Я имею в виду, что он может иметь EmailAddress, но не имеет имени

var contact = new Contact { EmailAddress = new EmailAddress("foo@bar.com") };

Позвольте исправить его и создать класс Contact с конструктором, который требует PersonalName, EmailAddress и PostalAddress:

public class Contact 
{
    public Contact(
               PersonalName personalName, 
               EmailAddress emailAddress,
               PostalAddress postalAddress
           ) 
    { 
         ... 
    }
}

Но у нас есть еще одна проблема. Что делать, если у человека есть только адрес электронной почты и у вас нет PostalAddress?

Если мы подумаем об этом, мы поймем, что существует три возможности действительного состояния объекта класса Contact:

  • У контакта есть только адрес электронной почты
  • Контакт имеет только почтовый адрес
  • У контакта есть адрес электронной почты и почтовый адрес

Пусть выписывают модели домена. Для начала создадим класс контактной информации, состояние которого будет соответствовать вышеуказанным случаям.

public class ContactInfo 
{
    public ContactInfo(EmailAddress emailAddress) { ... }
    public ContactInfo(PostalAddress postalAddress) { ... }
    public ContactInfo(Tuple<EmailAddress,PostalAddress> emailAndPostalAddress) { ... }
}

И класс контакта:

public class Contact 
{
    public Contact(
              PersonalName personalName,
              ContactInfo contactInfo
           )
    {
        ...
    }
}

Попробуйте использовать его:

var contact = new Contact(
                  new PersonalName("James", "Bond"),
                  new ContactInfo(
                      new EmailAddress("agent@007.com")
                  )
               );
Console.WriteLine(contact.PersonalName()); // James Bond
Console.WriteLine(contact.ContactInfo().???) // here we have problem, because ContactInfo have three possible state and if we want print it we would write `if` cases

Добавьте метод сопоставления в класс ContactInfo

public class ContactInfo 
{
   // constructor 
   public TResult Match<TResult>(
                      Func<EmailAddress,TResult> f1,
                      Func<PostalAddress,TResult> f2,
                      Func<Tuple<EmailAddress,PostalAddress>> f3
                  )
   {
        if (_emailAddress != null) 
        {
             return f1(_emailAddress);
        } 
        else if(_postalAddress != null)
        {
             ...
        } 
        ...
   }
}

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

Создайте вспомогательный класс, чтобы каждый раз не записывать столько кода.

public abstract class Union<T1,T2,T3>
    where T1 : class
    where T2 : class
    where T3 : class
{
    private readonly T1 _t1;
    private readonly T2 _t2;
    private readonly T3 _t3;
    public Union(T1 t1) { _t1 = t1; }
    public Union(T2 t2) { _t2 = t2; }
    public Union(T3 t3) { _t3 = t3; }

    public TResult Match<TResult>(
            Func<T1, TResult> f1,
            Func<T2, TResult> f2,
            Func<T3, TResult> f3
        )
    {
        if (_t1 != null)
        {
            return f1(_t1);
        }
        else if (_t2 != null)
        {
            return f2(_t2);
        }
        else if (_t3 != null)
        {
            return f3(_t3);
        }
        throw new Exception("can't match");
    }
}

Мы можем иметь такой класс заранее для нескольких типов, как это делается с делегатами Func, Action. 4-6 параметров типового типа будут полностью заполнены для класса Union.

Перепишите ContactInfo класс:

public sealed class ContactInfo : Union<
                                     EmailAddress,
                                     PostalAddress,
                                     Tuple<EmaiAddress,PostalAddress>
                                  >
{
    public Contact(EmailAddress emailAddress) : base(emailAddress) { }
    public Contact(PostalAddress postalAddress) : base(postalAddress) { }
    public Contact(Tuple<EmaiAddress, PostalAddress> emailAndPostalAddress) : base(emailAndPostalAddress) { }
}

Здесь компилятор запросит переопределение для хотя бы одного конструктора. Если мы забудем переопределить остальные конструкторы, мы не сможем создать объект класса ContactInfo с другим состоянием. Это будет защищать нас от исключений во время выполнения при сопоставлении.

var contact = new Contact(
                  new PersonalName("James", "Bond"),
                  new ContactInfo(
                      new EmailAddress("agent@007.com")
                  )
               );
Console.WriteLine(contact.PersonalName()); // James Bond
Console
    .WriteLine(
        contact
            .ContactInfo()
            .Match(
                (emailAddress) => emailAddress.Address,
                (postalAddress) => postalAddress.City + " " postalAddress.Zip.ToString(),
                (emailAndPostalAddress) => emailAndPostalAddress.Item1.Name + emailAndPostalAddress.Item2.City + " " emailAndPostalAddress.Item2.Zip.ToString()
            )
    );

Это все. Надеюсь, вам понравилось.

Пример, взятый с сайта F # для удовольствия и прибыли