Дискриминированный союз в C #
https://stackoverflow.com/questions/3151702
-
01-10-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Примечание: этот вопрос имел оригинальное название »C (ISH) Стиль союза в C #«Но как сообщил мне комментарий Джеффа, видимо, эта структура называется« дискриминированным союзом »
Извините в восторге этого вопроса.
Есть пара подобных звучательных вопросов, которые уже в моих уже так, но они, кажется, сосредоточены на преимуществах экономии памяти Союза или используют его для взаимодействия.Вот пример такого вопроса.
Мое желание иметь тип профсоюзного типа несколько разные.
Я пишу некоторый код в тот момент, который генерирует объекты, которые выглядят немного, как это
public class ValueWrapper
{
public DateTime ValueCreationDate;
// ... other meta data about the value
public object ValueA;
public object ValueB;
}
Довольно сложные вещи, которые я думаю, вы согласитесь. Дело в том, что ValueA может быть только нескольких определенных типов (скажем string, int а также Foo (который является классом) и ValueB может быть еще один маленький набор типов. Мне не нравится рассматривать эти ценности как объекты (я хочу теплое плодое чувство кодирования с небольшим количеством безопасности типа).
Поэтому я подумал о написании тривиального класса обертки, чтобы выразить тот факт, что 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 и как функции, как показывает следующий код, который демонстрирует следующий код
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;
}
У кого-нибудь есть идеи, если то, что я хочу достичь, возможен? Или я просто глупо для написания этого класса в первую очередь?
Заранее спасибо.
Решение
Мне очень нравятся решения для проверки типов и наряду, приведенные выше, поэтому вот 100%-%-тип-безопасный союз, который будет бросать ошибки компиляции, если вы пытаетесь использовать неправильный DataType:
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);
}
}
}
}
Другие советы
Мне нравится направление принятого решения, но он хорошо масштабируется для профсоюзов более трех пунктов (например, союз 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));
}
}
Я написал несколько сообщений в блоге на этой теме, который может быть полезен:
Допустим, у вас есть сценарий корзины с тремя состояниями: «пустой», «активный» и «платный», каждый с разные поведение.
- Вы создаете иметь
ICartStateИнтерфейс, который имеет общее состояние (и это может быть просто пустой интерфейс маркера) - Вы создаете три класса, которые реализуют этот интерфейс. (Классы не должны быть в отношениях на наследстве)
- Интерфейс содержит метод «сгиба», в результате чего вы передаете лямбду для каждого состояния или случая, который вам нужно обрабатывать.
Вы можете использовать время выполнения F # от C #, но в качестве более светлого веса альтернативы, я написал немного шаблона 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
);
}
Обратите внимание, что этот код полностью настроен на фирме - нет литейных или условлений в любом месте, а ошибки компилятора, если вы попытаетесь заплатить за пустую тележку, скажем.
Я написал библиотеку для этого в https://github.com/mcintyre321/oneof.
Установка-пакет ONEOF
У него есть общие типы в нем для DUS, например, OneOf<T0, T1> весь путь кOneOf<T0, ..., T9>. Отказ Каждый из них имеет .Match, и а .Switch Заявление, которое вы можете использовать для компилятора Безопасное напечатанное поведение, например:
```
OneOf<string, ColorName, Color> backgroundColor = getBackground();
Color c = backgroundColor.Match(
str => CssHelper.GetColorFromString(str),
name => new Color(name),
col => col
);
```
Я не уверен, что полностью понимаю вашу цель. В C профсоюз является структурой, которая использует то же местоположение памяти для более чем одного поля. Например:
typedef union
{
float real;
int scalar;
} floatOrScalar;
То floatOrScalar Союз может быть использован в качестве поплавка или INT, но они оба потребляют одинаковое пространство памяти. Изменение одного изменения других. Вы можете достичь то же самое со структурой в C #:
[StructLayout(LayoutKind.Explicit)]
struct FloatOrScalar
{
[FieldOffset(0)]
public float Real;
[FieldOffset(0)]
public int Scalar;
}
Приведенная выше структура использует 32бит, а не 64бит. Это возможно только со структурой. Ваш пример выше представляет собой класс и учитывая природу CLR, не гарантирует эффективность памяти. Если вы измените Union<A, B, C> От одного типа к другому, вы не обязательно используете память ... Скорее всего, вы выделяете новый тип на куче и выпадаете другой указатель в поддержке object поле. Вопреки А. реальный союз, Ваш подход может фактически вызвать большее количество кучи, чем вы, в противном случае, если вы не использовали свой тип Union.
char foo = 'B';
bool bar = foo is int;
Это приводит к предупреждению, а не ошибкой. Если вы ищете свой Is а также As Функции, чтобы быть аналогами для операторов C #, вы не должны ограничивать их таким образом.
Если вы разрешите несколько типов, вы не можете добиться безопасности типа (если типы не связаны).
Вы не можете и не добиться какого-либо типа безопасности типа, вы можете добиться только безопасности Byte-Value, используя FieldOffset.
Это сделало бы гораздо больше смысла иметь общий ValueWrapper<T1, T2> с участием T1 ValueA а также T2 ValueB, ...
PS: При разговоре о безопасности типа я имею в виду безопасность типа компиляции.
Если вам нужна кодовая обертка (выполнение логики бизнеса на модификациях, вы можете использовать что-то вдоль линий:
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
Вот моя попытка. Он делает компилярную проверку временных типов, используя ограничения общих типов.
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>()
}
}
Это может использовать некоторые ориентированные. Особенно я не мог выяснить, как избавиться от параметров типа как / IS / SET (нет ли способа указать один тип параметра и позволять C # набрать другой?)
Поэтому я ударил эту же проблему много раз, и я просто придумал решение, полученный синтаксис, который я хочу (за счет некоторого уродства в реализации типа профсоюза.)
Чтобы повторить: мы хотим такого рода использования на участке вызова.
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();
}
}
}
И моя попытка минимального, но расширяемого решения, используя Вложенность профсоюза / любого типаОтказ Также использование параметров по умолчанию в методе Match Naturally позволяет «либо 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);
}
}
}
}
После того, как вы можете бросить исключения, когда есть попытка доступа к переменным, которые не были инициализированы, то есть, если он создан с параметром, а позже, есть попытка получить доступ B или C, он может бросить, скажем, не поддерживаете работу. Тебе нужен добытчик, чтобы сделать это работать, хотя.
Вы можете экспортировать функцию сопоставления псевдоактивных шаблонов, как я использую для любого типа в моем САСА Библиотека. Отказ В настоящее время есть наверху времени выполнения, но я в конечном итоге планирую добавить анализ CIL, чтобы встроить все делегаты в истинное заявление о случаях.
Невозможно сделать с именно синтаксисом, который вы использовали, но с немного большего извлеченности и копией / вставкой легко сделать разрешение перегрузки сделать работу для вас:
// 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());
Таким образом, вы можете рассмотреть возможность добавления необходимых проверок и бросать исключения в таких случаях.
Я использую собственные из типа Union.
Рассмотрим пример, чтобы сделать его более понятным.
Представьте, что у нас есть контактный класс:
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) { ... }
}
В этих классах будут проверки во время создания, и мы в конечном итоге будем иметь допустимые модели. Конститутор в классе Personaname требует имени и фамилия одновременно. Это означает, что после создания он не может иметь неверное состояние.
И контакт класс соответственно
public class Contact
{
public PersonalName Name { get; set; }
public EmailAdress EmailAddress { get; set; }
public PostalAddress PostalAddress { get; set; }
}
В этом случае у нас такая же проблема, объект контактного класса может находиться в неверном состоянии. Я имею в виду, что это может иметь адрес электронной почты, но не имела
var contact = new Contact { EmailAddress = new EmailAddress("foo@bar.com") };
Давайте исправим его и создам контактный класс с конструктором, который требует Personalname, EmailAddress и PostalAddress:
public class Contact
{
public Contact(
PersonalName personalName,
EmailAddress emailAddress,
PostalAddress postalAddress
)
{
...
}
}
Но здесь у нас есть другая проблема. Что если у человека есть только адрес электронной почты и не посталльщина?
Если мы подумаем об этом, мы понимаем, что существует три возможности действительного состояния объекта класса контактов:
- Только контакт имеет адрес электронной почты
- Контакт только имеет почтовый адрес
- Контакт имеет адрес электронной почты, так и почтовый адрес
Давайте выпишем доменные модели. Для начала мы создадим класс контактной информации, какое состояние будет соответствовать вышеуказанным случаям.
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)
{
...
}
...
}
}
В методе Match мы можем написать этот код, поскольку состояние контактного класса контролируется конструкциями, и он может иметь только одно из возможных состояний.
Давайте создадим вспомогательный класс, так что каждый раз не пишут как много кода.
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, действием. 4-6 Параметры родового типа будут заполнены для профсоюзного класса.
Давайте переписать 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 # для удовольствия и прибыли
Команда дизайна языка C # обсудила дискриминированные союзы в январе 2017 года https://github.com/dotnet/csharplang/blob/master/meetings/2017/ldm-2017-01-10.md#discrimined-unions-via-closed-tomepes.
Вы можете проголосовать за запрос на функцию в https://github.com/dotnet/csharplang/issues/113.
