União discriminada em C #

[Observação: esta questão tinha o título original " União de estilo C (ish) em C # ", mas, como o comentário de Jeff me informou, aparentemente essa estrutura é chamada de 'união discriminada']

Desculpe a verbosidade desta pergunta.

Já existem algumas perguntas semelhantes às minhas no SO, mas elas parecem se concentrar nos benefícios de economia de memória do sindicato ou em usá-lo para interoperabilidade. Aqui está um exemplo de tal pergunta .

Meu desejo de ter um tipo de sindicato é um pouco diferente.

Estou escrevendo um código no momento que gera objetos que se parecem um pouco com este

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

    public object ValueA;
    public object ValueB;
}

Coisas muito complicadas, acho que você vai concordar. O fato é que ValueAsó podem ser de alguns tipos (digamos string, inte Foo(que é uma classe) e ValueBpodem ser outro pequeno conjunto de tipos. Não gosto de tratar esses valores como objetos (quero a sensação aconchegante de codificação com um pouco de segurança de tipo).

Portanto, pensei em escrever uma pequena classe de wrapper trivial para expressar o fato de que ValueA logicamente é uma referência a um tipo específico. Liguei para a classe Unionporque o que estou tentando alcançar me lembrou do conceito de união em 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);
    }
}

Usando esta classe ValueWrapper agora se parece com isto

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

que é algo parecido com o que eu queria alcançar, mas estou faltando um elemento bastante crucial - que é a verificação de tipo forçada do compilador ao chamar as funções Is e As, como o código a seguir demonstra

    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 Não é válido perguntar a ValueA se é um, charjá que sua definição diz claramente que não é - isso é um erro de programação e eu gostaria que o compilador pegasse nisso. [Além disso, se eu pudesse fazer isso corretamente, então (espero) eu também obteria intellisense - o que seria uma bênção.]

Para conseguir isso, gostaria de dizer ao compilador que o tipo Tpode ser A, B ou 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;
    } 

Alguém tem ideia se o que quero alcançar é possível? Ou eu sou simplesmente estúpido por escrever esta classe em primeiro lugar?

Desde já, obrigado.

Eu realmente não gosto das soluções de verificação de tipo e conversão de tipo fornecidas acima, então aqui está uma união 100% segura de tipo que lançará erros de compilação se você tentar usar o tipo de dados errado:

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);
            }
        }
    }
}

Eu gosto da direção da solução aceita, mas ela não se ajusta bem para sindicatos de mais de três itens (por exemplo, uma união de 9 itens exigiria 9 definições de classe).

Aqui está outra abordagem que também é 100% segura em tempo de compilação, mas que é fácil de expandir para grandes sindicatos.

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));
    }
}

Eu escrevi alguns posts sobre este assunto que podem ser úteis:

• Tipos de união em C #
• Implementando Tic-Tac-Toe usando classes estaduais

Digamos que você tenha um cenário de carrinho de compras com três estados: "Vazio", "Ativo" e "Pago", cada um com um comportamento diferente .

• Você cria uma ICartStateinterface que todos os estados têm em comum (e poderia ser apenas uma interface de marcador vazia)
• Você cria três classes que implementam essa interface. (As classes não precisam estar em um relacionamento de herança)
• A interface contém um método "dobrado", por meio do qual você passa um lambda para cada estado ou caso que precisa tratar.

Você poderia usar o tempo de execução F # do C #, mas como uma alternativa mais leve, escrevi um pequeno modelo T4 para gerar código como este.

Esta é a interface:

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

E aqui está a implementação:

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);
  }
}

Agora, digamos que você estenda o CartStateEmptye CartStateActivecom um AddItemmétodo que não é implementado por CartStatePaid.

E também vamos dizer que CartStateActivetem um Paymétodo que os outros estados não têm.

Então, aqui está um código que mostra isso em uso - adicionando dois itens e, em seguida, pagando pelo carrinho:

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
        );
}    

Observe que este código é completamente tipificado - sem conversão ou condicionais em lugar nenhum e erros de compilador se você tentar pagar por um carrinho vazio, por exemplo.

Eu escrevi uma biblioteca para fazer isso em https://github.com/mcintyre321/OneOf

Instalar-Pacote OneOf

Ele contém os tipos genéricos para fazer DUs, por exemplo, OneOf<T0, T1>até OneOf<T0, ..., T9>. Cada um deles tem um .Match, e uma .Switchinstrução que você pode usar para comportamento seguro do compilador, por exemplo:

`` `

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

`` `

Não tenho certeza se entendi totalmente seu objetivo. Em C, uma união é uma estrutura que usa os mesmos locais de memória para mais de um campo. Por exemplo:

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

A floatOrScalarunião pode ser usada como float ou int, mas ambos consomem o mesmo espaço de memória. Mudar um muda o outro. Você pode conseguir o mesmo com uma estrutura em C #:

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

A estrutura acima usa um total de 32 bits, em vez de 64 bits. Isso só é possível com uma estrutura. Seu exemplo acima é uma classe e, dada a natureza do CLR, não garante a eficiência da memória. Se você alterar um Union<A, B, C>de um tipo para outro, não estará necessariamente reutilizando memória ... muito provavelmente, você está alocando um novo tipo no heap e soltando um ponteiro diferente no objectcampo de apoio . Ao contrário de uma união real , sua abordagem pode realmente causar mais thrashing de heap do que você obteria se não usasse seu tipo Union.

char foo = 'B';

bool bar = foo is int;

Isso resulta em um aviso, não em um erro. Se você está procurando os seus Ise Asfunções a serem análogos para os operadores C #, então você não deveria estar restringindo-os dessa forma de qualquer maneira.

Se você permitir vários tipos, não poderá obter segurança de tipo (a menos que os tipos estejam relacionados).

Você não pode e não vai conseguir nenhum tipo de segurança de tipo, você só pode conseguir segurança de valor de byte usando FieldOffset.

Faria muito mais sentido ter um genérico ValueWrapper<T1, T2>com T1 ValueAe T2 ValueB, ...

PS: quando falo sobre segurança de tipo, quero dizer segurança de tipo em tempo de compilação.

Se você precisa de um wrapper de código (realizando lógica de negócios em modificações, você pode usar algo como:

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); }
}

Para uma saída fácil você pode usar (tem problemas de desempenho, mas é muito simples):

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

Aqui está minha tentativa. Ele compila a verificação de tipos, usando restrições de tipo genéricas.

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>()
    }
}

Ele poderia usar um pouco de embelezamento. Especialmente, não consegui descobrir como me livrar dos parâmetros de tipo para As / Is / Set (não há uma maneira de especificar um parâmetro de tipo e deixar C # descobrir o outro?)

Já tive esse mesmo problema muitas vezes e acabei de chegar a uma solução que obtém a sintaxe que desejo (às custas de alguma feiura na implementação do tipo Union).

Para recapitular: queremos esse tipo de uso no site da chamada.

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";

Queremos que os exemplos a seguir falhem na compilação, no entanto, para obtermos um mínimo de segurança de tipo.

DateTime dateTimeColumbusDiscoveredAmerica = u;
Foo fooInstance = u;

Para crédito extra, também não vamos ocupar mais espaço do que o absolutamente necessário.

Com tudo isso dito, aqui está minha implementação para dois parâmetros de tipo genérico. A implementação para três, quatro e assim por diante parâmetros de tipo é direta.

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

E minha tentativa de solução mínima, mas extensível, usando aninhamento de tipo Union / Either . Além disso, o uso de parâmetros padrão no método Match habilita naturalmente o cenário "X ou padrão".

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);
            }
        }
    }
}

Você pode lançar exceções quando houver uma tentativa de acessar variáveis ​​que não foram inicializadas, ou seja, se for criado com um parâmetro A e posteriormente houver uma tentativa de acessar B ou C, pode lançar, digamos, UnsupportedOperationException. Você precisaria de um getter para fazer funcionar.

Você pode exportar uma função de correspondência de pseudo-padrão, como eu uso para o tipo Either na minha biblioteca Sasa . Atualmente, há sobrecarga de tempo de execução, mas pretendo adicionar uma análise CIL para incorporar todos os delegados em uma instrução de caso verdadeiro.

Não é possível fazer exatamente com a sintaxe que você usou, mas com um pouco mais de detalhamento e copiar / colar é fácil fazer com que a resolução de sobrecarga faça o trabalho para você:

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

Agora deve ser bastante óbvio como implementá-lo:

    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
    {
    }

Não há verificações para extrair o valor do tipo errado, por exemplo:

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

Portanto, você pode considerar adicionar verificações necessárias e lançar exceções em tais casos.

Eu uso o próprio do tipo de união.

Considere um exemplo para torná-lo mais claro.

Imagine que temos aula de contato:

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

Todos são definidos como strings simples, mas realmente são apenas strings? Claro que não. O nome pode consistir em nome e sobrenome. Ou um e-mail é apenas um conjunto de símbolos? Eu sei que pelo menos deve conter @ e é necessariamente.

Vamos melhorar nosso modelo de domínio

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) { ... } 
}

Nestas aulas haverá validações durante a criação e, eventualmente, teremos modelos válidos. Consturctor na classe PersonaName requer FirstName e LastName ao mesmo tempo. Isso significa que após a criação, ele não pode ter estado inválido.

E classe de contato respectivamente

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

Neste caso temos o mesmo problema, o objeto da classe Contact pode estar em estado inválido. Quer dizer, pode ter EmailAddress, mas não tem nome

var contact = new Contact { EmailAddress = new EmailAddress("[email protected]") };

Vamos corrigi-lo e criar a classe Contact com construtor que requer PersonalName, EmailAddress e PostalAddress:

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

Mas aqui temos outro problema. E se Person tiver apenas EmailAdress e não PostalAddress?

Se pensarmos nisso, percebemos que existem três possibilidades de estado válido do objeto da classe Contact:

1. Um contato tem apenas um endereço de e-mail
2. Um contato tem apenas um endereço postal
3. Um contato possui um endereço de e-mail e um endereço postal

Vamos escrever modelos de domínio. Para o início, criaremos a classe Contact Info cujo estado será correspondente aos casos acima.

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

E classe de contato:

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

Vamos tentar usar:

var contact = new Contact(
                  new PersonalName("James", "Bond"),
                  new ContactInfo(
                      new EmailAddress("[email protected]")
                  )
               );
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

Vamos adicionar o método Match na classe 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)
        {
             ...
        } 
        ...
   }
}

No método match, podemos escrever este código, pois o estado da classe de contato é controlado com construtores e pode ter apenas um dos estados possíveis.

Vamos criar uma classe auxiliar, para que a cada vez não escrevamos tantos códigos.

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");
    }
}

Podemos ter essa classe com antecedência para vários tipos, como é feito com os delegados Func, Action. 4-6 parâmetros de tipo genérico estarão completos para a classe Union.

Vamos reescrever a ContactInfoaula:

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) { }
}

Aqui, o compilador solicitará a substituição de pelo menos um construtor. Se esquecermos de substituir o resto dos construtores, não podemos criar o objeto da classe ContactInfo com outro estado. Isso nos protegerá de exceções de tempo de execução durante o Matching.

var contact = new Contact(
                  new PersonalName("James", "Bond"),
                  new ContactInfo(
                      new EmailAddress("[email protected]")
                  )
               );
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()
            )
    );

Isso é tudo. Eu espero que você tenha gostado.

Exemplo retirado do site F # para diversão e lucro

A equipe de design da linguagem C # discutiu as uniões discriminadas em janeiro de 2017 https://github.com/dotnet/csharplang/blob/master/meetings/2017/LDM-2017-01-10.md#discriminated-unions-via-closed-types

Você pode votar na solicitação de recurso em https://github.com/dotnet/csharplang/issues/113