C# IFeatureSet类代码示例

 public CheckDataInput(IFeatureSet originalData, string field, string trans)
 {
     this._originalData = originalData;
     this.field = field;
     this.trans = trans;
 
 }

 /// <summary>
 /// Show the dialog to join an Excel table with a feature set.
 /// </summary>
 /// <param name="e"></param>
 public void ExcelJoin(IFeatureSet e)
 {
     using (var jd = new JoinDialog(e))
     {
         ShowDialog(jd);
     }
 }

 /// <summary>
 /// Creates a new instance of a GeoPointLayer without sending any status messages
 /// </summary>
 /// <param name="featureSet">The IFeatureLayer of data values to turn into a graphical GeoPointLayer</param>
 public MapPointLayer(IFeatureSet featureSet)
     : base(featureSet)
 {
     // this simply handles the default case where no status messages are requested
     Configure();
     OnFinishedLoading();
 }

        //when clicking "OK"
        private void btnOK_Click(object sender, EventArgs e)
        {
            queryResult = null;
            SpatiaLiteHelper slh = new SpatiaLiteHelper();
            queryResult = slh.ReadFeatureSet(connString, txtQuery.Text);

            dgQueryResult.DataSource = queryResult.DataTable;

            //SpatiaLiteHelper slh = new SpatiaLiteHelper();

            //foreach (DataGridViewRow r in dgGeometryColumns.Rows)
            //{
            //    if (r.Selected)
            //    {
            //        GeometryColumnInfo item = r.DataBoundItem as GeometryColumnInfo;
            //        if (item != null)
            //        {
            //            IFeatureSet fs = slh.ReadFeatureSet(connString, item);

            //            IMapFeatureLayer lay = mainMap.Layers.Add(fs);
            //            //lay.EditMode = false;

            //        }
            //    }
            //}
        }

 /// <summary>
 /// Generates an empty featureset that has the combined fields from this featureset
 /// and the specified featureset.
 /// </summary>
 /// <param name="self">This featureset</param>
 /// <param name="other">The other featureset to combine fields with.</param>
 /// <returns></returns>
 public static IFeatureSet CombinedFields(this IFeatureSet self, IFeatureSet other)
 {
     IFeatureSet result = new FeatureSet(self.FeatureType);
     Dictionary<string, DataColumn> resultColumns = new Dictionary<string, DataColumn>();
     foreach (DataColumn dc in self.DataTable.Columns)
     {
         string name = dc.ColumnName;
         int i = 1;
         while (resultColumns.ContainsKey(name))
         {
             name = dc.ColumnName + i;
             i++;
         }
         resultColumns.Add(name, dc);
     }
     foreach (DataColumn dc in other.DataTable.Columns)
     {
         string name = dc.ColumnName;
         int i = 1;
         while (resultColumns.ContainsKey(name))
         {
             name = dc.ColumnName + i;
             i++;
         }
         resultColumns.Add(name, dc);
     }
     foreach (KeyValuePair<string, DataColumn> pair in resultColumns)
     {
         result.DataTable.Columns.Add(new DataColumn(pair.Key, pair.Value.DataType));
     }
     return result;
 }

 public static IMapFeatureLayer Insert(this IMapLayerCollection collection, int index, IFeatureSet featureSet)
 {
     if (featureSet != null)
     {
         featureSet.ProgressHandler = collection.ProgressHandler;
         if ((featureSet.FeatureType == FeatureType.Point) || (featureSet.FeatureType == FeatureType.MultiPoint))
         {
             IMapPointLayer item = new MapPointLayer(featureSet);
             collection.Insert(index, item);
             item.ProgressHandler = collection.ProgressHandler;
             return item;
         }
         if (featureSet.FeatureType == FeatureType.Line)
         {
             IMapLineLayer layer2 = new MapLineLayer(featureSet);
             collection.Insert(index, layer2);
             layer2.ProgressHandler = collection.ProgressHandler;
             return layer2;
         }
         if (featureSet.FeatureType == FeatureType.Polygon)
         {
             IMapPolygonLayer layer3 = new MapPolygonLayer(featureSet);
             collection.Insert(index, layer3);
             layer3.ProgressHandler = collection.ProgressHandler;
             return layer3;
         }
     }
     return null;
 }

       public static IFeatureSet FeatureFromPoints(List<Kpoint> points, IFeatureSet refe)
        {
            foreach(Kpoint p in points)
               {
                }

            return refe;
        }

        private void Configure(IFeatureSet inFeatureSet)
        {
            if (inFeatureSet == null) throw new ArgumentNullException("inFeatureSet");
            if (inFeatureSet.FeatureType != FeatureType.Polygon) throw new PolygonFeatureTypeException();

            Symbology = new PolygonScheme();
            Symbology.SetParentItem(this);
        }

 /// <summary>
 ///
 /// </summary>
 /// <param name="featureSet"></param>
 /// <param name="inFilter"></param>
 /// <param name="activeType"></param>
 /// <param name="isReadOnly"></param>
 public FeatureSelection(IFeatureSet featureSet, IDrawingFilter inFilter, FilterType activeType, bool isReadOnly)
 {
     _filter = inFilter;
     _activeType = activeType;
     _isReadOnly = isReadOnly;
     _featureSet = featureSet;
     Configure();
 }

 private void Configure(IFeatureSet inFeatureSet)
 {
     if (inFeatureSet.FeatureType != FeatureType.Line)
     {
         throw new LineFeatureTypeException();
     }
     Symbology = new LineScheme();
 }

        /// <summary>
        /// Initializes a new instance of the IDW class
        /// </summary>
        /// <param name="shapeLayer">Shapefile type point</param>
        /// <param name="idField">Position of field that contains the Z value</param>
        public IDW(IFeatureSet shapeLayer, int idField) :
            base(shapeLayer, idField)
        {
            this.method = "IDW";

           // this.CreatePoints(shapeLayer, idField);
          //  this.CalculateDistances();
        }

        public SearchResultItem(string serviceCode, IFeatureSet featureSet)
        {
            if (serviceCode == null) throw new ArgumentNullException("serviceCode");
            if (featureSet == null) throw new ArgumentNullException("featureSet");
            Contract.EndContractBlock();

            ServiceCode = serviceCode;
            FeatureSet = featureSet;
        }

 /// <summary>
 /// Creates a new instance of Selection
 /// </summary>
 public Selection(IFeatureSet fs, IDrawingFilter inFilter):base(fs, inFilter, FilterTypes.Selection)
 {
     Selected = true;
     UseSelection = true;
     UseCategory = false;
     UseVisibility = false;
     UseChunks = false;
     SelectionMode = SelectionModes.IntersectsExtent;
 }

 public LocalTrend(IFeatureSet shapeLayer, int idField, int order) :
     base(shapeLayer, idField)
 {
     this.method = "LocalTrend";
     this.order = order;
     if (order >= 1 || order <= 3)
     {
         serie = SerieCoef(order);
     }
 }

 private void Configure(IFeatureSet inFeatureSet)
 {
     if (inFeatureSet.FeatureType != FeatureType.Polygon)
     {
         throw new PolygonFeatureTypeException();
     }
     PolygonScheme ps = new PolygonScheme();
     ps.SetParentItem(this);
     Symbology = ps;
 }