Service Locator

using UnityEngine;

namespace Patterns.Architectural.ServiceLocator
{
    /// <summary>
    /// A typical client. It asks the locator for services by interface and
    /// never cares which implementation answers.
    /// </summary>
    public class EnemyClient : MonoBehaviour
    {
        private IAudioService audio;
        private IAnalyticsService analytics;

        private void Start()
        {
            // Cache lookups once instead of resolving every frame.
            audio = ServiceLocator.Get<IAudioService>();
            analytics = ServiceLocator.Get<IAnalyticsService>();
        }

        public void Die()
        {
            audio.Play("enemy_death");
            analytics.Track("enemy_killed", name);
            Destroy(gameObject);
        }
    }
}

using System;
using System.Collections.Generic;
using UnityEngine;

namespace Patterns.Architectural.ServiceLocator
{
    /// <summary>
    /// A static type-to-instance registry. Missing services fall back to a
    /// registered Null Object when one exists.
    /// </summary>
    public static class ServiceLocator
    {
        private static readonly Dictionary<Type, object> services = new();
        private static readonly Dictionary<Type, object> fallbacks = new();

        public static void Register<T>(T service) where T : class =>
            services[typeof(T)] = service ?? throw new ArgumentNullException(nameof(service));

        public static void Unregister<T>() where T : class => services.Remove(typeof(T));

        public static void RegisterFallback<T>(T nullService) where T : class =>
            fallbacks[typeof(T)] = nullService;

        public static T Get<T>() where T : class
        {
            if (services.TryGetValue(typeof(T), out var service))
                return (T)service;

            if (fallbacks.TryGetValue(typeof(T), out var fallback))
            {
                Debug.LogWarning($"ServiceLocator: {typeof(T).Name} not registered, using fallback.");
                return (T)fallback;
            }

            throw new InvalidOperationException($"ServiceLocator: no service for {typeof(T).Name}.");
        }

        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
        private static void ResetStatics()
        {
            services.Clear();
            fallbacks.Clear();
        }
    }
}

using UnityEngine;

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

    /// <summary>Records gameplay events for analytics.</summary>
    public interface IAnalyticsService
    {
        void Track(string eventName, string detail);
    }

    /// <summary>Real audio implementation.</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 (clip != null) source.PlayOneShot(clip);
        }
    }

    /// <summary>Null Object: safe to call, does nothing.</summary>
    public class NullAudioService : IAudioService
    {
        public void Play(string clipId) { }
    }

    /// <summary>Debug analytics that just prints.</summary>
    public class ConsoleAnalytics : IAnalyticsService
    {
        public void Track(string eventName, string detail) =>
            Debug.Log($"[Analytics] {eventName}: {detail}");
    }

    /// <summary>Null Object for analytics (e.g. user opted out).</summary>
    public class NullAnalytics : IAnalyticsService
    {
        public void Track(string eventName, string detail) { }
    }
}

using UnityEngine;

namespace Patterns.Architectural.ServiceLocator
{
    /// <summary>
    /// Registers services before any scene loads, plus Null Object
    /// fallbacks so optional services never cause null references.
    /// </summary>
    public static class GameBootstrap
    {
        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
        private static void Init()
        {
            ServiceLocator.RegisterFallback<IAudioService>(new NullAudioService());
            ServiceLocator.RegisterFallback<IAnalyticsService>(new NullAnalytics());

            var audioHost = new GameObject("[Audio]");
            Object.DontDestroyOnLoad(audioHost);
            var source = audioHost.AddComponent<AudioSource>();

            ServiceLocator.Register<IAudioService>(new UnityAudioService(source));

#if DEVELOPMENT_BUILD || UNITY_EDITOR
            ServiceLocator.Register<IAnalyticsService>(new ConsoleAnalytics());
#endif
        }

        /// <summary>Example of a runtime swap, e.g. from a settings menu.</summary>
        public static void MuteAll() =>
            ServiceLocator.Register<IAudioService>(new NullAudioService());
    }
}