C#基础（一）

 

C#把数据类型分为两种
值类型 和 引用类型
这两种类型存储在内存的不同地方：值类型存储在堆栈中，而引用类型存储在托管堆上。

CTS类型
C#认可的基本预定义类型并没有内置于语言中，而是内置于.NET Framework中。例如，在C#中声明一个int类型的数据时，声明的实际上是.NET结构System.Int32的一个实例。

1. 整型

2.浮点类型

float f = 12.3F;

3. decimal类型

decimal d = 12.30M;

4. bool类型

如果试图使用0表示false，非0值表示true，就会出错。

5. 字符类型

char类型的字面量是用单引号括起来的，例如'A'。如果把字符放在双引号中，编译器会把它看作是字符串，从而产生错误。

6.预定义的引用类型

a.object类型
   object类型就是最终的父类型，所有内在和用户定义的类型都从它派生而来。
b.string类型
String对象保留在堆上，而不是堆栈上。当把一个字符串变量赋给另一个字符串时，会得到对内存中同一个字符串的两个引用。但是修改其中一个字符串，会创建一个全新的string对象，而另一个字符串没有改变（这实际上是运算符重载的结果）。
  字符串中的转义字符：/和@
   字符串的属性：
   Length 字符串的字符长度
   字符串的方法：
      s.TrimStart();
      s.TrimEnd();
      s.Trim();
      s.ToUpper();
      s.ToLower();
      s.ToCharArray();
      s.Substring(int start[,int length]);
      s.Split([int n]);
      s.Replace(string old,strinig new);
      s.LastIndexOf(string str);
     s.IndexOf(string str);
重复修改给定的字符串，效率会很低，它实际上是一个不可变的数据类型，一旦对字符串对象进行了初始化，该字符串对象就不能改变了。修改字符串内容的方法和运算符实际上是创建一个新的字符串。
如果使用string类型的变量对字符串进行大量的拼接的时候，就会在内存中产生大量的垃圾对象，并且每次拼接字符串的时候都会生成一个新的对象，这样是很影响程序的性能。为了解决这个问题，Microsoft提供了System.Text.StringBuilder类。

7.StringBuilder类
StringBuilder不像String功能那么强大，在StringBuilder上可以用在需要大量的修改字符串中的文本的场景中。但是，它的工作方式非常高效。
两个主要的属性
  Length指定字符串的实际长度；
   Capacity是字符串占据存储单元的长度。
最好把容量设置为字符串可能的最大长度，确保StringBuilder不需要重新分配内存。
StringBuilder构造函数
  StringBuilder sb = new StringBuilder("Hello"); //用一个字符串初始化StringBuilder
   StringBuilder sb = new StringBuilder(20); //初始化一个空的StringBuilder ，其容量是20个字符
   StringBuilder sb = new StringBuilder(100, 500); //初始化一个StringBuilder对象，其最初的容量是100个字符，最大容量是500字符。若是超范围就会产生异常

8.日期时间函数
属性：
  Now：当前时间
   Today：今天
   Year：时间的年份
   Month：时间的月份
   Day：时间的日期
   Hour：时间的小时
   Minute：时间的分钟
   Second：时间的秒
   DayOfWeek：时间的星期
   DayOfYear：时间是一年中的第几天
   Date：日期部分
方法：
AddYears：对年份计算
   AddMonths：对月份计算
   AddDays：对日期计算
   AddHours(int)：对小时计算
   AddMinutes(int)：对分钟计算
   AddSeconds(int)：对秒计算
   ToLongDateString()：把时间转换为本地的长日期格式，如：中国的“yyyy年MM月dd日”
   ToShortDateString()：把时间转换为本地的短日期格式，如：中国的“yyyy-MM-dd”
   ToLongTimeString()：把时间转换为本地的长时间格式，如：中国的“hh:mm:ss”
   ToShortTimeString()：把时间转换为本地的短时间格式，如：中国的“hh:mm”
  
9.格式化字符串
标准数字格式字符串
  C 或 c 货币：数字转换为表示货币金额的字符串。
D 或 d 十进制：只有整型才支持此格式。
   如：
   Console.WriteLine(MyDouble.ToString("C"));
    Console.WriteLine(MyDouble.ToString("E"));
    Console.WriteLine(MyDouble.ToString("P"));
    Console.WriteLine(MyDouble.ToString("N"));
    Console.WriteLine(MyDouble.ToString("F"));
   运算结果：
   $123,456,789.00
    1.234568E+008
    12,345,678,900.00%
    123,456,789.00
    1234567 .00
自定义数字格式字符串
  0 零占位符
   # 数字占位符
   . 小数点
   , 千位分隔符和数字比例换算
   % 百分比占位符
   如：
   double n = 1234567890.9;
     Response.Write(n.ToString("C")+"<br>");
     Response.Write(n.ToString("C4")+"<br>");
     Response.Write(n.ToString("RMB#,###.###")+"<br>");
     Response.Write(n.ToString("RMB#,###.000") + "<br>");
     Response.Write(n.ToString("RMB#")+"<br>");
    运行结果
   ￥1,234,567,890.90
    ￥1,234,567,890.9000
    RMB1,234,567,890.9
    RMB1,234,567,890.900
    RMB1234567891

格式化日期
   如：
   DateTime dt = DateTime.Now;
     Response.Write(dt.ToString("F")+"<br>");
     Response.Write(dt.ToString("yyyy年MM月dd日hh时mm分ss秒")+"<br>");
     Response.Write(dt.ToString("星期ddd"));
   运行结果：
   2008年7月10日 8:37:32
    2008年07月10日08时37分32秒
    星期四
  
10.常量
声明和初始化变量时，在变量的前面加上关键字const，就可以把该变量指定为一个常量。顾名思义，常量是其值在使用过程中不会发生变化的变量：
如：const int a = 100;
注意：
   常量必须在声明时初始化。指定了其值后，就不能再修改了。
  常量总是静态的。但注意，不必(实际上，是不允许)在常量声明中包含修饰符static。
  常量用易于理解的清楚的名称替代了“含义不明确的数字或字符串”，使程序更易于阅读。
   常量使程序更易于修改。
   常量更容易避免程序出现错误。可以防止把另一个值赋给程序中的一个常量。

11.枚举
枚举是用户定义的整数类型。所以枚举类型可以强制转换为整型。
如果在代码的某个地方，要试图把一个不在可接受值范围内的值赋予枚举的一个实例，编译器就会报告一个错误。
使用枚举比使用无格式的整数至少有如下三个优势：
  a.枚举可以使代码更易于维护，有助于确保给变量指定合法的、期望的值。
   b.枚举使代码更清晰，允许用描述性的名称表示整数值，而不是用含义模糊的数来表示。
   c.枚举使代码更易于键入。
枚举定义：
public enum TimeOfDay
   {
     Morning = 0,
     Afternoon = 1,
     Evening = 2
   }
使用枚举：
switch(timeOfDay)
   {
      case TimeOfDay.Morning:
         Console.WriteLine("Good morning!");
         break;
      case TimeOfDay.Afternoon:
         Console.WriteLine("Good afternoon!");
         break;
      case TimeOfDay.Evening:
         Console.WriteLine("Good evening!");
         break;
      default:
         Console.WriteLine("Hello!");
         break;
   }

12.数组
一维数组：
  int[] numbers = new int[]{1,2,3,4,5};
   string[] names = {“张三”,”李四”,”王五”}
多维数组：
  int[,] numbers = new int[3,2]{{1,2}{3,4}{5,6}};
   string[,] names = {{“张三”,”李四”}{“王五”,”赵六”}}
数组的数组：
  int[][] numbers = new int[2][]{new int[]{2,3,4},new int[]{5,6,7,8,9}}

13.集合
a.IEnumerable和IEnumerator接口
  IEnumberable接口是大部分集合类型的根。
  它是一个支持foreach迭代的接口，一个集合对象要能遍历所有对象的话，那它必需要实现这个接口，它的声明结构如下：
  public interface IEnumerable
   {
    IEnumerator GetEnumerator ();
   }
  其中的GetEnumerator方法返回的是IEnumerator类型
  IEnumerator接口的声明如下：
public interface IEnumerator
   {
    //获取集合中的当前元素。
    Object Current { get; }
    //如果枚举成功推进到下一个元素，则为 true；如果枚举数越过集合的结尾，则为 false。
    bool MoveNext ();
    //将枚举数设置为其初始位置，该位置位于集合中第一个元素之前。
    void Reset () ;
   }
b.ICollection接口
  ICollection接口派生自IEnumerable接口，扩展了集合元素个数和同步功能(对多线程安全访问的支持)。
   ICollection接口的声明：
public interface ICollection : IEnumerable
   {
    //ICollection集合中元素的个数
    int Count { get; }
    //获取是否同步对ICollection 的访问
    bool IsSynchronized { get; }
    //获取用于同步ICollection访问的对象。
    Object SyncRoot { get; }
   }
   可以在对集合元素遍历的时候，把集合锁定，以防其它线程（用户）对集合的修改。
  ArrayList al = new ArrayList();
   al.Add("aaa");
   al.Add("bbb");
  lock (al.SyncRoot)
   {
    for(int i=0;i<al.Count;i++)
    {
     Console.WriteLine(obj);
    }
   }
c.IList接口
IList是一个值的集合，派生自ICollection，其成员可以通过索引访问。如ArrayList
  public interface IList : ICollection, IEnumerable
   {
    //将某项添加到IList集合中
   int Add(object value);
    //从 IList 中移除所有项。
   void Clear ();
    //确定 IList 是否包含特定值。
    bool Contains (Object value);
    //取得IList集合中指定项的索引号。
   int IndexOf (Object value);
    //将一个项插入IList集合的指定索引处。
   void Insert (int index,Object value);
    //从IList集合中移除指定的项对象。
   void Remove(object value);
    //从IList集合中移除指定索引项的对象。
   void RemoveAt(int index);
    //指示IList 是否具有固定大小。大小固定的集合在创建之后不允许添加或移除元素，但允许修改现有元素。
    bool IsFixedSize { get; }
    //IList 是否为只读。只读集合在创建之后不允许添加、移除或修改元素。
    bool IsReadOnly { get; }
    //获取或设置指定索引号元素的内容。可以使用此索引器实现集合元素的循环遍历。
   Object this [int index] { get; set; }
   }
d.IDictionary接口
IDictionary接口实现一个“键/值”对的集合，派生自ICollection，可以用循环遍历其中的每一个元素。其中的每个"键/值"对是一个DictionaryEntry 对象，只能用键名来存取对象，不能用索引号来存取对象。
  public interface IDictionary : ICollection, IEnumerable
   {
    //在IDictionary集合中添加键和值对元素。
   void Add (Object key,Object value);
    //从 IList 中移除所有项。
   void Clear ();
    //确定 IList 是否包含特定值。
   bool Contains (Object value);
    //返回一个用于 IDictionary 集合的 IDictionaryEnumerator 对象。
    IDictionaryEnumerator GetEnumerator ();
    //从集合中移除指定键值的元素
   void Remove (Object key);
    //指示IList 是否具有固定大小。大小固定的集合在创建之后不允许添加或移除元素，但允许修改现有元素。
    //IList 是否为只读。只读集合在创建之后不允许添加、移除或修改元素。
    bool IsFixedSize { get; }
    bool IsReadOnly { get; }
   Object this [Object key] { get; set; } //获取或设置具有指定键的元素。
   ICollection Keys { get; } //获取IDictionary中的所有的键集合。
    ICollection Values { get; } //获取IDictionary中的所有的值集合。
   }
e.ArrayList类
  ArrayList类实现了IList接口，用来存储非泛型对象。
Count属性：集合中实际元素的个数。
  Capacity属性：ArrayList空间的大小。生成一个ArrayList对象的时候默认分配了4个元素的空间(默认)，在添加前4个元素的时候Capacity始终是4。当添加第5个元素的时候，首先框架会把ArrayList的Capacity的容量加倍，然后再把第5个元素存入。
   void AddRange (ICollection c)：将一个新的ICollection对象加到当前ArrayList后面，通常用来拼接两个ArrayList。
   ArrayList GetRange (int index,int count)：从当前的ArrayList对象中返回指定位置和指定数目的元素，并将这些元素以新的ArrayList对象形式返回。
   void InsertRange(int index,ICollection c) ：在指定的位置插入另一个ICollection对象。
  void TrimToSize()：将ArrayList的容量缩减到ArrayList的实际的元素个数。
void Reverse() ：将数组的顺序进行返转。
  void Sort()：将数组进行排序。
f.Hashtable类
  Hashtable实现了IDictionary接口，可以用来存储非泛型对象。由于Hashtable实现的是IEnumerable接口，所以可以用foreach对Hashtable进行遍历。
   void ContainsKey(object o)//判断Hashtable 是否包含指定键
   void ContainsValue(object o)//判断Hashtable是否包含指定的值。
   Hashtable Hashtable.Synchronized (Hashtable t) //静态方法，将一个普通的Hashtable包装为一个同步的(线程安全)Hashtable。
   如：
   Hashtable h = new Hashtable();
    h.Add("a","aaaa");
    h.Add("b", "bbbb");
   IEnumerator ie = h.GetEnumerator();
    while (ie.MoveNext())
    {
     Console.Write(((DictionaryEntry)ie.Current).Key + "/t" + ((DictionaryEntry)ie.Current).Value+"/n");
    }
g.Queue类和Stack类
   这两个类都实现了ICollection接口和IEnumerable接口，但没有实现IList接口。
Queue类：
   Queue：队列，先进先出。
    Enqueue(object var)：入队
    object Dequeue() ：出队
    object Peek()：返回队首的元素，但不移除。出队和入队都分影响Queue对象的元素的个数，即影响其Count属性。
   Queue q = new Queue();
    q.Enqueue("aaa");
    q.Enqueue("bbb");
    q.Enqueue("ccc");
    for (int i = 0; i < 3; i++) //这里用的是i<3而不是i<q.Count，因为Dequeue的过程中会影响q.Count。
    {
     Console.WriteLine(q.Dequeue());
    }
  Stack类：
   Stack：堆栈，先进后出。
    Push(object var)： //进栈
    object Pop() ： //出栈
    object Peek()： //返回栈顶元素，但不移除入栈和出栈都会影响Stack的元素个数。
   Stack s = new Stack();
    s.Push("aaa");
    s.Push("bbb");
    s.Push("ccc");
    for (int i = 0; i < 3; i++) //这里用的是i<3而不是i<s.Count，因为Pop的过程中会影响s.Count。
    {
     Console.WriteLine(s.Peek());
    }
h.NameValueCollection类
   类似于有序的字符串值和字符串键的集合，它并没实现IDictionary接口。
  string[] AllKeys属性：所有键的字符串数组。
   bool HasKeys()：集合对象中是否包含"键/值"对。
   string Get(int index/string key)：根据索引号或键名来取得元素的值。
   string GetKey(int index)：根据索引号取得键名。
   对NameValueCollection集合对象的遍历：
  NameValueCollection nvc = new NameValueCollection();
   nvc.Add("a", "aaa");
   nvc.Add("b","bbb");
   nvc.Add("c","ccc");
   foreach (string s in nvc.AllKeys)
   {
    Console.WriteLine(nvc[s].ToString());
   }
  
14.拆箱装箱
拆箱：把数据由引用类型变换为值类型。把数据由堆空间转换到栈空间。
装箱：把数据由值类型变换为引用类型。把数据由栈空间转换为堆空间。
装箱：
   int I = 10;
   object o = (object)I;
拆箱：
   object 0 = 10;
   int I = (int)o;

15.流程控制
条件语句
   if (条件)
   {
      statement(s)
   }
   else if(条件)
   {
    statement(s)
   }
   else
   {
      statement(s)
   }
   添加到if子句中的else if语句的个数没有限制
switch语句
   switch...case语句适合于从一组互斥的分支中选择一个执行分支。它只对一个个离散的常量值进行分支判，而if...else if...else可以对连续的区间进行判断
   switch (integerA)
   {
     case 1:
        Console.WriteLine("integerA =1");
        break;
     case 2:
        Console.WriteLine("integerA =2");
        break;
     case 3:
        Console.WriteLine("integerA =3");
        break;
     default:
        Console.WriteLine("integerA is not 1,2, or 3");
        break;
   }
   注意case的值必须是常量表达式——不允许使用变量。
for循环
   for (initializer; condition; iterator)
   {
    statement(s)
   }
while循环
   while(condition)
   {
   statement(s);
   }
foreach循环
   foreach循环可以迭代集合中的每个项目。foreach循环一次迭代数组中的一个元素。
   foreach (int temp in arrayOfInts)
   {
    statement(s)
   }
break语句
   break也可以用于退出for、foreach、while或do...while循环，循环结束后，立即执行后面的语句。
continue语句
   用于for、foreach、while或 do...while循环中。但它只从循环的当前迭代中退出，然后在循环的下一次迭代开始重新执行，而不是退出循环。
return语句
   return语句用于退出类的方法，把控制返回方法的调用者，如果方法有返回类型，return语句必须返回这个类型的值，如果方法没有返回类型，应使用没有表达式的return语句。

16.运算符：

is运算符
is运算符可以检查对象是否与特定的类型兼容。例如，要检查变量是否与object类型兼容：
   “兼容”是指对象是该类型，或者派生于该类型。
int i = 10;
   if (i is object)
   {
     Console.WriteLine("i is an object");
   }
as运算符
  as运算符用于执行引用类型的显式类型转换。如果要转换的类型与指定的类型兼容，转换就会成功进行；如果类型不兼容，as运算符就会返回值null。
  object o1 = "Some String";
   object o2 = 5;
   string s1 = o1 as string;      //s1 = "Some String"
   string s2 = o2 as string;     //s1 = null
typeof运算符
   Typeof运算符返回一个表示特定类型的Type对象。例如，typeof(string)返回表示System.String类型的Type对象。在使用反射动态查找对象的信息时，这个运算符是很有效的。