C#基础学习

 Console.WriteLine("Hellow World");
 
 Console.ReadLine();

快捷键

Ctrl +K+D  整理代码
Ctrl +J		提示
Ctrl +K+C  注释
Ctrl +K+U  取消注释
F1 帮助文档

冗余代码
#region
#endregion

2、c#的3种注释符
1)、单行注释 //
2)、多行注释 /*要注释的内容*/
3)、文档注释 /// 多用来解释类或者方法

\r\n window 不认识\n
@字符串   保留原格式输出
@取消\在字符串中的转义作用

占位符

            Console.WriteLine("第一个数字{0}，第二个数字{1}", n1, n2);
            Console.WriteLine("第一个数字" + n1);

类型转换

class Program
{
    static void Main(string[] args)
    {
         float num1 = 82.26f;
         int integer;
         string str;
         integer = Convert.ToInt32(num1);
         str = Convert.ToString(num1);
         Console.WriteLine("转换为整型数据的值{0}", integer);
         Console.WriteLine("转换为字符串{0},",str);
    }
}

namespace TypeConversionApplication
{
    class ExplicitConversion
    {
        static void Main(string[] args)
        {
            double d = 5673.74;
            int i;

            // 强制转换 double 为 int
            i = (int)d;
            Console.WriteLine(i);
            Console.ReadKey();
           
        }
    }
}

int i = 75;
 Console.WriteLine(i.ToString());

调试方法：
1)、F11逐语句调试(单步调试)
2)、F10逐过程调试
3)、断点调试

常量
不改变的数据

const int MyAge=18

枚举

1、变量类型
int double string char bool decimal
变量的使用规则：先声明再赋值最后使用
int number;
number=10;
 number=20;
Console.WriteLine(number);

2、Camel  Pascal

6、枚举
语法：
[public] enum 枚举名
{
	值1,
	值2,
	值3,
	........
}
public:访问修饰符。公开的公共的，哪都可以访问。
enum：关键字，声明枚举的关键字
枚举名：要符合Pascal命名规范

将枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用这个枚举。



public enum QQState
{
	ONLine,
	OffLine,
	Leave,
	Busy,
	QMe
}

类似对象，保存统一的变量名

结构
可以帮助我们一次性声明多个不同类型的变量。

public struct Person
{
	public string name;
	public int age;
	public char gender;
}

数组
一次性存储多个相同类型的变量。
语法：
数组类型[] 数组名=new 数组类型[数组长度];

int[] nums=new int[10];
Array.sort(A);
Array.Reverse(A);

方法

11、方法
函数就是将一堆代码进行重用的一种机制。
函数的语法：
///

方法功能
///
//第一个参数
//
[public] static 返回值类型 方法名([参数列表])
{
	
}

## 方法注释

在一个方法写好后，在方法名上一行直接输入"///"回车即可生成方法说明的主体结构，只需对方法名，用途，参数加以说明。类说明写法也一样

全局变量

public static int number=10;

//(用户输入数字，则返回，否则提示用户重新输入)
            while (true) {
                Console.WriteLine("请输入一个数字");
                try
                {
                    int number = Convert.ToInt32(Console.ReadLine());
                    Console.WriteLine(number);
                    break;
                }   
                catch (Exception)
                {
                    Console.WriteLine("输入有误");
                    throw;
                }

参数修饰符 out、ref、params

修饰符种类
1.无修饰符:如果一个参数没有用参数修饰符标记，则认为它将按值进行传递，这将意味着被调用的方法收到原始数据的一份副本。

1)、out参数。
如果你在一个方法中，返回多个相同类型的值的时候，可以考虑返回一个数组。
但是，如果返回多个不同类型的值的时候，返回数组就不行了，那么这个时候，
我们可以考虑使用out参数。
out参数就侧重于在一个方法中可以返回多个不同类型的值。
有点类似传地址

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };
            int min = 0;
            int max = 0;
            Test(numbers,out min,out max);
            Console.WriteLine(max);
            Console.WriteLine(min);
        }
        public static void Test(int[] nums, out int max, out int min) {
            max = nums[0];
            min = nums[0];
            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i] > max) {
                    max = nums[i];

                }
                if (nums[i] < min)
                {
                    min = nums[i];

                }
            }
        }
    }
}

2)、ref参数
能够将一个变量带入一个方法中进行改变，改变完成后，再讲改变后的值带出方法。
ref参数要求在方法外必须为其赋值，而方法内可以不赋值。

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n1 = 10;
            int n2 = 20;
            Test(ref n1, ref n2);
            Console.WriteLine(n1);
            Console.WriteLine(n2);
        }
        public static void Test(ref int n1, ref int n2) {
            int t = n1;
            n1 = n2;
            n2 = t;
        }
  
    }
}

3)、params可变参数
将实参列表中跟可变参数数组类型一致的元素都当做数组的元素去处理。
params可变参数必须是形参列表中的最后一个元素。

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //int[] score = { 99, 88, 77 };
            Test("张三",99,88,777);
        }
        public static void Test(string name, params int[] score) {
            int sum = 0;
            for (int i = 0; i < score.Length; i++)
            {
                sum += score[i];
            }
            Console.WriteLine("{0}这次考试的总成绩是{1}", name, sum);
        }
  
    }
}

5、方法的重载
概念：方法的重载指的就是方法的名称相同给，但是参数不同。
参数不同，分为两种情况
1)、如果参数的个数相同，那么参数的类型就不能相同。
2)、如果参数的类型相同，那么参数的个数就不能相同。
***方法的重载跟返回值没有关系。

方法的递归
方法自己调用自己。
找出一个文件夹中所有的文件。

方法练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {
        static void Main(string[] args)
        {
            //            提示用户输入两个数字  计算这两个数字之间所有整数的和
            //1、用户只能输入数字
            //2、计算两个数字之间和
            //3、要求第一个数字必须比第二个数字小  就重新输入
            Console.WriteLine("请输入第一个数字");
            string strNumberOne = Console.ReadLine();
            int numberOne;
            GetNumber(strNumberOne,out numberOne);
            Console.WriteLine("请输入第二个数字");
            string strNumberTwo = Console.ReadLine();
            int numberTwo;
            GetNumber(strNumberTwo,out numberTwo);

            //判断第一个数字是否小于第二个数字
            // ref 改变值
            JudgeNumber(ref numberOne, ref  numberTwo);

            //求和
            int sum = GetSum(numberOne, numberTwo);
            Console.WriteLine(sum);
            Console.ReadKey();


        }


        public static void JudgeNumber(ref int n1, ref  int n2)
        {
            while (true)
            {
                if (n1 < n2)
                {
                    //复合题意
                    return;
                }
                else//>=2
                {
                    Console.WriteLine("第一个数字不能大于或者等于第二个数字，请重新输入第一个数字");
                    string s1 = Console.ReadLine();
                    //调用GetNumber
                    GetNumber(s1,out n1);
                    Console.WriteLine("请重新输入第二个数字");
                    string s2 = Console.ReadLine();
                    GetNumber(s2,out n2);
                }

            }

        }
        public static void GetNumber(string s,out int number)
        {
            while (true)
            {
                try
                {
                    number = Convert.ToInt32(s);
                    return;
                }
                catch
                {
                    Console.WriteLine("输入有误！！！请重新输入");
                    s = Console.ReadLine();
                }
            }
        }

        public static int GetSum(int n1, int n2)
        {
            int sum = 0;
            for (int i = n1; i <= n2; i++)
            {
                sum += i;
            }
            return sum;
        }
    }
}

求平均值，保留两位小数
using System;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] numbers = { 1, 2, 7 };
            double avg = GetAvg(numbers);
            //保留两位小数
            string s = avg.ToString("0.00");
            avg = Convert.ToDouble(s);

            Console.WriteLine(avg);
            //占位符
            //Console.WriteLine("{0:0.00}",avg);

        }

        public static double GetAvg(int[] nums) 
        {
            double sum = 0;
            for (int i = 0; i < nums.Length; i++)
            {
                sum += nums[i];
            }
            return sum / nums.Length;
        }
    }
}

面向对象

语法：
[public] class 类名
{
Field字段
Method方法
Property属性
}

属性
属性的作用就是保护字段、对字段的赋值和取值进行限定。
属性的本质就是两个方法，一个叫get()一个叫set()。
既有get()也有set()我们诚之为可读可写属性。
只有get()没有set()我们称之为只读属性
没有get()只有set()我们称之为只写属性

using System;
using PersonClass;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Person zhangsan = new Person();
            zhangsan.Age = -33;
            zhangsan._name = "张三";
            zhangsan.Gender = '春';
            zhangsan.Work();
        }


    }
}

using System;
using System.Collections.Generic;
using System.Text;

namespace PersonClass
{
    public class Person
    {   
        //字段
        public string _name;
        public int _age;
        public char _gender;
        //通过属性包含字段
        public string Name {
            get { return _name; }
            set { _name = value; }
        }
        public int Age {
            get { return _age; }
            set {
                if (value < 0 || value > 100) 
                {
                    value = 0;
                }
                _age = value;
            }
        }
        public char Gender
        {
            get{
                if (_gender != '男' && _gender != '女') {
                    return _gender = '男';
                }
                return _gender;
            }
            set { _gender = value; }
        }
        public void Work() {

            //使用字段,不推荐
            //Console.WriteLine("我叫{0}，我今年{1}岁了，我是{2}生",this._name, this._age, this._gender);
            Console.WriteLine("我叫{0}，我今年{1}岁了，我是{2}生", this.Name, this.Age, this.Gender);


        }
    }
}

静态和非静态区别

1)、在非静态类中，既可以有实例成员，也可以有静态成员。
2)、在调用实例成员的时候，需要使用对象名.实例成员;
    在调用静态成员的时候，需要使用类名.静态成员名;
总结：静态成员必须使用类名去调用，而实例成员使用对象名调用。
	  静态函数中，只能访问静态成员，不允许访问实例成员。
      实例函数中，既可以使用静态成员，也可以使用实例成员。
      静态类中只允许有静态成员，不允许出现实例成员。
使用：
1)、如果你想要你的类当做一个"工具类"去使用，这个时候可以考虑将类写成静态的。
2)、静态类在整个项目中资源共享。
只有在程序全部结束之后，静态类才会释放资源。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    public class Person
    {
        private static string _name;

        public static string Name
        {
            get { return Person._name; }
            set { Person._name = value; }
        }
        private char _gender;

        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }
        public void M1()
        {

            Console.WriteLine("我是非静态的方法");
        }
        public static void M2()
        {

            Console.WriteLine("我是一个静态方法");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {
        static void Main(string[] args)
        {
            //调用实例成员
            Person p = new Person();
            p.M1();//实例方法
            Person.M2();//静态方法
           // Student s = new Student();


            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

构造函数和析构函数
类似python类的 init（），创建对象的时候会执行构造函数
作用：帮助我们初始化对象(给对象的每个属性依次的赋值)
构造函数是一个特殊的方法：
1)、构造函数是可以有重载的，构造函数没有返回值，连void也不能写。
2)、构造函数的名称必须跟类名一样。

public class Student{
	//构造函数
	public Student()
	{
	
	}

}
//构造函数重载
public Student(string name, int age, char gender, int chinese, int math, int english)
          {
             this.Name = name;
              this.Age = age;
              this.Gender = gender;
              this.Chinese = chinese;
              this.Math = math;
              this.English = english;
          }
          //用this 减少代码冗余，调用上面的构造函数
          public Student(string name, int chinese, int math, int english):this(name,0,'c',chinese,math,english)
          {
              //this.Name = name;
              //this.Chinese = chinese;
              //this.Math = math;
             //this.English = english
  }


  //当程序结束的时候  析构函数才执行
        //帮助我们释放资源
        //GC Garbage Collection
        ~Student()
        {
            Console.WriteLine("我是析构函数");
        }

命名空间

namespace（命名空间），用于解决类重名问题，可以看做“类的文件夹”
在不同命名空间下的类调用有两种方法:
·写全称命名空间.类名
·先using引用命名空间,再调用

字符串方法

ToCharArray()

            string s = "abcdefg";
            //用ToCharArray()修改字符串
            char[] chs = s.ToCharArray();
            chs[0] = 'b';
            //将字符数组转化成字符串
            s = new string(chs);

            Console.WriteLine(s);

计时器和StringBuilder

            StringBuilder sb = new StringBuilder();
            Stopwatch sw = new Stopwatch();

            sw.Start();
            for (int i = 0; i < 10000; i++)
            {
                sb.Append(i);
            }

            sw.Stop();
            Console.WriteLine(sw.Elapsed);
            Console.WriteLine(sb);

字符串比较函数

            string s1 = "ABc";
            string s2 = "abC";
            if (s1.Equals(s2, StringComparison.OrdinalIgnoreCase)) 
            {
                Console.WriteLine("yes");
            
            }

RemoveEmptyEntries 移除空字符串

            string s = "a b    dfd _  +  =  , , , fsd";
            char[] chs = { ' ', '_', '+', '=', ',' };
            //  StringSplitOptions.RemoveEmptyEntries 移除空字符串
            string[] str = s.Split(chs, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < str.Length; i++)
            {
                Console.WriteLine(str[i]);
            }

Contains、Replace

            string str = "cnm,会不会玩游戏";
            if (str.Contains("cnm")) 
            {
                str = str.Replace("cnm","***");

            }
            Console.WriteLine(str);

join

            string[] name = { "张三", "李四", "王五", "赵六", "田七" };

            string steNew = string.Join("|", name);
            Console.WriteLine(steNew);

字符串练习

1.从键盘接受字符串参数，并将其反序输出

           string str = "abcfefg";

            char[] chs = str.ToCharArray();

            for (int i = 0; i < chs.Length/2; i++)
            {
                char temp = chs[i];
                chs[i] = chs[chs.Length - 1 - i];
                chs[chs.Length - 1 - i] = temp;
            }

            str = new string(chs);
            Console.WriteLine(str);




            //倒叙循环
            for (int i = str.Length-1; i >=0; i--)
            {
                Console.WriteLine(str[i]);
            }
            Console.ReadKey();
           


           string str = "hello c sharp";
            string[] strNew = str.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < strNew.Length / 2; i++)
            {
                string temp = strNew[i];
                strNew[i] = strNew[strNew.Length - 1 - i];
                strNew[strNew.Length - 1 - i] = temp;

            }
            for (int i = 0; i < strNew.Length; i++)
            {
                Console.WriteLine(strNew[i]);

            }

字符串截取

            string email = "[email protected]";
            int index = email.IndexOf('@');

            string userName = email.Substring(0, index);
            string yuMing = email.Substring(index + 1);

            Console.WriteLine(yuMing);
            Console.WriteLine(userName);

  string path = @"C:\Users\18578\Desktop\1.txt";
            string[] contents = File.ReadAllLines(path, Encoding.Default);


            for (int i = 0; i < contents.Length; i++)
            {
                string[] strNew = contents[i].Split(new char[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
                if (contents[i].Length > 10)
                {
                    Console.WriteLine(strNew[0] = strNew[0].Substring(0, 8) + "..." + "|" + strNew[1]);
                }
                else 
                {

                    Console.WriteLine(strNew[0] + "|" + strNew[1]);

                }

             }

继承

子类继承父类的属性和方法，但是不会继承pivate字段
子类没有继承父类构造函数，但是子类会先执行父类无参构造函数（实际上创造一个父类，让子类使用父类中的成员）
所以，如果在父类中重新写一个有参数的构造函数之后，无参数就被干掉了，子类就调用不到会报错
解决方法
1.重载
2.在子类显示的调用父类的构造函数，使用关键字：base（）

继承的特性
1.继承的单根型：一个子类只有一个父类
2.继承的传递性




using System;
using System.Diagnostics;
using System.Text;
using System.IO;



namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {


        }
    }

    public class Person
    {
        public string _name;

        public string Name 
        {
            get { return _name; }
            set { _name = value; }
        }

        public int _age;

        public int Age 
        {
            get { return _age; }
            set { _age = value; }
        }

        public void CHLSS() {
            Console.WriteLine("吃喝拉撒睡");
        }
        public Person(string name,int age) {
            this.Name = name;
            this.Age = age;
        
        
        }

    }

    public class Student:Person
    {
        public int _sid;
         public int Sid
        {
            get { return _sid; }
            set { _sid = value; }
        }
        public void Study()
        {
            Console.WriteLine("学习中");
        }
        public Student(string name, int age,int sid) : base(name,age)
        {
            this.Sid = sid;
        }
    }

    public class Teacher : Person
    {
        public void Jiaoshu()
        {
            Console.WriteLine("教书中");
        }
    }

}

new 关键字
1.创建对象
2.隐藏从父类那里继承过来的同名成员。
隐藏的后果就是子类调用不到父类的成员

1、里氏转换
1)、子类可以赋值给父类
2)、如果父类中装的是子类对象，那么可以讲这个父类强转为子类对象。
is：表示类型转换，成功ture，false
as：表示类型转换 ，失败返回对象，失败null

2、
子类对象可以调用父类中的成员，但是父类对象永远都只能调用自己的成员。

3、
is：表示类型转换，如果能够转换成功，则返回一个true，否则返回一个false
as：表示类型转换，如果能够转换则返回对应的对象，否则返回一个null

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _02里氏转换
{
    class Program
    {
        static void Main(string[] args)
        {
                       1、里氏转换
            1)、子类可以赋值给父类:如果有一个地方需要一个父类作为参数，我们可以给一个子类代替
            //  Student s = new Student();
            Person p = new Student();//s;

            //string str = string.Join("|",new string[] { "1", "2", "3", "4" });
            //Console.WriteLine(str);
            //Console.ReadKey();

            2)、如果父类中装的是子类对象，那么可以讲这个父类强转为子类对象。

            //is的用法
            //if (p is Student)
            //{
            //    Student ss = (Student)p;
            //    ss.StudentSayHello();
            //}
            //else
            //{
            //    Console.WriteLine("转换失败");
            //}

            //as的用法

            Teacher t = p as Teacher;
            t.TeacherSayHello();
            Console.ReadKey();


        }
    }

    public class Person
    {
        public void PersonSayHello()
        {
            Console.WriteLine("我是父类");
        }
    }
    public class Student : Person
    {
        public void StudentSayHello()
        {
            Console.WriteLine("我是学生");
        }
    }
    public class Teacher : Person
    {
        public void TeacherSayHello()
        {
            Console.WriteLine("我是老师");
        }
    }


}

里氏转换练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建10个对象 通过一个循环 去调用他们各自打招呼的方法
            //Student s = new Student();
            //Person p = new Person();
            //ShuaiGuo sg = new ShuaiGuo();

            Person[] pers = new Person[10];
            Random r = new Random();
            for (int i = 0; i < pers.Length; i++)
            {
                int rNumber = r.Next(1, 7);
                switch (rNumber)//1-6
                {
                    case 1: pers[i] = new Student();
                        break;
                    case 2: pers[i] = new Teacher();
                        break;
                    case 3: pers[i] = new ShuaiGuo();
                        break;
                    case 4: pers[i] = new MeiLv();
                        break;
                    case 5: pers[i] = new YeShou();
                        break;
                    case 6: pers[i] = new Person();
                        break;
                }
            }


            for (int i = 0; i < pers.Length; i++)
            {
               // pers[i].PersonSayHi();
                if (pers[i] is Student)
                {
                    ((Student)pers[i]).StudentSayHi();
                  //  pers[i].PersonSayHi();
                }
                else if (pers[i] is Teacher)
                {
                    ((Teacher)pers[i]).TeacherSayHi();
                }
                else if (pers[i] is ShuaiGuo)
                {
                    ((ShuaiGuo)pers[i]).ShuaiGuoSayHi();
                }
                else if (pers[i] is YeShou)
                {
                    ((YeShou)pers[i]).YeShouSayHi();
                }
                else if (pers[i] is MeiLv)
                {
                    ((MeiLv)pers[i]).MeiLvSayHi();
                }
                else
                {
                    pers[i].PersonSayHi();
                }

            }
            Console.ReadKey();

        }
    }

    public class Person
    {
        public void PersonSayHi()
        {
            Console.WriteLine("我是人类");
        }
    }


    public class Student : Person
    {
        public void StudentSayHi()
        {
            Console.WriteLine("我是学生");
        }
    }

    public class Teacher : Person
    {
        public void TeacherSayHi()
        {
            Console.WriteLine("我是老师");
        }
    }


    public class MeiLv : Person
    {
        public void MeiLvSayHi()
        {
            Console.WriteLine("我是镁铝");
        }
    }


    public class ShuaiGuo : Person
    {
        public void ShuaiGuoSayHi()
        {
            Console.WriteLine("我是帅锅");
        }
    }


    public class YeShou : Person
    {
        public void YeShouSayHi()
        {
            Console.WriteLine("我是野兽");
        }
    }


}

C#中的访问修饰符

protected
受保护的：可以在当前类的内部以及该类的子类中访问。
public
公共访问是允许的最高访问级别。 对访问公共成员没有限制
private
私有成员只有在声明它们的类和结构体中才是可访问的
internal
只能在当前项目中使用，不写访问修饰符，默认这个修饰符。在同一个项目中internal和public等价
protected internal

！！ 子类的访问权限不能高于父类的访问权限，会暴露父类成员
1、能够修改类的访问修饰符只有两个：public、internal
2. 类中成员的访问修饰符：

多态
概念：让一个对象能够表现出多种状态（类型）
实现多态的3种手段：1、虚方法 2、抽象类 3、接口
虚方法
1.父类需要实例化
2.父类中的方法有实际意义
抽象类
1.不需要实例化对象
2.不知道如何去实现父类方法

1.虚方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _09多态
{
    class Program
    {
        static void Main(string[] args)
        {
			//1)、虚方法
//步骤：
//1、将父类的方法标记为虚方法 ，使用关键字 virtual，这个函数可以被子类重新写一个遍。
//子类使用override

            Chinese cn1 = new Chinese("韩梅梅");
            Chinese cn2 = new Chinese("李雷");
            Japanese j1 = new Japanese("树下君");
            Japanese j2 = new Japanese("井边子");
            Korea k1 = new Korea("金秀贤");
            Korea k2 = new Korea("金贤秀");
            American a1 = new American("科比布莱恩特");
            American a2 = new American("奥尼尔");
            Person[] pers = { cn1, cn2, j1, j2, k1, k2, a1, a2, new English("格林"), new English("玛利亚") };

            for (int i = 0; i < pers.Length; i++)
            {
                //if (pers[i] is Chinese)
                //{
                //    ((Chinese)pers[i]).SayHello();
                //}
                //else if (pers[i] is Japanese)
                //{
                //    ((Japanese)pers[i]).SayHello();
                //}
                //else if (pers[i] is Korea)
                //{
                //    ((Korea)pers[i]).SayHello();
                //}
                //else
                //{
                //    ((American)pers[i]).SayHello();
                //}


                pers[i].SayHello();
            }
            Console.ReadKey();
        }
    }

    public class Person
    {
        private string _name;
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public Person(string name)
        {
            this.Name = name;
        }
        public virtual void SayHello()
        {
            Console.WriteLine("我是人类");
        }

    }

    public class Chinese : Person
    {
        public Chinese(string name)
            : base(name)
        {

        }

        public override void SayHello()
        {
            Console.WriteLine("我是中国人，我叫{0}", this.Name);
        }
    }
    public class Japanese : Person
    {
        public Japanese(string name)
            : base(name)
        { }

        public override void SayHello()
        {
            Console.WriteLine("我是脚盆国人，我叫{0}", this.Name);
        }
    }
    public class Korea : Person
    {
        public Korea(string name)
            : base(name)
        {

        }


        public override void SayHello()
        {
            Console.WriteLine("我是棒之思密达，我叫{0}", this.Name);
        }
    }
    public class American : Person
    {
        public American(string name)
            : base(name)
        {

        }

        public override void SayHello()
        {
            Console.WriteLine("我叫{0}，我是米国人", this.Name);
        }
    }


    public class English : Person
    {
        public English(string name)
            : base(name)
        { }

        public override void SayHello()
        {
            Console.WriteLine("我是英国人");
        }
    }

}

2.抽象类
当父类中的方法不知道如何去实现的时候，可以考虑将父类写成抽象类，将方法写成抽象方法。

1.抽象成员必须标记为abstract,并且不能有任何实现。
2.抽象成员必须在抽象类中。可以子类继承，子类实现非抽象的方法
3.抽象类不能被实例化
4.子类继承抽象类后，必须把父类中的所有抽象成员都重写。
（除非子类也是一个抽象类，则可以不重写）
5.抽象成员的访问修饰符不能是private
6.在抽象类中可以包含实例成员。
并且抽象类的实例成员可以不被子类实现

7.抽象类是有构造函数的。虽然不能被实例化。

8、如果父类的抽象方法中有参数，那么。继承这个抽象父类的子类在重写父类的方法的时候必须传入对应的参数。

如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候 也必须要传入返回值。

======
如果父类中的方法有默认的实现，并且父类需要被实例化，这时可以考虑将父类定义成一个普通类，用虚方法来实现多态。

如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11_抽象类
{
    class Program
    {
        static void Main(string[] args)
        {
            //狗狗会叫 猫咪会叫

            Animal a = new Cat();//new Dog();
            a.Bark();

            Console.ReadKey();
        }
    }

    public abstract class Animal
    {

        public virtual void T()
        {
            Console.WriteLine("动物有声明");
        }

        private int _age;

        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        public Animal(int age)
        {
            this.Age = age;
        }
        public abstract void Bark();
        public abstract string Name
        {
            get;
            set;
        }

     //   public abstract string TestString(string name);


        public Animal()
        {

        }
        //public void Test()
        //{
        //    //空实现
        //}
    }


    public abstract class Test : Animal
    {

    }

    public class Dog : Animal
    {
       // public abstract void Test();


        public override void Bark()
        {
            Console.WriteLine("狗狗旺旺的叫");
        }

        public override string Name
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }

        //public override string TestString(string name)
        //{
        //    //throw new NotImplementedException();
        //}
    }

    public class Cat : Animal
    {
        public override void Bark()
        {
            Console.WriteLine("猫咪喵喵的叫");
        }

        public override string Name
        {
            get
            {
                throw new NotImplementedException();
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }
}

抽象类练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12_抽象类
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用多态求矩形的面积和周长以及圆形的面积和周长
            Shape shape = new Square(5, 6); //new Circle(5);
            double area = shape.GetArea();
            double perimeter = shape.GetPerimeter();
            Console.WriteLine("这个形状的面积是{0},周长是{1}", area, perimeter);
            Console.ReadKey();

        }
    }

    public abstract class Shape
    {
        public abstract double GetArea();
        public abstract double GetPerimeter();
    }
    public class Circle : Shape
    {

        private double _r;
        public double R
        {
            get { return _r; }
            set { _r = value; }
        }

        public Circle(double r)
        {
            this.R = r;
        }
        public override double GetArea()
        {
            return Math.PI * this.R * this.R;
        }

        public override double GetPerimeter()
        {
            return 2 * Math.PI * this.R;
        }
    }
    public class Square : Shape
    {
        private double _height;

        public double Height
        {
            get { return _height; }
            set { _height = value; }
        }

        private double _width;

        public double Width
        {
            get { return _width; }
            set { _width = value; }
        }

        public Square(double height, double width)
        {
            this.Height = height;
            this.Width = width;
        }

        public override double GetArea()
        {
            return this.Height * this.Width;
        }

        public override double GetPerimeter()
        {
            return (this.Height + this.Width) * 2;
        }
    }

}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _13_电脑_移动硬盘_U盘_MP3
{
    class Program
    {
        static void Main(string[] args)
        {
            //用多态来实现 将 移动硬盘或者U盘或者MP3插到电脑上进行读写数据

            //MobileDisk md = new MobileDisk();
            //UDisk u = new UDisk();
            //Mp3 mp3 = new Mp3();
            //Computer cpu = new Computer();
            //cpu.CpuRead(u);
            //cpu.CpuWrite(u);
            //Console.ReadKey();

            MobileStorage ms = new UDisk();//new Mp3();//new MobileDisk();//new UDisk();
            Computer cpu = new Computer(ms);
            //cpu.Ms = ms;
            cpu.CpuRead();
            cpu.CpuWrite();
            //Computer cpu = new Computer();
            //cpu.CpuRead(ms);
            //cpu.CpuWrite(ms);
            Console.ReadKey();

        }
    }


    /// 

    /// 抽象的父类
    /// 
    public abstract class MobileStorage
    {
        public abstract void Read();
        public abstract void Write();
    }


    public class MobileDisk : MobileStorage
    {
        public override void Read()
        {
            Console.WriteLine("移动硬盘在读取数据");
        }
        public override void Write()
        {
            Console.WriteLine("移动硬盘在写入数据");
        }
    }
    public class UDisk : MobileStorage
    {
        public override void Read()
        {
            Console.WriteLine("U盘在读取数据");
        }

        public override void Write()
        {
            Console.WriteLine("U盘在写入数据");
        }
    }
    public class Mp3 : MobileStorage
    {
        public override void Read()
        {
            Console.WriteLine("MP3在读取数据");
        }

        public override void Write()
        {
            Console.WriteLine("Mp3在写入数据");
        }

        public void PlayMusic()
        {
            Console.WriteLine("MP3自己可以播放音乐");
        }
    }



    public class Computer
    {
        private MobileStorage _ms;

        public MobileStorage Ms
        {
            get { return _ms; }
            set { _ms = value; }
        }
        public void CpuRead()
        {
            Ms.Read();
        }

        public void CpuWrite()
        {
            Ms.Write();
        }
        public Computer(MobileStorage ms)
        {
            Ms = ms;
        }
    }
}

接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _09接口
{
    class Program
    {
        static void Main(string[] args)
        {
            //接口就是一个规范、能力。
        }
    }

    public class Person
    {
        public void CHLSS()
        {
            Console.WriteLine("我是人类，我可以吃喝拉撒睡");
        }
    }
    public class NBAPlayer
    {
        public void KouLan()
        {
            Console.WriteLine("我可以扣篮");
        }
    }

    public class Student : Person,IKouLanable
    {
        public void KouLan()
        {
            Console.WriteLine("我也可以扣篮");
        }
    }


    public interface IKouLanable
    {
        void KouLan();
    }

	    //接口中的成员不允许添加访问修饰符 ，默认就是public
        void Fly();
        string Test();
        //不允许写具有方法体的函数

     //   string _name;
         string Name
        {
            get;
            set;
        }

}

接口特点

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12接口特点
{
    class Program
    {
        static void Main(string[] args)
        {
            IFlyable fly = new Bird();//new Person();
            
            // new IFlyable(); 接口不能实例化
            fly.Fly();
            Console.ReadKey();
        }
    }
    public class Person:IFlyable
    
    {	//继承了接口，必须实现接口中的所有成员
        public void Fly()
        {
            Console.WriteLine("人类在飞");
        }
    }

		//继承类和接口，书写顺序
    public class Student:Person, IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("人类在飞");
        }
    }

    public class Bird : IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("鸟在飞");
        }
    }

    public interface IFlyable
    {
        //不允许有访问修饰符 默认为public
        //方法、自动属性
        void Fly();
    }



    public interface M1
    {
        void Test1();
    }

    public interface M2
    {
        void Test2();
    }

    public interface M3
    {
        void Test3();
    }

	//接口不能继承一个类，而类可以继承接口
	//（接口只能继承于接口，而类既可以继承接口，也可以继承类）
    public interface SupperInterface : M1, M2, M3
    {

    }

    public class Car : SupperInterface
    {

        public void Test1()
        {
            throw new NotImplementedException();
        }

        public void Test2()
        {
            throw new NotImplementedException();
        }

        public void Test3()
        {
            throw new NotImplementedException();
        }
    }

}

接口练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _13接口练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //麻雀会飞  鹦鹉会飞  鸵鸟不会飞 企鹅不会飞  直升飞机会飞
            //用多态来实现
            //需方法、抽象类、接口


            IFlyable fly = new Plane();//new MaQue();//new YingWu();
            fly.Fly();
            Console.ReadKey();


        }
    }

    public class Bird
    {
        public double Wings
        {
            get;
            set;
        }
        public void EatAndDrink()
        {
            Console.WriteLine("我会吃喝");
        }
    }

    public class MaQue : Bird,IFlyable
    {

        public void Fly()
        {
            Console.WriteLine("麻雀会飞");
        }
    }

    public class YingWu : Bird, IFlyable,ISpeak
    {


        public void Fly()
        {
            Console.WriteLine("鹦鹉会飞");
        }

        public void Speak()
        {
            Console.WriteLine("鹦鹉可以学习人类说话");
        }
    }


    public class TuoBird : Bird
    {

    }

    public class QQ : Bird
    {

    }


    public class Plane : IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("直升飞机转动螺旋桨飞行");
        }
    }



    public interface IFlyable
    {
        void Fly();

    }

    public interface ISpeak
    {
        void Speak();
    }


}

解决方法重名问题

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _14_显示实现接口
{
    class Program
    {
        static void Main(string[] args)
        {
            //显示实现接口就是为了解决方法的重名问题
            IFlyable fly = new Bird();
            fly.Fly();
            Bird bird = new Bird();
            bird.Fly();

            Console.ReadKey();
        }
    }


    public class Bird : IFlyable
    {
        public void Fly()
        {
            Console.WriteLine("鸟飞会");
        }
        /// 

        /// 显示实现接口
        /// 
        // void IFlyable.Fly()
        //{
        //    Console.WriteLine("我是接口的飞");
        //}

    }

    public interface IFlyable
    {
        void Fly();
    }
}

普通属性，自动属性

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11_自动属性和普通属性
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
    public class Person
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        /// 

        /// 自动属性
        /// 
        public int Age
        {
            get;
            set;
        }
    }
}

接口练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _16超市收银系统
{
    class SupperMarket
    {
        //创建仓库对象
        CangKu ck = new CangKu();
        /// 

        /// 创建超市对象的时候，给仓库的货架上导入货物
        /// 
        public SupperMarket()
        {
            ck.JinPros("Acer", 1000);
            ck.JinPros("SamSung", 1000);
            ck.JinPros("JiangYou", 1000);
            ck.JinPros("Banana", 1000);
        }


        /// 

        /// 跟用户交互的过程
        /// 
        public void AskBuying()
        {
            Console.WriteLine("欢迎观临，请问您需要些什么？");
            Console.WriteLine("我们有 Acer、SamSung、Jiangyou、Banana");
            string strType = Console.ReadLine();
            Console.WriteLine("您需要多少？");
            int count = Convert.ToInt32(Console.ReadLine());
            //去仓库取货物
            ProductFather[] pros = ck.QuPros(strType, count);
            //下面该计算价钱了
            double realMoney = GetMoney(pros);
            Console.WriteLine("您总共应付{0}元", realMoney);
            Console.WriteLine("请选择您的打折方式 1--不打折 2--打九折  3--打85 折  4--买300送50  5--买500送100");
            string input = Console.ReadLine();
            //通过简单工厂的设计模式根据用户的舒服获得一个打折对象
            CalFather cal = GetCal(input);
            double totalMoney = cal.GetTotalMoney(realMoney);
            Console.WriteLine("打完折后，您应付{0}元", totalMoney);
            Console.WriteLine("以下是您的购物信息");
            foreach (var item in pros)
            {
                Console.WriteLine("货物名称:"+item.Name+","+"\t"+"货物单价:"+item.Price+","+"\t"+"货物编号："+item.ID);
            }

        }







        /// 

        /// 根据用户的选择打折方式返回一个打折对象
        /// 
        /// 用户的选择
        /// 返回的父类对象 但是里面装的是子类对象
        public CalFather GetCal(string input)
        {
            CalFather cal = null;
            switch (input)
            {
                case "1": cal = new CalNormal();
                    break;
                case "2": cal = new CalRate(0.9);
                    break;
                case "3": cal = new CalRate(0.85);
                    break;
                case "4": cal = new CalMN(300, 50);
                    break;
                case "5": cal = new CalMN(500, 100);
                    break;
            }
            return cal;
        }




        /// 

        /// 根据用户买的货物计算总价钱
        /// 
        /// 
        /// 
        public double GetMoney(ProductFather[] pros)
        {
            double realMoney = 0;
            //realMoney = pros[0].Price * pros.Length;

            for (int i = 0; i < pros.Length; i++)
            {
                realMoney += pros[i].Price;

                // realMoney = pros[i] * pros.Length;
            }
            return realMoney;
        }




        public void ShowPros()
        {
            ck.ShowPros();
        }

    }
}

ArrayList集合

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _05
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建了一个集合对象
            ArrayList list = new ArrayList();
            //集合：很多数据的一个集合
            //数组：长度不可变、类型单一
            //集合的好处：长度可以任意改变  类型随便
            list.Add(1);
            list.Add(3.14);
            list.Add(true);
            list.Add("张三");
            list.Add('男');
            list.Add(5000m);
            list.Add(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
            Person p = new Person();
            list.Add(p);
            list.Add(list);
            //list.AddRange(new string[]{})
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i] is Person)
                {
                    ((Person)list[i]).SayHello();
                }
                else if (list[i] is int[])
                {
                    for (int j = 0; j < ((int[])list[i]).Length; j++)
                    {
                        Console.WriteLine(((int[])list[i])[j]);
                    }
                }
                else
                {
                    Console.WriteLine(list[i]);
                }


                //Console.WriteLine(list[i]);
            }
            Console.ReadKey();
        }
    }

    public class Person
    {
        public void SayHello()
        {
            Console.WriteLine("我是人类");
        }
    }
}

ArrayList的各种方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
namespace _07
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();
            //添加单个元素
            list.Add(true);
            list.Add(1);
            list.Add("张三");
            //添加集合元素
            list.AddRange(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 });
            //list.AddRange(list);

            //list.Clear();清空所有元素
            //list.Remove(true);删除单个元素 写谁就删谁
            //list.RemoveAt(0);根据下标去删除元素
            //list.RemoveRange(0, 3);根据下标去移除一定范围的元素
            // list.Sort();//升序排列
            //list.Reverse();反转
            //list.Insert(1, "插入的");在指定的位置插入一个元素
            //list.InsertRange(0, new string[] { "张三", "李四" });在指定的位置插入一个集合
            //bool b = list.Contains(1);判断是否包含某个指定的元素
            list.Add("颜世伟");
            if (!list.Contains("颜世伟"))
            {
                list.Add("颜世伟");
            }
            else
            {
                Console.WriteLine("已经有这个屌丝啦");
            }
            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }
            Console.ReadKey();
        }
    }
}

ArrayList集合的长度问题
每次集合中实际包含的元素个数(count)超过了可以包含的元素的个数(capcity)的时候，
集合就会向内存中申请多开辟一倍的空间，来保证集合的长度一直够用。

            ArrayList list = new ArrayList();
            list.Add(1);
            list.Add(1);
            list.Add(1);
            list.Add(1);
            list.Add(1);
            //list.Add(1);
            //list.Add(1);
            //list.Add(1);
            //list.Add(1);
            Console.WriteLine(list.Count);
            Console.WriteLine(list.Capacity);
            Console.ReadKey();
            //count 表示这个集合中实际包含的元素的个数
            //capcity 表示这个集合中可以包含的元素的个数

集合的练习

            //创建一个集合，里面添加一些数字，求平均值与和

            ArrayList list = new ArrayList();

            list.AddRange(new int[] { 1,2,3,4,5,6,7,8,9});
            int sum = 0;
            for (int i = 0; i < list.Count; i++)
            {
                sum += (int)list[i];
               
            }


 //写一个长度为10的集合，要求在里面随机地存放10个数字（0-9），
            //但是要求所有的数字不重复
            //ArrayList list = new ArrayList();
            //Random r = new Random();
            //for (int i = 0; i <10; i++)
            //{
            //    int rNumber = r.Next(0, 10);
            //    //集合中没有这个随机数
            //    if (!list.Contains(rNumber))
            //    {
            //        list.Add(rNumber);
            //    }
            //    else//集合中有这个随机数
            //    {
            //        //一旦产生了重复的随机数 这次循环就不算数
            //        i--;
            //    }

            //}

List和ArrayList的区别
List就像是一个火车,ArrayList就像是自己家的小轿车,List对于装载的事物有限制一开始必须在泛型定义好的事物,就是拉货物的火车车厢中都几乎是货物,

而小汽车是自家的你想拉啥就拉啥,ArrayList就充当小轿车的角色,但是其相对速度 对比火车较差,

在编程中,我们对于ArrayList尽量能不用就不用,由于他什么东西都放,所以往往会导致,你无法用特定的类型进行接收,因为其取出时object类型需要强转为你需要的类型

同时ArrayList和List主要差别为装箱和拆箱的问题

ArrayList:需要首先将类型转变为Object也就是装箱的问题,然后再将Object转换为其所对应的类型也就是拆箱的操作

List:因为泛型中指定了类型所以其不需要进行装箱拆箱操作,效率也就相对提升
1.list性能较高,ArrayList性能较低
2.list一次存储中只能存储泛型中的类型,ArrayList在一次存储中任何类型的数据
3.List中获取值取出的是泛型中发的类型,因为ArrayList对元素没有限制,系统会将中获取的值当object类型的数据,
如果想获取到其中的内容需要进行
4. List在使用时候需要导入的using指令为using System.Collections.Generic;
ArrayList在使用的时候需要导入的using指令为using System.Collections;
5.List属于泛型集合 ArrayList属于非泛型集合

List<>泛型

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建泛型集合对象
            //List list = new List();
            //list.Add(1);
            //list.Add(2);
            //list.Add(3);

            //list.AddRange(new int[] { 1, 2, 3, 4, 5, 6 });
            //list.AddRange(list);

            //List泛型集合可以转换为数组
            //int[] nums = list.ToArray();

            //List listStr = new List();

            //string[] str = listStr.ToArray();


            //char[] chs = new char[] { 'c', 'b', 'a' };
            //List listChar = chs.ToList();
            //for (int i = 0; i < listChar.Count; i++)
            //{
            //    Console.WriteLine(listChar[i]);
            //}

               List listTwo = nums.ToList();


            //for (int i = 0; i < list.Count; i++)
            //{
            //    Console.WriteLine(list[i]);
            //}
            Console.ReadKey();
        }
    }
}

var

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 
{
    class Program
    {
        static void Main(string[] args)
        {
            //var:根据值能够推断出来类型
            //c#是一门强类型语言：在代码当中，必须对每一个变量的类型有一个明确的定义
            //int n = 15;
            //string n2 = "张三";
            //var n3 = 3.14;
            //var n4 = 5000m;
            //var n5 = true;
            //var n6 = '男';
            //Console.WriteLine(n.GetType());
            //Console.WriteLine(n2.GetType());
            //Console.WriteLine(n3.GetType());
            //Console.WriteLine(n4.GetType());
            //Console.WriteLine(n5.GetType());
            //Console.WriteLine(n6.GetType());
            //Console.ReadKey();

            //var input;
            //input = "张三";




            //js是一门弱类型语言
            //12 3.14 true "fdsfds"  'c'  var
        }
    }
}

HashTable(键值对集合)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {

      
    }
}

foreach遍历HashTable

 //创建了一个键值对集合对象
            Hashtable ht = new Hashtable();
            ht.Add(1, "张三");
            ht.Add(2, true);
            ht.Add(3, '男');
            ht.Add(false, "错误的");
            ht.Add(5, "张三");


            foreach (var item in ht.Keys)
            {
                Console.WriteLine("键是-----{0}==============值是{1}", item, ht[item]);
            }
            // foreach 
            Console.WriteLine("\n\n\n==============================");
            int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 556, 45 };

            foreach (var item in nums)
            {
                Console.WriteLine(item);

            }

繁体简体转化

 Hashtable ht = new Hashtable();
            //for (int i = 0; i < Jian.Length; i++)
            //{
            //    ht.Add(Jian[i], Fan[i]);
            //}
            //Console.WriteLine("请随便输入");
            //string input = Console.ReadLine();//张三abc李四
            遍历用户输入的字符串 将每一个字符都转换成繁体字
            //for (int i = 0; i < input.Length; i++)
            //{
            //    if (ht.ContainsKey(input[i]))
            //    {
            //        Console.Write(ht[input[i]]);
            //    }
            //    else
            //    {
            //        Console.Write(input[i]);
            //    }
            //}
            //Console.ReadKey();
            //将用户输入的简体字 转换成繁体字
            for (int i = 0; i < Jian.Length; i++)
            {
                ht.Add(Jian[i], Fan[i]);
            }
            Console.WriteLine("随便输入");
            string input = Console.ReadLine();
            for (int i = 0; i < input.Length; i++)
            {
                if (ht.Contains(input[i]))
                {
                    Console.Write(ht[input[i]]);
                }
                else
                {
                    Console.WriteLine(input[i]);
                }
            }
            Console.ReadKey();

Dictionary字典

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<int, string> dic = new Dictionary<int, string>();
            dic.Add(1, "张三");
            dic.Add(2, "李四");
            dic.Add(3, "王五");
            dic[1] = "新来的";
            //foreach (KeyValuePair kv in dic)
            //{
            //    Console.WriteLine("{0}---{1}",kv.Key,kv.Value);
            //}

            foreach (KeyValuePair <int,string> kv in dic)
            {
                Console.WriteLine("{0}---{1}",kv.Key,kv.Value);
            }

            //foreach (var item in dic.Keys)
            //{
            //    Console.WriteLine("{0}---{1}",item,dic[item]);
            //}
            Console.ReadKey();
        }
    }
}

练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {
        static void Main(string[] args)
        {
            
            // 将一个数组中的奇数放到一个集合中，再将偶数放到另一个集合中
            //最终将两个集合合并为一个集合，并且奇数显示在左边 偶数显示在右边。

            int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            List<int> listOu = new List<int>();
            List<int> listJi = new List<int>();
            for (int i = 0; i < nums.Length; i++)
            {
                if (nums[i] % 2 == 0)
                {
                    listOu.Add(nums[i]);
                }
                else
                {
                    listJi.Add(nums[i]);
                }
            }
            listJi.AddRange(listOu);
            foreach (var item in listJi)
            {
                Console.Write(item + "  ");
            }
            Console.ReadKey();




            //提手用户输入一个字符串，通过foreach循环将用户输入的字符串赋值给一个字符数组

            Console.WriteLine("请输入一个字符串");
            string input = Console.ReadLine();
            char[] chs = new char[input.Length];
            int i = 0;
            foreach (var item in input)
            {
                chs[i] = item;
                i++;
            }

            foreach (var item in chs)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

            //统计 Welcome to china中每个字符出现的次数 不考虑大小写


            字符 ------->出现的次数
            键---------->值
             string str = "Welcome to China";
            Dictionary<char, int> dic = new Dictionary<char, int>();
            for (int i = 0; i < str.Length; i++)
            {
                if (str[i] == ' ')
                {
                    continue;
                }
                //如果dic已经包含了当前循环到的这个键
                if (dic.ContainsKey(str[i]))
                {
                    //值再次加1
                    dic[str[i]]++;
                }
                else//这个字符在集合当中是第一次出现
                {
                    dic[str[i]] = 1;
                }
            }

            foreach (KeyValuePair<char, int> kv in dic)
            {
                Console.WriteLine("字母{0}出现了{1}次", kv.Key, kv.Value);
            }
            Console.ReadKey();

            //w  1



        }
    }
}

装箱、拆箱
装箱：就是将值类型转换为引用类型。
拆箱：将引用类型转换为值类型。
看两种类型是否发生了装箱或者拆箱，要看，这两种类型是否存在继承关系。

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {
        static void Main(string[] args)
        {
            //int n = 10;
            //object o = n;//装箱
            //int nn = (int)o;//拆箱


            //ArrayList list = new ArrayList();
            //List list = new List();
            这个循环发生了100万次装箱操作
            //Stopwatch sw = new Stopwatch();
            00:00:02.4370587
            00:00:00.2857600
            //sw.Start();
            //for (int i = 0; i < 10000000; i++)
            //{
            //    list.Add(i);
            //}
            //sw.Stop();
            //Console.WriteLine(sw.Elapsed);
            //Console.ReadKey();


            //这个地方没有发生任意类型的装箱或者拆箱
            //string str = "123";
            //int n = Convert.ToInt32(str);


            int n = 10;
            IComparable i = n;//装箱

            //发生
        }
    }
}

Path类

 //传统方法获得文件名
            string str = @"C:\3000soft\Red Spider\Data\Message\老赵.wav";
            int index = str.LastIndexOf("\\");
            str = str.Substring(index + 1);
            Console.WriteLine(str);


            //string str = @"C:\3000soft\Red Spider\Data\Message\老赵.wav";
            Console.WriteLine(Path.GetFileName(str));
            //获得文件名但是不包含扩展名
            Console.WriteLine(Path.GetFileNameWithoutExtension(str));
            //获得文件的扩展名
            Console.WriteLine(Path.GetExtension(str));
            //获得文件所在的文件夹的名称
            Console.WriteLine(Path.GetDirectoryName(str));
            //获得文件所在的全路径
            Console.WriteLine(Path.GetFullPath(str));
            //连接两个字符串作为路径
            Console.WriteLine(Path.Combine(@"c:\a\", "b.txt"));


            //int index = str.LastIndexOf("\\");
            //str = str.Substring(index + 1);
            //Console.WriteLine(str);
            Console.ReadKey();

File

（只能读小文件，因为一次读入全部）
创建、复制、粘贴文件

            //创建一个文件
            //File.Create(@"C:\Users\SpringRain\Desktop\new.txt");
            //Console.WriteLine("创建成功");
            //Console.ReadKey();

            //删除一个文件
            //File.Delete(@"C:\Users\SpringRain\Desktop\new.txt");
            //Console.WriteLine("删除成功");
            //Console.ReadKey();
            //1024byte=1kb
            //1024kb=1M
            //1024M=1G
            //1024G=1T
            //1024T=1PT

            //复制一个文件
            //File.Copy(@"C:\Users\SpringRain\Desktop\code.txt", @"C:\Users\SpringRain\Desktop\new.txt");
            //Console.WriteLine("复制成功");
            //Console.ReadKey();


            //剪切
            //File.Move(@"C:\Users\SpringRain\Desktop\code.txt", @"C:\Users\SpringRain\Desktop\newnew.txt");
            //Console.WriteLine("剪切成功");
            //Console.ReadKey();

            File.Create(@"d:\桌面\a.txt");
            //Console.WriteLine(sizeof(char));
            //Console.ReadKey();
            //Console.WriteLine(sizeof(string));a  "dsfdsfds"
            //Console.ReadKey();

使用File类操作文件的数据，字节流File.ReadAllBytes、WriteAllBytes

			//读取
            //File.ReadAllBytes 打开一个二进制文件，将文件的内容读入一个字节数组，然后关闭该文件。
            byte[] buffer = File.ReadAllBytes(@"C:\Users\18578\Desktop\1.txt");
            //按照指定编码格式解码成字符串
            string s = Encoding.Default.GetString(buffer);
            Console.WriteLine(s);

			//写入
			string s = "今天天气好晴朗，处处好风光";
            //将字符串转换成字节数组
            byte[] buffer = Encoding.Default.GetBytes(s);
            //以字节的形式向计算机中写入文本文件
            File.WriteAllBytes(@"C:\Users\18578\Desktop\new_txt.txt", buffer);
            Console.WriteLine("写入成功");
            Console.ReadKey();

读取文件ReadAllText、ReadAllLines

            string str=File.ReadAllText (@"C:\Users\18578\Desktop\.net基础班笔记\0505.Net基础班第九天.txt", Encoding.Default);

            Console.WriteLine(str);

   string[] contents = File.ReadAllLines(@"C:\Users\18578\Desktop\.net基础班笔记\0505.Net基础班第九天.txt",Encoding.Default);

            foreach (var item in contents)
            {
                Console.WriteLine(item);
            }

FileStream文件流

FileStream 操作字节的 ，StreamReader和StreamWriter是操作字符的

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _
{
    class Program
    {
        static void Main(string[] args)
        {
		            //使用FileStream来读取数据                                                     对文件进行操作     对文件的数据进行操作
            FileStream fsRead = new FileStream(@"C:\Users\SpringRain\Desktop\new.txt", FileMode.OpenOrCreate, FileAccess.Read);
            byte[] buffer = new byte[1024 * 1024 * 5];
            //3.8M  5M
            //返回本次实际读取到的有效字节数
            //       buffe读取的大小 0开始的位置  buffer.Length读取的长度
            int r = fsRead.Read(buffer, 0, buffer.Length);
            //将字节数组中每一个元素按照指定的编码格式解码成字符串
            string s = Encoding.UTF8.GetString(buffer, 0, r);
            //关闭流
            fsRead.Close();
            //释放流所占用的资源
            fsRead.Dispose();
            Console.WriteLine(s);
            Console.ReadKey();

            //将创建文件流对象的过程写在using当中，会自动的帮助我们释放流所占用的资源。

            //使用FileStream来写入数据
            //using (FileStream fsWrite = new FileStream(@"C:\Users\SpringRain\Desktop\new.txt", FileMode.OpenOrCreate, FileAccess.Write))
            //{
            //    string str = "看我游牧又把你覆盖掉";
            //    byte[] buffer = Encoding.UTF8.GetBytes(str);
            //    fsWrite.Write(buffer, 0, buffer.Length);
            //}
            //Console.WriteLine("写入OK");
            //Console.ReadKey();

        }
    }
}

使用FileStream复制文件

using System;
using System.Diagnostics;
using System.Text;
using System.IO;
using System.Collections;
using System.Collections.Generic;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            
            string Source= @"C:\Users\18578\Desktop\1.第1集 上(Av71516555,P1).mp4";
            string Target = @"C:\Users\18578\Desktop\new.mp4";
            CopyFile(Source,Target);

        }
        public static void CopyFile(string source, string target)
        {
            //创建一个写入流
            using (FileStream fsWrite = new FileStream(target, FileMode.OpenOrCreate, FileAccess.Write))
            {
                //创建一个读取流
                using (FileStream fsReader = new FileStream(source, FileMode.Open, FileAccess.Read)) 
                {
                    byte[] buffer = new byte[1024 * 1024 * 5];

                    while (true)
                    {
                        //返回实际读取到的字节数
                        int r = fsReader.Read(buffer,0,buffer.Length);
                        //读取完成，退出循环
                        if (r == 0) { break; }
                        fsWrite.Write(buffer,0,r);
                    }
                }

            }
        }
    }

}

StreamReader和StreamWriter

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
namespace _08StreamReader和StreamWriter
{
    class Program
    {
        static void Main(string[] args)
        {
            //使用StreamReader来读取一个文本文件
            using (StreamReader sr = new StreamReader(@"D:\桌面\a.txt", Encoding.Default))
            {
                using (StreamWriter sw = new StreamWriter(@"D:\桌面\b.txt",true))
                {
                    while (!sr.EndOfStream)
                    {
                        Console.WriteLine(sr.ReadLine());
                        sw.Write(sr.ReadLine());
                    }
                }
                Console.WriteLine("OK");
                Console.ReadKey();
            }


            //使用StreamWriter来写入一个文本文件
            //using (StreamWriter sw = new StreamWriter(@"C:\Users\SpringRain\Desktop\newnew.txt",true))
            //{
            //    sw.Write("看我有木有把你覆盖掉");
            //}
            //Console.WriteLine("OK");
            //Console.ReadKey();
        }
    }
}

序列化和反序列化
序列化：将对象转化为二进制
反序列化：将二进制转换成对象
作用：传输数据

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
namespace _05序列化和反序列化
{
    class Program
    {
        static void Main(string[] args)
        {
            //要将p这个对象 传输给对方电脑
            //Person p = new Person();
            //p.Name = "张三";
            //p.Age = 19;
            //p.Gender = '男';
            //using (FileStream fsWrite = new FileStream(@"C:\Users\SpringRain\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Write))
            //{
            //    //开始序列化对象
            //    BinaryFormatter bf = new BinaryFormatter();
            //    bf.Serialize(fsWrite, p);
            //}
            //Console.WriteLine("序列化成功");
            //Console.ReadKey();

            //接收对方发送过来的二进制 反序列化成对象
            Person p;
            using (FileStream fsRead = new FileStream(@"C:\Users\SpringRain\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Read))
            {
                BinaryFormatter bf = new BinaryFormatter();
                p = (Person)bf.Deserialize(fsRead);
            }
            Console.WriteLine(p.Name);
            Console.WriteLine(p.Age);
            Console.WriteLine(p.Gender);
            Console.ReadKey();
        }
    }


    [Serializable]
    public class Person
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }


        private char _gender;

        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }

        private int _age;

        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }
    }
}

partial部分类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _06部分类
{
    class Program
    {
        static void Main(string[] args)
        {
        }
    }

    public partial class Person
    {
        private string _name;
        public void Test()
        {

        }
    }

    public partial class Person
    {
        public void Test(string name)
        {
           // _name
        }
    }
}

密封类
如果所有的类都可以被继承，那么很容易导致继承的滥用，进而使类的层次结构体系变得十分复杂，这样使得开发人员对类的理解和使用变得十分困难，为了避免滥用继承，C#中提出了密封类的概念。
密封类可以继承其他类，密封类不能继承

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _07密封类
{
    class Program
    {
        static void Main(string[] args)
        {

        }
    }

    public sealed class Person:Test
    {

    }

    public class Test
    {

    }
}

重写父类Tostring方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _08重写ToString__方法
{
    class Program
    {
        static void Main(string[] args)
        {
            Person p = new Person();
            Console.WriteLine(p.ToString());
            Console.ReadKey();
        }
    }

    public class Person
    {
        public override string ToString()
        {
            return "Hello World";
        }
    }
}

GUID

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _17GUID
{
    class Program
    {
        static void Main(string[] args)
        {
            //产生一个不会重复的编号
            Console.WriteLine(Guid.NewGuid().ToString());
            Console.WriteLine(Guid.NewGuid().ToString());
            Console.WriteLine(Guid.NewGuid().ToString());
            Console.WriteLine(Guid.NewGuid().ToString());
            Console.WriteLine(Guid.NewGuid().ToString());
            Console.ReadKey();
        }
    }
}

MD5加密

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace _01MD5加密
{
    class Program
    {
        static void Main(string[] args)
        {
            // 目标：202cb962ac59075b964b07152d234b70
            string s = GetMD5("123");

        }

        public static string GetMD5(string str)
        {
            //创建MD5对象
            MD5 md5 = MD5.Create();
            //开始加密
            //需要将字符处转换成字节数组
            byte[] buffer = Encoding.GetEncoding("GBK").GetBytes(str);
            //返回一个加密好的字节数组
            byte[] MD5Buffer = md5.ComputeHash(buffer);

            //将字节数组转换成字符串

            string strNew = "";
            for (int i = 0; i < MD5Buffer.Length; i++)
            {	//转化成16进制Tostring（x）  2是对齐								
                strNew += MD5Buffer[i].ToString("x2");
            }
            return strNew;
        }
    }
}

进程与线程

进程打开应用

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _15进程
{
    class Program
    {
        static void Main(string[] args)
        {
            //获得当前程序中所有正在运行的进程
            //Process[] pros = Process.GetProcesses();
            //foreach (var item in pros)
            //{
            //    //不试的不是爷们
            //    //item.Kill();
            //    Console.WriteLine(item);
            //}

            //通过进程打开一些应用程序
            //Process.Start("calc");
            //Process.Start("mspaint");
            //Process.Start("notepad");
            //Process.Start("iexplore", "http://www.baidu.com");

            //通过一个进程打开指定的文件

            ProcessStartInfo psi = new ProcessStartInfo(@"C:\Users\SpringRain\Desktop\1.exe");

            //第一：创建进程对象
            Process p = new Process();
            p.StartInfo = psi;
            p.Start();
           // p.star


            Console.ReadKey();
        }
    }
}

多线程执行任务

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _17_线程
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        Thread th;
        private void button1_Click(object sender, EventArgs e)
        {
            //创建一个线程去执行这个方法
            th = new Thread(Test);
            //标记这个线程准备就绪了，可以随时被执行。具体什么时候执行这个线程，
            //由cpu决定
            //将线程设置为后台线程
            th.IsBackground = true;
            th.Start();
            th.Abort();
            th.Start();

        }

        private void Test()
        {
            for (int i = 0; i < 10000; i++)
            {
                //Console.WriteLine(i);
                textBox1.Text = i.ToString();
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            //取消跨线程的访问
            Control.CheckForIllegalCrossThreadCalls = false;
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            //当你点击关闭窗体的时候，判断新线程是否为null
            if (th != null)
            {
                //结束这个线程
                th.Abort();
            }
        }

    }
}

摇奖机

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _05_摇奖机应用程序
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        bool b = false;
        private void button1_Click(object sender, EventArgs e)
        {
            if (b == false)
            {
                b = true;
                button1.Text = "停止";
                Thread th = new Thread(PlayGame);
                th.IsBackground = true;
                th.Name = "新线程";
               // th.
                th.Start();
            }
            else//b==true
            {
                b = false;
                button1.Text = "开始";
            }
            //PlayGame();
        }
        private void PlayGame()
        {
            Random r = new Random();
            while (b)
            {
                label1.Text = r.Next(0, 10).ToString();
                label2.Text = r.Next(0, 10).ToString();
                label3.Text = r.Next(0, 10).ToString();
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
        }
    }
}

Socket

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MyWindowsForms
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //  创建一个监听Socket            指定IPV4，使用TCP协议
            Socket socketWatch = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            //创建IP地址和端口号对象
            IPAddress ip = IPAddress.Any;
            IPEndPoint point = new IPEndPoint(ip,Convert.ToInt32(TbPort.Text));
            //MessageBox.Show(ip);
            //Socket绑定IP地址跟端口号
            socketWatch.Bind(point);

            ShowMes("监听成功");
            //设置监听队列
            socketWatch.Listen(10);
            //负责监听的Socket 来接受客户端的连接,创建跟客户端通信的Socket

            Socket socketSend = socketWatch.Accept();
            ShowMes(socketSend.RemoteEndPoint.ToString());


        }

        void ShowMes(string str) 
        {
            TbLog.AppendText(str + "\r\n");
        }
    }
}

telnet 192.168.81.1  50000 

线程携带参数

接受端

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MyWindowsForms
{
    public partial class Form1 : Form
    {  
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
        }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {

        }

        private void textBox1_TextChanged_1(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            //  创建一个监听Socket            指定IPV4，使用TCP协议
            Socket socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //创建IP地址和端口号对象
            IPAddress ip = IPAddress.Any;
            IPEndPoint point = new IPEndPoint(ip,Convert.ToInt32(TbPort.Text));
            //MessageBox.Show(ip);
            //Socket绑定IP地址跟端口号
            socketWatch.Bind(point);
            //设置监听队列
            socketWatch.Listen(10);
            ShowMes("监听成功");


            //开启新的线程来执行Listen方法
            Thread th1 = new Thread(Linsten);
            th1.IsBackground = true;
            th1.Start(socketWatch);

            


        }

        void ShowMes(string str) 
        {
            TbLog.AppendText(str + "\r\n");
        }

        void Linsten(object o) 
        {

            Socket socketWatch = o as Socket;
            while (true)
            {   //负责监听的Socket 来接受客户端的连接,创建跟客户端通信的Socket
                Socket socketSend = socketWatch.Accept();
                ShowMes(socketSend.RemoteEndPoint.ToString()+"连接成功");

                Thread th2 = new Thread(Rec);
                th2.IsBackground = true;
                th2.Start(socketSend);
            }
        }
        void Rec(object o)
        {
            while (true)
            {
                Socket socketSend = o as Socket;
                byte[] buffer = new byte[1024 * 1024 * 2];
                int r = socketSend.Receive(buffer);
                if (r == 0) { break; }
                string str = System.Text.Encoding.UTF8.GetString(buffer, 0, r);
                ShowMes(socketSend.RemoteEndPoint.ToString() + ":" + str);



            }
        }
    }
}

发送端

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace MyWindowsFormsRecept
{
    public partial class Form1 : Form
    {    //  创建一个监听Socket            指定IPV4，使用TCP协议
        Socket socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        public Form1()
        {
            InitializeComponent();
        }

        private void BtnListen_Click(object sender, EventArgs e)
        {
           
            //创建IP地址和端口号对象
            IPAddress ip = IPAddress.Parse(TbIP.Text);
            IPEndPoint point = new IPEndPoint(ip, Convert.ToInt32(TbPort.Text));
            //MessageBox.Show(ip);
            //Socket绑定IP地址跟端口号
            socketWatch.Connect(point);
            ShowMes("连接成功");
        }

        void ShowMes(string str)
        {
            TbLog.AppendText(str + "\r\n");
        }

        private void textBox1_TextChanged(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            string str = textBox1.Text;
            byte[] buffer = System.Text.Encoding.UTF8.GetBytes(str);
            socketWatch.Send(buffer);
        }
    }
}

索引器

Person p=new Person();
p[1]=1
p[2]=2
public class Person
{
	int[] nums=new int[100];
	public int this[int index]
	{
		get{return nums[index];}
		set{nums[index]=value}
	}


}

委托
C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。引用可在运行时被改变。
委托（Delegate）特别用于实现事件和回调方法。所有的委托（Delegate）都派生自 System.Delegate 类。

using System;

namespace MyConsoleApp
{
    public delegate void DelSayHello(string name);
    class Program
    {
        static void Main(string[] args)
        {
            //声明的委托必须跟指向的方法具有同样的签名
			//new DelSayHi(SayHiEnglish);
            //del("张三");
            //new DelSayHello(JapaneseSayHello("张三"));

            DelSayHello del = JapaneseSayHello;
            Test("张三",JapaneseSayHello);
        }

        public static void Test(string name, DelSayHello del) 
        {
            del(name);
        }

        public static void ChineseSayHello(string name) 
        {
            Console.WriteLine("你好"+name);
        }
        public static void JapaneseSayHello(string name)
        {
            Console.WriteLine("o ha yo" + name);
        }
    }
}

用法

using System;

namespace MyConsoleApp
{
    public delegate string DelProStr(string str);
    class Program
    {
        static void Main(string[] args)
        {
            //DelProStr del = StrToUpper;
            string s=ProcessStr("abcsdaaEDFASDA",StrToUpper);
            DelProStr del1 = StrToLower;
            string s1=ProcessStr("abcsdaaEDFASDA", StrToLower);
            Console.WriteLine(s);
            Console.WriteLine("\n\n\n\n");
            Console.WriteLine(s1);
        }



        public static string ProcessStr(string str, DelProStr del) 
        {
            string strNew = null;
            char[] chs = str.ToCharArray();
            for (int i = 0; i < chs.Length; i++)
            {
                strNew += del(chs[i].ToString());
            }
            return strNew;
        }

        public static string StrToUpper(string str)
        {
            return str.ToUpper();
        }
        public static string StrToLower(string str)
        {
            return str.ToLower();
        }
    }
}

匿名函数
创建匿名方法实际上是一种将代码作为委托参数传递的方式，如下示例：

using System;

namespace MyConsoleApp
{
    public delegate string DelProStr(string str);
    class Program
    {
        static void Main(string[] args)
        {
            //使用匿名函数
            DelProStr del = delegate (string str)
            {

                return str.ToUpper();
            };
            string s = del("abcDEFg");
            Console.WriteLine(s);
        }

        


    }
}

求数组的最大值

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _10求数组的最大值
{
    public delegate int DelCompare(object o1, object o2);
    class Program
    {
        static void Main(string[] args)
        {
            object[] o = {"abc","fdsfdsds","fdsfdsfdsfdsfdsfds","fdsfds"};

            object result = GetMax(o, (object o1,object o2) => {
                string s1 = (string)o1;
                string s2 = (string)o2;
                return s1.Length - s2.Length;
            });
            Console.WriteLine(result);
            Console.ReadKey();
        }

        public static object GetMax(object[] nums, DelCompare del)
        {
            object max = nums[0];
            for (int i = 0; i < nums.Length; i++)
            {
                //要传一个比较的方法
                if (del(max, nums[i]) < 0)
                {
                    max = nums[i];
                }
            }
            return max;
        }


     
    }
}

泛型委托

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _11_泛型委托
{
    public delegate int DelCompare<T>(T t1, T t2);
    // public delegate int DelCompare(object o1, object o2);
    class Program
    {
        static void Main(string[] args)
        {
            int[] nums = { 1, 2, 3, 4, 5 };
            int max = GetMax<int>(nums, Compare1);
            Console.WriteLine(max);

            string[] names = { "abcdefg", "fdsfds", "fdsfdsfdsfdsfdsfdsfdsfsd" };
            string max1 = GetMax<string>(names, (string s1, string s2) =>
            {
                return s1.Length - s2.Length;
            });
            Console.WriteLine(max1);
            Console.ReadKey();
        }
        public static T GetMax<T>(T[] nums, DelCompare<T> del)
        {
            T max = nums[0];
            for (int i = 0; i < nums.Length; i++)
            {
                //要传一个比较的方法
                if (del(max, nums[i]) < 0)
                {
                    max = nums[i];
                }
            }
            return max;
        }


        public static int Compare1(int n1, int n2)
        {
            return n1 - n2;
        }
    }
}

lamda表达式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _12_lamda表达式
{

    public delegate void DelOne();
    public delegate void DelTwo(string name);
    public delegate string DelThree(string name);
    class Program
    {
        static void Main(string[] args)
        {
            DelOne del = () => { };// delegate() { };

            DelTwo del2 = (string name) => { };//delegate(string name) { };

            DelThree del3 = (string name) => { return name; };//delegate(string name) { return name; };


            List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            list.RemoveAll(n => n > 4);
            foreach (var item in list)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
        }
    }
}

委托窗体传值

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _14_窗体传值
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Form2 frm2 = new Form2(ShowMsg);
            frm2.Show();
        }


        void ShowMsg(string str)
        {
            label1.Text = str;
        }
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _14_窗体传值
{

    //声明一个委托
    public delegate void DelTest(string str);
    public partial class Form2 : Form
    {
        public DelTest _del;
        public Form2(DelTest del)
        {
            this._del = del;
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            _del(textBox1.Text);
        }
    }
}

多播委托

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _15多播委托
{
    public delegate void DelTest();
    class Program
    {
        static void Main(string[] args)
        {
            DelTest del = T1;
            del += T2;
            del += T3;
            del+= T4;
            del -= T3;
            del -= T1;
            del();
            Console.ReadKey();
        }

        public static void T1()
        {
            Console.WriteLine("我是T1");
        }
        public static void T2()
        {
            Console.WriteLine("我是T2");
        }

        public static void T3()
        {
            Console.WriteLine("我是T3");
        }
        public static void T4()
        {
            Console.WriteLine("我是T4");
        }
    }
}

XML

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
namespace _4_创建带属性的XML文档
{
    class Program
    {
        static void Main(string[] args)
        {
            XmlDocument doc = new XmlDocument();
            XmlDeclaration dec = doc.CreateXmlDeclaration("1.0", "utf-8","yes");
            doc.AppendChild(dec);

            XmlElement order = doc.CreateElement("Order");
            doc.AppendChild(order);

            XmlElement customerName = doc.CreateElement("CustomerName");
            customerName.InnerXml = "
我是一个p标签
";
            order.AppendChild(customerName);

            XmlElement customerNumber = doc.CreateElement("CustomerNumber");
            //符号会转义
            customerNumber.InnerText = "
我是一个p标签
";
            order.AppendChild(customerNumber);


            XmlElement items = doc.CreateElement("Items");
            order.AppendChild(items);

            XmlElement orderItem1 = doc.CreateElement("OrderItem");
            //给节点添加属性
            orderItem1.SetAttribute("Name", "充气娃娃");
            orderItem1.SetAttribute("Count", "10");
            items.AppendChild(orderItem1);

            XmlElement orderItem2 = doc.CreateElement("OrderItem");
            //给节点添加属性
            orderItem2.SetAttribute("Name", "充气娃娃");
            orderItem2.SetAttribute("Count", "10");
            items.AppendChild(orderItem2);

            XmlElement orderItem3 = doc.CreateElement("OrderItem");
            //给节点添加属性
            orderItem3.SetAttribute("Name", "充气娃娃");
            orderItem3.SetAttribute("Count", "10");
            items.AppendChild(orderItem3);

            doc.Save("Order.xml");
            Console.WriteLine("保存成功");
            Console.ReadKey();


        }
    }
}

泛型约束

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyGeneric
{
    public class Constraint
    {
        /// 

        /// 泛型：不同的参数类型都能进来；任何类型都能过来，你知道我是谁?
        /// 没有约束，也就没有自由
        /// 泛型约束--基类约束（不能是sealed）：
        /// 1 可以使用基类的一切属性方法---权利
        /// 2  强制保证T一定是People或者People的子类---义务
        /// 
        /// 
        /// 
        public static void Show<T>(T tParameter)
            where T : People, ISports, IWork, new()
        {
            //Console.WriteLine("This is {0},parameter={1},type={2}",
            //    typeof(GenericMethod), tParameter.GetType().Name, tParameter.ToString());

            Console.WriteLine($"{tParameter.Id}_{tParameter.Name}");
            tParameter.Hi();
            //tParameter.Majiang();
            tParameter.Pingpang();
            tParameter.Work();
        }
        public static void ShowBase(People tParameter)//因为约束可以叠加  更灵活
        {
            Console.WriteLine($"{tParameter.Id}_{tParameter.Name}");
            tParameter.Hi();
        }

        public static T Get<T>(T t)
            //where T : ISports//接口约束
            //where T : class//引用类型约束
            //where T : struct//值类型约束
            where T : new()//无参数构造函数约束
        {
            //t.Pingpang();
            //T tNew = null;
            //T tNew = default(T);//会根据T的不同  赋予默认值
            T tNew = new T();
            return t;
        }
    }
}