C#笔记

第一章_基本语法

C#概述

• C#运行环境
  .NET框架，是生成和运行.NET应用程序和Web Service的组件库，包括.net framework类库和公共语言运行库(CLR)
  .net framework类库：标准库。
  CLR：类似JAVA虚拟机，将C#编译为IL中间语言(Intermediate Language)。

• C#可创建的程序
  C#可创建的程序：控制台应用程序，Windows窗体应用程序，Web应用程序

• 命名空间
  对类的一种划分形式，命名空间和类的关系类似于目录和文件的关系，引入方法using spacename;

• Main方法
  应用程序的入口点；声明为static void Main(string[] args)，返回值只能是void或者int；可以放在任何一个类中，一个应用程序中必须有一个类包含Main方法。

C#基本数据类型

• 数据类型
  分为值类型和引用类型，值类型存的是数据，在栈中；引用类型则存引用数据的指针，在堆中。
  值类型：简单类型、枚举类型、结构类型、可空类型，存储在栈(但若在类内定义，则存储在堆)。
  引用类型(对象)： 类、接口、数组，存储在堆，赋值时传的是引用，通常被称为对象。

• 整型和浮点型
  int：4字节有符号，short：2字节有符号，long：8字节有符号
  float：4字节浮点数。
  double：8字节浮点数。
  decimal：16字节浮点数，精度高，适用于金融、货币等领域

• 类型转换
  分为隐式类型转换和显示类型转换
  隐式类型转换：小范围类型->大范围类型，程序自动转换，不会丢失数据
  显示类型转换：大范围类型->小范围类型，要手动强转，可能会丢失精度。

• 装箱与拆箱
  主要作用是实现值类型和引用类型的相互转换，让值类型可以使用引用类型的一些方法。
  Object/object类型：所有类型的基类

  //装箱：将值类型转换为object类型，会在堆上为其分配一个object对象的实例
  int i=5;
  object o = i;
  
  //拆箱：将object类型转换为值类型，必须先装箱再拆箱。
  int k = (int) o;

判断是否要强转：苹果是水果，水果不是苹果。

• 常量类型
  const：编译时初始化，所以不能用变量初始化赋值，且声明和初始化必须在一起。
  readonly：运行时初始化，声明和初始化可以分开，可用变量初始化赋值，但赋值后值就不能更改。

• 匿名类型var

  //无需指定具体类型，常用于foreach语句
  //foreach语句多用于集合操作中
  int[] arr = new int[]{1,2,3,4};
  foreach (var i in arr){
      Console.write(i);  //输出1234
  }

程序控制语句

控制台输入输出

//控制台输入
String str = Console.ReadLine();   //读取一行字符。

//控制台输出
Console.Write("123");                       //不换行
Console.WriteLine("3+{0}={1}", i, i+3);     //换行，格式化输出，0、1表序号
Console.WriteLine("{0:F4}",x);  //格式化输出，小数点后4位

//tostring用法，将数字转化为一定格式的字符串
int a = 12345;
double b = 1.2345;
String str1 = a.toString("d8");  //转换为8位字符串，位数不够用0补
String str2 = b.toString("f3");  //四舍五入保留3位小数，不够时用0补

//String转整型
int a = Int32.Parse(str);

基本流程控制语句

• switch case语句

  switch case语句
  int n = 3;
  switch (n)
  {
      case (1):
          Console.WriteLine("1");  //case后可以加{}，也可以不加
          break;
      case (2):
          Console.WriteLine("2");
          break;
      default:
          Console.WriteLine("3");
          break;
  }

• while语句

  while (条件)
  {
      //语句序列
  }
  
  do
  {
      //语句序列
  }while (条件);  //注意分号

注：while和do whiley语句都是条件不满足时跳出循环，唯一的区别是do while语句至少会执行一次。

• foreach语句

  int[] myInt={1,2,3};
  foreach(int i in myInt)
  {
      Console.WriteLine(i);
  }

注：循环变量i是只读的，不能更改值

• try-catch语句

  try
  {
      //语句序列
  }
  catch(Exception err)
  {
      //异常处理
  }
  finally
  {
      //语句序列
  }

注：finally语句块加不加都可以，如果加了，就是无论有没有捕获到异常，finally中的语句都会执行。

• throw语句

  //用法1，throw 异常表达式
  throw new Exception("方法中抛出的异常");
  
  //用法2，直接 throw
  //只能用在catch块中，重新抛出当前由catch块处理的异常。
  catch(Exception err)
  {
      throw;
  }

第二章_常用数据类型的用法

String类型

//初始化
String a = "str"; 

string b = a;  //传值

char c = b[1];  //取某字符

String.Compare(string s1,string s2)
//s1>s2，结果为1；s1=s2，结果为0；s1<s2，结果为-1。
//字符串大小是一一比较字符，比较对应字符的ASCII码大小

//判断字符串是否相等
if(b==a)

//判断字符串中是否包含指定的子字符串
string str1 = "this is a string";
bool b=str1.Contains("is");

//截取字符串
//从startIndex开始，截取conut个字符
//字符串的序号都是从0开始
str.Subtring(int startIndex，int count)

注：C#中string是String的别名，两者等价，编译器编译时会将string转换为String。

数组类型

• 基本使用方法
  数组是一种引用类型，而非值类型。
  声明数组：int[] a = new int[10]

  //数组是引用类型，而非值类型。
  //可动态申请
  int[] a = new int[30];   //一维数组
  
  int[,] ar = new int[3,2];  //二维数组，形式是括号内逗号分隔[,]
  for(int i = 0; i < 3; ++i)
  {
      for(int j = 0; j < 2; ++j)
      {
          ar[i,j] = i + j;
      }
  }
  
  //交错数组，数组的数组，每个一维数组元素也是一个数组，“数组的数组”。
  //形式为两个括号。
  int[][] ar = new int[5][];  //只指定行数即可
  for (int i = 0; i < 5; ++i)
  {
      ar[i] = new int[i + 1];
      for (int j = 0; j < i + 1; ++j)
      {
          ar[i][j] = j+1;
      }
  }

注：二维数组和交错数组的区别，二维数组每行列数一样，交错数组不一定。

• 动态改变数组大小
  函数原型：public static void Resize<T>(ref T[ ] array, int newSize)
  使用了泛型的概念，T表示数组类型，array表示要调整的数组，newSize表示要调整为多大。
  若newSize>array.Length，则分配一个新数组，并将所有元素复制到新数组。
  若newSize<array.Length，则分配一个新数组，并将元素复制到新数组直至填满，剩余元素将被忽略。

  int[] array = new int[5] { 0, 1, 2, 3, 4 };
  Array.Resize<int>(ref array, 10);  //ref为传引用关键字，必须显示传入

枚举类型

枚举是一组命名常量的集合，为一组在逻辑上紧密联系的整数值提供便于记忆的符号，从而使代码更清晰。

//手动赋值
enum days {Mon=0, Tue=1, Wed=2};
//默认赋值(默认为int，从0开始)
enum days {Mon, Tue, Wed};
//使用方法
days d1 = days.Mon

注1：enum都是使用专门的类型名，名字对应的数值使用的不多。
注2：enmu只能在类外部、namespace内部定义，不能在类里面定义

泛型

• 基本概念
  泛型可简单地理解为“广泛的数据类型”，就是说，泛型是数据类型的一种通用表示形式，可以表示任意一种数据类型。
  具体形式：泛型是具有占位符（类型参数）的类、结构、接口和方法，它与普通类的区别是泛型多了表示类型的占位符<T>，定义时无需指定具体类型，创建实例时才指定类型。

  //定义
  public class MyClass<T>
  {
      public T MyProp;   //定义属性MyProp
      public void Print( )
      {
          Console.WriteLine(MyProp);
      }
  }
  //创建实例
  MyClass<int> c1 = new MyClass<int>();
  c1.MyProp = 15;
  MyClass<String> c2 = new MyClass<String>();
  c2.MyProp = "1234";

常用泛型集合

• 泛型集合的特点
  非泛型集合如ArrayList、Stack等，无法在编译前确定数据类型，因此在运行时可能会进行频繁地进行数据类型转换，降低运行效率，因此推荐使用泛型集合类，尽量不要使用其对应的非泛型集合类。

列表List

• 基本特点
  List<T>可通过下标索引、允许重复元素、按插入顺序排序、可使用foreach语句遍历

• 具体用法

  List<String> li = new List<String>();
  li.Add("张三");  //末尾插入元素
  li.Add("李四");
  li.Insert(1,"李大");  //在指定位置插入元素
  Console.WriteLine(li[1]);   //按下标索引
  foreach(var i in li){
      //处理程序
  }

链表LinkedList

• 基本特点
  LinkedList<T>为双向链表，其中的每个节点都属于LinkedListNode类型，通过.Previous和.Next和属性指向其前后节点。
  不能通过下标索引，可以重复元素，可以foreach遍历

• 具体用法

  String[] word = { "a", "b", "c" };
  LinkedList<String> list = new LinkedList<string>(word); //用数组初始化
  list.AddFirst("dog");
  LinkedListNode<String> n1 = list.Find("a");  //通过值来查找某个节点
  LinkedListNode<String> n2 = n1.Next;       //.Next访问下一个节点
  Console.WriteLine(n2.Value);  //输出b
  foreach(var i in list)  //foreach遍历
  {
      Console.Write(i);
  }
  Console.WriteLine();

队列Queue

• 基本特点
  Queue<T>表示先进先出集合，在按接收顺序存储消息的情况下非常有用，元素在一端插入，在另一端移除。
  允许重复元素、可以保存null值、不能下标索引

• 具体用法

  Queue<string> q = new Queue<string>();
  q.Enqueue("one");  //Enqueue方法在队列末尾添加元素
  q.Enqueue("two");
  q.Enqueue("three");
  q.Dequeue();    //Dequeue方法删除队列头部元素
  foreach(var i in q)
  {
      Console.Write(i + " ");   //输出 two three
  }
  Console.WriteLine();

堆栈Stack

• 基本特点
  Stack<T>表示后进先出集合，适用于递归的相关情况。
  允许重复元素、可以保存null值、不能下标索引

• 具体用法

  Stack<String> st = new Stack<string>();
  st.Push("one");   //元素入站
  st.Push("two");
  st.Push("three");
  st.Pop();  //栈顶元素出栈
  foreach(var i in st)
  {
      Console.WriteLine(i + " ");  //输出 one two
  }
  Console.WriteLine();

时间类型DateTime

DateTime：表示时间点；TimeSpan：表示时间间隔。

DateTime now = DateTime.Now;  //获取当前时间
DateTime dt = new DateTime(2018,6,30);  //手动构造时间
Console.WriteLine(dt.toString("yyyy年M月d日"));   //格式化时间类型，输出2018年6月30日

//时间计算
DateTime dt = new DateTime(2010, 10, 3);
DateTime dt2 = new DateTime(2009, 10, 3);
TimeSpan times = now - dt2;
Console.WriteLine(times);
//输出为365.00:00:00，格式为TimeSpan，天.时:分:秒的格式

第三章_面向对象编程基础

类

• 类和对象
  类：一组具有相同数据结构和相同操作的对象的集合，类声明默认为private。
  对象：类的实例化。

  //定义类的的格式，[]表示可省略
  [附加声明] [访问修饰符] class 类名称[：[基类] [，接口序列]]
  {
      [字段声明]
      [构造函数]
      [方法]
      [事件]
  }

• 访问修饰符
  Public：类的数据成员和方法可以在外部使用。
  private：默认访问修饰符，类中的所有方法和数据成员只能在此类中使用，外部无法使用。
  Protected：本身和继承此类的子类可以使用。
  Partial：局部类型，类的定义和实现可以分布在多个文件中，但都要使用partial标注。

• 构造函数
  构造函数是一个特殊的方法，用于在建立对象时进行初始化的动作。
  1、每个类至少有一个构造函数。
  2、一个构造函数总是和它的类名相同。
  3、构造函数的声明不写任何返回值，void都没有。
  4、构造函数总是public的。

• 默认构造函数
  若程序代码中没有构造函数则系统会自动提供一个默认的构造函数
  默认构造函数没有参数，会为非静态成员变量初始化，int/double->0，bool->false，引用类型->null（静态成员变量不赋值的话会默认初始化赋值为0）。

• 类的静态成员
  在类内被声明为Static的成员，被类的所有对象所共享。
  静态变量不是存储在某一个对象中的，其存储在专门的一片内存区域中，因此一个对象更改了它的值，其他对象会共享这个改变。
  必须通过类来访问，不能通过对象来访问。

• 字段、局部变量、属性
  字段：定义在类一级别，就是类的成员变量
  局部变量：定义在类的方法内部的变量
  属性：带有{get; set;}声明的字段。

结构(struct)

struct是由一系列变量组织在一起而构成的数据表示形式，所有结构类型都隐式地从类型object继承。

public struct Point{
    public int x;
    public int y;
}

结构和类的区别：
结构类型是值类型，类类型是引用类型。
凡是定义为结构的，都可以用类来定义。
创建轻量级对象时，可以使用结构。

方法

• 方法的定义
  因为其是属于类的函数，因此定义方法必须放在某个类中。

  访问修饰符 返回值类型 方法名称(参数列表){
      程序
  }

• 方法的参数传递
  1、传值：为形参申请新的内存空间，复制实参的值到形参中。在函数内操作的是形参，对实参没有影响。
  2、传引用：格式为fun(ref 参数类型 参数名)，需要加上ref(reference)关键字，这时不再为形参申请新的空间，形参相当于实参的别名，函数内操作的就是实参。
  3、输出多个引用类型的参数：有时方法的计算结果可能有多个，但return只能返回一个结果，这时就可以用out关键字，使用该参数来接收输出值。

  public static void MyMethod(out int a, out int b) {
      a = 5;
      b = 6;
  }
  static void Main(){   
      int x, y;
      MyMethod(out x, out y);
  }

• 方法重载
  具有相同的方法名，但参数类型或参数个数不同的方法。
  重载方法的参数列表必须不同，不能只有返回值不同

属性和索引器

属性

带有{get; set;}声明的字段。
作用：给外部提供读写private成员的途径。
步骤：
1、为private成员定义一个对应的public成员。
2、为public成员定义get、set属性，并编写读写时的检查代码。
3、通过访问public成员来读写私有成员。

//具体用法
private string name;
public string Name{
    //定义检查操作
    get{
        return name != null? name: string.Empty;   //修改的是name的值
    }
    set{
        name = value;
    }
}
//最后通过xx.Name来间接修改name的值，同时会执行检查操作

//简化写法
//意义将公有成员设为read-only或write-only 
public int a{get; set;}           //可以这么写，但没什么意义
public int b{get; private set;}   //read-only
public int c{private get; set;}   //write-only

类的继承

• 基本概念
  在C#中，用冒号:表示继承，被继承的类叫基类/父类，继承的类叫派生类/子类。若没有指定基类，则编译器就将System.Object作为基类。
  两种继承方式：类继承和接口继承。类继承只允许单一继承，多重继承通过接口来实现。
  继承的成员：子类只能继承父类的public, protected成员，不能继承private成员。
  关于构造函数：子类初始化时，会首先调用父类的构造函数（初始化继承自父类的数据成员），再调用自己的构造函数（初始化自身特有的数据成员）。
  在子类中访问父类的成员：通过base.xx来调用。
  基类和派生类的转换：

  public class A
  {
      public A()
      {
          Console.WriteLine("A的构造函数");
      }
  }
  
  public class B: A
  {
      public B()
      {
          Console.WriteLine("B的构造函数");
      }
  }
  
  class Program
  {
      static void Main(string[] args)
      {
          A a = new B();    
      }
  }
  //最终输出：
  //A的构造函数
  //B的构造函数

类的多态性

多态是指同一操作用于不同的类的实例，不同的类将会进行不同的解释，最后产生不同的执行结果。

• 三种实现多态的方法
  通过继承实现多态性。
  通过抽象类实现多态性。
  通过接口实现多态性。

• 通过继承实现多态
  可通过virtual和override关键字，基类中通过virtual关键字定义要被重写的方法，子类中通过override关键字重写方法。
  也可通过new关键字，在子类中隐藏父类的同名方法。
  override和new的区别：

  public class A
  {
      public virtual void eat1()
      {
          Console.WriteLine("A eat");
      }
      public void eat2()
      {
          Console.WriteLine("A eat");
      }
  }
  
  public class B: A
  {
      public override void eat1()
      {
          Console.WriteLine("B eat");
      }
      public new void eat2()
      {
          Console.WriteLine("B eat");
      }
  }
  
  class Program
  {
      static void Main(string[] args)
      {
          A a = new B();
          a.eat1();
          a.eat2();
      }
  }
  //输出：
  //B eat
  //A eat

如果是override，父类方法是被覆盖的，因此在实例a中只有一个B重写后的eat()方法，因此调用的是B的eat()方法；
而如果是new，父类方法是被隐藏，还是会有两个方法。而经过类型转换后，子类就会被限制为父类的数据成员和方法，因此调用的就是父类的eat()。

• 通过抽象类实现多态
  抽象类abstract表示类中的成员不一定全部实现，可以只有声明部分而没有实现部分，因此抽象类不能实例化。
  当抽象类派生非抽象类时，必须实现抽象类的所有抽象成员，通过override方法。

• 通过接口实现多态
  接口就是完全抽象的成员集合，只有声明没有实现，通过interface 接口名{ //接口体 }来声明一个接口，实现时直接重写相应方法即可。
  接口中所有的成员都是public的，因此不能再指定访问修饰符。
  接口中不能出现字段，只能出现方法声明和属性。
  当有继承了多个接口时，且继承的接口中有同名方法，可通过接口名.方法名来显示指定实现哪个接口。
  具体代码见书p91。

委托与事件

委托

委托是一种数据结构，类似C++中的函数指针，作用：可通过委托来调用相应的函数。
委托定义格式：[访问修饰符] delegate 返回类型 委托名([参数序列]);
编译器编译这行代码时，会自动为其生成一个继承自System.Delegate的委托类，因此委托的定义虽然像是函数，但本质还是类。
委托的应用：回调机制、事件处理。

//使用委托的步骤
//第一步：定义委托类的原型
public delegate void MyDelegate(string name);
public class Program
{
    //第二步：定义被委托调用的方法
    public static void FunA(string name)
    {
        Console.WriteLine("A " + name);
    }
    public static void FunB(string name)
    {
        Console.WriteLine("B " + name);
    }
    public static void Main()
    {
        //第三步：实例化委托对象，并关联相关方法(相当于让函数指针指向对应函数)。
        MyDelegate da = new MyDelegate(FunA);
        MyDelegate db = new MyDelegate(FunB);
        //第四步：调用委托，即间接调用委托关联的方法
        da("张三");
        db("张三");
    }
}
//输出
//A 张三
//B 张三

注1：因为调用委托就相当于调用其关联的方法，因此方法和委托的参数类型和返回类型要完全匹配。

事件

事件是响应用户某个操作的行为，因此就涉及到两个问题：如何响应用户行为？响应后要干什么？
如何响应：直接事件名()的格式调用即可，就相当于触发了这个事件。
响应后干什么：一个事件对应一个委托类，通过这个委托类的多个实例就可调用多个方法，即完成响应后的操作。
具体使用方法:

class TestEvent
{
    public delegate void MyDelegate();  //定义委托
    public event MyDelegate MyEvent;    //定义事件，并关联委托类
    //定义被委托调用的方法
    public void fun1()
    {
        Console.WriteLine("Hello");
    }
    public void fun2()
    {
        Console.WriteLine("Bye");
    }
    static void Main()
    {
        TestEvent te = new TestEvent();
        te.MyEvent += new MyDelegate(te.fun1);
        te.MyEvent += new MyDelegate(te.fun2);
        te.MyEvent();
        te.MyEvent -= new MyDelegate(te.fun2);
        Console.WriteLine("去除一个委托");
        te.MyEvent();
    }
}
//输出：
//Hello
//Bye
//去除一个委托
//Hello

注1：事件的声明方法public event 委托名 事件名，且事件必须在类内声明，并通过对象调用，不能脱离对象存在。
注2：事件可通过+=, -=来添加、删除委托对象，事件添加的委托对象不同，事件触发后的行为也就不一样。
注3：窗体控件中事件的实现也是这个原理，每个控件都有一个事件成员，编写的事件响应方法通过默认委托绑定到事件上，发生事件时，即触发相应的响应方法。

第四章_窗体和控件

窗体

• 窗体程序的启动和停止
  使用Application类提供的静态方法来启动、停止窗体程序。
  Run方法：Application.Run(new Form1())，用于在当前线程上启动应用程序消息循环，并显示窗体。
  Exit方法：Application.Exit()，终止应用程序。
  注：在程序一开始必须用Run方法来启动Main窗体，不能用.show()方法，这样无法开启应用程序的消息循环，窗口会闪一下就结束了。

• 打开、关闭窗体

  //打开窗体
  Form fm = new Form();
  fm.Show();
  //关闭窗体
  fm.Close();
  //隐藏窗体
  this.Hide();
  //重新显示隐藏的窗体
  this.Show();

• 窗体常用属性
  StartPostion：设置窗体的起始位置，一般在构造函数中设置，this.StartPosition = FormStartPosition.CenterScreen。
  Location：重新设置窗体的位置，this.Location = new Point(500,400)。
  MaximizeBox：设置是否允许窗口最大化，true/false。
  MinimizeBox：设置是否允许窗口最小化，true/false。

• 单文档和多文档窗体
  多文档窗体(Multi-Document Interface, MDI)是指在一个主窗体中可以包含一个或多个子窗体的窗体，主窗体称为MDI父窗体，子窗体称为MDI子窗体。

对话框

对话框用于与用户交互信息，就是弹出的那个窗口，分为标准对话框和自定义对话框。

• MessageBox对话框
  标准对话框，调用MessageBox类的静态Show方法来显示消息对话框，Show方法提供了多种重载方式。

  public static DialogResult Show(string text)
  public static DialogResult Show(string text, string caption)
  public static DialogResult Show(string text, string caption, MessageBoxButtons buttons, MessageBoxIcon icon)

Text：消息框主题显示的文本。
caption：消息框的标题。
buttons：指定在消息框中显示哪些按钮。MessageBoxButtons枚举值之一，有：OK、OKCancel、YesNoCancel、YesNo等。
icon：指定在消息框中显示哪个图标。MessageBoxIcon枚举值之一，有：Question(问号)、Error(错误)、Warning(警告)等。
Show方法返回值：DialogResult枚举值，有：None(消息框未返回值)、OK、Cancel、Yes、No等。

常用控件

• 基本属性
  (Name)：指定控件的名称，它是控件在当前应用程序中的唯一标识，代码通过该属性来访问控件。
  Enabled：决定控件是否可用，取值为true时可用，取值为false时不可用。
  Anchor属性：设置控件与窗体哪个边框的相对距离不变。
  Dock属性：设置控件始终紧靠窗体的某边框。

• 一些控件快捷操作
  1、设置控件对齐方式：按住Shift键选中多个控件，在工具栏中间偏右的位置会有各种控件对齐操作，以Shift键选中的第一个控件为标准。
  2、设置控件焦点顺序：视图-Tab键顺序，可设置各控件的焦点顺序。
  3、如何删除事件：在“设计”界面，右上角-属性-事件窗口(小闪电图标)，右键对应事件-重置，然后再在代码界面删除事件方法代码即可。不能直接删除事件方法代码，因为在Form.Designer.cs文件中控件会和事件方法绑定，直接删除事件方法绑定就会出错，因此要连绑定的代码也一起删掉，绑定代码：this.button1.Click += new System.EventHandler(this.button1_Click)。
  4、如何设置控件属性：不要写在InitializeComponent()函数中，写在构造函数中InitializeComponent()函数的后面。InitializeComponent()是根据“设计”界面自动生成的，每次“设计”界面改变都会重新生成，因此其中写的额外代码就会被删掉。

• 控件常用事件
  Click：单击鼠标左键时触发
  MouseDoubleClick：双击鼠标左键时触发
  MouseEnter：鼠标进入控件可见区域时触发
  MouseMove：鼠标在控件区域内移动时触发
  MouseLeave：鼠标离开控件可见区域时触发
  KeyDown：按下键盘上某个键时触发
  KeyUp：释放键盘上的按键时触发
  KeyPress：在KeyDown之后KeyUp之前触发，非字符键不会触发该事件。

• 分组控件GroupBox
  用于将多个控件组合到一起。

  //遍历GroupBox中的所有控件
  foreach (Control con in groupBox1.Controls)
  {
      CheckBox cb = con as CheckBox;   //将循环变量转换为对应的控件类型，之后就可以调用相关属性了
      //处理代码
  }

• 文本操作控件
  Label：用于显示文字，通过.text属性设置文本内容。
  TextBox：用于接收用户的输入，通过.text属性读取用户输入的内容。
  TextBox常用属性和事件：
  PasswordChar属性：设置屏蔽密码时所用的字符，设置方法：textBox1.PasswordChar = '*'
  MaxLength属性：用户最多可输入的字符数，默认为32767个字符，因为使用的是Unicode字符，所以对中文和英文的字符计数方法是相同的，即一个英文字符的长度为1，一个汉字字符的长度也是1。
  TextChanged事件：表示文本框中的内容更改时触发的操作。
  RichTextBox：多行文本框，可进行较复杂的文本操作，属性、事件与TextBox类似。

• ListBox和ComboBox控件
  ListBox（列表框）控件和ComboBox（下拉框）控件均用于显示一组条目，以便操作者从中选择一条或者多条信息。
  两个控件的用法基本一样，区别仅仅在于显示的外观不同，ListBox将所有选项同时显示在框内，ComboBox则是以下拉列表显示。
  ListBox和ComoBox常用属性：
  Items：获取控件中的所有项
  SelectedIndex：获取当前选定的条目在列表中的索引（从0开始），int类型
  SelectedItem：获取当前选定的条目在列表中的项，返回object，需要.ToString()转化为字符串
  Items.Add：向列表中添加一项，comboBox1.Items.Add("xxx")
  Items.AddRange：向列表中添加一组项，传入string数组。
  Items.Remove：移除选项，传入string
  Items.RemoveAt：移除对应序号的选项，传入int
  Items.Clear：移除所有项
  注：ComboBox允许用户在下拉列表的顶部自己键入内容，通过.text属性访问。

• CheckBox控件
  CheckBox为复选控件，有三种状态：选中、未选中、不确定。
  两个重要属性：
  Checked{get; set;}：表示复选框是否被选中，bool类型：true/false。
  CheckState{get; set;}：表示复选框状态，CheckState枚举类型，有：Checked, Unchecked, Indeterminate三个值，分别表示选中、未选中和不确定。
  text{get; set;}：表示与复选框相关联的文本。
  CheckedChanged事件：当复选框状态值改变时触发该事件

• RadioButton控件
  RadioButton为单选按钮控件，一组RadioButton只能有一个处于选中状态。
  单选按钮是以其所在的容器来分组的，直接添加在窗体上的多个单选按钮默认属于同一组，此时窗体就是容器。若要对单选按钮分组，可以使用GroupBox控件。
  属性：
  Checked{get; set;}：表示单选框是否被选中，bool类型：true/false。
  text{get; set;}：表示与单选框相关联的文本。
  CheckedChanged事件：当单选框状态值改变时触发该事件

• MenuStrip控件
  菜单控件

第五章_目录与文件管理

三种对目录管理的类：Directory类、DirectoryInfo类、Path类，三个类的命名空间：System.IO
Directory类的静态方法：
Exists()：确定是否存在现有目录，返回bool类型。
GetFiles("e:\\test")：返回指定目录中的文件名称，string数组
GetDirectories()：返回指定目录中的子目录的名称
CreateDirectory("e:\\test")：在磁盘指定位置创建目录。

第六章_数据库操作

ADO：Active Data Objects
ADO.NET常用的对象模型：
(1) SqlConnection对象：建立与数据库的连接
(2) SqlCommand对象：执行SQL语句
(3) SqlDataReader对象
(4) SqlDataAdapter对象
(5) DataTable对象：
(6) DataSet对象：由表、关系、和约束的集合组成。

---

Post Date： 2018-01-26

版权声明： 本文为原创文章，转载请注明出处