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;
}
