控制台应用程序学习

.NET

console.WriteLine();
console.ReadKey();

#Region和#EndRegion//折叠冗余代码

decimal money=5000m; 

int n0 = 0;
int n1 = 1;
int n2 = 2;
//占位符
Console.WriteLine("第一个数字是：
{0}，第二个数字是：{1}，第三个数字是：{2}", n0, n1, n2);
 Console.ReadKey();

//接收用户信息输入
string name=Console.ReadLine();

//@ 符号作用：1、取消转义字符的功能让它只表示\。
string path = @"F:\老赵生活\music\a\b\c\d\e\小泽玛利亚.avi";
Console.WriteLine(path);
Console.ReadKey();
//2、将字符串按照编辑的原格式输出
Console.WriteLine(@"今天天气好晴朗
处处好风光");
Console.ReadKey();

int n1 = 10;
int n2 = 3;
double d = n1 * 1.0 / n2;//将n1转换为double类型
Console.WriteLine("{0:0.00}", d);//占位符保留小数点后几位的方法
Console.ReadKey();

//一元运算符优先级高于二元运算符
//逻辑与的优先级要高于逻辑或

Console.ReadLine()所接收的是字符串，赋值给int或double类型需要进行转换

try{}catch{} 

程序调试：
1、F11逐语句调试
2、F10逐过程调试
3、断点调试

int.Parse("123") 和 Convert.ToInt("123") 一样

int.TryParse
int number=0
bool b=int.TryParse("123",out number)//转换成功将值赋给number 返回true，转换失败，给number赋值0，返回false。

产生随机数：
1、创建能够产生随机数的对象
Radom r=new Random();
2、让产生随机数的这个对象调用方法来产生随机数
int rNumber=r.Next(1,11)//包左不包右

Math.Random是前端产生随机数

const int number=50//定义常亮

变量类型转换：

//Convert类型转换
string s = "123";
double d = Convert.ToDouble(s);
Console.WriteLine(d);
Console.ReadKey();
//Convert类型转换  转换的数据在形式上必须可以进行转换否则会报异常如：
string s = "123abc";
double d = Convert.ToDouble(s);
Console.WriteLine(d);//换行
Console.Write(d);//不换行 
Console.ReadKey();

将枚举声明到命名空间的下面，类的外面，表示这个命名空间下所有类都可以使用这个枚举。命名格式：
public enum Sex
{
       男，
       女，
       ........
}
使用：Sex a=Sex.男
//枚举类型默认可以跟int类型互相转换
console.WriteLine((int)Sex.男)//0
console.WriteLine((int)Sex.女)//1
//   int类型和枚举类型以序号相对应
console.WriteLine((Sex)0)    //男
console.WriteLine((Sex)1)    //女

//所有的类型都能够转换成string类型  用    .ToString()  如
int n1=10;
string s=n1.ToString();
Sex a=Sex.男；
String b=a.ToString();//b="男"

可以将一个枚举类型的变量跟int类型和string类型互相转换

枚举类型默认是跟int类型互相兼容的，所以可以通过强制类型转换的语法互相转换

当转换一个枚举中没有的值的时候，不会抛异常，而是直接将数字显示出来

枚举同样也可以跟string类型互相转换，如果将枚举类型转换成string类型，则直接调用ToString（）。

如果将字符串转换成枚举类型则需要下面这样一串代码：

         （要转换的枚举类型）Enum.Parse(typeof(要转换的枚举类型)，"要转换的字符串")；

如果转换的字符串是数字，则就算枚举中没有，也不会抛异常

如果转换的字符串是文本，如果枚举中没有，则会抛异常 

 

 

 //枚举、结构体综合使用

public struct Person
{
       public string _name;//字段
       public int _age;
       public Gender _gender;

 }

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

 public enum Gender
 {
        男,
        女,
  };
     

主函数：     

Person zsPerson;
zsPerson._age = 14;
zsPerson._name = "张三";
zsPerson._gender = Gender.男;
Console.WriteLine(zsPerson._age);
Console.WriteLine(zsPerson._name);
Console.WriteLine(zsPerson._gender);
Console.ReadKey();

 

 

数组的定义

int[] aaa=new int[10];

var aaa=[];

int aaa[10]={};

数组排序  两个方法：1、Array.Sort(nums)    2、Array.Reverse(nums)

 

out、ref、params三个高级参数

如果你在一个方法中，返回多个相同类型的值的时候，可以考虑返回一个数组。

但是，如果返回多个不同类型的值的时候，返回数组就不行了，那么这个时候，

我们就可以考虑使用out参数。

out参数就侧重于在一个方法中可以返回多个不同类型的值。       采用out参数传递时，该参数在创建时，可以不设置初始值，但是在方法中必须初始化，out侧重于输出；

 /// <summary>
        /// 分别的提示用户输入用户名和密码
        /// 你写一个方法来判断用户输入的是否正确
        /// 返回给用户一个登陆结果，并且还要单独的返回给用户一个登陆信息
        /// 如果用户名错误，除了返回登陆结果之外，还要返回一个“用户名错误”“密码错误”
        /// </summary>
        /// <param name="name">姓名</param>
        /// <param name="pwd">密码</param>
        /// <param name="msg">状态</param>
        /// <returns></returns>
        public static bool IsLogin(string name, string pwd, out string msg) {
            if (name == "admin" && pwd == "888888")
            {
                msg = "登陆成功";
                return true;
            }
            else if (name == "admin")
            {
                msg = "密码错误";
                return false;
            }
            else if (pwd == "888888")
            {
                msg = "用户名错误";
                return false;
            }
            else
            {
                msg = "未知错误";
                return false;
            }

        }

  while (true) {
                string name;
                string pwd;
                string msg;
                Console.WriteLine("请输入用户名");
                name=Console.ReadLine();
                Console.WriteLine("请输入密码");
                pwd = Console.ReadLine();
                bool b=IsLogin(name, pwd,out msg);
                Console.WriteLine("登陆结果{0}", b);
                Console.WriteLine("登陆信息{0}", msg);
                Console.ReadKey();

            }

ref 高级参数：使值随着传入参数的改变而改变       使用ref进行参数的传递时，该参数在创建时，必须设置其初始值，且ref侧重于修改；

        public static void JiangJin(ref double s)
        {
            s += 500;
        }

        public static void FaKuan(double s)
        {
            s -= 500;
        }

    double salary = 5000;
    JiangJin(ref salary);
    Console.WriteLine(salary);//salary 值发生改变  ref传入参数，外面的参数也随之改变
    Console.ReadKey();

params高级参数：将实参列表中跟可变参数数组类型一致的元素都当作数组的元素去处理

params可变参数必须是形参列表中的最后一个元素

public static void Test(string name, params int[] score)//params 参数数组必须是形参列表中的最后一个参数
{
     int sum = 0;
     for (int i = 0; i < score.Length; i++)
     {
         sum += score[i];
     }
     Console.WriteLine("{0}这次考试的总成绩是{1}", name, sum);
}

    //int[] s = { 99, 88, 77 };
    Test("张三", 99,88,77);//直接传入int数据
    Console.ReadKey();

保留两位小数：

double i=3.3333333333;
string s=i.ToString("{0.00}");//转换成两位小数的字符串
i=Convert.ToDouble(s);//转换成两位小数

控制台背景色和前景色：

Console.BackgroundColor=ConsoleColor.Yellow;

Console.ForegroundColor=ConsoleColor.Yellow;

 

Console.Clear();//清屏

 

类的属性有两个默认函数，赋值时调用set，取值时调用get

namespace two
{
    class test
    {
        private static string _name;

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

        }
    }
}

this 关键字

1、代表当前类的对象

2、在类当中显示的调用本类的构造函数

            #region 类的使用和this关键字
            Class1 cl = new Class1("张三", 18, '男', 100, 100, 100);
            Console.WriteLine("{0}{1}岁,性别：{2},语文：{3}，数学：{4}，英语：{5}", cl.Name, cl.Age, cl.Gender, cl.Chinese, cl.Math, cl.English);
            Console.ReadKey();

            Class1 co = new Class1("李四", 90, 90, 90);
            Console.WriteLine("{0}{1}岁,性别：{2},语文：{3}，数学：{4}，英语：{5}", co.Name, co.Age, co.Gender, co.Chinese, co.Math, co.English);
            Console.ReadKey();
            #endregion

 

Alt+Shift+F10      //快速代码补全

Ctrl+Enter    //快速代码补全

 

在一个项目中引用另一个项目的类：两步

1、添加引用

 

2、引用命名空间

using one;

            #region 引用外部项目
            List<int> list =new List<int>();

            lead le = new lead("王五", 18);
            Console.WriteLine("{0}{1}岁", le.Name, le.Age);
            Console.ReadKey();
            #endregion

 

堆栈存储数据：栈存储堆中数据的地址

值类型：int、double、bool、char、decimal、struct、enum

引用类型：string、自定义类、数组

存储：

值类型的值是存储在内存的栈中

引用类型的值是存储在内存中的堆中

 

 

字符串的不可变性：

当你给一个字符串重新赋值之后，老值并没有销毁，而是重新开辟一块空间存储新值

当程序结束后，GC扫描整个内存，如果发现有的空间没有被指向，则立即把他销毁

 

 

字符串

            #region 字符串
            //可以将string看做char类型的只读数组，所以可以通过下标去访问字符串中的某一个元素
            string s = "abcdefg";
            Console.WriteLine(s[0]);
            Console.ReadKey();
            #endregion

//将字符串转换为char类型的数组

            char[] chs = s.ToCharArray();
            Console.WriteLine(chs);
            Console.ReadKey();

//将字符串数组转换为我们的字符串

            chs[0] = 'b';
            s = new string(chs);
            Console.WriteLine(s[0]);
            Console.WriteLine(s);
            Console.ReadKey();

//对字符串进行操作StringBuilder     .Append(i)//增加字符串方法

//定时器Stopwatch类：用于测量起Start始Stop之间程序运行时间

        string str = null;
        StringBuilder sb = new StringBuilder();
        //创建一个计时器，用来记录程序运行的时间
        Stopwatch sw = new Stopwatch();
        sw.Start();//开始计时
        for (int i = 0; i < 100000; i++)
        {
            //str += i;
            sb.Append(i);//增加字符方法
        }
        sw.Stop();//结束计时
        Console.WriteLine(sw.Elapsed);//获取当前实例测量得出的总运行时间  str:00:00:13.3352976   sb:00:00:00.0149070
        Console.ReadKey();

//字符串大小写如何比较 

1、全部转换成小写或全部转换成大写

2、用Equals方法，此方法有3个重载函数，根据不同参数实现不同比较方法

            //字符串大小写如何比较
            Console.WriteLine("请输入你喜欢的课程");
            string lessonOne = Console.ReadLine();

            //将字符串转换成大写
            //lessonOne = lessonOne.ToUpper();

            //将字符串转换成小写
            //lessonOne = lessonOne.ToLower();

            Console.WriteLine("请输入你喜欢的课程");
            string lessonTwo = Console.ReadLine();

            //将字符串转换成大写
            //lessonTwo = lessonTwo.ToUpper();

            //将字符串转换成小写
            //lessonTwo = lessonTwo.ToLower();

            //if (lessonOne == lessonTwo)
            if(lessonOne.Equals(lessonTwo,StringComparison.OrdinalIgnoreCase)/*第二个参数是枚举值之一，用于指定将如何比较字符串*/)
            {
                Console.WriteLine("你们俩喜欢的课程相同");
            }
            else
            {
                Console.WriteLine("你们俩喜欢的课程不同");
            }
            Console.ReadKey();

 

 

//字符串的分割  用Split方法，此方法有6个重载，根据不同参数实现不同分割方法

            string ds = "a b    dfd _   +   =    ,,,  fdf";
            char[] cdhs = { ' ', '_', '+', '=', ',' };//需要去掉字符串的合集
            string[] str = ds.Split(cdhs, StringSplitOptions.RemoveEmptyEntries);//将chs中的字符串去掉但会留下空字符串，第二个参数是将这些空字符串去掉
            Console.ReadKey();
            //小练习  从日期字符串（“2008-08-08”）中分析出年、月、日；2008年08月08日。
            string s = "2008-08-08";
            char[] chs = { '-' };
            string[] date = s.Split(chs, StringSplitOptions.RemoveEmptyEntries);
            Console.WriteLine("{0}年{1}月{2}日", date[0], date[1], date[2]);
            Console.ReadKey();

 

字符串函数详解：
1、字符串替换：string Replace(string oldValue,string newValue)将字符串中的出现oldValue的地方替换为newValue。例子：名字替换

            string str = "国家关键人物老赵";
            if (str.Contains("老赵"))
            {
                str = str.Replace("老赵", "**");
            }
            Console.WriteLine(str);
            Console.ReadKey();

2、取字符串：string Substring(int startIndex),取从位置startIndex开始一直到最后的字符串；

            string str = "今天天气好晴朗，处处好风光";
            str = str.Substring(1);
            Console.WriteLine(str);
            Console.ReadKey();//天天气好晴朗，处处好风光

 3、string Substring(int startIndex,int length),取从位置startIndex开始长度为length的子字符串，如果字符串的长度不足length则报错。（2的重载） 

            string str = "今天天气好晴朗，处处好风光";
            str = str.Substring(1,2);
            Console.WriteLine(str);
            Console.ReadKey();//天天

4、bool Contains(string value)判断字符串中是否含有子串value。（1中有例）

5、bool StartWith(string value)判断字符串是否以子串value开始。

            string str = "今天天气好晴朗，处处好风光";
            if (str.StartsWith("今天"))
            {
                Console.WriteLine("是的");
            }
            else
            {
                Console.WriteLine("不是的");
            }
            Console.ReadKey();

6、bool EndsWith(string value)判断字符串是否以子串value结束。

            string str = "今天天气好晴朗，处处好风光";
            if (str.EndsWith("光"))
            {
                Console.WriteLine("是的");
            }
            else
            {
                Console.WriteLine("不是的");
            }
            Console.ReadKey();

7、int IndexOf(string value)取子串value第一次出现的位置。重载int IndexOf(string value，int startIndex)startIndex:搜索的起始位置

            string str = "今天天处气好晴朗，处处好风光";
            //int index = str.IndexOf("处");
            //Console.WriteLine(index);//3
            int index = str.IndexOf("处",4);
            Console.WriteLine(index);//9
            Console.ReadKey();

8、LastIndexof

            string str = "今天天处气好晴朗，处处好风光";
            int index = str.LastIndexOf("处");
            Console.WriteLine(index);//10
            Console.ReadKey();

             //lastIndexOf   Substring

            string path = @"c:\a\b\c苍\d\e苍\f\g\\fd\fd\fdf\d\vfd\苍老师苍.wav";
            int index = path.LastIndexOf("\\");//转义字符其实只有一个\
            path = path.Substring(index + 1);
            Console.WriteLine(path);
            Console.ReadKey();

9、Trim()    //去掉前面和后面空格
10、TrimEnd()//去掉后面空格
11、TrimStart()//去掉前面空格

            string str = "             hahahahahhaha           ";
            //str = str.Trim();
            //str = str.TrimEnd();
            str = str.TrimStart();
            Console.Write(str);
            Console.ReadKey();

12、string.isNullOrEmpty() 静态成员函数       判断字符串是否是Null或者是空

            //string str = "";//是的
            //string str = null;//是的
            string str = "sfafafgsadga";
            if (string.IsNullOrEmpty(str))
            {
                Console.WriteLine("是的");
            }
            else
            {
                Console.WriteLine("不是");
            }
            Console.ReadKey();

13、string.Join("|",str)5个重载函数，静态成员函数，为数组成员之间加上一个字符，以字符串的方式返回

            string[] names = { "张三", "李四", "王五", "赵六", "田七" };
            //string strNew = string.Join("|", names);
            string strNew = string.Join("|", "张三", "李四", "王五", "赵六", "田七");
            Console.WriteLine(strNew);
            Console.ReadKey();

//字符串提供的各种方法总结

1、Length：获得当前字符串中字符的个数

2、ToUpper():将字符转换成大写形式

3、ToLower():将字符串转换成小写形式

4、Equals(lessonTwo,StringComparison.OrdinalIgnorCase):比较两个字符串忽略大小写

5、Split()：分割字符串，返回字符串类型的数组

6、Substring()：截取字符串，在截取的时候要包含截取的那个位置

7、IndexOf():判断某个字符串在字符串中第一次出现的位置，如果没有返回-1

8、LastIndexOf():判断某个字符串在字符串中最后一次出现的位置，如果没有同样返回-1

9、StartWith():判断以.........开始

10、EndsWith():判断以.................结束

11、Replace():将字符串中某个字符串替换成一个新的字符串

12、Contains():判断某个字符串是否包含指定的字符串

13、Trim():去掉字符串中前后的空格

14、TrimEnd():去掉字符串中结尾的空格

15、TrimStart():去掉字符串中前面的空格

16、string.IsNullOrEmpty():判断一个字符串是否为空或者为null

17、string.Join():将数组按照指定的字符串连接，返回一个字符串

 

 

 

类：

父类：

class Person1
    {
        private string _name;
        private int _age;
        private char _gender;
        public string Name
        {
            set { this._name = value; }
            get { return this._name; }
        }
        public int Age
        {
            set { this._age = value; }
            get { return this._age; }
        }
        public char Gender
        {
            set { this._gender = value; }
            get { return this._gender; }
        }
        public void CHLSS()
        {
            Console.WriteLine("吃喝拉撒睡");
        }
        public Person1(string name, int age, char gender)
        {
            this.Name = name;
            this.Age = age;
            this.Gender = gender;
        }
        public void Per()
        {
            Console.WriteLine("我是人类");
        }
    }

子类1：

    class Student : Person1
    {
        public Student(string name, int age, char gender, int id) : base(name, age, gender)
        {
            this.Id = id;
        }
        private int _id;

        public int Id { get => _id; set => _id = value; }

        public void Study()
        {
            Console.WriteLine("学生会学习");
        }
        public new void Per()
        {
            Console.WriteLine("我是学生");
        }
    }

子类2：

    class Teacher : Person1
    {
        private double _salary;
        public double Salary
        {
            set { this._salary = value; }
            get { return this._salary; }
        }
        public void Teach()
        {
            Console.WriteLine("老师会讲课");
        }
        public Teacher(string name, int age, char gender, double salary) : base(name, age, gender)
        {
            this.Salary = salary;
        }
        public new void Per()
        {
            Console.WriteLine("我是老师");

        }
    }

子类3：

    class Driver : Person1
    {
        private int _dirveTime;
        public int DriveTime
        {
            set { this._dirveTime = value; }
            get { return this._dirveTime; }
        }
        public void Drive()
        {
            Console.WriteLine("司机会开车");
        }
        public Driver(string name, int age, char gender, int driverTime) : base(name, age, gender)
        {
            this.DriveTime = driverTime;
        }
    }

主函数：

            Teacher tea = new Teacher("张三", 28, '男', 10000);
            tea.Teach();
            Console.ReadKey();
            Student su = new Student("王五", 18, '男', 20);
            su.Study();
            Console.WriteLine(su.Id);
            Console.ReadKey();

            //new 关键字  声明重新定义覆盖父类的函数
            /*
            new关键字：
            1、创建对象
            2、隐藏从父类那里继承过来的同名函数
            隐藏的后果就是子类调用不到父类的成员

             */
            Student sa = new Student("苏三", 18, '女', 11);
            sa.Per();
            Console.ReadKey();

 

 

里氏转换

            //  1、子类可以赋值给父类:如果有一个地方需要一个父类作为参数，我们可以给一个子类代替
            Person1 p = new Student("李四",21,'男',12);
            p.Per();//我是人类
            //  2、如果父类中装的是子类对象，那么可以将这个父类强转为子类对象
            Student ss = (Student)p;
            ss.Per();//我是学生
            Console.ReadKey();

  类型转换判断：

  is:表示类型转换，如果能够转换成功，则返回一个true,否则返回一个false

            if (p is Student)//p is Teacher      转换失败
            {
                Student dd = (Student)p;
            }
            else
            {
                Console.WriteLine("转换失败");
            }
            Console.ReadKey();

  as:表示类型转换，如果能够转换则返回对应的对象，否则返回一个null

            /* 
            Teacher tt = p as Teacher;
            tt.Per();//tt为null
             */
            Student tt = p as Student;
            tt.Per();
            Console.ReadKey();

ArrayList集合

            //创建一个集合对象
            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);
            for (int i = 0; i < list.Count; i++)//list没有length属性，但是有Count和length效果一样
            {
                //Console.WriteLine(list[i]);
                if (list[i] is Person)
                {
                    ((Person)list[i]).Per();
                }
                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.ReadKey();


            //将一个对象输出到控制台   默认情况下打印的就是这个对象所在的类的命名空间
            int[] nums = { 1, 2, 3, 4, 5 };
            Console.WriteLine(nums.ToString());//System.Int32[]
            Console.ReadKey();

ArrayList 各种方法总结：

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);//判断是否包含某个指定的元素
            if (!list.Contains("颜世伟"))
            {
                list.Add("颜世伟");
            }
            else
            {
                Console.WriteLine("已经有这个屌丝啦");
            }

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

//ArrayList    集合长度问题

            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);//每次集合中实际包含的元素个数（count）超过了可以包含的元素的个数（capacity）的时候，集合就会向内存中申请多开辟一倍的空间，来保证集合的长度一直够用
            //count 表示这个集合中实际包含的元素的个数
            //capcity 表示这个集合中可以包含的元素的个数
            Console.WriteLine(list.Count);
            Console.WriteLine(list.Capacity);
            Console.ReadKey();

         

 

   Hastable 键值对集合

            //创建一个键值对集合对象
            Hashtable ht = new Hashtable();
            //添加数据有两种方式
            ht.Add(1, "张三");
            ht.Add(2, true);
            ht.Add(3, '男');
            ht.Add(false, "错误的");
            ht[6] = "新来的";
            ht[1] = "把张三干掉";//第二种添加方式,还可以对已有的元素重新赋值
            //ht.Add(1, "哈哈哈");//键值对中键必须是唯一的，.Add()方法不会覆盖原来键值，会报错

 //判断添加

            if (!ht.ContainsKey("abc"))//还有ht.Contains和ht.ContainsValue
            {
                ht.Add("abc", "cba");
            }
            else
            {
                Console.WriteLine("已经包含这个键！！！");
            }

 

            //ht.Clear();//移除集合中所有的元素
            ht.Remove(3);//根据键移除元素
            
            //foreach循环遍历
            foreach (var item in ht.Keys)//ht.Keys代表集合中键的集合
            {
                Console.WriteLine("键是========{0}=========值是{1}", item, ht[item]);
            }

            //在键值对集合中  是根据键去找值的
            Console.WriteLine(ht[1]);
            Console.WriteLine(ht[2]);
            Console.WriteLine(ht[3]);
            Console.WriteLine(ht[false]);
            Console.WriteLine("======================");
            for (int i = 0; i < ht.Count; i++)
            {
                Console.WriteLine(ht[i]);
            }
            Console.ReadKey();

路径  Path静态类 专业操作路径

            string str = @"E:\Visual Studio\Study\FirstDay\two\test.wav";
            //获得文件名
            Console.WriteLine(Path.GetFileName(str));
            //获得文件名但是不包括扩展名
            Console.WriteLine(Path.GetFileNameWithoutExtension(str));
            //获得文件的扩展名
            Console.WriteLine(Path.GetExtension(str));
            //获得文件所在的文件夹的名称
            Console.WriteLine(Path.GetDirectoryName(str));//Directory  目录
            //获得文件所在的全路径
            Console.WriteLine(Path.GetFullPath(str));
            //连接两个字符串作为路径
            Console.WriteLine(Path.Combine(@"C:\a\", "b.text"));//C:\a\b.text
            
            Console.ReadKey();

File文件类   静态类

            //创建一个文件
            File.Create(@"E:\Visual Studio\Study\FirstDay\two\test.wav");
            Console.WriteLine("创建成功");
            Console.ReadKey();

            //删除一个文件
            File.Delete(@"E:\Visual Studio\Study\FirstDay\two\test.wav");
            Console.WriteLine("删除成功");
            Console.ReadKey();

            //复制一个文件
            File.Copy(@"E:\Visual Studio\Study\FirstDay\two\test.wav", @"E:\Visual Studio\Study\FirstDay\two\copy.wav");
            Console.WriteLine("复制成功");
            Console.ReadKey();

 

           

            //移动文件 Move
            File.Move(@"E:\Visual Studio\Study\FirstDay\two\test.txt", @"E:\Visual Studio\Study\FirstDay\one\test.txt");
            Console.WriteLine("移动成功");
            Console.ReadKey();

            //读文件1
            byte[] buffer = File.ReadAllBytes(@"E:\Visual Studio\Study\FirstDay\two\test.txt");
            //将字节数组中的每一个元素都要按照我们指定的编码格式解码成字符串
            //UTF-8 GB2312 GBK ASCII Unicode

            //不同解码方式
            string s = Encoding.Default.GetString(buffer);
            string s = Encoding.GetEncoding("GB2312").GetString(buffer);
            string s = Encoding.GetEncoding("GBK").GetString(buffer);

            Console.WriteLine(s);
            Console.ReadKey();

            //读文件2
            string[] contents = File.ReadAllLines(@"E:\Visual Studio\Study\FirstDay\two\test.txt", Encoding.Default);
            foreach (string item in contents)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

            //读文件3
            string str = File.ReadAllText(@"E:\Visual Studio\Study\FirstDay\two\test.txt", Encoding.Default);
            Console.WriteLine(str);
            Console.ReadKey();

            //写文件1    没有这个文件会给你创建一个  有的话  会给你覆盖掉
            string str = "今天天气好晴朗处处好风光";
            //需要将字符串转换成字节数组
            byte[] buffer = Encoding.Default.GetBytes(str);
            File.WriteAllBytes(@"E:\Visual Studio\Study\FirstDay\two\test.txt", buffer);
            Console.WriteLine("写入成功");
            Console.ReadKey();

            //写文件2      没有这个文件会给你创建一个  有的话  会给你覆盖掉
            File.WriteAllLines(@"E:\Visual Studio\Study\FirstDay\two\test.txt", new string[] { "aoe", "iuǖ" });
            Console.WriteLine("OK");
            Console.ReadKey();

            //写文件3 没有这个文件会给你创建一个  有的话 会给你覆盖掉
            File.WriteAllText(@"E:\Visual Studio\Study\FirstDay\two\test.txt", "张三李四王五赵六");
            Console.WriteLine("OK");
            Console.ReadKey();

            //写文件4 添加数据不覆盖原来数据  3个
             File.AppendAllLines(,)
            File.AppendText()   不会 只有一个路径参数，添加的内容不知道写在哪里
            File.AppendAllText(@"E:\Visual Studio\Study\FirstDay\two\test.txt", "看我有没有把你覆盖掉");
            Console.WriteLine("OK");
            Console.ReadKey();

  泛型

            //创建泛型集合对象
            List<int> list = new List<int>();
            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<string> listStr = new List<string>();
            string[] str = listStr.ToArray();

            //数组转集合
            char[] chs = new char[] { 'c', 'b', 'a' };
            List<char> listChar = chs.ToList();
            for (int i = 0; i < listChar.Count; i++)
            {
                Console.WriteLine(listChar[i]);
            }
            
            for (int i = 0; i < list.Count; i++)
            {
                Console.WriteLine(list[i]);
            }
            Console.ReadKey();

 

.AsEnumerable() 和 .ToList() 的区别：

• .AsEnumerable()延迟执行，不会立即执行。当你调用.AsEnumerable()的时候，实际上什么都没有发生。
• .ToList()立即执行
• 当你需要操作结果的时候，用.ToList()，否则，如果仅仅是用来查询不需要进一步使用结果集，并可以延迟执行，就用.AsEnumerable()/IEnumerable /IQueryable
• .AsEnumerable()虽然延迟执行，但还是访问数据库，而.ToList()直接取得结果放在内存中。比如我们需要显示两个部门的员工时，部门可以先取出放置在List中，然后再依次取出各个部门的员工，这时访问的效率要高一些，因为不需要每次都访问数据库去取出部门。
• IQueryable实现了IEnumberable接口。但IEnumerable<T> 换成IQueryable<T>后速度提高很多。原因：
• IQueryable接口与IEnumberable接口的区别：  IEnumerable<T> 泛型类在调用自己的SKip 和 Take 等扩展方法之前数据就已经加载在本地内存里了，而IQueryable<T> 是将Skip ,take 这些方法表达式翻译成T-SQL语句之后再向SQL服务器发送命令，它并不是把所有数据都加载到内存里来才进行条件过滤。
• IEnumerable跑的是Linq to Object，强制从数据库中读取所有数据到内存先。