private static ITable CreateTable(IWorkspace2 workspace, string tableName, IFields fields)
{
UID uid = new UIDClass {
Value = "esriGeoDatabase.Object"
};
if (workspace == null)
{
return(null);
}
IFeatureWorkspace featWorkspace = (IFeatureWorkspace)workspace;
if (workspace.NameExists[esriDatasetType.esriDTTable, tableName])
{
using (ComReleaser releaser = new ComReleaser())
{
ITable table = featWorkspace.OpenTable(tableName);
releaser.ManageLifetime(table);
((IDataset)table).Delete();
}
}
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = workspace as IWorkspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
return(featWorkspace.CreateTable(tableName, validatedFields, uid, null, string.Empty));
}
/// <summary>
/// Creates fields for Voyage table.
/// </summary>
/// <param name="GDBWorkspace"></param>
/// <returns></returns>
public static IFields createVoyageFields(IWorkspace GDBWorkspace)
{
try
{
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
pFieldsEdit.AddField(createField("OID", esriFieldType.esriFieldTypeOID));
pFieldsEdit.AddField(createField("VoyageID", esriFieldType.esriFieldTypeInteger));
pFieldsEdit.AddField(createField("Destination", esriFieldType.esriFieldTypeString));
pFieldsEdit.AddField(createField("Cargo", esriFieldType.esriFieldTypeInteger));
pFieldsEdit.AddField(createField("Draught", esriFieldType.esriFieldTypeInteger));
pFieldsEdit.AddField(createField("ETA", esriFieldType.esriFieldTypeDate));
pFieldsEdit.AddField(createField("StartTime", esriFieldType.esriFieldTypeDate));
pFieldsEdit.AddField(createField("EndTime", esriFieldType.esriFieldTypeDate));
pFieldsEdit.AddField(createField("MMSI", esriFieldType.esriFieldTypeInteger));
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)GDBWorkspace;
fieldChecker.Validate(pFields, out enumFieldError, out validatedFields);
return(pFields);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\n\n" + ex.StackTrace, "AIS_Menu:Utilities:createVoyageFields");
return(null);
}
}
//格式转换后，检验字段的有效性并修复字段 YH 15/4/09
public static bool FieldsCheckAfterTransaction(IWorkspace pInputWorkspace, IWorkspace pOutPutWorkspace, IFields pInputFields, ref IFields pOoutPutFields)
{
bool functionReturnValue = false;
IFieldChecker pFieldChecker = default(IFieldChecker);
IEnumFieldError pEnumFieldError = null;
pFieldChecker = new FieldChecker();
pFieldChecker.InputWorkspace = pInputWorkspace;
pFieldChecker.ValidateWorkspace = pOutPutWorkspace;
pFieldChecker.Validate(pInputFields, out pEnumFieldError, out pOoutPutFields);
//处理字段中不符合语义规则的情况
if ((pEnumFieldError != null))
{
pEnumFieldError.Reset();
IFieldError pFieldError = default(IFieldError);
pFieldError = pEnumFieldError.Next();
//g_clsErrorHandle.DisplayInformation("导出字段中存在无效字段: " + pOoutPutFields.Field(pFieldError.FieldIndex).Name + "导出终止!!", false);
MessageBoxEx.Show("导出字段中存在无效字段: " + pOoutPutFields.get_Field(pFieldError.FieldIndex).Name + "导出终止!!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return(false);
return(functionReturnValue);
}
return(true);
return(functionReturnValue);
}
/// <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);
}
/// <summary>
/// 创建表
/// </summary>
/// <param name="workspace"></param>
/// <param name="tableName"></param>
/// <param name="fields"></param>
/// <returns></returns>
public ITable CreateTable(IWorkspace2 workspace, string tableName, IFields fields)
{
UID uid = new UIDClass();
if (workspace == null)
{
return(null);
}
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
ITable table;
if (workspace.get_NameExists(esriDatasetType.esriDTTable, tableName))
{
table = featureWorkspace.OpenTable(tableName);
return(table);
}
uid.Value = "esriGeoDatabase.Object";
if (fields == null)
{
return(null);
}
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)workspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
table = featureWorkspace.CreateTable(tableName, validatedFields, uid, null, "");
return(table);
}
/// <summary>
/// 检验字段合理性
/// </summary>
/// <param name="targetWorkspace">目标工作空间</param>
/// <param name="isReset">是否使用检验结果重置目标字段</param>
/// <returns>是否通过字段检验，若不通过则错误信息可通过ErrorMessage属性获取</returns>
public bool ValidateFields(IWorkspace targetWorkspace, bool isReset)
{
IFieldChecker pFieldChecker = new FieldChecker();
IEnumFieldError pEnumFieldError = null;
IFields validateFilelds = null;
pFieldChecker.ValidateWorkspace = targetWorkspace;
pFieldChecker.Validate(m_Fields, out pEnumFieldError, out validateFilelds);
if (pEnumFieldError != null)
{
IList <string> result = new List <string>();
IFieldError error = pEnumFieldError.Next();
while (error != null)
{
result.Add(string.Format("字段 {0} 出错，原因为 :{1}", m_Fields.Field[error.FieldIndex].Name, error.FieldError.ToString()));
error = pEnumFieldError.Next();
}
ErrorMessage = string.Join(";", result);
if (isReset)
{
ResetFields(validateFilelds);
}
return(false);
}
return(true);
}
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", ""));
}
/// <summary>
/// Creates the fields for the AttributeUnits table.
/// </summary>
/// <param name="pWorkspace">FileGeodatabase workspace.</param>
/// <returns>List of fields.</returns>
private IFields CreateUnitsFields(IWorkspace pWorkspace)
{
try
{
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
pFieldsEdit.AddField(createField("OID", esriFieldType.esriFieldTypeOID));
pFieldsEdit.AddField(createField("Attribute", esriFieldType.esriFieldTypeString));
pFieldsEdit.AddField(createField("Unit", esriFieldType.esriFieldTypeString));
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)pWorkspace;
fieldChecker.Validate(pFields, out enumFieldError, out validatedFields);
return(pFields);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
return(null);
}
}
/// <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>
/// <param name="pClass"></param>
/// <param name="pTargetWks"></param>
/// <param name="sError"></param>
/// <returns></returns>
public bool CheckFields(IClass pClass, IWorkspace pTargetWks, out IFields ResultFields)
{
ResultFields = null;
IFields sourceFields = pClass.Fields;
string sTableName = (pClass as IDataset).Name;
if (sTableName.IndexOf('.') > 0)
{
//面积字段
string sAreaFieldName = sTableName + ".AREA";
int iAreaIndex = sourceFields.FindField(sAreaFieldName);
if (iAreaIndex >= 0)
{
IFieldEdit fieldEdit = sourceFields.get_Field(iAreaIndex) as IFieldEdit;
fieldEdit.Name_2 = "AREA";
fieldEdit.AliasName_2 = "面积";
}
//长度字段
string sLenFieldName = sTableName + ".LEN";
int iLenIndex = sourceFields.FindField(sLenFieldName);
if (iLenIndex >= 0)
{
IFieldEdit fieldEdit = sourceFields.get_Field(iLenIndex) as IFieldEdit;
fieldEdit.Name_2 = "LEN";
fieldEdit.AliasName_2 = "长度";
}
}
// 创建字段检查对象
IFieldChecker pFieldChecker = new FieldChecker();
pFieldChecker.InputWorkspace = (pClass as IDataset).Workspace;
pFieldChecker.ValidateWorkspace = pTargetWks;
// 验证字段
IEnumFieldError pEnumFieldError = null;
try
{
ErrorMessage = "";
IList <string> tempError = new List <string>();
pFieldChecker.Validate(sourceFields, out pEnumFieldError, out ResultFields);
if (pEnumFieldError != null)
{
IFieldError pFieldError = null;
while ((pFieldError = pEnumFieldError.Next()) != null)
{
tempError.Add(sourceFields.get_Field(pFieldError.FieldIndex).Name + GetFieldNameError(pFieldError.FieldError));
}
}
ErrorMessage = string.Join(",", tempError);
}
finally
{
if (pEnumFieldError != null)
{
Marshal.ReleaseComObject(pEnumFieldError);
}
Marshal.ReleaseComObject(pFieldChecker);
}
return(string.IsNullOrEmpty(ErrorMessage));
}
/// <summary>
/// Creates fields for BaseStation table.
/// </summary>
/// <param name="GDBWorkspace"></param>
/// <returns></returns>
public static IFields createBaseStationFields(IWorkspace GDBWorkspace)
{
try
{
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
pFieldsEdit.AddField(createField("OID", esriFieldType.esriFieldTypeOID));
//pFieldsEdit.AddField(createIntegerField("VesselID"));
pFieldsEdit.AddField(createField("MMSI", esriFieldType.esriFieldTypeInteger));
pFieldsEdit.AddField(createField("Longitude", esriFieldType.esriFieldTypeDouble));
pFieldsEdit.AddField(createField("Latitude", esriFieldType.esriFieldTypeDouble));
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)GDBWorkspace;
fieldChecker.Validate(pFields, out enumFieldError, out validatedFields);
return(pFields);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\n\n" + ex.StackTrace, "AIS_Menu:Utilities:createVesselFields");
return(null);
}
}
/// <summary>
/// Transfers data from an input FeatureClass to an output FeatureClass with data filtered with the specified query filter.
/// </summary>
/// <param name="inputWorkspace">The input workspace.</param>
/// <param name="inputFeatureClassName">Name of the input feature class.</param>
/// <param name="outputWorkspace">The output workspace.</param>
/// <param name="outputFeatureClassName">Name of the output feature class.</param>
/// <param name="outputFeatureDatasetName">The output FeatureDataset</param>
/// <param name="queryFilter">The query filter used to filter data to be transfered.</param>
public static IEnumInvalidObject TransferData(IFeatureWorkspace inputWorkspace, IFeatureClass inputFeatureClass, IFeatureWorkspace outputWorkspace, IFeatureClassName outputFeatureClassName, IFeatureDatasetName outputFeatureDatasetName, IQueryFilter queryFilter, ISpatialReference outputSpatialReference)
{
if (inputWorkspace == null)
{
throw new ArgumentNullException("A valid input feature workspace reference [inputWorkspace] is required.");
}
if (inputFeatureClass == null)
{
throw new ArgumentNullException("A valid input featureclass [inputFeatureClass] is required.");
}
if (outputWorkspace == null)
{
throw new ArgumentNullException("A valid output feature workspace reference [outputWorkspace] is required.");
}
if (outputFeatureClassName == null)
{
throw new ArgumentNullException("A valid output featureclass name reference [outputFeatureClassName] is required.");
}
IDataset dataset = (IDataset)inputFeatureClass;
IFeatureClassName inputFeatureClassName = (IFeatureClassName)dataset.FullName;
IEnumFieldError error = null;
IFields outFields = null;
IFields inFields = inputFeatureClass.Fields;
FieldCheckerClass fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = (IWorkspace)inputWorkspace;
fieldChecker.ValidateWorkspace = (IWorkspace)outputWorkspace;
fieldChecker.Validate(inFields, out error, out outFields);
IField shapeField = null;
for (int i = 0; i < outFields.FieldCount; i++)
{
if (outFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
shapeField = outFields.get_Field(i);
break;
}
}
IGeometryDef shapeGeoDef = shapeField.GeometryDef;
IGeometryDefEdit shapeGeoDefEdit = shapeGeoDef as IGeometryDefEdit;
shapeGeoDefEdit.GridCount_2 = 1;
shapeGeoDefEdit.set_GridSize(0, DefaultIndexGrid(ref inputFeatureClass));
shapeGeoDefEdit.SpatialReference_2 = outputSpatialReference;
FeatureDataConverterClass fdc = new FeatureDataConverterClass();
return(fdc.ConvertFeatureClass(inputFeatureClassName, queryFilter, outputFeatureDatasetName, outputFeatureClassName, shapeGeoDefEdit, outFields, "", 1000, 0));
}
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));
}
}
/// <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);
}
private void validateFields(ref IFields shpFields, ref IFields covFields, ref IEnumFieldError enumError)
{
IFieldChecker fChecker = new FieldCheckerClass();
fChecker.Validate(shpFields, out enumError, out covFields);
if (enumError != null)
{
System.Windows.Forms.MessageBox.Show("error on validate fields");
}
}
private void button2_Click(object sender, EventArgs e)
{
//工作空间
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace pFeatureWorkspace = pWorkspaceFactory.OpenFromFile(pFilePath, 0) as IFeatureWorkspace;
//创建字段集2
IFeatureClassDescription fcDescription = new FeatureClassDescriptionClass();
//创建必要字段
IObjectClassDescription ocDescription = (IObjectClassDescription)fcDescription;
//必要字段
IFields pFields = new FieldsClass();
pFields = ocDescription.RequiredFields;
//要素类的几何类型、坐标系
int shapeFileIndex = pFields.FindField(fcDescription.ShapeFieldName);
IField pField = pFields.get_Field(shapeFileIndex);
IGeometryDef pGeometryDef = pField.GeometryDef;
IGeometryDefEdit pGeometryDefEdit = (IGeometryDefEdit)pGeometryDef;
pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
ISpatialReferenceFactory pSpatialReferenceFactory = new SpatialReferenceEnvironmentClass();
//更改为可选的坐标系
IProjectedCoordinateSystem pProjectedCoordinateSystem = pSpatialReferenceFactory.CreateProjectedCoordinateSystem(
(int)esriSRProjCS4Type.esriSRProjCS_Xian1980_GK_Zone_21);
pGeometryDefEdit.SpatialReference_2 = pProjectedCoordinateSystem;
//自定义字段
IFieldsEdit pFieldsEdit = (IFieldsEdit)pFields;
addField(pFieldsEdit, "FID");
addField(pFieldsEdit, "Row");
addField(pFieldsEdit, "Column");
addField(pFieldsEdit, "Number");
//传入字段
IFieldChecker pFieldChecker = new FieldCheckerClass();
IEnumFieldError pEnumFieldError = null;
IFields validatedFields = null;
pFieldChecker.ValidateWorkspace = (IWorkspace)pFeatureWorkspace;
pFieldChecker.Validate(pFields, out pEnumFieldError, out validatedFields);
//创建要素类
IFeatureClass pFeatureClass = pFeatureWorkspace.CreateFeatureClass(pFileName, validatedFields
, ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDescription.ShapeFieldName, "");
MessageBox.Show("创建要素类成功");
}
/// <summary>
/// 对表MatchedPolygonFCSettingDif进行判断处理
/// </summary>
/// <param name="workspace"></param>
/// <param name="table"></param>
/// <param name="featureWorkspace"></param>
/// <returns></returns>
private ITable TableExist(IWorkspace2 workspace, ITable table, IFeatureWorkspace featureWorkspace)
{
IFields fields;
//匹配参数表是否存在，存在则打开表并删除相关记录
if (workspace.get_NameExists(esriDatasetType.esriDTTable, ClsConstant.polygonSettingTable))
{
table = featureWorkspace.OpenTable(ClsConstant.polygonSettingTable);
IWorkspaceEdit workspaceEdit = workspace as IWorkspaceEdit;
workspaceEdit.StartEditing(true);
workspaceEdit.StartEditOperation();
ICursor cursor = table.Search(null, false);
IRow r = cursor.NextRow();
while (r != null)
{
r.Delete();
r = cursor.NextRow();
}
workspaceEdit.StopEditOperation();
workspaceEdit.StopEditing(true);
//ClsDeleteTables.DeleteFeatureClass(gdbPath, ClsConstant.lineSettingTable);
//fields = CreateMatchedPolylineFCSettingFields(workspace);
//UID uid = new UIDClass();
//uid.Value = "esriGeoDatabase.Object";
//IFieldChecker fieldChecker = new FieldCheckerClass();
//IEnumFieldError enumFieldError = null;
//IFields validatedFields = null;
//fieldChecker.ValidateWorkspace = (IWorkspace)workspace;
//fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
//table = featureWorkspace.CreateTable(ClsConstant.lineSettingTable, validatedFields, uid, null, "");
}
//匹配参数表是否存在，不存在则创建表
else
{
//返回MatchedPolygonFCSettingDif的所有字段集
fields = CreateMatchedPolygonFCSettingFields(workspace);
UID uid = new UIDClass();
uid.Value = "esriGeoDatabase.Object";
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)workspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
//创建表MatchedPolygonFCSettingDif
table = featureWorkspace.CreateTable(ClsConstant.polygonSettingTable, validatedFields, uid, null, "");
}
return(table);
}
/// <summary>
/// 将Shapefile导入到数据库
/// </summary>
/// <param name="pFeaClass"></param>
/// <param name="pWorkspace"></param>
/// <param name="tFeatureClass"></param>
private void importToDB(IFeatureClass pFeaClass, IWorkspace pWorkspace, IFeatureDataset tFeatureClass, string SHPName)
{
IFeatureClassDescription featureClassDescription = new FeatureClassDescriptionClass();
IObjectClassDescription objectClassDescription = featureClassDescription as IObjectClassDescription;
IFields pFields = pFeaClass.Fields;
IFieldChecker pFieldChecker = new FieldCheckerClass();
IEnumFieldError pEnumFieldError = null;
IFields vFields = null;
pFieldChecker.ValidateWorkspace = pWorkspace as IWorkspace;
pFieldChecker.Validate(pFields, out pEnumFieldError, out vFields);
IFeatureWorkspace featureWorkspace = pWorkspace as IFeatureWorkspace;
IFeatureClass sdeFeatureClass = null;
if (sdeFeatureClass == null)
{
sdeFeatureClass = tFeatureClass.CreateFeatureClass(SHPName, vFields,
objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID,
pFeaClass.FeatureType, pFeaClass.ShapeFieldName, "");
IFeatureCursor featureCursor = pFeaClass.Search(null, true);
IFeature feature = featureCursor.NextFeature();
IFeatureCursor sdeFeatureCursor = sdeFeatureClass.Insert(true);
IFeatureBuffer sdeFeatureBuffer;
while (feature != null)
{
sdeFeatureBuffer = sdeFeatureClass.CreateFeatureBuffer();
IField shpField = new FieldClass();
IFields shpFields = feature.Fields;
for (int i = 0; i < shpFields.FieldCount; i++)
{
shpField = shpFields.get_Field(i);
if (shpField.Name.Contains("Area") || shpField.Name.Contains("Leng") || shpField.Name.Contains("FID"))
{
continue;
}
int index = sdeFeatureBuffer.Fields.FindField(shpField.Name);
if (index != -1)
{
sdeFeatureBuffer.set_Value(index, feature.get_Value(i));
}
}
sdeFeatureCursor.InsertFeature(sdeFeatureBuffer);
sdeFeatureCursor.Flush();
feature = featureCursor.NextFeature();
}
featureCursor.Flush();
Marshal.ReleaseComObject(feature);
Marshal.ReleaseComObject(featureCursor);
}
}
public static bool CreateLogTable()
{
if (m_sysTable == null)
{
return(false);
}
//InitStaticFields();
Exception err;
ITable pTable = m_sysTable.OpenTable(m_LogNAME, out err);
if (pTable != null)
{
return(true);//若日志表已存在，返回true
}
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
IField pField = new FieldClass();
IFieldEdit pEdit = pField as IFieldEdit;
pEdit.Name_2 = "logTime";
pEdit.Type_2 = esriFieldType.esriFieldTypeString;
pEdit.Length_2 = 30;
pFieldsEdit.AddField(pField);
pField = new FieldClass();
pEdit = pField as IFieldEdit;
pEdit.Name_2 = "logUser";
pEdit.Type_2 = esriFieldType.esriFieldTypeString;
pEdit.Length_2 = 50;
pFieldsEdit.AddField(pField);
pField = new FieldClass();
pEdit = pField as IFieldEdit;
pEdit.Name_2 = "logIP";
pEdit.Type_2 = esriFieldType.esriFieldTypeString;
pEdit.Length_2 = 30;
pFieldsEdit.AddField(pField);
pField = new FieldClass();
pEdit = pField as IFieldEdit;
pEdit.Name_2 = "logEVENT";
pEdit.Type_2 = esriFieldType.esriFieldTypeString;
pEdit.Length_2 = 255;
pFieldsEdit.AddField(pField);
IFieldChecker pFieldChecker = new FieldCheckerClass();//检查字段有效性
pFieldChecker.ValidateWorkspace = m_gisDb.WorkSpace;
IFields pValidFields = null;
IEnumFieldError pEFE = null;
pFieldChecker.Validate(pFields, out pEFE, out pValidFields);
return(m_sysTable.CreateTable(m_LogNAME, pValidFields, out err));
}
private IFeatureClass CreateShapeFile(string strOutFileSource, string strOutFileName, ISpatialReference spatialReference, esriGeometryType pGeometryType)
{
try
{
//Setting Output Data
IWorkspaceFactory wsfOutput = new ShapefileWorkspaceFactoryClass();
IWorkspace wsOutput = wsfOutput.OpenFromFile(strOutFileSource, 0);
IFeatureWorkspace fwOutput = wsOutput as IFeatureWorkspace;
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
IField oidField = new FieldClass();
IFieldEdit oidFieldEdit = (IFieldEdit)oidField;
oidFieldEdit.Name_2 = "OID";
oidFieldEdit.Type_2 = esriFieldType.esriFieldTypeOID;
pFieldsEdit.AddField(oidField);
IGeometryDef geometryDef = new GeometryDefClass();
IGeometryDefEdit geometryDefEdit = (IGeometryDefEdit)geometryDef;
geometryDefEdit.GeometryType_2 = pGeometryType;
if (spatialReference != null)
{
geometryDefEdit.SpatialReference_2 = spatialReference;
}
IField geometryField = new FieldClass();
IFieldEdit geometryFieldEdit = (IFieldEdit)geometryField;
geometryFieldEdit.Name_2 = "Shape";
geometryFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
geometryFieldEdit.GeometryDef_2 = geometryDef;
pFieldsEdit.AddField(geometryField);
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)fwOutput;
fieldChecker.Validate(pFields, out enumFieldError, out validatedFields);
IFeatureClass fcOutput = fwOutput.CreateFeatureClass(strOutFileName, validatedFields, null, null, esriFeatureType.esriFTSimple, "Shape", "");
return(fcOutput);
}
catch (Exception ex)
{
MessageBox.Show("Fail to create a new shapefile.");
return(null);
}
}
private IFeatureClass CreateNewFeatureClass(IWorkspace pWS, String featureClassName, IFields pFields, esriFeatureType pEsriFeatureType)
{
IFeatureClassDescription fcDesc = new FeatureClassDescriptionClass();
IObjectClassDescription ocDesc = fcDesc as IObjectClassDescription;
IFieldChecker pFieldChecker = new FieldCheckerClass();
IEnumFieldError pEnumFieldError = null;
IFields validatedFields = null;
IFeatureWorkspace pFeatureWorkspace = pWS as IFeatureWorkspace;
pFieldChecker.ValidateWorkspace = pWS;
pFieldChecker.Validate(pFields, out pEnumFieldError, out validatedFields);
IFeatureClass pFeatureClass = pFeatureWorkspace.CreateFeatureClass(featureClassName, validatedFields, ocDesc.InstanceCLSID, ocDesc.ClassExtensionCLSID, pEsriFeatureType, fcDesc.ShapeFieldName, "");
return(pFeatureClass);
}
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);
}
public static IFields ValidateFields(IWorkspace workspace, IFields fields)
{
// Create and initialize a field checker.
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.ValidateWorkspace = workspace;
// Generate a validated fields collection.
IFields validatedFields = null;
IEnumFieldError enumFieldError = null;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
// Return the validated fields.
return(validatedFields);
}
/// <summary>
/// 创建属性表
/// </summary>
/// <param name="pFeatureWorkspace"></param>
/// <param name="tableStructureNode"></param>
/// <param name="featureCodeNode"></param>
/// <returns></returns>
private TableLayer CreateTableLayer(IFeatureWorkspace pFeatureWorkspace, TableStructureNode tableStructureNode, FeatureCodeNode featureCodeNode)
{
try
{
if (pFeatureWorkspace != null&&tableStructureNode!=null&&featureCodeNode!=null)
{
IObjectClassDescription ocDescription = new ObjectClassDescriptionClass();
///创建数据表字段
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields validatedFields = CreateFileds(tableStructureNode, featureCodeNode);
///字段信息验证
IFields fixFields = null;
fieldChecker.ValidateWorkspace = pFeatureWorkspace as IWorkspace;
IEnumFieldError enumFieldError = null;
fieldChecker.Validate(validatedFields, out enumFieldError, out fixFields);
ITable pTable = pFeatureWorkspace.CreateTable(tableStructureNode.TableName, fixFields,
ocDescription.InstanceCLSID, null, "");
if (pTable != null)
{
TableLayer pTableLayer = new TableLayer();
//从配置文件读取图形类型
string sGeometryType = "";
Metadata.MetaTable pMetaTalbe = Metadata.MetaDataFile.MetaTabls[tableStructureNode.TableName] as Metadata.MetaTable;
if (pMetaTalbe != null)
{
sGeometryType = pMetaTalbe.Type;
}
else
return null;
pTableLayer.GeometryType = sGeometryType;
pTableLayer.Table = pTable;
pTableLayer.UpdateFieldIndex();
return pTableLayer;
}
return null;
}
return null;
}
catch (Exception ex)
{
Logger.WriteErrorLog(ex);
return null;
}
}
public void FclssToShp(IFeatureClass fteClss, string lsshp)
{
if (fteClss == null || string.IsNullOrEmpty(lsshp))
{
return;
}
string filename = System.IO.Path.GetFileName(lsshp);
string filepath = System.IO.Path.GetDirectoryName(lsshp);
if (!System.IO.Directory.Exists(filepath))
{
System.IO.Directory.CreateDirectory(filepath);
}
//释放空间
using (ComReleaser comreleaser = new ComReleaser())
{
IDataset indataset = fteClss as IDataset;
IWorkspaceFactory pWorkfactory = new ShapefileWorkspaceFactoryClass();
IFeatureWorkspace fteWsp = pWorkfactory.OpenFromFile(filepath, 0) as IFeatureWorkspace;
IWorkspace inwsp = indataset.Workspace;
IFeatureClassName inFCName = indataset.FullName as IFeatureClassName;
//
IWorkspace outWsp = fteWsp as IWorkspace;
IDataset outdataset = outWsp as IDataset;
IWorkspaceName outWspName = outdataset.FullName as IWorkspaceName;
IFeatureClassName outFCName = new FeatureClassNameClass();
IDatasetName outDstName = outFCName as IDatasetName;
outDstName.WorkspaceName = outWspName;
outDstName.Name = fteClss.AliasName.ToString();
//检查字段的合法性
IFieldChecker checker = new FieldCheckerClass();
checker.InputWorkspace = inwsp;
checker.ValidateWorkspace = outWsp;
IFields fileds = fteClss.Fields;
IFields outfields = null;
IEnumFieldError error = null;
checker.Validate(fileds, out error, out outfields);
//转换为SHP
IFeatureDataConverter convert = new FeatureDataConverterClass();
convert.ConvertFeatureClass(inFCName, null, null, outFCName, null, outfields, "", 100, 0);
}
}
public ITable CreateTable(IWorkspace2 workspace, string tableName, IFields fields)
{
ITable table;
UID uid = new UIDClass();
if (workspace != null)
{
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
if (!workspace.NameExists[esriDatasetType.esriDTTable, tableName])
{
uid.Value = "esriGeoDatabase.Object";
IObjectClassDescription objectClassDescription = new ObjectClassDescriptionClass();
if (fields == null)
{
fields = objectClassDescription.RequiredFields;
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
IField field = new FieldClass();
IFieldEdit fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "SampleField";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.IsNullable_2 = true;
fieldEdit.AliasName_2 = "Sample Field Column";
fieldEdit.DefaultValue_2 = "test";
fieldEdit.Editable_2 = true;
fieldEdit.Length_2 = 100;
fieldsEdit.AddField(field);
fields = fieldsEdit;
}
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)workspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
table = featureWorkspace.CreateTable(tableName, validatedFields, uid, null, "");
}
else
{
table = featureWorkspace.OpenTable(tableName);
}
}
else
{
table = null;
}
return(table);
}
/// <summary>
/// 复制字段，包括几何字段、非几何字段，并设置新的几何字段的空间参考
/// </summary>
/// <param name="featureClass">源要素类</param>
/// <param name="factoryCode">坐标系代码</param>
/// <returns></returns>
public static IFields CloneFeatureClassFields(this IFeatureClass featureClass, int factoryCode)
{
IFields outputFields;
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError obj = null;
fieldChecker.Validate(featureClass.Fields, out obj, out outputFields);
IField shapeField = outputFields.get_Field(outputFields.FindField(featureClass.ShapeFieldName));
IGeometryDefEdit sfGeoDefEdit = (IGeometryDefEdit)shapeField.GeometryDef;
ISpatialReferenceFactory spatialRefFac = new SpatialReferenceEnvironmentClass();
IProjectedCoordinateSystem pcsSys = spatialRefFac.CreateProjectedCoordinateSystem(factoryCode);
sfGeoDefEdit.SpatialReference_2 = pcsSys;
System.Runtime.InteropServices.Marshal.ReleaseComObject(fieldChecker);
System.Runtime.InteropServices.Marshal.ReleaseComObject(spatialRefFac);
return(outputFields);
}
//用帮助里的例子，修改了字段和空间参考
public IFeatureClass CreateFeatureClass(String featureClassName, IFeatureWorkspace featureWorkspace, IField[] arrFields)
{
// 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;
// Add some fields to the required fields.
foreach (IField pField in arrFields)
{
fieldsEdit.AddField(pField);
}
// 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.esriGeometryPolygon;
geometryDefEdit.SpatialReference_2 = this.pMapControl.SpatialReference;//导进来的要素类使用当前地图的空间参考
// 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.//这一步极易出错，一般都是名为featureClassName的文件已存在
IFeatureClass featureClass = featureWorkspace.CreateFeatureClass(featureClassName, validatedFields,
ocDescription.InstanceCLSID, ocDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple,
fcDescription.ShapeFieldName, "");
return(featureClass);
}
public IFeatureClass CreateFeatureDatasetFeatureClass(IFeatureDataset featureDataset, String featureClassName, IFields fieldsCollection, esriFeatureType featureType, String shapeFieldName)
{
IFeatureClassDescription fcDesc = new FeatureClassDescriptionClass();
IObjectClassDescription ocDesc = (IObjectClassDescription)fcDesc;
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = featureDataset.Workspace;
fieldChecker.Validate(fieldsCollection, out enumFieldError, out validatedFields);
// The enumFieldError enumerator can be inspected at this point to determine
// which fields were modified during validation.
IFeatureClass featureClass = featureDataset.CreateFeatureClass(featureClassName, validatedFields, ocDesc.InstanceCLSID,
ocDesc.ClassExtensionCLSID, esriFeatureType.esriFTSimple, fcDesc.ShapeFieldName, "");
return(featureClass);
}
public static ITable CreateObjectClass(IWorkspace workspace, String className, IFields fields)
{
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspace;
IObjectClassDescription ocDescription = new ObjectClassDescriptionClass();
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = workspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
// The enumFieldError enumerator can be inspected at this point to determine
// which fields were modified during validation.
ITable table = featureWorkspace.CreateTable(className, validatedFields,
ocDescription.InstanceCLSID, null, "");
return(table);
}