C#关键字的使用(params、explicit、implicit、operator)

params object[] 用于函数多参数的定义

namespace AllDemo
{
    public class Program
    {
        static void Main(string[] args)
        {
            int count1 = Plus(1);       //输出 1
            Console.WriteLine(count1);

            int count2 = Plus(1, 2, 3);//输出 6
            Console.WriteLine(count2);

            int count3 = Plus();    //输出 0  参数数组本身可选，没传入值也不会出错
            {
                Console.WriteLine(count3);
            }

            Console.ReadKey();
        }

        public static int Plus(params int[] values)
        {
            int count = 0;
            foreach (int i in values)
            {
                count = count + i;
            }
            return count;
        }
    }
}

explicit  关键字用于声明必须使用 强制转换 来调用的用户定义的类型转换运算符。

namespace EventDemo
{
    class Celsius
    {
        private float degrees;
        public Celsius(float temp)
        {
            degrees = temp;
        }
        public static explicit operator Fahrenheit(Celsius c)
        {
            return new Fahrenheit((9.0f / 5.0f) * c.degrees + 32);
        }
        public float Degrees
        {
            get { return degrees; }
        }
        
    }

    class Fahrenheit
    {
        private float degrees;
        public Fahrenheit(float temp)
        {
            degrees = temp;
        }
        // Must be defined inside a class called Fahrenheit:
        public static explicit operator Celsius(Fahrenheit fahr)
        {
            return new Celsius((5.0f / 9.0f) * (fahr.degrees - 32));
        }
        public float Degrees
        {
            get { return degrees; }
        }
        
    }

    class Program
    {
        static void Main()
        {
            Fahrenheit fahr = new Fahrenheit(100.0f);
            Console.Write("{0} Fahrenheit", fahr.Degrees);
            Celsius c = (Celsius)fahr;

            Console.Write(" = {0} Celsius", c.Degrees);
            Fahrenheit fahr2 = (Fahrenheit)c;
            Console.WriteLine(" = {0} Fahrenheit", fahr2.Degrees);
            Console.ReadLine();
        }
    }
}

implicit 关键字用于声明隐式的用户定义类型转换运算符。  如果可以确保转换过程不会造成数据丢失，则可使用该关键字在用户定义类型和其他类型之间进行隐式转换

namespace EventDemo
{
    class Digit
    {
        public Digit(double d) { val = d; }
        public double val;
        // ...other members
        // User-defined conversion from Digit to double
        public static implicit operator double(Digit d)
        {
            return d.val;
        }
        //  User-defined conversion from double to Digit
        public static implicit operator Digit(double d)
        {
            return new Digit(d);
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            Digit dig = new Digit(7);
            //This call invokes the implicit "double" operator
            double num = dig;
            //This call invokes the implicit "Digit" operator
            Digit dig2 = 12;
            Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);
            Console.ReadLine();
        }
    }
}

使用  operator  关键字来重载内置运算符，或提供类或结构声明中的用户定义转换。

namespace EventDemo
{
    class Fraction
    {
        int num, den;
        public Fraction(int num, int den)
        {
            this.num = num;
            this.den = den;
        }

        // overload operator +
        public static Fraction operator +(Fraction a, Fraction b)
        {
            return new Fraction(a.num * b.den + b.num * a.den,
               a.den * b.den);
        }

        // overload operator *
        public static Fraction operator *(Fraction a, Fraction b)
        {
            return new Fraction(a.num * b.num, a.den * b.den);
        }

        // user-defined conversion from Fraction to double
        public static implicit operator double(Fraction f)
        {
            return (double)f.num / f.den;
        }
    }


    class Program
    {
        static void Main()
        {
            Fraction a = new Fraction(1, 2);
            Fraction b = new Fraction(3, 7);
            Fraction c = new Fraction(2, 3);
            Console.WriteLine((double)(a * b + c));
            Console.ReadLine();
        }
    }
}