signalr服务端-基础搭建

最新推荐文章于 2024-08-27 09:41:16 发布
最新推荐文章于 2024-08-27 09:41:16 发布
阅读量500 收藏 1
点赞数
文章标签： 数据库
原文链接：http://www.cnblogs.com/LQBlog/p/5939672.html
版权

signalr 支持 iis托管、winform、windowsservices、wpf 托管 这里我采用winfrom托管

首先画一个这样的窗体

在服务项目通过项目管理包安装signalr类库

安装后 如果客户端是web程序 则将js移动到客户端 编写客户端的时候使用

这次我安装缺少一个 程序集 我在官网下载手动引用上去了

新建一个类 该类用于自定义找到signalr回话的id  默认是随机的一个guid维护。。实现这个类 就可以根据用户id 直接发送给指定用户

  /// <summary>
    /// 自定义维护每个用户会话id的实现类
    /// </summary>
    public class UserIdProvider:IUserIdProvider
    {
        public string GetUserId(IRequest request)
        {
            return request.QueryString["Uid"];
        }
    }

新建一个signalr启动类。并将自定义维护会话注入

 public class Startup
    {
       public void Configuration(IAppBuilder app)
       {
           //注入signlar自定义维护会话id
           GlobalHost.DependencyResolver.Register(typeof(IUserIdProvider), () => new UserIdProvider());
           app.UseCors(CorsOptions.AllowAll);
           app.MapSignalR();
       }
    }

新建一个服务器的在线用户信息管理类

 /// <summary>
    /// 在线用户信息管理类
    /// </summary>
    public class User
    {
        /// <summary>
        /// 用户id
        /// </summary>
        public string Uid { get; set; }

        /// <summary>
        /// 用户名字
        /// </summary>
        public string UName { get; set; }

        /// <summary>
        /// 上线时间
        /// </summary>
        public DateTime Date { get; set; }

        /// <summary>
        /// 头像
        /// </summary>
        public string HeadPath { get; set; }


        /// <summary>
        /// 当前用户所在机构id
        /// </summary>
        public string OrganId{ get; set; }

        /// <summary>
        /// 当前用户所在部门id
        /// </summary>
        public string Depid { get; set; }
    }

 引入redis客户端 消息队列管理以及在线用户管理

编写接口层 如果不使用redis可以切换成其他存储

 public interface IDeposit
   {
       Task<bool> RemoveKey(string key);
       Task<bool> SetAsync(string key, object value, TimeSpan? timeOut = null);
       Task<T> GetAsync<T>(string key);
       Task<bool> ListLeftPush(string key, object value, TimeSpan? ts = null);
       Task<bool> ListRightPush(string key, object value, TimeSpan? ts = null);
       Task<T> ListLeftPop<T>(string key);

       Task<T> ListRightPop<T>(string key);

       bool HashSet(string keyA, string keyB, object value);

       T HashGet<T>(string keyA, string keyB);
   }
}

编写实现层

  public class RedisManager:IDeposit
    {
        private  ConnectionMultiplexer _redis;
        private  object _locker = new object();
        public  ConnectionMultiplexer Manager
        {
            get
            {
                if (_redis == null)
                {
                    lock (_locker)
                    {
                        if (_redis != null) return _redis;
                        _redis = GetManager();
                        return _redis;
                    }
                }
                return _redis;
            }
        }


        public  IDatabase DB
        {
            get
            {
                return Manager.GetDatabase();
            }

        }

        private  ConnectionMultiplexer GetManager()
        {
            ConfigurationOptions co = new ConfigurationOptions()
            {
                EndPoints =
                     {
        {ConfigHelper.GetRedisIp, ConfigHelper.GetRedisPort }
    }
            };

            return ConnectionMultiplexer.Connect(co);
        }


        public async  Task<bool> RemoveKey(string key)
        {
            return await DB.KeyDeleteAsync(key);
        }

        public async  Task<bool> SetAsync(string key, object value, TimeSpan? timeOut=null)
        {
            Type t = value.GetType();
            bool isOk;
            if (t.IsClass && t != typeof(string))
            {
                var str = JsonConvert.SerializeObject(value);
                isOk = Manager.GetDatabase().StringSet(key, str);

            }
            else
            {
                isOk = Manager.GetDatabase().StringSet(key,value.ToString());
            }
        
            //设置key的失效时间
             if (isOk && timeOut != null)
             {
                 DB.KeyExpire(key, timeOut);
             }
            return isOk;
        }

        public async  Task<T> GetAsync<T>(string key)
        {
            try
            {
                if (DB.KeyExists(key))
                {
                    Type t = typeof(T);
                    string str = DB.StringGet(key);
                    if (t.IsClass&&t!=typeof(string))
                    {
                        return JsonConvert.DeserializeObject<T>(str);
                    }
                    else
                    {
                        return (T)Convert.ChangeType(str, t);
                    }
                }
                else
                {
                    return default(T);
                }
            }
            catch (Exception e)
            {
                throw e;
            } 
        }


        /// <summary>
        /// 左侧入队
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="ts"></param>
        /// <returns></returns>
        public async  Task<bool> ListLeftPush(string key,object value,TimeSpan?ts=null) { 
               Type t = value.GetType();
               bool isOk;
               long oldLength = DB.ListLength(key);
            long length=0;
            if (t.IsClass && t != typeof(string))
            {
                   var str = JsonConvert.SerializeObject(value);
                   length = DB.ListLeftPush(key, str);
            }else{
                length = DB.ListLeftPush(key, value.ToString());
            }
           isOk=oldLength < length;
           //设置key的失效时间
           if (isOk && ts != null)
           {
               DB.KeyExpire(key, ts);
           }
           return isOk;
        }

        //右侧入队
        public async  Task<bool> ListRightPush(string key, object value, TimeSpan? ts = null)
        {
            Type t = value.GetType();
            bool isOk;
            long oldLength = DB.ListLength(key);
            long length = 0;
            if (t.IsClass && t != typeof(string))
            {
                var str = JsonConvert.SerializeObject(value);
                length = DB.ListRightPush(key, str);
            }
            else
            {
                length = DB.ListRightPush(key, value.ToString());
            }
            isOk= oldLength < length;
            //设置key的失效时间
            if (isOk && ts != null)
            {
                DB.KeyExpire(key, ts);
            }
            return isOk;
        }

        /// <summary>
        /// 左侧出队
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async  Task<T> ListLeftPop<T>(string key)
        {
            Type t = typeof(T);
            if (DB.KeyExists(key))
            {
                var values = DB.ListLeftPop(key);
                if (t.IsClass && t != typeof(string))
                {
                    return JsonConvert.DeserializeObject<T>(values); ;
                }
                else
                {
                    return (T)Convert.ChangeType(values, t);
                }
            }
            else
            {
                return default(T);
            }
        }

        /// <summary>
        /// 右侧出队
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public async  Task<T> ListRightPop<T>(string key)
        {
            Type t = typeof(T);
            if (DB.KeyExists(key))
            {
                var values = DB.ListRightPop(key);
                if (t.IsClass && t != typeof(string))
                {
                    return JsonConvert.DeserializeObject<T>(values); ;
                }
                else
                {
                    return (T)Convert.ChangeType(values, t);
                }
            }
            else
            {
                return default(T);
            }
        }

        public bool HashSet(string keyA, string keyB, object value)
        {
            if (DB == null) return false;
            var t = value.GetType();
            bool isOk;
          
            if (t.IsClass && t != typeof(string))
            {
                var str = JsonConvert.SerializeObject(value);
              isOk=  DB.HashSet(keyA, keyB, str);
            }
            else
            {
              isOk=  DB.HashSet(keyA,keyB, value.ToString());
            }
            return isOk;
        }

        public T HashGet<T>(string keyA, string keyB)
        {
            if (DB == null) return default(T);
            var t = typeof(T);

                var values = DB.HashGet(keyA,keyB);
                if (string.IsNullOrEmpty(values)) return default(T);
                if (t.IsClass && t != typeof(string))
                {
                    return JsonConvert.DeserializeObject<T>(values); ;
                }
                else
                {
                    return (T)Convert.ChangeType(values, t);
                }

               
        }
    }

编写帮助类

 public class DepositHelper
   {
       public static IDeposit rm = new RedisManager();
        public Task<bool> RemoveKey(string key)
        {
            return rm.RemoveKey(key);
        }

        public static  Task<bool> SetAsync(string key, object value, TimeSpan? timeOut = null)
        {
            return rm.SetAsync(key, value, timeOut);
        }

        public static  Task<T> GetAsync<T>(string key)
        {
            return rm.GetAsync<T>(key);
        }

        public static  Task<bool> ListLeftPush(string key, object value, TimeSpan? ts = null)
        {
            return rm.ListLeftPush(key, value, ts);
        }

        public static Task<bool> ListRightPush(string key, object value, TimeSpan? ts = null)
        {
            return rm.ListRightPush(key, value, ts);
        }

        public static  Task<T> ListLeftPop<T>(string key)
        {
            return rm.ListLeftPop<T>(key);
        }

        public static  Task<T> ListRightPop<T>(string key)
        {
            return rm.ListRightPop<T>(key);
        }

       public static bool HashSet(string keyA, string keyB, object value)
       {
           return rm.HashSet(keyA, keyB, value);
       }

       public static T HashGet<T>(string keyA, string keyB)
       {
           return rm.HashGet<T>(keyA, keyB);
       }

    }

编写在线用户信息管理类

 

 

以后再写了

 

转载于:https://www.cnblogs.com/LQBlog/p/5939672.html

denggouya9281
关注
基于SignalR的服务端和客户端通讯处理
微赚淘客开发者博客
10-26 1408
SignalR是一个.NET Core/.NET Framework的实时通讯的框架，一般应用在ASP.NET上，当然也可以应用在Winform上实现服务端和客户端的消息通讯，本篇随笔主要基于SignalR的构建一个基于Winform的服务端和客户端的通讯处理案例，介绍其中的处理过程。 1、SignalR基础知识 SignalR是一个.NET Core/.NET Framework的开源实时框...
SignalR做服务端 java,SignalR第一节-在5分钟内完成通信连接和消息发送
weixin_32262035的博客
03-12 1501
原标题：SignalR第一节-在5分钟内完成通信连接和消息发送前言首先声明，这又是一个小白从入门到进阶系列。 SignalR 这个项目我关注了很长时间，中间好像还看到过微软即将放弃该项目的消息，然后我也就没有持续关注了，目前的我项目中使用的是自己搭建的 WebSocket ，连接管理和消息推送都是统一维护；前段时间编写了 Asp.NETCore 轻松学系列，现在腾出了一点时间，抱着学习的心态，想把...
SignalR实现服务器与Web客户端的实时通信
09-04
本例是在ASP .NET 的Web项目中实现实时通信，通过三个DEMO学会SignalR的三种在线即时聊天系统
如何搭建SignalR服务器和客户端（c#）
热门推荐
记录自己得成长之路！
08-06 2万+
​SignalRASP .NET SignalR 是一个ASP .NET 下的类库，可以在ASP .NET 的Web项目中实现实时通信。什么是实时通信的Web呢?就是让客户端(Web页面)和服务器端可以互相通知消息及调用方法，当然这是实时操作的。SignalR当然也提供了非常简单易用的高阶API，使服务器端可以单个或批量调用客户端上的JavaScript函数，客户端也可以调用服务器端的方法，并且非常
学习SignalR（一）：搭建及简单通信
weixin_45132755的博客
12-25 1258
1、环境：服务端使用 .net 7.0 WebAPI，客户端使用 Winform2、我用的端口是5000，所以我的 WebAPI 地址是，如果部署到 IIS 服务，5000端口号需改成IIS配置的端口号3、目的是为了了解 signalR 的客户端是如何连接、发送、接收等和服务端的发送消息。
【转载】signalr简单环境搭建
yang651158的博客
02-25 465
我们实现一个简单的消息通知的Demo 在NuGet中添加SignalR引用 install-package Microsoft.AspNet.SignalR 然后我们创建一个类来引用Hub类 namespace SignalRDemo.Hubs { public class ServerHub:Hub { } } 或者直接在添加项中添加Sig...
Signal服务器部署指南
最新发布
gitblog_00406的博客
08-27 1082
Signal服务器部署指南 signal-setup-guideSetup guide for Signal (OpenWhisper) server & client. Please refer to the discussion section for questions & difficulties.项目地址:https://gitcode.com/gh_mirrors/si/signal...
一个更加完善的SignalR服务端，本人已经在实际项目中使用，聊天室接口已经全部定义，只需要实际的实现，同时集成了Quartz
08-24
在标题和描述中提到的，是一个经过优化的 SignalR 服务端实现，已经应用于实际的项目，并且包含了完整的聊天室接口定义，只需进行具体的实现。此外，该服务端还集成了 Quartz，这是一个开源的作业调度框架，用于在...
安装SignalR
yingying0708的专栏
08-19 499
项目中安装SignalR install-package Microsoft.AspNet.SignalR
nginx - nginx的安装部署-signal信号-配置文件
hj的博客
12-24 1679
nginx的安装部署-signal信号-配置文件
使用SignalR实现服务端消息推送
weixin_30838873的博客
12-21 271
概述 这篇文章参考的是Server Broadcast with SignalR 2这篇教程，很不错的一篇教程，如果有兴趣的话可以查看原文，今天记录下来作为一个学习笔记，这样今后翻阅会更方便一点。 这篇教程通过实现一个股票报价的小程序来讲解如何使用SignalR进行服务器端的推送，服务器会模拟股票价格的波动，并把最新的股票价格推送给所有连接的客户端，最终的运行效果如下图所示。 教程篇 ...
[C#]SignalR实现扫码登录(B/S,C/S)（一）——服务端搭建
xy596356456的博客
10-24 2465
直入主题 一、创建项目 先创建一个控制台应用程序用来搭建扫码登陆的服务端 二、安装Package 使用Nuget安装以下Package Microsoft.AspNet.SignalR.SelfHost ——用于构建自承载的SignalR服务 Microsoft.AspNet.WebApi.Owin ——用于提供WebApi服务 Microsoft.Owin.Cors ——用于跨域设置 以上包有依赖项，需要全部引入，引用完成后的packages.config文件如下：...
SignalR---服务端
weixin_30619101的博客
04-02 292
前段时间把SignalR的官网教程大致看了一下，算是翻译了一遍，加上了自己的个人理解， 一下上传三个文件，分别是服务端、web客户端、DOTNET客户端相关文档，供大家参考。 其中有一处由于翻译时不专心，但又没能找到的错误，是说$.connetion.myHub和$.hubConnection其中是同一个对象的。 下面以代码形式上传，篇幅过长，有翻译不当的地方请浏览指出。 在Start...
WinForms 应用程序中使用 SignalR 连接到服务器
一个专注于技术研究创新的程序员
04-29 982
假设您已经在服务器端实现了名为 SignalRHub 的 SignalR Hub，并且该 Hub 包含了一个名为 SendMessage 的方法，用于接收来自客户端的消息，并将其广播给所有连接的客户端。客户端在收到消息时调用名为 ReceiveMessage 的方法来处理。
signalr 消息服务器,.net core SignalR——服务器实时消息推送
weixin_33899835的博客
08-03 1540
背景在原生js实现文件上传并显示进度条一文中，我们实现了一个Excel上传功能，并且显示了服务端实时处理进度(正在处理第N行...)，不用让用户一直傻等而不知道什么情况，这样极大的提高了用户的体验有两种方式可以实现这样的功能：前端js去定时请求服务端处理进度/长轮询websocket双向通信两种方案的选择：传统的长轮询也能实现消息实时，就是定时向服务器发送请求获取消息，但是这样对服务器压力比较大，...
xp可以安装.net framework 4.6吗_.NET中SignalR自托管全解(使用SelfHost)
weixin_39751679的博客
11-27 1445
(给DotNet加星标，提升.Net技能)转自：.NET快速开发框架cnblogs.com/huyong/p/11381349.html一、概述我们对SignalR的概念以及SignalR的最主要的两类通信模型(PersistentConnections与Hubs)进行了详细的对比讲解，也做了案例展示。本篇将为大家介绍.NET特有的Self-Host自托管的应用，即以Self-Host...
signalR+redis 分布式聊天服务器搭建
weixin_33961829的博客
03-12 511
2019独角兽企业重金招聘Python工程师标准>>> ...
SignalR 实时通讯
黑夜中的潜行者
02-28 1790
SignalR 是一个开放源代码库，可用于简化向应用添加实时 Web 功能。实时 Web 功能使服务器端代码能够将内容推送到客户端。SignalR 提供用于创建服务器到客户端远程过程调用 (RPC) 的 API。RPC 从服务器端 .NET Core 代码调用客户端上的函数。提供多个受支持的平台，其中每个平台都有各自的客户端 SDK。与 ASP.NET 的其余部分一样，SignalR 是为实现高性能而构建的，也是市面上最快的实时框架之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值