码迷,mamicode.com
首页 > 其他好文 > 详细

知识点

时间:2014-06-24 11:22:16      阅读:301      评论:0      收藏:0      [点我收藏+]

标签:des   winform   class   code   tar   get   

第一章:

1、.net Framework是什么?
    是一个平台,可以在这个平台上进行 开发、部署和执行应用程序。
2、C#和.net什么关系?
    C#生成的代码是在.net环境中运行的,但是C#不是.net的一部分。
3、C#生成的可执行程序特点和过程和C++生成程序的区别?
    从文件中的源代码到可执行的代码,两个过程:
    A:源代码编译成Microsoft中间语言(IL)
    B:CLR把中间语言(IL)编译成在平台(.net平台)上可以运行的代码,这各C++生成的可执行二进制代码(本地机器吗)有所不同
4、CLR
    公共语言运行库,或者叫.net运行库。在CLR控制下运行的代码叫托管代码。是.net Framework的核心。CLR会检查哪些引用变量不再会访问了,然后会处理一下数据回收处理。
第二章:

1、为什么进行变量初始化?
    为了安全性考虑。
2、初始化的两种情况?
    方法外的变量在没有显式初始化时,编译器会自动初始化。
    方法内的变量必须在使用前初始化,否则会出现错误,编译器不会自动初始化。例如:
                int i;//
            Console.WriteLine(i);//会发生错误:    使用了未赋值的局部变量“i”
3、类型推断?
    用var 声明变量时,变量类型会随着初始化时的值来推断出变量的类型,并且一旦初始化后此变量的类型也就推断出来并固定了。
4、局部变量冲突
    在类级别和方法级别(暂且这样叫)声明的同名变量,不会引起冲突。
        class Program
    {
        private int i = 0;//类型级别
        static void Main(string[] args)
        {
            int i = 4;//方法级别
            Console.WriteLine(i);//输出4
        }
    }
5、常量:
    const int i=9;
    #:常量是静态的,不用也不能用static来修饰;
        class Program
        {
            public const int i = 9;//类型级别
            static void Main(string[] args)
            {
                Console.WriteLine(DDX.DD);//用类名来引用,说明是静态的
                Console.Read();
            }
        }
        class DDX
        {
            public const int DD = 90;
        }
    #:常量一定在声明时初始化,下面是错误的
       const int i;
       i=9;
    #:常量 ,优点是能把数字表示成一个有意思的字符串  比如: const int RATE=0.80;是一个利率
6、C#基本数据类型
    15种基本类型,其中有13种值类型,2种是引用类型。
7、小技巧,Char类型字符的表示,比如‘A‘
    (Char)65  ‘\u0041‘  ‘\x0041‘
8、一个特殊的引用string类型
            string str1 = "hello a";
            string str2 = str1;
            str2 += "b";
            Console.WriteLine(str1);//出现hello a
            Console.WriteLine(str2);//出现hello ab
        按正常的引用来思考:str1和str2是引用的同一个内存区域,str2的变量也会是str1的变化,但是str2变化后str1却没有变化,这是因为:修改一个字符串,就是再创建了一个全新的字符串对象。这是运算符重载的结果。
9、@在字符串中的使用
    string s1="C:\\1.txt";
    string s2=@"C:\1.txt";
    @的作用就是把字符还当成原来的含义,比如“\”就是一个普通斜线,但是@不能作用于双引号"。
10、 switch case 语句注意点:
    case 后的表达式一定要是常量;
    case 后的语句为空时,就会接着执行下面的case语句,这样可以合并几个case
    switch(i)
    {
        case 0:
        case 1:
        case 2:
            Console.Write(i);//当是0,1,2时都会成立
            break;
        default :
            Do Something;
    }
    case 后一定要有 break;否则会出错,这是和C++不同的地方。
    case 中的两个或者常量不能有重复
    switch(i)
    {
        case 1:
        case 1:这样会出错的
    }
11、 goto 语句的限制
    不能跑到循环内部;不能跳出类。
12、枚举类型
    作用:存数据,一次能存在两种类型,并且可视化强,易懂
        class Program
    {
        public const int i = 9;//类型级别
        enum TT : int
        {
            Monday = 9,
            Tuesday,
            Thirday
        }
        static void Main(string[] args)
        {
            Console.WriteLine(Convert.ToInt32(TT.Monday));//9
            Console.WriteLine(TT.Monday.ToString());//Monday
            Console.Read();
        }
    }
13、Main方法参数的使用 int Main(string[]args)
    在命令执行程序时,会使用的到
    int Main(string[] args)
    {
        for(int i=0;i<args.length;i++)
        {
            Console.WriteLine(args[i]);
        }
        Console.Read();
    }
    第二章部分.exe  23 34 eee bbb
    输出如下:
    23
    34
    eee
    bbb
14、格式化输出字符
                double a = 0.123;
            Console.WriteLine("{0:##.#0}", a);//输出.123
            Console.WriteLine("{0:##.#000}", a);//输出.1230,说明当0处有字符时,会用字符来代替掉0,但是如果0处没有字符时,还会显示0;说明当#处有字符时,也会被字符替换掉,但是当#处没有字符时,就不显示#;这是#和0当占位符用时的区别
15、三个斜线注释的作用
    可以直接对一个方法或者类进行说明;设置VS--项目--属性--生成 选项卡里 选中生成XML文件;这样会在执行项目时生成XML格式的说明文件。
    T "表 示一个类型,F :"表示一个字段,"M∶ "表示一个成员
16、预处理器指令
    作用:可以让一部分代码不会编译。这样,想生成一个程序的测试版本或者完全版本就有了用处。调试时也会用到。
    #define #undef #if #endif #elif #else   可以进行调试作用,
    #pragma 可以消除一些警告 例如字段定义后未使用会在编译时给出警告 这个警告的代号是169  ,#pragma warning disable   169 这样就消除了这种类型的警告;在发出警告或者错误提示时会在IDE中有行号显示,使用 #line 可以改变行号 比如:在第100行时出现错误 if(i=0),默认情况下系统会提示在100行的错误,但是在100行后使用 #line 101 "Class1.cs" 这时就会在错误时提示是在101行出现错误,如果想恢复原来的默认行号,可以使用#line default
    #warning "这里会出现一个警告" 会在出现#warning 处出现一个警告,警告的内容是后面的字符;
    #error "提示一个错误" 会在这里出现一个错误提示,编译不会再执行下去,停止了编译器的执行
    #region 与 #endregion 只是起到代码源文件中模块化的作用。
17、一些标识符的规则,小技巧与常识
    一般情况下C#的关键字不用作标识符的,例如int string 等,但是加上@时可以用作标识符了,@string
                string @int = "sss";
            Console.WriteLine(@int);//可以正常使用
    标识符也可以包含Unicode字符,比如\u005f表示"_"下划线,_aa与\u005faa都可以标识。

第三章:

1、类成员的4种访问类型?
    internal public protected private
2、类的常识:类的两个成员
    函数成员和数据成员;
    函数成员:方法、构造函数、析构函数、属性
    数据成员:字段,常量
3、引用传递的好处
    按 引用传递的 效率更高,不用复制更多的副本,也就是少占据内存空间
4、数组作为参数时是一种引用传递
5、强迫值传递为引用传递, ref 和 out 关键字的使用,两者的区别?
6、命名参数怎么用?可选参数的注意点?方法重载的几点要求?
7、属性Get和Set代码段在什么时间会调用到?构造只读和只写属性怎么做?
    访问属性其实是间接与字段交互数据,这个字段是和对应的属性关联的。
            Age = 5;//其实执行的是age = value(5)+2;结果是7
            Console.WriteLine(age);
            int i = 0;
            i = age;//其实执行的是get里面的代码 i=age(0);结果是0,和想象的结果1不一样
            Console.WriteLine(i);
            private int age = 0;
            public int Age
            {
                get
                {
                    return age + 1;
                }
                set
                {
                    age = value+2;
                }
            }
8、属性的自动实现
    如果属性的 set和 get访 问 器中 没有任何逻辑,就可以 使 用 自 动实现的 属性。
    public int Age{get;set;}不需要声明 private int age。 编译器会 自 动创建它。
    如果把属性名Age变成AGE或者aGE等呢?还没有尝试,在VS2005中会出错。
9、静态构造函数
    与普通非静态构造函数不冲突,一个类中可以同时存在这两种构造函数。
    在什么时间执行?由.net库来执行,并且只最多执行一次,不确定的某个时间执行,可以确定的是在类引用前就会执行了。
    使用的原因?一些类中有一些静态字段,不能用普通的构造函数来初始化,所以要用静态的构造函数来初始化。
10、构造函数间的调用和构造函数初始化器
    class A
    {
        public A():this("BBB")  //先执行有一个参数的构造函数,再执行第一个构造函数本身内的代码
        {
            Console.WriteLine("A");
        }
        public A(string s)
        {
            Console.WriteLine(s);
        }
    }
11、只读字段与关键字readonly
    与 const 常量的区别:readonly是在执行时才知道其值, const 是在编译时就已经有了值;readonly可以赋值,但是只在构造函数中赋值一次, const 常量在定义时就要初始化。
12、结构
    结构同样有构造函数,但是没有析构函数,是因为结构是值类型,初始化结构时可以像类那样用new关键字,但是也可以不用new,虽然使用了new,但是不会在堆上分配内存。
    结构的自定义的构造函数不能没有参数。
    在结构的内部不能直接为字段赋值。
    struct S
    {
        public S(int i)
        {
            this.i=i;
        }
        public int i=0;//这是操作是错误的,结构内部不能直接赋值给字段
    }
13、类的拆分和关键字 partial
    在 class interface struct 等前面加上 partial关键字,在编译时编译器认为在不同文件中的同名 类/结构/接口 合并。
    文件1.cs中:
    partical class A
    {
        public int i=0;
    }
    文件2.cs中:
    partical class A
    {
        public int j=9;
    }
    其实两个类是一个类。这在WinForm程序中容易见到。
14、静态类
    类关键字 class 前面 static ;
    不用再在类中的成员前面加关键字 static 了,所有成员都是静态的了。

第四章:

1、实现继承和接口继承:
    实现继承:一个派生类继承自基类;接口继承:派生类继承自接口。
    不支持多个实现继承,但是可以多个接口继承。
    结构的继承,只有接口继承。
2、虚方法和虚属性
    除了构造函数和静态函数外,其他方法和属性都能声音为虚的,用关键字 virtual 来修饰。虚方法和属性可以在派生类中重写;
    重写时要用关键字 override 来修饰,C++中不需要使用 override 。

3、隐藏方法
    基类中有方法fun();派生类中同样有相同签名的方法fun();那么在派生类中声明方法fun()时要使用 new :
    public new int fun();表示显式的说明,隐藏了基类的方法,如果不使用new的话,编译时会出现一个警告。隐藏方法没看出来会有什么实际意义 的作用。
4、调用函数的基类版本。
    class father
    {
        public virtual void fun()
        {
            Console.WriteLine("father");
        }
    }
    class child:father
    {
        public override void fun()
        {
            Console.WriteLine("child");
            base.fun();//在派生类中重写基类的虚方法,如果想调用基类中的虚方法,可以使用base.[方法名]
        }
    }
5、抽象函数和抽象类;
    抽象函数被 abstract 修饰,抽象函数是虚拟的,但不能用 virtual 修饰。
    抽象函数不能有代码,只能被子类中实现。
    如果函数被抽象了,也就是成为抽象函数,所在的类也必须也要被 abstract 修饰。此时类就成了抽象类。
    抽象函数 有点像是C++中的纯虚函数。
    抽象类中可以有普通函数。
    abstract class father
    {
        public abstract void fun();//只能在派生类中才有实现代码
    }
6、密封函数和密封类:
    被 sealed 修饰的方法或者属性不能被派生类继承;被 sealed 修饰的类,表示类不能被继承。
7、派生类和基类构造函数的调用顺序。
    class C
    {
        public C(string s)
        {
            Console.WriteLine(s);
        }
    }
    class D:C
    {
        public D():base("ccccc")//派生类的构造函数在被调用时,基类的构造函数会先被调用,调用方法是在派生类的构造函数后,使用base(实参数列表)
        {
            Console.WriteLine("D");
        }
    }
8、继承时 private 修饰的数据成员和函数成员,不会在派生类中看到。
    class C
    {
        private string s = "abc";
        protected string s2 = "aaa";
        public string s3 = "bbb";
        public C(string s)
        {
            Console.WriteLine(s);
        }
    }
    class D:C
    {
        public D():base("ccccc")
        {
            Console.WriteLine("D");
        }
        public void fun()
        {
            Console.WriteLine(s);//出现错误,基类中private修饰的数据不会在派生类中被看到,protected public 可以被看到
        }
    }
9、接口相关
    接口中不存在构造函数和字段。
    接口中的方法不能有实现代码。实现代码在派生类中,并且一定要实现。
    接口不能实例化。
    接口中的成员(方法)不能有修饰符 public private protected 等。因为里面的方法一定都是public类型的。
    接口之间可以继承。
10、接口引用类。
    interface IFather
    {
    }
    class Child : IFather
    {
    }
    Main()
    {
        IFather [] arr=new IFather[2];
        arr[0]=new Child();
        arr[1]=new Child();
    }

第五章:

1、泛型类,泛型接口,泛型结构,泛型方法
    class teacher<T>
    {
        public T Name{ get;set};
        public void PrintName()
        {
            Console.WriteLine(name);
        }
    }
2、默认值 default
    class Teacher<T>
    {
        public void Print()
        {
            T t = default(T);//函数级别的变量需要显式初始化,但是事先不知道T是值类型还是引用类型,所以要用default关键字来处理初始化。
            Console.WriteLine(t);
        }
    }
3、约束
    class A
    {
    }
    class Teacher<T>  where T:A  //where中,约束格式,说明泛型类型T是类类型并且继承自A类,多个约束间用","隔开
    {
    }
    几种固定的约束:
    where T:struct //约束T为值类型
    where T:class //约束T一定是引用类型
    where T:IF //约束T继承接口IF
    where T:new() //约束T要有一个默认的构造函数
4、泛型类的静态成员
    class Teacher<T>
    {
        public static int x;
    }
    Teacher<string>.x=9;
    Teacher<int>.x=90;
    Console.WriteLine(Teacher<string>.x);//结果是9,好像有多个静态成员
5、协变与抗变(向上转型)
    class Base
    {
    }
    class child:Base
    {
    }
     Base b = new Child();//正常
     Child c = new Base();//不能通过编译
    基类的变量(b),可以引用子类的实例,因为所有的子类的都是基类的一种
    但是,子类的对象不能引用父类的实例
6、泛型方法的定义和使用
    void swap<T>(ref T x,ref T y)
    {
        x=x+y;
    }
    调用
    int i=0;int j=9;swap<int>(i,j);
7、泛型方法与约束
    void swap<T>(ref T x) where T:struct
    {
    }

第六章:

1、数组的初始化和赋值
    用一条语句初始化: int []arr = new int[3];  arr[1]=1;...
    用两条语句初始化: int []arr; arr = new int [3]; arr[1]=1;...
    初始化时进行赋值: int []arr = new int[3] {1,2,3};或者  int []arr = new int []{1,2,3};
    使用花括号初始化: int []arr = {1,2,3};
    注意:不论是在函数内还是在函数外,数组是引用类型,数组中的元素在没有显式赋值时,都是有初始的值,比如int类型数组,元素初始是0;
2、锯齿数组
    int [][] arr = new int[3][];//3行数组,但是每一行的元素的个数还不确定
    arr[0] = new int[2]{1,2};//第一行有2 个元素
    arr[1] = new int[6];//第二行有6个元素
    arr[2] = new int[3];//第三行有3个元素
3、Array类
    是所有数组的基类;是一个抽像类。
    Array arr = Array.CreateInstance(typeof(int),3);
    int [] a = (int [])arr;
4、数组的复制
    int [] a =new int[3];
            int[] b = new int[2] { 1,2};
            a = b;//这里的a是对b的引用,
            Console.WriteLine(b[1]);
            Console.WriteLine(a[1]);
            a[1] = 9;
            Console.WriteLine(b[1]);//和以前的不一样,变化为9,引用的一个表现。
            Console.WriteLine(a[3]);//出错,只有两个值
5、元组
    数组中的每个元素都是相同的类型;元组中的每个元素的类型不一定相同。
6、 yield 关键字的使用:yield return ; yield break ;
    预定义的集合类型中,可以使用 foreach 语句得到集合中的每个元素 例如List;
    当要自定义一个能使用 foreach 集合时,或者想在一个方法中返回很多数据,并且数据在一个集合中,以供别的程序foreach遍历时,就要使用到yeild关键字。
    IEnumerable GetA()
    {
        int i=0;
        while(i<100)
        {
            yield return i;    //使用了yield,返回 的值都会在IEnumerbale 对象中了,但是循环会接着执行。
            i++;
        }
    }

第七章:

1、++i和i++
    当占据一行时,会有相同的结果;
    当在表达式中时:
    int i=0;
    int a= i++;//结果   a=0;
    int b = ++i;//结果 b =1;
    结论:当它们用于较长的 表达式的内 部时,把运算符放在前面t++x,会在计算表达式之前递增 x,换言之,递增了x后,在表达式中使用新值进行计算。而把运算符放在后mtx++9会 在计算表达式之后递增 x-使 用 x的 原始值计算表达式
2、溢出和处理 checked unchecked
    溢出的处理,
    byte i =255;
    i++;产生的溢出,默认情况下是不会检查的,为 unchecked
    如果代码块放在 checked 中
    checked
    (
        i=255;
        i++;
    )//会发出一个异常
3、检测 对象或者变量是不是属于一个类型,或者属于一个类型的派生类型
    int i = 8;
    if(i is object)//is运算符的使用
    {}
4、as运算符在类型转换中的使用
    object o1 = "stringss";//引用的是String类型的对象
    object o2 = new Hashmap();

    string s1=o1 as string;//s1赋值为string 类型的引用
    string s2=o2 as string;//s2会被赋值空null
    结论:如果对象名(o1)引用的内存数据("stringss")属于某个类型(string)或者其派生类型,则可以转换;否则结果是null.
5、不安全代码中使用 sizeof
    sizeof(int);得到是int占据的长度。4个字节。
6、可空类型:此值可以是基本的值,也可以是null
    int? a=null;//不会出现语法错误
    int? b=9;
    int? c= a+9;//c=null结果
    if(a>9){}//false
    结论:当与空数据进行运算时,只要有一个为null,结果就是null;在比较中特殊:两个进行比较的数据,只要有一个为null,结果是false;
7、值类型和引用类型之间的转换:装箱和拆箱
    装箱:CLR为值在堆上分配一个临时的内存,保存装箱后的结果。
8、运算符重载
    struct A
    {
        public int a,b;
        public static A operator +(A la,A ra)
        {
            A aresult;
            aresult.a = la.a+ra.a;
            aresult.b = la.b+ra.b;
            return aresult;
        }
    }
    注意:运算符重载定义时一定要使用 public  static operator 关键字。

第八章:

1、自定义委托和通用的两种委托
    一般使得的委托都是自定义委托,使用委托的示例:
    private delegate int MultiTwo(int i);
    int Func0(MultiTwo f,int b)
    {
       return f(b)+1;
    }
    int Add(int i)
    {
        return i+9;
    }
    main()
    {
        MultiTwo mt  = new MultiTwo(Add);
        Func0(mt,3);//委托可以作为函数的参数
    }
    通用的两种委托:Action<in T1,in T2> 此种委托有参数,但是没有返回值,T1和T2是传入的参数。
    Func<in T1,in T2,out Result>,有返回值的委托,最后一个参数是返回值的意思,并不会传入。
    Func<int,int>  AFun = new Func<int,int>(Add);
    public void CreateInt(Func<int,int> action,int a)
    {
        int b = action(a);
    }
2、匿名方法
    Func<int i,int j> F = delegate(int a)
    {
        return  a*2;
    }
    public delegate void PPint(string s);

    main()
    {
        PPint pp =  delegate(string s)
        {
            Console.WriteLine(s+"pp");
        }
        pp("dengdexin");//dengdexinpp
    }
3、Lambda表达式的使用
    适用于匿名方法:
    int string con="aaaaa";
    Func<string a,string b,string c>  SPintf= (参数列表,和前面对应,这里是两个 ,如果只有一个参数的暑假,括号可以省略)=>
    {
        方法体,如果只有一句的话,可以不用{}括号。
            c=a+b;
           c=c+con;//这里表达式可以使用外部的变量。一个重要特点。
    }
4、委托的另一个用处:事件
    事件基于委托。
    事件的两个基本关系者:发出者和侦听者;
    class Sender
    {
        public delegate void EventHandler(object o,EventArgs e);//定义委托
        public event EventHandler eventer;//定义事件eventer
        public void SendEvent()//触发事件
        {
            eventer(this,new EventArgs());
        }
    }
    class Listener
    {
        public void Handler(object o,EventArgs e)
        {
            Console.WriteLine("我接收并处理了消息");
        }
    }
    main()
    {
        Sender sender = new Sender();
        Listener listener = new Listener();
        sender.eventer+=listener.Handler;
    }

第九章:

1、String的一些劣势
    string str="hello";//假如想把每个字符用它后面的字符表示,以示加密:h->i;e->f;l->m;o->p;
     这时对每个字符的操作都会在内存中再开辟一段新的内存,以存在修改每个字符后的字符串,
     第一次 iello,开了一个内存
     第二次 ifllo,开了一个内存
     ...
     效率低下。
     StringBulid 不会出现这种问题,因为在使用StringBulid的对象时,第一个使用时会给定一定大小的内存,所有操作都是在这个内存中。
     当对字符串中的每个字符进行操作的时候,使用SB比较好一些。
2、正则表达式。

第十章:

1、泛型类:List<T>
    初始化并设定初始值:
    List<int> intlist = new List<int>(){2,3};
    添加元素使用Add方法:
    intlist.Add(4);
    一次添加多个元素,使用AddRange方法:
    intlist.AddRange(5,6,7);
    插入元素Insert:
    intlist.Insert(2,8);
2、队列
    先进先出(FIFO)
3、栈
    后进先出
4、链表
    优点:插入元素时会非常快,
    缺点:在查找后面的元素时,会慢。
5、有序列表
    SortedList<Tkey,Tvalue>
6、位数组
    BitArray
    每一个元素可以理解成一个Bool类型, BitArray ba = new BitArray(8);//设置长度为8,有代替多个Bool值的功效。
    BitVector32 是另一个位数组类,它和BitArrary不同在于,它是固定位数的,是32位,这算是它的一个缺点,但它的优点是数据元素存在栈上,运算速度 快。

第十一章:

1、什么是LINQ?
    语言集合查询,是用来访问数据的编程模型。个人的理解是有点像是SQL语句。
2、
    int[] numbers = new int[] { 1, 3,5,7, 9, 11, 13, 15, 17,19};
    var even = from number in numbers
           where number % 3 == 0
           grouprby number descending
           select number;
    关键字:from in where groupby  select
3、实现排序,查询等操作
4、
LINQ提供了Count()、Average()、Max()、Min()、Sum()等方法实现聚合查询。
5、使用Skip()、SkipWhile()、Take()、TakeWhile()方法组合实现分区类查询

第十二章:

1、Dynamic Language Runtime
    是添加到CLR的一些服务,这些服务允许添加动态语言,
2、Dynamic类型,和Var类型的比较
    Var:在运行时一旦初始化类型第一次后,以后就是这一类型,类型变固定了。
    Dynamic:在运行时可以随时改变表示的类型。
    动态变量引用的类型随时变化:
    main()
    {
        int i=9;
        Dynamic dyn = i;
        string str = "aaa";
        dyn = str;//这时又发生了变化。
    }
    Dynamic类型不会在编译时报错(就算有错也不会报)
    main()
    {
        Dyanmic dyn = new person();
        dyn.GetA(1,2,3);//引用了三个参数,和实际的一个参数的情况不相同,但在编译时不会报错,在运行时会报异常
    }
    class person
    {
        void GetA(int i)
        {
        }
    }

第十三章:

1、下面的作用域
{
    这里面的作用域叫块作用域或者结构作用域。
}
2、托管堆
    和普通的堆不同,它是在垃圾回收器的作用下工作的。
3、托管资源和非托管资源?
    C#常见的非托管资源:文件旬柄、网 络连接和数据库连接;垃圾处理器不会处理非托管资源,因此需要手动实现。
    使用两种方法来翻译非托管资源:
    析构函数和实现 systemDisposable 接口。
4、析构函数
     在垃圾回收器能处理托管资源时,当有析构函数时,会先执行析构函数。再执行垃圾回收器,第一次执行析构函数时不会清除对象,第二次会清除。
     C#中CLR会维护一个线程来执行析构函数,如果析构函数很多时 ,就会明显影响程序的性能。
     在C#中使用析构函数:
     ~MyClass(){}
     ;在方法体中对非托管资源进行释放。
5、实现Disposable接口。
    接口Disposable中有一个方法Dispose,可以在此方法中显式对非托管资源的释放。
    class MyClass : Disposable
    {
        private void Dispose()
        {
            //这里释放资源
        }
    }
    有些类的一些方法比如Close已经实现对方法Dispose的调用。
    using()子句也会自动调用Dispose来对非托管资源的释放。
6、C#中使用指针
    使得指针的函数或者类要使用关键字unsafe,表示是不安全代码
    unsafe int GetPoint()
    {
        //使用指针
        int *p=null;
    }
    umsafe 关键字可以修饰变量和函数,还可以修饰类。但局部变量不能使用unsafe。
7、不能存在指向类的指针,因为垃圾回收器不会维护关于指针的信息。
    class A
    {
        public long x;
        public long y;
    }
    A a=new A();
    long *pX = &(a.x);//出错
    原因:垃圾回收器会把对象(托管类型的成员)放到一个新单元上。
    处理方法:使用Fixed关键字,使用是告诉垃圾回收器,在Fixed块中的托管对象,这时可能会被指针用,不能移动。
    fixed(A a= new A())
    {
        long *pX = &(a.x);
    }
8、stackalloc
    说明在栈上分配内存

第十四章:

1、特性
    什么是特性?特性的分类?
    特性:其实质是一个类,并且此类继承自 System.Attribute 类。特性是提供有关编程元素(如类型、字段、方法和属性)的附加信息的描述性标记
    特性分为两种,一种是Microsoft定义好的,一种的我们自定义的。
    特性是作用:举一个例子,Dllimport特性,修饰一个方法时,是为了影响编译器,告诉编译器下面的方法是从某个DLL引用来的。
2、如何自定义一个特性?
    [AttributeUsage(AttributeTargets.Property,AllowMultiple=false,Inherted=false)]
    public class MySelfAttribute:Attribute
    {
        public MySelftAttribute(string str)//类可以有构造函数的,特性也是一种类的
        {}
    }
    这样就定义了一个特性。定义特性的说明:
    AttributeUage:这也是一个特性,是Microsoft定义好的一个特性。它为定义其他特性而生。
    AttributeTargets.Property:AttributeTargets,是一个枚举类型,Property只是其中的一个元素。在这里说明自定义的特性MySelfAttribute只能修饰属性Property。AttributeTargets还有很多元素,分别表示自定义的特性可以修饰类、方法等。
    AllowMultyple:是一个Bool类型,它表示自定义的属性MySelfAttribute是不是可以多次使用。为false表示只能使用一回。
    Inherted:表示自定义的属性在修改一个元数据(属性或者方法或者类等)时,当元数据被继承时,特性是不是也可以继承。
3、如何使用自定义的特性?
    用特性来修饰一个类:
    [MySelf("aaaa")]//这里也可以用[MySelftAttribute("aaaa")]好像是使用构造函数来初始化一个实例一样。
    public class A
    {
    }
    但是修饰了一个类A后,有什么作用呢?
4、Type类及其作用是什么?
    Type :是一个抽象类,不能用其构造函数来初始化一个实例,只能用其他方法。
    第一种:用 typeof            double d = 0.0;Type t = typeof(d);
    第二种:用GetType方法        double d = 0.0;Type t = d.GetType();
    第三种:用Type类的静态方法    Type t = Type.GetType(d);
    那么作用是什么呢?
    是根据一个类型的实例,比如d,得到这个实例d所对应的类型的各种信息,这些信息包括:
    实例对应类型的名字,在这里是System.Double;类型的成员有哪些,成员的名字是什么,成员的类型是方法还是字段;类型所在的命名空间等。详细见Type类。
5、特性的使用?
    A:标识程序集
    程序集标识,三种特性与强名称(比如a.dll)来完整标识一个程序集。引用程序集时Assembly.Load(参数可以是程序集的区域特性和版本特性),这是特性的一个用处。简单的说,用特性来描述程序集后,可以被静态方法Load利用来得到程序集的实例。
    B:影响编译器,比如 [DllImport("User32.dll")] 的作用 。
6、可以使用反射动态创建类型的实例,将类型绑定到现有对象,或从现有对象获取类型并调用其方法或访问其字段和属性。
namespace 反射
{
    class Program
    {
        static void Main(string[] args)
        {
            /*******第一种反射表现:动态创建实例******/
            Assembly ass = Assembly.Load("反射");//加载程序集
            object o = ass.CreateInstance("反射.DD");//用完整的空间路径
            (o as DD).WriteString("呵呵");

            /******第二种表现:从现有对象获取类型并调用其方法*****/
            Type t = ass.GetType("反射.DD");
            MethodInfo mi = t.GetMethod("WriteString");
            mi.Invoke(o, new object[] {"嘿嘿" });


            Console.Read();
        }
    }
    public class DD
    {
        public void WriteString(string para)
        {
            Console.WriteLine("反射动态调用方法:"+para);
        }
    }
}

第十五章:

1、结构
try
{
    if()
    {
        throw Exception1("1");
    }
    if()
    {
        throw Exception2("2");
    }
    ....
}
catch (Exception1 e)
{
}
catch (Exception2 e)
{
}
....
finally
{
}
2、代码没有处理异常时的情况?
    当我们的代码没有处理异常时,应用程序会立即退出,并弹出一个对话框,运行程序时常见的错误。对话框中会表示出异常的详细信息。
3、嵌套的try块。
    try
    {
        //这里的异常会在外部异常处理
        try
        {
            内异常,这里的异常会在内层异常中优先处理,再内部finally,再外部catch 再外部finally
        }
        catch (内层异常)
        {
        }
        finally
        {
            内层异常清理
        }
    }
    catch (外层异常)
    {
    }
    finally
    {
        外层异常清理
    }

 

知识点,布布扣,bubuko.com

知识点

标签:des   winform   class   code   tar   get   

原文地址:http://www.cnblogs.com/ddx-deng/p/3805312.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!