private static int[] getTopologicalSortOrder(List <Field> fields) { TopologicalSorter g = new TopologicalSorter(); Dictionary <string, int> _indexes = new Dictionary <string, int>(); //add vertices for (int i = 0; i < fields.Count; i++) { g.AddVertex((char)i); _indexes[fields[i].Name.ToLower()] = i; } //add edges for (int i = 0; i < fields.Count; i++) { if (fields[i].DependsOn != null) { for (int j = 0; j < fields[i].DependsOn.Length; j++) { g.AddEdge(i, _indexes[fields[i].DependsOn[j].ToLower()]); } } } char[] array = g.Sort(); int[] result = new int[fields.Count]; for (int i = 0; i < fields.Count; i++) { result[i] = (int)array[i]; } return(result); }
private static int[] GetTopologicalSortOrder(IList <DependencyField> fields) { var g = new TopologicalSorter(fields.Count()); var _indexes = new Dictionary <string, int>(); //add vertices for (int i = 0; i < fields.Count(); i++) { _indexes[fields[i].Alias.ToLower()] = g.AddVertex(i); } //add edges for (int i = 0; i < fields.Count; i++) { if (fields[i].DependsOn != null) { for (int j = 0; j < fields[i].DependsOn.Length; j++) { g.AddEdge(i, _indexes[fields[i].DependsOn[j].ToLower()]); } } } int[] result = g.Sort(); return(result); }
/// <summary> /// Sort a collection of service types so that each service may be started after all /// their dependencies are started. /// </summary> /// <param name="serviceTypes"> /// The service types. /// </param> /// <returns> /// The sorted service types. /// </returns> public IEnumerable <Type> Sort(IEnumerable <Type> serviceTypes) { var dependencies = serviceTypes.Select(x => new Dependency(x, FindDependencies(x))) .ToArray(); var sorter = new TopologicalSorter(dependencies.Length); var indexes = new Dictionary <Type, int>(); for (var i = 0; i < dependencies.Length; i++) { indexes[dependencies[i].Dependant] = sorter.AddVertex(i); } for (var i = 0; i < dependencies.Length; i++) { if (dependencies[i].Dependencies == null || !dependencies[i].Dependencies.Any()) { continue; } foreach (var t in dependencies[i].Dependencies) { sorter.AddEdge(i, indexes[t]); } } var sortedServices = sorter.Sort() .Reverse() .Select(x => dependencies[x].Dependant) .ToList(); return(sortedServices); }
public void TestMethod1() { // Arrange int[] idx = { 0, 1, 2, 3, 4, 5 }; var sorter = new TopologicalSorter(idx.Length); sorter.AddVertex(0); sorter.AddVertex(1); sorter.AddVertex(2); sorter.AddVertex(3); sorter.AddVertex(4); sorter.AddVertex(5); sorter.AddEdge(5, 2); sorter.AddEdge(5, 0); sorter.AddEdge(4, 0); sorter.AddEdge(4, 1); sorter.AddEdge(2, 3); sorter.AddEdge(3, 1); // Act var result = sorter.Sort(); // Assert result.Length.Should().Be(6); result.Should().ContainInOrder(new[] { 5, 4, 2, 3, 1, 0 }); }
/// <summary> /// Processes a list of application versions and their dependencies ready for sorting. /// </summary> /// <param name="requiredAppVersions">The list of required app versions.</param> /// <param name="sorter">The topological sorter.</param> /// <param name="ids">The full indexed list of ids.</param> /// <param name="currentId">The current id that owns the required app versions.</param> private void AddRequiredAppVersionEdgesToSorter( IEnumerable <ManagedAppVersion> requiredAppVersions, TopologicalSorter sorter, IList <Guid> ids, Guid currentId) { foreach (var req in requiredAppVersions) { if (req.VersionId == null || req.VersionId.Value == Guid.Empty) { continue; } // required app version --> dependent app/app version sorter.AddEdge(ids.IndexOf(req.VersionId.Value), ids.IndexOf(currentId)); AddRequiredAppEdgesToSorter(req.RequiredApps, sorter, ids, req.VersionId.Value); AddRequiredAppVersionEdgesToSorter(req.RequiredAppVersions, sorter, ids, req.VersionId.Value); } }
private static int[] GetTopologicalSortOrder(IList<DependencyField> fields) { var g = new TopologicalSorter(fields.Count()); var _indexes = new Dictionary<string, int>(); //add vertices for (int i = 0; i < fields.Count(); i++) { _indexes[fields[i].Alias.ToLower()] = g.AddVertex(i); } //add edges for (int i = 0; i < fields.Count; i++) { if (fields[i].DependsOn != null) { for (int j = 0; j < fields[i].DependsOn.Length; j++) { g.AddEdge(i, _indexes[fields[i].DependsOn[j].ToLower()]); } } } int[] result = g.Sort(); return result; }