题3答案-多线程的前端网络框架

//多线程的前端网络框架
using System;
using System.Collections.Generic;
using System.Threading;

// 定义请求类，包含请求的基本信息
public class NetworkRequest
{
    public string Id { get; set; }
    public string Url { get; set; }
    public string Method { get; set; }
    public object Data { get; set; }
    public Action<NetworkResponse> Callback { get; set; }

    public NetworkRequest(string id, string url, string method, object data, Action<NetworkResponse> callback)
    {
        Id = id;
        Url = url;
        Method = method;
        Data = data;
        Callback = callback;
    }
}

// 定义响应类，包含响应的基本信息
public class NetworkResponse
{
    public int StatusCode { get; set; }
    public object Data { get; set; }

    public NetworkResponse(int statusCode, object data)
    {
        StatusCode = statusCode;
        Data = data;
    }
}

// 线程池类，管理多个工作线程
public class ThreadPoolManager
{
    private List<Thread> _threads;
    private int _maxThreads;

    public ThreadPoolManager(int _maxThreads)
    {
        this._maxThreads = _maxThreads;
        _threads = new List<Thread>();
        InitializeThreads();
    }

    private void InitializeThreads()
    {
        for (int i = 0; i < _maxThreads; i++)
        {
            Thread thread = new Thread(WorkLoop);
            thread.IsBackground = true;
            _threads.Add(thread);
            thread.Start();
        }
    }

    private void WorkLoop()
    {
        while (true)
        {
            if (RequestQueue.HasPendingRequests())
            {
                NetworkRequest request = RequestQueue.GetNextRequest();
                if (request != null)
                {
                    ProcessRequest(request);
                }
            }
            else
            {
                Thread.Sleep(100); // 没有请求时适当休眠，减少 CPU 占用
            }
        }
    }

    private void ProcessRequest(NetworkRequest request)
    {
        NetworkResponse response = RequestProcessor.Process(request);
        request.Callback?.Invoke(response);
    }
}

// 请求队列类，管理待处理的网络请求
public static class RequestQueue
{
    private static Queue<NetworkRequest> _requests = new Queue<NetworkRequest>();
    private static readonly object lockObject = new object();

    public static void AddRequest(NetworkRequest request)
    {
        lock (lockObject)
        {
            _requests.Enqueue(request);
        }
    }

    public static bool HasPendingRequests()
    {
        lock (lockObject)
        {
            return _requests.Count > 0;
        }
    }

    public static NetworkRequest GetNextRequest()
    {
        lock (lockObject)
        {
            if (_requests.Count > 0)
            {
                return _requests.Dequeue();
            }
            return null;
        }
    }
}

// 请求处理器类，负责实际执行网络请求
public static class RequestProcessor
{
    public static NetworkResponse Process(NetworkRequest request)
    {
        // 这里可以替换为实际的网络请求代码，例如使用 HttpClient
        // 模拟网络请求耗时
        Thread.Sleep(1000);
        return new NetworkResponse(200, $"Response for {request.Url}");
    }
}

// 前端网络框架类，提供对外的接口
public class NetManager
{
    private ThreadPoolManager _threadPool;

    public NetManager(int _maxThreads)
    {
        _threadPool = new ThreadPoolManager(_maxThreads);
    }

    public void SendRequest(NetworkRequest request)
    {
        RequestQueue.AddRequest(request);
    }
}