diff --git a/src/QuikGraph/Algorithms/TopologicalSort/SourceFirstBidirectionalTopologicalSortAlgorithm.cs b/src/QuikGraph/Algorithms/TopologicalSort/SourceFirstBidirectionalTopologicalSortAlgorithm.cs
index a021da400..adbdf3a1f 100644
--- a/src/QuikGraph/Algorithms/TopologicalSort/SourceFirstBidirectionalTopologicalSortAlgorithm.cs
+++ b/src/QuikGraph/Algorithms/TopologicalSort/SourceFirstBidirectionalTopologicalSortAlgorithm.cs
@@ -2,6 +2,8 @@
 using System;
 #endif
 using System.Collections.Generic;
+using JetBrains.Annotations;
+using QuikGraph.Algorithms.Services;
 #if SUPPORTS_CONTRACTS
 using System.Diagnostics.Contracts;
 #endif
@@ -9,12 +11,11 @@
 
 namespace QuikGraph.Algorithms.TopologicalSort
 {
-    public enum TopologicalSortDirection
-    {
-        Forward,
-        Backward
-    }
-
+    /// <summary>
+    /// Topological sort algorithm (can be performed on an acyclic bidirectional graph).
+    /// </summary>
+    /// <typeparam name="TVertex">Vertex type.</typeparam>
+    /// <typeparam name="TEdge">Edge type.</typeparam>
 #if SUPPORTS_SERIALIZATION
     [Serializable]
 #endif
@@ -22,124 +23,152 @@ public sealed class SourceFirstBidirectionalTopologicalSortAlgorithm<TVertex, TE
         AlgorithmBase<IBidirectionalGraph<TVertex, TEdge>>
         where TEdge : IEdge<TVertex>
     {
-        private IDictionary<TVertex, int> predCounts = new Dictionary<TVertex, int>();
-        private BinaryQueue<TVertex, int> heap;
-        private IList<TVertex> sortedVertices = new List<TVertex>();
-        private TopologicalSortDirection direction = TopologicalSortDirection.Forward;
+        [NotNull]
+        private readonly BinaryQueue<TVertex, int> _heap;
 
+        private readonly TopologicalSortDirection _direction;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SourceFirstBidirectionalTopologicalSortAlgorithm{TVertex,TEdge}"/> class.
+        /// </summary>
+        /// <param name="visitedGraph">Graph to visit.</param>
         public SourceFirstBidirectionalTopologicalSortAlgorithm(
-            IBidirectionalGraph<TVertex, TEdge> visitedGraph
-            )
+            [NotNull] IBidirectionalGraph<TVertex, TEdge> visitedGraph)
             : this(visitedGraph, TopologicalSortDirection.Forward)
         {
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SourceFirstBidirectionalTopologicalSortAlgorithm{TVertex,TEdge}"/> class.
+        /// </summary>
+        /// <param name="visitedGraph">Graph to visit.</param>
+        /// <param name="direction">Sort direction.</param>
         public SourceFirstBidirectionalTopologicalSortAlgorithm(
-            IBidirectionalGraph<TVertex, TEdge> visitedGraph,
-            TopologicalSortDirection direction
-            )
+            [NotNull] IBidirectionalGraph<TVertex, TEdge> visitedGraph,
+            TopologicalSortDirection direction)
             : base(visitedGraph)
         {
-            this.direction = direction;
-            this.heap = new BinaryQueue<TVertex, int>(e => this.predCounts[e]);
+            _direction = direction;
+            _heap = new BinaryQueue<TVertex, int>(vertex => InDegrees[vertex]);
         }
 
-        public ICollection<TVertex> SortedVertices
+        /// <summary>
+        /// Sorted vertices.
+        /// </summary>
+#if SUPPORTS_CONTRACTS
+        [System.Diagnostics.Contracts.Pure]
+#endif
+        [NotNull, ItemNotNull]
+        public ICollection<TVertex> SortedVertices { get; private set; } = new List<TVertex>();
+
+        /// <summary>
+        /// Vertices in degrees.
+        /// </summary>
+#if SUPPORTS_CONTRACTS
+        [System.Diagnostics.Contracts.Pure]
+#endif
+        [NotNull]
+        public IDictionary<TVertex, int> InDegrees { get; } = new Dictionary<TVertex, int>();
+
+        /// <summary>
+        /// Fired when a vertex is added to the set of sorted vertices.
+        /// </summary>
+        public event VertexAction<TVertex> VertexAdded;
+
+        private void OnVertexAdded([NotNull] TVertex vertex)
         {
-            get
-            {
-                return this.sortedVertices;
-            }
+#if SUPPORTS_CONTRACTS
+            Contract.Requires(vertex != null);
+#endif
+
+            VertexAdded?.Invoke(vertex);
         }
 
-        public BinaryQueue<TVertex, int> Heap
+        private void InitializeInDegrees()
         {
-            get
+            foreach (TVertex vertex in VisitedGraph.Vertices)
             {
-                return this.heap;
+                InDegrees.Add(vertex, 0);
             }
-        }
 
-        public IDictionary<TVertex, int> InDegrees
-        {
-            get
+            foreach (TEdge edge in VisitedGraph.Edges)
             {
-                return this.predCounts;
+                if (edge.IsSelfEdge())
+                    continue;
+
+                TVertex successor = _direction == TopologicalSortDirection.Forward
+                    ? edge.Target
+                    : edge.Source;
+
+                ++InDegrees[successor];
             }
-        }
 
-        public event VertexAction<TVertex> AddVertex;
-        private void OnAddVertex(TVertex v)
-        {
-            var eh = this.AddVertex;
-            if (eh != null)
-                eh(v);
+            foreach (TVertex vertex in VisitedGraph.Vertices)
+            {
+                _heap.Enqueue(vertex);
+            }
         }
 
-        public void Compute(IList<TVertex> vertices)
+        /// <summary>
+        /// Runs the topological sort and puts the result in the provided list.
+        /// </summary>
+        /// <param name="vertices">Set of sorted vertices.</param>
+        public void Compute([NotNull, ItemNotNull] IList<TVertex> vertices)
         {
 #if SUPPORTS_CONTRACTS
             Contract.Requires(vertices != null);
 #endif
 
-            this.sortedVertices = vertices;
+            SortedVertices = vertices;
+            SortedVertices.Clear();
             Compute();
         }
 
+        #region AlgorithmBase<TGraph>
 
+        /// <inheritdoc />
         protected override void InternalCompute()
         {
-            var cancelManager = this.Services.CancelManager;
-            this.InitializeInDegrees();
+            ICancelManager cancelManager = Services.CancelManager;
+            InitializeInDegrees();
 
-            while (this.heap.Count != 0)
+            while (_heap.Count != 0)
             {
-                if (cancelManager.IsCancelling) break;
+                if (cancelManager.IsCancelling)
+                    break;
 
-                TVertex v = this.heap.Dequeue();
-                if (this.predCounts[v] != 0)
+                TVertex vertex = _heap.Dequeue();
+                if (InDegrees[vertex] != 0)
                     throw new NonAcyclicGraphException();
 
-                this.sortedVertices.Add(v);
-                this.OnAddVertex(v);
+                SortedVertices.Add(vertex);
+                OnVertexAdded(vertex);
 
-                // update the count of its successor vertices
-                var succEdges = (this.direction == TopologicalSortDirection.Forward) ? this.VisitedGraph.OutEdges(v) : this.VisitedGraph.InEdges(v);
-                foreach (var e in succEdges)
+                // Update the count of its successor vertices
+                IEnumerable<TEdge> successorEdges = _direction == TopologicalSortDirection.Forward
+                    ? VisitedGraph.OutEdges(vertex)
+                    : VisitedGraph.InEdges(vertex);
+
+                foreach (TEdge edge in successorEdges)
                 {
-                    if (e.Source.Equals(e.Target))
+                    if (edge.IsSelfEdge())
                         continue;
-                    var succ = (direction == TopologicalSortDirection.Forward) ? e.Target : e.Source;
-                    this.predCounts[succ]--;
+
+                    TVertex successor = _direction == TopologicalSortDirection.Forward
+                        ? edge.Target
+                        : edge.Source;
+
+                    --InDegrees[successor];
 
 #if SUPPORTS_CONTRACTS
-                    Contract.Assert(this.predCounts[succ] >= 0);
+                    Contract.Assert(InDegrees[successor] >= 0);
 #endif
 
-                    this.heap.Update(succ);
+                    _heap.Update(successor);
                 }
             }
         }
 
-        private void InitializeInDegrees()
-        {
-            foreach (var v in this.VisitedGraph.Vertices)
-            {
-                this.predCounts.Add(v, 0);
-            }
-
-            foreach (var e in this.VisitedGraph.Edges)
-            {
-                if (e.Source.Equals(e.Target))
-                    continue;
-                var succ = (direction == TopologicalSortDirection.Forward) ? e.Target : e.Source;
-                this.predCounts[succ]++;
-            }
-
-            foreach (var v in this.VisitedGraph.Vertices)
-            {
-                this.heap.Enqueue(v);
-            }
-        }
+        #endregion
     }
 }
diff --git a/src/QuikGraph/Algorithms/TopologicalSort/SourceFirstTopologicalSortAlgorithm.cs b/src/QuikGraph/Algorithms/TopologicalSort/SourceFirstTopologicalSortAlgorithm.cs
index 75af5bb5a..8fa12b79c 100644
--- a/src/QuikGraph/Algorithms/TopologicalSort/SourceFirstTopologicalSortAlgorithm.cs
+++ b/src/QuikGraph/Algorithms/TopologicalSort/SourceFirstTopologicalSortAlgorithm.cs
@@ -2,127 +2,145 @@
 using System;
 #endif
 using System.Collections.Generic;
+using JetBrains.Annotations;
+using QuikGraph.Algorithms.Services;
+using QuikGraph.Collections;
 #if SUPPORTS_CONTRACTS
 using System.Diagnostics.Contracts;
 #endif
-using QuikGraph.Collections;
 
 namespace QuikGraph.Algorithms.TopologicalSort
 {
+    /// <summary>
+    /// Topological sort algorithm (can be performed on an acyclic graph).
+    /// </summary>
+    /// <typeparam name="TVertex">Vertex type.</typeparam>
+    /// <typeparam name="TEdge">Edge type.</typeparam>
 #if SUPPORTS_SERIALIZATION
     [Serializable]
 #endif
-    public sealed class SourceFirstTopologicalSortAlgorithm<TVertex, TEdge> :
-        AlgorithmBase<IVertexAndEdgeListGraph<TVertex, TEdge>>
+    public sealed class SourceFirstTopologicalSortAlgorithm<TVertex, TEdge> : AlgorithmBase<IVertexAndEdgeListGraph<TVertex, TEdge>>
         where TEdge : IEdge<TVertex>
     {
-        private IDictionary<TVertex, int> inDegrees = new Dictionary<TVertex, int>();
-        private BinaryQueue<TVertex,int> heap;
-        private IList<TVertex> sortedVertices = new List<TVertex>();
+        [NotNull]
+        private readonly BinaryQueue<TVertex, int> _heap;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SourceFirstTopologicalSortAlgorithm{TVertex,TEdge}"/> class.
+        /// </summary>
+        /// <param name="visitedGraph">Graph to visit.</param>
         public SourceFirstTopologicalSortAlgorithm(
-            IVertexAndEdgeListGraph<TVertex,TEdge> visitedGraph
-            )
-            :base(visitedGraph)
+            [NotNull] IVertexAndEdgeListGraph<TVertex, TEdge> visitedGraph)
+            : base(visitedGraph)
         {
-            this.heap = new BinaryQueue<TVertex,int>(e => this.inDegrees[e]);
+            _heap = new BinaryQueue<TVertex, int>(vertex => InDegrees[vertex]);
         }
 
-        public ICollection<TVertex> SortedVertices
+        /// <summary>
+        /// Sorted vertices.
+        /// </summary>
+#if SUPPORTS_CONTRACTS
+        [System.Diagnostics.Contracts.Pure]
+#endif
+        [NotNull, ItemNotNull]
+        public ICollection<TVertex> SortedVertices { get; private set; } = new List<TVertex>();
+
+        /// <summary>
+        /// Vertices in degrees.
+        /// </summary>
+#if SUPPORTS_CONTRACTS
+        [System.Diagnostics.Contracts.Pure]
+#endif
+        [NotNull]
+        public IDictionary<TVertex, int> InDegrees { get; } = new Dictionary<TVertex, int>();
+
+        /// <summary>
+        /// Fired when a vertex is added to the set of sorted vertices.
+        /// </summary>
+        public event VertexAction<TVertex> VertexAdded;
+
+        private void OnVertexAdded([NotNull] TVertex vertex)
         {
-            get
-            {
-                return this.sortedVertices;
-            }
+#if SUPPORTS_CONTRACTS
+            Contract.Requires(vertex != null);
+#endif
+
+            VertexAdded?.Invoke(vertex);
         }
 
-        public BinaryQueue<TVertex,int> Heap
+        private void InitializeInDegrees()
         {
-            get
+            foreach (TVertex vertex in VisitedGraph.Vertices)
             {
-                return this.heap;
+                InDegrees.Add(vertex, 0);
             }
-        }
 
-        public IDictionary<TVertex,int> InDegrees
-        {
-            get
+            foreach (TEdge edge in VisitedGraph.Edges)
             {
-                return this.inDegrees;
+                if (edge.IsSelfEdge())
+                    continue;
+
+                ++InDegrees[edge.Target];
             }
-        }
 
-        public event VertexAction<TVertex> AddVertex;
-        private void OnAddVertex(TVertex v)
-        {
-            var eh = this.AddVertex;
-            if (eh != null)
-                eh(v);
+            foreach (TVertex vertex in VisitedGraph.Vertices)
+            {
+                _heap.Enqueue(vertex);
+            }
         }
 
-        public void Compute(IList<TVertex> vertices)
+        /// <summary>
+        /// Runs the topological sort and puts the result in the provided list.
+        /// </summary>
+        /// <param name="vertices">Set of sorted vertices.</param>
+        public void Compute([NotNull, ItemNotNull] IList<TVertex> vertices)
         {
 #if SUPPORTS_CONTRACTS
             Contract.Requires(vertices != null);
 #endif
 
-            this.sortedVertices = vertices;
+            SortedVertices = vertices;
+            SortedVertices.Clear();
             Compute();
         }
 
+        #region AlgorithmBase<TGraph>
 
+        /// <inheritdoc />
         protected override void InternalCompute()
         {
-            var cancelManager = this.Services.CancelManager;
-            this.InitializeInDegrees();
+            ICancelManager cancelManager = Services.CancelManager;
+            InitializeInDegrees();
 
-            while (this.heap.Count != 0)
+            while (_heap.Count != 0)
             {
-                if (cancelManager.IsCancelling) break;
+                if (cancelManager.IsCancelling)
+                    break;
 
-                TVertex v = this.heap.Dequeue();
-                if (this.inDegrees[v] != 0)
+                TVertex vertex = _heap.Dequeue();
+                if (InDegrees[vertex] != 0)
                     throw new NonAcyclicGraphException();
 
-                this.sortedVertices.Add(v);
-                this.OnAddVertex(v);
+                SortedVertices.Add(vertex);
+                OnVertexAdded(vertex);
 
-                // update the count of it's adjacent vertices
-                foreach (var e in this.VisitedGraph.OutEdges(v))
+                // Update the count of its adjacent vertices
+                foreach (TEdge edge in VisitedGraph.OutEdges(vertex))
                 {
-                    if (e.Source.Equals(e.Target))
+                    if (edge.IsSelfEdge())
                         continue;
 
-                    this.inDegrees[e.Target]--;
+                    --InDegrees[edge.Target];
 
 #if SUPPORTS_CONTRACTS
-                    Contract.Assert(this.inDegrees[e.Target] >= 0);
+                    Contract.Assert(InDegrees[edge.Target] >= 0);
 #endif
 
-                    this.heap.Update(e.Target);
+                    _heap.Update(edge.Target);
                 }
             }
         }
 
-        private void InitializeInDegrees()
-        {
-            foreach (var v in this.VisitedGraph.Vertices)
-            {
-                this.inDegrees.Add(v, 0);         
-            }
-
-            foreach (var e in this.VisitedGraph.Edges)
-            {
-                if (e.Source.Equals(e.Target))
-                    continue;
-                this.inDegrees[e.Target]++;
-            }
-
-            foreach (var v in this.VisitedGraph.Vertices)
-            {
-                this.heap.Enqueue(v);
-            }
-
-        }
+        #endregion
     }
 }
diff --git a/src/QuikGraph/Algorithms/TopologicalSort/TopologicalSortAlgorithm.cs b/src/QuikGraph/Algorithms/TopologicalSort/TopologicalSortAlgorithm.cs
index 29509ced7..be201f2d6 100644
--- a/src/QuikGraph/Algorithms/TopologicalSort/TopologicalSortAlgorithm.cs
+++ b/src/QuikGraph/Algorithms/TopologicalSort/TopologicalSortAlgorithm.cs
@@ -2,6 +2,7 @@
 using System;
 #endif
 using System.Collections.Generic;
+using JetBrains.Annotations;
 #if SUPPORTS_CONTRACTS
 using System.Diagnostics.Contracts;
 #endif
@@ -9,60 +10,82 @@
 
 namespace QuikGraph.Algorithms.TopologicalSort
 {
+    /// <summary>
+    /// Topological sort algorithm (can be performed on an acyclic graph).
+    /// </summary>
+    /// <typeparam name="TVertex">Vertex type.</typeparam>
+    /// <typeparam name="TEdge">Edge type.</typeparam>
 #if SUPPORTS_SERIALIZATION
     [Serializable]
 #endif
-    public sealed class TopologicalSortAlgorithm<TVertex, TEdge> :
-        AlgorithmBase<IVertexListGraph<TVertex, TEdge>>
+    public sealed class TopologicalSortAlgorithm<TVertex, TEdge>
+        : AlgorithmBase<IVertexListGraph<TVertex, TEdge>>
+        , IVertexTimeStamperAlgorithm<TVertex>
         where TEdge : IEdge<TVertex>
     {
-        private IList<TVertex> vertices = new List<TVertex>();
-        private bool allowCyclicGraph = false;
-
-        public TopologicalSortAlgorithm(IVertexListGraph<TVertex, TEdge> g)
-            : this(g, new List<TVertex>())
-        { }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TopologicalSortAlgorithm{TVertex,TEdge}"/> class.
+        /// </summary>
+        /// <param name="visitedGraph">Graph to visit.</param>
+        public TopologicalSortAlgorithm([NotNull] IVertexListGraph<TVertex, TEdge> visitedGraph)
+            : this(visitedGraph, new List<TVertex>())
+        {
+        }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TopologicalSortAlgorithm{TVertex,TEdge}"/> class.
+        /// </summary>
+        /// <param name="visitedGraph">Graph to visit.</param>
+        /// <param name="vertices">Set of sorted vertices.</param>
         public TopologicalSortAlgorithm(
-            IVertexListGraph<TVertex, TEdge> g,
-            IList<TVertex> vertices)
-            : base(g)
+            [NotNull] IVertexListGraph<TVertex, TEdge> visitedGraph,
+            [NotNull, ItemNotNull] IList<TVertex> vertices)
+            : base(visitedGraph)
         {
 #if SUPPORTS_CONTRACTS
             Contract.Requires(vertices != null);
 #endif
 
-            this.vertices = vertices;
+            SortedVertices = vertices;
         }
 
+        /// <summary>
+        /// Sorted vertices.
+        /// </summary>
+#if SUPPORTS_CONTRACTS
+        [System.Diagnostics.Contracts.Pure]
+#endif
+        [NotNull, ItemNotNull]
+        public IList<TVertex> SortedVertices { get; private set; }
 
-        public IList<TVertex> SortedVertices
+        private static void OnBackEdge([NotNull] TEdge args)
         {
-            get
-            {
-                return vertices;
-            }
+            throw new NonAcyclicGraphException();
         }
 
-        public bool AllowCyclicGraph
+        private void OnVertexFinished([NotNull] TVertex vertex)
         {
-            get { return this.allowCyclicGraph; }
+            SortedVertices.Insert(0, vertex);
         }
 
-        private void BackEdge(TEdge args)
+        /// <summary>
+        /// Runs the topological sort and puts the result in the provided list.
+        /// </summary>
+        /// <param name="vertices">Set of sorted vertices.</param>
+        public void Compute([NotNull, ItemNotNull] IList<TVertex> vertices)
         {
-            if (!this.AllowCyclicGraph)
-                throw new NonAcyclicGraphException();
-        }
+#if SUPPORTS_CONTRACTS
+            Contract.Requires(vertices != null);
+#endif
 
-        private void VertexFinished(TVertex v)
-        {
-            vertices.Insert(0, v);
+            SortedVertices = vertices;
+            SortedVertices.Clear();
+            Compute();
         }
 
-        public event VertexAction<TVertex> DiscoverVertex;
-        public event VertexAction<TVertex> FinishVertex;
+        #region AlgorithmBase<TGraph>
 
+        /// <inheritdoc />
         protected override void InternalCompute()
         {
             DepthFirstSearchAlgorithm<TVertex, TEdge> dfs = null;
@@ -70,11 +93,10 @@ protected override void InternalCompute()
             {
                 dfs = new DepthFirstSearchAlgorithm<TVertex, TEdge>(
                     this,
-                    this.VisitedGraph,
-                    new Dictionary<TVertex, GraphColor>(this.VisitedGraph.VertexCount)
-                    );
-                dfs.BackEdge += BackEdge;
-                dfs.FinishVertex += VertexFinished;
+                    VisitedGraph,
+                    new Dictionary<TVertex, GraphColor>(VisitedGraph.VertexCount));
+                dfs.BackEdge += OnBackEdge;
+                dfs.FinishVertex += OnVertexFinished;
                 dfs.DiscoverVertex += DiscoverVertex;
                 dfs.FinishVertex += FinishVertex;
 
@@ -84,19 +106,24 @@ protected override void InternalCompute()
             {
                 if (dfs != null)
                 {
-                    dfs.BackEdge -= BackEdge;
-                    dfs.FinishVertex -= VertexFinished;
+                    dfs.BackEdge -= OnBackEdge;
+                    dfs.FinishVertex -= OnVertexFinished;
                     dfs.DiscoverVertex -= DiscoverVertex;
                     dfs.FinishVertex -= FinishVertex;
                 }
             }
         }
 
-        public void Compute(IList<TVertex> vertices)
-        {
-            this.vertices = vertices;
-            this.vertices.Clear();
-            this.Compute();
-        }
+        #endregion
+
+        #region IVertexTimeStamperAlgorithm<TVertex>
+
+        /// <inheritdoc />
+        public event VertexAction<TVertex> DiscoverVertex;
+
+        /// <inheritdoc />
+        public event VertexAction<TVertex> FinishVertex;
+
+        #endregion
     }
 }
\ No newline at end of file
diff --git a/src/QuikGraph/Algorithms/TopologicalSort/TopologicalSortDirection.cs b/src/QuikGraph/Algorithms/TopologicalSort/TopologicalSortDirection.cs
new file mode 100644
index 000000000..0b3f51e46
--- /dev/null
+++ b/src/QuikGraph/Algorithms/TopologicalSort/TopologicalSortDirection.cs
@@ -0,0 +1,18 @@
+namespace QuikGraph.Algorithms.TopologicalSort
+{
+    /// <summary>
+    /// Enumeration of possible topological sort directions.
+    /// </summary>
+    public enum TopologicalSortDirection
+    {
+        /// <summary>
+        /// Forward sort.
+        /// </summary>
+        Forward,
+
+        /// <summary>
+        /// Backward sort.
+        /// </summary>
+        Backward
+    }
+}
diff --git a/src/QuikGraph/Algorithms/TopologicalSort/UndirectedFirstTopologicalSortAlgorithm.cs b/src/QuikGraph/Algorithms/TopologicalSort/UndirectedFirstTopologicalSortAlgorithm.cs
index 7df3e3889..9487150a2 100644
--- a/src/QuikGraph/Algorithms/TopologicalSort/UndirectedFirstTopologicalSortAlgorithm.cs
+++ b/src/QuikGraph/Algorithms/TopologicalSort/UndirectedFirstTopologicalSortAlgorithm.cs
@@ -3,118 +3,134 @@
 #if SUPPORTS_CONTRACTS
 using System.Diagnostics.Contracts;
 #endif
+using JetBrains.Annotations;
+using QuikGraph.Algorithms.Services;
 using QuikGraph.Collections;
 
 namespace QuikGraph.Algorithms.TopologicalSort
 {
+    /// <summary>
+    /// Undirected topological sort algorithm.
+    /// </summary>
+    /// <typeparam name="TVertex">Vertex type.</typeparam>
+    /// <typeparam name="TEdge">Edge type.</typeparam>
 #if SUPPORTS_SERIALIZATION
     [Serializable]
 #endif
-    public sealed class UndirectedFirstTopologicalSortAlgorithm<TVertex, TEdge> :
-        AlgorithmBase<IUndirectedGraph<TVertex, TEdge>>
+    public sealed class UndirectedFirstTopologicalSortAlgorithm<TVertex, TEdge> : AlgorithmBase<IUndirectedGraph<TVertex, TEdge>>
         where TEdge : IEdge<TVertex>
     {
-        private IDictionary<TVertex, int> degrees = new Dictionary<TVertex, int>();
-        private BinaryQueue<TVertex, int> heap;
-        private IList<TVertex> sortedVertices = new List<TVertex>();
-        private bool allowCyclicGraph = false;
-
-        public UndirectedFirstTopologicalSortAlgorithm(
-            IUndirectedGraph<TVertex, TEdge> visitedGraph
-            )
+        [NotNull]
+        private readonly BinaryQueue<TVertex, int> _heap;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UndirectedFirstTopologicalSortAlgorithm{TVertex,TEdge}"/> class.
+        /// </summary>
+        /// <param name="visitedGraph">Graph to visit.</param>
+        public UndirectedFirstTopologicalSortAlgorithm([NotNull] IUndirectedGraph<TVertex, TEdge> visitedGraph)
             : base(visitedGraph)
         {
-            this.heap = new BinaryQueue<TVertex, int>(e => this.degrees[e]);
+            _heap = new BinaryQueue<TVertex, int>(vertex => Degrees[vertex]);
         }
 
-        public ICollection<TVertex> SortedVertices
-        {
-            get
-            {
-                return this.sortedVertices;
-            }
-        }
+        /// <summary>
+        /// Sorted vertices.
+        /// </summary>
+#if SUPPORTS_CONTRACTS
+        [System.Diagnostics.Contracts.Pure]
+#endif
+        [NotNull, ItemNotNull]
+        public ICollection<TVertex> SortedVertices { get; private set; } = new List<TVertex>();
 
-        public BinaryQueue<TVertex, int> Heap
-        {
-            get
-            {
-                return this.heap;
-            }
-        }
+        /// <summary>
+        /// Vertices degrees.
+        /// </summary>
+#if SUPPORTS_CONTRACTS
+        [System.Diagnostics.Contracts.Pure]
+#endif
+        [NotNull]
+        public IDictionary<TVertex, int> Degrees { get; } = new Dictionary<TVertex, int>();
 
-        public IDictionary<TVertex, int> Degrees
-        {
-            get
-            {
-                return this.degrees;
-            }
-        }
+        /// <summary>
+        /// Gets or sets the flag that indicates if cyclic graph are supported or not.
+        /// </summary>
+        public bool AllowCyclicGraph { get; set; }
 
+        /// <summary>
+        /// Fired when a vertex is added to the set of sorted vertices.
+        /// </summary>
+        public event VertexAction<TVertex> VertexAdded;
 
-        public bool AllowCyclicGraph
+        private void OnVertexAdded([NotNull] TVertex vertex)
         {
-            get { return this.allowCyclicGraph; }
-            set { this.allowCyclicGraph = value; }
+#if SUPPORTS_CONTRACTS
+            Contract.Requires(vertex != null);
+#endif
+
+            VertexAdded?.Invoke(vertex);
         }
 
-        public event VertexAction<TVertex> AddVertex;
-        private void OnAddVertex(TVertex v)
+        private void InitializeInDegrees()
         {
-            var eh = AddVertex;
-            if (eh != null)
-                eh(v);
+            foreach (TVertex vertex in VisitedGraph.Vertices)
+            {
+                Degrees.Add(vertex, VisitedGraph.AdjacentDegree(vertex));
+                _heap.Enqueue(vertex);
+            }
         }
 
-        public void Compute(IList<TVertex> vertices)
+        /// <summary>
+        /// Runs the topological sort and puts the result in the provided list.
+        /// </summary>
+        /// <param name="vertices">Set of sorted vertices.</param>
+        public void Compute([NotNull, ItemNotNull] IList<TVertex> vertices)
         {
 #if SUPPORTS_CONTRACTS
             Contract.Requires(vertices != null);
 #endif
 
-            this.sortedVertices = vertices;
+            SortedVertices = vertices;
+            SortedVertices.Clear();
             Compute();
         }
 
+        #region AlgorithmBase<TGraph>
 
+        /// <inheritdoc />
         protected override void InternalCompute()
         {
-            this.InitializeInDegrees();
-            var cancelManager = this.Services.CancelManager;
+            ICancelManager cancelManager = Services.CancelManager;
+            InitializeInDegrees();
 
-            while (this.heap.Count != 0)
+            while (_heap.Count != 0)
             {
-                if (cancelManager.IsCancelling) return;
+                if (cancelManager.IsCancelling)
+                    return;
 
-                TVertex v = this.heap.Dequeue();
-                if (this.degrees[v] != 0 && !this.AllowCyclicGraph)
+                TVertex vertex = _heap.Dequeue();
+                if (Degrees[vertex] != 0 && !AllowCyclicGraph)
                     throw new NonAcyclicGraphException();
 
-                this.sortedVertices.Add(v);
-                this.OnAddVertex(v);
+                SortedVertices.Add(vertex);
+                OnVertexAdded(vertex);
 
-                // update the count of it's adjacent vertices
-                foreach (var e in this.VisitedGraph.AdjacentEdges(v))
+                // Update the count of its adjacent vertices
+                foreach (TEdge edge in VisitedGraph.AdjacentEdges(vertex))
                 {
-                    if (e.Source.Equals(e.Target))
+                    if (edge.IsSelfEdge())
                         continue;
 
-                    this.degrees[e.Target]--;
-                    if (this.degrees[e.Target] < 0 && !this.AllowCyclicGraph)
-                        throw new InvalidOperationException("Degree is negative, and cannot be");
-                    if (this.heap.Contains(e.Target))
-                        this.heap.Update(e.Target);
+                    --Degrees[edge.Target];
+
+                    if (Degrees[edge.Target] < 0 && !AllowCyclicGraph)
+                        throw new InvalidOperationException("Degree is negative, and cannot be.");
+
+                    if (_heap.Contains(edge.Target))
+                        _heap.Update(edge.Target);
                 }
             }
         }
 
-        private void InitializeInDegrees()
-        {
-            foreach (var v in this.VisitedGraph.Vertices)
-            {
-                this.degrees.Add(v, this.VisitedGraph.AdjacentDegree(v));
-                this.heap.Enqueue(v);
-            }
-        }
+        #endregion
     }
 }
diff --git a/src/QuikGraph/Algorithms/TopologicalSort/UndirectedTopologicalSortAlgorithm.cs b/src/QuikGraph/Algorithms/TopologicalSort/UndirectedTopologicalSortAlgorithm.cs
index c4bc79364..dc28878a8 100644
--- a/src/QuikGraph/Algorithms/TopologicalSort/UndirectedTopologicalSortAlgorithm.cs
+++ b/src/QuikGraph/Algorithms/TopologicalSort/UndirectedTopologicalSortAlgorithm.cs
@@ -3,61 +3,91 @@
 #if SUPPORTS_CONTRACTS
 using System.Diagnostics.Contracts;
 #endif
+using JetBrains.Annotations;
 using QuikGraph.Algorithms.Search;
 
 namespace QuikGraph.Algorithms.TopologicalSort
 {
+    /// <summary>
+    /// Undirected topological sort algorithm.
+    /// </summary>
+    /// <typeparam name="TVertex">Vertex type.</typeparam>
+    /// <typeparam name="TEdge">Edge type.</typeparam>
 #if SUPPORTS_SERIALIZATION
     [Serializable]
 #endif
-    public sealed class UndirectedTopologicalSortAlgorithm<TVertex, TEdge>
-        : AlgorithmBase<IUndirectedGraph<TVertex, TEdge>>
+    public sealed class UndirectedTopologicalSortAlgorithm<TVertex, TEdge> : AlgorithmBase<IUndirectedGraph<TVertex, TEdge>>
         where TEdge : IEdge<TVertex>
     {
-        private IList<TVertex> vertices;
-        private bool allowCyclicGraph = false;
-
-        public UndirectedTopologicalSortAlgorithm(IUndirectedGraph<TVertex, TEdge> g)
-            : this(g, new List<TVertex>())
-        { }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UndirectedTopologicalSortAlgorithm{TVertex,TEdge}"/> class.
+        /// </summary>
+        /// <param name="visitedGraph">Graph to visit.</param>
+        public UndirectedTopologicalSortAlgorithm([NotNull] IUndirectedGraph<TVertex, TEdge> visitedGraph)
+            : this(visitedGraph, new List<TVertex>())
+        {
+        }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UndirectedTopologicalSortAlgorithm{TVertex,TEdge}"/> class.
+        /// </summary>
+        /// <param name="visitedGraph">Graph to visit.</param>
+        /// <param name="vertices">Set of sorted vertices.</param>
         public UndirectedTopologicalSortAlgorithm(
-            IUndirectedGraph<TVertex, TEdge> g,
-            IList<TVertex> vertices)
-            : base(g)
+            [NotNull] IUndirectedGraph<TVertex, TEdge> visitedGraph,
+            [NotNull, ItemNotNull] IList<TVertex> vertices)
+            : base(visitedGraph)
         {
 #if SUPPORTS_CONTRACTS
             Contract.Requires(vertices != null);
 #endif
 
-            this.vertices = vertices;
+            SortedVertices = vertices;
         }
 
-        public IList<TVertex> SortedVertices
-        {
-            get
-            {
-                return vertices;
-            }
-        }
+        /// <summary>
+        /// Sorted vertices.
+        /// </summary>
+#if SUPPORTS_CONTRACTS
+        [System.Diagnostics.Contracts.Pure]
+#endif
+        [NotNull, ItemNotNull]
+        public IList<TVertex> SortedVertices { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the flag that indicates if cyclic graph are supported or not.
+        /// </summary>
+        public bool AllowCyclicGraph { get; set; }
 
-        public bool AllowCyclicGraph
+        private void BackEdge([NotNull] object sender, [NotNull] UndirectedEdgeEventArgs<TVertex, TEdge> args)
         {
-            get { return this.allowCyclicGraph; }
-            set { this.allowCyclicGraph = value; }
+            if (!AllowCyclicGraph)
+                throw new NonAcyclicGraphException();
         }
 
-        private void BackEdge(object sender, UndirectedEdgeEventArgs<TVertex, TEdge> a)
+        private void OnVertexFinished([NotNull] TVertex vertex)
         {
-            if (!this.AllowCyclicGraph)
-                throw new NonAcyclicGraphException();
+            SortedVertices.Insert(0, vertex);
         }
 
-        private void FinishVertex(TVertex v)
+        /// <summary>
+        /// Runs the topological sort and puts the result in the provided list.
+        /// </summary>
+        /// <param name="vertices">Set of sorted vertices.</param>
+        public void Compute([NotNull, ItemNotNull] IList<TVertex> vertices)
         {
-            vertices.Insert(0, v);
+#if SUPPORTS_CONTRACTS
+            Contract.Requires(vertices != null);
+#endif
+
+            SortedVertices = vertices;
+            SortedVertices.Clear();
+            Compute();
         }
 
+        #region AlgorithmBase<TGraph>
+
+        /// <inheritdoc />
         protected override void InternalCompute()
         {
             UndirectedDepthFirstSearchAlgorithm<TVertex, TEdge> dfs = null;
@@ -66,10 +96,9 @@ protected override void InternalCompute()
                 dfs = new UndirectedDepthFirstSearchAlgorithm<TVertex, TEdge>(
                     this,
                     VisitedGraph,
-                    new Dictionary<TVertex, GraphColor>(this.VisitedGraph.VertexCount)
-                    );
+                    new Dictionary<TVertex, GraphColor>(VisitedGraph.VertexCount));
                 dfs.BackEdge += BackEdge;
-                dfs.FinishVertex += FinishVertex;
+                dfs.FinishVertex += OnVertexFinished;
 
                 dfs.Compute();
             }
@@ -78,16 +107,11 @@ protected override void InternalCompute()
                 if (dfs != null)
                 {
                     dfs.BackEdge -= BackEdge;
-                    dfs.FinishVertex -= FinishVertex;
+                    dfs.FinishVertex -= OnVertexFinished;
                 }
             }
         }
 
-        public void Compute(IList<TVertex> vertices)
-        {
-            this.vertices = vertices;
-            this.vertices.Clear();
-            this.Compute();
-        }
+        #endregion
     }
 }
diff --git a/tests/QuikGraph.Tests/Algorithms/TopologicalSortAlgorithmTest.cs b/tests/QuikGraph.Tests/Algorithms/TopologicalSortAlgorithmTest.cs
index 09c060dc7..481fe531d 100644
--- a/tests/QuikGraph.Tests/Algorithms/TopologicalSortAlgorithmTest.cs
+++ b/tests/QuikGraph.Tests/Algorithms/TopologicalSortAlgorithmTest.cs
@@ -28,10 +28,9 @@ public void SortCyclic<TVertex,TEdge>(
         [Test]
         public void SortDCT8()
         {
-            var g = TestGraphFactory.LoadGraph(GetGraphFilePath("DCT8.graphml"));
-            var topo = new TopologicalSortAlgorithm<string, Edge<string>>(g);
-            Assert.IsFalse(topo.AllowCyclicGraph);
-            topo.Compute();
+            var graph = TestGraphFactory.LoadGraph(GetGraphFilePath("DCT8.graphml"));
+            var topologicalSort = new TopologicalSortAlgorithm<string, Edge<string>>(graph);
+            topologicalSort.Compute();
         }
 
         [Test]