C#基础知识大杂烩

这样是调用父类中第二个有参的构造函数，如果去掉Base默认调用无参构造函数

注意执行顺序是:先调用父类的构造函数，然后再执行子类自己的构造函数。

父类:

class Person
    {
        public Person()
        {
            Console.WriteLine("========================");
        }
 
        public Person(string name, int age, string email)
        {
            this.Name = name;
            this.Age = age;
            this.Email = email;
        }
 
        public string Name { get; set; }
        public int Age { get; set; }
        public string Email { get; set; }
    }

子类:

class Teacher : Person
    {
        public Teacher(string name, int age, string email, double salary)
            : base(name, age, email)
        {
            //this.Name = name;
            //this.Age = age;
            //this.Email = email;
            this.Salary = salary;
        }
        public double Salary { get; set; }
    }

http://www.cnblogs.com/dragonlhf/archive/2007/11/19/963838.html

private int _id;
//get是给属性赋值，set是取属性的值。
public int ID
{
    //去到属性value的值给_id赋值
    set{ _id=value;}
    //给属性赋值
    get{return _id;}
}

目录

面试准备.... 2

第一章： 基础加强一.... 2

练习题... 2

第二章：基础加强二.... 2

变量作用域... 2

封装... 2

继承... 2

里氏替换原则... 3

New关键字... 3

Base关键字... 3

第三章：访问修饰符 虚方法  静态 抽象类实现多态.... 3

访问修饰符... 3

虚方法... 3

静态成员... 4

抽象方法... 4

小技巧... 4

第四章：字符串常用函数.... 5

字符串常用方法... 5

简单工厂设计模式... 5

顺便说：... 6

值类型和引用类型... 6

ref. 7

第五章：接口 类型转换 异常处理 参数修饰符.... 10

接口... 10

类型转换... 12

异常处理... 12

参数修饰符... 14

Ref out. 15

第六章：StringBuilder 垃圾回收 ArrayList  Hashtable  List与Dictionary. 15

StringBuilder. 15

垃圾回收... 15

集合.... 15

第七章：基础加强.... 16

装箱拆箱... 16

第八章：基础加强.... 17

序列化... 17

面试准备

熟悉word、excel文件的导入以及导出；对线程有一定的了解，在项目中能够熟练运用；了解正则表达式的基本知识；

第一章： 基础加强一

封装继承多态参考文档地址：

http://www.cnblogs.com/mountain-mist/articles/1214996.html

练习题

讲了一些练习题，没什么好看的

第二章：基础加强二

变量作用域

没什么好说的

封装

封装成类就叫封装

继承

子类继承父类，子类拥有父类一切东西，还可以进行添加

里氏替换原则

要父类的时候给子类是可以的

New关键字

New放在方法名前，为了隐藏父类中与子类同名的方法(不推荐使用，此处写上是为了能看懂别人的代码)

Base关键字

:base调用基类的构造函数

参考文档：http://www.cnblogs.com/xiaoshi657/p/4556190.html

第三章：访问修饰符 虚方法  静态 抽象类实现多态

访问修饰符

子类修饰符必须小于等于父类的修饰符

比如 父类（Person） 用 internal 子类（student）用public，会提示一下错误：

错误1可访问性不一致: 基类“ConsoleApplication2.Person”比类“ConsoleApplication2.Student”的可访问性低

虚方法

（多态）父类中虚方法virtual子类中重写，当父类型的子类（即Person类型的Student），使用该方法的时候，是每个子类不同的方法。比如people[i]数组是英国人，people 是父类，使用的方法就是英国人的方法

虚方法特点总结：

1>  虚方法在父类中必须有实现。

2>  子类继承父类后，可以选择对虚方法进行重写也可以选择不重写。

3>  当方法的标记是virtual或者override的时候都可以重写。

静态成员

内存中只存储一份，普通成员new一个多一份

不过，静态类到程序关闭才释放内存

静态类不用实例化对象，不用new，一般工具类用静态类，里面是静态方法

如 SQLHelper

抽象方法

1>  使用abstract关键字标记方法

2>  抽象方法在父类中不能有任何实现，所以抽象方法没有方法体。

3>  抽象成员必须写在抽象类中。

4>  抽象类是不能被实例化的。不能直接new一个抽象类的对象。

5>  抽象类中既可以有抽象成员，也可以有实例成员。

6>  抽象成员不能是私有的。

7>  子类继承抽象类后，对于抽象类中的抽象成员子类必须重写（因为父类中没有默认实现），除非子类也标记为abstract。

抽象方法和虚方法都可以实现多态，父类中需要默认实现的时候用虚方法，不需要用抽象方法，抽象方法不能被实例化

应用场景：在既需要统一的接口，又需要实例变量或缺省的方法的情况下，就可以使用它

https://blog.csdn.net/lamyuqingcsdn/article/details/50501871

小技巧

Shift+alt+f10 自动创建代码

当字母下方有小横杠的时候，证明编译器特别想告诉你什么，这是按Shift+alt+f10

第四章：字符串常用函数

第六节课，

课前疑点：：base  简单工厂模式

字符串常用方法

视频12345主要是字符串的一些常用方法，百度一下了解即可

参考文档：http://www.cnblogs.com/xiaoshi657/p/4525124.html

简单工厂设计模式

返回类型是父类类型，在里面动态返回子类，

private static JiSuanQi GetJiSuanObject(int n1, string czf, int n2)
 
        {
 
            JiSuanQi jsq = null;
 
            switch (czf)
 
            {
 
                case "+":
 
                    jsq = new Add(n1, n2);
 
                    break;
 
                case "-":
 
                    jsq = new Sub(n1, n2);
 
                    break;
 
                case "/":
 
                    jsq = new Div(n1, n2);
 
                    break;
 
            }
 
            return jsq;
 
        }

顺便说：

现在的程度理解：多态是 定义一个虚拟的或者抽象的父类  然后给不同的子类，（子类就是该父类的各种表现形态）

值类型和引用类型

栈类型比堆类型效率高

栈类型直接释放 缺点不能存储大小不规定的

堆类型需要调用垃圾回收

值类型进行赋值的时候是把数据拷贝了一个副本进行赋值，因为数据直接存储在栈中，所以把栈拷贝了一份即把数据拷贝了一份。

引用类型赋值，是把栈中的对象的地址拷贝了一份，因为栈中是存储的对象的地址，而对象的数据都存储在了堆中，所以引用类型赋值，只是把对象的地址赋值给了另外一个变量

值类型, 栈

Int   short  byte  char bool double float struct enum（枚举） decimal

引用类型，堆

string 数组 类 接口 委托

string s = "a";

ref

ref表示参数传递时按引用传递。
例如，假如我要交换2个数。
void Swap(int a,int b) { int t=a; a=b; b=t; } 这样并不能完成交换。因为参数传递时默认按值来的。
改成void Swap(ref int a,ref int b) { int t=a; a=b; b=t; } 调用时:int a=3,b=5; Swap(ref a,ref b);
然后a,b的值就被交换了。
out表示参数是传出的。一般是用作函数返回多个值时使用。
例如：Int32的TryParse函数，它用作把一个对象转化为Int32类型。
string s="123"; Int32 a; bool canParse=Int32.TryParse(s,out a);
也就是说TryParse实际有2个返回值，一个在canParse里，是一个bool值，表示是否能够转换。
另一个返回值在a里，如果能转换，a就是转换后的结果。

ref是按引用传递，传的是栈本身的地址

参考地址：

http://zhidao.baidu.com/link?url=fSEDVG5SWCFXR9dTl7sfxG8CXeeW544aVdByyII_VnPAF7VreWgREdsekqjJjv5Q9X3koOJYlLK7u-C8YS5L9_

class Program
 
    {
 
        static void Main(string[] args)
 
        {
 
            JiaoHuan jh = new JiaoHuan();
 
            int a = ;
 
            int b = ;
 
            Console.WriteLine("函数一：");
 
            Console.WriteLine("交换前：" + a.ToString() + "   " + b.ToString());
 
            jh.Function1(a, b);
 
            Console.WriteLine("交换后：" + a.ToString() + "   " + b.ToString());
 
           //结果：1  2  
 
           //      1  2
 
            Console.WriteLine("\n\n\n函数二：");
 
            Console.WriteLine("交换前：" + a.ToString() + "   " + b.ToString());
 
            jh.Function2(ref a, ref b);
 
            Console.WriteLine("交换后：" + a.ToString() + "   " + b.ToString());
 
            Console.ReadKey();
 
            //结果：1  2  
 
            //      2  1
 
        }
 
    }
 
    public class JiaoHuan
 
    {
 
        public void Function1(int a, int b)
 
        {
 
            int t = a;
 
            a = b;
 
            b = t;
 
        }
 
        public void Function2(ref int a, ref int b)
 
        {
 
            int t = a;
 
            a = b;
 
            b = t;
 
        }
 
    }
 
}

第五章：接口 类型转换 异常处理 参数修饰符

接口

个人理解：接口也是父类，另一种形式的父类，可以多继承必须实现…..

用的时候，你定义一个接口，给你一个实现这个接口的子类就可以

 
class Program
 
    {
 
        static void Main(string[] args)
 
        {
 
            IUSB usb = new USBDisk();
 
            usb.Read();
 
            usb.Write();
 
            Console.ReadKey();
 
        }
 
}
 
public interface IUSB
 
    {
 
        void Read();
 
        void Write();
 
    }
 
    public class USBDisk : IUSB
 
    {
 
        public void Read()
 
        {
 
            Console.WriteLine("read......");
 
        }
 
        public void Write()
 
        {
 
            Console.WriteLine("write......");
 
        }
 
}

什么是接口

1. 接口就是一种规范,协议(*)，约定好遵守某种规范就可以写通用的代码。

1. 定义了一组具有各种功能的方法。（只是一种能力，没有具体实现，像抽象方法一样，“光说不做”）

接口存在的意义：多态。多态的意义：程序可扩展性。最终→节省成本，提高效率。

接口解决了类的多继承的问题

接口解决了类继承以后体积庞大的问题。

先从语法角度看一下接口，与抽象类类似。

案例(继承了一个类，同时实现了其他接口)

鸟-麻雀sparrow['spærəu] ，鸵鸟ostrich['ɔstritʃ] ，企鹅penguin['pengwin] ，鹦鹉parrot['pærət]

鸟能飞,鸵鸟，企鹅不能。。。你怎么办

子类继承抽象类，实现接口，父类在最前边，接口在后边，接口可以多继承

接口中的成员必须不能有实现，接口不能实例化。

接口中的成员不能有访问修饰符，隐式公开public

接口中可以有属性、方法、索引器等（其实都是方法），但不能有字段

接口中的所有成员必须被子类中全部实现,除非子类是抽象类，把接口中的成员标记为抽象的。

总结：

目前学了 虚方法  抽象类  接口三个，都是为了实现多态！

虚方法有默认方法  抽象类  可以单继承没有默认方法，接口，可以多继承

类型转换

1. 只有在内存存储上存在交集的类型之间才能进行隐式转换。（不是很理解）
2. 不能用Cast转换string/int，只能用Convert。Convert.ToInt32/Convert.ToString

将字符串转换成“数值类型”（int、float、double）：

1. int.Parse(string str); 、int.TryParse(string str,out int n);//很常用，推荐。
2. double.Parse(string str);、double.TryParse(string str,out double d);
3. Parse()转换失败报异常，TryParse()转换失败不报异常。

再说as与直接类型转换：（*）

if(p is Student){ Student stu=(Student)p; }

1. CLR会进行两次类型检查if(检查一次){ //再检查一次 }
2. 通过GetType()，GetType()不允许重写。

Student stu=p as Student; //推荐，效率高于第一种，如果转换失败返回null,而不会报异常。

异常处理

一个 try后面可以跟多个catch

try
 
            {
 
            }
 
            catch (NullReferenceException ex)
 
            {
 
                Console.WriteLine(ex.Message);
 
            }
 
            catch (DivideByZeroException ex)
 
            {
 
                Console.WriteLine(ex.Message);
 
            }
 
            catch (Exception ex)
 
            {
 
                //throw抛出异常
 
                Console.WriteLine(ex.Message);
 
            }
 
            finally
 
            {
 
                //比如数据库、文件、画图等操作，无论如果都有必要用//finally释放资源   
 
                Console.WriteLine("这里是finally中的代码1！！！");
 
            }

力度小的放前面，力度大的放后面，如果Exception放最前边，后边放什么都没有意思了！都不执行了！

能不使用异常，尽量不要适用异常，效率不高

如果try内有return，先执行return前代码，然后执行finally，然后执行return。

如果catch内有return，先执行异常前代码，然后catch内return前，然后finally，然后return

参数修饰符

可变参数  Params

有多个参数的时候，可变参数放在最后，不可以有两个params

可以直接传一个数值

Add(new int[]{,,})
 
        static void Main(string[] args)
 
        {
 
            Add(, , , , , , , , );
 
        }
 
static int Add(params int[] nums)
 
        {
 
            int sum = ;
 
            for (int i = ; i < nums.Length; i++)
 
            {
 
                sum += nums[i];
 
            }
 
            return sum;
 
        }

Ref out

out与ref用于值类型的方法参数时：

out与ref基本上是一样的，是对变量的指针里面的内容进行操作。

Ref,在传入之前必须赋值，out 在方法内必须赋值，传入之前赋值与否无所谓，用不到

ref是    有进有出，而out是       只出不进。

参考资料：

http://www.cnblogs.com/lixiangfa/archive/2011/09/16/2178912.html

第六章：StringBuilder 垃圾回收 ArrayList  Hashtable  List与Dictionary

StringBuilder

以后尽可能的用stringbuilder 效率高于Format/+=，在万奇的时候项目里面的都是SB.sppend(“”)

参考资料：http://www.cnblogs.com/xiaoshi657/p/4542116.html

垃圾回收

值类型的变量在栈里不需要垃圾回收，用完就释放了！

只回收堆里面的内存资源！

GC.Collect();

手动调用效率不高

集合

ArrayList/list

Arraylist（非泛型集合）  list（泛型集合）  两个集合很像，不过强烈推荐使用list非必要不必使用arraylist（微软也是推荐使用list，因为在使用arraylist的时候需要解析引用，而list在创建的时候  默认已经解析） list效率比 arraylist高，省去了类型转换，list只能添固定类型。 Arraylist能做的list都能做   arraylist不能做的list也可以做

参考资料：

需要了解的方法

Add AddRange Remove RemoveAt Insert Sort

Reverse//反转  先用Sort排序然后Reverse反转，这样可以实现倒序

必须实现 IComparable接口

参考资料：

http://www.cnblogs.com/rickie/articles/67978.html

ArrayList 中Add方法要的是obj；类型，所以什么都可以add

arrayList.Insert(0, ""); 把字符串插入到序列[0]

ArrayList arrList = new ArrayList() { 1, 2, 3, 4, 5, 6, "aaa", false, 99.9 };

arrList.RemoveAt(1);

arrList.RemoveAt(2);//这样 删除 1、2。不是以索引的形式删除

arraylist看到2  不过效果不是很好，下次从2的开头开始看吧

（4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange
    这几个方法比较类似
Add方法用于添加一个元素到当前列表的末尾
AddRange方法用于添加一批元素到当前列表的末尾
Remove方法用于删除一个元素，通过元素本身的引用来删除
RemoveAt方法用于删除一个元素，通过索引值来删除
RemoveRange用于删除一批元素，通过指定开始的索引和删除的数量来删除
Insert用于添加一个元素到指定位置，列表后面的元素依次往后移动
InsertRange用于从指定位置开始添加一批元素，列表后面的元素依次往后移动

Hashtable /Dictionary

区别在于hashtable非泛型  dictionary泛型，推荐使用dictionary
更常见些

参考资料：http://www.cnblogs.com/xiaoshi657/p/4579551.html

第七章：基础加强

装箱拆箱

装箱:把值类型转换为引用类型，就叫装箱。（没有父子关系不可能发生装箱拆箱）

拆箱：拆箱:把引用类型转换为值类型，就叫拆箱。

参考资料：http://www.cnblogs.com/xiaoshi657/p/4584729.html

第九章：基础加强

序列化

序列化推荐newtonsoft

序列化是将对象转换成另一种格式（XML、json、二进制byte[]）+

添加类库“system.Web.Extensions.dll”

如果进行二进制序列化，不要用自动属性，是把属性对应的字段名（自动生成的，且不固定）序列化！

XML、二进制序列化要加标记[Serializable]包括该类的父类

如果不像序列化某字段
需要加标记no….

参考资料：http://www.cnblogs.com/xiaoshi657/p/4590831.html

正则表达式

参考资料：http://www.cnblogs.com/xiaoshi657/p/4601047.html

MVC

Aspx引擎 和razor引擎

Aspx: <%=%>

Razor:@ 
自己找闭合

路由：

解析地址
找到控制器  action

路由器规则如何制定

（packages:存放所有第三方库dll/js）

RouteDebug 路由调试利器，添加DLL添加引用即可

自定义路由器规则  顺序很重要，如果把首页放到最前面，永远访问的都是首页，其他的页面就访问不到了

MVC自带的校验

Model类中的代码

JQuery ajax

MVC自带的ajax

前台代码：

MVC  过滤器

面向切面编程 AOP  如果日志记录、权限过滤、
MVC的过滤器

依赖注入（控制反转） IOC  autofac  pring.net