Open JunYearPrisoner opened 3 years ago
JunYearPrisoner
commented
3 years ago
1.decimal表示128位数据类型，但是要加后缀m
2.折叠代码
#region
#endregion
3.让两个字符串相连接用+号
string name="张三";
Console.WriteLine("Hello World!"+name);
4.占位符，下标要从0开始
int a1=10;
int a2=10;
int a3=30;
Console.WriteLine("第一个数字是{0}，第二个数字是{1}，第三个数字是{2}",a1,a2,a3);
5.从控制台输入
string name=Console.ReadeLine();
6.@的作用
（1)取消\在字符串中的转义作用
（2）将字符串按照原格式输出
如：
Console.WriteLine(@"晚来天欲雪
能饮一杯无");
加@不报错，不加报错
7.强制类型转换语法同c强制类型转换语法
8.保留n位小数
//以保留两位为例
double n=10/3;
Console.WriteLine("{0:0.00}",n);
9.string类型转double类型
string s="123";
double d=Convert.ToDouble(s);
//19版可用double.Parse(string);
//使用Convert转换必须要满足面值相同
//也可以用TryParse（）防止程序中止，函数返回一个布尔值，转换失败参数赋值0
10.异常代码的处理
try
{
可能出现异常的代码；
}
catch
{
出现异常后需要执行的代码；
}
执行过程：如果try中没有出现异常，catch中代码不会执行。
如果try中代表出现了异常，那怕出现异常的代码后边还有一百行，那么也不会执行
而是直接跳转到catch中执行代码11.vs的调试
1）F11，逐语句调试（单步调试），黄色表示该执行还未执行
2）F10，逐过程调试
3）断点调试，设置完断点后直接启动程序，往下执行按F11
12.随机数
1）创建能产生随机数的对象
Random r=new Random();
2）让产生随机数的对象调用方法产生随机数
int rNumber=r.Next(1,10);//限定范围,包含1不包含10
13.枚举
//中括号内的可以省略也可以不省略
//不可以在main函数里声明
[public] enum 枚举名
{
值1,
值2,
值3,
值4,
.....
}
调用代码示例：
using System;
namespace CA1
{
public enum gender
{
男,
女
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
gender gen=gender.男;
Console.ReadKey();
}
}
}
14.string转枚举
所有类型都能转成string类型
只能用
枚举名 对象 =(枚举名)Enum.Parse(typeof(枚举名),要转换的字符串);
15.结构体、类里的变量也称字段，为了和变量区分一般在前加下划线
16.数组的定义
数组类型[] 数组名=new 数组类型[数组长度];
17.c#没有全局变量，只能用静态字段来代替全局变量18.返回一个数组
using System;
namespace CA1
{
class Program
{
static void Main(string[] args)
{
int[] a = { 1, 2, 3, 4, 5, 6, 7, 8 };
int[] res = GetMaxMinSumAvg(a);
Console.WriteLine("最大值{0},最小值{1}，总和{2}，平均值{3}"
, res[0], res[1], res[2], res[3]);
Console.ReadKey();
}
/// <summary>
/// 计算一个数组的最大值最小值平均值总值
/// </summary>
/// <param name="a">数组名</param>
/// <returns></returns>
public static int[] GetMaxMinSumAvg(int[] a)
{
int[] res = new int[4];
res[0] = a[0];
res[1] = a[0];
res[2] = 0;
for(int i=0;i<a.Length;i++)
{
if (res[0] < a[i])
res[0] = a[i];
if (res[1] > a[i])
res[1] = a[i];
res[2] += a[i];
}
res[3] = res[2] / a.Length;
return res;
}
}
}19.out 、ref、params out返回多个不同类型的值
using System;
namespace CA1
{
class Program
{
static void Main(string[] args)
{
int a, b;
tst(out a,out b);
Console.WriteLine(a+b);
Console.ReadKey();
}
public static void tst(out int min,out int sum)
{
//out参数要求在方法内部必须为其赋值
min=10;
sum = 100;
}
}
}ref相当于引用指针的作用，要求再方法外必须赋值，方法内可以不赋值
main函数里：
double salary = 500;
jianjin(ref salary);
此时的salary的值为550；
public static void jianjin(ref double s)
{
s += 500;
}params可变参数，将实参列表中跟可变参数数组类型一致的元素都当作数组的元素去处理 参数数组必须是形参列表的最后一个参数
JunYearPrisoner
commented
3 years ago 20.实例化类的对象，右键，新建，类
main函数
Person per = new Person();
per._name = "sunquan";
per._age = 15;
per._gender = 'n';
per.CHLLS();
Person类
public class Person
{
public string _name;
public int _age;
public char _gender;
public void CHLLS()
{
Console.WriteLine("sadjalkjf{0}{1}{2}",this._name,this._age,this._gender);
}
}21.类不占内存，对象占内存 22.field 字段，method方法，property属性 23.通过属性给字段赋值，属性并没有值，是一个过度 24.一个属性既有set也有get称为可读可写属性。只有get只读，只有set只写 25.字段在类中必须是私有的
接上文
private int _name;//字段//只能在当前这个类的内部访问，出了这个类就访问不到，不加默认private
public string Name//属性
{
set
{
if(value<0||value>100)
value=0;
_name=value;
}//对照下文，value里存的是sunquan
给属性赋值时 首先会执行set方法
输出属性的值的时候会执行get方法
可以在set，get方法中进行限定
get
{
if(_name!="sunquan")
return _name="zhangsan";
return _name;
}
}
public void CHLSS ()
{
Console.WriteLine("my name is {0}",this.Name);
}
main函数里
Person per = new Person();
per.Name="sunquan";【过于阴间所以不想往下再写的东西回头补全（？maybe）】
//画游戏头
//初始化地图
//画地图
using System;
namespace CA1
{
class Program
{
//用静态字段模拟全局变量
public static int[] Maps = new int[100];
public enum Transform
{
口,
º,
々,
x,
卐
}
static void Main(string[] args)
{
//0表示普通，口
//1表示幸运轮盘，º
//2表示地雷，々
//3表示暂停，x
//4表示时空隧道，卐
GameShow();
PrimerMap();
PrintMap();
}
/// <summary>
/// 画游戏头
/// </summary>
public static void GameShow()
{
Console.ForegroundColor = ConsoleColor.Green;
//给字换颜色
Console.WriteLine("******************");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("******************");
Console.ForegroundColor = ConsoleColor.Gray;
Console.WriteLine("**20210124飞行棋**");
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("******************");
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("******************");
}
/// <summary>
///随机生成地图
/// </summary>
public static void PrimerMap()
{
Random r = new Random();
for (int i=0;i<100;i++)
{
int rNumber = r.Next(0, 5);
Maps[i] = rNumber;
}
}
/// <summary>
/// 打印阴间地图
/// </summary>
public static void PrintMap()
{
Transform trans;
string map = null;
for(int i=0;i<100;i++)
{
trans = (Transform)Maps[i];
map += trans+"\t";
if (i == 10 || i == 20 || i == 30 || i == 40
||i==50||i==60||i==70||i==80||i==90)
{
Console.WriteLine(map);
Console.WriteLine();
map = null;
}
}
}
}
}
26.静态与非静态的区别（加不加static）
1）在非静态类中，既可以有实例（非静态）成员，也可以有静态成员
2） 调用实例成员的时候，需要使用``对象名``+``.``+实例成员
3） 调用静态成员的时候，需要使用``类名``+``.``+静态成员
4） 实例类中可以出现静态字段也可以出现实例字段
5） 静态方法（函数）可以访问静态字段/静态属性
6） 静态方法（函数）中不能访问实例成员
7） 实例方法可以访问静态成员可以使用实例成员
main函数里
Person per = new Person();
per.FEIJINGTAI();
Person.JINGTAI();
Person类
public class Person
{
public void FEIJINGTAI()
{
Console.WriteLine("我是一个非静态方法");
}
public static void JINGTAI()
{
Console.WriteLine("我是一个静态方法");
}
}
8） 静态类中只允许出现静态成员，不能声明实例成员
9） 静态类不能实例化对象
10） 使用：如果你想要你的类当作一个“工具类”去使用，这个时候可以考虑将类写成静态的
11） 静态类在整个项目中资源共享。类不占内存，但是静态类本身占内存，存在静态存储区中
12） 只有程序全部结束后，静态类才会释放资源
27.给类取名字的时候首字母一定要大写
28.构造函数作用：帮助初始化对象。是一个特殊的方法
29.构造函数没有返回值，连void也不能写
30.构造函数的名称必须和类名一样，修饰符必须是public
31.创建对象的时候执行构造函数
protect在子类中可以访问，非自类和子类不能访问
main函数中
Person per1=new Person("zhangsan",18,'中',50);
per1.SayHello();
per1.ShowScore();
Person per2 = new Person("lisi",18,'男',100);
per2.SayHello();
per2.ShowScore();
Person类中
public class Person
{
public Person(string name,int age,char gender,int math)
{
this.Name = name;
this.Age = age;
this.Gender = gender;
this.Math = math;
}
private string _name;
public string Name
{
set { _name = value; }
get { return _name; }
}
private int _age;
public int Age
{
set {
if (value < 0 || value > 100)
value = 0;
_age = value;
}
get { return _age; }
}
private char _gender;
public char Gender
{
set { _gender = value; }
get
{
if (_gender != '男' || _gender != '女')
return _gender = '女';
return _gender;
}
}
private int _math;
public int Math
{
set { _math = value; }
get { return _math; }
}
public void SayHello()
{
Console.WriteLine("我叫{0},今年{1}岁,{2}生", this.Name, this.Age, this.Gender);
}
public void ShowScore()
{
Console.WriteLine("数学成绩{0}", this.Math);
}
}
32.new的作用有三个，缺一不可。在内存中开辟一块空间，在开辟的空间中创建对象，调用对象的构造函数初始化对象33.this的作用
1）代表当前类的对象
2）在类中显示的调用本类的构造函数，``：this``
public Person(string name,int age,char gender,int math)
{
this.Name = name;
this.Age = age;
this.Gender = gender;
this.Math = math;
}
public Person(string name):this(name,0,'n',90)
{
//再调用上面那个构造函数
}
34.可以认为类属于命名空间。如果当前项目中没有这个类的命名空间，需要我们手动导入
35.光标用鼠标去点。alt+shift+F10.
36.一个项目引用另外一个项目：外部依赖项->右键->增加引用->引用命名空间（using 下划线_名称）
37.被引用的类必须是public
38.值类型和引用类型再内存上存储的地方不一样
39.在传递值类型和引用类型的时候，传递的方式不一样
40.值类型我们称之为值传递，引用类型称之为引用传递
值类型：int ，double，bool，char，decimal，struct，enum
引用类型：string，自定义类
存储：
值类型存储在栈中
引用类型的值存在堆中
41.string 的不可变性 : 给字符串重新赋值时旧值并没有消失，而是重新开辟了一块新空间存储新值
42.当程序结束后，GC(垃圾处理机制）扫描整个内存，如果发现又的空间没有被指向，则立即把它销毁
43.
________________ ___________ ____________
string s1="zhangsan"; | 0x001001 | s1 | ——> | zhangsan |
________________ _________ / —— > ____________
string s2="zhangsan"; | 0x000101 | s2 | /
________________ _________
s1和s2在堆中所指向的内存地址是相同的
栈是变量本身的地址，堆是对象的实例地址
44.可以将字符串看做一个char类型的``只读``数组，因此可以通过下标访问
可以通过新建一个字符串对象把字符数组转为字符串类型
s=new string (chs)；
通过ToCharArray将string类型转为char数组45.
StringBuilder sb = new StringBuilder();
//stringbuilder不开辟新空间
string str = null;
Stopwatch sw = new Stopwatch();
//创建一个计时器用来记录程序运行的时间
sw.Start();//开始计时
for(int i=0;i<200;i++)
{
str += i;
sb.Append(i);//append就等于+=
}
sw.Stop();//结束计时
Console.WriteLine(sw.Elapsed);//得出总时长
string str2 = sb.ToString();
//用string builder一般还是要转化成string
Console.ReadKey();46.将字符串转换成大写，字符串.ToUpper();
47.转小写：字符串.ToLower();
48.字符串比较也可以调函数：字符串.Equals(字符串)
49.字符串比较：字符串.Equals（字符串，stringComparison.OrdinalIgnoreCase）//可以忽略大小写
50.字符串的分割
string s = "a b dfd _ + = ,,, gfg ";
//分割字符串Split
char[] chs = { ' ', '_', '+', '=', ',' };
string[] str = s.Split(chs, StringSplitOptions.RemoveEmptyEntries);
//返回值不包括含有空字符串的数51.字符串的替换
string str = "我列阵在北，白梅悄然落下";
if (str.Contains("列阵"))
str=str.Replace("列阵", "**");
Console.WriteLine(str);52.字符串的截取
string str ="今天天气好晴朗，处处好风光";
str=str.Substring(1,2);//从下标为1开始截取截取两个字符
53.str.StartsWith("今天")//判断字符串是否以今天开始，是的话返回true
54.str.EndsWith("风光")//判断字符串是否以风光结尾，是的话返回true
55.int index = str.IndexOf('天');
//返回天出现的第一个位置，第二个参数表示从哪里开始找，包括这个位置
//找所有的天用循环去找//找不到返回-156.移除字符串前后的空格可以用str=str.Trim()；只去前面用trimstart
57.string.IsNullOrEmpty(str)可以判断字符串是空或者是null，是返回true
58.将字符串数组串联起来并添加分隔符：
string[] names = { "zs","ls","ww","zl","tq"} ;
//zs|ls|ww|zl|tq
string str = string.Join("|" , names) ;59.类的特性：一个子类只能由一个父类（单根性）。类的传递性。
60.子类没有继承父类的构造函数，但是，子类会默认的调用父类的无参构造函数。创建父类对象，让子类可以使用父类的成员
61.如果父类重写一个有参构造函数之后，默认的无参构造函数就没了，子类就调用不到，因此子类会报错.
62.61的解决方法是，在父类重写一个无参的构造函数或者在子类中显示的调用父类的构造函数，使用关键字：base（）
Person类中
public class Person
{
public Person(string name,int age,char gender,int math)
{
this.Name = name;
this.Age = age;
this.Gender = gender;
this.Math = math;
}
private string _name;
public string Name
{
set { _name = value; }
get { return _name; }
}
private int _age;
public int Age
{
set {
if (value < 0 || value > 100)
value = 0;
_age = value;
}
get { return _age; }
}
private char _gender;
public char Gender
{
set { _gender = value; }
get
{
if (_gender != '男' || _gender != '女')
return _gender = '女';
return _gender;
}
}
有参构造函数
public Person(string name,int age ,char gender)
{
this.Name=name;
this.Age=age;
this.Gender=gender;
}
无参构造函数
public Person()
{
}
}
Student类中
public class Student : Person
{
public Student(string name,int age,char gender,int id) : base(name,age,gender)
{
this.Id=id;
}
}
63.object是所有类的基类。如果一个类没有继承任何类那么默认继承object
64.new关键字可以隐藏从父类继承来的方法。隐藏就是子类调不到从父类里来的
65.里氏转换
1）子类可以赋值给父类
2）如果父类中装的是子类的对象，那么可以将这个父类强转为子类对象
3）子类对象可以调用父类的成员，但是父类只能调用自己的成员
is的用法：如果能够转换成功，返回一个true，否则返回一个false
static void Main(string[] args)
{
Student stu = new Student();
Person per = stu;
//子类可以赋值给父类
//可以简写为：Person per=new Student();
//如果有一个地方需要一个父类作为参数那么我们可以给一个子类代替
//例如
string str = string.Join("|", new string[] { "1", "2", "3" });
//第二个参数需要父类类型的参数，而我们给的string数组类对象
//string属于object的子类，所以程序没有报错
if (per is Student)//is表示把student转换成person。如果可以转换，返回true
{
Student ss = (Student)per;
//父类中装的是子类对象，将父类强转为子类对象
ss.StudentSayHello();
}
else
{
Console.WriteLine("转换失败");
}
}
public class Person
{
public void PersonSayHello()
{
Console.WriteLine("PersonSayHello()");
}
}
public class Student : Person
{
public void StudentSayHello()
{
Console.WriteLine("StudentSayHello()");
}
}
as的用法：如果能够转换成功则返回对应的对象，否则返回一个null
static void Main(string[] args)
{
Student stu = new Student();
Person per = stu;
Teacher t = per as Teacher;
//不能转换成功因为per装的是student
Student t1 = per as Student;
t1.StudentSayHello();
//可以转成功,返回一个对象
}
public class Person
{
public void PersonSayHello()
{
Console.WriteLine("PersonSayHello()");
}
}
public class Student : Person
{
public void StudentSayHello()
{
Console.WriteLine("StudentSayHello()");
}
}
public class Teacher:Person
{
public void TeacherSayHello()
{
Console.WriteLine("TeacherSayHello()");
}
}
里氏转换的一个应用/练习
static void Main(string[] args)
{
//创建十个对象，通过循环去调用她们各自的成员函数
Person[] pers = new Person[10];
//根据里氏转换原则，子类可以放入父类
Random r = new Random();
for (int i = 0; i < pers.Length; i++)
{
int rnumber = r.Next(1, 4);
switch (rnumber)
{
case 1:pers[i] = new Person();break;
case 2:pers[i] = new Teacher();break;
case 3:pers[i] = new Student();break;
}
}
for (int i = 0; i < pers.Length; i++)
{
//pers数组表现出来的是父类类型
//调不到子类的成员
if (pers[i] is Student)
((Student)pers[i]).StudentSayHello();
else if (pers[i] is Teacher)
((Teacher)pers[i]).TeacherSayHello();
else
pers[i].PersonSayHello();
}
}
public class Person
{
public void PersonSayHello()
{
Console.WriteLine("PersonSayHello()");
}
}
public class Student : Person
{
public void StudentSayHello()
{
Console.WriteLine("StudentSayHello()");
}
}
public class Teacher:Person
{
public void TeacherSayHello()
{
Console.WriteLine("TeacherSayHello()");
}
}66.ArrayList（list）和HashTable（字典）元素的添加、插入、删除、清空、排序、反转
1）集合的长度可以任意改变，类型随便
随便放了一大堆后打印
static void Main(string[] args)
{
//创建一个集合的对象
ArrayList list = new ArrayList();
list.Add(1);
list.Add(3.2);
list.Add("zhangsan");
list.Add(new int[] { 1, 2, 3, 4, 5 });
Person p = new Person();
list.Add(p);
list.Add(list);
for (int i = 0; i < list.Count; i++)
{
Console.WriteLine(list[i]);
}
}
public class Person
{
public void PersonSayHello()
{
Console.WriteLine("PersonSayHello()");
}
}
打印的结果却是：
1
3.2
zhangsan
System.Int32[]
CA2.Program+Person
System.Collections.ArrayList
一堆乱七八糟的东西（buhsi
打印了一堆命名空间
ArrayList不管我往里面加什么。它返回的都是object类型
然后正确的一个实例（比较麻烦）
using System;
using System.Collections;
using System.Diagnostics;
using System.Text;
namespace CA2
{
class Program
{
static void Main(string[] args)
{
//创建一个集合的对象
ArrayList list = new ArrayList();
list.Add(1);
list.Add(3.2);
list.Add("zhangsan");
list.Add(new int[] { 1, 2, 3, 4, 5 });
Person p = new Person();
list.Add(p);
list.Add(list);
for (int i = 0; i < list.Count; i++)
{
if (list[i] is Person)//能这样去转是因为list是object类型
( (Person) list[i] ).PersonSayHello();
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]);
//其实有个list还应该再判断一遍但是懒得判断了
}
}
public class Person
{
public void PersonSayHello()
{
Console.WriteLine("PersonSayHello()");
}
}
}
}
创建一个集合的对象
ArrayList list = new ArrayList();
list.Add(true);
添加集合元素
list.AddRange(new int[] { 1, 2, 3, 4 });
list.AddRange(list);
for (int i = 0; i < list.Count; i++)
{
Console.WriteLine(list[i]);
}
list.Clear();
移除list里所有东西
list.Remove(true);
移除单个元素，想删谁就把谁放进去
list.RemoveAt(0);
根据下标去删除元素
list.RemoveRange(1, 3);
根据下标去移除一定范围的元素
list.Reverse();
反转
list.Insert(5);
在指定的索引处插入
capcity表示这个集合里可以包含的元素个数
67.Hashtable方法的增、删、查、判存
1）添加数据，都是“键值对”的形式
2）键值对均是object类型
3）键值对中的键就是为了找数据用的，必须提供，不允许重复
4）Hashtable使用键作为寻找的方式，是一种无序的结构
5）得到数据
6）使用<hashtable实例名>[键]，将返回object类型的，由键对应的数据
7）强转，使用里氏转换原则
8）键值对中键必须是唯一的，而值可以是重复的
68.强类型语言是指：必须在代码里必须对每一种类型有一个明确的定义
69.隐式类型的局部变量必须全部初始化
代码示例：
1）添加数据，对键和值的数据类型没有要求
Hashtable ht = new Hashtable();
//创建一个键值对集合对象
ht.Add(1, "zhangsan");
ht.Add(2, "nan");
ht.Add(false, "cuowude");
也可以通过: ht[6]="新来的"; 这样去添加
如果没有的话就加进去，有的话就替换掉。调用add不会覆盖而是会运行错误
所以一般添加的时候都会进行一个判断
if ( !ht.ContainsKey("abd") )
ht["abc"]="sahdiad";
else
Console.WriteLine("已经包含这个键了");
2）数据的遍历
//在键值对中是根据键去找值的
Console.WriteLine(ht[1]);
//在[]中放入键
//或者用foreach循环
foreach (var item in ht.Keys)
{
//item集合里的每一项
//var自动识别类型
Console.WriteLine(item);//键
Console.WriteLine(ht[item]);//值
}
3）数据的移除
ht.Clear();
移除所有元素
ht.Remove(3);
根据键去移除
4)练习
private const String Jian = "天地玄黄宇宙洪荒日月盈昃辰宿列张寒来暑往秋收冬藏";
private const String Fan = "天地玄黃宇宙洪荒日月盈昃辰宿列張寒來暑往秋收冬藏";
static void Main(string[] args)
{
Hashtable ht = new Hashtable();
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.ContainsKey(input[i]))
Console.Write(ht[input[i]]);
else
Console.WriteLine("can not find...");
}
}
70.Path类
string str = @"D:\3000soft\Rea Spider\Data\Message\wani.JPG";
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"));
将两个路径相加
71.File类
File.Create(@"C:\Users\Dell\Desktop\new.txt");
创建一个文件，要给出路径和名称
不会运行两次创建两个同名称的文件
也即第二次运行还是第一次运行时的文件
Console.WriteLine("创建成功");
File.Delete(@"C:\Users\Dell\Desktop\new.txt");
Console.WriteLine("删除成功");
删除是彻底删除，回收站都没有
创建代码和删除代码一起写程序运行会出错
File.Copy(@"C:\Users\Dell\Desktop\new.txt", @"C:\Users\Dell\Desktop\copy.txt");
复制一个文件，注意要改名称
读出文件内容
byte[] buffer=File.ReadAllBytes(@"C:\Users\Dell\Desktop\new.txt");
以字节形式读取,字节看不懂所以要改码
将字节数组中的每一个元素都按照我们指定的编码格式解码
UFT-8 GB2312 GBK Unicode
string s=Encoding.GetEncoding("UTF-8").GetString(buffer);
Console.WriteLine(s);
向文件中写入内容
string str = "如果是唱歌的话那么就能对你说出那句thank you";
byte[] buffer=Encoding.Default.GetBytes(str);
File.WriteAllBytes(@"C:\Users\Dell\Desktop\new.txt",buffer);
没有创建有覆盖
逐行读取
string[] contents = File.ReadAllLines(@"C:\Users\Dell\Desktop\new.txt", Encoding.Default);
foreach (string item in contents)
{
Console.WriteLine(item);
}
直接读取
string str =File.ReadAllText(@"C:\Users\Dell\Desktop\new.txt", Encoding.Default);
Console.WriteLine(str);
72.绝对路径：通过给定的这个路径直接能在我的电脑中找到这个文件
73.相对路径：文件相对于应用程序的路径
74.list泛型集合
List<int> list = new List<int>();
list.Add(4);
list.Add(1);
list.AddRange(new int[] { 1, 2, 3, 4 });
for (int i = 0; i < list.Count; i++)
{
Console.WriteLine(list[i]);
}
//可以转成一个数组
int[] n = list.ToArray();
75.装箱：值类型转为引用类型 int n=10; object o=n;
76.拆箱：引用类型转为值类型 int nn=(int)o;
77.看两种类型是否发生了装箱或者拆箱，要看这两种类型是否存在继承关系。有继承关系有
可能，没有继承关系一定不会发生
78.Dictionary
Dictionary<int, string> dic = new Dictionary<int, string>();
键是int，值是string
dic.Add(1, "zs");
dic.Add(2, "ls");
dic.Add(3,"Ww");
dic[1] = "xinlaide";
foreach (var item in dic.Keys)
{
Console.WriteLine(item);
Console.WriteLine(dic[item]);
}
Console.WriteLine("-------------");
还有另外一种遍历方法，可以直接遍历键值对
foreach (KeyValuePair<int,string> kv in dic)
{
Console.WriteLine(kv.Key);
Console.WriteLine(kv.Value);
}
79.FileStream
用FileStream读取数据
FileStream fs = new FileStream(@"C:\Users\Dell\Desktop\new.txt",
FileMode.OpenOrCreate,FileAccess.Read);
第一个数据是路径，第二个数据是文件打开方式
第三个数据是对文件中的数据进行的操作
byte[] buffer = new byte[1024 * 1024 * 5];
int r=fs.Read(buffer, 0, buffer.Length);
通过这种方式限定每次读多少数据，这次最高5M
第二个参数要求从哪个位置开始放数据
第三个参数要求限定读的大小
将字节数组中每一个元素按照指定的编码格式转化为字符串
第二个参数表示从哪个位置开始读，第三个参数表示读到哪里
string s = Encoding.Default.GetString(buffer,0,r);
关闭流
fs.Close();
释放流所占的资源
fs.Dispose();
Console.WriteLine(s);
将创建文件流对象的过程写在using中，会自动帮助我们释放流所占用的资源
using(FileStream fs = new FileStream(@"C:\Users\Dell\Desktop\new.txt",
FileMode.OpenOrCreate, FileAccess.Write))
{
string str = "kanwo";
byte[] buffer = Encoding.UTF8.GetBytes(str);
fs.Write(buffer, 0, buffer.Length);
}
Console.WriteLine("ok");
80.filestream的一个应用
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
namespace CA2
{
class Program
{
static void Main(string[] args)
{
//思路：就是先将要复制的多媒体文件读取出来，
//然后写入到指定的位置
string source = @"C:\Users\SpringRain\Desktop\1.fuxi.wmv";
string target = @"C:\Users\SpringRain\Desktop\new.wmv";
CopyFile(source, target);
Console.WriteLine("ok");
}
public static void CopyFile(string soucre,string target)
{
//1）创建一个负责读取的流
using(FileStream fsread=new FileStream(soucre,FileMode.Open,FileAccess.Read))
{
//2）创建一个负责写入的流
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);
//如果返回一个0，也就意味着什么都没读到
if (r == 0)
break;
fswrite.Write(buffer, 0, r);
}
}
}
}
}
}
81.StreamReader和StreamWriter
读取文本文件
using(StreamReader sr =new
StreamReader(@"C:\Users\Dell\Desktop\new.txt",Encoding.Default))
{
while(!sr.EndOfStream)
Console.WriteLine(sr.ReadLine());
}
覆盖式写入文件
using(StreamWriter sw =new StreamWriter(@"C:\Users\Dell\Desktop\new.txt"))
{
sw.Write("sadhiahdawihdaoi");
}
不覆盖
(@"C:\Users\Dell\Desktop\new.txt"，true))
82.实现多态的三种手段：虚方法，抽象类，接口
1）虚方法可以重写父类方法也可以不须写
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
namespace CA2
{
class Program
{
static void Main(string[] args)
{
//Person[] pers = new Person[6];
Chinese cn1 = new Chinese("zs");
Chinese cn2 = new Chinese("ls");
Japanese js1 = new Japanese("Dazai Osamu");
Japanese js2 = new Japanese("Akutagawa Ryunosuke");
Korea ko1 = new Korea("jxx");
Korea ko2 = new Korea("xjx");
Person[] pers = { cn1, cn2, js1, js2, ko1, ko2 };
for (int i = 0; i < pers.Length; i++)
{
pers[i].SayHellow();
}
}
public class Person
{
private string _name;
public string Name
{
set { _name = value; }
get { return _name; }
}
public Person(string name)
{
this.Name = name;
}
public virtual void SayHellow()
{
Console.WriteLine("PersonSayHellow()");
}
}
public class Chinese : Person
{
public Chinese(string name):base(name)
{
}
public override void SayHellow()
{
Console.WriteLine(this.Name);
Console.WriteLine("ChineseSayHellow()");
}
}
public class Japanese : Person
{
public Japanese(String name):base(name)
{
}
public override void SayHellow()
{
Console.WriteLine(this.Name);
Console.WriteLine("JapaneseSayhellow()");
}
}
public class Korea : Person
{
public Korea(string name):base(name)
{
}
public override void SayHellow()
{
Console.WriteLine(this.Name);
Console.WriteLine("KoreaSayHellow()");
}
}
}
}
2）抽象类。当父类函数不知道如何实现的时候可以用抽象类
2.1）抽象方法不允许有方法体
2.2）有大括号就是有方法体，如果大括号为空还有别名：空实现
class Program
{
static void Main(string[] args)
{
创建一个子类对象赋值给父类
Animal a = new Dog();
a.Bark();
}
public abstract class Animal
{
public abstract void Bark();
}
public class Dog:Animal
{
public override void Bark()
{
Console.WriteLine("walf! walf!");
}
}
public class Cat:Animal
{
public override void Bark()
{
Console.WriteLine("miao! miao!");
}
}
}
2.3）父类抽象类可以写非抽象成员，并且子类不需要重写非抽象成员
2.4）抽象成员必须在抽象类中
2.5）抽象类不能实例化对象
2.6）抽象类是有构造函数的
2.7）如果父类的抽象方法中有参数，那么继承这个抽象父类的子类重写父类方法的时候必须传入对应的参数
2.8）如果抽象父类的抽象方法中有返回值，那么子类在重写这个抽象方法的时候，也必须要传入返回值
2.9）抽象类同样可以写虚方法
83.多态练习，求矩形圆形面积周长
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Text;
namespace CA2
{
class Program
{
static void Main(string[] args)
{
Shape s = new Circle(5);
double erae = s.GetArea();
double per = s.GetPermiter();
Console.WriteLine("面积{0},周长{1}", erae, per);
Shape s1 = new Square(5,6);
double erae1 = s1.GetArea();
double per1 = s1.GetPermiter();
Console.WriteLine("面积{0},周长{1}", erae1, per1);
}
public abstract class Shape
{
public abstract double GetArea();
public abstract double GetPermiter();
}
public class Circle:Shape
{
private double _r;
public double R
{
set { _r = value; }
get { return _r; }
}
public Circle(double r)
{
this.R = r;
}
public override double GetArea()
{
return Math.PI * this.R * this.R;
}
public override double GetPermiter()
{
return 2 * Math.PI * this.R;
}
}
public class Square : Shape
{
private double _height;
public double Height
{
set { _height = value; }
get { return _height; }
}
private double _width;
public double Width
{
set { _width = value; }
get { return _width; }
}
public Square(double height,double width)
{
this._width = width;
this._height = height;
}
public override double GetArea()
{
return this.Height * this.Width;
}
public override double GetPermiter()
{
return (this.Height + this.Width) * 2;
}
}
}
}84.internal：只能在当前项目中访问
85.能够修饰类的访问修饰符只有两个：public、internal
86.在同一个项目中internal和public的权限是一样的
87.子类的访问权限不能高于父类
88.c#共有五个访问修饰符，public、private、protected、internal、protected internal
89.23种设计模式：https://blog.csdn.net/qq_40323256/article/details/82559050
（大话设计模式）
90.值类型，栈上：int、double、char、decimal、bool、enum、struct。
91.引用类型，堆上：string 、数组、自定义类、集合、object、接口
92.值类型在复制的时候，传递的是值的本身
93.引用传递传的地址，如果复制了一个，改变任意一个值，那么另外一个也改变，因为指向的是同一个。
但是字符串有不可变性，每次赋值直接开新空间
94.序列化：将对象转为二进制 在类前加[Serializable]
Person类
using System;
using System.Collections.Generic;
using System.Text;
namespace CA2
{
[Serializable]
public class Person
{
public Person(string name,int age,char gender,int math)
{
this.Name = name;
this.Age = age;
this.Gender = gender;
this.Math = math;
}
public Person(string name):this(name,0,'n',90)
{
}
private string _name;
public string Name
{
set { _name = value; }
get { return _name; }
}
private int _age;
public int Age
{
set {
if (value < 0 || value > 100)
value = 0;
_age = value;
}
get { return _age; }
}
private char _gender;
public char Gender
{
set { _gender = value; }
get
{
if (_gender != '男' || _gender != '女')
return _gender = '女';
return _gender;
}
}
private int _math;
public int Math
{
set { _math = value; }
get { return _math; }
}
public void SayHello()
{
Console.WriteLine("我叫{0},今年{1}岁,{2}生", this.Name, this.Age, this.Gender);
}
public void ShowScore()
{
Console.WriteLine("数学成绩{0}", this.Math);
}
}
}
main函数
Person per = new Person("zs",23,'n',35);
using(FileStream fswrite=new FileStream(@"C:\Users\Dell\Desktop\new.txt",
FileMode.OpenOrCreate,FileAccess.Write))
{
//开始序列化对象
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(fswrite, per);
}
Console.WriteLine("ok");
95.反序列化：将二进制转化为对象
Person per;
//接受对方发送来的二进制 反序列化成对象
using(FileStream fsread=new
FileStream(@"C:\Users\Dell\Desktop\new.txt"
,FileMode.OpenOrCreate,FileAccess.Read))
{
BinaryFormatter bf = new BinaryFormatter();
per=(Person)bf.Deserialize(fsread);
}
Console.WriteLine(per.Name);
Console.WriteLine(per.Math);
Console.WriteLine(per.Gender);95.partial表示部分类，比如两个person类前加partial表示这两个person类都是person类的一部分
且两个互通，写在里面的成员不管属性如何都可以直接用
96.密封类，在类前加上sealed，不能被继承，但是能继承别人
97.继承具有单根性，一个子类只能由一个父类
98.接口.声明用interface。一个类继承了接口类必须要实现接口的成员
99.接口就是一个规范，能力
100.接口的成员不允许添加访问修视符，默认就是public
101.接口中不允许写有方法题的函数
102.接口中不能包含字段，可以写自动属性，自动属性可以自动生成一个私有属性
105.接口与接口之间可以继承并且可以多继承
106.接口中只能有方法、属性、索引器、事件，不能有字段和构造函数
107.为了多态接口不能被实例化
108.接口不能继承一个类
109.如果一个类既继承接口又继承类，必须把类放在接口前面
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
namespace CA2
{
class Program
{
static void Main(string[] args)
{
IFlyable fly = new Person();
fly.Fly();
IFlyable fl = new Bird();
fl.Fly();
}
public interface IFlyable
{
void Fly();
//string Test();
// string Name
// {
// get;
// set;
// }
}
public class Person:IFlyable
{
public void Fly()
{
Console.WriteLine("Person:IFlyable");
}
}
public class Bird:IFlyable
{
public void Fly()
{
Console.WriteLine("Bird:IFlyable");
}
}
}
}
110.显示实现接口，解决方法的重名问题
public class Bird:IFlyable
{
public void Fly()
{
Console.WriteLine("Bird:IFlyable");
}
void IFlyable.Fly()
{
Console.WriteLine("xianshishixianjieku");
}
}
111.练习，超市管理系统（待完善）
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
namespace CA2
{
class Program
{
static void Main(string[] args)
{
//创建超市对象
SuperMarket sm = new SuperMarket();
//展示货物
sm.ShowPros();
//与用户交互
sm.AskBuying();
}
class ProductFather
{
public double Price
{
get;
set;
}
public string Name
{
get;
set;
}
public string ID
{
get;
set;
}
public ProductFather(string id,double price,string name)
{
this.ID = id;
this.Price = price;
this.Name = name;
}
}
class SamSung:ProductFather
{
public SamSung(string id,double price,string name)
:base(id,price,name)
{
}
}
class Acer:ProductFather
{
public Acer(string id, double price, string name)
: base(id, price, name)
{
}
}
class Banana:ProductFather
{
public Banana(string id, double price, string name)
: base(id, price, name)
{
}
}
class JiangYou:ProductFather
{
public JiangYou(string id, double price, string name)
: base(id, price, name)
{
}
}
/// <summary>
/// 存贮货物
/// </summary>
class CangKu
{
List<List<ProductFather>> list = new List<List<ProductFather>>();
// List<ProductFather> list2 = new List<ProductFather>();
/// <summary>
/// 在创建仓库对象的时候，向仓库中添加货架
/// list[0]:Acer list[1]:SunSumg
/// list[2]:JiangYou list[3]:Banana
/// </summary>
public CangKu()
{
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
}
/// <summary>
/// 进货
/// </summary>
/// <param name="strType">货物类型</param>
/// <param name="count">货物数量</param>
public void GetPros(string strType,int count)
{
for (int i = 0; i < count; i++)
{
switch(strType)
{
case "Acer":list[0].Add(new Acer(Guid.NewGuid().ToString(), 1000, "Acer"));
break;
case "SamSung":list[1].Add(new SamSung(Guid.NewGuid().ToString(), 2000, "SamSung"));
break;
case "JiangYou":list[2].Add(new JiangYou(Guid.NewGuid().ToString(), 20, "JiangYou"));
break;
case "Banana":list[3].Add(new Banana(Guid.NewGuid().ToString(), 2, "Banana"));
break;
}
}
}
public ProductFather[] QuPros(string strType,int count)
{
ProductFather[] pros = new ProductFather[count];
for (int i = 0; i < count; i++)
{
switch(strType)
{
case "Acer":
if (list[0].Count == 0)
{
Console.WriteLine("There is no more Acer....");
break;
}
else
{
pros[i] = list[0][0];//list[0]是货架,list[0][0]是货架上第一个货物
list[0].RemoveAt(0);
break;
}
case "SamSung":
if (list[1].Count == 0)
{
Console.WriteLine("There is no more SamSung....");
break;
}
else
{
pros[i] = list[1][0];
list[1].RemoveAt(0);
break;
}
case "JiangYou":
if (list[2].Count == 0)
{
Console.WriteLine("There is no more JiangYou....");
break;
}
else
{
pros[i] = list[2][0];
list[2].RemoveAt(0);
break;
}
case "Banana":
if (list[3].Count == 0)
{
Console.WriteLine("There is no more Banana....");
break;
}
else
{
pros[i] = list[3][0];
list[3].RemoveAt(3);
break;
}
}
}
return pros;
}
/// <summary>
/// 向用户展示货物
/// </summary>
public void ShowPros()
{
foreach (var item in list)
{
Console.WriteLine("we have " + item[0].Name+"\t"+item.Count+"\t"+item[0].Price+"Rmb");
}
}
}
/// <summary>
/// 打折的父类
/// </summary>
abstract class CalFather
{
/// <summary>
/// 计算打折后应付多少钱
/// </summary>
/// <param name="realmoney">打折前应付的价钱</param>
/// <returns>打折后应付的钱</returns>
public abstract double GetTotalMoney(double realmoney);
}
/// <summary>
/// 不打折，该多少钱就多少钱
/// </summary>
class CalNormal:CalFather
{
public override double GetTotalMoney(double realmoney)
{
return realmoney;
}
}
/// <summary>
/// 按折扣率打折
/// </summary>
class CalRate:CalFather
{
/// <summary>
/// 折扣率
/// </summary>
public double Rate
{
get;
set;
}
public CalRate(double rate)
{
this.Rate = rate;
}
public override double GetTotalMoney(double realmoney)
{
return realmoney * this.Rate;
}
}
/// <summary>
/// 买m送n
/// </summary>
class CalMN:CalFather
{
public double M
{
set;
get;
}
public double N
{
set;
get;
}
public CalMN(double m, double n)
{
this.M = m;
this.N = n;
}
public override double GetTotalMoney(double realmoney)
{
if (realmoney >= this.M)
return realmoney - this.N;
else
return realmoney;
}
}
class SuperMarket
{
CangKu ck = new CangKu();
/// <summary>
/// 创建超市对象的时候，给仓库的货架上导入货物
/// </summary>
public SuperMarket()
{
ck.GetPros("SamSung", 1000);
ck.GetPros("Acer", 1000);
ck.GetPros("Banana", 1000);
ck.GetPros("JiangYou", 1000);
}
/// <summary>
/// 跟用户交互的过程
/// </summary>
public void AskBuying()
{
Console.WriteLine("Welcom to our Market ,what do you want?");
Console.WriteLine("We have Acer,SamSung,JiangYou,Banana");
string strType = Console.ReadLine();
Console.WriteLine("How many?");
int count = Convert.ToInt32(Console.ReadLine());
//去仓库取货物
ProductFather[] pros = ck.QuPros(strType, count);
//计算价格
double realmoney = GetMoney(pros);
Console.WriteLine("You need pay {0} yuan to us", realmoney);
Console.WriteLine("Please choose the way of discount ");
Console.WriteLine("1---no discount \t 2--10% discount ");
Console.WriteLine("3-- 15% discount \t 4--300 return 50");
Console.WriteLine("5--500 return 100");
string input = Console.ReadLine();
//根据简单工厂的设计模式根据用户的输入获得一个打折对象
CalFather cal = GetCal(input);
realmoney=cal.GetTotalMoney(realmoney);
Console.WriteLine("After discount you need pay for {0}", realmoney);
Console.WriteLine("This is the information of this buying");
foreach (var item in pros)
{
Console.WriteLine("name:\t\tprice:\t\tid:");
Console.WriteLine(item.Name + "\t" + item.Price + "\t" + item.ID);
}
}
/// <summary>
/// 根据用户选择的打折方式返回打折对象
/// </summary>
/// <param name="input">用户的选择</param>
/// <returns>返回父类对象 但是里面装的是子类对象</returns>
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;
}
/// <summary>
/// 根据用户买的货物计算总价钱
/// </summary>
/// <param name="pros"></param>
/// <returns></returns>
public double GetMoney(ProductFather[] pros)
{
double realmoney = 0;
for (int i = 0; i < pros.Length; i++)
{
realmoney += pros[i].Price;
}
return realmoney;
}
public void ShowPros()
{
ck.ShowPros();
}
}
}
}
113.MD5加密
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
string s = GetMD5("123");
Console.WriteLine(s);
}
public static string GetMD5(string str)
{
//创建MD5对象
MD5 md5 = MD5.Create();
//开始加密
//需要将字符转为字节数组
byte[] buffer = Encoding.Default.GetBytes(str);
byte[] md5buffer=md5.ComputeHash(buffer);
//将字节数组转为字符串
//字节数组--字符串
//将字节数组中每个元素按照指定的编码格式解析成字符串
//直接将数组转为ToString（）；
//将字节数组中的每个元素ToString（）；
//return Encoding.Default.GetString(md5buffer);
string strnew = "";
for (int i = 0; i < md5buffer.Length; i++)
{
strnew += md5buffer[i].ToString("x2");
//x就是把10进制转为16进制。
}
return strnew;
}
114.
Process[] pros = Process.GetProcesses();
foreach (var item in pros)
{
Console.WriteLine(item);
}
//通过进程打开一些应用程序
Process.Start("calc");
Process.Start("iexplore", "http://www.baidu.com");
//通过进程打开指定的文件
ProcessStartInfo psi = new ProcessStartInfo(@"C:\Users\Dell\Desktop\new.txt");
Process p = new Process();
p.StartInfo = psi;
p.Start();
115.线程分为两种，前台线程和后台线程，具体执行之间由cpu决定
116.前台线程：只有所有的前台线程都关闭才能完成程序关闭
117.后台线程：只要所有的前台线程结束，后台线程自动结束
118.多线程目的：·让计算机同时做多件事情，节约时间···
private void button1_Click(object sender, EventArgs e)
{
//创建一个线程,去执行test方法
Thread th = new Thread(test);
//标记线程准备就绪了，可以随时被执行
//将线程设置为后台线程
th.IsBackground = true;
th.Start();
}
private void test()
{
for (int i = 0; i < 1000; i++)
{
Console.WriteLine(i);
}
}
118.。net平台不允许跨线程
119.
private void Form1_Load(object sender, EventArgs e)
{
//取消跨线程的访问
//所有控件都继承于control这个类
Control.CheckForIllegalCrossThreadCalls = false;
}
120.
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
//点击关闭窗体的时候，判断新线程是否为null。
if (th != null)
{
th.Abort();
}
}
121.线程被abort了后就不能被start
122.socket作为进程通信机制，取插座的意思，通常也称作套接字，用于描述ip地址和端口
是一个通信链的句柄
123.服务器至少有两个scoket，一个负责监听一个负责通信
124.流式socket（STREAM）：是一种面向链接的socket，针对面向链接的TCP服务应用，安全，但是效率低
125.数据报式socket（DATAGRAM）：是一种无连接的socket，对应于无链接的UDP服务应用，不安全
（丢失，顺序混乱，在接受端要分析重排以及要求重发），但效率高
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 WA5
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
Thread th;
private void button1_Click(object sender, EventArgs e)
{
//创建一个线程,去执行test方法
th = new Thread(test);
//标记线程准备就绪了，可以随时被执行
//将线程设置为后台线程
th.IsBackground = true;
th.Start();
}
private void test()
{
for (int i = 0; i < 1000; i++)
{
Console.WriteLine(i);
textBox1.Text = i.ToString();
}
}
private void Form1_Load(object sender, EventArgs e)
{
//取消跨线程的访问
//所有控件都继承于control这个类
Control.CheckForIllegalCrossThreadCalls = false;
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
//点击关闭窗体的时候，判断新线程是否为null。
if (th != null)
{
th.Abort();
}
}
private void button2_Click(object sender, EventArgs e)
{
//创建负责监听的socket
Socket socketWatch = new Socket(AddressFamily.InterNetworkV6,SocketType.Stream,ProtocolType.Tcp);
//第一个参数表示ip版本，第二个参数流式的socket
//第三个参数表示协议（tcp
//创建ip地址和端口号对象
IPAddress ip = IPAddress.Parse(textBox1.Text);
//或者用
IPAddress ip2 = IPAddress.Any;
//创建端口号
IPEndPoint point = new IPEndPoint(ip2, Convert.ToInt32(textBox2.Text));
//第一个参数ip地址，第二个参数端口号
//监听的socket绑定ip地址跟端口号
socketWatch.Bind(point);
ShowMsg("监听成功");
//设置监听队列（在某一个时间点内能连入服务端的最大客户端数量）
socketWatch.Listen(10);
//负责监听的socket 来接受客户端的链接
Socket socketSend= socketWatch.Accept();
//等待客户端的链接，如果没有链接就一直等
//将成功连入的显示出来
ShowMsg(socketSend.RemoteEndPoint.ToString()+"链接成功");
//通过remoteendpoint拿到远程的IP地址和端口号
//线程执行的方法如果有参数必须是object类型
}
void ShowMsg(string str)
{
textBox3.AppendText(str + "\r\n");
}
}
}
126.服务器
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 WA5
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
Thread th;
private void button1_Click(object sender, EventArgs e)
{
//创建一个线程,去执行test方法
th = new Thread(test);
//标记线程准备就绪了，可以随时被执行
//将线程设置为后台线程
th.IsBackground = true;
th.Start();
}
private void test()
{
for (int i = 0; i < 1000; i++)
{
Console.WriteLine(i);
textBox1.Text = i.ToString();
}
}
private void Form1_Load(object sender, EventArgs e)
{
//取消跨线程的访问
//所有控件都继承于control这个类
Control.CheckForIllegalCrossThreadCalls = false;
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
//点击关闭窗体的时候，判断新线程是否为null。
if (th != null)
{
th.Abort();
}
}
private void button2_Click(object sender, EventArgs e)
{
//创建负责监听的socket
Socket socketWatch = new Socket(AddressFamily.InterNetworkV6,SocketType.Stream,ProtocolType.Tcp);
//第一个参数表示ip版本，第二个参数流式的socket
//第三个参数表示协议（tcp
//创建ip地址和端口号对象
IPAddress ip = IPAddress.Parse(textBox1.Text);
//或者用
IPAddress ip2 = IPAddress.Any;
//创建端口号
IPEndPoint point = new IPEndPoint(ip2, Convert.ToInt32(textBox2.Text));
//第一个参数ip地址，第二个参数端口号
//监听的socket绑定ip地址跟端口号
socketWatch.Bind(point);
ShowMsg("监听成功");
//设置监听队列（在某一个时间点内能连入服务端的最大客户端数量）
socketWatch.Listen(10);
//负责监听的socket 来接受客户端的链接
Socket socketSend= socketWatch.Accept();
//等待客户端的链接，如果没有链接就一直等
//将成功连入的显示出来
ShowMsg(socketSend.RemoteEndPoint.ToString()+"链接成功");
//通过remoteendpoint拿到远程的IP地址和端口号
//线程执行的方法如果有参数必须是object类型
Thread the = new Thread(Listen);
the.IsBackground = true;
th.Start(socketWatch);
//循环等待客户端链接
}
void Listen(object o)
{
Socket socketWatch = o as Socket;
while(true)
{
Socket socketSend = socketWatch.Accept();
ShowMsg(socketSend.RemoteEndPoint.ToString() + "链接成功");
//开启一个新线程不停的接受客户端发来的消息
Thread tha = new Thread(Recive);
tha.IsBackground = true;
tha.Start(socketSend);
}
}
/// <summary>
/// 服务器端不停的接受客户端发送过来的消息
/// </summary>
/// <param name="o"></param>
void Recive(object o)
{
Socket socketSend = o as Socket;
while (true)
{
try
{
byte[] buffer = new byte[1024 * 1024 * 5];
int r = socketSend.Receive(buffer);
//接受客户端发来的消息
//返回实际接受到的字节数
string str = Encoding.UTF8.GetString(buffer, 0, r);
if (r == 0)
break;
ShowMsg(socketSend.RemoteEndPoint + ":" + str);
}
catch
{ }
}
}
void ShowMsg(string str)
{
textBox3.AppendText(str + "\r\n");
}
}
}
设计版面：
最上方一排从左到右：一个ip地址文本框，一个端口号文本框，一个开始监听按钮，两个按钮
第二排：一个文本框
第三排：一个文本框
第四排：一个文本框 右边上面：选择按钮，发送文件按钮 下面：发送消息按钮，震动按钮
127.GDI+。是一种绘图装置接口，可以讲应用程序和绘图硬件分离，能让我们编写与装置
无关的应用程序。可以让我们不需要注意特定显示装置的详细数据，便可在屏幕或打印机
显示信息。
128.
private void button1_Click(object sender, EventArgs e)
{
//创建gdi对象
Graphics g = this.CreateGraphics();
//创建画笔对象
Pen pen = new Pen(Brushes.Red);
//创建两个点
Point p1 = new Point(30, 50);
Point p2 = new Point(250, 250);
g.DrawLine(pen, p1, p2);
}
private void button2_Click(object sender, EventArgs e)
{
//画一个矩形
Graphics g = this.CreateGraphics();
Pen pen = new Pen(Brushes.Black);
Size size = new System.Drawing.Size(80, 80);
Rectangle rec = new Rectangle(new Point(50, 50),size);
g.DrawRectangle(pen,rec);
}
private void button3_Click(object sender, EventArgs e)
{
//画一个扇形
Graphics g = this.CreateGraphics();
Pen pen = new Pen(Brushes.Blue);
Size size = new System.Drawing.Size(180, 180);
Rectangle rec = new Rectangle(new Point(150, 150), size);
g.DrawPie(pen, rec, 60, 60);
}
private void button4_Click(object sender, EventArgs e)
{
//画文本
Graphics g = this.CreateGraphics();
g.DrawString("sgmsszd",new Font("宋体",20,FontStyle.Underline),Brushes.Black,new Point(300,300));
}
129.画验证码
private void pictureBox1_Click(object sender, EventArgs e)
{
Random r = new Random();
string str = null;
for (int i = 0; i < 5; i++)
{
int number = r.Next(0, 10);
str += number;
}
Bitmap bmp = new Bitmap(150, 40);
Graphics g = Graphics.FromImage(bmp);
for (int i = 0; i < 5; i++)
{
string[] fonts = { "微软雅黑", "宋体", "黑体", "隶书", "仿宋" };
Color[] colors = { Color.Red, Color.Yellow, Color.Black, Color.Blue, Color.Green };
Point p = new Point(i*30,0);
g.DrawString(str[i].ToString(),new Font(fonts[r.Next(0,5)],20,FontStyle.Bold),new SolidBrush(colors[r.Next(0,5)]),p);
}
for (int i = 0; i < 10; i++)
{
Point p1 = new Point(r.Next(0,bmp.Width),r.Next(0,bmp.Height));
Point p2 = new Point(r.Next(0, bmp.Width), r.Next(0, bmp.Height));
Point p3 = new Point(r.Next(0, bmp.Width), r.Next(0, bmp.Height));
Point p4 = new Point(r.Next(0, bmp.Width), r.Next(0, bmp.Height));
g.DrawLine(new Pen(Brushes.BlueViolet), p1, p2);
g.DrawLine(new Pen(Brushes.OrangeRed), p3, p4);
}
//添加一些像素点
for (int i = 0; i < 500; i++)
{
Point p = new Point(r.Next(0, bmp.Width), r.Next(0, bmp.Height));
bmp.SetPixel(p.X, p.Y, Color.Black);
}
//将图片镶嵌到picturebmp中
pictureBox1.Image = bmp;
}
130.
【常规的hellow world】用vs控制台打开