Static typed Ids (integers) in C#

Question

Within our application I need to work a lot with simple IDs (just integers).

They are used to make queries against a database. For performance reasons I don't want to materialize them to Entities before the query.

Example:

// not really *that* static typed
public void DoQuery(int userId, int groupId)
{
}

Because I want to make our application more static typed (preventing errors like accidentally switching parameters around), I'm looking for a way to make this all more static typed, like:

public struct UserId
{
     int _UserId;

     public UserId(int userId)
     {
          _UserId = userId;
     }

    public static implicit operator int (UserId userId)
    {
        return userId._Id;
    }
}

and then:

// will throw compilation errors when I try to shoehorn a UserId into a GroupId
public void DoQuery(UserId userId, GroupId groupId)
{
}

• Do I need to override equals operators and hascode, or would this be enough?
• Are there any important performance penalties (during a highload)? For i.e. garbage collection.
• What could be any more negative consequences from this?

Answer 1

You can try DRY here :) Define class like this (UPDATED to include ASP.NET support):

[TypeConverter(typeof(IdTypeConverter))]
[JsonConverter(typeof(IdJsonConverter))]
public struct Id<T> 
{
    public static explicit operator Id<T>(int value) => new Id<T>(value);
    public static implicit operator int(Id<T> id) => id.Value;

    public Id(int value)
       : this()
    {
        Value = value;
    }

    int Value { get; }

    public override int GetHashCode() => Value.GetHashCode();
    public override bool Equals(object obj) =>
          obj is Id<T> &&
          ((Id<T>)obj).Value == Value;

    public static bool operator ==(Id<T> left, Id<T> right) =>
          left.Value == right.Value;

    public static bool operator !=(Id<T> left, Id<T> right) =>
          left.Value != right.Value;
}

class IdJsonConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return  
            objectType.IsConstructedGenericType && 
            objectType.GetGenericTypeDefinition() == typeof(Id<>);
    }

    public override object ReadJson(
         JsonReader reader, 
         Type objectType, 
         object existingValue, 
         JsonSerializer serializer)
    {
        return Activator.CreateInstance(
            objectType, 
            reader.ReadAsInt32());
    }

    public override void WriteJson(
          JsonWriter writer, 
          object value, 
          JsonSerializer serializer)
    {
        writer.WriteValue((int)(dynamic)value);
    }
}

class IdTypeConverter : TypeConverter
{
    public IdTypeConverter(Type type)
    {
        Type = type;
    }

    Type Type { get; }

    public override bool CanConvertFrom(
        ITypeDescriptorContext context, Type sourceType)
    {
        return
            sourceType == typeof(string) ||
            base.CanConvertFrom(context, sourceType);
    }

    public override object ConvertFrom(
        ITypeDescriptorContext context, 
        CultureInfo culture, object value)
    {
        if (value is string)
            return Activator.CreateInstance(
                 Type, 
                 int.Parse(value as string));

        return base.ConvertFrom(context, culture, value);
    }

    public override bool CanConvertTo(
        ITypeDescriptorContext context, 
        Type destinationType)
    {
        return
            destinationType == typeof(string) ||
            base.CanConvertTo(context, destinationType);
    }

    public override object ConvertTo(
        ITypeDescriptorContext context, 
        CultureInfo culture, 
        object value, 
        Type destinationType)
    {
        if (destinationType == typeof(string))
            return $"{(int)(dynamic)value}";

        return base.ConvertTo(context, culture, value, destinationType);
    }
}

Let's imagine you have Entity Framework Entity Type User:

class User
{
   public int Id { get; set; } 
   public string Name { get; set; }
}  

Then:

IUserReader reader = new UserReader();
User dirkBoer = reader.Read(Users.DirkBoer);

Where:

class Users
{
   public static readonly Id<User> DirkBoer = (Id<User>)22;
   public static readonly Id<User> Jamal = (Id<User>)23;
}   

class UserReader : IUserReader
{
   public User Read(Id<User> id) => 
       Users().First(u => u.Id == id);

   IQueryable<User> Users() => 
       new EfContext()
         .Users
         .Include(u => u.Certificates);
} 

Answer 2

Do I need to override equals operators and hascode, or would this be enough?

Structs automatically implement Equals() and GetHashCode(), but that implementation is slow. If you're actually going to use them (even indirectly, e.g. by using some LINQ methods), and you care about performance, you should override them.

Are there any important performance penalties (during a highload)? For i.e. garbage collection.

There shouldn't be. GC doesn't get involved (unless you're going to box the values, but that's the same for integers).

I'm not sure if the runtime can optimize code using UserId as well as it could for an integer, so for performance critical code, you should make sure it's okay by profiling.

What could be any more negative consequences from this?

I think this is not a usual pattern in C#, so one negative consequence might be some confusion by your coworkers.