Orleans[NET Core 3.1] 学习笔记（四）（ 1 ）创建项目

classroom

classroom是一个练手demo，目的是为了能熟悉掌握orleans的基本知识和使用方法，我会尽量在这个项目中加入更多的知识点，一边学一边练避免我看完文档就忘掉

创建项目

依旧是四个项目起步

项目名称	项目类型	项目说明
igrains	.net core 3.1 类库	grain接口库
grains	.net core 3.1 类库	实现grain的类库
silo_consoleapp	.net core 3.1 控制台	silo服务
client_consoleapp	.net core 3.1 控制台	客户端程序

引用类库

igrains：
microsoft.orleans.core.abstractions（3.0.2）
microsoft.orleans.codegenerator.msbuild（3.0.2）

grains：
microsoft.orleans.core.abstractions（3.0.2）
microsoft.orleans.codegenerator.msbuild（3.0.2）

silo_consoleapp：
microsoft.orleans.server（3.0.2）

client_consoleapp：
microsoft.orleans.client（3.0.2）

igrains 定义

using system.threading.tasks;

namespace igrains
{
    /// <summary>
    /// 学生
    /// </summary>
    public interface istudent : orleans.igrainwithintegerkey
    {
        /// <summary>
        /// 打招呼
        /// </summary>
        /// <returns></returns>
        task<string> sayhello();
    }
}

注意orleans.igrainwithintegerkey，这个决定了grain的key的类型，是long还是string，或者guid.

再加个控制台日志帮助类

using system;

namespace igrains
{
    /// <summary>
    /// 控制台帮助类
    /// </summary>
    public static class consolehelper
    {

        static void writecolorline(string str, consolecolor color)
        {
            consolecolor currentforecolor = console.foregroundcolor;
            console.foregroundcolor = color;
            console.writeline(str);
            console.foregroundcolor = currentforecolor;
        }

        /// <summary>
        /// 打印错误信息
        /// </summary>
        /// <param name="str">待打印的字符串</param>
        /// <param name="color">想要打印的颜色</param>
        public static void writeerrorline(this string str, consolecolor color = consolecolor.red)
        {
            writecolorline(str, color);
        }

        /// <summary>
        /// 打印警告信息
        /// </summary>
        /// <param name="str">待打印的字符串</param>
        /// <param name="color">想要打印的颜色</param>
        public static void writewarningline(this string str, consolecolor color = consolecolor.yellow)
        {
            writecolorline(str, color);
        }
        /// <summary>
        /// 打印正常信息
        /// </summary>
        /// <param name="str">待打印的字符串</param>
        /// <param name="color">想要打印的颜色</param>
        public static void writeinfoline(this string str, consolecolor color = consolecolor.white)
        {
            writecolorline(str, color);
        }
        /// <summary>
        /// 打印成功的信息
        /// </summary>
        /// <param name="str">待打印的字符串</param>
        /// <param name="color">想要打印的颜色</param>
        public static void writesuccessline(this string str, consolecolor color = consolecolor.green)
        {
            writecolorline(str, color);
        }
    }
}

grains 定义

using igrains;
using system;
using system.threading.tasks;

namespace grains
{
    /// <summary>
    /// 学生 
    /// </summary>
    public class student : orleans.grain, istudent
    {
        /// <summary>
        /// 打招呼
        /// </summary>
        /// <returns></returns>
        public task<string> sayhello()
        {
            var id = this.grainreference.grainidentity.primarykeylong;//当前grain的key
            console.writeline($"\n {id}收到sayhello消息 \n");
            return task.fromresult($"\n 大家好，我是{id} \n");
        }
    }
}

这里我使用了grainreference.grainidentity.primarykeylong，这个值就是当前grain的idkey值，有了它grain才能知道自己是谁. =_=!

silo_consoleapp

using grains;
using orleans;
using orleans.configuration;
using orleans.hosting;
using system;
using system.net;
using system.threading.tasks;

namespace silo_consoleapp
{
    class program
    {
        static async task main(string[] args)
        {
            console.writeline("开始启动silo!");
            try
            {
                var host = await startsilo();
                console.writeline("silo启动完成");
                console.writeline("\n\n 按回车键停止 \n\n");
                console.readline();
                await host.stopasync();//停止当前silo
                return;
            }
            catch (exception ex)
            {
                console.writeline(ex);
                return;
            }
        }

        /// <summary>
        /// 启动本地配置
        /// </summary>
        /// <returns></returns>
        private static async task<isilohost> startsilo()
        {
            var host = new silohostbuilder()
                 .uselocalhostclustering()                     //配置silo只使用开发集群，并监听本地主机。
                 .configure<clusteroptions>(options =>
                 {
                     options.clusterid = "dev";
                     options.serviceid = "myhost";             //获取或设置此服务的唯一标识符，该标识符应在部署和重新部署后仍然有效
                 })
                 .configure<endpointoptions>(options => options.advertisedipaddress = ipaddress.loopback)//配置silo的端口
                 .configureapplicationparts(parts => parts.addapplicationpart(typeof(student).assembly).withreferences())
                 .build();
            await host.startasync();//启动当前silo.
            return host;
        }
    }
}

先用本地开发配置

client_consoleapp

using igrains;
using orleans;
using orleans.configuration;
using system;
using system.threading.tasks;

namespace client_consoleapp
{
    class program
    {
        static async task main(string[] args)
        {
            console.writeline("开始启动silo!");
            try
            {
                using (var client = await connectclient())
                {
                    console.writeline("客户端已成功连接到silo host  \n");
                    await doclientwork(client);
                }
            }
            catch (exception ex)
            {
                console.writeline(ex);
            }
            console.writeline("\n\n 按任意键退出 \n\n");
            console.readkey();
            return;
        }

        private static async task doclientwork(iclusterclient client)
        {
            //从客户端调用grain的示例
            var student = client.getgrain<istudent>(321);
            var response = await student.sayhello();
            console.writeline("\n\n{0}\n\n", response);
        }

        /// <summary>
        /// 使用本地配置连接服务
        /// </summary>
        /// <returns></returns>
        private static async task<iclusterclient> connectclient()
        {
            iclusterclient client;
            client = new clientbuilder()
                .uselocalhostclustering()           //配置客户端以连接到本地主机上的筒仓。
                .configure<clusteroptions>(options =>
                {
                    options.clusterid = "dev";
                    options.serviceid = "myhost";
                })
                .build();
            await client.connect();
            return client;
        }
    }
}

同样适用本地配置

修改发布设置

.net core 的程序有个比较烦的地方，每次编译都会编译出来一大堆文件，看着心烦。

还好微软给了咱一个单文件发布的方法，可以把这些文件打到一个文件里，下面我来举个栗子

右键silo_consoleapp项目，选择发布，然后选择发布到本地文件夹，修改为如下配置：

然后点一下发布，咱们在选择的文件夹里就能看到它了：

client_consoleapp可以执行同样的操作

运行程序

咱们把silo和client程序都跑起来，注意，要先启动silo程序，等待silo启动成功后再启动client。

运行效果如下：

便捷路由

目录 ： orleans[net core 3.1] 学习笔记（一）.net环境下的分布式应用程序

上一节 ：orleans[net core 3.1] 学习笔记（三）（ 3 ）服务端配置

下一节 ：