Unity 代理模式（实例详解）

文章目录

- - 实例1：资源加载代理（Asset Loading Proxy）
  - 实例2：网络请求代理（Network Request Proxy）
  - 实例3：性能优化代理（Performance Optimization Proxy）
  - 实例4：权限控制代理（Authorization Control Proxy）
  - 实例5：热更新代理（Hot Reload Proxy）

在Unity游戏开发中，代理模式（Proxy Design Pattern）用于为另一个对象提供一个代理以控制对这个对象的访问。以下是在Unity环境下实现代理模式的5个不同代码实例说明：

实例1：资源加载代理（Asset Loading Proxy）

// 原始资源加载接口
public interface IResourceLoader
{
    Texture2D LoadTexture(string path);
}

// 真实资源加载器
public class RealResourceLoader : IResourceLoader
{
    public Texture2D LoadTexture(string path)
    {
        return Resources.Load<Texture2D>(path);
    }
}

// 资源加载代理，负责异步加载并缓存资源
public class AssetLoadingProxy : IResourceLoader
{
    private Dictionary<string, IEnumerator> _loadingTasks;
    private RealResourceLoader _realLoader;

    public AssetLoadingProxy()
    {
        _loadingTasks = new Dictionary<string, IEnumerator>();
        _realLoader = new RealResourceLoader();
    }

    public IEnumerator LoadTextureAsync(string path, Action<Texture2D> onLoaded)
    {
        if (!_loadingTasks.ContainsKey(path))
        {
            var www = UnityWebRequestTexture.GetTexture(path);
            yield return www.SendWebRequest();

            if (www.result == UnityWebRequest.Result.Success)
            {
                var texture = DownloadHandlerTexture.GetContent(www);
                _loadingTasks[path] = null; // 移除任务记录，避免重复加载
                onLoaded?.Invoke(texture);
            }
            else
            {
                Debug.LogError($"Failed to load texture: {www.error}");
            }
        }
        else
        {
            while (_loadingTasks[path] != null)
            {
                yield return null; // 等待资源完成加载
            }
            onLoaded?.Invoke(_realLoader.LoadTexture(path)); // 加载完成后调用回调
        }
    }
}

实例2：网络请求代理（Network Request Proxy）

// 网络请求接口
public interface INetworkService
{
    void SendRequest(string url, Action<string> onResponse);
}

// 真实网络服务类
public class RealNetworkService : INetworkService
{
    public void SendRequest(string url, Action<string> onResponse)
    {
        StartCoroutine(SendRequestCoroutine(url, onResponse));
    }

    private IEnumerator SendRequestCoroutine(string url, Action<string> onResponse)
    {
        using (var request = UnityWebRequest.Get(url))
        {
            yield return request.SendWebRequest();

            if (request.result == UnityWebRequest.Result.Success)
            {
                onResponse(request.downloadHandler.text);
            }
            else
            {
                Debug.LogError($"Error sending network request: {request.error}");
            }
        }
    }
}

// 网络请求代理，添加了请求队列和错误重试机制
public class NetworkRequestProxy : INetworkService
{
    private INetworkService _realService;
    private Queue<Action> _requestQueue;
    private int _maxRetryCount;

    public NetworkRequestProxy(INetworkService realService, int maxRetries)
    {
        _realService = realService;
        _requestQueue = new Queue<Action>();
        _maxRetryCount = maxRetries;
    }

    public void SendRequest(string url, Action<string> onResponse)
    {
        _requestQueue.Enqueue(() => _realService.SendRequest(url, response =>
        {
            if (!string.IsNullOrEmpty(response) || --_maxRetryCount < 0)
            {
                onResponse(response);
            }
            else
            {
                SendRequest(url, onResponse); // 重试请求
            }
        }));

        ProcessNextRequest(); // 开始处理队列中的下一个请求
    }

    private void ProcessNextRequest()
    {
        if (_requestQueue.Count > 0)
        {
            var nextAction = _requestQueue.Dequeue();
            StartCoroutine(ProcessRequestCoroutine(nextAction));
        }
    }

    private IEnumerator ProcessRequestCoroutine(Action action)
    {
        yield return new WaitForSeconds(0.1f); // 假设这里有防止频繁请求的间隔
        action();
    }
}

实例3：性能优化代理（Performance Optimization Proxy）

// 高级图形渲染组件接口
public interface IAdvancedRenderer
{
    void RenderHighQualityMesh(Mesh mesh);
}

// 真实高级渲染组件
public class RealAdvancedRenderer : IAdvancedRenderer
{
    public void RenderHighQualityMesh(Mesh mesh)
    {
        // 执行高质量、高消耗的渲染操作
        // ...
    }
}

// 性能优化代理，根据设备性能动态调整渲染质量
public class PerformanceProxyRenderer : IAdvancedRenderer
{
    private IAdvancedRenderer _realRenderer;
    private bool _isLowEndDevice;

    public PerformanceProxyRenderer(IAdvancedRenderer realRenderer, SystemInfo systemInfo)
    {
        _realRenderer = realRenderer;
        _isLowEndDevice = systemInfo.graphicsMemorySize < 1024; // 假设低于1GB显存的设备是低端设备
    }

    public void RenderHighQualityMesh(Mesh mesh)
    {
        if (!_isLowEndDevice)
        {
            _realRenderer.RenderHighQualityMesh(mesh);
        }
        else
        {
            // 执行低质量、低消耗的替代渲染操作
            RenderLowQualityMesh(mesh);
        }
    }

    private void RenderLowQualityMesh(Mesh mesh)
    {
        // ...
    }
}

实例4：权限控制代理（Authorization Control Proxy）

// 数据库访问接口
public interface IDataAccess
{
    void SaveData(UserData data);
}

// 真实数据库访问类
public class RealDataAccess : IDataAccess
{
    public void SaveData(UserData data)
    {
        // 存储用户数据到数据库
        // ...
    }
}

// 权限控制代理，确保只有管理员可以写入数据
public class AuthorizationProxy : IDataAccess
{
    private IDataAccess _realAccess;
    private IUserService _userService;

    public AuthorizationProxy(IDataAccess realAccess, IUserService userService)
    {
        _realAccess = realAccess;
        _userService = userService;
    }

    public void SaveData(UserData data)
    {
        if (_userService.IsCurrentUserAdmin())
        {
            _realAccess.SaveData(data);
        }
        else
        {
            Debug.LogWarning("Non-admin user attempted to save data.");
        }
    }
}

实例5：热更新代理（Hot Reload Proxy）

// MonoBehavior基类
public abstract class MonoBehaviourBase : UnityEngine.MonoBehaviour
{
    // 公共方法声明...
}

// 热更脚本接口
public interface IHotReloadable
{
    void OnHotReload();
}

// 热更代理MonoBehavior
public class HotReloadProxy : MonoBehaviourBase
{
    private IHotReloadable _hotReloadTarget;

    public void SetHotReloadTarget(IHotReloadable target)
    {
        _hotReloadTarget = target;
    }

    void Update()
    {
        // 如果目标实现了热更接口，则在Update时触发OnHotReload
        if (_hotReloadTarget != null && Application.isEditor && UnityEditor.EditorUtility.IsDirty(targetScript))
        {
            _hotReloadTarget.OnHotReload();
        }
    }
}

// 真实业务逻辑脚本，通过ILRuntime或类似技术热更新
[HotReloading]
public class RealBusinessLogic : IHotReloadable
{
    public void OnHotReload()
    {
        // 重新加载业务逻辑
        // ...
    }

    // 其他业务逻辑...
}