C# surcharge: méthode pour valeur nulle

Question

Je suis actuellement en train d'écrire un sérialiseur pour certaines de mes classes. J'ai créé un ensemble de méthodes statiques avec les signatures suivantes

public static string serialize(int val);
public static string serialize(string val);
public static string serialize(float val);
public static string serialize(MyOwnClass val);
public static string serialize(AnotherClass val);
public static string serialize(SomethingElse val);

De plus, parfois je dois traiter des valeurs null. J'aimerais les traiter de manière spéciale, c'est-à-dire avec une signature telle que:

public static string serialize(null val);

L'appel à la fonction devrait ressembler à :

string s = serialize(someVariableThatMightBeNull);

Et cela devrait être déclenché à chaque fois que serialize est appelé avec la valeur null, indépendamment du type avec lequel la variable a été déclarée.

Y a-t-il un moyen d'implémenter cela en C#?

Actuellement, ma seule solution serait d'ajouter cette ligne à chaque méthode : (pour les types de données qui peuvent être null) :

if(val == null){ dealWithNull(); }

Cette solution semble un peu fastidieuse, car j'ai environ 30 cas différents et je préférerais ne pas avoir une méthode de répartition.

---

À titre d'exemple, Xtend propose des méthodes de répartition qui offrent également le type Void qui vérifie les valeurs null. Xtend Dispatch Methods

Answer 1

Si je vous ai bien compris :

Je choisirais une signature de méthode qui attend un object.

Le compilateur choisira TOUJOURS la signature de méthode qui semble la plus proche de ce que vous avez utilisé. Ainsi, il n'utilisera la méthode avec la signature object que si aucune autre n'est disponible.

Dans cette méthode, vous pourrez vérifier si le paramètre est nul et/ou gérer les classes qui n'ont pas leur propre méthode statique de sérialisation

---

Pour la sérialisation personnalisée, à mon avis, il serait préférable de laisser chaque classe se gérer elle-même.

Pour ce faire, je définirais une Interface ICustomSerialization contenant une méthode string CustomSerialization()

Ensuite, je ferais hériter chacune des classes dont j'aurais besoin de sérialiser de cette interface et implémenter la méthode à l'intérieur de chaque classe.

Cela offrirait l'avantage d'avoir le code de sérialisation DANS la classe concernée, éviterait une classe de sérialisation massive.

Permettez à votre sérialiseur de fonctionner avec des interfaces (et ainsi ne pas avoir à savoir comment gérer chaque classe particulière)

Answer 2

La méthode qui sera appelée dépend du type de l'élément qui est passé en paramètre.

Si vous avez quelque chose de typé comme string qui contient une valeur nulle, alors elle va appeler la méthode avec le paramètre string. Si vous avez quelque chose de type MyOwnClass et que c'est nul, alors elle va appeler la méthode avec le paramètre MyOwnClass.

Je pense que votre meilleure option est de faire quelque chose dans le code qui est externe à ceci.

if(whatever == null) { serializeNull(whatever); } else { serialize(whatever); }

Answer 3

Votre solution actuelle est la seule en C# (où vous n'avez pas de vrais templates).

Je pense que vous pourriez être simplement satisfait tant que la taille du code généré reste petite par rapport au reste du code de sérialisation.

Si vous acceptez d'introduire un couplage fort entre vos classes et le code de sérialisation, alors vous pouvez opter pour la manière "OO" pour éliminer la redondance en introduisant une classe de base qui gère les nulls et demande à chaque classe dérivée de remplacer une méthode d'implémentation virtuelle.