C#学习笔记(控制台)

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<T>
    {
        private T t;
        public C(T t)
        {
            this.t = t;
        }
        
        public void print()
        {
            Console.WriteLine(t);
        }
    }
    class cs文件名
    {
        //函数模板（泛型方法）
        public static  void print<T>(T t)
        {
            Console.WriteLine(t.ToString());
        }

        static void Main(string[] args)
        {
            C<int> c1 = new C<int>(5);
            C<string> c2 = new C<string>("congratulations");
            c1.print();
            c2.print();

            print<int>(3);
            print<string>("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 C<T>where 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<test> c1 = new C<test>(new test());
            c1.print();
            var t = new test("world");
            var c2= new C<test>(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));
            }

可以看到生成的随机数都是0