C#聊天程序，包含发送文本消息、发送图片、发送小文件、抖动等功能；

实现C#聊天程序可以分为客户端和服务端两个部分。

首先是服务端的实现：

1. 创建一个服务器程序，用于接收客户端的连接请求，可以使用C#中Socket类库实现。

2. 为每个客户端连接创建一个独立的线程，用于接收客户端发送的消息并进行处理。

3. 使用TCP协议进行数据传输，可以通过发送JSON格式的数据来实现消息的发送与接收。

4. 在服务端实现发送图片、小文件等功能时，需要将文件进行二进制转换，然后进行传输。

接下来是客户端的实现：

1. 创建一个客户端程序，用于向服务端发送连接请求，也可以使用Socket类库实现。

2. 在客户端中实现文本消息的输入和发送，可以使用C#中的TextBox和Button控件实现。

3. 实现发送图片和小文件的功能，可以使用C#中的OpenFileDialog控件选择文件，然后进行二进制转换并发送给服务端。

4. 实现抖动功能时，可以在客户端中发送一个特殊的命令给服务端，服务端接收到该命令后向所有客户端发送一个震动的信号。

以上是简单的实现思路，具体实现过程中还需要考虑消息的加密和解密、用户身份验证等问题。

相关问题

编写C#聊天程序，包含发送文本消息、发送图片、发送小文件、抖动等功能；

以下是一个简单的 C# 聊天程序示例，包括发送文本消息、发送图片、发送小文件、抖动等功能。

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Windows.Forms;

namespace ChatProgram
{
    public partial class Form1 : Form
    {
        private const int PORT = 12345;
        private const int BUFFER_SIZE = 1024;

        private TcpClient client;
        private NetworkStream stream;
        private byte[] buffer = new byte[BUFFER_SIZE];

        public Form1()
        {
            InitializeComponent();
        }

        private void btnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                client = new TcpClient(txtServer.Text, PORT);
                stream = client.GetStream();
                AppendText("Connected to server.");
                btnConnect.Enabled = false;
                btnDisconnect.Enabled = true;
                btnSend.Enabled = true;
                txtMessage.Enabled = true;
                btnSendFile.Enabled = true;
                btnSendImage.Enabled = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void btnDisconnect_Click(object sender, EventArgs e)
        {
            try
            {
                stream.Close();
                client.Close();
                AppendText("Disconnected from server.");
                btnConnect.Enabled = true;
                btnDisconnect.Enabled = false;
                btnSend.Enabled = false;
                txtMessage.Enabled = false;
                btnSendFile.Enabled = false;
                btnSendImage.Enabled = false;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void btnSend_Click(object sender, EventArgs e)
        {
            try
            {
                string message = txtMessage.Text.Trim();
                if (!string.IsNullOrEmpty(message))
                {
                    byte[] data = Encoding.Unicode.GetBytes(message);
                    stream.Write(data, 0, data.Length);
                    AppendText("You: " + message);
                    txtMessage.Clear();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void btnSendFile_Click(object sender, EventArgs e)
        {
            try
            {
                OpenFileDialog dialog = new OpenFileDialog();
                dialog.Filter = "All Files (*.*)|*.*";
                if (dialog.ShowDialog() == DialogResult.OK)
                {
                    FileInfo fileInfo = new FileInfo(dialog.FileName);
                    byte[] fileNameData = Encoding.Unicode.GetBytes(fileInfo.Name);
                    byte[] fileData = File.ReadAllBytes(dialog.FileName);
                    byte[] data = new byte[8 + fileNameData.Length + fileData.Length];
                    BitConverter.GetBytes(fileNameData.Length).CopyTo(data, 0);
                    fileNameData.CopyTo(data, 8);
                    fileData.CopyTo(data, 8 + fileNameData.Length);
                    stream.Write(data, 0, data.Length);
                    AppendText("You sent a file: " + fileInfo.Name);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void btnSendImage_Click(object sender, EventArgs e)
        {
            try
            {
                OpenFileDialog dialog = new OpenFileDialog();
                dialog.Filter = "Image Files (*.bmp;*.jpg;*.gif)|*.bmp;*.jpg;*.gif";
                if (dialog.ShowDialog() == DialogResult.OK)
                {
                    Image image = Image.FromFile(dialog.FileName);
                    MemoryStream ms = new MemoryStream();
                    image.Save(ms, image.RawFormat);
                    byte[] imageData = ms.ToArray();
                    byte[] data = new byte[4 + imageData.Length];
                    BitConverter.GetBytes(imageData.Length).CopyTo(data, 0);
                    imageData.CopyTo(data, 4);
                    stream.Write(data, 0, data.Length);
                    AppendText("You sent an image: " + dialog.FileName);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void btnShake_Click(object sender, EventArgs e)
        {
            try
            {
                byte[] data = Encoding.Unicode.GetBytes("shake");
                stream.Write(data, 0, data.Length);
                AppendText("You sent a shake.");
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            btnDisconnect.Enabled = false;
            btnSend.Enabled = false;
            txtMessage.Enabled = false;
            btnSendFile.Enabled = false;
            btnSendImage.Enabled = false;
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (client != null && client.Connected)
            {
                stream.Close();
                client.Close();
            }
        }

        private void AppendText(string text)
        {
            if (txtChat.InvokeRequired)
            {
                txtChat.Invoke(new Action<string>(AppendText), text);
            }
            else
            {
                txtChat.AppendText(text + Environment.NewLine);
            }
        }

        private void ReceiveData()
        {
            int bytesRead = 0;
            while (true)
            {
                try
                {
                    bytesRead = stream.Read(buffer, 0, BUFFER_SIZE);
                    string message = Encoding.Unicode.GetString(buffer, 0, bytesRead);
                    if (message == "shake")
                    {
                        PerformShake();
                    }
                    else if (bytesRead > 0)
                    {
                        if (message.StartsWith("file:"))
                        {
                            int fileNameLength = BitConverter.ToInt32(buffer, 0);
                            string fileName = Encoding.Unicode.GetString(buffer, 8, fileNameLength);
                            byte[] fileData = new byte[bytesRead - 8 - fileNameLength];
                            Array.Copy(buffer, 8 + fileNameLength, fileData, 0, fileData.Length);
                            string filePath = Path.Combine(Path.GetTempPath(), fileName);
                            File.WriteAllBytes(filePath, fileData);
                            AppendText("Friend sent a file: " + filePath);
                        }
                        else if (message.StartsWith("image:"))
                        {
                            int imageDataLength = BitConverter.ToInt32(buffer, 0);
                            byte[] imageData = new byte[imageDataLength];
                            Array.Copy(buffer, 4, imageData, 0, imageDataLength);
                            Image image = Image.FromStream(new MemoryStream(imageData));
                            picImage.Image = image;
                            AppendText("Friend sent an image.");
                        }
                        else
                        {
                            AppendText("Friend: " + message);
                        }
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                    break;
                }
            }
        }

        private void PerformShake()
        {
            int x = Location.X;
            int y = Location.Y;
            for (int i = 0; i < 10; i++)
            {
                Location = new System.Drawing.Point(x + 5, y + 5);
                System.Threading.Thread.Sleep(50);
                Location = new System.Drawing.Point(x - 5, y - 5);
                System.Threading.Thread.Sleep(50);
            }
            Location = new System.Drawing.Point(x, y);
        }

        private void txtMessage_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                btnSend.PerformClick();
            }
        }

        private void Form1_Shown(object sender, EventArgs e)
        {
            try
            {
                TcpListener listener = new TcpListener(IPAddress.Any, PORT);
                listener.Start();
                AppendText("Waiting for connection...");
                client = listener.AcceptTcpClient();
                stream = client.GetStream();
                AppendText("Connected to friend.");
                btnConnect.Enabled = false;
                btnDisconnect.Enabled = true;
                btnSend.Enabled = true;
                txtMessage.Enabled = true;
                btnSendFile.Enabled = true;
                btnSendImage.Enabled = true;
                ReceiveData();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
    }
}

该示例使用了 TCP/IP 协议进行通信，可以通过发送文本消息、发送图片、发送小文件、抖动等功能与远程主机进行交互。注意，该示例仅供参考，实际应用中需要根据具体需求进行修改和优化。

编写WinForm程序，包含发送文本消息、图片、小文件以及抖动等功能

以下是一个简单的WinForm程序，包含发送文本消息、图片、小文件以及抖动等功能。其中，发送文本消息和图片使用了C#的Socket编程，发送小文件使用了C#的File类，抖动功能使用了C#的System.Windows.Forms.Timer类。需要注意的是，该程序只是一个示例，具体情况需要根据自己的实际需求进行修改。

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Windows.Forms;

namespace WinFormChat
{
    public partial class Form1 : Form
    {
        // 定义Socket对象
        private Socket clientSocket;

        // 定义接收消息的线程
        private Thread receiveThread;

        // 定义抖动计时器
        private Timer shakeTimer;

        // 定义接收缓冲区大小
        private const int receiveBufferSize = 1024;

        // 定义发送缓冲区大小
        private const int sendBufferSize = 1024;

        // 定义消息结束标志
        private const string messageEndFlag = "<EOF>";

        public Form1()
        {
            InitializeComponent();
        }

        // 连接服务器按钮事件处理函数
        private void btnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                // 创建Socket对象
                clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                // 连接服务器
                clientSocket.Connect(txtServerIP.Text, Convert.ToInt32(txtServerPort.Text));

                // 启动接收消息的线程
                receiveThread = new Thread(ReceiveMessage);
                receiveThread.IsBackground = true;
                receiveThread.Start();

                // 设置抖动计时器
                shakeTimer = new Timer();
                shakeTimer.Interval = 100;
                shakeTimer.Tick += ShakeTimer_Tick;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        // 发送文本消息按钮事件处理函数
        private void btnSendText_Click(object sender, EventArgs e)
        {
            try
            {
                // 获取发送文本消息
                string message = txtMessage.Text.Trim();

                // 发送消息
                SendMessage(message);

                // 清空文本框
                txtMessage.Text = "";
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        // 发送图片按钮事件处理函数
        private void btnSendImage_Click(object sender, EventArgs e)
        {
            try
            {
                // 打开文件对话框
                OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.Filter = "图片文件|*.jpg;*.jpeg;*.png;*.bmp";
                openFileDialog.RestoreDirectory = true;
                if (openFileDialog.ShowDialog() == DialogResult.OK)
                {
                    // 获取图片文件名和路径
                    string fileName = Path.GetFileName(openFileDialog.FileName);
                    string filePath = openFileDialog.FileName;

                    // 发送消息头
                    string messageHeader = "Image|" + fileName + "|";
                    byte[] headerBytes = Encoding.UTF8.GetBytes(messageHeader);
                    clientSocket.Send(headerBytes);

                    // 发送图片数据
                    byte[] buffer = new byte[sendBufferSize];
                    using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
                    {
                        int bytesRead = 0;
                        while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            clientSocket.Send(buffer, bytesRead, SocketFlags.None);
                        }
                    }

                    // 发送消息结束标志
                    byte[] endBytes = Encoding.UTF8.GetBytes(messageEndFlag);
                    clientSocket.Send(endBytes);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        // 发送小文件按钮事件处理函数
        private void btnSendFile_Click(object sender, EventArgs e)
        {
            try
            {
                // 打开文件对话框
                OpenFileDialog openFileDialog = new OpenFileDialog();
                openFileDialog.RestoreDirectory = true;
                if (openFileDialog.ShowDialog() == DialogResult.OK)
                {
                    // 获取文件名和路径
                    string fileName = Path.GetFileName(openFileDialog.FileName);
                    string filePath = openFileDialog.FileName;

                    // 发送消息头
                    string messageHeader = "File|" + fileName + "|";
                    byte[] headerBytes = Encoding.UTF8.GetBytes(messageHeader);
                    clientSocket.Send(headerBytes);

                    // 发送文件数据
                    byte[] buffer = new byte[sendBufferSize];
                    using (FileStream fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
                    {
                        int bytesRead = 0;
                        while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            clientSocket.Send(buffer, bytesRead, SocketFlags.None);
                        }
                    }

                    // 发送消息结束标志
                    byte[] endBytes = Encoding.UTF8.GetBytes(messageEndFlag);
                    clientSocket.Send(endBytes);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        // 抖动按钮事件处理函数
        private void btnShake_Click(object sender, EventArgs e)
        {
            try
            {
                // 启动抖动计时器
                shakeTimer.Start();

                // 发送抖动消息
                string message = "Shake|";
                SendMessage(message);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        // 接收消息函数
        private void ReceiveMessage()
        {
            while (true)
            {
                try
                {
                    // 接收消息头
                    byte[] headerBytes = new byte[receiveBufferSize];
                    int bytesReceived = clientSocket.Receive(headerBytes);
                    string messageHeader = Encoding.UTF8.GetString(headerBytes, 0, bytesReceived);

                    // 解析消息头
                    string[] messageHeaderParts = messageHeader.Split('|');
                    string messageType = messageHeaderParts[0];
                    string messageFileName = "";
                    if (messageHeaderParts.Length > 1)
                    {
                        messageFileName = messageHeaderParts[1];
                    }

                    // 根据消息类型接收消息数据
                    if (messageType == "Text")
                    {
                        // 接收文本消息
                        byte[] messageBytes = new byte[receiveBufferSize];
                        StringBuilder messageBuilder = new StringBuilder();
                        do
                        {
                            bytesReceived = clientSocket.Receive(messageBytes);
                            string message = Encoding.UTF8.GetString(messageBytes, 0, bytesReceived);
                            messageBuilder.Append(message);
                        } while (!messageBuilder.ToString().EndsWith(messageEndFlag));
                        string messageContent = messageBuilder.ToString().Substring(0, messageBuilder.Length - messageEndFlag.Length);

                        // 显示消息
                        ShowMessage(messageContent);
                    }
                    else if (messageType == "Image")
                    {
                        // 接收图片消息
                        byte[] buffer = new byte[receiveBufferSize];
                        int bytesRead = 0;
                        using (FileStream fs = new FileStream(messageFileName, FileMode.Create, FileAccess.Write))
                        {
                            do
                            {
                                bytesRead = clientSocket.Receive(buffer);
                                fs.Write(buffer, 0, bytesRead);
                            } while (bytesRead == receiveBufferSize);
                        }

                        // 显示图片
                        ShowImage(messageFileName);
                    }
                    else if (messageType == "File")
                    {
                        // 接收文件消息
                        byte[] buffer = new byte[receiveBufferSize];
                        int bytesRead = 0;
                        using (FileStream fs = new FileStream(messageFileName, FileMode.Create, FileAccess.Write))
                        {
                            do
                            {
                                bytesRead = clientSocket.Receive(buffer);
                                fs.Write(buffer, 0, bytesRead);
                            } while (bytesRead == receiveBufferSize);
                        }

                        // 显示文件
                        ShowFile(messageFileName);
                    }
                    else if (messageType == "Shake")
                    {
                        // 抖动窗口
                        ShakeWindow();
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                    break;
                }
            }
        }

        // 发送消息函数
        private void SendMessage(string message)
        {
            try
            {
                // 发送消息头
                string messageHeader = "Text|";
                byte[] headerBytes = Encoding.UTF8.GetBytes(messageHeader);
                clientSocket.Send(headerBytes);

                // 发送消息数据
                byte[] messageBytes = Encoding.UTF8.GetBytes(message);
                clientSocket.Send(messageBytes);

                // 发送消息结束标志
                byte[] endBytes = Encoding.UTF8.GetBytes(messageEndFlag);
                clientSocket.Send(endBytes);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        // 显示消息函数
        private void ShowMessage(string message)
        {
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    txtChat.Text += message + Environment.NewLine;
                }));
            }
            else
            {
                txtChat.Text += message + Environment.NewLine;
            }
        }

        // 显示图片函数
        private void ShowImage(string fileName)
        {
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    picBox.Image = Image.FromFile(fileName);
                }));
            }
            else
            {
                picBox.Image = Image.FromFile(fileName);
            }
        }

        // 显示文件函数
        private void ShowFile(string fileName)
        {
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    txtChat.Text += "已接收文件：" + fileName + Environment.NewLine;
                }));
            }
            else
            {
                txtChat.Text += "已接收文件：" + fileName + Environment.NewLine;
            }
        }

        // 抖动窗口函数
        private void ShakeWindow()
        {
            if (InvokeRequired)
            {
                Invoke(new Action(() =>
                {
                    int x = Location.X;
                    int y = Location.Y;
                    Random random = new Random();
                    for (int i = 0; i < 10; i++)
                    {
                        int offsetX = random.Next(-10, 10);
                        int offsetY = random.Next(-10, 10);
                        Location = new System.Drawing.Point(x + offsetX, y + offsetY);
                        Thread.Sleep(20);
                    }
                    Location = new System.Drawing.Point(x, y);
                }));
            }
            else
            {
                int x = Location.X;
                int y = Location.Y;
                Random random = new Random();
                for (int i = 0; i < 10; i++)
                {
                    int offsetX = random.Next(-10, 10);
                    int offsetY = random.Next(-10, 10);
                    Location = new System.Drawing.Point(x + offsetX, y + offsetY);
                    Thread.Sleep(20);
                }
                Location = new System.Drawing.Point(x, y);
            }
        }

        // 抖动计时器事件处理函数
        private void ShakeTimer_Tick(object sender, EventArgs e)
        {
            shakeTimer.Stop();
            ShakeWindow();
        }
    }
}