如何让 C# 对枚举类型使用 int 方法重载？

Question

I got a class in C# that has multiple overloads for different parameter types:

class Writer
{
  public Writer Write(bool value)
  {
    // Do something with value
    return this;
  }
  public Writer Write(double value)
  {
    // Do something with value
    return this;
  }
  public Writer Write(int value)
  {
    // Do something with value
    return this;
  }
  public Writer Write<T>(T value) where T : class, IInterface, new()
  {
    // Do something with value
    return this;
  }
}

class Reader
{
  public Reader Read(out bool value)
  {
    // Retrieve value
    return this;
  }
  public Reader Read(out double value)
  {
    // Retrieve value
    return this;
  }
  public Reader Read(out int value)
  {
    // Retrieve value
    return this;
  }
  public Reader Read<T>(out T value) where T : class, IInterface, new()
  {
    // value = new T() or null
    return this;
  }
}

Now I want to call Write and Read for multiple variables in a row, one of which is of an enum type. However, that enum type causes difficulties in the method resolving. (Btw: I am used to VB.NET, where Enum types are compatible to Integer parameters.)

enum MyEnum : int
{
  Foo = 0, Bar = 1
}

class CallingClass
{
  public void Call()
  {
    bool b;
    double d;
    int i;
    IInterface o;
    MyEnum e = MyEnum.Foo;

    var w = new Writer();

    // Unintuitive for Write
    w
      .Write(b)
      .Write(d)
      .Write(i)
      .Write(o)
      .Write((int) e);

    // w.Write(e); // resolves to Writer.Write<T>(T)
    // => Compile error: "MyEnum has to be reference type to match T"

    // Even worse for Read, you need a temp variable
    // and can't use fluent code anymore:

    var r = new Reader();
    r
      .Read(out b)
      .Read(out d)
      .Read(out i)
      .Read(out o);
    int tmp;
    r.Read(out tmp);
    e = (MyEnum) tmp;
  }
}

Is there any way I can modify Write / Read , Writer / Reader or MyEnum so that w.Write(e) will automatically resolve to Writer.Write(int) and more importantly r.Read(out e) to Reader.Read(int) ?

Answer 1

Little late on the answer but since I was having the same issue, an overload like this should work

public void Foo(int a)
{
    // do something
}

public void Foo(Enum @enum)
{
    Foo(Convert.ToInt32(@enum));
}

Answer 2

with the where constraint:

public void Get<T>(out T value) where T : class, IInterface, new()

you are explicitly saying that T has to be a reference type (not a value type, as enums are). Try to delete class constraint.

[edit] you can also try this, avoiding out param:

  public T Get<T>() where T : new()
  {
    return default(T);
  } 

and call it as

c.Get<MyEnum>();

but again, if you add an IInterface constraint, no Enum can satisfy it.

Answer 3

From the comments to my question and Gian Paolo's answer, it has become clear that - opposed to VB.NET - C# does not support implicit type conversion of enum to int or vice versa, even when using tricks.

Hence, my desired "one-method handles all enum types" solution is impossible to achieve.

If you cannot (project hierarchy) or do not want to add overloads per enum type to the Writer / Reader class itself, you can create extension methods for the enum types.