基于.net\webSocket的网上聊天室开发记录(待续)

最新推荐文章于 2022-11-16 17:45:59 发布

穿越的马里奥

最新推荐文章于 2022-11-16 17:45:59 发布

阅读量210

点赞数

分类专栏： C#

本文链接：https://blog.csdn.net/qq_37644845/article/details/102955223

版权

C# 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

基于.net\webSocket的网上聊天室开发记录

一、解除webSocket以及遇到的问题

一、解除webSocket以及遇到的问题

webSocket好像很有意思的样子，于是决定找点例子看

1、网上找了个.net后台的例子

原网址已经找不到了，就不贴出来了


using System;
using System.Collections;
using System.Web;
using System.Net;
using System.Net.WebSockets;
using System.Web.WebSockets;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Threading;
using System.Text;

/// <summary>
/// 
/// 版本升级到4.5.1
/// </summary> 

/// <summary> 
/// 离线消息
/// </summary>
public class MessageInfo
{
    public MessageInfo(DateTime _MsgTime, ArraySegment<byte> _MsgContent)
    {
        MsgTime = _MsgTime;
        MsgContent = _MsgContent;
    }
    public DateTime MsgTime { get; set; }
    public ArraySegment<byte> MsgContent { get; set; }
}


/// <summary>
/// Handler1 的摘要说明
/// </summary>
public class WebsocketTest : IHttpHandler
{
    private static Dictionary<string, WebSocket> CONNECT_POOL = new Dictionary<string, WebSocket>();//用户连接池
    private static Dictionary<string, List<MessageInfo>> MESSAGE_POOL = new Dictionary<string, List<MessageInfo>>();//离线消息池
    public void ProcessRequest(HttpContext context)
    {
        context.Response.ContentType = "text/plain";
        if (context.IsWebSocketRequest)
        {
            context.AcceptWebSocketRequest(ProcessChat);
        }
    }

    private async Task ProcessChat(AspNetWebSocketContext context)
    {
        WebSocket socket = context.WebSocket;
        string user = context.QueryString["user"].ToString();

        try
        {
            #region 用户添加连接池
            //第一次open时，添加到连接池中
            if (!CONNECT_POOL.ContainsKey(user))
                CONNECT_POOL.Add(user, socket);//不存在，添加
            else
                if (socket != CONNECT_POOL[user])//当前对象不一致，更新
                CONNECT_POOL[user] = socket;
            #endregion

            #region 离线消息处理
            if (MESSAGE_POOL.ContainsKey(user))
            {
                List<MessageInfo> msgs = MESSAGE_POOL[user];
                foreach (MessageInfo item in msgs)
                {
                    await socket.SendAsync(item.MsgContent, WebSocketMessageType.Text, true, CancellationToken.None);
                }
                MESSAGE_POOL.Remove(user);//移除离线消息
            }
            #endregion

            string descUser = string.Empty;//目的用户
            while (true)
            {
                if (socket.State == WebSocketState.Open)
                {
                    ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[2048]);
                    WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None);

                    #region 消息处理（字符截取、消息转发）
                    try
                    {
                        #region 关闭Socket处理，删除连接池
                        if (socket.State != WebSocketState.Open)//连接关闭
                        {
                            if (CONNECT_POOL.ContainsKey(user)) CONNECT_POOL.Remove(user);//删除连接池
                            break;
                        }
                        #endregion

                        string userMsg = Encoding.UTF8.GetString(buffer.Array, 0, result.Count);//发送过来的消息
                        string[] msgList = userMsg.Split('|');
                        if (msgList.Length == 2)
                        {
                            if (msgList[0].Trim().Length > 0)
                                descUser = msgList[0].Trim();//记录消息目的用户
                            buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(msgList[1]));
                        }
                        else
                            buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMsg));

                        if (CONNECT_POOL.ContainsKey(descUser))//判断客户端是否在线
                        {
                            WebSocket destSocket = CONNECT_POOL[descUser];//目的客户端
                            if (destSocket != null && destSocket.State == WebSocketState.Open)
                                await destSocket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
                        }
                        else
                        {
                            Task.Run(() =>
                            {
                                if (!MESSAGE_POOL.ContainsKey(descUser))//将用户添加至离线消息池中
                                    MESSAGE_POOL.Add(descUser, new List<MessageInfo>());
                                MESSAGE_POOL[descUser].Add(new MessageInfo(DateTime.Now, buffer));//添加离线消息
                            });
                        }
                    }
                    catch (Exception exs)
                    {
                        //消息转发异常处理，本次消息忽略 继续监听接下来的消息
                    }
                    #endregion
                }
                else
                {
                    break;
                }
            }//while end
        }
        catch (Exception ex)
        {
            //整体异常处理
            if (CONNECT_POOL.ContainsKey(user)) CONNECT_POOL.Remove(user);
        }
    }


    public bool IsReusable
    {
        get
        {
            return false;
        }
    }
}

评价：该页面直接使用的就是ashx一般处理程序，.net后台我也不是很清楚运行起来的话其它页面如何来调用该ashx文件中的程序池，所以应该使用单例模式将Dictionary<string, WebSocket>程序池放到一个单独的对象中。
页面中有许多代码是自己没怎么用过的，下面一一贴出来

2、C#中单例模式的实现

js中的单例模式颇为好实现，但是c#中的还没有试过，于是先找了一个网站参考

C# 单例模式的五种写法 https://www.cnblogs.com/mcyushao/p/9671357.html

文章中的单例模式介绍得很齐全，一并贴出，作为备忘

简单实现

public sealed class Singleton
    {
        static Singleton instance = null;
 
        public void Show()
        {
            Console.WriteLine(  "instance function");
        }
        private Singleton()
        {
        }
 
        public static Singleton Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
        }
    }

评注：
对于线程来说不安全
单线程中已满足要求

优点:
由于实例是在 Instance 属性方法内部创建的，因此类可以使用附加功能
直到对象要求产生一个实例才执行实例化；这种方法称为“惰性实例化”。惰性实例化避免了在应用程序启动时实例化不必要的 singleton。

线程的安全


public sealed class Singleton
    {
        static Singleton instance = null;
        private static readonly object padlock = new object();
 
        private Singleton()
        {
        }
 
        public static Singleton Instance
        {
            get
            {
                lock (padlock)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
 
                return instance;
            }
        }
    }

评注：
同一个时刻加了锁的那部分程序只有一个线程可以进入
对象实例由最先进入的那个线程创建
后来的线程在进入时（instence == null）为假，不会再去创建对象实例
增加了额外的开销，损失了性能

双重锁定


public sealed class Singleton
    {
        static Singleton instance = null;
        private static readonly object padlock = new object();
 
        private Singleton()
        {
        }
 
        public static Singleton Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (padlock)
                    {
                        if (instance == null)
                        {
                            instance = new Singleton();
                        }
                    }
                }
                return instance;
            }
        }
    }

评注：
多线程安全
线程不是每次都加锁
允许实例化延迟到第一次访问对象时发生

静态初始化


public sealed class Singleton
    {
        private static readonly Singleton instance = null;
        static Singleton()
        {
            instance = new Singleton();
        }
        private Singleton()
        {
        }
        public static Singleton Instance
        {
            get
            {
                return instance;
            }
        }
    }

评注：
依赖公共语言运行库负责处理变量初始化
公共静态属性为访问实例提供了一个全局访问点
对实例化机制的控制权较少(.NET代为实现)
静态初始化是在 .NET 中实现 Singleton 的首选方法

小注：
静态构造函数既没有访问修饰符，C#会自动把他们标记为private，之所以必须标记为private，是为了阻止开发人员写的代码调用它，对它的调用总是由CLR负责的。

延迟初始化


public sealed class Singleton
    {
        private Singleton()
        {
        }
        public static Singleton Instance
        {
            get
            {
                return Nested.instance;
            }
        }
 
        public static void Hello()
        {
        }
 
        private class Nested
        {
            internal static readonly Singleton instance = null;
            static Nested()
            {
                instance = new Singleton();
            }
        }
    }

评注：
初始化工作由Nested类的一个静态成员来完成，这样就实现了延迟初始化。

由于静态函数的调用时机，是在类被实例化或者静态成员被调用的时候进行调用，并且是由.net框架来调用静态构造函数来初始化静态成员变量，所以，如果按照写法四来写，再调用Hello方法的时候，就会实例化出来Singleton实例，这不是我们想看到的，因为我们有可能只是想用Hello方法，而不是别的。

注意事项：
1、Singleton模式中的实例构造器可以设置为protected以允许子类派生。
2、Singleton模式一般不要支持ICloneable接口，因为这可能会导致多个对象实例，与Singleton模式的初衷违背。
3、Singleton模式一般不要支持序列化，因为这也有可能导致多个对象实例，同样与Singleton模式的初衷违背。
4、Singletom模式只考虑到了对象创建的管理，没有考虑对象销毁的管理。就支持垃圾回收的平台和对象的开销来讲，我们一般没有必要对其销毁进行特殊的管理。

总结：
1、Singleton模式是限制而不是改进类的创建。
2、理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的构造器的任意调用”。
3、可以很简单的修改一个Singleton，使它有少数几个实例，这样做是允许的而且是有意义的。
好文要顶关注我收藏该文

3、不太懂的代码

sealed 参考下列文章

https://blog.csdn.net/qq_43024228/article/details/89885161

介绍：
a. 密封类的定义:
如果我们不希望自己编写的类被继承；如果有的类已经没有再被继承的必要，这时，我们可以使用sealed修饰符在类中进行声明，以达到该类不能派生其它类的目的，该类就被称为密封类。
b. 密封类与抽象类:
密封类不能同时又是抽象类，因为密封类不能用作基类、也不能被继承，而抽象类总是希望被继承的。
c. 什么情况下使用密封类:
需要阻止其它程序员无意中继承该类的时候；在程序运行时需要起到优化效果的时候，可以使用密封类。

async与await使用
参考文章

https://blog.csdn.net/codingriver/article/details/83342267

ArraySegment类型的用法
特点: ArraySegment reference to the original array and does NOT make a copy of it, so the changes of segment will affect the array as well.
翻译: 数组片段ArraySegment引用原始的数组而不是复制他，因此原始数组的改变也会影响该对象
好处: 结合下面的文章以及自己写过的代码发现好处如下，a)不用重新创建新的数组对象，节省了内存空间，尤其是对socket通讯来说可能一个数组就是好几兆；b)不用拷贝原始数组，仅仅只是创建一个对象，略微的节省点时间；c)在方法间当作参数传递的时候其实就是相当于把原始数组当作传递对象，但是又给了自己在原始数组中需要信息的位置即 arraySegment.Offset 与信息的长度arraySegment.Count；