AE属性表操作

于 2017-12-15 16:01:57 发布
阅读量1.4k 收藏 11
点赞数 1
分类专栏： AE

原文连接：http://blog.csdn.net/lysc_forever/article/details/17093405


实现的操作包括：1、打开属性表；2、编辑属性表；3、增加属性列；4、数据排序；5、字段计算……

嗯，实现的功能目前就这些吧，后续还会继续跟进，还望大家多多关注……下面就分功能说说我的实现方式吧……

1、打开属性表

属性表的打开是在TOC的右键菜单中打开的，首先新建一个类OpenAttribute，继承BaseCommand，OpenAttribute类的源码如下：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using ESRI.ArcGIS.ADF.BaseClasses;  
  5. using ESRI.ArcGIS.Controls;  
  6.   
  7. namespace MapDemo  
  8. {  
  9.     public sealed class OpenAttribute : BaseCommand  
  10.     {  
  11.         IMapControl3 m_mapControl;  
  12.         AxMapControl _MapControl;  
  13.   
  14.         public OpenAttribute(AxMapControl pMapControl)  
  15.         {  
  16.             base.m_caption = "查看属性表";  
  17.             _MapControl = pMapControl;  
  18.         }  
  19.   
  20.         public override void OnClick()  
  21.         {  
  22.             formTable formtable = new formTable(_MapControl, m_mapControl);  
  23.             formtable.Show();  
  24.   
  25.         }  
  26.   
  27.         public override void OnCreate(object hook)  
  28.         {  
  29.             m_mapControl = (IMapControl3)hook;  
  30.         }  
  31.     }  
  32. }  


解释一下，AxMapControl参数是为了后面属性表操作时刷新视图的。接着在toc右键事件中添加代码：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. //查看属性表  
  2.             m_menuLayer.AddItem(new OpenAttribute(mapMain), -1, 2, false, esriCommandStyles.esriCommandStyleIconAndText);  


如此这般，这般如此，我们期待的属性表就出现了，效果呢比较丑陋，莫怪莫怪……


属性表打开之后呢，大家就看到了有关属性表操作的一些功能了，不过呢，属性表的大开的工作还尚未完成。接下来呢，添加如下引用：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. using ESRI.ArcGIS.Carto;  
  2. using ESRI.ArcGIS.Controls;  
  3. using ESRI.ArcGIS.Geodatabase;  


完了之后，定义一下变量：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. AxMapControl _MapControl;  
  2.         IMapControl3 m_mapControl;  
  3.         public DataTable dt2;          
  4.         ITableSort pTs;//处理排序  
  5.         bool up = true;  
  6.         int row_index = 0;  
  7.         int col_index = 0;  
  8.         public string strAddField = "";  
  9.         RowAndCol[] pRowAndCol = new RowAndCol[10000];  
  10.         int count = 0;  


这个窗口的参数为：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. ublic formTable(AxMapControl pMapControl,IMapControl3 pMapCtrl)  
  2.         {  
  3.             InitializeComponent();  
  4.             _MapControl = pMapControl;  
  5.             m_mapControl = pMapCtrl;  
  6.         }  


这样，下面就可以显示属性了，在form_load事件中写如下代码：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. private void formTable_Load(object sender, EventArgs e)  
  2.         {  
  3.             TableShow();  
  4.         }  


此处，调用了TableShow方法，TableShow的代码如下：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public void TableShow()  
  2.         {  
  3.             ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  4.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  5.             IFeatureClass pFeatureClass = pFLayer.FeatureClass;  
  6.   
  7.             if (pFeatureClass == null) return;  
  8.   
  9.             DataTable dt = new DataTable();  
  10.             DataColumn dc = null;  
  11.   
  12.             for (int i = 0; i < pFeatureClass.Fields.FieldCount; i++)  
  13.             {  
  14.   
  15.                 dc = new DataColumn(pFeatureClass.Fields.get_Field(i).Name);  
  16.   
  17.                 dt.Columns.Add(dc);  
  18.   
  19.             }  
  20.   
  21.             IFeatureCursor pFeatureCuror = pFeatureClass.Search(null, false);  
  22.             IFeature pFeature = pFeatureCuror.NextFeature();  
  23.   
  24.             DataRow dr = null;  
  25.             while (pFeature != null)  
  26.             {  
  27.                 dr = dt.NewRow();  
  28.                 for (int j = 0; j < pFeatureClass.Fields.FieldCount; j++)  
  29.                 {  
  30.                     if (pFeatureClass.FindField(pFeatureClass.ShapeFieldName) == j)  
  31.                     {  
  32.   
  33.                         dr[j] = pFeatureClass.ShapeType.ToString();  
  34.                     }  
  35.                     else  
  36.                     {  
  37.                         dr[j] = pFeature.get_Value(j).ToString();  
  38.   
  39.                     }  
  40.                 }  
  41.   
  42.                 dt.Rows.Add(dr);  
  43.                 pFeature = pFeatureCuror.NextFeature();  
  44.             }  
  45.             gdvAttribute.DataSource = dt;  
  46.             dt2 = dt;  
  47.         }  


这样呢，属性表的显示就完成了。

2、新增字段

先看看那个“新增字段”按钮的事件吧……

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  2.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  3.             formAddField formaddfield = new formAddField(pFLayer, gdvAttribute);  
  4.             formaddfield.Show();  


此处，调用了窗体formAddField ，传递的参数是IFeatureLayer pFLayer 和DataGridView gdvAttribute，那么，下面看看formAddField的设计以及实现


界面呢也是比较简单，看看formAddField 的代码：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.ComponentModel;  
  4. using System.Data;  
  5. using System.Drawing;  
  6. using System.Linq;  
  7. using System.Text;  
  8. using System.Windows.Forms;  
  9.   
  10. using ESRI.ArcGIS.Carto;  
  11. using ESRI.ArcGIS.Geodatabase;  
  12. using ESRI.ArcGIS.Controls;  
  13.   
  14. namespace MapDemo  
  15. {  
  16.     public partial class formAddField : Form  
  17.     {  
  18.         private IFeatureLayer _FeatureLayer = null;  
  19.         private DataGridView _dgv;  
  20.         public formAddField(IFeatureLayer pFeatureLayer, DataGridView dgv)  
  21.         {  
  22.             InitializeComponent();  
  23.             _FeatureLayer = pFeatureLayer;  
  24.             _dgv = dgv;  
  25.         }  
  26.   
  27.         private void formAddField_Load(object sender, EventArgs e)  
  28.         {  
  29.             this.cmbFieldType.Items.Add("长整型");  
  30.             this.cmbFieldType.Items.Add("短整型");  
  31.             this.cmbFieldType.Items.Add("浮点型");  
  32.             this.cmbFieldType.Items.Add("双精度");  
  33.             this.cmbFieldType.Items.Add("文本型");  
  34.             this.cmbFieldType.Items.Add("日期型");  
  35.             this.cmbFieldType.SelectedIndex = 0;  
  36.         }  
  37.   
  38.         /// <summary>  
  39.         /// 改变事件  
  40.         /// </summary>  
  41.         /// <param name="sender"></param>  
  42.         /// <param name="e"></param>  
  43.         private void cmbFieldType_SelectedIndexChanged(object sender, EventArgs e)  
  44.         {  
  45.             string strFieldType = cmbFieldType.Text;  
  46.             switch (strFieldType)  
  47.             {  
  48.                 case "长整型":  
  49.                     {  
  50.                         panelPrecision.Visible = true;  
  51.                         panelScale.Visible = false;  
  52.                         break;  
  53.                     }  
  54.                 case "短整型":  
  55.                     {  
  56.                         panelPrecision.Visible = true;  
  57.                         panelScale.Visible = false;  
  58.                         break;  
  59.                     }  
  60.                 case "浮点型":  
  61.                     {  
  62.                         panelPrecision.Visible = true;  
  63.                         panelScale.Visible = true;  
  64.                         break;  
  65.                     }  
  66.                 case "双精度":  
  67.                     {  
  68.                         panelPrecision.Visible = true;  
  69.                         panelScale.Visible = true;  
  70.                         break;  
  71.                     }  
  72.                 case "文本型":  
  73.                     {  
  74.                         panelPrecision.Visible = true;  
  75.                         panelScale.Visible = false;  
  76.                         lblPrecision.Text = "长度";  
  77.                         break;  
  78.                     }  
  79.                 default://日期型0  
  80.                     {  
  81.                         panelPrecision.Visible = false;  
  82.                         panelScale.Visible = false;  
  83.                         break;  
  84.                     }  
  85.             }   
  86.         }  
  87.   
  88.         private void btnOK_Click(object sender, EventArgs e)  
  89.         {  
  90.             string strFieldName = txtFieldName.Text;  
  91.             string strFieldType = cmbFieldType.Text;  
  92.             try  
  93.             {  
  94.                 IFeatureLayer editAttributeLayer = _FeatureLayer;  
  95.   
  96.                 //Field collection  
  97.                 IFieldsEdit pFieldsEdit;  
  98.                 //获取FeatureLayer  
  99.                 IFeatureLayer pFeatureLayer = editAttributeLayer;  
  100.   
  101.                 //从FeatureLayer获取工作空间  
  102.                 IDataset pDataSet = pFeatureLayer.FeatureClass as IDataset;  
  103.                 IWorkspace pWorkSpace = pDataSet.Workspace;  
  104.                 //设置字段属性  
  105.                 IField pNewField = new FieldClass();  
  106.                 IFieldEdit pFieldEdit = pNewField as IFieldEdit;  
  107.                 pFieldEdit.AliasName_2 = strFieldName;  
  108.                 pFieldEdit.Name_2 = strFieldName;  
  109.                 switch (strFieldType)  
  110.                 {  
  111.                     case "长整型":  
  112.                     {  
  113.                         pFieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger;  
  114.                         pFieldEdit.Precision_2 = int.Parse(txtPrecision.Text);  
  115.                         break;  
  116.                     }  
  117.                     case "Class1.cs短整型":  
  118.                     {  
  119.                         pFieldEdit.Type_2 = esriFieldType.esriFieldTypeSmallInteger;  
  120.                         pFieldEdit.Precision_2 = int.Parse(txtPrecision.Text);  
  121.                         break;  
  122.                     }  
  123.                     case "浮点型":  
  124.                     {  
  125.                         pFieldEdit.Type_2 = esriFieldType.esriFieldTypeSingle;  
  126.                         pFieldEdit.Precision_2 = int.Parse(txtPrecision.Text);  
  127.                         pFieldEdit.Scale_2 = int.Parse(txtScale.Text);  
  128.                         break;  
  129.                     }  
  130.                     case "双精度":  
  131.                     {  
  132.                         pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDouble;  
  133.                         pFieldEdit.Precision_2 = int.Parse(txtPrecision.Text);  
  134.                         pFieldEdit.Scale_2 = int.Parse(txtScale.Text);  
  135.                         break;  
  136.                     }  
  137.                     case "文本型":  
  138.                     {  
  139.                         pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;  
  140.                         pFieldEdit.Length_2 = int.Parse(txtPrecision.Text);  
  141.                         break;  
  142.                     }  
  143.                     default://日期型0  
  144.                     {  
  145.                         pFieldEdit.Type_2 = esriFieldType.esriFieldTypeDate;  
  146.                         break;  
  147.                     }  
  148.                 }                 
  149.                 //添加字段  
  150.                 try  
  151.                 {  
  152.                     int theField = pFeatureLayer.FeatureClass.Fields.FindField(strFieldName);  
  153.                     if (theField == -1)  
  154.                     {  
  155.                         pFeatureLayer.FeatureClass.AddField(pFieldEdit);  
  156.                         MessageBox.Show("字段添加成功！");  
  157.                     }  
  158.                     else  
  159.                     {  
  160.                         MessageBox.Show("字段已经存在！");  
  161.                     }  
  162.                 }  
  163.                 catch (Exception ex)  
  164.                 {  
  165.                     MessageBox.Show("Field " + pFieldEdit.Name + " was not added due to an error (" + ex.Message + " )");  
  166.                 }  
  167.   
  168.             }  
  169.             catch (System.Exception ex)  
  170.             {  
  171.                 MessageBox.Show(ex.Message);  
  172.             }              
  173.             this.Close();  
  174.             RefreshTable refresh = new RefreshTable();  
  175.             refresh.Refresh(_dgv, _FeatureLayer);  
  176.         }  
  177.   
  178.         private void btnCancle_Click(object sender, EventArgs e)  
  179.         {  
  180.             this.Close();  
  181.         }          
  182.     }  
  183. }  


首先，在窗体加载的时候将数据类型添加进去，之后在类型选择改变时触发其属性控制控件的显示或者改变，接下来就是最重要的添加字段了，大家注意到了，在this.Close()之后，还调用了RefreshTable 的Refresh方法，传递的参数是datagridview _dgv和Ifeaturelayer _FeatureLayer,Refresh方法主要是实现添加自断后显示的刷新，由于后面还有涉及到，所以，这个后面一并说。

3、编辑属性并保存

还是先看看那两个按钮的时间吧：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /// <summary>  
  2.         /// 编辑属性，并定位到最后一行  
  3.         /// </summary>  
  4.         /// <param name="sender"></param>  
  5.         /// <param name="e"></param>  
  6.         private void toolEditor_Click(object sender, EventArgs e)  
  7.         {  
  8.             gdvAttribute.ReadOnly = false;  
  9.             this.gdvAttribute.CurrentCell = this.gdvAttribute.Rows[this.gdvAttribute.Rows.Count - 2].Cells[0];  
  10.         }  
  11.   
  12.  /// <summary>  
  13.         /// 保存编辑  
  14.         /// </summary>  
  15.         /// <param name="sender"></param>  
  16.         /// <param name="e"></param>  
  17.         private void toolSave_Click(object sender, EventArgs e)  
  18.         {  
  19.             gdvAttribute.ReadOnly = true;  
  20.             ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  21.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  22.             IFeatureClass pFeatureClass = pFLayer.FeatureClass;  
  23.             ITable pTable;  
  24.             //pTable = pFeatureClass.CreateFeature().Table;//很重要的一种获取shp表格的一种方式           
  25.             pTable = pFLayer as ITable;  
  26.             //将改变的记录值传给shp中的表  
  27.             int i = 0;  
  28.             while (pRowAndCol[i].Column != 0 || pRowAndCol[i].Row != 0)  
  29.             {  
  30.                 IRow pRow;  
  31.                 pRow = pTable.GetRow(pRowAndCol[i].Row);  
  32.                 pRow.set_Value(pRowAndCol[i].Column, pRowAndCol[i].Value);  
  33.                 pRow.Store();  
  34.                 i++;  
  35.             }  
  36.             count = 0;  
  37.             for (int j = 0; j < i; j++)  
  38.             {  
  39.                 pRowAndCol[j].Row = 0;  
  40.                 pRowAndCol[j].Column = 0;  
  41.                 pRowAndCol[j].Value = null;  
  42.             }  
  43.             MessageBox.Show("保存成功！", "提示", MessageBoxButtons.OK);  
  44.         }  


在保存属性表的时候，出现了pRowAndCol，对他的定义如下：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public struct RowAndCol  
  2.         {  
  3.             //字段  
  4.             private int row;  
  5.             private int column;  
  6.             private string _value;  
  7.   
  8.             //行属性  
  9.             public int Row  
  10.             {  
  11.                 get  
  12.                 {  
  13.                     return row;  
  14.                 }  
  15.                 set  
  16.                 {  
  17.                     row = value;  
  18.                 }  
  19.             }  
  20.             //列属性  
  21.             public int Column  
  22.             {  
  23.                 get  
  24.                 {  
  25.                     return column;  
  26.                 }  
  27.                 set  
  28.                 {  
  29.                     column = value;  
  30.                 }  
  31.             }  
  32.             //值属性  
  33.             public string Value  
  34.             {  
  35.                 get  
  36.                 {  
  37.                     return _value;  
  38.                 }  
  39.                 set  
  40.                 {  
  41.                     _value = value;  
  42.                 }  
  43.             }  
  44.         }  


4、删除选择

顾名思义，就是删除选择的行，这里的选择可以是多选，也可是单选，看看对应按钮的事件吧：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /// <summary>  
  2.         /// 删除行  
  3.         /// </summary>  
  4.         /// <param name="sender"></param>  
  5.         /// <param name="e"></param>  
  6.         private void toolDelSelect_Click(object sender, EventArgs e)  
  7.         {  
  8.             if (((MessageBox.Show("确定要删除吗", "警告", MessageBoxButtons.YesNo)) == DialogResult.Yes))  
  9.             {  
  10.                 ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  11.                 IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  12.                 ITable pTable = pFLayer as ITable;  
  13.                 IRow pRow = pTable.GetRow(row_index);  
  14.                 pRow.Delete();  
  15.                 TableShow();  
  16.                 MessageBox.Show("删除成功！", "提示", MessageBoxButtons.OK);  
  17.                 _MapControl.ActiveView.Refresh();  
  18.             }  
  19.         }  


此处，看看下面这个事件：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. private void gdvAttribute_CellValueChanged(object sender, DataGridViewCellEventArgs e)  
  2.         {  
  3.             //记录值一旦改变触发此事件  
  4.             //在dataGridView中获取改变记录的行数，列数和记录值  
  5.             pRowAndCol[count].Row = gdvAttribute.CurrentCell.RowIndex;  
  6.             pRowAndCol[count].Column = gdvAttribute.CurrentCell.ColumnIndex;  
  7.             pRowAndCol[count].Value = gdvAttribute.Rows[gdvAttribute.CurrentCell.RowIndex].Cells[gdvAttribute.CurrentCell.ColumnIndex].Value.ToString();  
  8.             count++;  
  9.         }  


5、导出Excel

首先得添加程序对Microsoft.Office.Interop.Excel的引用，添加完成之后方可导出：

 

[csharp]   view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /// <summary>  
  2.         /// 导出Excel  
  3.         /// </summary>  
  4.         /// <param name="sender"></param>  
  5.         /// <param name="e"></param>  
  6.         private void toolExpXLS_Click(object sender, EventArgs e)  
  7.         {  
  8.             ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  9.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  10.             IFeatureClass pFeatureClass = pFLayer.FeatureClass;  
  11.             IFields pFields = pFeatureClass.Fields;  
  12.             ExportExcel(gdvAttribute, pFields);  
  13.         }  
  14.   
  15.         private void ExportExcel(DataGridView myDGV, IFields pFields)  
  16.         {  
  17.             string saveFileName = "";  
  18.             SaveFileDialog saveDialog = new SaveFileDialog();  
  19.             saveDialog.DefaultExt = "xls";  
  20.             saveDialog.Filter = "Excel文件|*.xls";  
  21.             saveDialog.ShowDialog();  
  22.             saveFileName = saveDialog.FileName;  
  23.             if (saveFileName.IndexOf(":") < 0) return; //被点了取消   
  24.   
  25.             Microsoft.Office.Interop.Excel.Application xlApp = new Microsoft.Office.Interop.Excel.Application();  
  26.             if (xlApp == null)  
  27.             {  
  28.                 MessageBox.Show("无法创建Excel对象，可能您的机子未安装Excel");  
  29.                 return;  
  30.             }  
  31.   
  32.             Microsoft.Office.Interop.Excel.Workbooks workbooks = xlApp.Workbooks;  
  33.             Microsoft.Office.Interop.Excel.Workbook workbook = workbooks.Add(Microsoft.Office.Interop.Excel.XlWBATemplate.xlWBATWorksheet);  
  34.             Microsoft.Office.Interop.Excel.Worksheet worksheet = (Microsoft.Office.Interop.Excel.Worksheet)workbook.Worksheets[1];//取得sheet1  
  35.   
  36.             //写入标题  
  37.             for (int i = 0; i < myDGV.ColumnCount; i++)  
  38.             {  
  39.                 worksheet.Columns.Cells[1, i + 1] = myDGV.Columns[i].HeaderText;  
  40.             }  
  41.             //写入数值  
  42.             for (int r = 0; r < myDGV.Rows.Count; r++)  
  43.             {  
  44.                 for (int i = 0; i < myDGV.ColumnCount; i++)  
  45.                 {  
  46.                     worksheet.Cells[r + 2, i + 1] = myDGV.Rows[r].Cells[i].Value;  
  47.                 }  
  48.                 System.Windows.Forms.Application.DoEvents();  
  49.             }  
  50.   
  51.             worksheet.Columns.EntireColumn.AutoFit();//列宽自适应  
  52.   
  53.             if (saveFileName != "")  
  54.             {  
  55.                 try  
  56.                 {  
  57.                     workbook.Saved = true;  
  58.                     workbook.SaveCopyAs(saveFileName);  
  59.                 }  
  60.                 catch (Exception ex)  
  61.                 {  
  62.                     MessageBox.Show("导出文件时出错,文件可能正被打开！\n" + ex.Message);  
  63.                 }  
  64.                 xlApp.Quit();  
  65.                 GC.Collect();//强行销毁   
  66.                 MessageBox.Show("资料保存成功", "提示", MessageBoxButtons.OK);  
  67.             }  
  68.         }  





6、选中行高亮在地图中显示

[csharp]  view plain  copy
  1. /// <summary>  
  2.         /// 该行选中时高亮显示  
  3.         /// </summary>  
  4.         /// <param name="sender"></param>  
  5.         /// <param name="e"></param>  
  6.         private void gdvAttribute_RowHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)  
  7.         {  
  8.             IQueryFilter pQuery = new QueryFilterClass();  
  9.             int count = this.gdvAttribute.SelectedRows.Count;  
  10.             string val;  
  11.             string col;  
  12.             col = this.gdvAttribute.Columns[0].Name;  
  13.             //当只选中一行时  
  14.             if (count == 1)  
  15.             {  
  16.                 val = this.gdvAttribute.SelectedRows[0].Cells[col].Value.ToString();  
  17.                 //设置高亮要素的查询条件  
  18.                 pQuery.WhereClause = col + "=" + val;  
  19.             }  
  20.             else//当选中多行时  
  21.             {  
  22.                 int i;  
  23.                 string str;  
  24.                 for (i = 0; i < count - 1; i++)  
  25.                 {  
  26.                     val = this.gdvAttribute.SelectedRows[i].Cells[col].Value.ToString();  
  27.                     str = col + "=" + val + " OR ";  
  28.                     pQuery.WhereClause += str;  
  29.                 }  
  30.                 //添加最后一个要素的条件  
  31.                 val = this.gdvAttribute.SelectedRows[i].Cells[col].Value.ToString();  
  32.                 str = col + "=" + val;  
  33.                 pQuery.WhereClause += str;  
  34.             }  
  35.             ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  36.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  37.             IFeatureSelection pFeatSelection;  
  38.             pFeatSelection = pFLayer as IFeatureSelection;  
  39.             pFeatSelection.SelectFeatures(pQuery, esriSelectionResultEnum.esriSelectionResultNew, false);  
  40.             _MapControl.ActiveView.Refresh();  
  41.         }    

7、右键事件

右键事件里目前只实现了前四个：

首先是排序：

[csharp]  view plain  copy
  1. /// <summary>  
  2.         /// 数据排序  
  3.         /// </summary>  
  4.         /// <param name="pFeatureClass"></param>  
  5.         private void SortFeatures(IFeatureClass pFeatureClass)  
  6.         {  
  7.             ITableSort pTableSort = new TableSortClass();  
  8.             IFields pFields = pFeatureClass.Fields;  
  9.             IField pField = pFields.get_Field(col_index);  
  10.   
  11.             pTableSort.Fields = pField.Name;  
  12.   
  13.             if (up)  
  14.             {  
  15.                 pTableSort.set_Ascending(pField.Name, true);  
  16.             }  
  17.             else  
  18.             {  
  19.                 pTableSort.set_Ascending(pField.Name, false);  
  20.             }  
  21.             pTableSort.set_CaseSensitive(pField.Name, true);  
  22.             pTableSort.Table = pFeatureClass as ITable;  
  23.             pTableSort.Sort(null);  
  24.             ICursor pCursor = pTableSort.Rows;  
  25.             pTs = pTableSort;              
  26.             RefreshTable();  
  27.         }  
  28.   
  29.   
  30.         /// <summary>  
  31.         /// 正序  
  32.         /// </summary>  
  33.         /// <param name="sender"></param>  
  34.         /// <param name="e"></param>  
  35.         private void toolAsc_Click(object sender, EventArgs e)  
  36.         {  
  37.             ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  38.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  39.             up = true;  
  40.             SortFeatures(pFLayer.FeatureClass);  
  41.         }  
  42.   
  43.         /// <summary>  
  44.         /// 逆序  
  45.         /// </summary>  
  46.         /// <param name="sender"></param>  
  47.         /// <param name="e"></param>  
  48.         private void toolDesc_Click(object sender, EventArgs e)  
  49.         {  
  50.             ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  51.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  52.             up = false;  
  53.             SortFeatures(pFLayer.FeatureClass);  
  54.         }    

接下来就是删除字段：

[csharp]  view plain  copy
  1. /// <summary>  
  2.         /// 删除字段  
  3.         /// </summary>  
  4.         /// <param name="sender"></param>  
  5.         /// <param name="e"></param>  
  6.         private void toolDel_Click(object sender, EventArgs e)  
  7.         {  
  8.             int indexNum = gdvAttribute.CurrentCell.ColumnIndex;  
  9.             string strField = gdvAttribute.Columns[indexNum].HeaderText.ToString();  
  10.             ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  11.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  12.             string strResult = "";  
  13.             if ((MessageBox.Show("确定要删除该字段吗?", "提示", MessageBoxButtons.YesNo) == DialogResult.Yes))  
  14.             {  
  15.                 strResult = DeleteField(pFLayer, strField);  
  16.                 gdvAttribute.Columns.Remove(strField);  
  17.                 MessageBox.Show(strResult, "提示", MessageBoxButtons.OK);  
  18.             }                 
  19.         }  
  20.   
  21.         /// <summary>  
  22.         /// 删除属性表字段  
  23.         /// </summary>  
  24.         /// <param name="layer">需要添加字段的IFeatureLayer</param>  
  25.         /// <param name="fieldName">添加的字段的名称</param>  
  26.         /// <returns></returns>  
  27.         public string DeleteField(IFeatureLayer layer, string fieldName)  
  28.         {  
  29.             try  
  30.             {  
  31.                 ITable pTable = (ITable)layer;  
  32.                 IFields pfields;  
  33.                 IField pfield;  
  34.                 pfields = pTable.Fields;  
  35.                 int fieldIndex = pfields.FindField(fieldName);  
  36.                 pfield = pfields.get_Field(fieldIndex);  
  37.                 pTable.DeleteField(pfield);  
  38.                 return "删除成功!";  
  39.             }  
  40.             catch (Exception ex)  
  41.             {  
  42.                 return ex.Message;  
  43.             }  
  44.         }  

最后一个功能就是属性表计算：

[csharp]  view plain  copy
  1. /// <summary>  
  2.         /// 字段计算  
  3.         /// </summary>  
  4.         /// <param name="sender"></param>  
  5.         /// <param name="e"></param>  
  6.         private void toolFieldCalculator_Click(object sender, EventArgs e)  
  7.         {  
  8.             int indexNum = gdvAttribute.CurrentCell.ColumnIndex;  
  9.             string strField = gdvAttribute.Columns[indexNum].HeaderText.ToString();  
  10.             ILayer pLayer = (ILayer)m_mapControl.CustomProperty;  
  11.             IFeatureLayer pFLayer = pLayer as IFeatureLayer;  
  12.             formCalField formcalfield = new formCalField(pFLayer, gdvAttribute,strField);  
  13.             formcalfield.Show();  
  14.         }  

属性表计算调用了窗口formCalField ，调用参数为IFeatureLayer pFeatureLayer,DataGridView dataGridView,string strField，那么看看formCalField 是如何设计的吧：

[attach]165443[/attach]

很简单，一个listbox,一个txtbox用与输入表达式，还有一个txtbox用于显示计算信息，其代码为：

[csharp]  view plain  copy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Data;  
  4. using System.Linq;  
  5. using System.Windows.Forms;  
  6. using ESRI.ArcGIS.DataManagementTools;  
  7. using ESRI.ArcGIS.Geodatabase;  
  8. using ESRI.ArcGIS.Carto;  
  9. using ESRI.ArcGIS.Geoprocessor;  
  10.   
  11. namespace MapDemo  
  12. {  
  13.     public partial class formCalField : Form  
  14.     {  
  15.         private IFeatureLayer _FeatureLayer = null;  
  16.         private DataGridView Gridviwe;  
  17.         private string Field = "";  
  18.         public formCalField(IFeatureLayer pFeatureLayer,DataGridView dataGridView,string strField)  
  19.         {  
  20.             InitializeComponent();  
  21.             _FeatureLayer = pFeatureLayer;  
  22.             Field = strField;  
  23.             Gridviwe = dataGridView;  
  24.         }  
  25.   
  26.         /// <summary>  
  27.         /// 窗体加载  
  28.         /// </summary>  
  29.         /// <param name="sender"></param>  
  30.         /// <param name="e"></param>  
  31.         private void formCalField_Load(object sender, EventArgs e)  
  32.         {  
  33.             IFeatureClass pFeatureCls = _FeatureLayer.FeatureClass;  
  34.             int FieldCount = pFeatureCls.Fields.FieldCount;  
  35.             for (int i = 0; i < FieldCount; i++)  
  36.             {  
  37.                 IField pField = pFeatureCls.Fields.get_Field(i);  
  38.                 //去除shape字段  
  39.                 if (pField.Name == "shape")  
  40.                 {  
  41.                     continue;  
  42.                 }  
  43.                 listField.Items.Add("["+pField.Name+"]");  
  44.             }  
  45.             lblField.Text = Field+"=";  
  46.         }  
  47.   
  48.         /// <summary>  
  49.         /// 双击选择字段  
  50.         /// </summary>  
  51.         /// <param name="sender"></param>  
  52.         /// <param name="e"></param>  
  53.         private void listField_DoubleClick(object sender, EventArgs e)  
  54.         {  
  55.             string strSelectField = this.listField.SelectedItem.ToString();  
  56.             txtExpression.Text = strSelectField;  
  57.         }  
  58.   
  59.         /// <summary>  
  60.         /// 计算  
  61.         /// </summary>  
  62.         /// <param name="sender"></param>  
  63.         /// <param name="e"></param>  
  64.         private void btnCal_Click(object sender, EventArgs e)  
  65.         {  
  66.             string strResult = FieldCal(_FeatureLayer, Field, txtExpression.Text);  
  67.             MessageBox.Show(strResult);  
  68.             this.Close();  
  69.             RefreshTable refreshtable = new RefreshTable();  
  70.             refreshtable.Refresh(Gridviwe, _FeatureLayer);  
  71.         }  
  72.   
  73.         /// <summary>  
  74.         /// 取消  
  75.         /// </summary>  
  76.         /// <param name="sender"></param>  
  77.         /// <param name="e"></param>  
  78.         private void brnCancle_Click(object sender, EventArgs e)  
  79.         {  
  80.             this.Close();  
  81.         }  
  82.   
  83.         private string FieldCal(IFeatureLayer pFtLayer,string strField,string strExpression)  
  84.         {  
  85.             txtMessage.Text = "正在计算请稍后……\r\n";  
  86.             try  
  87.             {  
  88.                 Geoprocessor Gp = new Geoprocessor();  
  89.                 Gp.OverwriteOutput = true;  
  90.                 CalculateField calField = new CalculateField();  
  91.                 calField.in_table = pFtLayer as ITable;  
  92.                 calField.field = strField;  
  93.                 calField.expression = strExpression;  
  94.   
  95.                 Gp.Execute(calField, null);  
  96.                   
  97.                 for (int i = 0; i < Gp.MessageCount; i++)  
  98.                 {  
  99.                     txtMessage.Text += Gp.GetMessage(i).ToString() + "\r\n";  
  100.                 }  
  101.                 return "计算成功";  
  102.             }  
  103.             catch (Exception e)  
  104.             {  
  105.                 txtMessage.Text += e.Message;  
  106.                 return "计算失败"+e.Message;  
  107.             }              
  108.         }  
  109.     }  
  110. }  

字段计算我是通过调用Geopressor实现的。最后，粘出RefreshTable这个类的源代码：

[csharp]  view plain  copy
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Data;  
  4. using System.Linq;  
  5. using System.Windows.Forms;  
  6. using ESRI.ArcGIS.Geodatabase;  
  7. using ESRI.ArcGIS.Carto;  
  8.   
  9. namespace MapDemo  
  10. {  
  11.     public class RefreshTable  
  12.     {  
  13.         //刷新属性表  
  14.         public void Refresh(DataGridView dataGridView, IFeatureLayer pFeatureLayer)  
  15.         {  
  16.             IFeatureLayer pFLayer = pFeatureLayer;  
  17.             IFeatureClass pFeatureClass = pFLayer.FeatureClass;  
  18.   
  19.             if (pFeatureClass == null) return;  
  20.   
  21.             DataTable dt = new DataTable();  
  22.             DataColumn dc = null;  
  23.   
  24.             for (int i = 0; i < pFeatureClass.Fields.FieldCount; i++)  
  25.             {  
  26.   
  27.                 dc = new DataColumn(pFeatureClass.Fields.get_Field(i).Name);  
  28.   
  29.                 dt.Columns.Add(dc);  
  30.   
  31.             }  
  32.   
  33.             IFeatureCursor pFeatureCuror = pFeatureClass.Search(null, false);  
  34.             IFeature pFeature = pFeatureCuror.NextFeature();  
  35.   
  36.             DataRow dr = null;  
  37.             while (pFeature != null)  
  38.             {  
  39.                 dr = dt.NewRow();  
  40.                 for (int j = 0; j < pFeatureClass.Fields.FieldCount; j++)  
  41.                 {  
  42.                     if (pFeatureClass.FindField(pFeatureClass.ShapeFieldName) == j)  
  43.                     {  
  44.   
  45.                         dr[j] = pFeatureClass.ShapeType.ToString();  
  46.                     }  
  47.                     else  
  48.                     {  
  49.                         dr[j] = pFeature.get_Value(j).ToString();  
  50.   
  51.                     }  
  52.                 }  
  53.   
  54.                 dt.Rows.Add(dr);  
  55.                 pFeature = pFeatureCuror.NextFeature();  
  56.             }  
  57.             dataGridView.DataSource = dt;  
  58.         }  
  59.     }  
  60. }  

 

杨千羽
关注
专栏目录
ae实现点击图层弹出属性表
12-25
代码实现了双击图层弹出属性表。代码是建立在arcgis engine的C#语言基础上实现的。
#AE实现矢量数据的基本操作—属性表操作（IFeatureClass）
Zzzpiu的博客
08-31 1367
#AE实现矢量数据的基本操作—属性表操作(IFeatureClass) 实现：字段添加、字段删除、字段查找、读取属性值： 1.字段添加： 首先查看IFeatureClass接口，其中有AddField方法可以添加字段。 而IFeatureLayer中存在FeatureClass属性直接获得IFeatureClass接口，使用AddField方法就可以添加字段。 但是AddField方法中需要一个I...
IFeature IFeatureClass IFeatureDataset等接口的介绍
CA431的博客
08-12 5113
IFeature IFeatureClass IFeatureDataset等接口的介绍 摘自帮助文档   IFeature Interface Feature指的是空间对象，它包含在一个feature class中，就如一行数据包含在一张表中，一个对象包含在一个对象类中一样。一个feature包含一个与之相关联的shape，其类型背定义在了feature class中。Shape对象
AE属性表操作(1)
热门推荐
lysc_forever的专栏
12-03 1万+
今天给大家分享一个AE属性表操作的程序源码，希望对有需要的筒子一定的帮助，小弟倍感荣幸！ 好了，废话少说！首先说说实现了哪些操作吧…… 实现的操作包括：1、打开属性表；2、编辑属性表；3、增加属性列；4、数据排序；5、字段计算…… 嗯，实现的功能目前就这些吧，后续还会继续跟进，还望大家多多关注……下面就分功能说说我的实现方式吧…… 1、打开属性表 属性表的打开是在TO
AE栅格表面分析
05-06
综合上述信息，"AE栅格表面分析"可能是指利用特定的软件工具对栅格数据进行的一系列地理空间分析操作，包括但不限于挖填方、方位角计算、观察点设定、单位转换以及坡度分析等。通过对这些知识点的理解和实践，用户...
查看shapefile图层的属性表
01-09
在GIS（地理信息系统）开发中，查看shapefile图层的属性表是一项常见的操作。这个过程通常涉及编程技术，如Visual Studio 2010（VS2010）、ArcObjects（AE）和C#，这些都是构建GIS应用程序的关键工具。本文将深入...
C# AE属性编辑
03-29
在IT领域，C# AE属性编辑是一个专门针对Esri的ArcEngine进行数据处理的应用程序开发技术。ArcEngine是Esri公司提供的一个强大的GIS（地理信息系统）开发平台，它允许开发者利用C#等编程语言创建定制化的GIS解决方案...
C#+AE 对栅格数据的操作
04-12
栅格数据是一种二维阵列，由许多小的单元格（或像素）组成，每个单元格代表特定的空间位置和相应的属性值。在地理信息系统中，栅格常被用来表示地形、卫星图像、气候模型等空间信息。 ArcEngine是Esri公司提供的一...
AE属性表操作(2)
lysc_forever的专栏
12-03 5023
转自：http://bbs.esrichina-bj.cn/ESRI/viewthread.php?tid=129398 6、选中行高亮在地图中显示 /// /// 该行选中时高亮显示 /// /// /// private void gdvAttribute_RowHeaderMouseClick
栅格数据导出属性表 arcpy
07-07
适用于初学者，arcpy 批量栅格数据导出
点选查询，并且输出属性表
12-27
地图的点选查询，并且有属性表输出，选择自己的地图，
AE 学习小结-toccontrol右键菜单打开图层属性表
06-16
AE 学习小结-在toccontrol中右键菜单打开图层属性表，查看图层属性
ArcEngine 属性表操作
04-01
C# + ArcEngine实现的属性表读取、排序等操作。
属性数据表的查询显示
睥睨永恒
08-01 3921
在ArcMap中，单击图层右键菜单中的“Open Attribute Table”命令，便可弹出属性数据表。本讲将完成类似的功能，效果如下： 图1数据表显示，我们用了DataGridView控件。DataGridView 控件提供一种强大而灵活的以表格形式显示数据的方式。可以使用 DataGridView 控件来显示少量数据的只读视图，也可以对其进行缩放以显示特大数据集的可编辑视图。我
AE实现点击一个要素，并显示其属性
a13792584878的博客
09-05 1775
第一步：根据鼠标点击处的点，找到被选中的要素 1 public IFeature Find2(IPoint pPoint) 2 { 3 ITopologicalOperator pTopoOpe = pPoint as ITopologicalOperator; 4 double dis = m_pM...
用AE实现点击查看属性
rfk1988的专栏
11-03 2346
关于ARCGIS中IDENTIFY功能的实现 一：功能实现的基本思路是这样的： 1. 点击时，先获取点击位置的屏幕坐标，然后转换到地图坐标； 2. 定义一个图层对象（Identify），调用相应的Identify方法生成点对象； 3. 提取图层中点击处的图形，提取属性，填充到事先设计好的窗口中； 4. 显示窗口。   二：代码 IIdentify pIdentify;    //I
AE图层属性查看：toccontrol右键菜单实现
本文主要介绍了如何在Adobe After Effects（AE）中通过TOCControl的右键菜单来访问和查看图层属性表。在AE中，图层属性是控制动画效果和视觉元素的关键因素，理解并熟练操作图层属性对于创建复杂的动态设计至关重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值