依存関係に基づいてスクリプト実行順設定を自動化する

using System;

[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
public class DependsOnAttribute : Attribute {
    public Type dependee;
    public DependsOnAttribute(Type dependee) {
        this.dependee = dependee;
    }
}

using UnityEditor;
using UnityEngine;
using System;
using System.Collections.Generic;
using System.Linq;

[InitializeOnLoad]
public class ExecutionOrderCoordinator {
    static ExecutionOrderCoordinator() {
        EditorApplication.update += DoRefreshExecutionOrders;
    }

    static void DoRefreshExecutionOrders() {
        EditorApplication.update -= DoRefreshExecutionOrders;
        if (!EditorApplication.isPlaying) {
            RefreshExecutionOrders();
        }
    }

    static void RefreshExecutionOrders() {
        var graph = GetDependencyGraph();
        List<Type> sorted = TSort(graph.dependencies);

        for (int i = 0; i < sorted.Count; ++i) {
            var type = sorted[i];
            var script = graph.monoScripts[type];
            var order = i - sorted.Count;

            if (MonoImporter.GetExecutionOrder(script) != order) {
                MonoImporter.SetExecutionOrder(script, order);
            }
        }
    }

    class DependencyGraph {
        public Dictionary<Type, MonoScript> monoScripts = new Dictionary<Type, MonoScript>();
        public Dictionary<Type, HashSet<Type>> dependencies = new Dictionary<Type, HashSet<Type>>();
    }

    static DependencyGraph GetDependencyGraph() {
        var graph = new DependencyGraph();
        foreach (var script in MonoImporter.GetAllRuntimeMonoScripts()) {
            var klass = script.GetClass();
            if (klass != null) {
                graph.monoScripts[klass] = script;

                var attrs = Attribute.GetCustomAttributes(klass, typeof(DependsOnAttribute));
                foreach (DependsOnAttribute attr in attrs) {
                    HashSet<Type> set;
                    if (!graph.dependencies.TryGetValue(klass, out set)) {
                        set = graph.dependencies[klass] = new HashSet<Type>();
                    }
                    set.Add(attr.dependee);

                    if (!graph.dependencies.ContainsKey(attr.dependee)) {
                        graph.dependencies[attr.dependee] = new HashSet<Type>();
                    }
                }
            }
        }
        return graph;
    }

    // The AWK Programming Language(1988) SECTION 7.3 TOPOLOGICAL SORTING
    // http://d.hatena.ne.jp/tociyuki/20120919
    // Color definition: white=0, gray=1, black=2
    static List<Type> Depends(Type target, Dictionary<Type, HashSet<Type>> dependencies, Dictionary<Type, int> marked, List<Type> sorted) {
        if (marked.ContainsKey(target)) {
            return null;
        }
        marked[target] = 1;
        foreach (var m in dependencies[target].OrderBy(x => x.FullName)) {
            if (!marked.ContainsKey(m)) {
                Depends(m, dependencies, marked, sorted);
            } else if (marked[m] == 1) {
                throw new InvalidOperationException(string.Format("nodes {0} and {1} are in a cycle", m, target));
            }
        }
        sorted.Add(target);
        marked[target] = 2;
        return sorted;
    }

    static List<Type> TSort(Dictionary<Type, HashSet<Type>> dependencies) {
        var marked = new Dictionary<Type, int>();
        var sorted = new List<Type>();
        foreach (var target in dependencies.Keys.OrderBy(x => x.FullName)) {
            Depends(target, dependencies, marked, sorted);
        }
        return sorted;
    }
}

[DependsOn(typeof(C8))]
[DependsOn(typeof(C11))]
public class C7 : MonoBehaviour { }

[DependsOn(typeof(C9))]
public class C8 : MonoBehaviour { }