Orleans8.2入门测试

原创 已于 2024-12-21 22:04:28 修改 · 303 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#ui

于 2024-11-02 18:13:52 首次发布

微软官方文档：快速入门：使用 ASP.NET Core 生成第一个 Orleans 应用 - .NET | Microsoft Learn

项目及引入的nuget库：

1、接口项目；2、接口实现项目；3、silo项目；4、客户端项目

其中Microsoft.Orleans.Streaming，为测试流功能额外添加。 

//IHello.cs代码
using System.Reflection;

namespace GrainInterfaces
{
    /// <summary>
    /// Grain接口
    /// 从IGrainWithStringKey继承可以使用字符串作为Grain的唯一标识，便于理解
    /// 从IGrainObserver继承为了支持订阅方式双向通信
    /// </summary>
    public interface IHello : IGrainWithStringKey, IGrainObserver
    {
        /// <summary>
        /// 默认测试接口
        /// </summary>
        /// <param name="greeting"></param>
        /// <returns></returns>
        ValueTask<string> SayHello(string greeting);
        /// <summary>
        /// 传递复杂对象测试
        /// </summary>
        /// <param name="param"></param>
        /// <returns></returns>
        ValueTask<ResultA> GetResultA(ParamA param);
        #region 用订阅方式实现双向通信
        Task NotifyOtherGrain(string grainID, string message);
        /// <summary>
        /// 客户端订阅Grain上的通知消息
        /// 需要额外的一个IGrainObserver类型对象IChat支持
        /// </summary>
        /// <param name="observer"></param>
        /// <returns></returns>
        Task Subscribe(IChat observer);
        /// <summary>
        /// 解除订阅
        /// </summary>
        /// <param name="observer"></param>
        /// <returns></returns>
        Task Unsubscribe(IChat observer);
        /// <summary>
        /// Grains直接通信,只要有Grains的id,就可以很方便的从客户端或其他grains中拿到grains的引用
        /// </summary>
        /// <param name="sender">目标grains的id</param>
        /// <param name="message">要转发的消息</param>
        /// <returns></returns>
        Task ReceiveBrotherMessage(string sender, string message);
        #endregion
    }
    #region 订阅方式支持类定义
    /// <summary>
    /// Grain类不允许出现属性,为了方便客户端订阅,额外定义一个带Action委托的接口让Chat对象实现
    /// </summary>
    public interface IChatNotify
    {
        /// <summary>
        /// 收到服务端通知触发事件,客户端指定处理事件
        /// </summary>
        Action<string> ReceiveAct { get; set; }
    }

    /// <summary>
    /// 消息订阅支持接口
    /// </summary>
    [Alias("GrainInterfaces.IChat")]
    public interface IChat : IGrainObserver
    {
        /// <summary>
        /// 定义订阅模式消息接收函数
        /// 注意IChat在客户端实例化,此函数在客户端执行
        /// </summary>
        /// <param name="message"></param>
        /// <returns></returns>
        [Alias("ReceiveMessage")]
        Task ReceiveMessage(string message);
    }

    /// <summary>
    /// 消息订阅类实现(在客户端实例化)
    /// </summary>
    public class Chat : IChat, IChatNotify
    {
        public Action<string> ReceiveAct { get; set; } = null;
        public Task ReceiveMessage(string message)
        {
            var log = $"===={message}   {Assembly.GetEntryAssembly()?.FullName}";
            Console.WriteLine(log);
            ReceiveAct?.Invoke(message);
            return Task.CompletedTask;
        }
    }
    #endregion

    /// <summary>
    /// 定义复杂函数参数类型
    /// 注解GenerateSerializer:告诉Orleans使用其默认的序列化反序列化方式
    /// </summary>
    [GenerateSerializer]
    public class ParamA
    {
        [Id(0)]
        public int ID { get; set; }
        [Id(1)]
        public int DataLen { get; set; }
        [Id(2)]
        public required string Name { get; set; }
    }

    /// <summary>
    /// 定义复杂函数返回类型
    /// 注解GenerateSerializer:告诉Orleans使用其默认的序列化反序列化方式
    /// </summary>
    [GenerateSerializer]
    public class ResultA
    {
        [Id(0)]
        public int ID { get; set; }
        [Id(1)]
        public required string Name { get; set; }
        [Id(2)]
        public required byte[] Data { get; set; }
    }

    /// <summary>
    /// 测试用全局数据定义
    /// </summary>
    public static class GlobalValueDefinition
    {
        public const string StreamProviderName = "StreamProvider";
        public const string GrainStorageName = "PubSubStore";
        public const string ImplicitStreamSubscriptionName = "RANDOMDATA";
    }
}
//HelloGrains.cs
using GrainInterfaces;
using Microsoft.Extensions.Logging;
using Orleans;
using Orleans.Streams;
using Orleans.Utilities;
using System.Net.NetworkInformation;

namespace Grains
{
    /// <summary>
    /// Hello Grain定义
    /// [ImplicitStreamSubscription(GlobalValueDefinition.ImplicitStreamSubscriptionName)]
    /// 这个注解告诉Orleans使用隐式订阅流(简化测试)
    /// </summary>
    [ImplicitStreamSubscription(GlobalValueDefinition.ImplicitStreamSubscriptionName)]
    public class HelloGrains :Grain, IHello
    {
        private readonly ILogger _logger;

        private readonly ObserverManager<IChat> _subManager;

        public HelloGrains(ILogger<HelloGrains> logger)
        {
            _logger = logger;
            _subManager = new ObserverManager<IChat>(TimeSpan.FromMinutes(5), logger);
            Console.WriteLine($"====={GrainContext.GrainId}");
        }

        private IAsyncStream<string> _demoStream;

        public override Task OnActivateAsync(CancellationToken cancellationToken)
        {
            #region 流的支持
            CreateStreamSubscribe().GetAwaiter().GetResult();
            #endregion
            return base.OnActivateAsync(cancellationToken);
        }

        private async Task CreateStreamSubscribe()
        {
            var guid = this.GetPrimaryKeyString();
            var streamProvider = this.GetStreamProvider(GlobalValueDefinition.StreamProviderName);
            var streamId = StreamId.Create(GlobalValueDefinition.ImplicitStreamSubscriptionName, guid);
            _demoStream = streamProvider.GetStream<string>(streamId);
            await _demoStream.SubscribeAsync<string>(
                async (data, token) => { 
                    Console.WriteLine($"*****Hello {data}");
                    await Task.CompletedTask;
                });
        }

        #region 订阅支持
        public Task Subscribe(IChat observer) 
        {
            _subManager.Subscribe(observer, observer);
            return Task.CompletedTask;
        }

        public Task Unsubscribe(IChat observer) 
        { 
            _subManager.Unsubscribe(observer); 
            return Task.CompletedTask; 
        }
        //向订阅者发送消息
        public Task SendUpdateMessage(string message)
        {
            _subManager.Notify(s=>s.ReceiveMessage(message));
            return Task.CompletedTask;
        }
        #endregion
        public ValueTask<string> SayHello(string greeting)
        {
            var response = $"Client {GrainContext.GrainId} said:{greeting}, so HelloGrain says: Hello";
            _logger.LogInformation(response);
            SendUpdateMessage("SendUpdateMessage：" + response);
            return ValueTask.FromResult(response);
        }

        public ValueTask<ResultA> GetResultA(ParamA param)
        {
            _logger.LogInformation($"Invoke GetResultA({param.ID}  {param.Name})");
            var res = new ResultA
            {
                ID = param.ID + 1,
                Name = param.Name,
                Data = new byte[param.DataLen],
            };
            return ValueTask.FromResult(res);
        }

        public Task NotifyOtherGrain(string otherGrainID, string message)
        {
            var otherGrainHello = GrainFactory.GetGrain<IHello>(otherGrainID);
            otherGrainHello.ReceiveBrotherMessage(this.GetPrimaryKeyString(), message);
            return Task.CompletedTask;
        }

        public Task ReceiveBrotherMessage(string sender, string message)
        {
            SendUpdateMessage($"GetBrotherMessage({sender},{message})");
            return Task.CompletedTask;
        }
    }
}

//Silo服务启动源码
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Orleans.Configuration;
using Orleans.Serialization;
using System.Net;
using GrainInterfaces;

namespace Silo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private async void button1_Click(object sender, EventArgs e)
        {
            //本地集群方式部署
            var primarySiloEndPoint = new IPEndPoint(IPAddress.Parse(textBox_IPAddr.Text), 11_111);
            var silo = new HostBuilder()
                .UseOrleans(builder =>
                {
                    builder.UseDevelopmentClustering(primarySiloEndPoint)
                    .Configure<ClusterOptions>(options =>
                    {
                        options.ClusterId = "cluster001";
                        options.ServiceId = "service001";
                    })
                    .ConfigureEndpoints(siloPort: 11_111, gatewayPort: 30_001)
                    .ConfigureLogging(logging => logging.AddConsole())
                    .AddMemoryStreams(GlobalValueDefinition.StreamProviderName) //unget引入 Microsoft.Orleans.Streaming
                    .AddMemoryGrainStorage(GlobalValueDefinition.GrainStorageName);
                }).Build();
            
            await silo.RunAsync();
        }

        //#region 本地测试模式
        ////IHostBuilder builder = Host.CreateDefaultBuilder(args)
        ////    .UseOrleans(silo =>
        ////    {
        ////        silo.UseLocalhostClustering(11111, 30001, serviceId: "service001", clusterId: "cluster001")
        ////        .ConfigureLogging(logging => logging.AddConsole());
        ////    })
        ////    .UseConsoleLifetime();

        ////using IHost host = builder.Build();
        ////await host.RunAsync();
        //#endregion
    }
}

//客户端代码
using GrainInterfaces;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Orleans.Configuration;
using Orleans.Serialization.WireProtocol;
using Orleans.Streams;
using System.Net;
using System.Security.AccessControl;

namespace WinFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private IClusterClient client = null;
        private IHost host = null;
        private IHello friend1;
        private IHello friend2;
        private IChat chat;
        private async void button1_Click(object sender, EventArgs e)
        {
            #region 开发者模式连接
            //IHostBuilder builder = Host.CreateDefaultBuilder()
            //    .UseOrleansClient(client =>
            //    {
            //        client.UseLocalhostClustering(30001, "service001", "cluster001");
            //    })
            //    .ConfigureLogging(logging => logging.AddConsole())
            //    .UseConsoleLifetime();

            //host = builder.Build();
            //await host.StartAsync();

            //client = host.Services.GetRequiredService<IClusterClient>();
            #endregion
            var PRIMARY_SILO_IP_ADDRESS = IPAddress.Parse(textBox_IPAddr.Text);
            //var PRIMARY_SILO_IP_ADDRESS_1 = IPAddress.Parse("192.168.0.101");
            #region 专用服务器群集模式连接
            var gateways = new IPEndPoint[] {
                new IPEndPoint(PRIMARY_SILO_IP_ADDRESS, 30_001)
            };

            host = Host.CreateDefaultBuilder()
                .UseOrleansClient(clientBuilder =>
                    clientBuilder.UseStaticClustering(gateways)
                    .Configure<ClusterOptions>(options =>
                    {
                        options.ClusterId = "cluster001";
                        options.ServiceId = "service001";
                    })
                #region Stream测试
                    .AddMemoryStreams(GlobalValueDefinition.StreamProviderName)
                #endregion
                ).Build();
            await host.StartAsync();

            client = host.Services.GetRequiredService<IClusterClient>();
            #endregion

            #region 订阅
            friend1 = client.GetGrain<IHello>("user1");
            friend2 = client.GetGrain<IHello>("user2");
            Chat c = new Chat();
            (c as IChatNotify).ReceiveAct += ShowLog;
            chat = client.CreateObjectReference<IChat>(c);
            await friend1.Subscribe(chat);
            #endregion

            #region StreamTest
            await CreateStreamSubscribe();
            #endregion
        }

        private IAsyncStream<string> _demoStream;

        private async Task CreateStreamSubscribe()
        {
            var clientStreamName = "clientStream001";
            var streamProvider = client.GetStreamProvider(GlobalValueDefinition.StreamProviderName);
            var streamId = StreamId.Create(GlobalValueDefinition.ImplicitStreamSubscriptionName, clientStreamName);
            _demoStream = streamProvider.GetStream<string>(streamId);//流的内容可为容易可序列化类实例
            await _demoStream.SubscribeAsync<string>(
                async (data, token) =>
                {
                    ShowLog($"*****Hello {data}");
                    await Task.CompletedTask;
                });
        }

        private async void button2_Click(object sender, EventArgs e)
        {
            await host.StopAsync();
        }

        private async void button3_Click(object sender, EventArgs e)
        {
            string response = await friend1.SayHello("Hi friend!");
            ShowLog($"{friend1.GetPrimaryKeyString()}  {response}");


        }
        private void ShowLog(string log)
        {
            Invoke(new Action(() =>
            {
                textBox1.AppendText($"{log}\r\n");
            }));
        }

        private async void button4_Click(object sender, EventArgs e)
        {
            string response = await friend2.SayHello("Hi friend!");
            ShowLog($"{friend2.GetPrimaryKeyString()}  {response}");
        }

        private async void button5_Click(object sender, EventArgs e)
        {
            IHello friend = client.GetGrain<IHello>("user1");
            var dateLen = Convert.ToInt32(textBox_DataLen.Text);
            var result = await friend.GetResultA(new ParamA { ID = 1, Name = "henreash", DataLen = dateLen });
            ShowLog($"GetResultA({result.ID} {result.Name}  {result.Data.Length})");
        }

        private void button6_Click(object sender, EventArgs e)
        {
            friend2.NotifyOtherGrain(friend1.GetPrimaryKeyString(), "让user2转告user1");
        }

        private async void button7_Click(object sender, EventArgs e)
        {
            await _demoStream.OnNextAsync("Send test stream message!");
        }
    }
}

结论:Orleans部署不需要额外的平台,编译后的进程直接启动;通过配置即可做集群扩展.grain和grain间,grain和客户端间很方便实现双向tcp通信.关闭silo服务,客户端访问失败,启动soli服务后客户端可继续访问.

服务器增加Dashboard

silo引入nuget库OleansDashboard(8.2.0),配置增加如下内容

可方便查看silo服务器的性能数据 

 集群部署

ClusterID、ServiceID不变，多个服务端使用不同的IP和端口号；

客户端使用相同的ClusterID、ServiceID，连接时gateway指定多个IPEndPoint即可测试。

注意：这种方式仍旧是开发模式，测试发现服务端无法获取其他silo上的grain实例，而是在本地重新创建一个同名的grain实例，无法实现集群效果。为了完整实现orleans的效果，必须部署集群，下章使用MySql数据库配置集群。

从0到全栈：C#/.NET/.NET Core终极学习路线——2025年开发者必修的12个阶段与30个实战项目
墨夶的博客
04-01 1461
【代码】从0到全栈：C#/.NET/.NET Core终极学习路线——2024年开发者必修的12个阶段与30个实战项目。
第02节课：创建Orleans游戏服务器工程
Pizza猫
01-10 595
搭建Orleans游戏服务器框架(手把手)
orleans简单入门例子（1.5.4）
07-31
orleans简单入门例子（1.5.4） 附带客户端及服务端。可以执行。
Orleans入门
weixin_30301449的博客
12-22 597
一、Grains 二、开发一个Grain 三、开发一个客户端 四、运行应用程序 五、调式 一、Grains Grains是Orleans编程模型的关键原语。 Grains是Orleans应用程序的构建块，它们是隔离，分配和持久性的原子单元。 Grains是表示应用程序实体的对象。 就像在经典的面向对象编程（Object Oriented Programming）中一样，grain封装实...
Microsoft Orleans 之 入门指南
weixin_33921089的博客
12-09 777
Microsoft Orleans 在.net用简单方法构建高并发、分布式的大型应用程序框架。 原文：http://dotnet.github.io/orleans/ 在线文档：http://dotnet.github.io/orleans/What's-new-in-Orleans 源码地址：https://github.com/dotnet/orleans 简介：Orleans 框架...
Orleans学习入门(最近公司要用奥尔良，特此记录下学习过程，希望各大神多指教)...
weixin_30600503的博客
09-12 237
介绍 Orleans是一个可以直接构建分布式大型计算应用程序的框架，而无需学习和应用复杂的并发或其他可扩展的模式。 背景 云应用和服务本质上是并行和分布式的。他们也是互动和动态的;通常需要几乎实时的云实体之间的直接交互。这样的应用程序今天很难构建。开发过程需要专家级程序员，并且通常需要昂贵的设计和架构迭代，随着工作量的增长。 今天的大部分大型属性都构建为无状态n层服务的组合，大多数应用逻...
Orleans 初接触
weixin_34178244的博客
11-22 158
简介 　　这篇随笔主要记录了自己学习Orleans的经过和理解，在学习过程中会一直更新，思路和理解可能有些偏颇，如果有幸有大佬看到这篇文章，希望能给予批评指正。 导航 （一） 入门例子 （二） 测试用例 3. 理解 　　首先，Microsoft Orleans是在.net用简单方法构建高并发、分布式的大型应用程序框架。 　　官方文档以及源码：http://dotnet.github...
Orleans 2.0 官方文档 —— 2.2 入门教程与示例 -> 入门教程1：Orleans基础
uddiqpl的专栏
01-06 4460
教程1—— 创建一个极小的Orleans应用程序 本教程提供了有关创建基本功能的Orleans应用程序的分步说明。它被设计为自包含且极尽简约，具有以下特征： 它仅依赖于NuGet包 它已在使用Orleans 2.2.0的Visual Studio 2017中进行了测试 它不依赖于外部存储 请记住，这只是一个教程，缺少适当的错误处理和其他对生产环境有用的好东西。但是，它应该有助于读者真实地了...
.NET 8.0 项目升级到 .NET 9.0
热门推荐
csdn_aspnet的专栏，请点击博客主页右上角三个点中的私信联系
12-26 11万+
.NET 8.0 项目升级到 .NET 9.0，发现AutoMapper-v13.0.1正常，AutoMapper.Extensions.Microsoft.DependencyInjection-v12.0.1已弃用，将AutoMapper和AutoMapper.Extensions.Microsoft.DependencyInjection版本都降至12.0.0版本后，异常消除.可能因为之前项目内的AutoMapper-v13.0.1语法不支持。选择相应程序包-右侧选择版本，点击更新即可。
Orleans7.0 游戏服务器全栈开发实战
01-10
                           Orleans 游戏服务器全栈开发实战                                                                                  -- Pizza猫老师课程目标：    1. 手把手搭建一套基于Orleans的游戏服务器框架    2. 实现一个简单的Unity客户端框架    3. 使用这套框架实现一个井字棋的对战游戏课程说明：    1. 课程的完整工程和对应的笔记文件都在课程最后一节(【第052节课：完成Grain的生命周期的管理】的附件里，大家可以自行下载)    2. 如果大家想了解课程详情，或者售后有问题想咨询的同学，可以加入Pizza猫老师的售后QQ群 960074053 注明: CSDN学院学员课程适合什么样的人：    1. 立志于做出自己的上架的独立游戏的开发者    2. 中小型游戏开发团队的主程序    3. 目前大学在读并想要进入游戏行业的大学生课程特点：    1. 全程以实践为主，以做出真实的项目成果为第一目标    2. 非常实用，课程的代码可以直接使用在实际的商业项目中Orleans官网：    https://learn.microsoft.com/zh-cn/dotnet/orleans/环境要求：    Win10/11系统    Visual Studio 2022    Unity2022.3.42f1c1
Orleans 2.0 官方文档中文版 （闫辉）
uddiqpl的专栏
02-10 7320
目录 第一章 概览 1.1 概览 -&gt; 介绍 1.2 概览 -&gt; 优点 1.3 概览 -&gt; 常见问题 1.4 概览 -&gt; Orleans 2.0 1.5 概览 -&gt; Orleans更新历史 第二章 入门教程与示例 2.1 入门教程与示例 -&gt; 概览 2.2 入门教程与示例 -&gt; 入门教程1：Orleans基础 2.3 入门教程与示例 -...
orleans-samples:示例项目
07-01
奥尔良样品 示例奥尔良项目。
Orleans 基础示例
一个有料的码农
06-22 1479
.NET 开发人员构建分布式应用的框架—— Orleans
Orleans 2.0 官方文档 —— 2.1 入门教程与示例 -> 概览
uddiqpl的专栏
01-06 1221
教程 教程1：Orleans基础知识 教程1指导您完成创建结构和设置第一个Orleans应用程序的包和引用的步骤。 示例 你需要什么 示例是自包含的，除非另有说明。某些示例可能需要Azure订阅。对于基于Azure的示例，您需要安装SDK。 示例可以从GitHub下载。 Hello, World Orleans版的经典Hello World应用程序。这表明，虽然在处理分布式计算时不...
Orleans框架分析
最新发布
weixin_42804968的博客
04-10 876
本文想深入了解Orleans silo启动流程，grain之间调用，以及网络底层实现原理
OrleansContrib/Orleankka 项目使用教程
gitblog_00240的博客
04-06 553
OrleansContrib/Orleankka 项目使用教程 1. 项目的目录结构及介绍 Orleankka 是一个基于 Microsoft Orleans 框架的功能性扩展，其目录结构如下： .config: 包含项目配置文件。 Docs: 存放项目文档。 Samples: 包含示例代码，用于演示如何使用 Orleankka。 Source: 项目的主要源代码，包括核心功能实现。 Tests...
Orleans 2.0 官方文档 —— 4.5 Grains -> 观察者
uddiqpl的专栏
01-11 1449
观察者 在某些情况下，简单的消息/响应模式是不够的，客户端需要接收异步通知。例如，用户可能希望在朋友发布新的即时消息时得到通知。 客户端的观察者是一种允许异步通知客户端的机制。观察者是从IGranobserver继承的单向异步接口，它的所有方法都必须是void。grain通过像grain接口方法一样，调用它向观察者发送通知，只不过它没有返回值，因此grain不需要依赖于结果。Orleans运行...
Orleans介绍
weixin_30915951的博客
12-22 496
一、介绍 Orleans是一个框架，提供了一个直接的方法来构建分布式高规模计算应用程序 默认可扩展 -》 Orleans处理构建分布式系统的复杂性，使您的应用程序能够扩展到数百台服务器。低延迟 -》 Orleans允许你在内存中保持你需要的状态，所以你的应用程序可以快速响应传入的请求。简化的并发性-》 Orleans允许你编写简单的单线程C＃代码，处理异步消息在对象（Grains）之间传递...
Orleans入门实战示例教程（1.5.4版本）
- 考虑到性能和稳定性，要对Orleans应用进行充分的压力测试和性能优化。 - 根据具体业务需求，可能需要为Grain添加额外的错误处理和日志记录功能。 通过以上步骤和知识点的介绍，你应该对Orleans框架有了一个初步的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值