C ＃ use the default transformation method

*

This article is about 《 Write high quality code to improve C# programmatic 157 A suggestion 》 Chapter one Basic language elements Suggestions for 2 Use the default transformation method , If you like this book, please buy the original book in major shopping malls , Support genuine .

In addition to string operations , The second problem commonly encountered by programmers is ： How to transform types correctly . In the previous suggestion , from int Transformation into string, We used type int Of ToString Method . In most cases , When need is right FCL When transforming the type provided , Should be used FCL Transformation methods provided .

These transformation methods include ：

• Use type conversion operators .

• Use the built-in Parse、TryParse, Or as ToString、ToDouble、 and ToDateTime Other methods .

• Use the methods provided by the help class .

• Use CLR Supported transformation .

These methods are described below .

1. Use the conversion operator of type

Use type conversion operators , In fact, it is to use a method inside the type （ It's a function ）. There are two types of conversion operators ： Hidden and explicit conversions （ Coercive transformation ）. Primitive types generally provide conversion operators , Such as ：

int i = 0;
float j = 0;
j = i;        // int To float(Single) There is an implicit transformation 
i = (int)j;   // float(Single) To int There is , And there must be an explicit conversion 

*

Be careful So-called “ Primitive type ”, Data types directly supported by the compiler , That is, directly map to FCL The type of . Primitive types include sbyte、byte、short、ushort、int、uint、long、ulong、char、float、double、bool、decimal、object、string.

User defined types can also provide this kind of conversion by overloading conversion operators , The code is as follows ：

class Program
{
    static void Main(string[] args)
    {
        IP ip = "192.168.0.1";
        Console.WriteLine(ip.ToString());
    }
}

class IP
{
    IPAddress value;

    public IP(string ip)
    {
        value = IPAddress.Parse(ip);
    }

    public static implicit operator IP(string ip)
    {
        IP iptemp = new IP(ip);
        return iptemp;
    }

    public override string ToString()
    {
        return value.ToString();
    }
}

In the code above IP ip = "192.168.0.1"; What is provided is the string to IP The implicit transformation between . however , Unless you consider some initial values , It is generally not recommended that users overload conversion operators for their own types . If you need to convert between user-defined types , It is suggested to consider from an object-oriented perspective , Because they usually contain some kind of relationship （ Such as inheritance 、 To achieve, etc ）. under these circumstances , You should use the fourth method that will be introduced ：CLR Supported transformation . however , We still need to master FCL The type of , Especially the conversion operators between primitive types , In order to quickly convert primitive types .

2. Use the built-in Parse、TryParse, Or as ToString、ToDouble、ToDateTime Other methods

stay FCL in , If a certain type often needs transformation , The type itself has some transformation methods . For instance from string Transformation into int, Because it happens all the time , therefore int In itself, it provides Parse and TryParse Method . In general , If you want to convert a type , It is recommended to check this type of API file .

3. Use the methods provided by the help class

It can be used as System.Convert class 、System.BitConverter Class for type conversion .

System.Covnert Provides a method to convert a primitive type to another type , Such as ToChar、ToBoolean Such method . It is worth noting that ,System.Convert It also supports converting any custom type to any primitive type , As long as the custom type inherits IConvertible Interface will do . As in the above IP class , If you will IP Transformation into string, In addition to rewriting Object Of ToString Outside method , It can also be realized IConvertible Of ToString Method , The code is as follows ：

class IP:IConvertible
{
    //  Omit 
    public bool ToBoolean(IFormatProvider provider)
    {
        throw new InvalidCastException("IP-to-Boolean conversion is not supported.");
    }

    public override string ToString()
    {
        return value.ToString();
    }
    //  Omit 
}

Inherit IConvertible Interfaces must implement other transformation methods at the same time , As in the above ToBoolean, If this transformation is not supported , You should throw a InvalidCastException, Instead of a NotImplementedException.

System.BitConverter It provides a method to convert primitive types to byte arrays , No more details here .

4. Use CLR Supported transformation

CLR Supported transformation , That is, upward transformation and downward transformation . The first thing about this concept is Java The one mentioned in , In fact, it is the conversion between the base class and the subclass , As shown in the figure ：

Class inheritance

Implicit transformation is supported in the transformation from subclass to base class , Such as Dog Obviously it's a Animal; And when Animal Transformation into Dog When , Must be an explicit conversion , because Animal It could be a Cat, The code is as follows ：

Animal animal;
Dog dog = new Dog();
animal = dog;        //  Hide transformation , because Dog Namely Animal
// dog = animal;     //  Compile not pass 
dog = (Dog)animal;   //  There must be an explicit transformation