C#简易知识点

成员命名规则：carColor

属性命名规则：Color

 

int 不能自动(隐士)转换成 char  (但是 VC 中可以)

double 不能自动(隐士)转换成 int

int 可以自动(隐士)转换成 double

 

Xxx.Parse(string)  //字符串转换为 其他类型

如： string s = "123";

     int i = int.Parse(s);  //ok, but if s = "a" then error! so just numeric

     同理有：float.Parse(string)  double.Parse(string)

 

int i = 123;

float f = 45.6;

double d = 153.789;

string s = s = i.ToString();   //ok, but only if i is numeric

string s = s = f.ToString();   //ok, but only if f is numeric

string s = s = d.ToString();   //ok, but only if d is numeric

 

Convert.ToXxx(ObjectValue)  //任意类型 转换为 其他类型

如： string s1 = "123";
     int i = Convert.ToInt32(s1);  //ok, i = 123;

 

     string s2 = "123.45";
     float f = Convert.ToSingle(s2);  //ok, f = 123.45;

 

     string s3 = "123.45";
     double d = Convert.ToDouble(s3);  //ok, d = 123.45;

 

 

值类型存储在堆栈中，如：int, char, 结构等。

引用类型存储在对中，如：类，接口，数组，字符串。 

 

object 类型是所有其他数据类型的基类，它可以表示通用的类型。所有类型都可以转换为 object 类型。

装箱是将值类型转换为引用类型。

拆箱是将引用类型转换为值类型。

如：   int i = 12;
       double d = 23.45;
       object obj;
       obj = i;   //装箱
       Console.WriteLine(obj);  //12;

       int i2 = (int)obj;  //拆箱，注意要强制类型转换。

       Console.WriteLine(i2);   //12;
       obj = d;   //装箱
       Console.WriteLine(obj);   //23.45;

       double d2 = (double)obj;  //拆箱，注意要强制类型转换。

       Console.WriteLine(d2);    //23.45;

 

装箱拆箱会消耗性能。大多数情况下，简易性比性能更重要（因为可能考虑到开发速度）。

 

定义数组

type [] name = {value1, value2, ...};

如： int [] a = {1,2,3};  //ok

     int [] a = new int [] { 1, 3, 5, 7, 9 };  //ok

     int [] a = new int [5] { 1, 3, 5, 7, 9 };  //ok

     string [] s = {"abc", "中国", "123"};  //ok

 

     int [] a;  //ok, 声明

     int a[];   //error

     a = new int[5];  //分配空间

 

交错数组 

如： int[][] jaggedArray = new int[2][];   //定义了不一定是矩形的数组

     jaggedArray[0] = new int[4];

     jaggedArray[1] = new int[3];

     jaggedArray[0][2] = 29;   //ok

     jaggedArray[0, 2] = 29;   //error

 

     int[, ] array;

     array = new int[5, 4];   //定义了矩形的数组，5行4列。

     array[3, 2] = 29;   //ok

     array[3][2] = 29;   //error

 

二维数组
– 平面上点的坐标pt(x,y)
– 声明：
• double[,] dbHeight=new double[3,4];
• double[,] dbHeight={ {1,2,3,4},{2,3,4,5},{3,4,5,6} };

 

数组的数组

• 数组的每个元素是数组
• 声明方式
int[][] arrayInt;
– 方式一：
arrayInt=new int[2][];
//注意不能用arrayInt=new int[3][4]!
arrayInt[0]=new int[3];
arrayInt[1]=new int[4];
– 方式二：
arrayInt={new int[]{1,2,3,},new int[]{4,5,6,7}};

 

参数的类型
– 值参数
– 引用参数
– 输出参数

C#输出参数和引用参数的区别

从CLR的角度看，关键字out和关键字ref是等效的，这就是说，无论使用哪个关键字，都会生成相同的元数据和IL代码。但是，C#编译器将两个关键字区别对待，在C#中，这两个关键字的区别在于哪个方法负责初始化引用对象。如果方法的参数标记为out，那么调用者不希望在调用方法之前初始化对象，被调用的方法不能读取对象的值，而且被调用的方法必须在返回之前为对象赋值。如果方法的参数标记为ref,那么调用者必须在调用方法之前首先初始化参数的值，被调用的方法可以读取参数或为参数赋值。

 

一种新类型的参数:参数数组
– 可以使用个数不定的参数调用函数
– 必须是参数定义中的最后一个参数
– 用关键字params说明
– params参数必须是一维数组
– 例如：
public void fun(params in[]args）

 

委托
– 委托使用的目标：把函数作为参数传递
– 类似于C++中的函数指针
– 是事件处理的基础
– 委托是面向对象的、类型安全的和保险的。
– 委托声明:
• delegate double process(double db1);
• delegate 函数返回类型名委托名（函数参数）

 

匿名方法
• 匿名方法（anonymous methods）允许将
与一个委托关联的代码“内联（in-line）”到
使用委托的地方，我们可以很方便地将代
码直接写在委托实例中。
• 匿名方法还共享对本地语句所包含的函数
成员的访问。
• 要将代码块传递为委托参数，创建匿名方
法则是唯一的方法。

 

可空类型
• 可空类型表示可被赋值为null 值的值类型变量。
无法创建基于引用类型的可空类型。（引用类型
已支持null 值。）。
• 语法 T? 是System.Nullable<T> 的简写，此处的
T 为值类型。这两种形式可以互换。
• 为可空类型赋值与为一般值类型赋值的方法相
同，如 int? x = 10; 或 double? d = 4.108;
• 如果基础类型的值为null，请使用
System.Nullable.GetValueOrDefault 属性返回该
基础类型所赋的值或默认值，例如int j =
x.GetValueOrDefault();

• 请使用HasValue 和Value 只读属性测试
是否为空和检索值。可空类型变量的默认
值将HasValue 设置为false。未定义
Value。
• 使用 ?? 运算符分配默认值，当前值为空的
可空类型被赋值给非空类型时将应用该默
认值，如：

         int? x = null;

         int y = x ?? -1; //若 x 为空，则 y 为 -1；

                          //若 x 不为空，则 y 为 x。
• 不允许使用嵌套的可空类型。将不编译下
面一行：Nullable<Nullable<int>> n;

 

泛型
• 泛型允许类、接口、结构、委托和方法通过它们
所存储和操作的数据的类型来指定类型。
• 这些类和方法将一个或多个类型的指定推迟到客
户端代码声明并实例化该类或方法的时候。
• 和使用object类相比，泛型降低了装箱和拆箱的
负担，减少了类型转换所带来的错误
• 使用泛型类型可以最大限度地重用代码、保护类
型的安全以及提高性能。
• 泛型最常见的用途是创建集合类。

 

类的成员有以下类型
– 成员常量：代表与类相关联的常量值
– 域即类中的变量
– 成员方法：负责执行类中的计算和其它操作
– 属性：用于定义类中的值并对它们进行读写
– 事件：用于说明发生了什么事情
– 操作符：定义类中特有的操作
– 构造函数和析构函数：分别用于对类的实例进行初始化和销毁

 

静态成员由类访问；非静态成员由对象访问。

 

构造函数和析构函数不能被继承。除此以外的其
它成员，不论对它们定义了怎样的访问方式，都能
被继承。基类中成员的访问方式只能决定派生类能
否访问它们。

 

类可以定义虚方法、虚属性以及虚索引指示器。它
的派生类能够重载这些成员，从而实现类可以展示
出多态性。

 

虚函数：当类中的方法声明前加上了virtual 修饰
符。我们称之为虚方法。反之为非虚。使用了
virtual 修饰符后不允许再有static, abstract, 或
override 修饰符。

 

重载：在派生类中声明对虚方法的重载要求在声明中加上
override 关键字，而且不能有new, static 或virtual
修饰符。

 

public, private, protect, internal

其中 internal 表示在同一个工程中才可以访问（即当前程序集内才可访问）。

 

C# 中的属性可以处理可读可写:

        private string _name;
        public string Name   //Name 属性
        {
            set { _name = value; }   //可写, 其中value是内置的参数
            get { return _name; }    //可读
        } 

封装字段快捷键 Ctrl+R 然后 Ctrl+E 。

 

base关键字可以调用父类的属性和方法，还有父类的构造函数。

如： 

namespace HelloWorld
{
    class Student : Person  //从 Person 类继承了 Name, Age 属性。
    {

        public void 考试()
        {
            Console.WriteLine("考试, 姓名 = {0}, 年龄 = {1}", base.Name, base.Age);
        }

    }
}

调用 考试() 则输出： 考试, 姓名 = XXX, 年龄 = XXX

通过 base 调用基类的构造函数。

        Student(int age, string name)
            : base(age, name)
        {
        } 

 

 

[访问修饰符] virtual[new][override] [返回值类型] 方法名([参数列表])

{
}

virtual 关键字是用于父类的。

new 和 override 关键字是用于子类的。

 

抽象类

abstract class Person   //抽象类（含有一个抽象方法的类）

{

    public abstract void SayHi();  //抽象方法（即一个没有实现的方法）
}

 

 

虚方法                    抽象方法

--------------------------------------------

在具体类中           |    在抽象类中

用 virtual 修饰      |    用 abstract 修饰 

要有方法体           |    不允许有方法体

可以被子类 override  |    必须被子类 override   

除了密封类都可以写   |    只能在抽象类中   

 

 

public class OtherPerson : Student, Teacher   //error，C Sharp 不支持多继承，想要达到目的，可

{                                             //以通过接口的方式实现，把 Student,Teacher 都定

}                                             //义成接口，再通过 OtherPerson 类对其实现。

 

接口

public interface IPict   //默认也是 public

{

    int DeleteImage();  //只定义，不实现。而且无访问修饰符（如public等）

    void DisplayImage();  //同上

}

 

 

abstract 实现面向对象的多态

例：

abstract class Person   //抽象基类

{

    public void abstract SayHello();

}

class Student : Person

{

    public override void SayHello()

    {

        Console.WriteLine("Student SayHello");

    }

}

class Teacher : Person

{

    public override void SayHello()

    {

        Console.WriteLine("Teacher SayHello");

    }

}

Student 类和 Teacher 类分别实现各自的 SayHello()方法；则：

Person p1 = new Student();

Person p2 = new Teacher();

p1.SayHello();  //输出 Student SayHello

p2.SayHello();  //输出 Teacher SayHello

多态：不同对象受到相同消失时，会产生不同行为。 

 

interface 接口实现多态：

例：

    interface IPerson
    {
        void SayHello();
    } 

    class Student : IPerson
    { 

        public void SayHello()
        {  

            Console.WriteLine("Student SayHello");
        }

    }

    class Teacher : IPerson
    {

        public void SayHello()
        {
            Console.WriteLine("Teacher SayHello");
        }
    } 
    IPerson p = new Student();
    p.SayHello();   //输出 Student SayHello           

    p = new Teacher();
    p.SayHello();   //输出 Teacher SayHello

 

 

简单工厂设计模式

class Factory

{

    public static Person Create(string name)

    {

        switch (name)

        {

            case "s":

                return new Student();

                break;

            default:

                return new Teacher();

                break;

        }   

        return null;

    }

}

    interface IPerson
    {
        void SayHello();
    } 

    class Student : IPerson
    { 

        public void SayHello()
        {  

            Console.WriteLine("Student SayHello");
        }

    }

    class Teacher : IPerson
    {

        public void SayHello()
        {
            Console.WriteLine("Teacher SayHello");
        }
    } 

            IPerson p = Factory.Create("s");
            p.SayHello();   //输出 Student SayHello  
            p = Factory.Create("t");
            p.SayHello();   //输出 Teacher SayHello  

 

ArrayList 是一个可动态维护长度的集合。

using System.Collections;  //引入命名空间

 

HashTable 可通过关键字来检索数据。

using System.Collections;  //引入命名空间

 

ArrayList 和 HashTable 可存储不同类型的对象，但遍历时可能涉及到类型转换的错误，如果考虑类型安全，可以用泛型。

泛型去数据时不用拆箱，而 ArrayList 和 HashTable 需要拆箱，而且拆箱比装箱耗费大。 

 

典型的泛型集合：  List<T> ,  Dictionary<K,V>

技巧：

遍历写 foreach 时，可按两下 tab 键。

 

读写文件的步骤：

1. 创建一个文件流。

2. 创建相应的读写器。(reader and writer)

3. 执行读写操作。

4. 关闭读写器。(reader and writer)

5. 关闭文件流。

注意先要引入命名空间   using System.IO;

例：

            string path = "d:\\ttt.txt";

也可以写成  string path = @"d:\ttt.txt";
            FileStream fs = new FileStream(path, FileMode.Create);  //创建文件流
            StreamWriter sw = new StreamWriter(fs);  //创建读写器
            sw.WriteLine("this is a test prog.");  //写操作
            sw.Close();  //关闭读写器
            fs.Close();  //关闭流文件

 

            FileStream fs2 = new FileStream(path, FileMode.Open);   //创建文件流
            StreamReader sr = new StreamReader(fs2);  //创建读写器
            string str = sr.ReadLine();  //读操作。还有 ReadToEnd() 的方法
            Console.WriteLine(str);

            sr.Close();  //关闭读写器
            fs2.Close();  //关闭流文件

 

 

File (静态类)操作举例

            string path = @"d:\ccc.txt";
            if (File.Exists(path))
            {
                Console.WriteLine("file exists!");
            }
            else
            {
                Console.WriteLine("file not exists!");
                StreamWriter sw = File.CreateText(path);
                sw.WriteLine("write finished!");
                sw.Close();
            }

 

Directory (静态类)可以对目录和子目录进行操作

 

静态类                     非静态类

------------------------------------------------------

static 修饰            |   不用 static 修饰

只包含静态成员         |   可以包含静态成员

不可以包含实例成员     |   可以包含实例成员

使用类名调用静态成员   |   使用实例对象调用非静态成员

不能被实例化           |   可以被实例化

不能包含实例构造函数   |   包含实例构造函数