Dependency Injection

using UnityEngine;

namespace Patterns.Architectural.DependencyInjection
{
    /// <summary>
    /// The composition root. It is the only place that knows which concrete
    /// services exist; everything else receives interfaces.
    /// </summary>
    [DefaultExecutionOrder(-100)]
    public class GameInstaller : MonoBehaviour
    {
        public enum SaveBackend { File, Cloud }

        [SerializeField] private Player player;
        [SerializeField] private SaveBackend saveBackend = SaveBackend.File;
        [SerializeField] private bool muteAudioForTests;

        private void Awake()
        {
            if (player == null)
            {
                Debug.LogError("GameInstaller: Player reference is missing.", this);
                return;
            }

            ILogger logger = new UnityConsoleLogger();

            IAudioService audio = muteAudioForTests
                ? new SilentAudioService()
                : new UnityAudioService(GetComponent<AudioSource>());

            ISaveService save = saveBackend == SaveBackend.Cloud
                ? new CloudSaveService(logger)
                : new FileSaveService(logger);

            // Method injection: MonoBehaviours cannot use constructors.
            player.Inject(logger, audio, save);
        }
    }
}

using UnityEngine;

namespace Patterns.Architectural.DependencyInjection
{
    /// <summary>
    /// A consumer that only knows about interfaces. It never creates or
    /// searches for its services — they are handed to it.
    /// </summary>
    public class Player : MonoBehaviour
    {
        private ILogger logger;
        private IAudioService audio;
        private ISaveService save;

        public int Gold { get; private set; }

        public void Inject(ILogger logger, IAudioService audio, ISaveService save)
        {
            this.logger = logger;
            this.audio = audio;
            this.save = save;
            logger.Log($"Player injected with {save.GetType().Name}");
        }

        public void CollectCoin()
        {
            Gold++;
            audio.Play("coin");
        }

        public void Save()
        {
            if (save == null)
            {
                Debug.LogError("Player.Save called before Inject.", this);
                return;
            }

            save.Write("gold", Gold.ToString());
            audio.Play("save");
            logger.Log($"Saved {Gold} gold");
        }
    }
}

namespace Patterns.Architectural.DependencyInjection
{
    /// <summary>Writes diagnostic messages somewhere.</summary>
    public interface ILogger
    {
        void Log(string message);
    }

    /// <summary>Plays named sound effects.</summary>
    public interface IAudioService
    {
        void Play(string clipId);
    }

    /// <summary>Persists simple key/value data.</summary>
    public interface ISaveService
    {
        void Write(string key, string value);
        string Read(string key, string fallback = "");
    }
}

using System.IO;
using UnityEngine;

namespace Patterns.Architectural.DependencyInjection
{
    /// <summary>Logger that forwards to the Unity console.</summary>
    public class UnityConsoleLogger : ILogger
    {
        public void Log(string message) => Debug.Log($"[Game] {message}");
    }

    /// <summary>Real audio backed by an AudioSource and Resources clips.</summary>
    public class UnityAudioService : IAudioService
    {
        private readonly AudioSource source;

        public UnityAudioService(AudioSource source) => this.source = source;

        public void Play(string clipId)
        {
            var clip = Resources.Load<AudioClip>($"Audio/{clipId}");
            if (source != null && clip != null) source.PlayOneShot(clip);
        }
    }

    /// <summary>Does nothing. Perfect for tests and headless builds.</summary>
    public class SilentAudioService : IAudioService
    {
        public void Play(string clipId) { }
    }

    /// <summary>Saves each key to a file in persistentDataPath.</summary>
    public class FileSaveService : ISaveService
    {
        private readonly ILogger logger;

        public FileSaveService(ILogger logger) => this.logger = logger;

        private static string PathFor(string key) =>
            Path.Combine(Application.persistentDataPath, key + ".txt");

        public void Write(string key, string value)
        {
            File.WriteAllText(PathFor(key), value);
            logger.Log($"File write: {PathFor(key)}");
        }

        public string Read(string key, string fallback = "") =>
            File.Exists(PathFor(key)) ? File.ReadAllText(PathFor(key)) : fallback;
    }

    /// <summary>Stand-in for a cloud backend (would call a web API).</summary>
    public class CloudSaveService : ISaveService
    {
        private readonly ILogger logger;

        public CloudSaveService(ILogger logger) => this.logger = logger;

        public void Write(string key, string value) =>
            logger.Log($"Cloud PUT /save/{key} = {value}");

        public string Read(string key, string fallback = "") => fallback;
    }
}