Index: src/Common/NetTopologySuite/Operation/Linemerge/LineMerger.cs
===================================================================
diff -u -r8f6ae890fed8e8eae3a32f9c0498a10f82e0ddf9 -r5fc71a385897af92ccb092f2f969b5709afab85a
--- src/Common/NetTopologySuite/Operation/Linemerge/LineMerger.cs	(.../LineMerger.cs)	(revision 8f6ae890fed8e8eae3a32f9c0498a10f82e0ddf9)
+++ src/Common/NetTopologySuite/Operation/Linemerge/LineMerger.cs	(.../LineMerger.cs)	(revision 5fc71a385897af92ccb092f2f969b5709afab85a)
@@ -16,42 +16,20 @@
     /// at their endpoints.  The LineMerger will still run on incorrectly noded input
     /// but will not form polygons from incorrected noded edges.
     /// </summary>
-    public class LineMerger 
+    public class LineMerger
     {
-        /// <summary>
-        /// 
-        /// </summary>
-        private class AnonymousGeometryComponentFilterImpl : IGeometryComponentFilter
-        {
-            private LineMerger container = null;
+        private readonly LineMergeGraph graph = new LineMergeGraph();
+        private IList mergedLineStrings = null;
+        private IList edgeStrings = null;
+        private IGeometryFactory factory = null;
 
-            /// <summary>
-            /// 
-            /// </summary>
-            /// <param name="container"></param>
-            public AnonymousGeometryComponentFilterImpl(LineMerger container)
-            {
-                this.container = container;
-            }
-
-            /// <summary>
-            /// 
-            /// </summary>
-            /// <param name="component"></param>
-            public void Filter(IGeometry component)
-            {
-                if (component is ILineString)
-                    container.Add((ILineString) component);
-            }
-        }
-
         /// <summary>
         /// Adds a collection of Geometries to be processed. May be called multiple times.
         /// Any dimension of Geometry may be added; the constituent linework will be
         /// extracted.
         /// </summary>
         /// <param name="geometries"></param>
-        public void Add(IList geometries) 
+        public void Add(IList geometries)
         {
             IEnumerator i = geometries.GetEnumerator();
             while (i.MoveNext())
@@ -61,96 +39,105 @@
             }
         }
 
-        private LineMergeGraph graph = new LineMergeGraph();
-        private IList mergedLineStrings = null;
-        private IList edgeStrings = null;
-        private IGeometryFactory factory = null;
-
         /// <summary>
         /// Adds a Geometry to be processed. May be called multiple times.
         /// Any dimension of Geometry may be added; the constituent linework will be
         /// extracted.
         /// </summary>
         /// <param name="geometry"></param>
         public void Add(IGeometry geometry)
-        {            
+        {
             geometry.Apply(new AnonymousGeometryComponentFilterImpl(this));
         }
 
         /// <summary>
+        /// Returns the LineStrings built by the merging process.
+        /// </summary>
+        /// <returns></returns>
+        public IList GetMergedLineStrings()
+        {
+            Merge();
+            return mergedLineStrings;
+        }
+
+        /// <summary>
         /// 
         /// </summary>
         /// <param name="lineString"></param>
-        private void Add(ILineString lineString) 
+        private void Add(ILineString lineString)
         {
-            if (factory == null) 
-                this.factory = lineString.Factory;            
+            if (factory == null)
+            {
+                factory = lineString.Factory;
+            }
             graph.AddEdge(lineString);
         }
-        
+
         /// <summary>
         /// 
         /// </summary>
-        private void Merge() 
+        private void Merge()
         {
-            if (mergedLineStrings != null) 
-                return; 
+            if (mergedLineStrings != null)
+            {
+                return;
+            }
             edgeStrings = new ArrayList();
             BuildEdgeStringsForObviousStartNodes();
             BuildEdgeStringsForIsolatedLoops();
-            mergedLineStrings = new ArrayList();    
-            for (IEnumerator i = edgeStrings.GetEnumerator(); i.MoveNext(); ) 
+            mergedLineStrings = new ArrayList();
+            for (IEnumerator i = edgeStrings.GetEnumerator(); i.MoveNext();)
             {
                 EdgeString edgeString = (EdgeString) i.Current;
                 mergedLineStrings.Add(edgeString.ToLineString());
-            }    
+            }
         }
 
         /// <summary>
         /// 
         /// </summary>
-        private void BuildEdgeStringsForObviousStartNodes() 
+        private void BuildEdgeStringsForObviousStartNodes()
         {
             BuildEdgeStringsForNonDegree2Nodes();
         }
 
         /// <summary>
         /// 
         /// </summary>
-        private void BuildEdgeStringsForIsolatedLoops() 
+        private void BuildEdgeStringsForIsolatedLoops()
         {
             BuildEdgeStringsForUnprocessedNodes();
-        }  
+        }
 
         /// <summary>
         /// 
         /// </summary>
-        private void BuildEdgeStringsForUnprocessedNodes() 
+        private void BuildEdgeStringsForUnprocessedNodes()
         {
             IEnumerator i = graph.Nodes.GetEnumerator();
             while (i.MoveNext())
             {
                 Node node = (Node) i.Current;
-                if (!node.IsMarked) 
-                { 
+                if (!node.IsMarked)
+                {
                     Assert.IsTrue(node.Degree == 2);
                     BuildEdgeStringsStartingAt(node);
                     node.Marked = true;
                 }
             }
-        }  
+        }
 
         /// <summary>
         /// 
         /// </summary>
-        private void BuildEdgeStringsForNonDegree2Nodes() 
+        private void BuildEdgeStringsForNonDegree2Nodes()
         {
             IEnumerator i = graph.Nodes.GetEnumerator();
-            while (i.MoveNext()) 
+            while (i.MoveNext())
             {
                 Node node = (Node) i.Current;
-                if (node.Degree != 2) 
-                { 
+                if (node.Degree != 2)
+                {
                     BuildEdgeStringsStartingAt(node);
                     node.Marked = true;
                 }
@@ -161,14 +148,16 @@
         /// 
         /// </summary>
         /// <param name="node"></param>
-        private void BuildEdgeStringsStartingAt(Node node) 
+        private void BuildEdgeStringsStartingAt(Node node)
         {
             IEnumerator i = node.OutEdges.GetEnumerator();
-            while (i.MoveNext()) 
+            while (i.MoveNext())
             {
                 LineMergeDirectedEdge directedEdge = (LineMergeDirectedEdge) i.Current;
                 if (directedEdge.Edge.IsMarked)
+                {
                     continue;
+                }
                 edgeStrings.Add(BuildEdgeStringStartingWith(directedEdge));
             }
         }
@@ -178,28 +167,46 @@
         /// </summary>
         /// <param name="start"></param>
         /// <returns></returns>
-        private EdgeString BuildEdgeStringStartingWith(LineMergeDirectedEdge start) 
-        {    
+        private EdgeString BuildEdgeStringStartingWith(LineMergeDirectedEdge start)
+        {
             EdgeString edgeString = new EdgeString(factory);
             LineMergeDirectedEdge current = start;
-            do 
+            do
             {
                 edgeString.Add(current);
                 current.Edge.Marked = true;
-                current = current.Next;      
-            }
-            while (current != null && current != start);
+                current = current.Next;
+            } while (current != null && current != start);
             return edgeString;
         }
 
         /// <summary>
-        /// Returns the LineStrings built by the merging process.
+        /// 
         /// </summary>
-        /// <returns></returns>
-        public IList GetMergedLineStrings() 
+        private class AnonymousGeometryComponentFilterImpl : IGeometryComponentFilter
         {
-            Merge();
-            return mergedLineStrings;
+            private readonly LineMerger container = null;
+
+            /// <summary>
+            /// 
+            /// </summary>
+            /// <param name="container"></param>
+            public AnonymousGeometryComponentFilterImpl(LineMerger container)
+            {
+                this.container = container;
+            }
+
+            /// <summary>
+            /// 
+            /// </summary>
+            /// <param name="component"></param>
+            public void Filter(IGeometry component)
+            {
+                if (component is ILineString)
+                {
+                    container.Add((ILineString) component);
+                }
+            }
         }
     }
-}
+}
\ No newline at end of file