J'ai récemment trouvé ce code:
public static implicit operator XElement(XmlBase xmlBase)
{
return xmlBase.Xml;
}
Que signifie static implicit operator
?
C'est un opérateur conversion . Cela signifie que vous pouvez écrire ce code:
XmlBase myBase = new XmlBase();
XElement myElement = myBase;
Et le compilateur ne va pas se plaindre! Au moment de l'exécution, l'opérateur de conversion sera exécuté: transmettra myBase
en tant qu'argument et renverra une XElement
valide en tant que résultat.
C'est une façon pour vous en tant que développeur de dire au compilateur:
"Même s'ils ressemblent à deux types totalement indépendants les uns des autres, il existe en fait un moyen de convertir l'un en l'autre; laissez-moi juste m'occuper de la logique qui explique comment le faire."
Un tel opérateur implicite signifie que vous pouvez convertir XmlBase
en XElement
implicitement.
XmlBase xmlBase = WhatEverGetTheXmlBase();
XElement xelement = xmlBase;
//no explicit convert here like: XElement xelement = (XElement)xmlBase;
C'est un opérateur de conversion implicite (par opposition à un opérateur Explicit, qui requiert la syntaxe de conversion (type)
)
Une autre utilisation intéressante est (ce qu'Unity a fait pour vérifier si un objet (et donc une instance de MonoBehavior) est null):
public static implicit operator bool (CustomClass c)
{
if (c == null) return false;
else return true;
}
De cette façon, vous pouvez faire quelque chose comme ça:
void Method ()
{
CustomClass c1 = null;
CustomClass c2 = new CustomClass ();
bool b1 = c1; // is false
bool b2 = c2; // is true
if (!c1 && c2)
{
// Do stuff
}
}
Évidemment, l'utilisation la plus notoire pourrait être de l'utiliser pour convertir une de vos classes en une autre de vos classes. Mais les utiliser avec des types de base mérite également une attention particulière ... et je vois que cela est mentionné assez rarement.