typedef équivalent pour la surcharge en c #

Question

J'ai un tas de code qui a beaucoup entiers avec des significations différentes (je préfère une solution générale mais pour un exemple précis: jour-of-the mois par rapport à un mois de d'année par rapport à l'année etc. .). Je veux être en mesure de surcharger un constructeur de classe en fonction de ces significations.

Par exemple

int a; // takes role A
int b; // takes role B

var A = new Foo(a);  // should call one constructor
var B = new Foo(b);  // should call another constructor

Maintenant, bien que ne fonctionnera pas, mais si je pouvais définir un type (et pas seulement un alias) qui est un int dans tout sauf le nom comme celui-ci:

typedef int TypeA;  // stealing the C syntax
typedef int TypeB;

Je pourrais faire la surcharge j'ai besoin et laisser le système de type garder une trace de ce que les choses sont ce. En particulier, cela me permettrait d'être sûr que les valeurs ne sont pas mélangés, par exemple une valeur retournée par une fonction comme une année n'est pas utilisé comme un jour-of-the mois.

Est-il possible à court d'emballages de class ou struct de le faire en C #?

---

Ce serait bien si la solution fonctionnerait aussi pour chars et doubles.

Answer 1

Il n'y a pas typedef directe équivalent, mais vous pouvez faire ce qui suit:

using TypeA = int;
using TypeB = int;

Cependant, ce type alias juste plutôt que de créer un nouveau type fort. Par conséquent, le compilateur les traitera toujours comme int lors de la résolution des appels de méthode.

Une meilleure solution pourrait être de créer des classes simples wrapper qui enveloppe int et fournit coulée implicite, par exemple:

struct TypeA
{
   public TypeA(int value)
   {
      this.realValue = value;
   }

   private int realValue;
   public static implicit operator int(TypeA value)
   {
     return this.realValue;
   }

   public static implicit operator TypeA(int value)
   {
     return new TypeA(value);
   }
}

Cependant, dans la plupart des cas, un enum serait plus approprié.

Answer 2

Cela peut être loin, mais on ne pouvait pas utiliser un ENUM pour cela? base de Enum est int, mais est tapé, et vous pouvez définir différents constructeurs en fonction du type de ENUM passé.

Answer 3

Si c'est juste pour le constructeur, ne pourriez-vous utiliser quelque chose comme ceci:

 int dom = 5;
int doy = 100;

Foo b = Foo.NewFromDayoftheMonth(dom);

Foo c = Foo.NewFromDayoftheYear(doy);

où chaque procédé sont statiques et créer un nouvel objet Foo en fonction des paramètres transmis.

Cela semble être une solution pour moi, où il n'y a pas grand-chose d'un.

Answer 4

Je voudrais aussi créer une struct autour de la valeur:

public struct TypeA
{
  private int value;
  public TypeA(int value)
  {
    this.value = value;
  }

  public static explicit operator int(TypeA a)
  {
     return a.value;
  }

  public static explicit operator TypeA(int value)
  {
     return new TypeA(value);
  }
}

vous pouvez également déclarer les opérateurs de combiner des types et des méthodes pour fournir un type riche autour de la valeur int.

Un type YEAR peut provde une propriété IsLeap, un jour du mois peut être retenue à des valeurs comprises entre 1 et 31 et fournir une arithmétique spéciale.