Proxy

using UnityEngine;
using UnityEngine.UI;

namespace Patterns.Structural.Proxy
{
    /// <summary>
    /// Client. Asks its provider for a texture every time it is shown.
    /// It cannot tell whether it holds a proxy or the real thing.
    /// </summary>
    public class InventorySlot : MonoBehaviour
    {
        [SerializeField] private RawImage icon;
        [SerializeField] private string assetKey = "Icons/DragonSword_4K";
        [SerializeField] private Texture2D placeholder;

        private ITextureProvider provider;

        private void Awake()
        {
            provider = new TextureProxy(assetKey, placeholder);
        }

        private void OnEnable()
        {
            icon.texture = provider.GetTexture();
            provider.Loaded += OnLoaded;
        }

        private void OnDisable()
        {
            provider.Loaded -= OnLoaded;
        }

        private void OnLoaded(Texture2D texture) => icon.texture = texture;
    }
}

using System;
using UnityEngine;

namespace Patterns.Structural.Proxy
{
    /// <summary>
    /// Subject interface shared by the real texture and its proxy.
    /// </summary>
    public interface ITextureProvider
    {
        /// <summary>
        /// Returns the best texture available right now. For a proxy this
        /// may be a placeholder until the real asset finishes loading.
        /// </summary>
        Texture2D GetTexture();

        /// <summary>Raised once the full-quality texture is available.</summary>
        event Action<Texture2D> Loaded;
    }
}

using System;
using UnityEngine;

namespace Patterns.Structural.Proxy
{
    /// <summary>
    /// Real subject: owns a heavy, fully loaded texture. Constructing one
    /// is expensive, which is exactly why we hide it behind a proxy.
    /// </summary>
    public class RealTexture : ITextureProvider
    {
        private readonly Texture2D texture;

        public RealTexture(Texture2D loaded)
        {
            texture = loaded != null ? loaded : throw new ArgumentNullException(nameof(loaded));
            Debug.Log($"RealTexture ready: {texture.name} ({texture.width}x{texture.height})");
        }

        public Texture2D GetTexture() => texture;

        // Already loaded, so subscribers are notified immediately.
        public event Action<Texture2D> Loaded
        {
            add => value?.Invoke(texture);
            remove { }
        }
    }
}

using System;
using UnityEngine;

namespace Patterns.Structural.Proxy
{
    /// <summary>
    /// Virtual proxy: returns a placeholder at once, loads the real
    /// texture lazily on first request, then caches it for everyone.
    /// </summary>
    public class TextureProxy : ITextureProvider
    {
        private readonly string key;
        private readonly Texture2D placeholder;
        private RealTexture real;
        private ResourceRequest pending;

        public TextureProxy(string key, Texture2D placeholder)
        {
            this.key = key;
            this.placeholder = placeholder;
        }

        public event Action<Texture2D> Loaded;

        public bool IsLoaded => real != null;

        public Texture2D GetTexture()
        {
            if (real != null) return real.GetTexture();   // cache hit: instant

            if (pending == null)                          // first request only
            {
                pending = Resources.LoadAsync<Texture2D>(key);
                pending.completed += OnCompleted;
            }

            return placeholder;
        }

        private void OnCompleted(AsyncOperation _)
        {
            real = new RealTexture((Texture2D)pending.asset);
            pending = null;
            Loaded?.Invoke(real.GetTexture());
        }
    }

    /// <summary>
    /// Protection proxy: same interface, but only forwards to the inner
    /// provider when the player owns the item.
    /// </summary>
    public class ProtectedTextureProxy : ITextureProvider
    {
        private readonly ITextureProvider inner;
        private readonly Func<bool> isOwned;
        private readonly Texture2D locked;

        public ProtectedTextureProxy(ITextureProvider inner, Func<bool> isOwned, Texture2D locked)
        {
            this.inner = inner;
            this.isOwned = isOwned;
            this.locked = locked;
        }

        public event Action<Texture2D> Loaded
        {
            add => inner.Loaded += value;
            remove => inner.Loaded -= value;
        }

        public Texture2D GetTexture() => isOwned() ? inner.GetTexture() : locked;
    }
}