Unity IOC

IOCContainer.cs

using Core;
using Services;
using Sirenix.OdinInspector;

namespace App
{
    public class IOCContainer
    {
        // Common.
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly UnityApp UnityApp;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly Clock Clock;

        // Resource Loaders.
        public readonly ResourceLoader ResourceLoader;
        public readonly CommonPopupLoader CommonPopupLoader;
        public readonly SlideNoitificationLoader SlideNoitificationLoader;
        public readonly CatUIThumbnailLoader CatUIThumbnailLoader;
        public readonly InterialUIThumbnailLoader InterialUIThumbnailLoader;
        public readonly TowerScenePrefabLoader TowerScenePrefabLoader;
        public readonly NonogramLevelLoader NonogramLevelLoader;

        // Data Loader & Providers.
        public readonly TableDownloader TableDownloader;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly DBProvider DBProvider;
        public readonly SettingsTableProvider SettingsTableProvider;
        public readonly CatTableProvider CatTableProvider;
        public readonly InterialTableProvider InterialTableProvider;

        // Model Loader & Providers.
        public readonly UserDataIO UserDataIO;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly UserDataProvider UserDataProvider;
        public readonly MeProvider MeProvider;
        public readonly EnergyStateProvider EnergyStateProvider;
        public readonly CatContainerProvider CatContainerProvider;
        public readonly TowerLevelProgressProvider TowerLevelProgressProvider;
        public readonly NonogramProgressStateProvider NonogramProgressStateProvider;
        public readonly NotificationBadgeStateProvider NotificationBadgeStateProvider;

        // Model Updater.
        public readonly CatNeedsSimulator CatNeedsSimulator;
        public readonly MeController MeController;
        public readonly EnergyController EnergyController;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly NotificationBadgeBroadcast NotificationBadgeBroadcast;
        public readonly NotificationBadgeManipulator NotificationBadgeManipulator;

        // Scene & UI Related.
        public readonly SceneLoader SceneLoader;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly SceneCanvasProvider SceneCanvasProvider;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly ScenePopupStackProvider ScenePopupStackProvider;
        public readonly OpenCommonPopup OpenCommonPopup;
        public readonly OpenAskForGoBackToTower OpenAskForGoBackToTower;
        public readonly OpenAlbumPopup OpenAlbumPopup;
        public readonly OpenNonogramPopup OpenNonogramPopup;

        // Miscs.
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly BackKeyBinder BackKeyBinder;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly ErrorPopupQueue ErrorPopupQueue;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly SlideNotificationQueue SlideNotificationQueue;
        [ShowInInspector, HideReferenceObjectPicker]
        public readonly CheckTowerLevelUp CheckTowerLevelUp;
        public readonly OpenQuitPopupOnQuit OpenQuitPopupOnQuit;
        public readonly CatSampler CatSampler;
        public readonly InterialUnlockNotifier InterialUnlockNotifier;
        public readonly InterialOwnStateResolver InterialOwnStateResolver;

        // Wrap up.
        public readonly Transactions Transactions;

        // Debug.
        public readonly HandleDebugKeyInput HandleDebugKeyInput;

        public IOCContainer()
        {
            L.D("Create start...");

            // Common.
            UnityApp = new UnityApp();
            Clock = new Clock();

            // Resource Loaders.
            ResourceLoader = new ResourceLoader();
            CommonPopupLoader = new CommonPopupLoader(ResourceLoader);
            SlideNoitificationLoader = new SlideNoitificationLoader(ResourceLoader);
            CatUIThumbnailLoader = new CatUIThumbnailLoader(ResourceLoader);
            InterialUIThumbnailLoader = new InterialUIThumbnailLoader(ResourceLoader);
            TowerScenePrefabLoader = new TowerScenePrefabLoader(ResourceLoader);
            NonogramLevelLoader = new NonogramLevelLoader(ResourceLoader);

            // Data.
            TableDownloader = new TableDownloader();
            DBProvider = new DBProvider(TableDownloader);
            SettingsTableProvider = new SettingsTableProvider(DBProvider);
            CatTableProvider = new CatTableProvider(DBProvider);

            // Model Loader & Providers.
            UserDataIO = new UserDataIO();
            UserDataProvider = new UserDataProvider(UserDataIO);
            MeProvider = new MeProvider(UserDataProvider);
            EnergyStateProvider = new EnergyStateProvider(MeProvider);
            CatContainerProvider = new CatContainerProvider(MeProvider);
            TowerLevelProgressProvider = new TowerLevelProgressProvider(MeProvider);
            NonogramProgressStateProvider = new NonogramProgressStateProvider(UserDataProvider);
            NotificationBadgeStateProvider = new NotificationBadgeStateProvider(UserDataProvider);

            // Model Updater.
            CatNeedsSimulator = new CatNeedsSimulator();
            MeController = new MeController(Clock, MeProvider, CatNeedsSimulator);
            EnergyController = new EnergyController(EnergyStateProvider, Clock);
            NotificationBadgeBroadcast = new NotificationBadgeBroadcast(NotificationBadgeStateProvider);
            NotificationBadgeManipulator = new NotificationBadgeManipulator(
                NotificationBadgeStateProvider, NotificationBadgeBroadcast);

            // Scene & UI Related.
            SceneLoader = new SceneLoader();
            SceneCanvasProvider = new SceneCanvasProvider();
            ScenePopupStackProvider = new ScenePopupStackProvider();
            OpenCommonPopup = new OpenCommonPopup(ScenePopupStackProvider, CommonPopupLoader);
            OpenAskForGoBackToTower = new OpenAskForGoBackToTower(OpenCommonPopup, SceneLoader);
            OpenAlbumPopup = new OpenAlbumPopup(ScenePopupStackProvider, ResourceLoader);
            OpenNonogramPopup = new OpenNonogramPopup(ScenePopupStackProvider, ResourceLoader);

            // Miscs.
            BackKeyBinder = new BackKeyBinder();
            ErrorPopupQueue = new ErrorPopupQueue(OpenCommonPopup);
            SlideNotificationQueue = new SlideNotificationQueue(SceneCanvasProvider, SlideNoitificationLoader);
            CheckTowerLevelUp = new CheckTowerLevelUp(
                TowerLevelProgressProvider, SlideNotificationQueue);
            OpenQuitPopupOnQuit = new OpenQuitPopupOnQuit(UnityApp, BackKeyBinder, OpenCommonPopup);
            CatSampler = new CatSampler(CatTableProvider, CatContainerProvider);
            InterialUnlockNotifier = new InterialUnlockNotifier(
                InterialTableProvider, CatTableProvider,
                NotificationBadgeManipulator, SlideNotificationQueue);
            InterialOwnStateResolver = new InterialOwnStateResolver(
                MeProvider, InterialTableProvider);

            // Wrap up.
            Transactions = new Transactions(
                Clock, SettingsTableProvider,
                MeProvider, NonogramProgressStateProvider,
                ErrorPopupQueue, NotificationBadgeManipulator,
                CatNeedsSimulator, CatSampler, InterialUnlockNotifier);

            // Debug.
            HandleDebugKeyInput = new HandleDebugKeyInput(OpenCommonPopup);

            L.D("Create done.");
        }

        static readonly DebugLogger L = new DebugLogger(nameof(IOCContainer));
    }
}

IOCInjector.cs

using System;
using System.Linq;
using System.Reflection;
using Core;
using Data;
using Models;
using Services;

namespace App
{
    public struct IOCInjector
    {
        public void Inject(IOCContainer iocContainer)
        {
            L.D("Inject");
            var types = Assembly.GetExecutingAssembly().GetTypes();
            var diTypes = types.Where(t => t.GetCustomAttribute<DIAttribute>() != null);
            foreach (var diType in diTypes)
                AssignServicesToDIClass(diType, iocContainer);
        }

        static void AssignServicesToDIClass(Type diType, IOCContainer iocContainer)
        {
            var fields = diType.GetFields(BindingFlags.Public | BindingFlags.Static);
            foreach (var field in fields)
            {
                if (IsAssignableFromUserData(field.FieldType)) continue;
                if (IsAssignableFromDB(field.FieldType)) continue;
                var service = GetServiceOfType(iocContainer, field.FieldType);
                field.SetValue(null, service);
            }
        }

        static object GetServiceOfType(IOCContainer iocContainer, Type type)
        {
            var fieldInfo = iocContainer.GetType()
                .GetField(type.Name, BindingFlags.Public | BindingFlags.Instance);

            if (fieldInfo == null)
            {
                L.E("Field for type not found: " + type.Name);
                return null;
            }

            return fieldInfo.GetValue(iocContainer);
        }

        public void InjectDB(DB db)
        {
            L.D("InjectDB");
            var types = Assembly.GetExecutingAssembly().GetTypes();
            var diTypes = types.Where(t => t.GetCustomAttribute<DIAttribute>() != null);
            foreach (var diType in diTypes)
                AssignDBToDIClass(diType, db);
        }

        static bool IsAssignableFromDB(Type diType)
        {
            if (diType == typeof(SettingsTable)) return true;
            if (diType == typeof(CatTable)) return true;
            if (diType == typeof(CatMemoryTable)) return true;
            if (diType == typeof(InterialTable)) return true;
            if (diType == typeof(NonogramLevelTable)) return true;
            return false;
        }

        static void AssignDBToDIClass(Type diType, DB db)
        {
            var fields = diType.GetFields(BindingFlags.Public | BindingFlags.Static);
            foreach (var field in fields)
            {
                var t = field.FieldType;
                if (t == typeof(SettingsTable)) field.SetValue(null, db.Settings);
                else if (t == typeof(CatTable)) field.SetValue(null, db.Cat);
                else if (t == typeof(CatMemoryTable)) field.SetValue(null, db.CatMemory);
                else if (t == typeof(InterialTable)) field.SetValue(null, db.Interial);
                else if (t == typeof(NonogramLevelTable)) field.SetValue(null, db.NonogramLevel);
            }
        }

        public void InjectUserData(UserData userData)
        {
            L.D("InjectUserData");
            var types = Assembly.GetExecutingAssembly().GetTypes();
            var diTypes = types.Where(t => t.GetCustomAttribute<DIAttribute>() != null);
            foreach (var diType in diTypes)
                AssignUserDataToDIClass(diType, userData);
        }

        static bool IsAssignableFromUserData(Type diType)
        {
            if (diType == typeof(Me)) return true;
            if (diType == typeof(Wallet)) return true;
            if (diType == typeof(EnergyState)) return true;
            if (diType == typeof(TowerLevelProgress)) return true;
            if (diType == typeof(NonogramProgressState)) return true;
            return false;
        }

        static void AssignUserDataToDIClass(Type diType, UserData userData)
        {
            var me = userData.Me;
            var nonogramProgressState = userData.NonogramProgressState;
            var fields = diType.GetFields(BindingFlags.Public | BindingFlags.Static);
            foreach (var field in fields)
            {
                var t = field.FieldType;
                if (t == typeof(Me)) field.SetValue(null, me);
                else if (t == typeof(Wallet)) field.SetValue(null, me.Wallet);
                else if (t == typeof(EnergyState)) field.SetValue(null, me.EnergyState);
                else if (t == typeof(TowerLevelProgress)) field.SetValue(null, me.TowerLevelProgress);
                else if (t == typeof(NonogramProgressState)) field.SetValue(null, nonogramProgressState);
            }
        }

        static readonly DebugLogger L = new DebugLogger(nameof(IOCInjector));
    }
}