1.foreach
c#中foreach关键字的用法如下;
int[] a={1,2,3,4,5};
foreach(int i in a)
Console.Write(i+" ");
2.声明二维数组
int[] arr1={1,2,3,4,5};//一维数组,获取长度:arr1.Length
int[,] arr2={{1,2,3},{4,5,6},{7,8,9}};//二维数组,获取长度:arr2.LongLength
3.属性封装
比如类C有a属性,封装方法如下:
private int _a;
...
public int A
{
get
{
return _a;//读
}
set
{
_a=value;//写
}
}
vs可以按快捷键,选中要封装的属性,按Ctrl+R+E即可
4.对象初始化器
C#中构造方法,带参不带参,还有this,和C++都是一样的用法,可以用构造函数来初始化对象,C#中还有一种方法就是使用对象初始化器,用法如下(Main方法中)
C c=new C()//圆括号可写可不写
{
//给各个字段赋值
}
实际上对象初始化器使用的是无参构造函数,所以前提是必须定义了无参构造函数
5.值和引用
C#中也有引用,普通变量如int,char等都是值类型,而类,数组,接口等都是引用类型,比如
C c1=new C(3);
C c2=c1;//这时c2是c1的引用,改变c2也会改变c1
6.ref关键字
如果想让函数的参数通过引用方式传递,可以使用ref关键字
public void add(ref int a)
{
a++;
}
7.out关键字
ref主要用来传参,而out主要用来获取方法的结果,return只能返回一个值,当需要返回多个值时就可以使用out,用法如下:
int a,b;
public void fun(int x,out int a,out int b);
ref和out都是引用类型的传参方法,不过ref修饰的参数必须要有值,而out修饰的不用
8.隐藏
当子类想隐藏父类的方法时,参数类型参数个数需一样,返回值没有要求,最好在新的方法前加上new关键字
9.sealed关键字
sealed关键字可以用来修饰类和方法
密闭类:有些类不希望其他人通过继承来修改
密闭方法:不希望其他人重写该方法
10.接口
C#中是单继承,但是实现接口的话可以一次实现多个接口
11.static
C#中有静态构造函数,专门用来初始化静态成员
不仅如此,static还可以修饰类和方法,可以通过static来给类添加功能,用法如下:
/*当需求变化,需要添加功能时,分以下几种情况:
* 1.如果有源代码,直接添加一个新的方法即可
* 2.如果不可以修改,而且也不是sealed类,那么可以用派生类扩展
* 3.如果上面的条件都不满足,那么考虑使用static类扩展方法
*/
class Person
{
public void walk()
{
Console.WriteLine("人在行走");
}
}
//写法如下
static class PersonManage
{
static public void eat(this Person p)
{
Console.WriteLine("通过static扩展Person类的方法");
}
}
class Static用法
{
static void Main(string[] args)
{
Person p = new Person();
p.walk();
p.eat();//使用时就可以当做自己的方法一样直接调用,神奇吧!!
}
}
12.装箱和拆箱
/*装箱:根据值类型的值,在堆上创建一个完整的引用类型的对象,并且返回
对象的引用,属于隐式转换,demo如下:
*/
int i = 2019;
object o = i;
Console.WriteLine(o+" "+o.ToString());
//拆箱:将装箱后的对象转换为值类型的过程,属于显示转换,demo如下:
int j = (int)o;
Console.WriteLine(j);
13.自定义转换
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 练习
{
class Person
{
protected string name;
public Person(string name)
{
this.name = name;
}
//隐藏
public void walk()
{
Console.WriteLine("1:人在走路-->" + name);
}
//覆盖
virtual public void eat()
{
Console.WriteLine("1:人在吃饭-->" + name);
}
}
class Worker : Person
{
public Worker(string name) : base(name)
{
}
new public void walk()
{
Console.WriteLine("2:工人在走路-->" + name);
}
override public void eat()
{
Console.WriteLine("2:工人在吃饭-->" + name);
}
}
class Farmer : Person
{
public Farmer(string name) : base(name)
{
}
new public void walk()
{
Console.WriteLine("3:农民在走路-->" + name);
}
override public void eat()
{
Console.WriteLine("3:农民在吃饭-->" + name);
}
/*自定义转换分为显示转换(explict)和隐式转换(implict)
*以之前的Person类为例,将Farmer转换为Worker
*语法如下(注意是static,并且需要注意该方法的位置,这里是在Farmer内):
*/
public static explicit operator Worker(Farmer f)
{
return new Worker(f.name);
}
/*public static implicit operator Worker(Farmer f)
{
return new Worker(f.name);
}
*/
}
class 自定义转换
{
static void Main(string[] args)
{
Farmer f = new Farmer("农民1");
f.eat();
Worker w = (Worker)f;//显示转换需要显式地指出要转换的类型,隐式转换则不用,直接赋值即可
//Worker w=f; //隐式转换直接赋值
w.eat();
w.walk();
}
}
}
14.运算符重载
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 练习
{
class Person
{
private int age;
public Person(int age)
{
this.age = age;
}
public void printAge()
{
Console.WriteLine(age);
}
//比C++的要简单很多
public static Person operator ++(Person p)
{
++p.age;
return p;
}
}
class 重载运算符
{
static void Main(string[] args)
{
Person p = new Person(20);
p.printAge();
++p;
p.printAge();
}
}
}
15.泛型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 泛型
{
//类模板(泛型类)
class C
{
private T t;
public C(T t)
{
this.t = t;
}
public void print()
{
Console.WriteLine(t);
}
}
class cs文件名
{
//函数模板(泛型方法)
public static void print(T t)
{
Console.WriteLine(t.ToString());
}
static void Main(string[] args)
{
C c1 = new C(5);
C c2 = new C("congratulations");
c1.print();
c2.print();
print(3);
print("hello");
}
}
}
16.约束
下面给出泛型类的约束,泛型方法的同理
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 泛型
{
/*约束:
* 一、约束的类型:
* 1.类名:传入的类型可以是该类或者该类的派生类
* 2.class:可以传入任何类
* 3.struct:可以传入任何值
* 4.接口名:可以传入该接口类型或者任何实现该接口的类型
* 5.new():传入的类型必须含有公有的无参构造函数
* 二、约束的叠加规则
* A.主约束(类名,class,struct等只能有一个)
* B.接口约束(任意多个)
* C.构造约束
*/
//注意约束的写法:where T:
//类模板(泛型类)
interface get
{
string Get();
}
class test:get
{
private string t;
public test()
{
t = "hello";
}
public test(string t)
{
this.t = t;
}
public string Get()
{
return t;
}
}
class Cwhere T:class,get,new()//现在传入的类型必须是类类型,并且有公有的无参构造函数
{
private T t;
public C(T t)
{
this.t = t;
}
public void print()
{
Console.WriteLine(t.Get());
}
}
class cs文件名
{
static void Main(string[] args)
{
C c1 = new C(new test());
c1.print();
var t = new test("world");
var c2= new C(t);
c2.print();
}
}
}
17.委托delagate和Lambda表达式
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 练习
{
class Student
{
private string name;
private int age;
public Student(string name,int age)
{
this.name = name;
this.age = age;
}
public void Print()
{
Console.WriteLine("name:" + name + ",age:" + age);
}
public void Study()
{
Console.WriteLine(name+"同学今天学习了C#课程");
}
public void Study1()
{
Console.WriteLine(name + "同学今天学习了数据结构课程");
}
}
class 委托Delegate
{
delegate void Learn();//声明一个委托类型Learn,Learn所持有的方法的参数,返回值都已经声明了
static void Main(string[] args)
{
Learn l=null;
Student s = new Student("Lanbo", 20);
l = s.Study;//现在l持有Student类的Student方法,即将Study委托给l
l += s.Study1;//可以委托多个方法,直接加进去
l();//执行所委托的所有方法
l += () =>
{
Console.WriteLine("执行Lambda表达式");
};
l();
}
}
}
18.事件
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace 练习
{
class Student
{
private string name;
private int age;
public delegate void Handle();//定义一个委托类型
public static event Handle Ring;//定义一个通知事件,通知学生上课
public Student(string name, int age)
{
this.name = name;
this.age = age;
if(Ring!=null)//当有学生时,就被通知上课
{
Ring();
}
}
public void Print()
{
Console.WriteLine("name:" + name + ",age:" + age);
}
public void Study()
{
Console.WriteLine(name + "同学今天学习了C#课程");
}
public void Study1()
{
Console.WriteLine(name + "同学今天学习了数据结构课程");
}
}
class 事件
{
static void Main(string[] args)
{
/*事件声明
* delegate void Handle();委托类型
* public event Handle e1();e1就是一个事件
*/
Student s = new Student("Jim",20);
Student.Ring += s.Study;
Student.Ring += s.Study1;
Student client = new Student("client", 20);
}
}
}
19.随机数
C#中随机数类是Random
//Random的简单用法
Random ran = new Random();
while(true)
{
//生成大于等于a小于b的随机数,即区间[a,b)
int a = 0, b = 1;
Console.WriteLine(ran.Next(a, b));
}