using System; 
   
namespace MyProgram 
{ 
  class Program 
  { 
    static void Main(string[] args) 
    { 
      //变量的定义格式： 
      //数据类型 变量名 赋值运算符 值 
      int a = 10; // 定义一个整数类型的变量a 并赋值10 
      int b = 20; // 定义一个整数类型的变量b 并赋值20 
   
      int c = a + b;//定义一个整数类型的变量b 赋值为 a + b 的和 
         
      Console.WriteLine("10 + 20 = "+c.ToString());//打印结果 
    } 
  } 
}

using System; 
   
namespace MyProgram 
{ 
  class Program 
  { 
    static void Main(string[] args) 
    { 
      int a = 20; //定义一个整数类型的变量 
      char b = 'A';//定义一个字符类型的变量 
   
      var _intType = 20; //定义一个匿名类型的变量 给赋值一个整数数字 20 
      var _charType = 'A'; //定义一个匿名类型的变量 给赋值一个字符 A 
   
      Console.WriteLine(" a 的数据类型为:{0}",a.GetType().ToString()); //打印出变量a的数据类型 
      Console.WriteLine(" b 的数据类型为:{0}", b.GetType().ToString()); //打印出变量b的数据类型 
   
      Console.WriteLine(" _intType 的数据类型为:{0}", _intType.GetType().ToString());//打印出变量_intType的数据类型 
      Console.WriteLine(" _charType 的数据类型为:{0}", _charType.GetType().ToString());//打印出变量_charType的数据类型 
    } 
  } 
}

class MyClass 
{ 
  int a = 10; 
   
  public void MyMethod() 
  { 
    int a = 20; //方法内部变量与类属性变量 a同时出现时， 以当前方法内（作用域的变量为准） 
    Console.WriteLine("a:{0}",a); //输出结果为20 
   
    int a = 30; // 编译错误，同一个作用域内不可以出现相同名称的变量 
  } 
}

class MyClass 
{ 
  public int a = 10; //第一种初始化方法在定义是就赋值 
  public bool b; //默认值为false 
  public MyClass(bool c) 
  { 
    b = c; //通过构造函数初始化类属性 
  } 
} 
   
class Program 
{ 
  static void Main(string[] args) 
  { 
    MyClass mc = new MyClass(true);//通过构造函数传入true 赋给参数bool类型变量c = true 
    Console.WriteLine("mc->a :{0}", mc.a.ToString()); 
    Console.WriteLine("mc->b :{0}",mc.b.ToString()); 
  } 
}

using System; 
   
namespace MyProgram 
{ 
  class MyClass 
  { 
    public int a = 10; //变量a为对象级别属性 
    public static int b = 20; //变量b为类级别属性 
  } 
   
  class Program 
  { 
    static void Main(string[] args) 
    { 
      MyClass mc = new MyClass(); 
      int a_Mc = mc.a; //变量级别需要创建对象MC后通过MC（对象）来访问 
   
      int b_MyClass = MyClass.b; //类属性可直接通过类名访问无需创建对象 
   
      Console.WriteLine("mc->a :{0}", a_Mc); 
      Console.WriteLine("MyClass->b :{0}", b_MyClass); 
    } 
  } 
}

using System; 
   
namespace MyProgram 
{ 
  class MyClass 
  { 
    public const int a = 10; //定义常量a 
    public const bool b = false; //定义常量b 
  } 
   
  class Program 
  { 
    static void Main(string[] args) 
    { 
      int a_Const_MyClass = MyClass.a; //常量必须是静态的，通过类名访问 
   
      bool b_Const_MyClass = MyClass.b; //常量必须是静态的，通过类名访问 
   
      Console.WriteLine("MyClass->a_Const :{0}", a_Const_MyClass.ToString()); 
      Console.WriteLine("MyClass->b_Const :{0}", b_Const_MyClass.ToString()); 
   
      //任何试图修改常量的动作都会引起编译错误 
      MyClass.a = 20;  
      MyClass.b = true; 
    } 
  } 
}

using System; 
   
namespace MyProgram 
{ 
  class MyClass 
  { 
    public readonly int a = 10; //定义只读变量a 
    public static readonly bool b = false; //定义静态只读变量b 
  } 
   
  class Program 
  { 
    static void Main(string[] args) 
    { 
      MyClass mc = new MyClass(); 
      int a_ReadOnly_MC = mc.a; //只读变量是非静态的，由对象级别访问 
   
      bool b_StaticReadOnly_MyClass = MyClass.b; //静态只读变量是类级别变量，有类名访问 
   
      Console.WriteLine("a_ReadOnly_MC : {0}",a_ReadOnly_MC); 
      Console.WriteLine("b_StaticReadOnly_MyClass :{1}", b_StaticReadOnly_MyClass); 
   
      //任何对只读类型的修改都将引起编译错误 
      mc.a = 20; 
      MyClass.b = true; 
    } 
  } 
}