标签：asc list 相互 password htable 长度 enum 本质 逻辑运算
.net fromwork是基于.net平台的开发工具
B/S：浏览器服务器交互模式，客户机只要求装有浏览器
C/S：客户机服务器交互模式，客户机需要安装专用的客户端软件。
\n:表示换行
\t:表示一个tab键的空格
\”:表示一个英文半角的双引号
\b:表示一个退格键：backspace，放在字符串的两边没有效果
\r\n:Windows操作系统不认识\n，只认识这个换行符
@符号，1.取消\在字符串的转义作用，使其单纯的表示为\2.将字符串按照原格式输出console.writeline(@“天赋
奇真好”);
=号两边的数据类型必须一样，如果不一致，满足下列条件会发生自动类型转换，或者称之为隐式类型转换1、两种类型兼容2、目标类型大于原类型
隐式类型转换因为比较舒服，为由小到大转换；显示类型转换因为不舒服，为由大转小。
显示类型转换：double a=3.03；int b=（int）a；这就是显示类型转换
如果两个转换的类型不兼容，我们就用convert进行强制转换
Console.writeline({0:0.00},num);\\表示保留num的小数点后两位
命名方法：
Camel：要求变量名中单词的首字母小写，其余每个单词的首字母都要大写，多用于给变量命名
Pascal：要求标识符中的每个单词的首字母都要大写，其余字母小写，多用于给类或者方法命名
++，不在表示中不管在前还是在后直接+1；如果在表达式中前加加时，先进行加1后进行表达式运算，如果是后++则先运算表达式，后进行+1；
如果一个表达式中既有一元运算符，同时有二元运算符，先运算一元运算符。
逻辑运算符：&&逻辑与 ||逻辑或 ！逻辑非 逻辑与的优先级大于逻辑或的优先级
bool b= (year%400==0) || (year%4==0 && year%100!=0); 其中的括号是可以不加的，因为逻辑与的优先级比较高
关系运算符：< > <= >= ==
复合赋值运算符：
+= -= *= /= %=
异常捕获：在程序中经常会出现各种各样的异常，在你的代码中应该经常的使用try—catch来进行异常捕获
语法：
try
{
可能出现异常的代码；
}
Catch
{
出现异常后要执行的代码；
}
变量的作用域：变量的作用域一般从声明它的那个括号开始到那个括号所对应的结束的括号结束，在这个范围内，我们可以访问并使用变量。超出这个范围就无法访问了。
Try和catch之间不能有代码
break只能跳出当前循环，并不能跳出所有循环；一般不单独使用而是跟if判断一起使用，表示当满足某些条件是就不在循环了；
continue能跳出所有循环
程序调试：
枚举
Public enum sense
{
春，夏，秋，冬
}
sense s=sense.冬；
我们可以将一个枚举类型的变量跟int类型和string类型互相转换
枚举类型默认是跟int类型相互兼容的，所以可以通过强制转换的语法互相转换。
当转换一个枚举中没有的值得时候，不会抛异常，而是直接将数字显示出来。
枚举同样也可以跟string类型互相转换，如果将枚举类型转换成string类型，则直接调用ToString（）.
如果将字符串转换成枚举类型则需要下面这样一行代码：
（要转换的枚举类型）Enum.Parse（typeof（要转换的枚举类型），”要转换的字符串”）；
如果转换的字符串是数字，则就算枚举中没有，也不会抛异常。
如果转换的字符串是文本，如果枚举中没有，则会抛异常。
所有的类型都能转换成string类型，调用ToString（）
结构：帮助我们一次性声明多个不同类型的变量
语法：public struct 结构名
{成员；}
变量在程序运行期间只能存储一个值，字段可以存储多个值
字段命名前面规范要加_下划线
冒泡排序：将一个数组中的元素按照从大到小或者从小到大进行排序。
Array.Sort(nums); 对数组做一个升序的排列
Array.Reverse（nums）；对数组进行反转
Return有两个作用1.返回值2.立即退出本次方法
Out参数：如果你在一个方法中，返回多个相同类型的值得时候，可以考虑返回一个数组。但是，如果返回多个不同类型的值得时候，返回数组就不行了，那么这个时候，我们可以考虑使用out参数。
Out参数就侧重于在一个方法中可以返回多个不同类型的值。
Ref参数
能够将一个变量带入一个方法中进行改变，改变完成后，再将改变后的值带出方法。
Out参数要求在方法内必须为其赋值，ref参数要求在方法外必须为其赋值。
Params可变参数
将实参列表中跟可变参数数组类型一致的元素当做数组的元素去处理。它必须是形参列表中的最后一个参数。
方法的重载：
方法的重载指得就是方法的名称相同，参数不同。
参数分为两种：1.如果参数的个数相同，参数类型就不能相同。2.如果参数的类型相同，参数的个数就不能相同。方法的重载跟返回值没有关系。
方法的递归：
方法自己调用自己：找出一个文件夹中所有的文件
静态字段的作用域在整个类中。
如下定义个静态字段 public’static int i=0;
属性的作用就是保护字段，对字段的赋值和取值进行限定。
属性的本质就是两个方法，一个叫get（）一个叫set（）
get{return __Old;}
set{__Old = value;}
Field 字段Method方法Property属性
字段就是女人，属性才是男人，字段是存储数据的地方。所以需要保护起来，通过属性进行访问。字段在类中必须是私有的。只能通过中间商属性进行使用。
既有set也有get我们称之为可读可写属性
只有get没有set我们称之为只读属性
只有set没有get我们称之为只写属性。
当我们创建好一个类的对象后，需要给这个对象的每个属性去赋值。我们管这个过程称之为对象的初始化。
静态类与非静态类区别
在非静态类中既可以有静态成员也可以有非静态成员
在调用实例成员（非静态成员）的时候，需要使用对象名.实例成员
在调用静态成员的时候，需要使用类名.静态成员名，不管属性字段还是方法
总结：静态成员必须使用类名去调用，而实例成员使用对象名去调用
静态函数中，只能访问静态成员，不允许访问实例成员
实例函数中，既可以使用静态成员，也可以使用实例成员。
静态类中只允许有静态成员，不允许有实例成员，静态类不允许被实例化
使用：
如果你想要你的类当做一个“”工具类“”去使用，这个时候可以考虑将类写成静态类，因为在使用的时候不需要创建类的对象实例化他，只需要类名去点
静态类在整个项目中资源共享。因为类是不占内存的，对象占内存，实例类的实例化对象需要占内存，
释放资源：GC Garbage Collection垃圾回收器，只有在程序全部结束之后，静态类才会释放资源
构造函数：
构造函数写在定义字段的下面
作用：帮助我们初始化，为实例化的对象（给对象的每个属性依次赋值）
构造函数是一个特殊的方法：
1构造函数没有返回值，连void也不能写
2构造函数的名称必须跟类名一样。
创建对象的时候会运行构造函数
构造函数是可以重载的，类中会有一个默认的无参数的构造函数，当你写了一个新的构造函数之后，默认的构造函数会被取而代之。
导入命名空间时可以：alt+shift+f10
值类型：存储在内存的栈中。
引用类型：存储在堆中 string ，剩余的全是值类型。自定义类，数组
区别：值类型和引用类型在内存上存储的地方不一样。在传递值类型和传递引用类型的时候，传递的方式不一样。值类型我们称之为值传递，引用类型我们称之为引用传递。
引用类型是将其数据放入堆中，将其堆中所对应的地址放入栈中。
我们可以将字符串看做char类型的只读数组
ToCharArray（）；将字符串转换成char数组
new string（char[] chs）：能够将char数组转换为字符串
字符串提供的各种方法：
Length：获得当前字符串中字符的个数
ToUpper（）：将字符串转换成大写形式
ToLower（）：将字符串转换成小写格式
Equals（str1，StringComparison.ordinalIgnoreCase）：比较两个字符串可以忽略大小写
Split（）：分割字符串，返回字符串类型的数组
string[] data = str.Split(new char []{‘ ‘},StringSplitOptions.RemoveEmptyEntries);
Substring（）：截取字符串，在截取的时候包含要截取的那个位置
str= str.Substring(1,2);
IndexOf（）：判断某个字符串在字符串中第一次出现的位置，如果没有返回-1
LastIndexOf（）：判断某个自渡船在字符串中最后一个出现的位置如果没有返回-1
Startswith（）：判断以…开始
Endswith（）：判断以…结束
Replace（）：将字符串中某个字符串替换成一个新的字符串
Contains（）：判断某个字符串是否包含指定的字符串
if (str.Contains("开发"))
//{
// str = str.Replace("开发","**");
//}
Trim（）：去掉字符串中前后的空格
TrimEnd（）：去掉字符串中结尾的空格
TrimStart（）：去掉字符串中前面的空格
String.IsNullorEmpty（）：判断一个字符串是否为空或为null
String.Join（）：将数组按照指定的字符串链接，返回一个字符串。
继承
我们可能会在一个类中，写一些重复的成员，我们可以将这些重复的成员，单独封装到一歌类中，作为这些类的父类。
子类又成为派生类，父类又成为基类
子类继承了父类，那么子类从父类那里继承过来了什么？
首先，子类继承了父类的属性和方法，但是子类并没有继承父类的私有字段。
子类有没有继承父类的构造函数？
子类并没有继承父类的构造函数，但是，子类会默认的调用父类无参数的构造函数，创建父类对象，让子类可以使用父类中成员。所以，如果在父类中重新写了一个有参数的构造函数之后，那个无参数的就被干掉了，子类就调不到了，多以子类会报错
解决方法：1.父类中重新写一个无参数的构造函数
2.在子类中显示的调用父类的构造函数，使用关键字base（）
public Programmer(string name, int age, char gender, string grammer)
: base(name, age, gender)
继承的特性
查看类图
里氏转换：
Person p = new Student();
//as转换
Student s = p as Student;
s.studentSayHello();
Console.ReadKey();
//is转换
if (p is Student)
{
((Student)p).studentSayHello();
}
else
{
Console.WriteLine("转换失败。");
}
Console.ReadKey();
}
}
public class Person
{
public void personSayHello()
{
Console.WriteLine("父类sayHello。");
}
}
public class Student : Person
{
public void studentSayHello()
{
Console.WriteLine("子类SayHello。");
}
}
Protected:受保护的，可以在当前类的内部以及该类的子类中访问。
集合ArrayList
ArrayList list = new ArrayList();
//添加单个元素用Add
list.Add(true);
list.Add(1);
list.Add("张三");
//添加集合元素用AddRange
list.AddRange(new int []{1,2,3,4,5,6,7});
list.AddRange(list);
//写谁就删谁
list.Remove(1);
//根据索引删除
list.RemoveAt(0);
//根据索引删除一个范围内的元素
list.RemoveRange(5,8);
//元素反转
list.Reverse();
//指定位置插入
list.Insert(1,"插入");
//在指定的位置插入一个集合
list.InsertRange(1,new string[]{"Khk","df"});
//判断是否包含某个指定的元素，返回一个布尔类型的值
bool b = list.Contains(1);
for (int i = 0; i < list.Count; i++)
//count表示实际包含的元素个数
{
Console.WriteLine(list[i]);
}
Console.ReadKey();
ArrayList集合的长度问题：
每次集合中实际包含的元素个数（count）超过了可以包含的元素的个数（capcity）的时候，集合就会像内存中申请多开辟一倍的空间，来保证集合的长度一直够用。
Hashtable 键值对集合
在键值对集合当中，我们是根据键去找值得。键必须是唯一的，值可以随意重复。
Hashtable ht = new Hashtable();
ht.Add(1,56);
ht.Add(false,88);
ht[2] = "Nidaye";//这也是一种添加数据的方式
ht.Remove(1);//根据键进行移除
ht.Clear();//清空键
ht[1] = "把56干掉";//首先会判断该键是否含有，如果有的话进行值的替换，没有直接添加
if (!ht.ContainsKey("Nidaye"))//判断ht是否包含该键
{
ht.Add("sfd", "dfs");
}
else
{
Console.WriteLine("已经包含这个键");
}
//通过键去找值ht.Add(键，值);
Console.WriteLine(ht[false]);
foreach (var item in ht.Keys)
{
Console.WriteLine(ht[item]);
}
Console.ReadKey();
使用foreach’循环进行遍历
初始化数组的两个方法：
int [ ]num=new int[100];定义一个包含100的元素的数组
int[ ]num={1,2,3,4,5,6,7,8,9};定义一个包含1到9元素的数组
泛型集合List
List<int> list = new List<int>();
list.AddRange(new int []{1,2,3,4,5,6});
//泛型集合可以转换为数组
int[] num = list.ToArray();
//将数组转换为集合
List<int>listtow= num.ToList();
键值对操作Dictionary
Dictionary<int, string> dic = new Dictionary<int, string>();
dic.Add(1,"旧的");
dic.Add(0, "zhsgfgsdf");
dic.Add(2, "zhsdfgsdfgsdf");
dic.Add(3, "zhsddgsdgf");
dic.Add(4, "zhsdfdfgdfds");
dic[1] = "新来了";
foreach (KeyValuePair<int,string> item in dic)
{
Console.WriteLine("{0}======={1}",item.Key,item.Value);
}
foreach (var item in dic.Keys)
{
Console.WriteLine("{0}========{1}",item,dic[item]);
}
Console.ReadKey();
对文件的操作
string str=@"D:\asp.net\亲情奉献-全套精品.Net基础班视频教程-video\亲情奉献全套精品.Net基础视频教程之9-面向对象继承\（第十一天）\video.avi";
//获得文件名
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:\z\","c.txt"));
Console.ReadKey();
通过file对文件进行新建删除拷贝
//创建一个文件
//File.Create(@"C:\Users\Administrator.USER-20161026IR\Desktop\你好.txt");
//Console.WriteLine("创建成功。");
//Console.ReadKey();
//删除一个文件
File.Delete(@"C:\Users\Administrator.USER-20161026IR\Desktop\你好.txt");
Console.WriteLine("删除成功。");
Console.ReadKey();
//File.Copy(@"C:\Users\Administrator.USER-20161026IR\Desktop\你好.txt", @"C:\Users\Administrator.USER-20161026IR\Desktop\你不好.txt");
//Console.WriteLine("拷贝成功。");
//Console.ReadKey();
编码：将字符串以怎样的形式保存为二进制
乱码：保存这个文件所采用的编码，跟打开这个文件的编码格式不一致。
字节数组
byte[] buffer = File.ReadAllBytes(@"C:\Users\Administrator.USER-20161026IR\Desktop\FlappyBird.txt");
//将字节数组中的每一个元素都按照我们指定的编码格式解码成字符串
string s= Encoding.GetEncoding("GB2312").GetString(buffer);
Console.WriteLine(s);
Console.ReadKey();
//没有这个文件的话，会给你创建一个 有的话给你覆盖掉
string str="贷款计划疯狂代理费家里电缆附件了";
//需要将字符串转换成字节数组
byte[]buff= Encoding.Default .GetBytes(str);
File.WriteAllBytes(@"C:\Users\Administrator.USER-20161026IR\Desktop\考试课.txt",buff);
Console.WriteLine("写入成功。");
Console.ReadKey();
绝对路径：通过给定的这个路径直接能在我的电脑中找到该文件
相对路径：文件对应应用程序的路径
我们在开发中尽量使用相对路径
装箱：将值类型转换为引用类型
拆箱：将引用类型转换为值类型
看两种类型是够发生了装箱或者拆箱。看这两种类型是否有继承关系。有的话才有可能发生
int n = 10;
object s = n;//装箱
int nn=(int )s;//拆箱
文件流的操作可以进行大文件的分割读取
FileStream str = new FileStream(@"C:\Users\Administrator.USER-20161026IR\Desktop\FlappyBird.txt", FileMode.OpenOrCreate, FileAccess.Read);
byte[] buffer=new byte[1024*1024*5];
int r= str.Read(buffer,0,buffer.Length);
//将字节数组中每一个元素按照指定的编码格式解码成字符串
string s= Encoding.Default.GetString(buffer,0,r);
//关闭流
str.Close();
//释放流空间
str.Dispose();
Console.WriteLine(s);
Console.ReadKey();
将创建文件流对象的过程写在using中，会自动帮助我们释放流所占用的空间
using (FileStream fsWrite = new FileStream(@"C:\Users\Administrator.USER-20161026IR\Desktop\FlappyBird.txt", FileMode.OpenOrCreate, FileAccess.Write))
{
string str = "看我是不是写的";
byte[] buffer = Encoding.UTF8.GetBytes(str);
fsWrite.Write(buffer,0,buffer.Length);
}
Console.WriteLine("成功");
Console.ReadKey();
通过流对多媒体文件进行复制
string source = @"C:\Users\Administrator.USER-20161026IR\Desktop\[cstx][anejiru][01][GB][jp_chn].rmvb";
string target = @"C:\Users\Administrator.USER-20161026IR\Desktop\汁姐.rmvb";
CopyFile(source,target);
Console.WriteLine("ok");
Console.ReadKey();
}
public static void CopyFile(string source, string target)
{
//首先传过去一个地址参数，而后是打开方式，然后是判断是读数据还是写数据
using (FileStream fsRead = new FileStream(source, FileMode.Open, FileAccess.Read))
{
using (FileStream fsWrite = new FileStream(target, FileMode.OpenOrCreate, FileAccess.Write))
{
byte[]buffer=new byte[1024*1024*5];
while (true)
{
int r = fsRead.Read(buffer,0,buffer.Length);
if (r == 0)
{
break;
}
fsWrite.Write(buffer,0,r);
}
}
}
}
StreamReader是用来对文本操作的方法
using (StreamReader sr = new StreamReader(@"C:\Users\Administrator.USER-20161026IR\Desktop\[cstx][anejiru][01][GB][jp_chn].rmvb"))
{
while (!sr.EndOfStream)
{
Console.WriteLine(sr.ReadLine());
}
}
多态：让一个对象能够表现出多种状态
实现多态的方法：1.虚方法，父类使用关键字virtual，这个函数可以被子类重写，子类使用关键字override 2.抽象类 当父类中的方法不知道如何去实现的时候，可以将父类写成抽象类，方法写成抽象方法abstract关键字 抽象成员必须标记为abstract并且不能有任何实现3.接口
抽象类与虚方法：
如果父类中的方法有默认的实现，并且父类需要被实例化，这是可以考虑将父类定义成一个普通类，用虚方法实现多态
如果父类中的方法没有默认实现，父类也不需要被实例化，则可以将该类定义为抽象类。
#region
////狗会叫，猫会叫
////通过抽象类进行多态
//Animal a = new Dog();
//a.Bark();
//Animal b = new Cat();
//b.Bark();
//Console.ReadKey();
#endregion
#region
//通过虚方法实现多态
//Chineses ch = new Chineses("李雷");
//Chineses ch2 = new Chineses("韩梅梅");
//Amermain am = new Amermain("乔丹");
//Amermain am2 = new Amermain("罗伯茨");
//Person[] s = { ch,ch2,am,am2};
//for (int i = 0; i <s.Length; i++)
//{
// s[i].SayHello();
//}
//Console.ReadKey();
#endregion
//使用多态求矩形的面积和周长以及圆形的面积和周长
Shape shape = new Circle(5);//圆
Shape shape2 = new Square(5,6);//矩形
double area = shape.GetArea();
double perimeter = shape.GetPerimeter();
Console.WriteLine("面积为{0}。周长为{1}",area,perimeter);
Console.ReadKey();
}
}
//public abstract class Animal
//{
// public abstract void Bark();
//}
//public class Dog : Animal
//{
// public override void Bark()
// {
// Console.WriteLine("狗狗旺旺叫。");
// }
//}
//public class Cat : Animal
//{
// public override void Bark()
// {
// Console.WriteLine("猫咪叫");
// }
//}
#region
//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("我是{0}，我是人类",this.Name);
// }
//}
//class Chineses:Person
//{
// private string _name;
// public string Name
// {
// get { return _name; }
// set { _name = value; }
// }
// public Chineses(string name):base(name)
// {
// this.Name = name;
// }
// public override void SayHello()
// {
// Console.WriteLine("我是{0}，我是中国人",this.Name);
// }
//}
//class Amermain:Person
//{
// private string _name;
// public string Name
// {
// get { return _name; }
// set { _name = value; }
// }
// public Amermain(string name):base(name)
// {
// this.Name = name;
// }
// public override void SayHello()
// {
// Console.WriteLine("我是{0}，我是美国人",this.Name);
// }
//}
#endregion
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;
}
C#中的访问权限：
Public：公开的公共的
Private：私有的，只能在当前类的内部访问
Protected：受保护的，只能在当前类的内部以及该类的子类中访问
Internal：只能在当前 项目中访问，在同一项目中，internal和public的权限一样
Protected internal:protected+internal
值类型在复制的时候，传递的是这个值的本身。
引用类型在复制的时候，传递的是这个对象的引用。
序列化：就是将对象转换为二进制
反序列化：就是将二进制转换为对象
作用：传输数据
Partial部分类 可以写多个类名相同
Sealed密封类：不能够被其他类继承，但是可以继承其他类
接口：public interface 类名
接口中的成员不允许添加访问修饰符，默认就是public
而对于类中默认为private
接口中不允许写具有方法体的函数
接口是一种规范
只要一个类继承了一个接口，这个类就必须实现接口中的所有成员
为了多态，接口不能被实例化，也就是说接口不能new，不能创建对象
接口中的成员不能加访问修饰符，接口中的成员访问修饰符为public，不能修改（默认为pubic）接口中的成员不能有任何实现，光说不做，只是定义了一组未实现的成员
接口中只能有方法，索引器，事件，不能有字段和构造函数
接口与接口之间可以继承，并且可以多个继承
接口并不能去继承一个类，而类可以继承接口
实现接口的子类必须实现该接口的全部成员
一个类可以同时继承一个类并实现多个接口，如果一个类同时继承了父类A，并实现了接口B，那么语法上A必须写在B的前面
桌面应用程序
Name：在后台要获得前台的控件对象，需要使用name属性
注册事件：双击控件注册的都是控件默认被选中的那个事件
触发事件：
wordWrap：指示文本框是否换行
PasswordChar：让文本框显示一个单一的字符
ScollBars：是否显示滚动条
事件：TextChanged当文本框中的内容发生改变的时候触发这个时间
窗体中播放音乐：
SoundPlayer sp=new SoundPlayer（）；
Sp.SoundPlayer=@“歌曲的地址”;只能接受wav格式的歌曲
Sp.play();
单选和多选
Checked：指示这个控件是否处于选中状态
默认情况下，在一个窗体中，所有的单选按钮只允许一个被选中，可以使用groupbox进行分组。
MDI窗体的设计
方法LayoutMdi用于在父窗体中排列子窗体
横向排列：LayoutMdi（MdiLayout.TileHorizontal）；
纵向排列：LayoutMdi（MdiLayout.TileVertical）；
string[] path = Directory.GetFiles(@"C:\Users\Administrator.USER-20161026IR\Desktop");
//path数组中有该文件夹下每个文件的路径
Directory类：操作文件夹
//创建文件夹
Directory.CreateDirectory(@"C:\Users\Administrator.USER-20161026IR\Desktop\a");
Console.WriteLine("创建成功");
Console.ReadKey();
//删除文件夹，如果不加true，在该文件夹内部不为空的时候无法删除
Directory.Delete(@"C:\Users\Administrator.USER-20161026IR\Desktop\a",true);
Console.WriteLine("删除成功");
Console.ReadKey();
//剪切文件夹、
Directory.Move(@"文件夹的地址",@"文件夹被剪切的地址");
//获得指定指定目录下所有文件夹的全路径。后面的*.jgp表示只选择jpg文件的地址
string[] path = Directory.GetDirectories(@"文件夹的地址",*.jpg);
for (int i = 0; i < path.Length; i++)
{
Console.WriteLine(path[i]);
}
Console.WriteLine("OK");
Console.ReadKey();
//判断指定的文件夹是否存在
if (Directory.Exists(@"文件夹的地址"))
{
for (int i = 0; i < 100; i++)
{
Directory.CreateDirectory(@"文件夹的地址\"+i);
}
}
Console.WriteLine("OK");
Console.ReadKey();
Directory：操作文件夹
CreateDirectory：创建文件夹
Delete：删除文件夹
Move：剪切文件夹
Exist：判断是否存在
GetFiles：获得指定的目录下所有文件的全路径
GetDirectory：获得指定目录下所有文件夹的全路径
对对话框的操作
保存对话框
SaveFileDialog sfd = new SaveFileDialog();
sfd.Title = "请选择要保存的路径";
sfd.InitialDirectory = @"C:\Users\Administrator.USER-20161026IR\Desktop";
sfd.Filter = "文件文本|*.txt";
sfd.ShowDialog();
string path = sfd.FileName;
if (path == "")
{
return;
}
using (FileStream fsWrite = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write))
{
byte[] buffer = Encoding.Default.GetBytes(textBox1.Text);
fsWrite.Write(buffer,0,buffer.Length);
}
打开对话框
//点击弹出对话框
OpenFileDialog ofd = new OpenFileDialog();
//设置对话框的标题
ofd.Title="请选择你要打开的文本文件";
//设置对话框可以多选
ofd.Multiselect = true;
//设置对话框的初始目录
ofd.InitialDirectory = @"C:\Users\Administrator.USER-20161026IR\Desktop";
//设置对话框的文件类型
ofd.Filter="文本文件|*.txt|所有文件|*.*";
//展示对话框
ofd.ShowDialog();
string path = ofd.FileName;
if (path == "")
{
return;
}
using (FileStream fsRead = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Read))
{
byte[]buffer=new byte[1024*1024*5];
int r = fsRead.Read(buffer,0,buffer.Length);
textBox1.Text = Encoding.Default.GetString(buffer,0,r);
}
为此打开对话框为OpenFileDialog类，保存对话框为:SaveFileDialog类,对话框字体为：FontDialog类，颜色对话框：ColorDialog类
前台线程和后台线程
前台线程：只有所有的前台线程都能关闭才能完成程序关闭
后台线程：只要所有的前台线程结束，后台线程自动结束
在.net下是不允许跨线程访问的
一个进程包含多个线程
如果线程执行的方法需要参数，那么要求这个参数必须是object类型
标签：asc list 相互 password htable 长度 enum 本质 逻辑运算
原文地址：http://www.cnblogs.com/nihaoshui/p/7652806.html
