private static void GeometryToSqlGeometry(IMultiPoint geom, SqlGeometryBuilder bldr)
        {
            bldr.BeginGeometry(OpenGisGeometryType.MultiPoint);

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

            bldr.EndGeometry();
        }

 /// <summary>
 /// A MultiPoint is simple if it has no repeated points.
 /// </summary>
 public bool IsSimple(IMultiPoint mp)
 {
     if (mp.IsEmpty) 
         return true;
     ISet points = new ListSet();
     for (int i = 0; i < mp.NumGeometries; i++)
     {
         IPoint pt = (IPoint) mp.GetGeometryN(i);
         ICoordinate p = pt.Coordinate;
         if (points.Contains(p))
             return false;
         points.Add(p);
     }
     return true;
 }   

 public bool IsSimple(IMultiPoint mp)
 {
     return IsSimpleMultiPoint(mp);
 }

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

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

 /// <summary>
 /// Checks validity of a MultiPoint.
 /// </summary>
 /// <param name="g"></param>
 private void CheckValid(IMultiPoint g)
 {
     CheckInvalidCoordinates(g.Coordinates);
 }

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

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPoint"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IMultiPoint multiPoint)
 {            
     int numPoints = multiPoint.NumPoints;
     return CalculateLength(numPoints);
 }        

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPoint"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IMultiPoint multiPoint)
 {
     int count = InitValue;
     foreach (IPoint p in multiPoint.Geometries)
         count += SetByteStreamLength(p);
     return count;
 }

 /// <summary>
 /// Converts a <c>MultiPoint</c> to &lt;MultiPoint Text format, then
 /// appends it to the writer.
 /// </summary>
 /// <param name="multiPoint">The <c>MultiPoint</c> to process.</param>
 /// <param name="level"></param>
 /// <param name="writer">The output writer to append to.</param>
 private void AppendMultiPointText(IMultiPoint multiPoint, int level, TextWriter writer)
 {
     if (multiPoint.IsEmpty) 
         writer.Write(" EMPTY");
     else 
     {
         writer.Write("(");
         for (int i = 0; i < multiPoint.NumGeometries; i++) 
         {
             if (i > 0) writer.Write(",");
             AppendCoordinate(((IPoint) multiPoint.GetGeometryN(i)).Coordinate, writer, multiPoint.PrecisionModel);
         }
         writer.Write(")");
     }
 }

 /// <summary>
 /// Converts a <c>MultiPoint</c> to &lt;MultiPoint Tagged Text
 /// format, then appends it to the writer.
 /// </summary>
 /// <param name="multipoint">The <c>MultiPoint</c> to process.</param>
 /// <param name="level"></param>
 /// <param name="writer">The output writer to append to.</param>
 private void AppendMultiPointTaggedText(IMultiPoint multipoint, int level, TextWriter writer)
 {
     writer.Write("MULTIPOINT");
     AppendMultiPointText(multipoint, level, writer);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="geom"></param>
 /// <param name="parent"></param>
 /// <returns></returns>
 protected virtual IGeometry TransformMultiPoint(IMultiPoint geom, IGeometry parent) 
 {
     ArrayList transGeomList = new ArrayList();
     for (int i = 0; i < geom.NumGeometries; i++) 
     {
         IGeometry transformGeom = TransformPoint((IPoint) geom.GetGeometryN(i), geom);
         if (transformGeom == null) continue;
         if (transformGeom.IsEmpty) continue;
         transGeomList.Add(transformGeom);
     }
     return factory.BuildGeometry(transGeomList);
 }

 /// <summary>
 /// Converts the <c>ICollection</c> to an array.
 /// </summary>
 /// <param name="multiPoints">The <c>ICollection</c> of MultiPoints to convert.</param>
 /// <returns>The <c>ICollection</c> in array format.</returns>
 public static IMultiPoint[] ToMultiPointArray(ICollection multiPoints)
 {
     IMultiPoint[] list = new IMultiPoint[multiPoints.Count];
     int i = 0;
     foreach (IMultiPoint mp in multiPoints)
         list[i++] = mp;
     return list;
 }

 private static DSMultiPoint FromMultiPoint(IMultiPoint geometry, DSGeometryFactory factory, bool setUserData)
 {
     var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
     if (setUserData)
         result.UserData = geometry.UserData;
     return result;
 }

 private static GeoAPIMultiPoint FromMultiPoint(IMultiPoint geometry, GeoAPIGeometryFactory factory, bool copyUserData)
 {
     var result = factory.CreateMultiPoint(FromCoordinates(geometry.Coordinates));
     if (copyUserData)
         result.UserData = geometry.UserData;
     return result;
 }

        private bool IsSimpleMultiPoint(IMultiPoint mp)
        {
            if (mp.IsEmpty) 
                return true;

            HashSet<Coordinate> points = new HashSet<Coordinate>();
            for (int i = 0; i < mp.NumGeometries; i++)
            {
                IPoint pt = (IPoint)mp.GetGeometryN(i);
                Coordinate p = pt.Coordinate;
                if (points.Contains(p))
                {
                    _nonSimpleLocation = p;
                    return false;
                }
                points.Add(p);
            }
            return true;
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="multiPoint"></param>
 /// <param name="writer"></param>
 protected void Write(IMultiPoint multiPoint, XmlTextWriter writer)
 {
     writer.WriteStartElement("MultiPoint", GMLElements.gmlNS);
     for (int i = 0; i < multiPoint.NumGeometries; i++)
     {
         writer.WriteStartElement("pointMember", GMLElements.gmlNS);
         Write(multiPoint.Geometries[i] as IPoint, writer);
         writer.WriteEndElement();
     }
     writer.WriteEndElement();
 }

        /// <summary>
        /// Method to write a multipoint geometry to the <paramref name="writer"/>
        /// </summary>
        /// <param name="points">The multipoint geometry</param>
        /// <param name="writer">The JSON writer</param>
        public static void Write(IMultiPoint points, JsonTextWriter writer)
        {
            if (points == null)
                return;
            if (writer == null)
                throw new ArgumentNullException("writer", "A valid JSON writer object is required");

            writer.WriteStartObject();
            writer.WritePropertyName("type");
            writer.WriteValue("MultiPoint");
            writer.WritePropertyName("coordinates");
            /*
            writer.WriteStartArray();
            foreach (var entry in points.Coordinates)
                WriteCoord(entry, writer);
            writer.WriteEndArray();
             */
            WriteCoord(points.Coordinates, writer);
            writer.WriteEndObject();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="multiPoint"></param>
        /// <param name="writer"></param>
        public void Write(IMultiPoint multiPoint, BinaryWriter writer)
        {
            writer.Write((int) ShapeGeometryTypes.MultiPoint);

            // Write BoundingBox            
            WriteBoundingBox(multiPoint, writer);

            // Write NumPoints            
            writer.Write((int) multiPoint.NumPoints);

            // Write Coordinates
            for (int i = 0; i < multiPoint.NumPoints; i++)
                Write(multiPoint.Coordinates[i], writer);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="geometry"></param>
        /// <returns></returns>
        protected int SetByteStream(IMultiPoint geometry)
        {
			// int size
			int result = 4;
			if (geometry.NumPoints > 0)
			{
				// We can shortcut here, as all subgeoms have the same fixed size
				result += geometry.NumPoints * SetByteStream(geometry.Geometries[0] as IGeometry);
			}
			return result;
		}