# server-framework

**Repository Path**: Among_the_universe/server-framework

## Basic Information

- **Project Name**: server-framework
- **Description**: 这是一个基于 .NET Core 的服务端框架。
- **Primary Language**: C#
- **License**: GPL-3.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-06-24
- **Last Updated**: 2025-07-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: 服务端, 框架, dotNET, 网络

## README

# ServerFramework

### 介绍

这是一个基于 .NET Core 的服务端框架。

### 软件架构

- **ServerFramework.core**：提供核心服务基类、依赖注入、单例模式等基础功能。
- **ServerFramework.network**：实现基于 TCP/UDP 的网络通信，支持绑定配置、异步处理等功能。
- **ServerFramework.timer**：提供定时任务调度功能，支持周期性任务和严格时间控制。
- **ServerFramework.cluster**：支持集群节点管理和主从架构，便于构建分布式系统。
- **ServerFramework.delegates**：实现委托模式，用于事件驱动的开发方式。

### 安装教程

在 NuGet 中搜索 'Nobita.ServerFramework' 安装相关的包。

| 包名称                              | 版本    | 状态 |
|----------------------------------|-------|----|
| Nobita.ServerFramework.Core      | 1.1.0 | 正常 |
| Nobita.ServerFramework.Network   | 1.1.0 | 正常 |
| Nobita.ServerFramework.Timer     | 1.1.0 | 正常 |
| Nobita.ServerFramework.Cluster   | 1.1.0 | 正常 |
| Nobita.ServerFramework.Delegates | 1.1.0 | 正常 |

### 使用说明

- **Attribute 说明**

| Attribute         | 位置                               | 作用                                   |
|-------------------|----------------------------------|--------------------------------------|
| [Abstract]        | Nobita.ServerFramework.Core      | 标记抽象服务，在自动反射时忽略                      |
| [Singleton]       | Nobita.ServerFramework.Core      | 标记单例服务，在自动反射时注册单例                    |
| [Name]            | Nobita.ServerFramework.Core      | 命名服务，在自动反射时注册命名服务                    |
| [Dependency]      | Nobita.ServerFramework.Core      | 设置依赖的服务，确定服务启动和关闭的先后顺序               |
| [InstanceCount]   | Nobita.ServerFramework.Core      | 设置实例数量，用于控制服务实例的数量                   |
| [Bind]            | Nobita.ServerFramework.Network   | 硬编码绑定IP地址和端口                         |
| [BindJson]        | Nobita.ServerFramework.Network   | 通过配置文件绑定IP地址和端口                      |
| [Backlog]         | Nobita.ServerFramework.Network   | 设置TCP连接的缓冲区大小                        |
| [BufferSize]      | Nobita.ServerFramework.Network   | 设置UDP数据包的缓冲区大小                       |
| [SocketInfo]      | Nobita.ServerFramework.Network   | 设置Socket的信息                          |
| [Delegate]        | Nobita.ServerFramework.Delegates | 设置委托                                 |
| [DelegateFixture] | Nobita.ServerFramework.Delegates | 设置委托的容器类                             |
| [Period]          | Nobita.ServerFramework.Timer     | 设置定时任务执行周期(毫秒)                       |
| [Strict]          | Nobita.ServerFramework.Timer     | 严格模式,任务启动后会暂停定时器，任务结束后恢复(默认为false)   |
| [Parallel]        | Nobita.ServerFramework.Cluster   | 设置集群最大和最小的处理节点数（推荐优先使用线程池，除非要保证先后顺序） |

- **BindJson配置文件格式**

本框架采用约定大于配置的设计思路，所有使用了BindJsonAttribute的服务会自动按照 'services:serviceName' 路径去搜索。

```
{
  "services": {
    "tcpserviceimplement": {
      "address": "0.0.0.0",
      "port": 8080
    },
    "udpserviceimplement": {
      "address": "0.0.0.0",
      "port": 8082
    }
  }
}
```

- **创建TCP服务**

```
[Singleton]
[Name(nameof(TcpServiceImplement))]
[BindJson("application.json")]
[Backlog(100)]
[Dependency(typeof(UdpServiceImplement))]
public sealed class TcpServiceImplement : TcpService
{
    protected override Task OnProcessAsync(TcpContext context, CancellationToken token)
    {
        throw new NotImplementedException();
    }
}
```

- **创建UDP服务**

```
[Singleton]
[Name(nameof(UdpServiceImplement))]
[BindJson("application.json")]
[BufferSize(1024)]
public sealed class UdpServiceImplement : UdpService
{
    protected override Task OnProcessAsync(UdpContext context, CancellationToken token)
    {
        throw new NotImplementedException();
    }
}
```

- **创建定时器服务**

```
[Singleton]
[Strict]
[Period(1000)]
[Name(nameof(TimerImplement))]
[Dependency(typeof(TcpServiceImplement))]
[Dependency(typeof(UdpServiceImplement))]
public sealed class TimerImplement(IServiceProvider provider) : TimerService
{
    private IServiceProvider Provider { get; } = provider;
    protected override void OnTimer(object? state)
    {
        Console.WriteLine("Provider: " + Provider);
    }
}
```

- **创建集群服务**

```
[Singleton]
[Name(nameof(TestCluster))]
[Parallel(1, 2)]
private class TestCluster : ClusterMaster
{
    public TestCluster()
    {
        OnIncreased += (sender, args) =>
        {
            Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} Increased: " + args.CurrentCount);
        };
        OnDecreased += (sender, args) =>
        {
            Console.WriteLine($"{DateTime.Now:yyyy-MM-dd HH:mm:ss} Decreased: " + args.CurrentCount);
        };
    }

    protected override void OnAction(object? param, CancellationToken token)
    {
        throw new NotImplementedException();
    }
}
```

- **启动服务程序**

```
// 创建服务端
var app = new ServerApplication();

// 配置服务端
app.MapDependencies()
   .MapServices()
   .UsePassiveMode();

// 运行服务端
app.Run();
```

### 特点

- **空依赖检测**

```
private void CheckEmptyWaiting()
{
    // 检测等待队列中是否存在空等待现象
    // 即某服务依赖了某服务，但该服务未在等待队列或者运行队列中
    // 因为依赖的服务只能是单例，所以检测类型就行
    if (Waiting.Any(x => x.Dependencies.Count > 0 &&
                         x.Dependencies.Any(dependency =>
                             Waiting.Any(y => y.GetType() == dependency) == false &&
                             Running.Any(y => y.GetType() == dependency) == false)))
        throw new ArgumentException("Empty waiting detected.");
}
```

- **循环依赖检测**

```
// 核心拓扑排序
...

// 检测是否存在循环依赖
// 如果结果的长度与入度表长度不一致，则说明存在循环依赖
if (result.Count != graph.Count) 
   throw new ArgumentException("Circular dependency detected.");
```

- **群组委托**

在本框架中，设计了一套便于维护与扩展的委托反射机制。通过 DelegateFixture 类定义委托容器，并借助群组（Group）配置，可将分散在多个容器中的委托进行统一聚合与管理。

每个容器可根据需要进行独立初始化，系统在运行时自动完成委托的注册与调用，实现了行为的灵活组织与动态执行。

```
[DelegateFixture("Analyze")]
public class UserHandlers
{
    public class UserHandlers()
    {
        // 进行相关的初始化
    }

    [Delegate("Login")]
    public async Task LoginHandler(object? param, CancellationToken token)
    {
        throw new NotImplementedException();
    }

    [Delegate("Register")]
    public async Task RegisterHandler(object? param, CancellationToken token)
    {
        throw new NotImplementedException();
    }

    [Delegate("Unregister")]
    public async Task UnregisterHandler(object? param, CancellationToken token)
    {
        throw new NotImplementedException();
    }
}

[DelegateFixture("Analyze")]
public class OtherHandlers
{
    public OtherHandlers()
    {
        // 进行相关的初始化
    }
    
    [Delegate("OtherProtocol")]
    public async Task OtherHandler(object? param, CancellationToken token)
    {
        throw new NotImplementedException();
    }
}

public class Program 
{
    public static void Main(string[] args)
    {
        // 创建委托注册表
        var registry = DelegateHelper.CreateRegistry("Analyze");
    
        // 触发委托
        await registry.InvokeAsync("Login", null, CancellationToken.None);
    }
}
```