C#基础知识大杂烩

2023-02-26 10:32:37

这样是调用父类中第二个有参的构造函数，如果去掉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......");

        }

}

什么是接口

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

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

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

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

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

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

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

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

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

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

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

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

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

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

总结：

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

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

类型转换

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

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

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

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

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

CLR会进行两次类型检查if(检查一次){ //再检查一次 }
通过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

码农公寓

父类:

面试准备

第一章： 基础加强一

练习题

第二章：基础加强二

变量作用域

封装

继承

里氏替换原则

New关键字

Base关键字

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

访问修饰符

虚方法

静态成员

抽象方法

小技巧

第四章：字符串常用函数

字符串常用方法

简单工厂设计模式

顺便说：

值类型和引用类型

值类型, 栈

引用类型，堆

ref

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

接口

类型转换

异常处理

参数修饰符

Ref out

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

StringBuilder

垃圾回收

集合

ArrayList/list

Hashtable /Dictionary

第七章：基础加强

装箱拆箱

第九章：基础加强

序列化

正则表达式

相关文章

第一章：基础加强一

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

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