Conversion implicite et explicite personnalisée C#

Explicite et implicite sont des opérateurs de conversion. L'utilisation de ces deux types peut permettre à nos types personnalisés de prendre en charge l'échange mutuel.
explicti signifie que la conversion explicite, comme from A ->, doit être forcée à taper (B. = (B)A)
implicite signifie conversion implicite, comme depuis B -> A il suffit d'attribuer directement (A = B)

La conversion implicite peut rendre notre code plus beau, concis et facile à comprendre, il est donc préférable d'utiliser davantage les opérateurs implicites. mais! Si l'objet lui-même perd certaines informations (telles que la précision) lors de la conversion, nous ne pouvons alors utiliser que l'opérateur explicite afin que les clients puissent être avertis au moment de la compilation lors de l'appel de

namespace OperatorTest
{
    /// <summary>
    /// 猪
    /// </summary>
    public class Pig
    {
        public Pig(string name)
        {
            this.Name = name;
        }
        public string Name;

        //explicit 关键字用于声明必须使用强制转换来调用的用户定义的类型转换运算符。
        //static explicit operator target_type { source_type identifier }
        //target_type 目标类型
        //source_type 源类型
        //identifier Something
        /*转换运算符将源类型转换为目标类型。源类型提供转换运算符。与隐式转换不同，必须通过强制转换的方式来调用显式转换运算符。如果转换操作可能导致异常或丢失信息，则应将其标记为 explicit。这可以防止编译器无提示地调用可能产生无法预见后果的转换操作*/
        public static implicit operator Pig(Monkey value)
        {
            Pig mk = new Pig(value.Name + "：猴子变猪！！");
            return mk;
        }
    }

namespace OperatorTest
{
    /// <summary>
    /// 猴子
    /// </summary>
    public class Monkey
    {
        public Monkey(string name)
        {
            this.Name = name;
        }
        public string Name;

        //implicit 关键字用于声明隐式的用户定义类型转换运算符。
        //static implicit operator target_type { source_type identifier }
        public static explicit operator Monkey(Pig value)
        {
            Monkey mk = new Monkey(value.Name + "：猪变猴子！！");
            return mk;
        }
    }

Appel :

 Monkey monkey = new Monkey("悟空");
            //隐式转换 猴子变猪
            Pig monkeyToPig = monkey;
            MessageBox.Show(monkeyToPig.Name);

            Pig pig = new Pig("八戒");
            //显式转换 猪变猴子
            Monkey pigToMonkey = (Monkey)pig;
            MessageBox.Show(pigToMonkey.Name);

Sortie :

Application :
Par exemple, en fonctionnement réel, un objet A (ou une entité) est sérialisé en XML Storage, vous pouvez alors définir un opérateur explicite dans la classe d'objet A pour convertir le contenu XML qui répond aux exigences en un objet ou une entité.
Bien sûr, vous pouvez également définir une fonction dans la classe de l'objet A pour implémenter ce traitement, mais cela peut nécessiter une étape supplémentaire, c'est-à-dire que lorsque la fonction n'est pas une fonction statique, vous devez d'abord instancier l'objet pour appeler la fonction de traitement correspondante.

Référence :

mot clé explicite

mot-clé implicite

mot-clé opérateur

Téléchargement de la démo

Ce qui précède est le contenu de la conversion implicite et explicite personnalisée C#. Pour plus de contenu connexe, veuillez faire attention à PHP. Réseau chinois (www.php.cn) !