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

来源：互联网发布：奥迪工程师编程教程编辑：程序博客网时间：2024/05/16 12:27

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();        }    }}

0 0