18 子 2D卡牌客户端搭建 / 2D卡牌客户端搭建 配置表问题

yyl

20 小时以前 1566a91aadaaccad72c140dbcd38dd17dc0e5c0a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace HybridCLR.Editor.Meta
{
 
    public class AssemblySorter
    {
        class Node
        {
            public string Name;
            public List<Node> Dependencies = new List<Node>();
 
            public Node(string name)
            {
                Name = name;
            }
        }
 
        class TopologicalSorter
        {
 
            public static List<Node> Sort(List<Node> nodes)
            {
                List<Node> sorted = new List<Node>();
                HashSet<Node> visited = new HashSet<Node>();
                HashSet<Node> tempMarks = new HashSet<Node>();
 
                foreach (var node in nodes)
                {
                    if (!visited.Contains(node))
                    {
                        Visit(node, visited, tempMarks, sorted);
                    }
                }
                return sorted;
            }
 
            private static void Visit(Node node, HashSet<Node> visited, HashSet<Node> tempMarks, List<Node> sorted)
            {
                if (tempMarks.Contains(node))
                {
                    throw new Exception("Detected cyclic dependency!");
                }
 
                if (!visited.Contains(node))
                {
                    tempMarks.Add(node);
                    foreach (var dependency in node.Dependencies)
                    {
                        Visit(dependency, visited, tempMarks, sorted);
                    }
                    tempMarks.Remove(node);
                    visited.Add(node);
                    sorted.Add(node);
                }
            }
        }
 
        private static List<string> SortAssemblyByReferenceOrder(IEnumerable<string> assemblies, Dictionary<string, HashSet<string>> refs)
        {
            var nodes = new List<Node>();
            var nodeMap = new Dictionary<string, Node>();
            foreach (var assembly in assemblies)
            {
                var node = new Node(assembly);
                nodes.Add(node);
                nodeMap.Add(assembly, node);
            }
            foreach (var assembly in assemblies)
            {
                var node = nodeMap[assembly];
                foreach (var refAssembly in refs[assembly])
                {
                    node.Dependencies.Add(nodeMap[refAssembly]);
                }
            }
            var sortedNodes = TopologicalSorter.Sort(nodes);
            return sortedNodes.Select(node => node.Name).ToList();
        }
 
        public static List<string> SortAssemblyByReferenceOrder(IEnumerable<string> assemblies, IAssemblyResolver assemblyResolver)
        {
            var assCache = new AssemblyCache(assemblyResolver);
            var assRefAssemblies = new Dictionary<string, HashSet<string>>();
            foreach (var assName in assemblies)
            {
                var refAssemblies = new HashSet<string>();
                var mod = assCache.LoadModule(assName, false);
                foreach (var refAss in mod.GetAssemblyRefs())
                {
                    if (assemblies.Contains(refAss.Name.ToString()))
                    {
                        refAssemblies.Add(refAss.Name.ToString());
                    }
                }
                assRefAssemblies.Add(assName, refAssemblies);
            }
            return SortAssemblyByReferenceOrder(assemblies, assRefAssemblies);
        }
    }
}