private static IGeometryCollection ClipGeometryCollection(IGeometryCollection geom, Envelope clipEnv)
        {
            var clipPoly = geom.Factory.ToGeometry(clipEnv);
            var clipped = new List<IGeometry>();
            for (var i = 0; i < geom.NumGeometries; i++)
            {
                var g = geom.GetGeometryN(i);
                IGeometry result = null;
                // don't clip unless necessary
                if (clipEnv.Contains(g.EnvelopeInternal))
                    result = g;
                else if (clipEnv.Intersects(g.EnvelopeInternal))
                {
                    result = clipPoly.Intersection(g);
                    // keep vertex key info
                    result.UserData = g.UserData;
                }

                if (result != null && !result.IsEmpty)
                {
                    clipped.Add(result);
                }
            }
            return geom.Factory.CreateGeometryCollection(GeometryFactory.ToGeometryArray(clipped));
        }

 /// <summary>
 /// Constructs an iterator over the given <c>GeometryCollection</c>.
 /// </summary>
 /// <param name="parent">
 /// The collection over which to iterate; also, the first
 /// element returned by the iterator.
 /// </param>
 public GeometryCollectionEnumerator(IGeometryCollection parent) 
 {
     this.parent = parent;
     atStart = true;
     index = 0;
     max = parent.NumGeometries;
 }

 private static void WriteShape(IGeometryCollection geometries, string shapepath)
 {
     if (File.Exists(shapepath))
         File.Delete(shapepath);
     var sfw = new ShapefileWriter(geometries.Factory);
     sfw.Write(Path.GetFileNameWithoutExtension(shapepath), geometries);
 }

 /// <summary>
 /// Constructs an iterator over the given <c>GeometryCollection</c>.
 /// </summary>
 /// <param name="parent">
 /// The collection over which to iterate; also, the first
 /// element returned by the iterator.
 /// </param>
 public GeometryCollectionEnumerator(IGeometryCollection parent) 
 {
     _parent = parent;
     _atStart = true;
     _index = 0;
     _max = parent.NumGeometries;
 }

 public void LoadSourceGeometries(IGeometryCollection geomColl)
 {
     for (int i = 0; i < geomColl.NumGeometries; i++)
     {
         IGeometry geom = geomColl.GetGeometryN(i);
         LoadVertices(geom.Coordinates, geom.UserData);
     }
 }

        private static IEnumerable<IGeometry> DoMerge(IGeometryCollection coll)
        {
            if (coll == null)
                throw new ArgumentNullException("coll");

            IEnumerable<IGeometry> items = GetItems(coll);
            yield return UnaryUnionOp.Union(items.ToArray());
        }

        public static void AddOutlineToGraphicsLayer3D(IGraphicsContainer3D graphicsContainer3D, IGeometryCollection geometryCollection, IColor color, esriSimple3DLineStyle style, double width)
        {
            for (int i = 0; i < geometryCollection.GeometryCount; i++)
            {
                IGeometry geometry = geometryCollection.get_Geometry(i);

                graphicsContainer3D.AddElement(ElementUtilities.ConstructPolylineElement(geometry, color, style, width));
            }
        }

        /// <summary>
        /// Uses the passed geometry collection to generate a QuickGraph.
        /// </summary>
        /// <param name="edges"></param>
        /// <param name="src"></param>
        /// <param name="dst"></param>
        public ILineString TestGraphBuilder2WithSampleGeometries(IGeometryCollection edges, ICoordinate src, ICoordinate dst)
        {
            GraphBuilder2 builder = new GraphBuilder2(true);            
            foreach (IMultiLineString edge in edges.Geometries)
                foreach (ILineString line in edge.Geometries)                                
                    builder.Add(line);            
            builder.Initialize();

            return builder.Perform(src, dst);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="gc"></param>
 /// <returns></returns>
 private bool HasRepeatedPoint(IGeometryCollection gc)
 {
     for (int i = 0; i < gc.NumGeometries; i++)
     {
         IGeometry g = gc.GetGeometryN(i);
         if (HasRepeatedPoint(g)) 
             return true;
     }
     return false;
 }

 /// <summary>
 /// Transforms a <see cref="IGeometryCollection" /> object.
 /// </summary>
 /// <param name="factory">The factory to create the new <see cref="IGeometryCollection"/></param>
 /// <param name="geoms">The input <see cref="IGeometryCollection"/></param>
 /// <param name="transform">The <see cref="IMathTransform"/></param>
 /// <returns>A transformed <see cref="IGeometryCollection"/></returns>
 public static IGeometryCollection TransformGeometryCollection(IGeometryFactory factory, 
     IGeometryCollection geoms, IMathTransform transform)
 {
     var geometries = geoms.Geometries;
     var coll = new List<IGeometry>(geometries.Length);
     foreach (var g in geometries)
     {
         var item = TransformGeometry(factory, g, transform);
         coll.Add(item);
     }
     return factory.CreateGeometryCollection(coll.ToArray());
 }

 /// <summary>
 ///
 /// </summary>
 /// <param name="gc"></param>
 /// <returns></returns>
 public IGeometryCollection Map(IGeometryCollection gc)
 {
     IList<IGeometry> mapped = new List<IGeometry>();
     for (var i = 0; i < gc.NumGeometries; i++)
     {
         var g = _mapOp(gc.GetGeometryN(i));
         if (!g.IsEmpty)
             mapped.Add(g);
     }
     return gc.Factory.CreateGeometryCollection(
         GeometryFactory.ToGeometryArray(mapped));
 }

        private static IEnumerable<IGeometry> DoClean(IGeometryCollection coll)
        {
            if (coll == null)
                throw new ArgumentNullException("coll");

            IEnumerable<IGeometry> items = GetItems(coll);
            foreach (IGeometry geom in items)
            {
                DouglasPeuckerSimplifier simplifier = new DouglasPeuckerSimplifier(geom);
                IGeometry clean = simplifier.GetResultGeometry();
                yield return clean;
            }
        }

        public List<string> ParseGeometryCollection(IGeometryCollection geometryCollection)
        {
            var coords = new List<string>();

            //for each geometry in the collection
            for (int i = 0; i < geometryCollection.GeometryCount; i++)
            {
                var pGeom = geometryCollection.Geometry[i];
                var pntCollection = (IPointCollection)pGeom;

                for (var a = 0; a < pntCollection.PointCount; a++)
                {
                    var roundedPoint = Math.Round(pntCollection.Point[a].Y, 5) + " " + Math.Round(pntCollection.Point[a].X, 5);
                    //compare the point to the last one entered to make sure only unique points are entered
                    string lastPoint = "";
                    if (coords.Count > 1) lastPoint = coords[coords.Count - 1];
                    if (!lastPoint.Equals(roundedPoint)) coords.Add(roundedPoint);
                }
            }
            return coords;
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="geometryCollection"></param>
 /// <returns></returns>
 protected int SetByteStreamLength(IGeometryCollection geometryCollection)
 {
     int count = InitValue;
     foreach (IGeometry g in geometryCollection.Geometries)
         count += SetByteStreamLength(g);
     return count;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="geometryCollection"></param>
 /// <param name="writer"></param>
 protected void Write(IGeometryCollection geometryCollection, XmlTextWriter writer)
 {
     writer.WriteStartElement("MultiGeometry", GMLElements.gmlNS);
     for (int i = 0; i < geometryCollection.NumGeometries; i++)
     {
         writer.WriteStartElement("geometryMember", GMLElements.gmlNS);
         Write(geometryCollection.Geometries[i], writer);
         writer.WriteEndElement();
     }
     writer.WriteEndElement();
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="gc"></param>
 private void AddCollection(IGeometryCollection gc)
 {
     for (int i = 0; i < gc.NumGeometries; i++)
     {
         IGeometry g = gc.GetGeometryN(i);
         Add(g);
     }
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="operation"></param>
        /// <returns></returns>
        private IGeometryCollection EditGeometryCollection(IGeometryCollection collection, GeometryEditorOperation operation)
        {
            IGeometryCollection newCollection = (IGeometryCollection) operation.Edit(collection, factory);
            ArrayList geometries = new ArrayList();
            for (int i = 0; i < newCollection.NumGeometries; i++) 
            {
                IGeometry geometry = Edit(newCollection.GetGeometryN(i), operation);
                if (geometry.IsEmpty)  continue;
                geometries.Add(geometry);
            }

            if (newCollection is IMultiPoint) 
                return factory.CreateMultiPoint((IPoint[]) geometries.ToArray(typeof(IPoint)));

            if (newCollection is IMultiLineString) 
                return factory.CreateMultiLineString((ILineString[]) geometries.ToArray(typeof(ILineString)));

            if (newCollection is IMultiPolygon)
                return factory.CreateMultiPolygon((IPolygon[]) geometries.ToArray(typeof(IPolygon)));

            return factory.CreateGeometryCollection((IGeometry[]) geometries.ToArray(typeof(IGeometry)));
        }

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

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

        /// <summary>
        /// Transforms a <see cref="GeoAPI.Geometries.IGeometryCollection"/>.
        /// </summary>
        /// <param name="geoms">GeometryCollection 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 GeometryCollection</returns>
        public static IGeometryCollection TransformGeometryCollection(IGeometryCollection geoms, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
        {
            var gOut = new IGeometry[geoms.Count];
            for (var i = 0; i < geoms.Count; i++)
                gOut[i] = TransformGeometry(geoms.GetGeometryN(i), from, to, toFactory);

            return toFactory.CreateGeometryCollection(gOut);
        }