//private Map endpointMap;

        private Coordinate[] ComputeBoundaryCoordinates(IMultiLineString mLine)
        {
            IList<Coordinate> bdyPts = new List<Coordinate>();
            _endpointMap = new OrderedDictionary<Coordinate, Counter>();
            for (int i = 0; i < mLine.NumGeometries; i++)
            {
                ILineString line = (ILineString)mLine.GetGeometryN(i);
                if (line.NumPoints == 0)
                    continue;
                AddEndpoint(line.GetCoordinateN(0));
                AddEndpoint(line.GetCoordinateN(line.NumPoints - 1));
            }

            foreach (KeyValuePair<Coordinate, Counter> entry in _endpointMap)
            {
                Counter counter = entry.Value;
                int valence = counter.Count;
                if (_bnRule.IsInBoundary(valence))
                {
                    bdyPts.Add(entry.Key);
                }
            }

            return CoordinateArrays.ToCoordinateArray(bdyPts);
        }

 public static void DrawMultiLineString(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IMultiLineString lines, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, Map map, float offset)
 {
     for (var i = 0; i < lines.NumGeometries; i++)
     {
         var line = (ILineString)lines[i];
         DrawLineString(renderTarget, factory, line, pen, penWidth, penStrokeStyle, map, offset);
     }
 }

 public static void DrawMultiLineString(Graphics g, IMultiLineString lines, Pen pen, Map map, float offset)
 {
     for(var i = 0; i < lines.NumGeometries; i++)
     {
         var line = (ILineString) lines[i];
         DrawLineString(g, line, pen, map, offset);
     }
 }

        private static void GeometryToSqlGeometry(IMultiLineString geom, SqlGeometryBuilder bldr)
        {
            bldr.BeginGeometry(OpenGisGeometryType.MultiLineString);

            for (int i = 0, c = geom.NumGeometries; i < c; i++)
                GeometryToSqlGeometry(geom.Geometries[i] as ILineString, bldr);

            bldr.EndGeometry();
        }

        private IGeometry BoundaryMultiLineString(IMultiLineString mLine)
        {
            if (_geom.IsEmpty)
            {
                return GetEmptyMultiPoint();
            }

            Coordinate[] bdyPts = ComputeBoundaryCoordinates(mLine);

            // return Point or MultiPoint
            if (bdyPts.Length == 1)
            {
                return _geomFact.CreatePoint(bdyPts[0]);
            }
            // this handles 0 points case as well
            return _geomFact.CreateMultiPoint(bdyPts);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="geometry"></param>
        /// <returns></returns>
        protected int SetByteStream(IMultiLineString geometry)
        {
			// 4-byte count + subgeometries
			return 4 + SetByteStream(geometry.Geometries);
		}

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiLineString"></param>
 /// <param name="writer"></param>
 protected void Write(IMultiLineString multiLineString, BinaryWriter writer)
 {
     WriteByteOrder(writer);     // LittleIndian
     writer.Write((int) WKBGeometryTypes.WKBMultiLineString);
     writer.Write((int) multiLineString.NumGeometries);
     for (int i = 0; i < multiLineString.NumGeometries; i++)
         Write(multiLineString.Geometries[i] as ILineString, writer);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiLineString"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IMultiLineString multiLineString)
 {            
     int numParts = multiLineString.NumGeometries;
     int numPoints = multiLineString.NumPoints;
     return CalculateLength(numParts, numPoints);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiLineString"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IMultiLineString multiLineString)
 {
     int count = InitValue;
     foreach (ILineString ls in multiLineString.Geometries)
         count += SetByteStreamLength(ls);
     return count;
 }

 public bool IsSimple(IMultiLineString geom)
 {
     return IsSimpleLinearGeometry(geom);
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="multiLineString"></param>
 /// <param name="writer"></param>
 protected virtual void Write(IMultiLineString multiLineString, BinaryWriter writer)
 {
     WriteByteOrder(writer);
     writer.Write((int)WkbGeometryType.MultiLineString);
     writer.Write(multiLineString.NumGeometries);
     for (int i = 0; i < multiLineString.NumGeometries; i++)
         Write(multiLineString.Geometries[i] as LineString, writer);
 }

        private static GeoAPIMultiLineString FromMultiLineString(IMultiLineString geometry, GeoAPIGeometryFactory factory, bool copyUserData)
        {
            var dsLineStrings = new GeoAPILineString[geometry.NumGeometries];

            for (var i = 0; i < dsLineStrings.Length; i++)
                dsLineStrings[i] = FromLineString((ILineString)geometry.GetGeometryN(i), factory, copyUserData);

            var result = factory.CreateMultiLineString(dsLineStrings);
            if (copyUserData)
                result.UserData = geometry.UserData;
            return result;
        }

        /// <summary>
        /// Method to write a multi linestring geometry to the <paramref name="writer"/>
        /// </summary>
        /// <param name="lines">The multi linestring geometry</param>
        /// <param name="writer">The JSON writer</param>
        public static void Write(IMultiLineString lines, TextWriter writer)
        {
            if (lines == null)
                return;
            if (writer == null)
                throw new ArgumentNullException("writer", "A valid text writer object is required");

            Write(lines, CreateWriter(writer));
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiLineString"></param>
 /// <param name="writer"></param>
 protected void Write(IMultiLineString multiLineString, BinaryWriter writer)
 {
     WriteByteOrder(writer);     // LittleIndian
     if (Double.IsNaN(multiLineString.Coordinate.Z))
          writer.Write((int)WKBGeometryTypes.WKBMultiLineString);
     else writer.Write((int)WKBGeometryTypes.WKBMultiLineStringZ);
     writer.Write((int) multiLineString.NumGeometries);
     for (int i = 0; i < multiLineString.NumGeometries; i++)
         Write(multiLineString.Geometries[i] as ILineString, writer);
 }

        /// <summary>
        /// Writes a multilinestring.
        /// </summary>
        /// <param name="mls">The multilinestring to be written.</param>
        /// <param name="bWriter">Stream to write to.</param>
        /// <param name="byteorder">Byte order</param>
        private static void WriteMultiLineString(IMultiLineString mls, BinaryWriter bWriter, WkbByteOrder byteorder)
        {
            //Write the number of linestrings.
            int num = mls.NumGeometries;
            WriteUInt32((uint) num, bWriter, byteorder);

            //Loop on the number of linestrings. 
            //NOTE: by contract, the first item returned 
            //      from GetEnumerator (i.e. using foreach) is the IMultiLineString itself!
            for (int i = 0; i < num; i++)
            {
                ILineString ls = (ILineString) mls.GetGeometryN(i);
                //Write LineString Header
                bWriter.Write((byte)byteorder);
                WriteUInt32((uint)WKBGeometryType.wkbLineString, bWriter, byteorder);
                //Write each linestring.
                WriteLineString(ls, bWriter, byteorder);
            }
        }

        /// <summary>
        /// Transforms a <see cref="GeoAPI.Geometries.IMultiLineString"/>.
        /// </summary>
        /// <param name="lines">MultiLineString to transform</param>
        /// <param name="from">Source Projection</param>
        /// <param name="to">Target Projection</param>
        /// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param>
        /// <returns>Transformed MultiLineString</returns>
        public static IMultiLineString TransformMultiLineString(IMultiLineString lines, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
        {
            var l = new ILineString[lines.Count];
            for (var i = 0; i < lines.Count; i++)
                l[i] = TransformLineString((ILineString)lines.GetGeometryN(i), from, to, toFactory);

            return toFactory.CreateMultiLineString(l);
        }

        private static DSMultiLineString FromMultiLineString(IMultiLineString geometry, DSGeometryFactory factory, bool setUserData)
        {
            var dsLineStrings = new DotSpatial.Topology.IBasicLineString[geometry.NumGeometries];

            for (var i = 0; i < dsLineStrings.Length; i++)
                dsLineStrings[i] = FromLineString((ILineString)geometry.GetGeometryN(i), factory, setUserData);

            var result = factory.CreateMultiLineString(dsLineStrings);
            if (setUserData)
                result.UserData = geometry.UserData;
            return result;
        }

 /// <summary>
 ///
 /// </summary>
 /// <param name="geometry"></param>
 /// <returns></returns>
 protected virtual int SetByteStream(IMultiLineString geometry)
 {
     int count = INIT_COUNT;
     count += 4;
     foreach (LineString geom in geometry.Geometries)
         count += SetByteStream(geom);
     return count;
 }

        /// <summary>
        /// Determines whether specific Coordinate in on the given multiline.
        /// </summary>
        /// <param name="c">The coordinate to check.</param>
        /// <param name="multiline">The multiline to check coordinate against.</param>
        /// <returns>true if coordinate lies on any line of the given multiline, otherwise false.</returns>
        public bool IsOnLine(Coordinate c, IMultiLineString multiline)
        {
            foreach (var line in multiline.Geometries) {
                if (this.IsOnLine(c, line)) {
                    return true;
                }
            }

            return false;
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiLineString"></param>
 /// <param name="writer"></param>
 protected void Write(IMultiLineString multiLineString, XmlTextWriter writer)
 {
     writer.WriteStartElement("MultiLineString", GMLElements.gmlNS);
     for (int i = 0; i < multiLineString.NumGeometries; i++)
     {
         writer.WriteStartElement("lineStringMember", GMLElements.gmlNS);
         Write(multiLineString.Geometries[i] as ILineString, writer);
         writer.WriteEndElement();
     }
     writer.WriteEndElement();
 }