精华内容
下载资源
问答
  • C#五子棋练手小项目源码,控制台五子棋游戏,包括棋盘绘图,棋子布局,键盘控制下棋子,分两个玩家,控制台显示,可以作为初学者练习代码功底
  • C#练手小案例

    2021-04-14 14:51:54
    前言 本文是将 C# 语言基础中一些易错的知识点结合案例的方式进行讲解,不会全面而细致地对 C# 语法进行阐述。示例代码均是在主函数中书写,因此部分案例省略了 C# 程序框架的部分内容。

    前言

    本文是将 C# 语言基础中一些易错的知识点结合案例的方式进行讲解,不会全面而细致地对 C# 语法进行阐述。示例代码均是在主函数中书写,因此部分案例省略了 C# 程序框架的部分内容。

    1.数据类型的转换

    /*
    	在 C# 语言中默认的整型是 int 类型,比 int 小的整形数据类型会自动转换为 int
    */
    byte number01 = 1;
    short number02 = 2;
    //类型自动提升为 int,想要赋值给 short 型需要强制类型转换
    short number03 = (short)(number01 + number02); //强制类型转换
    int number04 = number01 + number02;
    
    /*
    	遇到比 int 型更大的数据类型进行计算时,int 型会自动转换为相应类型
    	将占用字节数少的数据向占用字节数多的类型转换是一种显式转换,是自动进行的
    	将占用字节数多的数据向占用字节数少的类型转换是一种隐式转换,一般需要强制类型转换
    	int a3 = a1 + a2; 先将 a1 类型转换,使 a1,a2 具有相同的数据类型,然后再进行运算
    */
    int a1 = 1;
    long a2 = 2;
    long a3 = a1 + a2;
    
    int b1 = 1;
    float b2 = 1.0f;
    float b3 = b1 + b2;
    
    /*
    	快捷运算符,不做自动类型提升(常用的快捷运算符:+=、-=、*=、/=、%=、++、--)
    */
    byte b = 1;
    b = (byte)(b + 3); //类型自动提升
    b += 3; 
    
    /*
    	C# 语言中默认的浮点型是 double 类型。如果变使用单精度浮点型,需要在数值后面加上 f 或者 F 来表示
    */
    float c1 = 1.0f; //float c1 = 1.0; 报错:无法将 double 隐式转换为 float
    double c2 = 2.0;
    

    2.算术运算符的使用

    案例要求:使用 /% 运算符来取得数字 1234 中的千位、百位、十位、个位的值。

        class Program
        {
            static void Main(string[] args)
            {
                int number = 1234;
                Console.WriteLine("千位为:" + number / 1000);
                Console.WriteLine("百位为:" + number / 100 % 10);
                Console.WriteLine("十位为:" + number / 10 % 10);
                Console.WriteLine("个位为:" + number % 10);   
            }
        }
    

    3.赋值运算符的易错点

    案例要求:定义两个变量,并将两个变量的值交换后输出。

    class Program
    {
       static void Main(string[] args)
       {
           int a = 100;
           int b = 200;
           Console.WriteLine("交换前:");
           Console.WriteLine("a = " + a + ",b = " + b);
           int temp = a;
           a = b;
           b = temp;
           Console.WriteLine("交换后:");
           Console.WriteLine("a = " + a + ",b = " + b);
       }
    }
    

    方法拓展:

    //通过“加和再减”的方式实现
    class Program
    {
        static void Main(string[] args)
        {
            int a = 100;
            int b = 200;
            Console.WriteLine("交换前:");
            Console.WriteLine("a = " + a + ",b = " + b);
            a = a + b;
            b = a - b; //需要知道这里使用的 a 通过上面的赋值已经不再是 100
            a = a - b;
            Console.WriteLine("交换后:");
            Console.WriteLine("a = " + a + ",b = " + b);
        }
    }
    
    //同一个数如果用 2 次异或操作则数值保持不变 a == a ^ b ^ b;
    class Program
    {
        static void Main(string[] args)
        {
            int a = 100;
            int b = 200;
            Console.WriteLine("交换前:");
            Console.WriteLine("a = " + a + ",b = " + b);
            a = a ^ b;
            b = a ^ b;
            a = a ^ b;
            Console.WriteLine("交换后:");
            Console.WriteLine("a = " + a + ",b = " + b);
        }
    }
    
    运算符
    说明
    & 按位与。两个运算数都为 1,则整个表达式为 1,否则为 0;也可以对布尔型的值进行比较,相当于“与”运算,但不是短路运算
    | 按位或。两个运算数都为 0,则整个表达式为 0,否则为 1;也可以对布尔型的值进行比较,相当于“或”运算,但不是短路运算
    ~ 按位非,当被运算的值为 1 时,运算结果为 0;当被运算的值为 0 时,运算结果为 1。该操作符不能用于布尔型。对正整数取反,则在原来的数上加 1,然后取负数:对负整数取反,则在原来的数上加 1,然后取绝对值
    ^ 按位异或只有运算的两位不同结果才为 1,否则为 0
    << 左移。把运算符左边的操作数向左移动运算符右边指定的位数,右边因移动空岀的部分补 0
    >> 有符号右移。把运算符左边的操作数向右移动运算符右边指定的位数。如果是正值,左侧因移动空出的部分补 0;如果是负值,左侧因移动空出的部分补 1
    >>> 无符号右移。和 >> 的移动方式一样,只是不管正负,因移动空出的部分都补 0

    4.if-else 的使用

    案例要求:使用 if 语句判断从控制台输入的整数是否为偶数。

    //从控制台输入的值是字符串类型,因此需要将字符串类型的值转换成整数型
    //转换是通过“int.Parse(Console.ReadLine())”语句实现的
    class Program
    {
    	static void Main(string[] args)
    	{
    	    Console.WriteLine("请输入一个整数:");
    	    int num = int.Parse(Console.ReadLine());
    	    string msg = num + "不是偶数!";
    	    if (num % 2 == 0)
    	    {
    	        msg = num + "是偶数!";
    	    }
    	    Console.WriteLine(msg);
    	}
    }
    

    5.switch case 语句

    案例要求:使用 switch…case 语句根据学生的考试成绩来判断等级,如果成绩在 90 分以上是优秀;如果成绩为 80~90 分是良好;如果成绩为 60~80 分是及格,如果成绩在 60 分以下是不及格。

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入考生成绩(0~100):");
            int grade = int.Parse(Console.ReadLine());
            if (grade<0||grade>100)
            {
                grade = 0;
            }
            switch (grade / 10)
            {
                case 10:
                case 9:
                    Console.WriteLine("优秀");
                    break;
                case 8:
                    Console.WriteLine("良好");
                    break;
                case 7:
                case 6:
                    Console.WriteLine("及格");
                    break;
                default:
                    Console.WriteLine("不及格");
                    break;
            }
        }
    }
    

    6.for 循环的使用

    案例要求:打印九九乘法表。

    class Program
    {
        static void Main(string[] args)
        {
            for (int i = 1; i < 10; i++)
            {
                for (int j = 1; j <= i; j++)
                {
                    Console.Write(i + "x" + j + "=" + i * j + "\t");
                }
                Console.WriteLine();
            }
        }
    }
    

    实现效果:
    在这里插入图片描述
    更新中。。。

    展开全文
  • C# KTV项目 练手

    2017-12-21 23:15:52
    C# KTV项目 练手
  • C#练手项目10-1之正义永不缺席

    千次阅读 2020-11-20 20:47:07
    C#实例练手之test10-1 ————2020/11/20 写作目的:相互学习交流,提供实例,练习C#,有啥问题,可以直接留言,也可以加我vx:poyeezy996. 目标题目: 1.参照P209例8.7进行实验,要求用到抽象...
    										C#实例练手之test10-1
    																				————2020/11/20
    

    写作目的:相互学习交流,提供实例,练习C#,有啥问题,可以直接留言,也可以加我vx:poyeezy996.

    目标题目:
    1.参照P209例8.7进行实验,要求用到抽象类以及抽象方法。
    2. 定义玩家类(Player)、枪类(Gun)。以及派生于玩家类的警察类(Police)
    和坏人类(Robber),派生于枪类的手枪类(Handgun)和机关枪类
    (MachineGun);
    3. 手枪类可以造成1点初始伤害值,并且发出的声音为“biubiu” 。机关枪类可
    以造成2点初始伤害值,发出的声音为“boomboom

    4. 警察类有初始20点血量,可以使用手枪对坏人射击,造成手枪的伤害值的伤害,
    也可以选择前进一步,使得手枪伤害值提高100%;坏人类有初始20点血量,可
    以使用机关枪对警察射击,造成机关枪的伤害值的伤害,也可以选择前进一步,
    使得机关枪伤害值提高50%。
    5. 在Main函数中循环坏人与警察进行选择判断,分别轮流输入数字进行操作。前
    进增加伤害:1,开枪造成伤害:2。
    6. 直至一方血量低于0,结束游戏。

    目标生成内容:在这里插入图片描述
    思路讲解
    这一个题目涉及到的知识点其实吧,很简单。
    1.抽象类以及抽象方法
    (首先来看看抽象类和抽象方法是什么呢)
    自己看书或者百度吧,记得抽象类不能实例化就行了。
    1.1基本语法
    1.1.1
    抽象类:

    abstarct class 类名{
    	//声明类成员
    }
    

    1.1.2
    抽象方法:

    abstract [修饰符] 返回值类型 方法名 ([形参列表];
    

    2.定义基类和派生类

    using System;
    
    namespace test10_1
    {
        public abstract class Player
        {
            public int hp;   //血量
            public abstract void forward();
        public Player(int hp) { this.hp = hp; }
        }
    
        class Police : Player
        {
            public override void forward()
            {
                Console.WriteLine("前进1步,伤害提升100%");    
            } 
            public Police(int hp=20) : base(hp) { }//定义初始值
        }
    
        class Robber : Player
        {   
            public override void forward()
            {
                Console.WriteLine("前进1步,伤害提升50%"); 
            }       
            public Robber(int hp=20) : base(hp) { }
        }
    
    
        abstract class Gun
        {
            public string voice;
            public double damage;
            public abstract void shoot();
            public Gun(string voice,double damage) { this.voice = voice;this.damage = damage; }
        }
    
        class Handgun:Gun
        {
            public override void shoot()
            {
                Console.Write("警察使用手枪向坏人射击。");
            }
            public Handgun(string voice="biu~biu", double damage=1) : base(voice,damage) { }
        }
        class Machinegun : Gun
        {
            public override void shoot()
            {
                Console.Write("坏人使用手枪向警察射击。");
            }
            public Machinegun(string voice="boom~boom", double damage=2) : base(voice,damage) { }
        }
    
    
    

    对于上面的代码,根据题目要求,基类有Player、Gun,派生类分别是Police、Robber;Handgun、Machinegun.
    要完成动作,前进和射击的功能,我们在基类中分别定义抽象方法forward、shoot,在派生类中,对抽象方法重写,并对属性给定默认值,接下来对后面的对象创建,我们就可以不用给定值了
    3.处理逻辑
    这里是带佬给出来的思路
    在这里插入图片描述
    图都有了,自己看呗,不会留言区见。
    于是我们就处理一下下面的逻辑问题。

      class testprogram
        {
            static void Main()
            {
                int i;
                int people=1;
                Police pc = new Police();
                Robber rb = new Robber();
                Handgun hg = new Handgun();
                Machinegun mg = new Machinegun();
                Console.WriteLine("警察共有"+pc.hp+"滴血,射击一次造成"+hg.damage+"伤害");
                Console.WriteLine("坏人共有" + rb.hp + "滴血,射击一次造成" + mg.damage + "伤害");
                Console.WriteLine("开始游戏:");
    			while (pc.hp > 0 && rb.hp > 0)
    			{
                    if (people % 2 != 0)
                    {
                        Console.Write("坏人选择操作:1:前进1步,伤害提高50%;2:射击,造成"+ mg.damage +"点伤害。请选择:");
                        i = Convert.ToInt32(Console.ReadLine());
                        switch (i)
                        {
                            case 1:
                                rb.forward();
                                mg.damage *= 1.5;
                                people += 1;
                                break;
                            case 2:
                                mg.shoot();
                                Console.WriteLine(mg.voice);
                                pc.hp -= (int)mg.damage;
                                if(pc.hp<=0){Console.WriteLine("警察死亡!");}
                                else{
                                Console.WriteLine("警察受到" + mg.damage + "点伤害,还剩" + pc.hp + "血");
                                }
                                people += 1;
                                break;
                        }
                    }
    
                    else if (people % 2 == 0)
                    {
                        Console.Write("警察选择操作:1:前进1步,伤害提高100%;2:射击,造成"+ hg.damage +"点伤害。请选择:");
                        i = Convert.ToInt32(Console.ReadLine());
                        switch (i)
                        {
                            case 1:
                                pc.forward();
                                hg.damage *= 2;
                                people += 1;
                                break;
                            case 2:
                                hg.shoot();
                                Console.WriteLine(hg.voice);
                                rb.hp -= (int)hg.damage;
                                if (rb.hp <= 0) { Console.WriteLine("坏人死亡!"); }
                                else { 
                                Console.WriteLine("坏人受到" + hg.damage + "点伤害,还剩" + rb.hp + "血");
                                }
                                people += 1;
                                break;
                        }
                    }   
                }
            Console.ReadLine();
            }
            
        }
    }
    
    

    ps:上面两行代码在一起才能运行哦
    嗯哼,首先定义一个i作为派生类在行动时的选择;people作为后面判定该谁进行选择用。
    直接看,while一个都不能死,死了就不玩了。
    if看到谁行动了
    switch看选择啥选择中,把伤害算一下,people要累加。单数时坏人,双数是jc
    于是代码就这样:你一枪我一枪的,演起来了电视桥段,最终正义或许回来迟,但是他永远不会缺席。
    在这里插入图片描述
    PS:我可真想把这玩意放到无限大.
    今天完。

    展开全文
  • 配合Winform窗体界面,实现了简单的窗体间互相通信的小项目(可以互相发消息,服务器可以给客户端发送文件和震动弹出)。 现在把这两天学习到的知识点记录下来分享。。。 首先要声明:本篇博客并不会详细的讲解...

    在公司花了两天的时间来研究Socket编程,感觉也还是学到了一点点皮毛,不过也还是有一点点的小成就。

    配合Winform窗体界面,实现了简单的窗体间互相通信的小项目(可以互相发消息,服务器可以给客户端发送文件和震动弹出)。

    现在把这两天学习到的知识点记录下来分享。。。

    首先要声明:本篇博客并不会详细的讲解Socket底层的实现逻辑,只是讲解他是怎么运用的,是怎么实现窗体间通信的。


    Socket的简单原理

    Socket的两个概念:端口协议

    端口

    我们是通过服务端去访问应用程序的,但是在同一个服务端中的应用程序,他们的IP地址都是一样的,所以单单通过IP地址去访问对应的应用程序是不可能的,所以,得再结合端口去实现具体的访问。
    每个应用程序就会有一个端口,我们就可以根据IP地址和端口号去实现访问了。(每个应用程序的端口号都是唯一的)

    在这里插入图片描述

    通过端口和IP地址客户端就可以准确无误的去访问服务器里面的应用程序了。

    在访问的过程中,又会涉及到协议的问题!

    协议

    Socket有两个协议:TCPUDP

    TCP

    其中我们要知道,TCP协议是网络上比较安全稳定的协议,一般不会发送数据丢失。使用TCP协议建立网络连接,需要经过“三次握手”才建立连接。如下图:
    在这里插入图片描述
    只有客户端和服务器完成了这三次握手的过程,服务器才会和客户端进行数据的传输。(只要是少了一次都不会进行互相通信)

    TCP建立网络连接的优缺点:

    1. 优点:安全,稳定,防止数据丢失。
    2. 缺点:效率低,经过三次握手的过程,需要耗费一定的时间。

    UDP

    UDP协议是与TCP协议相反的。

    UDP协议不管服务器有没有空,就是一直给服务器发送消息,直到发完为止。他不管服务器有没有接收到,他只是要完成任务就行。
    在这里插入图片描述

    如果服务器很忙的话,并没有时间去处理客户端发过来的消息,那么就会造成数据丢失。

    UDP建立网络连接的优缺点:

    1. 优点:快速,效率高。
    2. 缺点:不稳定,容易造成数据丢失。

    两个协议各有的优缺点,也不好说哪个比较好。
    像UDP协议一般用于视频的传输等。

    好了TCP/UDP协议了解到这里就好了!


    Socket

    需要包含命名空间:
    using System.Net;
    using System.Net.Sockets;

    一个服务器至少有两个Socket用于通信,一个用来监听,一个用来连接客户端进行通信。

    我们先看一张图:
    在这里插入图片描述
    这张图描述的就是客户端和服务其进行互相通信的过程。
    下面的讲解也是根据这张图来说明。

    1. Socket
      他是一个类,用来定义对象进行通信。
      首先创建一个用于监听的Socket(监听有没有客户端连接服务器)
      如代码:
    // 一个负责监听的Socket ************************************************************************
    								// ip地址的类型(ipV4/ipv6)   选择以流的方式     流对应的是Tcp协议
    Socket socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    

    参数一:填写IP地址的类型(ipv4:InterNetwork; ipv6:InterNetworkV6)

    参数二:填写TCP/UDP连接对应的方式
    补充知识点:TCP是以的方式(Stream);UDP是以数据报的方式(Dgram)。

    参数三:填写TCP/UDP协议
    这里就用了TCP的传输方式。

    然后创建ip地址和端口号对象:

    // 创建ip地址和端口号对象     
    IPAddress iPAddress = IPAddress.Any; //IPAddress.Parse(this.txtSever.Text);
    IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, Convert.ToInt32(this.txtPort.Text));
    

    Any是自动获取连接进行的客户端的IP地址。
    端口号是获取我们textBox控件里面的。

    1. Bind
      绑定监听端口

      // 让负责监听的Socket绑定IP地址和端口号
      socketWatch.Bind(iPEndPoint);
      

      到了这里,就完成了监听的工作。

    2. Listen
      设置监听队列
      在同一个时间段允许最大的连接个数

      // 设置监听队列(比如在同一个时间段允许最大的连接个数)
      socketWatch.Listen(10);
      

      比如在一秒内最多允许10个客户端连接服务器,从第11个客户端往后都得排队等待连接。

    3. Accept
      该函数用于等待客户端与服务器进行连接,并返回一个新的Socket,用于与客户端进行通信。

       // 负责监听的Socket来接受客户端的连接(创建跟客户端通信的Socket)
       Socket  socket = socketWatch.Accept();   // Accept() : 等待客户端连接
      

      利用死循环可以一直与多个客户端进行连接
      为了不卡死主线程,可以使用多线程对其进行操作!

       // 该线程的作用是:服务器不停的监听,等待客户端连接,并且创建与之通信用的Socket
      Thread th = new Thread(Listen);
      th.IsBackground = true;
      th.Start(socketWatch);
      
      private void Listen(Object o) {
      	Socket socketWatch = o as Socket;
      
      	// 等待客户端连接,并且创建与之通信用的Socket
      	while (true) {
      		// 负责监听的Socket来接受客户端的连接(创建跟客户端通信的Socket)
      		Socket socket= socketWatch.Accept();   // Accept() : 等待客户端连接                
      	}
             
      }
      
    4. Receive
      获取客户端发过来的消息(单位:byte)

      // 客户端连接成功后,服务器接收客户端发来的消息
      byte[] buffer = new byte[1024 * 1024 * 2];
      // b:实际接收到的有效字节数    
      int b = socket.Receive(buffer); // 调用Receive函数返回客户端发来的消息(单位:字节)
      

      可以根据b来判断客户端发过来的消息的字节个数。

    5. Send
      服务器给客户端发送消息

      仅支持字节发送数组发送

      byte[] newByte = Encoding.UTF8.GetBytes("我是服务器");
      socket.Send(newByte);
      

    好了,服务器的流程基本上就这样了。

    客户端与服务端雷同,就不演示了。




    练手小项目

    可能讲的不是很好,但是没关系,我把我自己写好的代码上传到此给需要的朋友玩一下。(可以实现两个窗口间互相通信)

    界面如下:

    服务器:
    在这里插入图片描述
    客户端:
    在这里插入图片描述

    代码如下:
    服务器

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.IO;
    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 _Socket {
        public partial class Form1 : Form {
            public Form1() {
                InitializeComponent();
            }
    
            private void Form1_Load(object sender, EventArgs e) {
                Control.CheckForIllegalCrossThreadCalls = false;
            }
    
            private void btnStart_Click(object sender, EventArgs e) {
                try {
                    // 一个负责监听的Socket ************************************************************************
                    // ip地址的类型(ipV4/ipv6)   选择以流的方式     流对应的是Tcp协议
                    Socket socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    
                    // 创建ip地址和端口号对象     
                    IPAddress iPAddress = IPAddress.Any; //IPAddress.Parse(this.txtSever.Text);
                    IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, Convert.ToInt32(this.txtPort.Text));
    
                    // 让负责监听的Socket绑定IP地址和端口号
                    socketWatch.Bind(iPEndPoint);
    
                    ShowMsg("监听成功!");
    
                    // 设置监听队列(比如在同一个时间段允许最大的连接个数)
                    socketWatch.Listen(10);
    
    
                    // 该线程的作用是:服务器不停的监听,等待客户端连接,并且创建与之通信用的Socket
                    Thread th = new Thread(Listen);
                    th.IsBackground = true;
                    th.Start(socketWatch);
                }
                catch (Exception) {  }
                  
            }
    
    
            // 存储连接服务器的客户端的IP地址/端口号和负责通信的socket
            Dictionary<string, Socket> dictionary = new Dictionary<string, Socket>();
    
    
            Socket socket;  // 负责通信
            private void Listen(Object o) {
                Socket socketWatch = o as Socket;
    
                // 等待客户端连接,并且创建与之通信用的Socket
                while (true) {
                    try {
                        // 负责监听的Socket来接受客户端的连接(创建跟客户端通信的Socket)
                        socket = socketWatch.Accept();   // Accept() : 等待客户端连接
                        // 将连接成功后的客户端IP地址和端口号显示出来
                        ShowMsg(socket.RemoteEndPoint.ToString() + "连接成功\r\n");
    
                        // 将远程连接的客户端的IP地址和socket存入集合中
                        dictionary.Add(socket.RemoteEndPoint.ToString(), socket);
    
                        // 将远程连接的客户端的IP地址和端口号存储到下拉框中
                        this.cobUsers.Items.Add(socket.RemoteEndPoint.ToString());
    
                        // 该线程的作用是:使服务器不停的接收客户端发过来的消息
                        Thread th = new Thread(Recive);
                        th.IsBackground = true;
                        th.Start(socket);
                    }
                    catch (Exception) {  }
                             
                }
               
            }
    
    
            // 服务器不停的接收客户端发过来的消息
            private void Recive(Object o) {
                Socket socket = o as Socket;
    
                while (true) {
                    try {
                        // 客户端连接成功后,服务器接收客户端发来的消息
                        byte[] buffer = new byte[1024 * 1024 * 2];
                        // b:实际接收到的有效字节数    
                        int b = socket.Receive(buffer); // 调用Receive函数返回客户端发来的消息(单位:字节)
    
                        // 用户点击了叉×
                        if (b == 0) {
                            break;
                        }
    
                        // 将其转为人能看得懂的字符串类型
                        string str = Encoding.UTF8.GetString(buffer, 0, b);
                        ShowMsg(socket.RemoteEndPoint.ToString() + "(客户端):" + str);  // 显示出来
                    }
                    catch (Exception) { }
                    
                }
            }
    
            private void ShowMsg(string str) {
                this.txtLog.AppendText(str + "\r\n");
            }
    
    
            private void btnSend_Click(object sender, EventArgs e) {
    
                try {
                    // 获取文本的值并转换为byte类型数组
                    byte[] by = Encoding.UTF8.GetBytes(this.txtMsg.Text.Trim());
                    this.txtMsg.Text = "";
    
                    // 定义一个泛型集合,将文本表示符0 和 byte数组存储入集合中
                    List<byte> list = new List<byte>();
                    list.Add(0);
                    list.AddRange(by);
    
                    // 将泛型集合转换为数组
                    byte[] newByte = list.ToArray();
                    
    
                    // 服务器给客户端发送消息
                    //socket.Send(by);
                    string ip = this.cobUsers.SelectedItem.ToString();  // 获得下拉框中选中项的IP地址和端口号
                    dictionary[ip].Send(newByte);    // 将其传入Dictionary中获得跟客户端通信的socket
                }
                catch (Exception) {  }
                
            }
    
            // 选择需要发送的文件
            private void btnSelect_Click(object sender, EventArgs e) {
    
                try {
                    OpenFileDialog ofd = new OpenFileDialog();
    
                    // 设置初始路径
                    ofd.InitialDirectory = @"C:\Users\yangg\Desktop";
                    ofd.Title = "请选择你需要发送的文件";
                    // 设置文件筛选
                    ofd.Filter = "所有文件|*.*";
    
                    if (ofd.ShowDialog() == DialogResult.OK) {
                        this.txtPath.Text = ofd.FileName;
                    }
                }
                catch (Exception) {  }
                
            }
    
            private void btnSentFile_Click(object sender, EventArgs e) {
    
                try {
                    // 获取文件路径
                    string path = this.txtPath.Text;
    
                    // 使用文件流以读的方式打开文件
                    using (FileStream fileRead = new FileStream(path, FileMode.Open, FileAccess.Read)) {
                        byte[] buffer = new byte[1024 * 1024 * 10];
    
                        // 将文件中的数据读取进字节数组中,返回读取到的个数
                        int r = fileRead.Read(buffer, 0, buffer.Length);
    
                        List<byte> list = new List<byte>();
                        list.Add(1);
                        list.AddRange(buffer);
    
                        byte[] newBuffer = list.ToArray();
    
                        // 发送
                        dictionary[this.cobUsers.SelectedItem.ToString()].Send(newBuffer, 0, r + 1, SocketFlags.None);
                    }
                }
                catch (Exception) {  }
                
            }
    
            private void btnZD_Click(object sender, EventArgs e) {
                byte[] buffer = new byte[1];
                buffer[0] = 2;
                dictionary[this.cobUsers.SelectedItem.ToString()].Send(buffer);
            }
    
        }
    }
    
    

    客户端

    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.IO;
    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 _Client {
        public partial class Form1 : Form {
            public Form1() {
                InitializeComponent();
            }
    
            Socket socket;
            private void btnStart_Click(object sender, EventArgs e) {
    
                try {
                    // 创建一个发送消息的Socket
                    socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    
                    // 建立IP地址和端口号的对象
                    IPAddress iPAddress = IPAddress.Parse(this.txtSever.Text);
                    IPEndPoint iPEndPoint = new IPEndPoint(iPAddress, Convert.ToInt32(this.txtPort.Text));
    
                    // 客户端服务器建立连接
                    socket.Connect(iPEndPoint);
    
                    Shows("连接成功!");
    
                    // 建立线程,无限的接收服务器发过来的消息
                    Thread th = new Thread(Recive);
                    th.IsBackground = true;
                    th.Start();
                }
                catch (Exception) {  }
                
            }
    
            private void Shows(string str) {
                this.txtLog.AppendText(str + "\r\n");
            }
    
            // 客户端给服务器发送消息
            private void benSend_Click(object sender, EventArgs e) {
    
                try {
                    // 获取待发送的文本,并转换为byte字节数组
                    byte[] by = Encoding.UTF8.GetBytes(this.txtMsg.Text.Trim());
                    this.txtMsg.Text = "";
    
                    // 客户端给服务器发送消息
                    socket.Send(by);
                }
                catch (Exception) {  }
                
            }
    
    
            // 不停的接收服务器发过来的消息
            private void Recive() {
    
                while (true) {
    
                    try {
                        byte[] by = new byte[1024 * 1024 * 10];
                        // 获取服务器发过来的消息,返回接收到的个数
                        int r = socket.Receive(by);
                        if (r == 0) {
                            break;
                        }
    
    
                        // 表示发送文字消息
                        if (by[0] == 0) {
                            string str = Encoding.UTF8.GetString(by, 1, r - 1);
                            Shows(socket.RemoteEndPoint.ToString() + "(服务器):" + str);
                           
                        } else if (by[0] == 1) {    // 表示发送文件
                            SaveFileDialog sfd = new SaveFileDialog();
                            sfd.InitialDirectory = @"C:\Users\yangg\Desktop";
                            sfd.Title = "请选择报错位置";
                            sfd.Filter = "所有文件|*.*";
    
                            
                            if (sfd.ShowDialog(this) == DialogResult.OK) {
                                string path = sfd.FileName;
    
                                using (FileStream fileWrite = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write)) {
                                    fileWrite.Write(by, 1, r - 1);                               
                                }
                                MessageBox.Show("保存成功");
                            }
                            
                        } else if (by[0] == 2) {    // 表示发送震动
                            ZD();
                        }
                    }
                    catch (Exception) {  }
                    
                }
                
            }
    
    
            // 震动
            private void ZD() {
                int x = this.Location.X;
                int y = this.Location.Y;
    
                for (int i = 0; i < 300; i++) {
                    this.Location = new Point(x - 50, y);
                    this.Location = new Point(x, y + 50);
                    this.Location = new Point(x + 50, y);
                    this.Location = new Point(x, y - 50);
                    
                }
    
                this.Location = new Point(x, y);
            }
    
            private void Form1_Load(object sender, EventArgs e) {
                Control.CheckForIllegalCrossThreadCalls = false;
            }
        }
    }
    
    

    CSDN:
    https://download.csdn.net/download/cpp_learner/12761444

    百度连接:
    链接:https://pan.baidu.com/s/16TE3Q51NhxMXNv2sp9gfcQ
    提取码:fc4n


    总结:
    也就基本上是这样了,其他的也就不会了,希望对大家有帮助吧!

    展开全文
  • 下面是文件加密和解密功能的代码 using System.Security.Cryptography;... public void EncryptFile(string filePath, string...完整项目下载地址: http://download.csdn.net/detail/wang03989/9620188


    下面是文件加密和解密功能的代码

    using System.Security.Cryptography;
    //加密
            public  void EncryptFile(string filePath, string savePath, string keyStr)
            {
                try
                {
                    //通过des加密  
                    DESCryptoServiceProvider des = new DESCryptoServiceProvider();
                    //通过流打开文件  
                    FileStream fs = File.OpenRead(filePath);
                    //获取文件二进制字符  
                    byte[] inputByteArray = new byte[fs.Length];
                    //读流文件  
                    fs.Read(inputByteArray, 0, (int)fs.Length);
                    //关闭流  
                    fs.Close();
                    //获得加密字符串二进制字符 
                    byte[] keyByteArray = Encoding.Default.GetBytes(keyStr);
                    //计算指定字节组指定区域哈希值  
                    SHA1 ha = new SHA1Managed();
                    byte[] hb = ha.ComputeHash(keyByteArray);
                    //加密密钥数组  
                    byte[] sKey = new byte[8];
                    //加密变量 
                    byte[] sIV = new byte[8];
                    for (int i = 0; i < 8; i++)
                        sKey[i] = hb[i];
                    for (int i = 8; i < 16; i++)
                        sIV[i - 8] = hb[i];
                    //获取加密密钥  
                    des.Key = sKey;
                    //设置加密初始化向量  
                    des.IV = sIV;
                    MemoryStream ms = new MemoryStream();
                    CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
                    cs.Write(inputByteArray, 0, inputByteArray.Length);
                    cs.FlushFinalBlock();
                    fs = File.OpenWrite(savePath);
                    foreach (byte b in ms.ToArray())
                    {
                        fs.WriteByte(b);
                    }
                    fs.Close();
                    cs.Close();
                    ms.Close();
                }
                catch
                {
                    System.Windows.Forms.MessageBox.Show("加密失败");
                    progressBar1.Value = 0;
                }

            }

    ----------------------------------------------------------------------------------------------------------------------------------------------

    //解密

            public  void DecryptFile(string filePath, string savePath, string keyStr)
            {
                try
                {
                    //通过des解密  
                    DESCryptoServiceProvider des = new DESCryptoServiceProvider();
                    //通过流读取文件  
                    FileStream fs = File.OpenRead(filePath);
                    //获取文件二进制字符  
                    byte[] inputByteArray = new byte[fs.Length];
                    //读取流文件  
                    fs.Read(inputByteArray, 0, (int)fs.Length);
                    //关闭流  
                    fs.Close();
                    //密钥数组 
                    byte[] keyByteArray = Encoding.Default.GetBytes(keyStr);
                    //定义哈希变量  
                    SHA1 ha = new SHA1Managed();
                    //计算指定字节组指定区域哈希值 
                    byte[] hb = ha.ComputeHash(keyByteArray);
                    //加密密钥数组 
                    byte[] sKey = new byte[8];
                    //加密变量  
                    byte[] sIV = new byte[8];
                    for (int i = 0; i < 8; i++)
                        sKey[i] = hb[i];
                    for (int i = 8; i < 16; i++)
                        sIV[i - 8] = hb[i];
                    //获取加密密钥  
                    des.Key = sKey;
                    //加密变量  
                    des.IV = sIV;
                    MemoryStream ms = new MemoryStream();
                    CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
                    cs.Write(inputByteArray, 0, inputByteArray.Length);
                    cs.FlushFinalBlock();
                    fs = File.OpenWrite(savePath);
                    foreach (byte b in ms.ToArray())
                    {
                        fs.WriteByte(b);
                    }
                    fs.Close();
                    cs.Close();
                    ms.Close();
                }


                catch
                {
                    System.Windows.Forms.MessageBox.Show("解密失败");
                    progressBar1.Value = 0;
                }
            }


    完整项目下载地址:

    http://download.csdn.net/detail/wang03989/9620188

    展开全文
  • ...测试小项目: 工程下载: http://download.csdn.net/detail/wang03989/9618807 gif操作类库 http://download.csdn.net/detail/wang03989/9618833
  • C#课后练手

    2019-10-03 12:43:29
    做了一个三局两胜的猜拳游戏,顺便帮自己回忆下,也为了更加熟练的运用C#基本代码 1 int user = 0 ; 2 int computer = 0 ; 3 for (; ; ) 4 { 5 6 Console.WriteLine( " 请输入手势...
  • 最近有越来越多做电气的伙伴开始学习C#来做上位机开发,很多人在学习一段时间后,都有这种感觉,似乎学到了很多知识,但是不知道怎么应用,因此我找了一个真实的上位机小项目,让大家来练练。这篇文章主要对这个...
  • 项目的流程如下: 1.检索文件 2.修改图片的尺寸比例成3:2 3.按3:2比例分割图片成一块块正方形 4.批量修改名字 5.按顺序名字把子图片合并完整的一张图 namespace ImageTool { class Program { private ...
  • 新手node入门,用这个小项目练练,写这篇文章也是为了自己巩固下知识。 先看效果图: 先是让用户输入名字 get yourself a nickname :) 输入好了之后进入,然后随便说点什么, 可以多个人在线聊天, 也可以上传...
  • 开始学习C#之路,起当然是小小计算器了,这个软件,包含了很多C#的精华,比如TextBox只处理数字和加减符号等,TextBox设置多行并一直显示最下面,编译生成更改自己的图标等......总之,麻雀虽小,五脏俱全!非常...
  • ​ 最近有越来越多做电气的伙伴开始学习C#来做上位机开发,很多人在学习一段时间后,都有这种感觉,似乎学到了很多知识,但是不知道怎么应用,因此我找了一个真实的上位机小项目,让大家来练练。这篇文章主要对...
  • C#练习小项目

    2011-12-20 20:12:06
    课程中的一些练习
  • 最近有越来越多做电气的伙伴开始学习C#来做上位机开发,很多人在学习一段时间后,都有这种感觉,似乎学到了很多知识,但是不知道怎么应用,因此我找了一个真实的上位机小项目,让大家来练练。这篇文章主要对这个...
  • c#自己做的小项目,适合练习

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,483
精华内容 2,193
关键字:

c#练手小项目

c# 订阅