总结下遇到的C#新语法

1.属性的private set读写器

public int x { get; private set; }

是另一种简写, set前面的private声明是告诉编译器属性X是只读（read-only）的. 意思是对于外部类不能通过属性X给x赋值,而只能读取其值。

例子：

public class PswChangingEventArgs : EventArgs
    {
        public readonly string message;

        public PswChangingEventArgs(string _message)
        {
            this.message = _message;
        }
    }

    public class TestClass
    {
        public event EventHandler<PswChangingEventArgs> PasswordChanging;   // 普通非泛型EventHandler不支持自定义EventArgs

        private string _pwd;
        public string Pwd
        {
            get { return _pwd; }
            private set
            {
                if (string.IsNullOrEmpty(value))
                {
                    throw new ArgumentException("password cannot be empty");
                }
                if (_pwd != value)
                {
                    if (PasswordChanging != null) PasswordChanging(this, new PswChangingEventArgs("password已经改变"));
                }
                _pwd = value;
            }
        }

        public void Fun()
        {
            this._pwd = "abc";                 // 直接赋值，什么额外事情都不会发生
            this.Pwd = "efg";                  // 可以引发密码更改事件，可以进行校验
        }
    }

 class Program
    {
        static void Main(string[] args)
        {
            TestClass a = new TestClass();
            a.PasswordChanging += new EventHandler<PswChangingEventArgs>(ShowMessage);
            a.Fun();
            //a.Pwd = "1111";           //error，private set:外部不可写入
            Console.WriteLine("执行Fun()后password:" + a.Pwd);   //ok,外部可以读取

            Console.Read();
        }

        static void ShowMessage(object sender, PswChangingEventArgs e)
        {
            Console.WriteLine("执行Main()里的ShowMessage方法");
            Console.WriteLine("sender:"+sender.ToString() + ",message:" + e.message);
        }
    }

①.若直接用set，则类外部也可以访问通过Pwd属性读取、写入pwd字段了，扩大了访问权限，破坏了封装、隐蔽性

②.若不用set，则外部只可访问不可写入，但类内部方法虽可读取写入，但写入时不会应发对应操作，不便

③.为了对外隐藏pwd字段的写入（仍可读取），对内可以在写入时设定一些操作。

2.i??操作符:

?? 运算符称为 null 合并运算符，用于定义可以为 null 值的类型和引用类型的默认值。 如果此运算符的左操作数不为 null，则此运算符将返回左操作数；否则返回右操作数。

例子:

            //int i = null; //error
            int? i = null;
            Console.WriteLine(i);
            int j = i ?? 1;
            //等价如下：
            //int j = i.HasValue ? i.Value : 1;
            Console.WriteLine(i);
            Console.WriteLine(j);

3.默认参数，例如：

　　Fun(int a=1),调用时会看到提示Fun([int a=1]),a参数指不指定都合法。

class Program
    {
        static void Main(string[] args)
        {
            TestMethod("Foo");
            TestMethod("Foo", "Bar1");
            TestMethod("Foo", "Bar1", "Baz1");

            Console.Read();
        }

        static void TestMethod(string foo, string bar = "Bar", string baz = "Baz")
        {
            Console.WriteLine("{0, -5} - {1, -5} - {2, -5}", foo, bar, baz);
        }
    }

 4.readonly 关键字与const 关键字不同。

const 字段只能在该字段的声明中初始化,。 readonly 字段可以在声明或构造函数中初始化。

因此，根据所使用的构造函数，readonly 字段可能具有不同的值。 另外，const 字段为编译时常数，而 readonly 字段可用于运行时常数。

public class Test
    {
        public readonly string ConnectionString = "User ID=bbb;Password=aaa;Persist Security Info=True;Initial Catalog=xxx";    //声明时赋值
        public readonly string DatasourceName;                 //声明但不赋值

        public const string ErrorMessage = "数据库连接出错";   //只能在声明的时候定义.且在类外部调用时使用方法：Test.ErrorMessage;

        public Test(string _datasourceName, string _connectionString)                    //构造函数里给readOnly变量赋值。不可给const赋值。
        {
            DatasourceName = _datasourceName;
            ConnectionString = _connectionString;              //先执行上文的ConnectionString，再执行这里赋值。所以ConnectionString值将不再是上文的"User ID=bbb;Password=aaa; "
        }
    }