C# Learning Diary 16 ---- Cas d'utilisation spécifiques de conversion implicite

Après l'étude précédente des types de données de base en C#, nous l'avons presque introduit. Découvrons la conversion mutuelle entre les types. La conversion de type en C# peut être divisée en deux catégories : la conversion implicite et la conversion explicite.

Conversion implicite :

La conversion implicite est la conversion par défaut du système et peut être convertie sans déclaration. Pendant le processus de conversion implicite, le compilateur peut effectuer la conversion en toute sécurité sans vérifier la conversion. Par exemple, la conversion du type int en type long est une conversion implicite. La conversion implicite n'échouera généralement pas et les informations ne seront pas perdues pendant le processus de conversion

Par exemple : int i = 100; long a = i; // Convertit automatiquement le type int sans. déclaration Convertir en type long

La conversion implicite n'est pas vraie pour deux types. Par exemple, si nous convertissons implicitement le type long ci-dessus en type int, cela ne réussira pas :

long a =. 100;

int i = a; //Le compilateur signalera une erreur

Par conséquent, la conversion implicite a les règles suivantes :

Implicit conversion numérique
Conversion d'énumération implicite
Conversion de référence implicite
Conversion numérique implicite :
La conversion numérique implicite inclut les types suivants :

Du type sbyte au type court, int, long, float, double, décimal
•  ;

Du type octet au type court, ushort, int, uint, long, ulong, float, double, décimal
Du type court à int, types longs, flottants, doubles, décimaux
du type ushort aux types int, uint, long, ulong, doubles, décimaux

• Du type int au type long, flaot, double, décimal

• Du type uint au type long, ulong, flaot, double, décimal

• Du type long au type flottant, double, décimal

• Du type ulong au type flottant, double, décimal

• Du type char au type ushort, int, uint, long, ulong, flaot, double, décimal

• Du type float au type double

• Résumons après avoir écrit tant de choses. En un mot, il s'agit d'une conversion d'un type de basse précision à un type de haute précision (car la précision et les informations sur les données ne sont pas perdues), mais il n'y a pas de conversion implicite d'un type de haute précision à un type de haute précision. -type de précision (éventuellement Certaines informations seront perdues et ne seront pas sûres). Pour la précision et la gamme de types, veuillez vous référer au C# Learning Diary 04. Ce qu'il faut rappeler ici, c'est qu'il n'y a pas de conversion implicite des autres types vers le type Char.

Exemple de conversion numérique implicite :

Résultat :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{    
    class Program  
    {  
        static void Main(string[] args)  
        {  
            byte x = 255;      //byte 表示的范围0~255  
            short y = x;      //将从byte到short隐式转换  
            y++;  
            Console.WriteLine("y = {0}",y);  
  
            y = 32767; //shot的范围 -32768~32767  
  
            int i = y + 5;  //从 short 到 int 隐式转换扩大范围 结果是准确的  
            y+=5;          //超出范围了结果会不准确  
            Console.WriteLine("y = {0}",y); //y超出范围数据会丢失部分  
              
            Console.WriteLine("i = {0}",i);   
  
              
        }  
    }  
}

Comme le montre cet exemple , l'utilisation opportune de la conversion de type est toujours très importante.

Conversion d'énumération implicite :

La conversion d'énumération implicite permet de convertir le nombre décimal 0 en n'importe quel type d'énumération. Notez qu'il ne peut convertir que 0 , il n'existe pas de conversion implicite de ce type. pour les autres entiers, regardez l'exemple suivant :

Le résultat de sortie est :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{    
    class Program  
    {  
        enum weekday  //定义一个枚举类型  
        { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };  
        static void Main(string[] args)  
        {  
            weekday day;  
            day = 0;      //隐式将0转换为枚举类型（只能是0）  
            Console.WriteLine(day);  
              
        }  
    }  
}

Si nous mettons day = 0 dans le code ci-dessus, ce devrait être day = 1 le compilateur donnera une erreur.

  Sunday

Conversion de référence implicite :

Conversion de n'importe quel type de référence en un type d'objet

(Personne p = nouvelle Personne ; ())

• Conversion du type de classe s en type de classe t, où s est une classe dérivée de t

• Conversion du type de classe s au type d'interface t, où la classe s implémente l'interface t ; (le contenu sur l'interface (interface) sera écrit plus tard, utilisez-le uniquement pour déclarer des méthodes mais pas pour définir des méthodes)

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    class person     //定义了一个基类（父类） person  
    {   
    }  
    class person1 : person   // person1 派生于基类person，person1就叫person的一个子类，  
    {   
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            person1 per = new person1();  //将子类person1实例化一个对象per  
            person Per = per;        //将子类隐式转换为父类  
              
              
        }  
    }  
}

Conversion du type d'interface s au type d'interface t, où t est l'interface parent de s ;

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    public interface Infa   //定义了一个接口  
    {  
        void Output();  
    }  
    class person : Infa    //定义一个person类继承于接口并实现方法  
    {  
        public void Output()  
        {  
            Console.WriteLine("Welcome");  
        }  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            person per = new person();  //实例化  
  
            Infa fa = per;    //从person到interface（接口）隐式转换  
              
        }  
    }  
}

Conversion du tableau de type référence s en tableau de type référence t, où s est une classe dérivée de t, et le dimension du tableau Les nombres sont les mêmes ;

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    public interface Infa   //定义了一个接口  
    {  
        void Output();  //接口只声明方法，具体实现由它的派生类写代码决定  
    }  
    public interface infa1 : Infa    //定义一个infa1接口继承于Infa接口  
    {  
        void input();  
    }  
    class person1 : infa1  //由infa1派生一个person1类，因为接口不能直接实例化  
    {   
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            person1 per = new person1 { };  //接口不能直接实例化，需要实例化一个派生于infa1接口person1类  
  
            Infa fa = per;    //实现子接口到父借口隐式转换  
              
        }  
    }  
}

Il convient de rappeler ici que si le tableau de type référence est un tableau de type valeur, le code suivant signalera une erreur :

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    class Person //定义一个基类 Person   
    {   
    }  
    class person1 : Person  //由基类派生一个子类person1  
    {   
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            person1[] per = new person1[5];  //实例化一个person1  
  
           Person[] Per = per;    //实现隐式转换  
              
        }  
    }  
}

Du type de tableau à la conversion System.Array ; (Array est la classe de base de tous les tableaux, veuillez vous référer à l'article précédent^_^)

class Program  
    {  
        static void Main(string[] args)  
        {  
            int[] n_int = new int[10];  
            double[] n_doubel = new double[10];  
            n_doubel = n_int;  //这里报错啦  
              
        }  
    }

Conversion de n'importe quel type représentatif en System.Delegate ; j'écrirai sur le délégué plus tard)

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{  
    class Program  
    {  
        public static int output(int s)  //定义一个方法  
        {  
            Console.WriteLine("welcome,{0}",s);  
            return 1;  
        }  
  
        public delegate int mydel(int s);  //声明一个委托（以后我会说到委托）  
          
        static void Main(string[] args)  
        {  
            mydel my = new mydel(output);   //将 output方法委托给my  
            Delegate MYDEL = my;    //向 MYDEL 隐式转换  
        }  
    }  
}

以上就是 C#学习日记16----隐式转换具体用例的内容，更多相关内容请关注PHP中文网（www.php.cn）！