/// <summary>
/// Create the polyline feature class
/// </summary>
/// <param name="featWorkspace">IFeatureWorkspace</param>
/// <param name="name">Name of the featureclass</param>
/// <returns>IFeatureClass</returns>
private IFeatureClass CreatePolylineFeatureClass(IFeatureWorkspace featWorkspace, string name)
{
IFieldsEdit pFldsEdt = new FieldsClass();
IFieldEdit pFldEdt = new FieldClass();
pFldEdt = new FieldClass();
pFldEdt.Type_2 = esriFieldType.esriFieldTypeOID;
pFldEdt.Name_2 = "OBJECTID";
pFldEdt.AliasName_2 = "OBJECTID";
pFldsEdt.AddField(pFldEdt);
IGeometryDefEdit pGeoDef;
pGeoDef = new GeometryDefClass();
pGeoDef.GeometryType_2 = esriGeometryType.esriGeometryPolyline;
pGeoDef.SpatialReference_2 = ArcMap.Document.FocusMap.SpatialReference;
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "SHAPE";
pFldEdt.AliasName_2 = "SHAPE";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeGeometry;
pFldEdt.GeometryDef_2 = pGeoDef;
pFldsEdt.AddField(pFldEdt);
IFeatureClass pFClass = featWorkspace.CreateFeatureClass(name, pFldsEdt, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
return pFClass;
}
/// <summary>
/// Coder: 梁 爽
/// Date: 2008-10-16
/// Content:该函数实现要素类的创建，首先用接口IGeometryDefEdit设置要素类的类型，即是Point,Polylin还是Polygon
/// 然后用接口IFieldEdit设置要素类的字段，这里设置了三个字段，分别是ID,OID和Shape。最后通过接口IFeatureWorkspace
/// 的CreateFeatureClass方法创建要素类，函数返回IFeatureClass接口类型
/// </summary>
/// <param name="pWorkspace">设置工作空间</param>
/// <param name="pGeometryType">设置要素的类型，即是点，线，还是面</param>
/// <param name="strFeatName">设置要素类的名称</param>
/// <param name="ValCoordinatType">传递一个数值型参数，该参数为1-UnkownCoordinateSystem，2-GeographicCoordinateSystem
/// 或3ProjectedCoordinateSystem</param>
/// <returns></returns>
private IFeatureClass CreateFeatureClass(esriGeometryType pesriGeometryType, string pstrLayerName,
IWorkspace pWorkspace, IMapControl4 pm_mapControl, List <string> pstrFieldNameLt = null, List <esriFieldType> pesriFieldTypeLt = null)
{
//创建要素空间
IFeatureWorkspace pFeatureWorkspace = (IFeatureWorkspace)pWorkspace;
IGeometryDef geometryDef = new GeometryDefClass();
IGeometryDefEdit pGeometryDefEdit = (IGeometryDefEdit)geometryDef;
//_esriGeometryType could be: esriGeometryPoint, esriGeometryMultipoint,
//esriGeometryPolyline, esriGeometryPolygon, and esriGeometryMultiPatch.
pGeometryDefEdit.GeometryType_2 = pesriGeometryType;
pGeometryDefEdit.SpatialReference_2 = pm_mapControl.SpatialReference;
// Set the grid count to 1 and the grid size to 0 to allow ArcGIS to
// determine a valid grid size.
pGeometryDefEdit.GridCount_2 = 1;
pGeometryDefEdit.set_GridSize(0, 0);
//新建字段
IFieldsEdit pFieldsEdit = new FieldsClass();
//添加“Shape”字段
IFieldEdit pField;
pField = new FieldClass();
pField.Type_2 = esriFieldType.esriFieldTypeGeometry;
pField.GeometryDef_2 = geometryDef;
pField.Name_2 = "Shape";
pFieldsEdit.AddField((IField)pField);
//添加其它字段
if (pstrFieldNameLt != null)
{
//we don't need the first three FieldNames, i.e., "FID", "Shape", and "Id"
for (int i = 0; i < pstrFieldNameLt.Count; i++)
{
pFieldsEdit.AddField((IField)GenerateFieldEdit(pesriFieldTypeLt[i], pstrFieldNameLt[i]));
}
}
string strFullName = pWorkspace.PathName + "\\" + pstrLayerName;
File.Delete(strFullName + ".dbf");
File.Delete(strFullName + ".lyr");
File.Delete(strFullName + ".prj");
File.Delete(strFullName + ".shp");
//File.Delete(strFullName + ".shp.PALANQUE.2296.5388.sr.lock");
File.Delete(strFullName + ".shx");
try
{
return(pFeatureWorkspace.CreateFeatureClass(pstrLayerName,
(IFields)pFieldsEdit, null, null, esriFeatureType.esriFTSimple, "Shape"", ""));
}
catch
{
return(pFeatureWorkspace.CreateFeatureClass(pstrLayerName,
(IFields)pFieldsEdit, null, null, esriFeatureType.esriFTSimple, "Shape", ""));
}
}
public static IFeatureClass CreateFeatureClassByAxfFeatureLayer(IWorkspace workspace, IFeatureLayer axfFeatureLayer, bool isConvertToPoint = false, string className = "")
{
IFeatureWorkspace pFeatureWorkspace = workspace as IFeatureWorkspace;
if (pFeatureWorkspace == null)
{
return(null);
}
IFields pFields = GetFields(axfFeatureLayer.FeatureClass);
if (pFields == null)
{
return(null);
}
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
if (pFieldsEdit == null)
{
return(null);
}
IField pField = new FieldClass();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = "AXF_STATUS";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger;
pFieldsEdit.AddField(pField);
if (isConvertToPoint && axfFeatureLayer.FeatureClass.ShapeType == esriGeometryType.esriGeometryMultipoint)
{
for (int i = 0; i < pFieldsEdit.FieldCount; i++)
{
if (pFieldsEdit.Field[i].Type == esriFieldType.esriFieldTypeGeometry)
{
IFieldEdit geoFieldEdit = pFieldsEdit.Field[i] as IFieldEdit;
IGeometryDefEdit pGeometryDefEdit = geoFieldEdit.GeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
geoFieldEdit.GeometryDef_2 = pGeometryDefEdit;
}
}
}
IFieldChecker pFieldChecker = new FieldCheckerClass();
IEnumFieldError pEnumFieldError = null;
IFields validateFields = null;
pFieldChecker.ValidateWorkspace = workspace;
pFieldChecker.Validate(pFieldsEdit, out pEnumFieldError, out validateFields);
if (string.IsNullOrEmpty(className))
{
return(pFeatureWorkspace.CreateFeatureClass(className, validateFields, axfFeatureLayer.FeatureClass.CLSID,
axfFeatureLayer.FeatureClass.EXTCLSID, axfFeatureLayer.FeatureClass.FeatureType, "SHAPE", null));
}
else
{
return(pFeatureWorkspace.CreateFeatureClass(axfFeatureLayer.Name, validateFields, axfFeatureLayer.FeatureClass.CLSID,
axfFeatureLayer.FeatureClass.EXTCLSID, axfFeatureLayer.FeatureClass.FeatureType, "SHAPE", null));
}
}
private static IFeatureClass CreateFeaturepointClass(String featureClassName, IFeatureWorkspace featureWorkspace, ISpatialReference spatialReference)
{
try
{
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;
IFields fields = ocDescription.RequiredFields;
int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName);
IField field = fields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = field.GeometryDef;
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
geometryDefEdit.SpatialReference_2 = spatialReference;
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass(featureClassName, fields,
ocDescription.ClassExtensionCLSID, ocDescription.InstanceCLSID, esriFeatureType.esriFTSimple,
fcDescription.ShapeFieldName, "");
return(featureClass);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "异常");
return(null);
}
}
/// <summary>
/// 在地理数据库中创建要素类
/// </summary>
/// <param name="workspacePath">工作空间路径</param>
/// <param name="feaclassName">所创建要素类名称</param>
/// <param name="GeometeyType">枚举要素类类型: esriGeimetryType(</param>
/// <param name="gcsType">地理空间坐标系类型,格式如: (int)esriSRGeoCS3Type.esriSRGeoCS_Xian1980</param>
/// <returns></returns>
public IFeatureClass CreateFeatureClass(string workspacePath, string feaclassName, esriGeometryType GeometeyType, int gcsType)
{
AccessGeoData accData = new AccessGeoData();
IFeatureWorkspace pFeaWorkspace = accData.OpenFeatureWorkspace(workspacePath);
spatialRef = spatialRefFactory.CreateGeographicCoordinateSystem(gcsType);
//字段编辑：包括ObjectID 与 Shape
IFields fields = new FieldsClass();
IFieldsEdit fedits = (IFieldsEdit)fields;
//构建唯一标识符字段
IField objfield = new FieldClass();
IFieldEdit objEdit = (IFieldEdit)objfield;
objEdit.Name_2 = "OBJECTID";
objEdit.Type_2 = esriFieldType.esriFieldTypeOID;
fedits.AddField(objEdit);
//构建shape
IField Spfield = new FieldClass();
IFieldEdit fEdit = (IFieldEdit)Spfield;
IGeometryDef pGeoDef = new GeometryDefClass();
IGeometryDefEdit pGeoDefEdit = (IGeometryDefEdit)pGeoDef;
pGeoDefEdit.GeometryType_2 = GeometeyType;
pGeoDefEdit.SpatialReference_2 = spatialRef;
fEdit.Name_2 = "Shape";
fEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
fEdit.GeometryDef_2 = pGeoDef;
fedits.AddField(Spfield);
//附加一个可编辑字段，存放属性值
IField fieldZ = new FieldClass();
IFieldEdit EditZ = (IFieldEdit)fieldZ;
EditZ.Name_2 = "Value";
EditZ.Type_2 = esriFieldType.esriFieldTypeDouble;
fedits.AddField(EditZ);
//若有其他需求，在此处添加字段，参加Value字段添加方式
IFeatureClass pFeaClass = pFeaWorkspace.CreateFeatureClass(feaclassName, fields, null, null, esriFeatureType.esriFTSimple, "Shape", "");
return pFeaClass;
}
/// <summary>
/// 在内存中创建要素类
/// </summary>
/// <returns></returns>
public IFeatureClass MemoryFeatureClass()
{
AccessGeoData accData = new AccessGeoData();
IFeatureWorkspace pFeaWorkspace = accData.FeatureWorkspace();
IFields fields = new FieldsClass();
IFieldsEdit fedits = (IFieldsEdit)fields;
IField objfield = new FieldClass();
IFieldEdit objEdit = (IFieldEdit)objfield;
objEdit.Name_2 = "OBJECTID";
objEdit.Type_2 = esriFieldType.esriFieldTypeOID;
fedits.AddField(objEdit);
IField Spfield = new FieldClass();
IFieldEdit fEdit = (IFieldEdit)Spfield;
IGeometryDef pGeoDef = new GeometryDefClass();
IGeometryDefEdit pGeoDefEdit = (IGeometryDefEdit)pGeoDef;
pGeoDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pGeoDefEdit.SpatialReference_2 = spatialRef;
fEdit.Name_2 = "Shape";
fEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
fEdit.GeometryDef_2 = pGeoDef;
fedits.AddField(Spfield);
IField fieldZ = new FieldClass();
IFieldEdit EditZ = (IFieldEdit)fieldZ;
EditZ.Name_2 = "Z";
EditZ.Type_2 = esriFieldType.esriFieldTypeDouble;
fedits.AddField(EditZ);
IFeatureClass pFeaClass = pFeaWorkspace.CreateFeatureClass("FeaturePoints", fields, null, null, esriFeatureType.esriFTSimple, "Shape", "");
return pFeaClass;
}
public static IFeatureClass CreateFeatureClass(IWorkspace workspace, string featureClassName, esriGeometryType type, ISpatialReference spatialReference)
{
IFeatureWorkspace pFeatureWorkspace = workspace as IFeatureWorkspace;
IFeatureClassDescription pFeatureClassDescription = new FeatureClassDescriptionClass();
IObjectClassDescription pObjectClassDescription = pFeatureClassDescription as IObjectClassDescription;
IFields pFields = pObjectClassDescription.RequiredFields;
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
for (int i = 0; i < pFields.FieldCount; i++)
{
if (pFieldsEdit.Field[i].Type == esriFieldType.esriFieldTypeGeometry)
{
IFieldEdit pFieldEdit = pFieldsEdit.Field[i] as IFieldEdit;
IGeometryDef pGeometryDef = new GeometryDefClass();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = type;
pGeometryDefEdit.SpatialReference_2 = spatialReference;
pFieldEdit.GeometryDef_2 = pGeometryDef;
}
}
IFieldChecker pFieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
pFieldChecker.ValidateWorkspace = workspace;
pFieldChecker.Validate(pFields, out enumFieldError, out validatedFields);
return(pFeatureWorkspace.CreateFeatureClass(featureClassName, validatedFields,
pObjectClassDescription.InstanceCLSID, pObjectClassDescription.ClassExtensionCLSID,
esriFeatureType.esriFTSimple, "SHAPE", ""));
}
//http://resources.esri.com/help/9.3/arcgisengine/arcobjects/esriGeoDatabase/IFeatureWorkspace.CreateFeatureClass_Example.htm
static IFeatureClass CreateFeatureClass(string name, IFeatureWorkspace ftrSpc, esriGeometryType type, int epsg, List <dynamic> extraFields)
{
IFeatureClass ftrc = null;
if (null != ftrSpc && null != name)
{
IFieldsEdit flds = new FieldsClass();
flds.FieldCount_2 = 2 + (extraFields == null ? 0 : extraFields.Count);
IFieldEdit fld = new FieldClass();
fld.Name_2 = OBJECT_ID;
fld.Type_2 = esriFieldType.esriFieldTypeOID;
flds.Field_2[0] = fld;
fld = new FieldClass();
fld.Name_2 = SHP_NAME;
fld.Type_2 = esriFieldType.esriFieldTypeGeometry;
fld.GeometryDef_2 = CreateGeometryDef(type, epsg);
flds.Field_2[1] = fld;
int eidx = 2;
foreach (var efld in extraFields)
{
fld = new FieldClass();
fld.Name_2 = efld.Name;
fld.Type_2 = efld.Type;
flds.Field_2[eidx++] = fld;
}
ftrc = ftrSpc.CreateFeatureClass(name, flds, null, null, esriFeatureType.esriFTSimple, SHP_NAME, null);
}
return(ftrc);
}
/// <summary>
/// Converts the spatialite table to a featureclass in a temporary, scratch workspace.
/// </summary>
/// <returns>IFeatureClass copy of the spatialite table</returns>
public IFeatureClass ConvertToFeatureclass()
{
try
{
CreateTemporaryGeodatabase();
IWorkspaceFactory factory = new AccessWorkspaceFactoryClass();
IWorkspace workspace = factory.OpenFromFile(this.PGDBPath, 0);
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
IFields fields = CreateFields();
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass(this.TableName, validatedFields,
null, null, esriFeatureType.esriFTSimple, "Shape", "");
LoadFeatureclass(featureClass);
return(featureClass);
}
catch (Exception ex)
{
Trace.WriteLine(ex.StackTrace);
throw;
}
}
/// <summary>
/// 新建线图层
/// </summary>
public void CreatePolylineLayer()
{
SaveFileDialog sfdPoint = new SaveFileDialog();
sfdPoint.Title = "请选择线图层的存储位置";
sfdPoint.Filter = "Shapefile(*.shp)|*.shp|All files(*.*)|*.*";
sfdPoint.RestoreDirectory = true;
if (sfdPoint.ShowDialog() == DialogResult.OK)
{
LocalFilePath = sfdPoint.FileName;
FilePath = System.IO.Path.GetDirectoryName(LocalFilePath);
FileName = System.IO.Path.GetFileName(LocalFilePath);
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
IField pField = new FieldClass();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = "SHAPE";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDef pGeometryDef = new GeometryDefClass();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolyline;
pFieldEdit.GeometryDef_2 = pGeometryDef;
pFieldsEdit.AddField(pField);
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace pFeatureWorkspace = pWorkspaceFactory.OpenFromFile(FilePath, 0) as IFeatureWorkspace;
pFeatureWorkspace.CreateFeatureClass(FileName, pFields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
m_mapControl.AddShapeFile(FilePath, FileName);
m_mapControl.ActiveView.Refresh();
}
}
private IFeatureClass CreateFeatureClass(IFeatureWorkspace FeatureWorkspace, string LayerName, esriFeatureType featureType, esriGeometryType GeometryType)
{
IFields fields = new FieldsClass();
IFieldsEdit edit = fields as IFieldsEdit;
//创建OBJECTID字段
IField field3 = new FieldClass();
IFieldEdit edit2 = field3 as IFieldEdit;
edit2.Name_2 = "OBJECTID";
edit2.AliasName_2 = "OBJECTID";
edit2.Type_2 = esriFieldType.esriFieldTypeOID;
edit.AddField(field3);
//创建Shape字段
IGeometryDef def = new GeometryDefClass();
IGeometryDefEdit edit4 = def as IGeometryDefEdit;
edit4.GeometryType_2 = GeometryType;
edit4.GridCount_2 = 1;
edit4.set_GridSize(0, 1000);
edit4.AvgNumPoints_2 = 2;
edit4.HasM_2 = false;
edit4.HasZ_2 = false;
edit4.SpatialReference_2 = this.ExportSpatialReference;
IField field4 = new FieldClass();
IFieldEdit edit3 = field4 as IFieldEdit;
edit3.Name_2 = "SHAPE";
edit3.AliasName_2 = "SHAPE";
edit3.Type_2 = esriFieldType.esriFieldTypeGeometry;
edit3.GeometryDef_2 = def;
edit.AddField(field4);
string ShapeFiledName = field4.Name;
UID uid = null;
UID uid2 = null;
switch (featureType)
{
case esriFeatureType.esriFTSimple: //FeatureClass
IObjectClassDescription description4 = new FeatureClassDescriptionClass();
uid = description4.InstanceCLSID;
uid2 = description4.ClassExtensionCLSID;
break;
case esriFeatureType.esriFTAnnotation: //AnnotationFeatureClass
IObjectClassDescription description = new AnnotationFeatureClassDescriptionClass();
uid = description.InstanceCLSID;
uid2 = description.ClassExtensionCLSID;
GeometryType = esriGeometryType.esriGeometryPolygon;
break;
}
//创建要素对象
IFeatureClass fc = FeatureWorkspace.CreateFeatureClass(LayerName, fields, uid, uid2, featureType, ShapeFiledName, null);
return(fc);
}
/// <summary>
/// 创建要素类，该要素类仅存储在内存中
/// </summary>
/// <param name="name">要素类名称</param>
/// <param name="fields">要创建的字段集（必须包含SHAPE字段和OID字段），可参考<see cref="FieldOpt.CreateBaseFields"/>等方法创建字段集</param>
/// <param name="strWorkspaceName">内存工作空间的名称</param>
/// <returns></returns>
public static IFeatureClass CreateInMemory(string name, IFields fields, string strWorkspaceName = "InMemoryWorkspace")
{
var workspace = WorkspaceEx.NewInMemoryWorkspace(strWorkspaceName);
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
return(featureWorkspace.CreateFeatureClass(name, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", ""));
}
public static IFeatureClass CreateFeatureClass(IWorkspace workspace, string datasetname, string name, IFeatureClass refFeatureClass)
{
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
string username = null;
string checkname = null;
try
{
username = workspace.ConnectionProperties.ToDictionary()["USERNAME"].ToString();
checkname = $"{username}.{name}";
}
catch (Exception)
{
checkname = name;
//throw;
}
var exist = CheckFeatureClassExist(checkname, workspace);
IFeatureClass createdFeatureClass;
if (!exist)
{
createdFeatureClass = featureWorkspace.CreateFeatureClass($"{name}", refFeatureClass.Fields, null, null, refFeatureClass.FeatureType, refFeatureClass.ShapeFieldName, "");
return(createdFeatureClass);
}
throw new NotImplementedException();
}
/// <summary>
/// 将IFeatureCursor保存到指定工作空间的指定表
/// </summary>
/// <param name="cursor"></param>
/// <param name="workspace"></param>
/// <param name="layername"></param>
/// <param name="clearReords">是否清空原图层的数据</param>
/// <param name="type"></param>
/// <param name="ShapeFieldName"></param>
/// <param name="ConfigKeyword"></param>
/// <returns></returns>
public static IFeatureClass SaveToWorkspace(this IFeatureCursor cursor, IFeatureWorkspace workspace, string layername
, bool clearReords = false
, esriFeatureType type = esriFeatureType.esriFTSimple
, string ShapeFieldName = "SHAPE"
, string ConfigKeyword = "")
{
try
{
IFeatureClass featureClass = workspace.TryOpenFeatureClass(layername);
if (featureClass == null)
{
IFields fields = cursor.Fields.Clone();
featureClass = workspace.CreateFeatureClass(layername, fields, type, ShapeFieldName, ConfigKeyword);
}
else
{
if (clearReords)
{
featureClass.Delete();
}
}
cursor.SaveToFeatureClass(featureClass);
return(featureClass);
}
catch
{
return(null);
}
}
/// <summary>
/// 创建矢量数据
/// </summary>
/// <param name="pWorkspace"></param>
/// <returns></returns>
public IFeatureClass CreateFeatureClassClass(IWorkspace pWorkspace, string strName, string strAliasName, IFields fields)
{
if (pWorkspace == null)
{
return(null);
}
IFeatureWorkspace featureWorkspace = pWorkspace as IFeatureWorkspace;
if (featureWorkspace == null)
{
return(null);
}
IFeatureClass featureClass = null;
try
{
featureClass = featureWorkspace.CreateFeatureClass(strName, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", null);
if (!string.IsNullOrEmpty(strAliasName))
{
IClassSchemaEdit classSchemaEdit = featureClass as IClassSchemaEdit;
if (null != classSchemaEdit)
{
classSchemaEdit.AlterAliasName(strAliasName);
}
}
}
catch (Exception ex)
{
}
return(featureClass);
}
static IFeatureClass CreateFeatureClass(IFeatureWorkspace workspace, string name, ISpatialReference outSR)
{
IFieldsEdit fields = new FieldsClass();
IFieldEdit field = new FieldClass();
field.Type_2 = esriFieldType.esriFieldTypeOID;
field.Name_2 = "OBJECTID";
field.AliasName_2 = "OBJECTID";
fields.AddField(field);
IGeometryDefEdit geom = new GeometryDefClass();
geom.GeometryType_2 = esriGeometryType.esriGeometryPolygon;
geom.SpatialReference_2 = outSR;
geom.HasM_2 = true;
geom.HasZ_2 = false;
field = new FieldClass();
field.Name_2 = "SHAPE";
field.AliasName_2 = "SHAPE";
field.Type_2 = esriFieldType.esriFieldTypeGeometry;
field.GeometryDef_2 = geom;
fields.AddField(field);
return workspace.CreateFeatureClass(name, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
}
private IFeatureClass CreateShapeFile(string shapeFullname, string proj)
{
FileInfo finfo = new FileInfo(shapeFullname);
string parFolder = System.IO.Path.GetDirectoryName(shapeFullname);
if (!Directory.Exists(parFolder))
{
Directory.CreateDirectory(parFolder);
}
IWorkspaceFactory shpwf = new ShapefileWorkspaceFactory();
IFeatureWorkspace featureWs = shpwf.OpenFromFile(parFolder, 0) as IFeatureWorkspace;
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
//添加几何字段
IField pField = new FieldClass();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = "Shape";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDef pGeomDef = new GeometryDefClass();
IGeometryDefEdit pGeomDefEdit = pGeomDef as IGeometryDefEdit;
pGeomDefEdit.GeometryType_2 = ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint; //几何类型
pGeomDefEdit.HasZ_2 = true; //是否有Z值
pGeomDefEdit.SpatialReference_2 = CreateSpatialReference(proj); //设置空间参考
pFieldEdit.GeometryDef_2 = pGeomDef;
pFieldsEdit.AddField(pField);
return(featureWs.CreateFeatureClass(finfo.Name, pFields, null, null, esriFeatureType.esriFTSimple, "SHAPE", null));
}
private void Btn_ExportSelection_Click(object sender, EventArgs e)
{
SaveFileDialog sfd = new SaveFileDialog()
{
Filter = "Shapefile|*.shp",
};
if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
IWorkspaceFactory factory = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace tempWorkspace = factory.OpenFromFile(sfd.FileName.Substring(0, sfd.FileName.LastIndexOf('\\')), 0) as IFeatureWorkspace;
IFeatureClass curFeatureClass = (m_selectedLayer as IFeatureLayer).FeatureClass;
IFeatureClass newFeatureClass = tempWorkspace.CreateFeatureClass("result", curFeatureClass.Fields, null, null, esriFeatureType.esriFTSimple, curFeatureClass.ShapeFieldName, "");
ICursor cursor;
(m_selectedLayer as IFeatureSelection).SelectionSet.Search(null, true, out cursor);
IFeatureCursor featureCursor = cursor as IFeatureCursor;
IFeature curFeature = featureCursor.NextFeature();
while (curFeature != null)
{
IFeature newFeature = newFeatureClass.CreateFeature();
for (int i = 0; i < newFeatureClass.Fields.FieldCount; i++)
{
IField curField = newFeatureClass.Fields.get_Field(i);
if (curField.Type != esriFieldType.esriFieldTypeOID)
{
newFeature.set_Value(i, curFeature.get_Value(i));
}
}
newFeature.Store();
curFeature = featureCursor.NextFeature();
}
}
}
public IFeatureClass CreateFeatureClass()
{
IFeatureClass result = null;
IFieldsEdit fieldsEdit = new FieldsClass();
fieldsEdit = CreateField(fieldsEdit, "ObjectId", esriFieldType.esriFieldTypeOID);
IMappedFeature mapFeature = CreateMappedFeature(null);
esriGeometryType esriGeometryType = mapFeature.EsriGeometryType;
Dictionary <string, esriFieldType> fields = mapFeature.Fields;
if ((esriGeometryType != esriGeometryType.esriGeometryNull) && (fields.Count >= 1))
{
string shapeFieldName = mapFeature.ShapeFieldName;
ISpatialReference spatialReference = ArcUtils.SpatialReference;
fieldsEdit = CreateGeometryField(fieldsEdit, shapeFieldName, spatialReference, esriGeometryType);
fieldsEdit = fields.Aggregate(fieldsEdit, (current, field) => CreateField(current, field.Key, field.Value));
foreach (var fieldName in FieldNames)
{
if ((!string.IsNullOrEmpty(fieldName)) &&
(!fields.Aggregate(false, (current, field) => (field.Key == fieldName) || current)))
{
CreateField(fieldsEdit, fieldName, esriFieldType.esriFieldTypeString);
}
}
IFeatureWorkspace featureWorkspace = _cycloMediaGroupLayer.FeatureWorkspace;
result = featureWorkspace.CreateFeatureClass(FcName, fieldsEdit, null, null, esriFeatureType.esriFTSimple,
shapeFieldName, string.Empty);
}
return(result);
}
/// <summary>
/// 创建一个要素集
/// </summary>
/// <param name="shpfolder"></param>
/// <param name="shpname"></param>
/// <returns></returns>
public static IFeatureClass CreatePolygonFeatureClass(string shpfolder, string shpname)
{
IWorkspaceFactory pWorkSpaceFac = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace pFeatureWorkSpace = pWorkSpaceFac.OpenFromFile(shpfolder, 0) as IFeatureWorkspace;
//创建字段集2
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;//创建必要字段
IFields fields = ocDescription.RequiredFields;
int shapeFieldIndex = fields.FindField(fcDescription.ShapeFieldName);
IField field = fields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = field.GeometryDef;
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
//geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
//geometryDefEdit.SpatialReference_2 = spatialReference;
geometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPolyline;
ISpatialReferenceFactory pSpatialRefFac = new SpatialReferenceEnvironmentClass();
IProjectedCoordinateSystem pcsSys = pSpatialRefFac.CreateProjectedCoordinateSystem((int)esriSRProjCS4Type.esriSRProjCS_Xian1980_3_Degree_GK_Zone_39);
geometryDefEdit.SpatialReference_2 = pcsSys;
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null; //将传入字段 转成 validatedFields
fieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkSpace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
IFeatureClass featureClass = pFeatureWorkSpace.CreateFeatureClass(shpname, validatedFields, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, "");
AddField(featureClass, "BuildID", "自带id", 50);
return(featureClass);
}
public IFeatureClass CreateShapeFile(DataSet ds, string strOutShpName, ISpatialReference pSRF)
{
try
{
DirectoryInfo di = new DirectoryInfo(strOutShpName);
string filefolder = di.Parent.FullName;
ClsGDBDataCommon cdc = new ClsGDBDataCommon();
//cdc.OpenFromShapefile(filefolder);
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
//设置字段
IField pField = new FieldClass();
IFieldEdit pFieldEdit = (IFieldEdit)pField;
//创建类型为几何类型的字段
IGeometryDef pGeoDef = new GeometryDefClass();
IGeometryDefEdit pGeoDefEdit = (IGeometryDefEdit)pGeoDef;
pGeoDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pGeoDefEdit.HasM_2 = false;
pGeoDefEdit.HasZ_2 = false;
pGeoDefEdit.SpatialReference_2 = pSRF;
pFieldEdit.Name_2 = "SHAPE";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
pFieldEdit.GeometryDef_2 = pGeoDef;
//pFieldEdit.IsNullable_2 = true;
//pFieldEdit.Required_2 = true;
pFieldsEdit.AddField(pField);
for (int i = 0; i < ds.Tables[0].Columns.Count; i++)
{
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = ds.Tables[0].Columns[i].ColumnName;
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldEdit.IsNullable_2 = true;
pFieldsEdit.AddField(pField);
}
ClsGDBDataCommon comm = new ClsGDBDataCommon();
IWorkspace inmemWor = comm.OpenFromShapefile(filefolder);
// ifeatureworkspacee
IFeatureWorkspace pFeatureWorkspace = inmemWor as IFeatureWorkspace;
IFeatureClass pFeatureClass = pFeatureWorkspace.CreateFeatureClass(di.Name, pFields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
return(pFeatureClass);
//IFeatureLayer pFeatureLayer = new FeatureLayerClass();
//pFeatureLayer.FeatureClass = pFeatureClass;
//pFeatureLayer.Name = System.IO.Path.GetFileNameWithoutExtension(di.Name);
//m_mapControl.AddLayer(pFeatureLayer as ILayer, 0);
//m_mapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
catch (SystemException ee)
{
MessageBox.Show(ee.Message);
return(null);
}
}
public IFeatureLayer CreateLayer(IFeatureClass pFeatureClass, int index) //新建任意范围打印地图的图层
{
string FilePath = @"C:\任意打印\";
string FileName = "bb" + index.ToString();
/////////////////////////////////////////////////
// ILayerFile layerFile = new LayerFileClass();
// layerFile.New(FilePath + FileName);
/////////////////////////////////////////////
IFields pFields = pFeatureClass.Fields;
IClone pClone = pFields as IClone;
IFields pCloneFields = pClone.Clone() as IFields;
IDataset pDataSet = pFeatureClass as IDataset;
IWorkspace pWorkSpace = pDataSet.Workspace;
IFeatureWorkspace pFeatWorkspace = pWorkSpace as IFeatureWorkspace;
IFeatureClass newFeatcls = pFeatWorkspace.CreateFeatureClass(FileName, pCloneFields,
null, null, esriFeatureType.esriFTSimple, pFeatureClass.ShapeFieldName, "");
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.FeatureClass = newFeatcls;
pFeatureLayer.Name = newFeatcls.AliasName;
return(pFeatureLayer);
// System.Runtime.InteropServices.Marshal.ReleaseComObject(FilePath);
// System.Runtime.InteropServices.Marshal.ReleaseComObject(FileName );
// System.Runtime.InteropServices.Marshal.ReleaseComObject(pFields );
//System.Runtime.InteropServices.Marshal.ReleaseComObject(pDataSet );
// System.Runtime.InteropServices.Marshal.ReleaseComObject(newFeatcls);
}
/// <summary>
/// Create a polygon feature class used to store buffer geometries for observer points
/// </summary>
/// <param name="featWorkspace">IFeatureWorkspace</param>
/// <param name="spatialRef">ISpatialReference of selected surface</param>
/// <param name="name">Name of the feature class</param>
/// <returns>IFeatureClass</returns>
private static IFeatureClass CreateMaskFeatureClass(IFeatureWorkspace featWorkspace, ISpatialReference spatialRef, string name)
{
IFieldsEdit pFldsEdt = new FieldsClass();
IFieldEdit pFldEdt = new FieldClass();
pFldEdt = new FieldClass();
pFldEdt.Type_2 = esriFieldType.esriFieldTypeOID;
pFldEdt.Name_2 = "OBJECTID";
pFldEdt.AliasName_2 = "OBJECTID";
pFldsEdt.AddField(pFldEdt);
IGeometryDefEdit pGeoDef;
pGeoDef = new GeometryDefClass();
pGeoDef.GeometryType_2 = esriGeometryType.esriGeometryPolygon;
pGeoDef.SpatialReference_2 = spatialRef;
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "SHAPE";
pFldEdt.AliasName_2 = "SHAPE";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeGeometry;
pFldEdt.GeometryDef_2 = pGeoDef;
pFldsEdt.AddField(pFldEdt);
IFeatureClass pFClass = featWorkspace.CreateFeatureClass(name, pFldsEdt, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
return(pFClass);
}
public IFeatureClass CreateFeatureClass(string geometryType)
{
IWorkspaceFactory workspaceFactory = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspaceFactory.OpenFromFile(System.IO.Path.GetTempPath(), 0);
IFeatureClass featureClass;
IFields fields;
UID CLSID = new UIDClass();
CLSID.Value = "esriGeoDatabase.Feature";
IObjectClassDescription objectClassDescription = new FeatureClassDescriptionClass();
// create the fields using the required fields method
fields = objectClassDescription.RequiredFields;
string strShapeField = "";
// locate the shape field
for (int j = 0; j < fields.FieldCount; j++)
{
if (fields.get_Field(j).Type == ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeGeometry)
{
strShapeField = fields.get_Field(j).Name;
}
}
featureClass = featureWorkspace.CreateFeatureClass(tempFeatureLayerName, fields, CLSID, null, esriFeatureType.esriFTSimple, strShapeField, null);
return(featureClass);
}
private IFeature Convert_Point2MultiPoint_Class(IFeatureClass PointFeatureClass)
{
IWorkspaceFactory contourWSF = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace contourFWS = (IFeatureWorkspace)contourWSF.OpenFromFile(WorkSpaceName, 0);
IFields pFields = CreateShapeFields(esriGeometryType.esriGeometryMultipoint);
string filename = PointFeatureClass.AliasName + "_muilti";
string filename_shp = WorkSpaceName + @"/" + filename + ".shp";
if (System.IO.File.Exists(filename_shp))
{
System.IO.File.Delete(filename_shp);
System.IO.File.Delete(System.IO.Path.ChangeExtension(filename_shp, ".dbf"));
System.IO.File.Delete(System.IO.Path.ChangeExtension(filename_shp, ".shx"));
}
contourFWS.CreateFeatureClass(filename, pFields, null, null, esriFeatureType.esriFTSimple, "Shape", null);
IFeatureClass MultiFeatureClass = contourFWS.OpenFeatureClass(filename);
IPointCollection pPointCollection = new MultipointClass();
for (int i = 0; i < PointFeatureClass.FeatureCount(null); i++)
{
IFeature pFeature = PointFeatureClass.GetFeature(i);
IPoint pPoint = pFeature.Shape as IPoint;
pPointCollection.AddPoint(pPoint);
}
IFeature MultiFeature = MultiFeatureClass.CreateFeature();
MultiFeature.Shape = pPointCollection as IGeometry;
MultiFeature.Store();
return(MultiFeature);
}
public static void CreateShpFile(string filePath, string fileName, Field[] fields, ISpatialReference spatialReference, Func <IFeatureClass, bool> featureCreationCallback)
{
fileName = fileName.Replace("/", "");
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactory();
IFields pFields = new Fields();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
IField pField = new Field();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = "Shape";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDef pGeometryDef = new GeometryDef();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pGeometryDefEdit.SpatialReference_2 = spatialReference;
pFieldEdit.GeometryDef_2 = pGeometryDef;
pFieldsEdit.AddField(pField);
foreach (Field f in fields)
{
pFieldsEdit.AddField(f);
}
IFeatureWorkspace pFeatureWorkspace = pWorkspaceFactory.OpenFromFile(filePath, 0) as IFeatureWorkspace;
int i = fileName.IndexOf(".shp");
if (i == -1)
{
pFeatureWorkspace.CreateFeatureClass(fileName + ".shp", pFields, null, null,
esriFeatureType.esriFTSimple, "Shape", "");
}
else
{
pFeatureWorkspace.CreateFeatureClass(fileName, pFields,
null, null, esriFeatureType.esriFTSimple, "Shape", "");
}
//if (featureCreationCallback == null)
//{
IFeatureClass featureClass = pFeatureWorkspace.OpenFeatureClass(fileName);
featureCreationCallback(featureClass);
//}
}
public IFeatureClass CreateShapefile(
string sParentDirectory,
string sWorkspaceName,
string sFileName)
{
if (System.IO.Directory.Exists(sParentDirectory + sWorkspaceName))
{
System.IO.Directory.Delete(sParentDirectory + sWorkspaceName, true);
}
IWorkspaceFactory pWf = new ShapefileWorkspaceFactoryClass();
IWorkspaceName pWn = pWf.Create(sParentDirectory, sWorkspaceName, null, 0);
ESRI.ArcGIS.esriSystem.IName name = pWn as ESRI.ArcGIS.esriSystem.IName;
IWorkspace pW = (IWorkspace)name.Open();
IFeatureWorkspace pFw = pW as IFeatureWorkspace;
IFields pFs = new FieldsClass();
IFieldsEdit pFse = pFs as IFieldsEdit;
IFieldEdit pFe = new FieldClass();
pFe.Name_2 = "OID";
pFe.AliasName_2 = "序号";
pFe.Type_2 = esriFieldType.esriFieldTypeOID;
pFse.AddField((IField)pFe);//IFieldEdit.AddField是AO隐藏属性
pFe = new FieldClass();
pFe.Name_2 = "Name";
pFe.AliasName_2 = "名称";
pFe.Type_2 = esriFieldType.esriFieldTypeString;
pFse.AddField((IField)pFe);
IGeometryDefEdit pGde = new GeometryDefClass();
ISpatialReference pSr = m_map.SpatialReference;
pGde.SpatialReference_2 = pSr;
pGde.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pFe = new FieldClass();
string sShapeFieldName = "Shape";
pFe.Name_2 = sShapeFieldName;
pFe.AliasName_2 = "形状";
pFe.Type_2 = esriFieldType.esriFieldTypeGeometry;
pFe.GeometryDef_2 = pGde;
pFse.AddField((IField)pFe);
IFeatureClass pFc = pFw.CreateFeatureClass(sFileName, pFs, null, null, esriFeatureType.esriFTSimple, "Shape", "");
if (pFc == null)
{
return(null);
}
return(pFc);
}
/// <summary>
///
/// </summary>
/// <param name="workspace"></param>
/// <param name="featureName"></param>
/// <param name="fields"></param>
/// <param name="featuretype"></param>
/// <returns></returns>
public IFeatureClass createFeatureClass(IWorkspace workspace, string featureName, IFields fields, string featuretype)
{
IFeatureWorkspace featureWorkspace = workspace as IFeatureWorkspace;
deleteFeatureClass(workspace, featureName);
IFeatureClass pFtClass = featureWorkspace.CreateFeatureClass(featureName, fields, null, null, esriFeatureType.esriFTSimple, "SHAPE", null);
return(pFtClass);
}
public void Test()
{
//定义一个几何字段，类型为点类型
ISpatialReferenceFactory2 originalSpatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference originalSpatialReference = originalSpatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
IGeometryDefEdit pGeoDef = new GeometryDefClass();
IGeometryDefEdit pGeoDefEdit = pGeoDef as IGeometryDefEdit;
pGeoDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pGeoDefEdit.SpatialReference_2 = originalSpatialReference;
//定义一个字段集合对象
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
//定义shape字段
IField pField = new FieldClass();
IFieldEdit pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SHAPE";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
pFieldsEdit.AddField(pField);
pFieldEdit.GeometryDef_2 = pGeoDef;
//定义单个的字段，并添加到字段集合中
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "STCD";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldsEdit.AddField(pField);
//定义单个的字段，并添加到字段集合中
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SLM10";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldsEdit.AddField(pField);
//定义单个的字段，并添加到字段集合中
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SLM20";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldsEdit.AddField(pField);
//定义单个的字段，并添加到字段集合中
pField = new FieldClass();
pFieldEdit = (IFieldEdit)pField;
pFieldEdit.Name_2 = "SLM40";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
pFieldsEdit.AddField(pField);
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactory();
IFeatureWorkspace pFWS = pWorkspaceFactory.OpenFromFile(workspaceDirectory, 0) as IFeatureWorkspace;
IFeatureClass pFtClass = pFWS.CreateFeatureClass("Test", pFields, null, null, esriFeatureType.esriFTSimple, "SHAPE", null);
}
/// <summary>
/// create a feature class in workspace with type geometry
/// </summary>
/// <param name="geometry">geometry of feature class</param>
/// <param name="featureWorkspace">workspace for store feature class</param>
/// <returns>feature class created</returns>
private IFeatureClass CreateFeatureClass(IGeometry geometry, IFeatureWorkspace featureWorkspace)
{
// Create a fields collection for the feature class.
IFields fields = new FieldsClass();
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
// Add an object ID field to the fields collection. This is mandatory for feature classes.
IField oidField = new FieldClass();
IFieldEdit oidFieldEdit = (IFieldEdit)oidField;
oidFieldEdit.Name_2 = "OID";
oidFieldEdit.Type_2 = esriFieldType.esriFieldTypeOID;
fieldsEdit.AddField(oidField);
IField idField = new FieldClass();
IFieldEdit idFieldEdit = (IFieldEdit)idField;
idFieldEdit.Name_2 = SAUtility.FieldNameIdWatershed;
idFieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger;
fieldsEdit.AddField(idField);
// Create a geometry definition (and spatial reference) for the feature class.
IGeometryDef geometryDef = new GeometryDefClass();
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
geometryDefEdit.GeometryType_2 = geometry.GeometryType;
geometryDefEdit.SpatialReference_2 = geometry.SpatialReference;
IFeatureClassDescription featureClassDescription = new FeatureClassDescriptionClass();
IObjectClassDescription objectClassDescription = (IObjectClassDescription)featureClassDescription;
// Add a geometry field to the fields collection. This is where the geometry definition is applied.
IField geometryField = new FieldClass();
IFieldEdit geometryFieldEdit = (IFieldEdit)geometryField;
geometryFieldEdit.Name_2 = featureClassDescription.ShapeFieldName;
geometryFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
geometryFieldEdit.GeometryDef_2 = geometryDef;
fieldsEdit.AddField(geometryField);
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
// The enumFieldError enumerator can be inspected at this point to determine
// which fields were modified during validation.
// Create the feature class. Note that the CLSID parameter is null - this indicates to use the
// default CLSID, esriGeodatabase.Feature (acceptable in most cases for feature classes).
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass("pourPoint", validatedFields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, featureClassDescription.ShapeFieldName, string.Empty);
return(featureClass);
}
/// <summary>
/// 以旧图层为基础创建新图层要素集合
/// </summary>
/// <param name="featureWorkspace">要素工作空间</param>
/// <param name="selectionLayer">旧图层</param>
/// <param name="newLayerName">新图层名称</param>
/// <returns></returns>
private static IFeatureClass CreateNewFeatureClass(IFeatureWorkspace featureWorkspace,
IFeatureLayer selectionLayer, string newLayerName)
{
IFeatureClass oldFeatureClass = selectionLayer.FeatureClass;
//以旧图层为基础创建新图层要素集合
IFeatureClass newFeatureClass = featureWorkspace.CreateFeatureClass(newLayerName, oldFeatureClass.Fields,
oldFeatureClass.CLSID, oldFeatureClass.EXTCLSID, oldFeatureClass.FeatureType,
oldFeatureClass.ShapeFieldName, "");
return(newFeatureClass);
}
/// <summary>
/// 创建FeatureClass
/// </summary>
/// <param name="Name"></param>
/// <param name="fieldsHelper"></param>
/// <param name="esriFeatureType"></param>
/// <param name="ShapeFieldName"></param>
/// <param name="ConfigKeyword"></param>
public static IFeatureClass CreateFeatureClass(this IFeatureWorkspace workspace, string Name, IFields fields, esriFeatureType type = esriFeatureType.esriFTSimple, string ShapeFieldName = "SHAPE", string ConfigKeyword = "")
{
try
{
return(workspace.CreateFeatureClass(Name, fields, null, null, type, ShapeFieldName, ConfigKeyword));
}
catch (Exception ex)
{
throw new Exception("创建FeatureClass失败", ex);
}
}
/// <summary>
/// Create the point feature class for observer locations
/// </summary>
/// <param name="featWorkspace"></param>
/// <param name="name"></param>
/// <returns></returns>
public static IFeatureClass CreateObserversFeatureClass(IFeatureWorkspace featWorkspace, string name)
{
IFieldsEdit pFldsEdt = new FieldsClass();
IFieldEdit pFldEdt = new FieldClass();
pFldEdt = new FieldClass();
pFldEdt.Type_2 = esriFieldType.esriFieldTypeOID;
pFldEdt.Name_2 = "OBJECTID";
pFldEdt.AliasName_2 = "OBJECTID";
pFldsEdt.AddField(pFldEdt);
IGeometryDefEdit pGeoDef;
pGeoDef = new GeometryDefClass();
pGeoDef.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pGeoDef.SpatialReference_2 = ArcMap.Document.FocusMap.SpatialReference;
pGeoDef.HasZ_2 = true;
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "SHAPE";
pFldEdt.AliasName_2 = "SHAPE";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeGeometry;
pFldEdt.GeometryDef_2 = pGeoDef;
pFldsEdt.AddField(pFldEdt);
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "OFFSETA";
pFldEdt.AliasName_2 = "OFFSETA";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeDouble;
pFldsEdt.AddField(pFldEdt);
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "OFFSETB";
pFldEdt.AliasName_2 = "OFFSETB";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeDouble;
pFldsEdt.AddField(pFldEdt);
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "AZIMUTH1";
pFldEdt.AliasName_2 = "AZIMUTH1";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeDouble;
pFldsEdt.AddField(pFldEdt);
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "AZIMUTH2";
pFldEdt.AliasName_2 = "AZIMUTH2";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeDouble;
pFldsEdt.AddField(pFldEdt);
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "RADIUS1";
pFldEdt.AliasName_2 = "RADIUS1";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeDouble;
pFldsEdt.AddField(pFldEdt);
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "RADIUS2";
pFldEdt.AliasName_2 = "RADIUS2";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeDouble;
pFldsEdt.AddField(pFldEdt);
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "VERT1";
pFldEdt.AliasName_2 = "VERT1";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeDouble;
pFldsEdt.AddField(pFldEdt);
pFldEdt = new FieldClass();
pFldEdt.Name_2 = "VERT2";
pFldEdt.AliasName_2 = "VERT2";
pFldEdt.Type_2 = esriFieldType.esriFieldTypeDouble;
pFldsEdt.AddField(pFldEdt);
IFeatureClass pFClass = featWorkspace.CreateFeatureClass(name, pFldsEdt, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
return pFClass;
}
public IFeatureClass CreateWithoutDescription(String featureClassName, UID classExtensionUID, IFeatureWorkspace featureWorkspace, esriGeometryType geoType, IFields fields)
{
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass
(featureClassName, validatedFields, null, classExtensionUID,
esriFeatureType.esriFTSimple, "Shape", "");
return featureClass;
}
/// <summary>
/// 创建一个新的FeatureClass
/// </summary>
/// <param name="FeatureWorkspace">要素命名空间</param>
/// <param name="Name">名称</param>
/// <param name="esriGeometryType">类型</param>
/// <param name="FieldDict">字段已经类型</param>
/// <returns></returns>
private static IFeatureClass Create(IFeatureWorkspace FeatureWorkspace, string Name, ESRI.ArcGIS.Geometry.esriGeometryType esriGeometryType,Dictionary<string,esriFieldType> FieldDict)
{
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
IField pField = new FieldClass();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = "shape";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDef pGeometryDef = new GeometryDefClass();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = esriGeometryType;
ISpatialReferenceFactory pSpatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference pSpatialReference = pSpatialReferenceFactory.CreateGeographicCoordinateSystem((int)esriSRGeoCSType.esriSRGeoCS_WGS1984);
pSpatialReference.SetDomain(-6000000, 6000000, -6000000, 6000000);
pGeometryDefEdit.SpatialReference_2 = pSpatialReference;
pFieldEdit.GeometryDef_2 = pGeometryDef;
pFieldsEdit.AddField(pField);
pField = new FieldClass();
pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = "FID";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeOID;
pFieldsEdit.AddField(pField);
foreach (var key in FieldDict.Keys)
{
if (key.ToUpper() == "SHAPE"||key.ToUpper()=="OBJECTID")
{
continue;
}
pField = new FieldClass();
pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = key;
pFieldEdit.Type_2 = FieldDict[key];
pFieldsEdit.AddField(pField);
}
IFeatureClassDescription featureClassDescription = new FeatureClassDescriptionClass();
IObjectClassDescription objectClassDescription = featureClassDescription as IObjectClassDescription;
IFeatureClass featureClass = FeatureWorkspace.CreateFeatureClass(Name, pFields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, "shape", "");
return featureClass;
}
private IFeatureClass CreateFeatureClassFromGeometry(IGeometry pGeometry, IFeatureWorkspace pOutFeatWorkspace, int wkid)
{
// thanks to http://bcdcspatial.blogspot.co.uk/2011/12/some-random-arcobjects-that-make.html
// which was the only place i could find an answer to the problem I was having - the last
// argument to createfeatureclass is null NOT an empty string
try
{
IFields tFields = new FieldsClass() as IFields;
IFieldsEdit tFieldsEdit = (IFieldsEdit)tFields;
IField tShpFld = new Field();
IFieldEdit tShpEd = (IFieldEdit)tShpFld;
tShpEd.Type_2 = esriFieldType.esriFieldTypeGeometry;
tShpEd.Name_2 = "Shape";
IGeometryDef tGeomDef = new GeometryDef();
IGeometryDefEdit tGdEdit = (IGeometryDefEdit)tGeomDef;
tGdEdit.GeometryType_2 = pGeometry.GeometryType;
ISpatialReferenceFactory2 tSRFac = new SpatialReferenceEnvironment() as ISpatialReferenceFactory2;
ISpatialReference tSpatRef = tSRFac.CreateSpatialReference(wkid);
ISpatialReferenceResolution tSpatRefRes = (ISpatialReferenceResolution)tSpatRef;
tSpatRefRes.ConstructFromHorizon();
tGdEdit.SpatialReference_2 = tSpatRef;
tShpEd.GeometryDef_2 = tGeomDef;
tFieldsEdit.AddField(tShpFld);
IObjectClassDescription tOCDesc = new FeatureClassDescription();
for (int i = 0; i < tOCDesc.RequiredFields.FieldCount; i++)
{
IField tField = tOCDesc.RequiredFields.get_Field(i);
if (tFieldsEdit.FindField(tField.Name) == -1)
{
tFieldsEdit.AddField(tField);
}
}
string tFCName = "tmp" + Guid.NewGuid().ToString("N");
IFeatureClass tFC = pOutFeatWorkspace.CreateFeatureClass(
tFCName, tFields, null, null, esriFeatureType.esriFTSimple, "Shape", null);
IFeature tGeomAsFeature = tFC.CreateFeature();
tGeomAsFeature.Shape = pGeometry;
tGeomAsFeature.Store();
return tFC;
}
catch (Exception e)
{
Console.WriteLine(e.Message);
logger.LogMessage(ServerLogger.msgType.error, "CreateFeatureClassFromGeometry", 99,
"Could not create feature class " + e.Message + e.Source + e.StackTrace);
throw e;
}
}
static void CopyAndLabel(IFeatureClass inFC, IFeatureWorkspace destination, String name)
{
IFieldsEdit outFields = new FieldsClass();
ISpatialReference outSR = null;
for (int i = 0; i < inFC.Fields.FieldCount; i += 1) {
IField field = inFC.Fields.get_Field(i);
if (field.Type == esriFieldType.esriFieldTypeGeometry) {
outSR = field.GeometryDef.SpatialReference;
} else {
outFields.AddField(field);
}
}
outSR.SetMDomain(-137434824702, 137434824702);
IGeometryDefEdit geom = new GeometryDefClass();
geom.GeometryType_2 = esriGeometryType.esriGeometryPolygon;
geom.SpatialReference_2 = outSR;
geom.HasM_2 = true;
geom.HasZ_2 = false;
IFieldEdit geomField = new FieldClass();
geomField.Name_2 = "SHAPE";
geomField.AliasName_2 = "SHAPE";
geomField.Type_2 = esriFieldType.esriFieldTypeGeometry;
geomField.GeometryDef_2 = geom;
outFields.AddField(geomField);
IFeatureClass outFC = destination.CreateFeatureClass(name, outFields, null, null, esriFeatureType.esriFTSimple, "SHAPE", "");
// Start numbering from 1, because index 0 is used by clipping cell
int vIndex = 1;
IFeatureCursor featureCursor = inFC.Search(null, true);
IFeature inFeature;
while ((inFeature = featureCursor.NextFeature()) != null) {
IFeature outFeature = outFC.CreateFeature();
for (int i = 0; i < outFields.FieldCount; i += 1) {
IField field = outFields.Field[i];
if (field.Editable && (field.Type != esriFieldType.esriFieldTypeGeometry)) {
outFeature.set_Value(i, inFeature.get_Value(i));
}
}
IPolygon4 inShape = inFeature.Shape as IPolygon4;
PolygonClass outShape = new PolygonClass();
IGeometryBag extRingBag = inShape.ExteriorRingBag;
IGeometryCollection extRings = extRingBag as IGeometryCollection;
for (int i = 0; i < extRings.GeometryCount; i += 1) {
IGeometry inExtRingGeom = extRings.get_Geometry(i);
IPointCollection inExtRing = inExtRingGeom as IPointCollection;
RingClass outExtRing = new RingClass();
for (int j = 0; j < inExtRing.PointCount; j += 1) {
IPoint point = inExtRing.get_Point(j);
point.M = vIndex;
vIndex += 2;
outExtRing.AddPoint(point);
}
outShape.AddGeometry(outExtRing);
IGeometryBag intRingBag = inShape.get_InteriorRingBag(inExtRingGeom as IRing);
IGeometryCollection intRings = intRingBag as IGeometryCollection;
for (int j = 0; j < intRings.GeometryCount; j += 1) {
IGeometry intRingGeom = intRings.get_Geometry(j);
IPointCollection inIntRing = intRingGeom as IPointCollection;
RingClass outIntRing = new RingClass();
for (int k = 0; k < inIntRing.PointCount; k += 1) {
IPoint point = inExtRing.get_Point(k);
point.M = vIndex;
vIndex += 2;
outIntRing.AddPoint(point);
}
outShape.AddGeometry(outIntRing);
}
}
outFeature.Shape = outShape;
outFeature.Store();
}
}
private IFeatureClass CreateFeatureClass(string Name, IFeatureWorkspace FeatureWorkspace)
{
//The feature that will be returned
IFeatureClass featureClassCreated;
//Create the filed for the histogram and the fields to be created in the future class
IObjectClassDescription objectClassDescription = new FeatureClassDescription();
IFields fields = objectClassDescription.RequiredFields;
IFieldsEdit fieldsEdit = fields as IFieldsEdit;
IField field = new Field();
IFieldEdit fieldEdit = field as IFieldEdit;
fieldEdit.AliasName_2 = "HistoField";
fieldEdit.Name_2 = "HistoField";
fieldEdit.Editable_2 = true;
fieldEdit.Type_2 = esriFieldType.esriFieldTypeInteger;
fieldsEdit.AddField(field);
fields = fieldsEdit as IFields;
//Create and assugn a CLSID
UID CLSID = new UIDClass();
CLSID.Value = "esriGeodatabase.Feature";
string strShapeField = "";
//Find the geometry field and then set the spatial reference and the geometry type.
for (int i = 0; i < fields.FieldCount; i++)
{
if (fields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
strShapeField = fields.get_Field(i).Name;
IGeometryDef geomDef = fields.get_Field(i).GeometryDef;
IGeometryDefEdit geomDefEdit = (IGeometryDefEdit)geomDef;
geomDefEdit.SpatialReference_2 = getSpatialReference(4326);
geomDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
break;
}
}
//If the file exists, overwrite it, otherwise create a new one.
if (((IWorkspace2)FeatureWorkspace).NameExists[esriDatasetType.esriDTFeatureClass, Name])
{
IDataset dataset = FeatureWorkspace.OpenFeatureClass(Name) as IDataset;
dataset.Delete();
featureClassCreated = FeatureWorkspace.CreateFeatureClass(Name, fields, CLSID, null, esriFeatureType.esriFTSimple, strShapeField, "");
}
else
{
featureClassCreated = FeatureWorkspace.CreateFeatureClass(Name, fields, CLSID, null, esriFeatureType.esriFTSimple, strShapeField, "");
}
return featureClassCreated;
}
/// <summary>
/// Add Feature class and its feilds
/// </summary>
/// <param name="featureClassName"></param>
/// <param name="featureWorkspace"></param>
/// <returns></returns>
public IFeatureClass CreateFeatureClassWithFields(String featureClassName, IFeatureWorkspace featureWorkspace, string dir)
{
GeoJson geoJson = new GeoJson();
try
{
_featureInJSON = geoJson.readGeoJsonFile(dir);
// Instantiate a feature class description to get the required fields.
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
IObjectClassDescription ocDescription = (IObjectClassDescription)
fcDescription;
IFields fields = ocDescription.RequiredFields;
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
for (int i = 0; i < 9; i++)
{
if (_featureInJSON.fields[i].name == "OBJECTID")
continue;
else
addFeatureFeild(_featureInJSON.fields[i].name, _featureInJSON.fields[i].alias, (esriFieldType)Enum.Parse(typeof(esriFieldType), _featureInJSON.fields[i].type), fieldsEdit);
}
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
// The enumFieldError enumerator can be inspected at this point to determine
// which fields were modified during validation.
// Create the feature class.
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass
(featureClassName, validatedFields, ocDescription.InstanceCLSID,
ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple,
fcDescription.ShapeFieldName, "");
return featureClass;
}
catch (Exception e)
{
Log.WriteLine("CreateFeatureClassWithFields: " + e.Message);
}
return null;
}
//http://resources.esri.com/help/9.3/arcgisengine/arcobjects/esriGeoDatabase/IFeatureWorkspace.CreateFeatureClass_Example.htm
static IFeatureClass CreateFeatureClass(string name, IFeatureWorkspace ftrSpc, esriGeometryType type, int epsg, List<dynamic> extraFields)
{
IFeatureClass ftrc = null;
if(null != ftrSpc && null != name)
{
IFieldsEdit flds = new FieldsClass();
flds.FieldCount_2 = 2 + (extraFields == null ? 0 : extraFields.Count);
IFieldEdit fld = new FieldClass();
fld.Name_2 = OBJECT_ID;
fld.Type_2 = esriFieldType.esriFieldTypeOID;
flds.Field_2[0] = fld;
fld = new FieldClass();
fld.Name_2 = SHP_NAME;
fld.Type_2 = esriFieldType.esriFieldTypeGeometry;
fld.GeometryDef_2 = CreateGeometryDef(type, epsg);
flds.Field_2[1] = fld;
int eidx = 2;
foreach(var efld in extraFields)
{
fld = new FieldClass();
fld.Name_2 = efld.Name;
fld.Type_2 = efld.Type;
flds.Field_2[eidx++] = fld;
}
ftrc = ftrSpc.CreateFeatureClass(name, flds, null, null, esriFeatureType.esriFTSimple, SHP_NAME, null);
}
return ftrc;
}
public IFeatureClass CreateFeatureClassWithFieldsGeoRef(String featureClassName, IFeatureWorkspace featureWorkspace)
{
GeoJson geoJson = new GeoJson();
try
{
// Instantiate a feature class description to get the required fields.
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
IObjectClassDescription ocDescription = (IObjectClassDescription)
fcDescription;
IFields fields = ocDescription.RequiredFields;
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
addFeatureFeild("URI", "URI", esriFieldType.esriFieldTypeString, fieldsEdit);
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)featureWorkspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
// The enumFieldError enumerator can be inspected at this point to determine
// which fields were modified during validation.
// Create the feature class.
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass
(featureClassName, validatedFields, ocDescription.InstanceCLSID,
ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple,
fcDescription.ShapeFieldName, "");
return featureClass;
}
catch (Exception e)
{
Log.WriteLine("CreateFeatureClassWithFields: " + e.Message);
}
return null;
}
