private void moveFeature(int x, int y)
{
IFeatureLayer curLayer = getEditLayer.isExistLayer(m_MapControl.Map) as IFeatureLayer;
IWorkspaceEdit iWE = (curLayer.FeatureClass as IDataset).Workspace as IWorkspaceEdit;
if (!iWE.IsBeingEdited())
{
iWE.StartEditing(false);
}
IFeatureSelection curLayerSn = curLayer as IFeatureSelection;
ISelectionSet pSS = curLayerSn.SelectionSet;
if (pSS.Count != 1)
{
return;
}
ISelectionSet iSS = (curLayer as IFeatureSelection).SelectionSet;
ICursor iCursor;
iSS.Search(null, false, out iCursor);
IFeatureCursor iFC = iCursor as IFeatureCursor;
IFeature tmpFeature = iFC.NextFeature();
IPoint pPnt = m_MapControl.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(x, y);
IGeometry pGeometry = tmpFeature.ShapeCopy;
if (pGeometry.GeometryType == esriGeometryType.esriGeometryPoint)
{
pGeometry = pPnt;
}
else if (pGeometry.GeometryType == esriGeometryType.esriGeometryPolyline || pGeometry.GeometryType == esriGeometryType.esriGeometryPolygon)
{
double offX = 0, offY = 0;
offX = pGeometry.Envelope.XMin + pGeometry.Envelope.Width / 2 - pPnt.X;
offY = pGeometry.Envelope.YMin + pGeometry.Envelope.Height / 2 - pPnt.Y;
ITransform2D iT2D = pGeometry as ITransform2D;
iT2D.Move(-offX, -offY);
}
iWE.StartEditOperation();
tmpFeature.Shape = pGeometry;
tmpFeature.Store();
iWE.StopEditOperation();
//iWE.StopEditing(true);
iWE = null;
curLayerSn.Clear();
curLayerSn.Add(tmpFeature);
m_MapControl.ActiveView.Refresh();
}
/// <summary>
/// 对村落、POI实体进行编码
/// </summary>
/// <param name="pFeatureLayer">需要编码的图层</param>
/// <param name="pENTIID">需要编码的字段名称</param>
private static void CreatePOICode(IFeatureLayer pFeatureLayer, string pENTIID)
{
#region 针对GUID编码来讲
int i = 0;
//遍历Feature
IDataset pDataset = pFeatureLayer.FeatureClass as IDataset;
IWorkspaceEdit pWorkspaceEdit = null;
if (pDataset != null)
{
pWorkspaceEdit = pDataset.Workspace as IWorkspaceEdit;
if (pWorkspaceEdit != null || pWorkspaceEdit.IsBeingEdited() == false)
{
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
}
IFeatureCursor pFeatureCursor = pFeatureLayer.Search(null, false);
//test
int test = pFeatureLayer.FeatureClass.FeatureCount(null);
IFeature pFeature = pFeatureCursor.NextFeature();
while (pFeature != null)
{
string pResult = null;
//获取单条Feature的某个字段值
//int test2 = pFeature.Fields.FindFieldByAliasName(pENTIID);
while (i < 10000000)
{
i++;
break;
}
for (int k = 0; k < 7 - i.ToString().Length; k++)
{
pResult += "0";
}
//string pEntiid = pPoiOneTwo + ReturnNumberCharacter(i);
string pEntiid = pPoiOneTwo + pResult + i.ToString();
pFeature.set_Value(pFeature.Fields.FindField(pENTIID), pEntiid);
pFeature.Store();
pFeature = pFeatureCursor.NextFeature();
}
pWorkspaceEdit.StopEditing(true);
pWorkspaceEdit.StopEditOperation();
}
#endregion
}
//将线添加到图层
private void AddFeature(IGeometry geometry)
{
string pLineFile = txtLineFilePath.Text;
string pFilePath = System.IO.Path.GetDirectoryName(pLineFile);
string pFileName = System.IO.Path.GetFileName(pLineFile);
//打开工作空间
IWorkspaceFactory pWSF = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace pWS = (IFeatureWorkspace)pWSF.OpenFromFile(pFilePath, 0);
//写入实体对象
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.FeatureClass = pWS.OpenFeatureClass(pFileName);
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IDataset pDataset = (IDataset)pFeatureClass;
IWorkspace pWorkspace = pDataset.Workspace;
//开始空间编辑
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pWorkspace;
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
IFeatureBuffer pFeatureBuffer = pFeatureClass.CreateFeatureBuffer();
IFeatureCursor pFeatureCursor;
////清除图层原有实体对象
//pFeatureCursor = pFeatureClass.Update(null, true);
//IFeature pFeature;
//pFeature = pFeatureCursor.NextFeature();
//while (pFeature != null)
//{
// pFeatureCursor.DeleteFeature();
// pFeature = pFeatureCursor.NextFeature();
//}
//开始插入新的实体对象
pFeatureCursor = pFeatureClass.Insert(true);
pFeatureBuffer.Shape = geometry;
object featureOID = pFeatureCursor.InsertFeature(pFeatureBuffer);
//保存实体
pFeatureCursor.Flush();
//结束空间编辑
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor);
}
private void CreateFeature(IGeometry pGeom)
{
if (pGeom == null)
{
return;
}
if (m_pCurrentLayer == null)
{
return;
}
// Create the feature
IWorkspaceEdit pWorkspaceEdit = GetWorkspaceEdit();
IFeatureLayer pFeatureLayer = (IFeatureLayer)m_pCurrentLayer;
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
pWorkspaceEdit.StartEditOperation();
//Envelope to Polygon
IEnvelope pEnv = pGeom as IEnvelope;
IPointCollection pPtColl;
pPtColl = new PolygonClass();
object missing = Type.Missing;
pPtColl.AddPoint(pEnv.LowerLeft, ref missing, ref missing);
pPtColl.AddPoint(pEnv.UpperLeft, ref missing, ref missing);
pPtColl.AddPoint(pEnv.UpperRight, ref missing, ref missing);
pPtColl.AddPoint(pEnv.LowerRight, ref missing, ref missing);
//Close the polygon
pPtColl.AddPoint(pEnv.LowerLeft, ref missing, ref missing);
IFeature pFeature = pFeatureClass.CreateFeature();
try
{
pFeature.Shape = pPtColl as IGeometry;
}
catch (Exception ex)
{
MessageBox.Show("创建要素", ex.Message);
}
pFeature.Store();
pWorkspaceEdit.StopEditOperation();
m_ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, m_pCurrentLayer, pGeom.Envelope);
}
//添加实体对象到地图图层
private void addFeature(string layerName, IGeometry geometry)
{
int i = 0;
ILayer layer = null;
for (i = 0; i < axMapControl1.LayerCount; i++)
{
layer = axMapControl1.Map.get_Layer(i);
if (layer.Name.ToLower() == layerName)
{
break;
}
}
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureClass featureClass = featureLayer.FeatureClass;
IDataset dataset = (IDataset)featureClass;
IWorkspace workspace = dataset.Workspace;
//开始空间编辑
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)workspace;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
IFeatureBuffer featureBuffer = featureClass.CreateFeatureBuffer();
IFeatureCursor featureCursor;
//清除图层原有实体对象
featureCursor = featureClass.Update(null, true);
IFeature feature;
feature = featureCursor.NextFeature();
while (feature != null)
{
featureCursor.DeleteFeature();
feature = featureCursor.NextFeature();
}
//开始插入新的实体对象
featureCursor = featureClass.Insert(true);
featureBuffer.Shape = geometry;
object featureOID = featureCursor.InsertFeature(featureBuffer);
//保存实体
featureCursor.Flush();
//结束空间编辑
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
System.Runtime.InteropServices.Marshal.ReleaseComObject(featureCursor);
}
public override void OnMouseDown(int int_2, int int_3, int int_4, int int_5)
{
if (int_2 == 1)
{
IPoint mapPoint = _context.ActiveView.ScreenDisplay.DisplayTransformation.ToMapPoint(int_4, int_5);
double mapUnits = Common.ConvertPixelsToMapUnits((IActiveView)_context.FocusMap,
_context.Config.EngineSnapEnvironment.SnapTolerance);
IFeature hitLineFeature = Yutai.ArcGIS.Common.Editor.Editor.GetHitLineFeature(_context.FocusMap,
mapPoint, mapUnits);
if (hitLineFeature != null)
{
double num = 0;
bool flag = false;
int num1 = -1;
int num2 = -1;
IPoint pointClass = new ESRI.ArcGIS.Geometry.Point();
IHitTest shapeCopy = hitLineFeature.ShapeCopy as IHitTest;
shapeCopy.HitTest(mapPoint, mapUnits, esriGeometryHitPartType.esriGeometryPartBoundary, pointClass,
ref num, ref num1, ref num2, ref flag);
if (this.ifeature_0 != null)
{
IWorkspaceEdit workspace = (hitLineFeature.Class as IDataset).Workspace as IWorkspaceEdit;
workspace.StartEditOperation();
bool flag1 = Yutai.ArcGIS.Common.Editor.Editor.ConstructJunction(_context.FocusMap,
this.ifeature_0, this.ipoint_0, this.int_0, this.int_1, hitLineFeature, pointClass, num1,
num2);
workspace.StopEditOperation();
if (!flag1)
{
MessageBox.Show("两条线无法计算交点，线段可能不相交或交点在该图层坐标范围以外！");
}
else
{
_context.ActiveView.Refresh();
}
this.ifeature_0 = null;
}
else
{
this.ifeature_0 = hitLineFeature;
this.int_0 = num1;
this.int_1 = num2;
this.ipoint_0 = pointClass;
}
}
}
}
public bool AddTemplate(IObjectTemplate template)
{
try
{
IObjectTemplate objectTemplate = _templates.FirstOrDefault(c => c.Name == template.Name);
if (objectTemplate == null)
{
MessageService.Current.Warn("该模板已经存在，请更换名字!");
return(false);
}
if (_workspace == null)
{
Connect();
}
ITable pTable = _workspace.OpenTable("YT_TEMPLATE_FEATURECLASS");
IWorkspaceEdit pWksEdit = _workspace as IWorkspaceEdit;
pWksEdit.StartEditing(true);
pWksEdit.StartEditOperation();
IRow pRow = pTable.CreateRow();
template.UpdateRow(pRow);
//pTable = _workspace.OpenTable("YT_TEMPLATE_FIELD");
//int tmpIndex = pTable.FindField("TemplateName");
//foreach (IYTField ytField in template.Fields)
//{
// pRow = pTable.CreateRow();
// pRow.set_Value(tmpIndex,template.Name);
// ytField.UpdateRow(pRow);
//}
pWksEdit.StopEditOperation();
pWksEdit.StopEditing(true);
_templates.Add(template);
ComReleaser.ReleaseCOMObject(pTable);
DisConnect();
return(true);
}
catch (Exception ex)
{
MessageService.Current.Warn("系统发生错误:" + ex.Message);
return(false);
throw;
}
}
public bool SaveDataset(IObjectDataset dataset)
{
try
{
if (_workspace == null)
{
Connect();
}
if (_datasets == null)
{
_datasets = new List <IObjectDataset>();
}
ITable pTable = _workspace.OpenTable("YT_TEMPLATE_DATASET");
IWorkspaceEdit pWksEdit = _workspace as IWorkspaceEdit;
pWksEdit.StartEditing(true);
pWksEdit.StartEditOperation();
IRow pRow;
int oldID = dataset.ID;
if (oldID > 0)
{
pRow = pTable.GetRow(dataset.ID);
}
else
{
pRow = pTable.CreateRow();
}
dataset.UpdateRow(pRow);
pWksEdit.StopEditOperation();
pWksEdit.StopEditing(true);
if (oldID <= 0)
{
_datasets.Add(dataset);
}
ComReleaser.ReleaseCOMObject(pTable);
DisConnect();
return(true);
}
catch (Exception ex)
{
MessageService.Current.Warn("系统发生错误:" + ex.Message);
return(false);
throw;
}
}
//向图层中添加要素
private bool Edit(ILayer m_pCurrentLayer, int index)
{
try
{
IFeatureLayer pFeatureLayer = (IFeatureLayer)m_pCurrentLayer;
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IDataset pDataset = (IDataset)pFeatureClass;
if (pDataset == null)
{
throw new ArgumentNullException("数据集为空。");
}
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pDataset.Workspace;
pWorkspaceEdit.StartEditOperation();
IFeature pFeature = pFeatureClass.CreateFeature();
IGeometry pGeometry = axMapControl1.TrackPolygon();
ISimpleLineSymbol pSimpleLineSymbol = new SimpleLineSymbol
{
Color = RGB2IRgb(Color.Black),
Style = esriSimpleLineStyle.esriSLSSolid
};
ISimpleFillSymbol pSimpleFillSymbol = new SimpleFillSymbol
{
Color = ROIColors[index],
};
IFillShapeElement pFillElement = new PolygonElementClass
{
Symbol = pSimpleFillSymbol
};
IElement pElement;
pElement = pFillElement as IElement;
pElement.Geometry = pGeometry;
pFeature.Shape = pGeometry;
pFeature.Store();
pWorkspaceEdit.StopEditOperation();
ROIFeatureCount[index]++;
RefreshCount();
m_mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, m_pCurrentLayer, pGeometry.Envelope);
return(true);
}
catch (Exception err)
{
MessageBox.Show(err.ToString());
return(false);
}
}
//将线添加到图层
private void AddFeatureVector(IGeometry geometry, string strFieldSun, double dSunValue, string strType, string strValue)
{
string pLineFile = txtOutFile.Text;
string pFilePath = System.IO.Path.GetDirectoryName(pLineFile);
string pFileName = System.IO.Path.GetFileName(pLineFile);
//打开工作空间
IWorkspaceFactory pWSF = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace pWS = (IFeatureWorkspace)pWSF.OpenFromFile(pFilePath, 0);
//写入实体对象
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.FeatureClass = pWS.OpenFeatureClass(pFileName);
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IDataset pDataset = (IDataset)pFeatureClass;
IWorkspace pWorkspace = pDataset.Workspace;
//开始空间编辑
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pWorkspace;
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
IFeatureBuffer pFeatureBuffer = pFeatureClass.CreateFeatureBuffer();
IFeatureCursor pFeatureCursor;
//开始插入新的实体对象
pFeatureCursor = pFeatureClass.Insert(true);
pFeatureBuffer.Shape = geometry;
//写入太阳矢量值
pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField(strFieldSun), dSunValue);
pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField(strType), strValue);
////写入地球矢量值
//pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField(strFieldEar), dEarValue);
//pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField(strType), strFieldEar);
object featureOID = pFeatureCursor.InsertFeature(pFeatureBuffer);
//保存实体
pFeatureCursor.Flush();
//结束空间编辑
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor);
}
/// <summary>
/// 点云转图层
/// </summary>
/// <param name="path">保存路径</param>
/// <param name="sr">参考系</param>
/// <param name="pc">三维点云</param>
/// <returns>图层要素</returns>
public static IFeatureClass CreatePointCloudFeature(string path, ISpatialReference sr, List <Point3D> pc)
{
string folder = System.IO.Path.GetDirectoryName(path);
//先将点云转换成点图层
IFeatureClass fc = (CreateFeatureLayer(folder + "\\PointCloud.shp", sr, new string[] { "x", "y", "z" }, new string[] { "D", "D", "D" }, "P")).FeatureClass;
IWorkspaceEdit wsEdit = GetEdit(folder);
wsEdit.StartEditing(false);
wsEdit.StartEditOperation();
foreach (Point3D point in pc)
{
AddFeature(fc, new Point3D[] { point }, new object[] { point.x, point.y, point.z });
}
wsEdit.StopEditing(true);
wsEdit.StopEditOperation();
return(fc);
}
/// <summary>
/// Stop Editing operation
/// </summary>
/// <param name="ipWorkspace">IWorkspace</param>
/// <returns>True if successful, false otherwise</returns>
public static bool StopEditOperation(IWorkspace ipWorkspace)
{
bool blnWasSuccessful = false;
IWorkspaceEdit ipWsEdit = ipWorkspace as IWorkspaceEdit;
try
{
ipWsEdit.StopEditOperation();
blnWasSuccessful = true;
}
catch (Exception ex)
{
ipWsEdit.AbortEditOperation();
}
return(blnWasSuccessful);
}
public string GenerateTempProfileLinesStorage()
{
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)calcWorkspace;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
string newFeatureClassName = $"{calcFeatureClass}{MilSpace.DataAccess.Helper.GetTemporaryNameSuffix()}";
IWorkspace2 wsp2 = (IWorkspace2)calcWorkspace;
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)calcWorkspace;
if (!wsp2.get_NameExists(esriDatasetType.esriDTFeatureClass, newFeatureClassName))
{
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;
IFields fields = ocDescription.RequiredFields;
// Find the shape field in the required fields and modify its GeometryDef to
// use point geometry and to set the spatial reference.
int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName);
IField field = fields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = field.GeometryDef;
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolyline;
geometryDefEdit.SpatialReference_2 = ArcMapInstance.Document.FocusMap.SpatialReference;;
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
IField nameField = new FieldClass();
IFieldEdit nameFieldEdit = (IFieldEdit)nameField;
nameFieldEdit.Name_2 = "ID";
nameFieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger;
fieldsEdit.AddField(nameField);
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass(newFeatureClassName, fields,
ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, "shape", "");
}
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
return(newFeatureClassName);
}
/// <summary>
/// 开始编辑
/// </summary>
/// <param name="player"></param>
public static void StartEditing(ILayer player, string strOperator)
{
// 开始编辑前检查编辑状态
m_strOperator = strOperator;
m_CurrentLayer = player;
if (m_CurrentLayer == null)
{
return;
}
if ((IGeoFeatureLayer)m_CurrentLayer == null)
{
return;
}
IFeatureLayer pFeatureLayer = (IFeatureLayer)m_CurrentLayer;
IDataset pDataset = (IDataset)pFeatureLayer.FeatureClass;
if (pDataset == null)
{
return;
}
// Start editing, making sure that undo/redo are enabled
pWorkspaceEdit = (IWorkspaceEdit)pDataset.Workspace;
if (!pWorkspaceEdit.IsBeingEdited())
{
try
{
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
pWorkspaceEdit.EnableUndoRedo();
}
catch
{
if (pWorkspaceEdit.IsBeingEdited())
{
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
pWorkspaceEdit.EnableUndoRedo();
}
}
}
}
/// <summary>
///添加点图层
/// </summary>
/// <param name="axMap"></param>
/// <param name="longtitude"></param>
/// <param name="latitude"></param>
/// <param name="fieldsMap"></param>
public static IFeature addPointInLayer(AxMapControl axMap, String layerName, double longtitude, double latitude)
{
ILayer layer = getLayerByName(axMap.Map, layerName);
//将ILayer转换为IFeaturelayer，为了对图层上的要素进行编辑
IFeatureLayer featureLayer = layer as IFeatureLayer;
//定义一个要素集合，并获取图层的要素集合
IFeatureClass featureClass = featureLayer.FeatureClass;
//定义一个实现新增要素的接口实例，并该实例作用于当前图层的要素集
IFeatureClassWrite writer = (IFeatureClassWrite)featureClass;
//定义一个工作编辑工作空间，用于开启前图层的编辑状态
IWorkspaceEdit edit = (featureClass as IDataset).Workspace as IWorkspaceEdit;
//定义一个IFeature实例，用于添加到当前图层上
IFeature feature;
//开启编辑状态
edit.StartEditing(true);
//开启编辑操作
edit.StartEditOperation();
//定义一个点，用来作为IFeature实例的形状属性，即shape属性
IPoint point;
//下面是设置点的坐标和参考系
point = new PointClass();
point.SpatialReference = axMap.SpatialReference;
point.X = longtitude;
point.Y = latitude;
//将IPoint设置为IFeature的shape属性时，需要通过中间接口IGeometry转换
IGeometry geometry = point;
//实例化IFeature对象， 这样IFeature对象就具有当前图层上要素的字段信息
feature = featureClass.CreateFeature();
//设置IFeature对象的形状属性
feature.Shape = geometry;
feature.Store(); //保存IFeature对象
writer.WriteFeature(feature); //将IFeature对象，添加到当前图层上
edit.StopEditOperation(); //停止编辑操作
edit.StopEditing(true); //关闭编辑状态，并保存修改
axMap.Refresh(); //刷新地图
return(feature);
}
private IFeatureClass CreateFeatureClass(string tableName, esriGeometryType type, List <FieldMapping> fieldMappings)
{
IWorkspaceEdit pWorkspaceEdit = _targetWorkspace as IWorkspaceEdit;
if (pWorkspaceEdit == null)
{
return(null);
}
if (pWorkspaceEdit.IsBeingEdited())
{
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
}
IFeatureClass pFeatureClass = WorkspaceHelper.CreateFeatureClass(_targetWorkspace, tableName, type, _spatialReference);
FeatureClassUtil.AddZ(pFeatureClass);
FeatureClassUtil.AddM(pFeatureClass);
foreach (FieldMapping fieldMapping in fieldMappings)
{
switch (fieldMapping.Type)
{
case esriFieldType.esriFieldTypeInteger:
FeatureClassUtil.AddIntField(pFeatureClass, fieldMapping.Name, fieldMapping.Length, null, fieldMapping.AliasName);
break;
case esriFieldType.esriFieldTypeDouble:
FeatureClassUtil.AddDoubleField(pFeatureClass, fieldMapping.Name, fieldMapping.Length, fieldMapping.Precision, null, fieldMapping.AliasName);
break;
case esriFieldType.esriFieldTypeString:
FeatureClassUtil.AddStringField(pFeatureClass, fieldMapping.Name, fieldMapping.Length, null, fieldMapping.AliasName);
break;
case esriFieldType.esriFieldTypeDate:
FeatureClassUtil.AddDateField(pFeatureClass, fieldMapping.Name, fieldMapping.AliasName);
break;
default:
break;
}
fieldMapping.IndexTargetField = pFeatureClass.FindField(fieldMapping.Name);
}
return(pFeatureClass);
}
protected override void OnClick()
{
//time before running/
DateTime fDate = DateTime.Now;
int features = 1000000;
IMxDocument pmxdoc = ArcMap.Application.Document as IMxDocument;
IFeatureLayer pflayer = pmxdoc.FocusMap.Layer[0] as IFeatureLayer;
IDataset pDs = pflayer.FeatureClass as IDataset;
IWorkspaceEdit pWorkspace = pDs.Workspace as IWorkspaceEdit;
pWorkspace.StartEditing(false);
pWorkspace.StartEditOperation();
IFeatureBuffer pBuffer = pflayer.FeatureClass.CreateFeatureBuffer();
IFeatureCursor pFcursor = pflayer.FeatureClass.Insert(true);
Random r = new Random();
for (int i = 0; i < features; i++)
{
//-12,232,313.174 7,222,833.142
IPoint pPoint = new Point();
pPoint.X = -12232313.174 + r.NextDouble() * 20000;
pPoint.Y = 7222833.142 + r.NextDouble() * 20000;
pBuffer.Shape = pPoint;
pBuffer.Value[pBuffer.Fields.FindField("NAME")] = "myfeature" + i.ToString();
pFcursor.InsertFeature(pBuffer);
if (i % 1000 == 0)
{
pFcursor.Flush();
}
}
pFcursor.Flush();
pWorkspace.StopEditOperation();
pWorkspace.StopEditing(true);
//time after completing
double timeinseconds = (DateTime.Now - fDate).TotalSeconds;
MessageBox.Show("Time to create " + features + ": " + timeinseconds + " seconds");
pmxdoc.ActiveView.Refresh();
}
protected override void OnMouseDown(MouseEventArgs arg)
{
IMxDocument pMxdoc = ArcMap.Application.Document as IMxDocument;
IRubberBand pRubber = new RubberLine();
IPolyline pPolyline;// pRubber.TrackNew(pMxdoc.ActiveView.ScreenDisplay, null) as IPolyline;
IPoint pPoint1 = new Point();
pPoint1.X = -2140489.683;
pPoint1.Y = 33264366.694;
IPoint pPoint2 = new Point();
pPoint2.X = 19727215.727;
pPoint2.Y = 27942068.023;
IPoint pPoint3 = new Point();
pPoint3.X = 30400767.253;
pPoint3.Y = 14570156.281;
IPointCollection pPointCollection = new Polyline();
pPointCollection.AddPoint(pPoint1);
pPointCollection.AddPoint(pPoint2);
pPointCollection.AddPoint(pPoint3);
IFeatureLayer pFLayer = pMxdoc.FocusMap.Layer[0] as IFeatureLayer;
IDataset pDS = pFLayer.FeatureClass as IDataset;
IWorkspaceEdit pWSE = pDS.Workspace as IWorkspaceEdit;
pWSE.StartEditing(false);
pWSE.StartEditOperation();
IFeature pFeature = pFLayer.FeatureClass.CreateFeature();
pFeature.Shape = pPointCollection as IGeometry;
pFeature.Store();
pWSE.StopEditOperation();
pWSE.StopEditing(true);
pMxdoc.ActiveView.Refresh();
}
private static void SetStudentInfo(IFeatureLayer featureLayer, IFeature feature, object Id, object SID, object SNAME, object SSEX, object SBIRTH, object SHOME)
{
IFeatureClassWrite pWrite = featureLayer.FeatureClass as IFeatureClassWrite;
IWorkspaceEdit pEdit = (featureLayer.FeatureClass as IDataset).Workspace as IWorkspaceEdit;
pEdit.StartEditing(true);
pEdit.StartEditOperation();
feature.set_Value(featureLayer.FeatureClass.Fields.FindField("Id"), Id);
feature.set_Value(featureLayer.FeatureClass.Fields.FindField("SID"), SID);
feature.set_Value(featureLayer.FeatureClass.Fields.FindField("SNAME"), SNAME);
feature.set_Value(featureLayer.FeatureClass.Fields.FindField("SSEX"), SSEX);
feature.set_Value(featureLayer.FeatureClass.Fields.FindField("SBIRTH"), SBIRTH);
feature.set_Value(featureLayer.FeatureClass.Fields.FindField("SHOME"), SHOME);
feature.Store();
pWrite.WriteFeature(feature);
pEdit.StopEditOperation();
pEdit.StopEditing(true);
}
private void addFeature(string layerName, IGeometry geometry)
{
int i = 0;
ILayer layer = null;
for (i = 0; i < mainMapControl.LayerCount; i++)
{
layer = mainMapControl.Map.get_Layer(i);
if (layer.Name.ToLower() == layerName)
{
break;
}
}
IFeatureLayer pfeatureLayer = layer as IFeatureLayer;
IFeatureClass pfeatureclass = pfeatureLayer.FeatureClass;
IDataset dataset = (IDataset)pfeatureclass;
IWorkspace pworkspace = dataset.Workspace;
//开始空间编辑
IWorkspaceEdit eworkspaceEdit = (IWorkspaceEdit)pworkspace;
eworkspaceEdit.StartEditing(true);
eworkspaceEdit.StartEditOperation();
IFeatureBuffer bfeatureBuffer = pfeatureclass.CreateFeatureBuffer();
//清除图层原有的实体对象
IFeatureCursor cfeatureCursor = pfeatureclass.Search(null, true);
IFeature ifeature = cfeatureCursor.NextFeature();
while (ifeature != null)
{
ifeature.Delete();
ifeature = cfeatureCursor.NextFeature();
}
//开始插入新的实体对象
cfeatureCursor = pfeatureclass.Insert(true);
bfeatureBuffer.Shape = geometry;
object ofeatureID = cfeatureCursor.InsertFeature(bfeatureBuffer);
//保存实体
cfeatureCursor.Flush();
eworkspaceEdit.StopEditOperation();
eworkspaceEdit.StopEditing(true);
System.Runtime.InteropServices.Marshal.ReleaseComObject(cfeatureCursor);
}
/// <summary>
/// 构造小区的一个网格
/// </summary>
/// <param name="cellName"></param>
/// <param name="gxid"></param>
/// <param name="gyid"></param>
/// <param name="x1"></param>
/// <param name="y1"></param>
/// <param name="x2"></param>
/// <param name="y2"></param>
/// <param name="recePower"></param>
/// <param name="pathLoss"></param>
public void constructGrid(string cellName, int enodeb, int ci, int gxid, int gyid, double x1, double y1, double x2, double y2, double recePower, double pathLoss)
{
IDataset dataset = (IDataset)pFeatureLayer.FeatureClass;
IWorkspace workspace = dataset.Workspace;
IWorkspaceEdit workspaceEdit = (IWorkspaceEdit)workspace;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
IFeatureCursor pFeatureCursor = pFeatureClass.Insert(true);
IFeatureBuffer pFeatureBuffer;
IPoint pointA = GeometryUtilities.ConstructPoint2D(x1, y1);
IPoint pointB = GeometryUtilities.ConstructPoint2D(x2, y1);
IPoint pointC = GeometryUtilities.ConstructPoint2D(x2, y2);
IPoint pointD = GeometryUtilities.ConstructPoint2D(x1, y2);
IGeometryCollection pGeometryColl = GeometryUtilities.ConstructPolygon(new IPoint[] { pointA, pointB, pointC, pointD });
pFeatureBuffer = pFeatureClass.CreateFeatureBuffer();
pFeatureBuffer.Shape = pGeometryColl as IGeometry;
pFeatureBuffer.set_Value(this.GXIDIndex, gxid);
pFeatureBuffer.set_Value(this.GYIDIndex, gyid);
pFeatureBuffer.set_Value(this.eNodeBIndex, enodeb);
pFeatureBuffer.set_Value(this.CIIndex, ci);
pFeatureBuffer.set_Value(this.cellNameIndex, cellName);
pFeatureBuffer.set_Value(this.RecePowerIndex, recePower);
pFeatureBuffer.set_Value(this.PathLossIndex, pathLoss);
pFeatureCursor.InsertFeature(pFeatureBuffer);
//一次性提交
pFeatureCursor.Flush();
//stop editing
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
IFeatureClassManage pFeatureClassManage = (IFeatureClassManage)pFeatureClass;
pFeatureClassManage.UpdateExtent();
//GISMapApplication.Instance.RefreshLayer(pFeatureLayer);
//GISMapApplication.Instance.FullExtent(pFeatureLayer.AreaOfInterest);
}
/// <summary>
/// 根据点创建要素
/// </summary>
/// <params name="pGeom"></params>
private void CreateFeature(IGeometry pGeom)
{
try
{
if (pGeom == null)
{
return;
}
if (m_pCurrentLayer == null)
{
return;
}
IWorkspaceEdit pWorkspaceEdit = DataEditCommon.g_CurWorkspaceEdit;// GetWorkspaceEdit();
IFeatureLayer pFeatureLayer = (IFeatureLayer)m_pCurrentLayer;
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
pWorkspaceEdit.StartEditOperation();
IFeature pFeature = pFeatureClass.CreateFeature();
// 处理Z/M值
DrawCommon.HandleZMValue(pFeature, pGeom, 0);
pFeature.Shape = pGeom;
pFeature.Store();
pWorkspaceEdit.StopEditOperation();
IActiveView pActiveView = (IActiveView)m_pMap;
m_GeometryCollection = null;
IGraphicsContainer pGra = m_pMapControl.Map as IGraphicsContainer;
for (int i = 0; i < m_ElementArray.Count; i++)
{
pGra.DeleteElement(m_ElementArray.get_Element(i) as IElement);
}
m_ElementArray.RemoveAll();
m_pMap.SelectFeature(m_pCurrentLayer, pFeature);
m_pMapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGraphics | esriViewDrawPhase.esriViewGeoSelection, null, null);
}
catch (Exception e)
{
Console.WriteLine(e.Message.ToString());
}
}
protected override void OnClick()
{
//time before running
DateTime fDate = DateTime.Now;
int feature = 5000;
IMxDocument pmxDoc = ArcMap.Application.Document as IMxDocument;
IFeatureLayer pFlayer = pmxDoc.FocusMap.Layer[0] as IFeatureLayer;
IDataset pDs = pFlayer.FeatureClass as IDataset;
IWorkspaceEdit pWorkspace = pDs.Workspace as IWorkspaceEdit;
pWorkspace.StartEditing(false);
pWorkspace.StartEditOperation();
IFeatureBuffer pBuffer = pFlayer.FeatureClass.CreateFeatureBuffer();
IFeatureCursor pFcursor = pFlayer.FeatureClass.Insert(true);
Random r = new Random();
for (int i = 0; i < feature; i++)
{
IPoint pPoint = new Point();
pPoint.X = -78.115341 + r.NextDouble() * 20000;
pPoint.Y = 133.077697 + r.NextDouble() * 20000;
pBuffer.Shape = pPoint;
pBuffer.Value[pBuffer.Fields.FindField("Name")] = "myfeature" + i.ToString() + " " + "Finish";
pFcursor.InsertFeature(pBuffer);
if (i % 1000 == 0)
{
pFcursor.Flush();
}
}
pFcursor.Flush();
pWorkspace.StopEditOperation();
pWorkspace.StopEditing(true);
//time after complete;
double timeinsecond = (DateTime.Now - fDate).TotalSeconds;
MessageBox.Show("Time to create " + feature + ":" + timeinsecond + "second");
pmxDoc.ActiveView.Refresh();
}
/// <summary>
/// 按类型删除线段
/// <summary>
/// <param name="path">shp文件路径</param>
static private void RemoveRoadByType(string inPath)
{
//计时
Stopwatch sw = new Stopwatch();
sw.Start();
//string inPath = "E:\\桌面\\道路平行性判断\\CityShapeFile\\#test\\hk_island_spf.shp";
string dir = System.IO.Path.GetDirectoryName(inPath); //可以获得不带文件名的路径
string name = System.IO.Path.GetFileNameWithoutExtension(inPath); //可以获得文件名
string linkPath = dir + "\\" + name + "_link.shp";
Console.WriteLine("inPath: " + inPath);
Console.WriteLine("linkPath: " + linkPath);
IFeatureClass linkFeatClass = CopyFeatureClass(inPath, linkPath); //拷贝要素类
roadTypeIndex = QueryFieldIndex(linkFeatClass, "fclass");
linkIndex = AddField(linkFeatClass, "link", esriFieldType.esriFieldTypeSmallInteger, 1);
//打开编辑器
IWorkspaceFactory workspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspace workspace = workspaceFactory.OpenFromFile(System.IO.Path.GetDirectoryName(linkPath), 0);
IWorkspaceEdit workspaceEdit = workspace as IWorkspaceEdit;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
//按类型删除
DeleteFeatureByRoadType(linkFeatClass);
//为link做标记
UpdateTagField(linkFeatClass, linkIndex);
//停止编辑状态
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
//停止计时，输出结果
sw.Stop();
int featCount = linkFeatClass.FeatureCount(null);
Console.WriteLine("规模：" + linkFeatClass.FeatureCount(null) + " 用时：" + Math.Round(sw.Elapsed.TotalMinutes, 2) + "Min");
}
//确定键
private void buttonOK_Click(object sender, EventArgs e)
{
double dL = 0.0, dB = 0.0, dZJ = 0.0;
bool bL = double.TryParse(textBoxLong.Text, out dL); //经度
bool bB = double.TryParse(textBoxLat.Text, out dB); //纬度
bool bZJ = double.TryParse(textBoxLevel.Text, out dZJ); //震级
time = textBoxTime.Text; //时间
//开启编辑状态
IWorkspaceFactory pWorkspaceFactory = new AccessWorkspaceFactoryClass();
IFeatureWorkspace pFeatureWorkspace = pWorkspaceFactory.OpenFromFile(dataFile, 0) as IFeatureWorkspace;
IWorkspaceEdit pWorkspaceEdit = pFeatureWorkspace as IWorkspaceEdit;
pWorkspaceEdit.StartEditing(false);
pWorkspaceEdit.StartEditOperation();
//插入余震点数据
IFeatureClass pFeatureClassPoint = pFeatureLayerPoint.FeatureClass;
IFeatureClassWrite fwritePoint = pFeatureClassPoint as IFeatureClassWrite;
IFeature pFeaturePoint = pFeatureClassPoint.CreateFeature();
IPointCollection pointCollection = new MultipointClass();
IPoint pPoint = new PointClass();
IGeoDataset pGeoDataset = pFeatureClassPoint as IGeoDataset;
//记录空间投影信息
ISpatialReference spatialReference = pGeoDataset.SpatialReference;
//输入经纬度
pPoint.PutCoords(dL, dB);
pPoint.SpatialReference = spatialReference;
pointCollection.AddPoint(pPoint, ref _missing, ref _missing);
pFeaturePoint.Shape = pointCollection as IGeometry;
//设置属性值
pFeaturePoint.set_Value(3, dZJ);
pFeaturePoint.set_Value(5, time + "," + textBoxLevel.Text);
fwritePoint.WriteFeature(pFeaturePoint);
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeaturePoint);
pFeaturePoint = null;
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
this.Hide();
MessageBox.Show("操作成功！", "提示");
}
//将线添加到图层
private void AddFeature(IFeatureLayer pFeatureLayer, List <IPolyline> lineList, List <IPoint> ptsList, List <double> lineLengthList)
{
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
IDataset pDataset = (IDataset)pFeatureClass;
IWorkspace pWorkspace = pDataset.Workspace;
//for (int i = 0; i < lineList.Count; i++)
//{
// if (lineList[i].Length > 0)
// {
// IFeature pFeature = pFeatureClass.CreateFeature();
// pFeature.Shape = lineList[i];
// double sLength = Math.Round((ptsList[i + 1].X - ptsList[i].X) * (ptsList[i + 1].X - ptsList[i].X) + (ptsList[i + 1].Y - ptsList[i].Y) * (ptsList[i + 1].Y - ptsList[i].Y) + (ptsList[i + 1].Z - ptsList[i].Z) * (ptsList[i + 1].Z - ptsList[i].Z),4);
// pFeature.set_Value(pFeature.Fields.FindField("length"), sLength);
// pFeature.Store();
// }
//}
//开始空间编辑
IWorkspaceEdit pWorkspaceEdit = (IWorkspaceEdit)pWorkspace;
pWorkspaceEdit.StartEditing(true);
pWorkspaceEdit.StartEditOperation();
IFeatureBuffer pFeatureBuffer = pFeatureClass.CreateFeatureBuffer();
IFeatureCursor pFeatureCursor;
//开始插入新的实体对象
for (int i = 0; i < lineList.Count; i++)
{
IGeometry geometry = lineList[i];
pFeatureCursor = pFeatureClass.Insert(true);
pFeatureBuffer.Shape = geometry;
double sLength = lineList[i].Length;
lineLengthList.Add(sLength);
pFeatureBuffer.set_Value(pFeatureBuffer.Fields.FindField("length"), sLength);
object featureOID = pFeatureCursor.InsertFeature(pFeatureBuffer);
//保存实体
pFeatureCursor.Flush();
//结束空间编辑
pWorkspaceEdit.StopEditOperation();
pWorkspaceEdit.StopEditing(true);
System.Runtime.InteropServices.Marshal.ReleaseComObject(pFeatureCursor);
}
}
/// <summary>
/// 删除feature图元
/// </summary>
/// <param name="intObjID"></param>
/// <param name="strLayerName"></param>
/// <param name="map"></param>
public void DelFeature(int intObjID, string strLayerName, AxMapControl map)
{
IFeatureLayer pfeaLayer;
for (int intI = 0; intI < map.LayerCount; intI++)
{
try
{
pfeaLayer = map.get_Layer(intI) as IFeatureLayer;
if (pfeaLayer != null && pfeaLayer.FeatureClass.AliasName == strLayerName)
{
//定义一个地物类,把要编辑的图层转化为定义的地物类
IFeatureClass fc = pfeaLayer.FeatureClass;
//先定义一个编辑的工作空间,然后把转化为数据集,最后转化为编辑工作空间,
IWorkspaceEdit w = (fc as IDataset).Workspace as IWorkspaceEdit;
//开始事务操作
w.StartEditing(false);
//开始编辑
w.StartEditOperation();
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "OBJECTID=" + intObjID;
IFeatureCursor updateCursor = pfeaLayer.FeatureClass.Update(queryFilter, false);
IFeature feature = updateCursor.NextFeature();
int m = 0;
while (feature != null)
{
m++;
updateCursor.DeleteFeature();
feature = updateCursor.NextFeature();
}
//结束编辑
w.StopEditOperation();
//结束事务操作
w.StopEditing(true);
break;
}
}
catch
{
}
}
}
public bool DeleteObject(int objectID, enumTemplateObjectType objectType)
{
if (_workspace == null)
{
Connect();
}
IWorkspaceEdit pWksEdit = _workspace as IWorkspaceEdit;
pWksEdit.StartEditing(true);
pWksEdit.StartEditOperation();
ITable pTable;
IRow pRow;
switch (objectType)
{
case enumTemplateObjectType.FeatureClass:
pTable = _workspace.OpenTable("YT_TEMPLATE_FEATURECLASS");
pRow = pTable.GetRow(objectID);
break;
case enumTemplateObjectType.Domain:
pTable = _workspace.OpenTable("YT_TEMPLATE_DOMAIN");
pRow = pTable.GetRow(objectID);
break;
case enumTemplateObjectType.FeatureDataset:
pTable = _workspace.OpenTable("YT_TEMPLATE_DATASET");
pRow = pTable.GetRow(objectID);
break;
default:
return(false);
}
pRow.Delete();
pWksEdit.StopEditOperation();
pWksEdit.StopEditing(true);
DisConnect();
return(true);
}
private void btnApply_Click(object sender, EventArgs e)
{
if (this.m_pAnnoFeat != null)
{
try
{
IDataset dataset = (this.m_pAnnoFeat as IObject).Class as IDataset;
IWorkspaceEdit workspace = dataset.Workspace as IWorkspaceEdit;
workspace.StartEditOperation();
this.m_pAnnoFeat.Annotation = this.m_pTextElement as IElement;
(this.m_pAnnoFeat as IFeature).Store();
workspace.StopEditOperation();
this.m_pActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
}
}
protected override void OnClick()
{
//
// TODO: Sample code showing how to access button host
//
ArcMap.Application.CurrentTool = null;
IMxDocument pMxdoc = ArcMap.Application.Document as IMxDocument;
IFeatureLayer pFLayer = pMxdoc.ActiveView.FocusMap.Layer[0] as IFeatureLayer;
IFeature pFeature = pFLayer.FeatureClass.GetFeature(0);
IWorkspaceEdit pWS = (pFLayer.FeatureClass as IDataset).Workspace as IWorkspaceEdit;
pWS.StartEditing(false);
pWS.StartEditOperation();
pFeature.Delete();
pWS.StopEditOperation();
pWS.StopEditing(true);
}
public void ProcessFeature(IWorkspaceEdit iwe, IFeatureLayer ifl_active, IRow rw)
{
double value = double.NaN;
if (CoordinateSystem == "")
{
CoordinateSystem = ((IFeature)rw).Shape.SpatialReference.Name;
}
if (this.LinearUnit == null || this.LinearUnit == "")
{
if (fieldTier == 2)
{
LinearUnit = rw.get_Value(GetFieldUnitIndex()).ToString();
}
if (this.LinearUnit == null || this.LinearUnit.Trim() == "")
{
LinearUnit = GetSpatialReferenceLinearUnit(((IFeature)rw).Shape.SpatialReference);
}
}
if (LinearUnit.IndexOf("meter", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
if (useArealUnit)
{
currentAreaUnit = esriAreaUnits.esriSquareMeters;
LinearUnit = "Square Meters";
}
else
{
currentLinearUnit = esriUnits.esriMeters;
}
}
else if (LinearUnit.IndexOf("foot", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
if (useArealUnit)
{
currentAreaUnit = esriAreaUnits.esriSquareFeet;
LinearUnit = "Square Feet";
}
else
{
currentLinearUnit = esriUnits.esriFeet;
}
}
else if (LinearUnit.IndexOf("acre", 0, StringComparison.CurrentCultureIgnoreCase) > -1)
{
currentAreaUnit = esriAreaUnits.esriAcres;
currentLinearUnit = esriUnits.esriUnknownUnits;
LinearUnit = "Acres";
}
if (doReCalcValues || !double.TryParse(rw.get_Value(GetFieldIndex()).ToString(), out value) || value == double.NaN || value == 0.0)
{
value = DoMeasure(rw);
//try writing the (single) measured value to the table
try
{
IFeature feat = (IFeature)rw;
//if we are re-calculating all values, there is no need to start editing on each row
if (!doReCalcValues)
{
if (!iwe.IsBeingEdited())
iwe.StartEditing(true);
iwe.StartEditOperation();
}
feat.set_Value(GetFieldIndex(), value);
feat.set_Value(GetFieldUnitIndex(), LinearUnit);
feat.Store();
}
catch (Exception err)
{
}
finally
{
if (!doReCalcValues)
{
iwe.StopEditOperation();
if (iwe.IsBeingEdited())
iwe.StopEditing(true);
//there may be more than one row that requires editing
doReCalcValues = true;
}
}
}
values.Add(value);
}
public bool InsertNewRow(ITable table,IWorkspaceEdit workspace)
{
using (ComReleaser comReleaser = new ComReleaser())
{
try
{
multiWspEdit.StartMultiuserEditing(esriMultiuserEditSessionMode.esriMESMVersioned);
workspace.StartEditOperation();
_currentRow = table.CreateRow();
_currentRow.Store();
workspace.StopEditOperation();
workspace.StopEditing(true);
return true;
}
catch {
workspace.StopEditOperation();
workspace.StopEditing(false);
return false; }
}
}
