c# 基础 一些与c++不同的

0
对象（Object）类型
对象（Object）类型 是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。
当一个值类型转换为对象类型时，则被称为 装箱；另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。
object obj;
obj = 100; // 这是装箱

动态（Dynamic）类型
您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。
声明动态类型的语法：
dynamic <variable_name> = value;
dynamic d = 20;

1
Console.ReadKey();
Console.ReadLine():
readline 按enter结束
readkey 按任意非功能键（字符） 结束

2
&  |   ^  与或非
~ 按位取反运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0，包括符号位。
<<   二进制左移运算符。左操作数的值向左移动右操作数指定的位数。
>>  二进制右移运算符。左操作数的值向右移动右操作数指定的位数。

3
Protected：只有该类对象及其子类对象可以访问
Internal：同一个程序集的对象可以访问；
Protected internal：该程序集内的派生类访问，是protected和internal的交集；

4
ref
则方法定义和调用方法都必须显式使用ref关键字。ref是 Reference的缩写。

5
out
使用 输出参数 来从函数中返回两个值。输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似。
public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }
int a = 100;
n.getValue(out a);

6
可空类型（Nullable）
可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。
< data_type> ? <variable_name> = null;

Null 合并运算符（ ?? ）
如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值。
 double? num1 = null;
 num3 = num1 ?? 5.34;  
 Console.WriteLine("num3 的值： {0}", num3);
-----------num3 的值： 5.34


7
声明数组
datatype[] arrayName;
double[] balance;
double[] balance = new double[10];
balance[0] = 4500.0;
int [] marks = new int[5]  { 99,  98, 92, 97, 95};

使用 foreach 循环
在前面的实例中，我们使用一个 for 循环来访问每个数组元素。您也可以使用一个 foreach 语句来遍历数组。
 int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */
 /* 初始化数组 n 中的元素 */         
 for ( int i = 0; i < 10; i++ )
 {
            n[i] = i + 100;
 }
         /* 输出每个数组元素的值 */
         foreach (int j in n )
  {
            int i = j-100;
            Console.WriteLine("Element[{0}] = {1}", i, j);
    }
j是从n中取得的值，第一个是100，第二个是101.。。第十个是109


Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109


8
using System;
namespace StringApplication
{
    class Program
    {
        static void Main(string[] args)
        {
           //字符串，字符串连接
            string fname, lname;
            fname = "Rowan";

            lname = "Atkinson";

            string fullname = fname + lname;
            Console.WriteLine("Full Name: {0}", fullname);

            //通过使用 string 构造函数
            char[] letters = { 'H', 'e', 'l', 'l','o' };
            string greetings = new string(letters);
            Console.WriteLine("Greetings: {0}", greetings);
            //方法返回字符串
            string[] sarray = { "Hello", "From", "Tutorials", "Point" };
            string message = String.Join(" ", sarray);
            Console.WriteLine("Message: {0}", message);
            //用于转化值的格式化方法
            DateTime waiting = new DateTime(2012, 10, 10, 17, 58, 1);
            string chat = String.Format("Message sent at {0:t} on {0:D}", 
            waiting);
            Console.WriteLine("Message: {0}", chat);
            Console.ReadKey() ;
        }
    }
}

显示
Full Name: RowanAtkinson
Greetings: Hello
Message: Hello From Tutorials Point
Message: Message sent at 17:58 on Wednesday, 10 October 2012

9 
结构体与类
1、类是引用类型，结构是值类型。（既然class是引用类型，class可以设为null。但是我们不能将struct设为null,因为它是值类型。）
2、结构不支持继承。
3、结构不能声明默认的构造函数。

10  
enum  枚举
enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };
默认情况下，第一个枚举符号的值是 0.
Days.Mon  1
Days.Fri  5

11 
类的 构造函数 是类的一个特殊的成员函数，当创建类的新对象时执行。

析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。析构函数不能继承或重载。

静态成员和静态函数
static 关键字把类成员定义为静态的。当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个该静态成员的副本。
也可以把一个成员函数声明为 static。这样的函数只能访问静态变量。静态函数在对象被创建之前就已经存在。


using System;
namespace StaticVarApplication
{
    class StaticVar
    {
       public static int num;
        public void count()
        {
            num++;
        }
        public static int getNum()
        {
            return num;
        }
    }
    class StaticTester
    {
        static void Main(string[] args)
        {
            StaticVar s = new StaticVar();
            s.count();
            s.count();
            s.count();                   
            Console.WriteLine("变量 num： {0}", StaticVar.getNum());
            Console.ReadKey();
        }
    }
}

变量 num： 3

12 继承
基类 Person 和派生类 Employee 都有一个名为 Getinfo 的方法。通过使用 base 关键字，可以从派生类中调用基类的 Getinfo 方法。
using System;
public class Person
{
    protected string ssn = "444-55-6666";
    protected string name = "John L. Malgraine";
    public virtual void GetInfo()
    {
        Console.WriteLine("Name: {0}", name);
        Console.WriteLine("SSN: {0}", ssn);
    }
}
class Employee : Person
{
    public string id = "ABC567EFG";
    public override void GetInfo()
    {
        // Calling the base class GetInfo method:
        base.GetInfo();
        Console.WriteLine("Employee ID: {0}", id);
    }
}

class TestClass
{
    static void Main()
    {
        Employee E = new Employee();
        E.GetInfo();
    }
}

本示例显示如何指定在创建派生类实例时调用的基类构造函数。
using System;
public class BaseClass
{
    int num;
    public BaseClass()
    {
        Console.WriteLine("in BaseClass()");
    }
    public BaseClass(int i)
    {
        num = i;
        Console.WriteLine("in BaseClass(int i)");
    }
    public int GetNum()
    {
        return num;
    }
}


public class DerivedClass : BaseClass
{
    // This constructor will call BaseClass.BaseClass()
    public DerivedClass() : base()
    {
    }
    // This constructor will call BaseClass.BaseClass(int i)
    public DerivedClass(int i) : base(i)
    {
    }
    static void Main()
    {
        DerivedClass md = new DerivedClass();
        DerivedClass md1 = new DerivedClass(1);
    }
}


13
abstract class是抽象类.比如说,圆形和三角形都是形状.圆形和三角形有具体的表现方式,可以说是具体类.而形状没办法具体表现出来,就是抽象类.抽象类可以有自己的属性,可以有非abstract 的方法.
请注意，下面是有关抽象类的一些规则：
您不能创建一个抽象类的实例。
您不能在一个抽象类外部声明一个抽象方法。
通过在类定义前面放置关键字 sealed，可以将类声明为密封类。当一个类被声明为 sealed 时，它不能被继承。抽象类不能被声明为 sealed。
当有一个定义在类中的函数需要在继承类中实现时，可以使用虚方法。虚方法是使用关键字 virtual 声明的。虚方法可以在不同的继承类中有不同的实现。对虚方法的调用是在运行时发生的。
动态多态性是通过 抽象类 和 虚方法 实现的。

interface是接口.相当于某些具体对象的交叉点,这个点本身不能做什么,只能把操作传达给各个具体的对象,让对象自己去执行.接口的数据成员必须是静态且不能修改的(static final),所有的方法都是虚方法.