Add simple way to create struct wrappers for types

[wanton7]

Add simple way to wrap types like int, long, Guid etc.. to a struct without need to do all overrides and operators yourself.

Let's say you have double that is Celsius and you want a method to convert it to Fahrenheit, something like this double ConvertToFahrenheit(double celsius). It's much more typesafe with wrapper structs Fahrenheit ConvertToFahrenheit(Celsius celsius).

We use wrapper structs in our company's code base for typesafety and we have lot of code like this

public struct ChallengeId : System.IEquatable<ChallengeId>
{
    public static readonly ChallengeId Empty = new ChallengeId(0);

    private readonly int _value;

    public ChallengeId(int value) => _value = value;

    public static explicit operator ChallengeId(int value) => new ChallengeId(value);

    public static implicit operator int(ChallengeId value) => value._value;

    public override bool Equals(object obj) => obj is ChallengeId ? this.Equals((ChallengeId)obj) : false;

    public bool Equals(ChallengeId other) => _value == other._value;

    public override int GetHashCode() => _value.GetHashCode();

    public static bool operator ==(ChallengeId left, ChallengeId right) => left.Equals(right);

    public static bool operator !=(ChallengeId left, ChallengeId right) => !(left == right);

    public override string ToString() => _value.ToString();
}

[DavidArno]

Related: #234

[orthoxerox]

Also see #410

[HaloFour]

Could be managed by the mythical source generators!

[StructWrapper(typeof(int))]
public partial struct Celcius { }

[DavidArno]

@HaloFour,

Wow, it's been a while since someone mentioned them 😀

[jnm2]

Well, the reason we won't be getting them has been pretty relentlessly explained, so I've been wondering if the right thing to do is go back to all the issues we said were covered by source generators and work towards alternative solutions.

[quinmars]

I think a general and short (short in the sense of a keyword) will not work for all cases. There are many decissions one has/can take especially for the possible operator overloads. Which cast direction is implicit, can I use addition, can I use multiplication, etc. But you can reduce much of the code with the proposed and championated record syntax (#39):

public struct ChallengeId(int Value)
{
    public static readonly ChallengeId Empty = default;
    public static explicit operator ChallengeId(int value) => new ChallengeId(value);
    public static implicit operator int(ChallengeId cid) => cid.Value;
    public override string ToString() => Value.ToString();
}

With default interface methods (#52) this can maybe even be more reduced, although I'm not sure if the ToString() part will work.

public interface IStrongTypedefMixins<TSelf, T>
{
    T Value { get; }
    public static readonly TSelf Empty = default;
    public string ToString() => Value.ToString();
}

public struct ChallengeId(int Value) : IStrongTypedefMixins<ChallengeId, int>
{
    public static explicit operator ChallengeId(int value) => new ChallengeId(value);
    public static implicit operator int(ChallengeId cid) => cid.Value;
}

Edit: Empty should be of the ChallengeId not int.

[DarthVella]

I like the records/default interface methods suggestion; it's short and sweet and customisable; but I wonder if interactions would get confusing between mixins defined in different libraries, with different expectations on explicit/implicit casting behaviour.

[YairHalberstadt]

Source generators have finally landed for C# 9.0, and should be able to deal with generating all this code easily.