public static Dictionary <int, KeyValuePair <string, IEnumInvalidObject> > TransferMapDataWithinExtents(IMap map, IFeatureWorkspace outputWorkspace, IFeatureDatasetName outputFeatureDatasetName, ESRI.ArcGIS.ADF.Web.Geometry.Envelope downloadDataExtent, ISpatialReference outputSpatialReference)
{
Dictionary <int, KeyValuePair <string, IEnumInvalidObject> > invalidObjects = new Dictionary <int, KeyValuePair <string, IEnumInvalidObject> >();
IWorkspaceName outWorkspaceName = GeodatabaseUtil.GetWorkspaceName((IWorkspace)outputWorkspace);
List <IFeatureLayer> featureLayers = GetFeatureLayers(map);
int counter = 0;
foreach (IFeatureLayer featureLayer in featureLayers)
{
IFeatureClass inFeatureClass = featureLayer.FeatureClass;
IDataset dataset = (IDataset)inFeatureClass;
IFeatureWorkspace inFeatureWorkspace = (IFeatureWorkspace)dataset.Workspace;
IEnvelope env = new ESRI.ArcGIS.Geometry.EnvelopeClass();
env.XMin = downloadDataExtent.XMin;
env.YMin = downloadDataExtent.YMin;
env.XMax = downloadDataExtent.XMax;
env.YMax = downloadDataExtent.YMax;
ISpatialFilter spatialFilter = new SpatialFilterClass();
spatialFilter.Geometry = env;
spatialFilter.GeometryField = inFeatureClass.ShapeFieldName;
spatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
IFeatureClassName outputFeatureClassName = GeodatabaseUtil.GetFeatureClassName(outWorkspaceName, dataset.Name);
IEnumInvalidObject eInvalidObject = TransferData(inFeatureWorkspace, inFeatureClass, outputWorkspace, outputFeatureClassName, outputFeatureDatasetName, spatialFilter, outputSpatialReference);
invalidObjects.Add(counter, new KeyValuePair <string, IEnumInvalidObject>(dataset.Name, eInvalidObject));
counter++;
}
return(invalidObjects);
}
/// <summary>
/// SDE要素类导出mdb（要素集下要素类）
/// </summary>
/// <param name="IN_SourceWorkspace">源工作空间</param>
/// <param name="IN_TargetWorkspace">目标要素数据集</param>
/// <param name="IN_SourceFeatureClassName">源要素类名</param>
/// <param name="IN_TargetFeatureClassName">目标要素类名</param>
private void ConvertFeatureClass(IWorkspace IN_SourceWorkspace, IFeatureDataset IN_TargetWorkspace, string IN_SourceFeatureClassName, string IN_TargetFeatureClassName)
{
#region 环境配置
//创建源工作空间名
IDataset Temp_SourceWorkspaceDataset = (IDataset)IN_SourceWorkspace;
IWorkspaceName Temp_SourceWorkspaceName = (IWorkspaceName)Temp_SourceWorkspaceDataset.FullName;
//创建源要素数据集名
IFeatureClassName Temp_SourceFeatureClassName = new FeatureClassNameClass();
IDatasetName Temp_SourceDatasetName = (IDatasetName)Temp_SourceFeatureClassName;
Temp_SourceDatasetName.WorkspaceName = Temp_SourceWorkspaceName;
Temp_SourceDatasetName.Name = IN_SourceFeatureClassName;
//创建目标工作空间名
IDataset Temp_TargetWorkspaceDataset = (IDataset)IN_TargetWorkspace.Workspace;
IWorkspaceName Temp_TargetWorkspaceName = (IWorkspaceName)(Temp_TargetWorkspaceDataset.FullName);
//创建目标要素类名
IFeatureClassName Temp_TargetFeatureClassName = new FeatureClassNameClass();
IDatasetName Temp_TargetDatasetName = (IDatasetName)Temp_TargetFeatureClassName;
Temp_TargetDatasetName.WorkspaceName = Temp_TargetWorkspaceName;
Temp_TargetDatasetName.Name = IN_TargetFeatureClassName;
//创建目标要素数据集名
IFeatureDatasetName Temp_TargetFeatureDatasetName = new FeatureDatasetNameClass();
IDatasetName Temp_TargetDatasetName2 = (IDatasetName)Temp_TargetFeatureDatasetName;
Temp_TargetDatasetName2.WorkspaceName = Temp_TargetWorkspaceName;
Temp_TargetDatasetName2.Name = IN_TargetWorkspace.Name;
#endregion
//打开源要素类获取字段定义
ESRI.ArcGIS.esriSystem.IName Temp_SourceName = (ESRI.ArcGIS.esriSystem.IName)Temp_SourceFeatureClassName;
IFeatureClass Temp_SourceFeatureClass = (IFeatureClass)Temp_SourceName.Open();
//验证字段
IFieldChecker Temp_FieldChecker = new FieldCheckerClass();
IFields Temp_TargetFeatureClassFields;
IFields Temp_SourceFeatureClassFields = Temp_SourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
Temp_FieldChecker.InputWorkspace = IN_SourceWorkspace;
Temp_FieldChecker.ValidateWorkspace = IN_TargetWorkspace.Workspace;
Temp_FieldChecker.Validate(Temp_SourceFeatureClassFields, out enumFieldError, out Temp_TargetFeatureClassFields);
//批量导入
IField Temp_GeometryField;
for (int i = 0; i < Temp_TargetFeatureClassFields.FieldCount; i++)
{
if (Temp_TargetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
Temp_GeometryField = Temp_TargetFeatureClassFields.get_Field(i);
//获取空间定义
IGeometryDef Temp_GeometryDef = Temp_GeometryField.GeometryDef;
IGeometryDefEdit Temp_TargetFCGeoDefEdit = (IGeometryDefEdit)Temp_GeometryDef;
Temp_TargetFCGeoDefEdit.GridCount_2 = 1;
Temp_TargetFCGeoDefEdit.set_GridSize(0, 0);
Temp_TargetFCGeoDefEdit.SpatialReference_2 = Temp_GeometryField.GeometryDef.SpatialReference;
//定义筛选条件
IQueryFilter Temp_QueryFilter = new QueryFilterClass();
Temp_QueryFilter.WhereClause = "";
//导入要素类至要素数据集
IFeatureDataConverter Temp_FeatureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = Temp_FeatureDataConverter.ConvertFeatureClass(Temp_SourceFeatureClassName, Temp_QueryFilter, Temp_TargetFeatureDatasetName, Temp_TargetFeatureClassName, Temp_GeometryDef, Temp_TargetFeatureClassFields, "", 1000, 0);
break;
}
}
}
/// <summary>
/// 将一个要素类从一个工作空间转移到另外一个工作空间
/// 注意目标工作空间不能有改要素类，必须先清除
/// </summary>
/// <param name="sourceWorkspace">源工作空间</param>
/// <param name="targetWorkspace">目标工作空间</param>
/// <param name="nameOfSourceFeatureClass">源要素类名</param>
/// <param name="nameOfTargetFeatureClass">目标要素类名</param>
public void IFeatureDataConverter_ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, string nameOfSourceFeatureClass, string nameOfTargetFeatureClass)
{
//create source workspace name
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//create source dataset name
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfSourceFeatureClass;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Open input Featureclass to get field definitions.
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
}
public void IFeatureDataConverter(IWorkspace pSourceWorkspace, IWorkspace pTargetWorkspace, string pSFeatureClass, string pDFeatureClass)
{
IDataset sourceWorkspaceDataset = (IDataset)pSourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = pSFeatureClass;
IDataset targetWorkspaceDataset = (IDataset)pTargetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = pDFeatureClass;
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = pSourceWorkspace;
fieldChecker.ValidateWorkspace = pTargetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
}
public IEnumInvalidObject ConvertTable(IDatasetName idatasetName_0, IQueryFilter iqueryFilter_0,
IDatasetName idatasetName_1, IFields ifields_0, string string_0, int int_0, int int_1)
{
IEnumFieldError enumFieldError;
IFields field;
string str;
IEnumInvalidObject enumInvalidObject = null;
IFieldChecker fieldCheckerClass = new FieldChecker();
IWorkspace workspace = (idatasetName_1.WorkspaceName as IName).Open() as IWorkspace;
fieldCheckerClass.ValidateWorkspace = workspace;
fieldCheckerClass.Validate(ifields_0, out enumFieldError, out field);
fieldCheckerClass.ValidateTableName(idatasetName_1.Name, out str);
string str1 = str;
ITable table = null;
table = (workspace as IFeatureWorkspace).CreateTable(str1, field, null, null, string_0);
ITable table1 = (idatasetName_0 as IName).Open() as ITable;
ICursor cursor = table1.Search(iqueryFilter_0, false);
int num = 0;
ICursor cursor1 = table.Insert(true);
IRow row = cursor.NextRow();
while (row != null)
{
IRowBuffer rowBuffer = table.CreateRowBuffer();
try
{
this.method_1(cursor1, rowBuffer, field, row);
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
num++;
if (num == int_0)
{
num = 0;
cursor1.Flush();
}
row = cursor.NextRow();
if (this.ifeatureProgress_StepEventHandler_0 == null)
{
continue;
}
this.ifeatureProgress_StepEventHandler_0();
}
if (num > 0)
{
cursor1.Flush();
}
ComReleaser.ReleaseCOMObject(cursor);
ComReleaser.ReleaseCOMObject(cursor1);
return(enumInvalidObject);
}
/// <summary>
/// 复制源图层到目标dataset中的目标图层
/// </summary>
/// <param name="sourceWorkspaceDataset">源图层集</param>
/// <param name="targetWorkspaceDataset">目标图层集</param>
/// <param name="sourceFeatureClass">源图层</param>
/// <param name="nameOfTargetFeatureClass">待创建的图层名</param>
public static bool ConvertFeatureClass(IDataset sourceWorkspaceDataset, IDataset targetWorkspaceDataset,
IFeatureClass sourceFeatureClass,
string nameOfTargetFeatureClass)
{
try
{
IFeatureClassName nameOfSourceFeatureClass =
((IDataset)sourceFeatureClass).FullName as IFeatureClassName;
IDatasetName pSourceDsName = (IDatasetName)sourceWorkspaceDataset.FullName;
IDatasetName pTargetDsName = (IDatasetName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
targetFeatureClassName.FeatureDatasetName = pTargetDsName;
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = nameOfTargetFeatureClass;
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = sourceWorkspaceDataset.Workspace;
fieldChecker.ValidateWorkspace = targetWorkspaceDataset.Workspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField = targetFeatureClassFields.get_Field(targetFeatureClassFields.FindField(sourceFeatureClass.ShapeFieldName));
//for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
//{
// if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
// {
//geometryField = targetFeatureClassFields.get_Field(i);
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertFeatureClass(nameOfSourceFeatureClass, queryFilter,
pTargetDsName as IFeatureDatasetName, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
// break;
// }
//}
return(true);
}
catch (Exception exp)
{
return(false);
}
}
/// <summary>
/// 拷贝源表到目标空间
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="SourceDataset"></param>
/// <param name="nameOfTargetDataset"></param>
public static void ConvertTable(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, IDataset SourceDataset,
string nameOfTargetDataset)
{
try
{
//create source workspace name
ITable pSourceTab = (ITable)SourceDataset;
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IDatasetName sourceDatasetName = (IDatasetName)SourceDataset.FullName;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
ITableName targetTableName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetTableName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetDataset;
////Open input Featureclass to get field definitions.
//ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceDatasetName;
//ITable sourceTable = (ITable)sourceName.Open();
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFields;
IFields sourceFields = pSourceTab.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError == null)
{
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertTable(sourceDatasetName, queryFilter, targetDatasetName, pSourceTab.Fields, "",
1000, 0);
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
/// <summary>
/// Creates an <see cref="IEnumerable{T}" /> from an <see cref="IEnumDomain" />
/// </summary>
/// <param name="source">An <see cref="IEnumInvalidObject" /> to create an <see cref="IEnumerable{T}" /> from.</param>
/// <returns>An <see cref="IEnumerable{T}" /> that contains the fields from the input source.</returns>
public static IEnumerable <IInvalidObjectInfo> AsEnumerable(this IEnumInvalidObject source)
{
if (source != null)
{
source.Reset();
var value = source.Next();
while (value != null)
{
yield return(value);
value = source.Next();
}
}
}
/// <summary>
/// 拷贝源表到目标空间
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="SourceDataset"></param>
/// <param name="nameOfTargetDataset"></param>
public static bool ConvertTable(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, IDataset SourceDataset,
string nameOfTargetDataset)
{
try
{
ITable pSourceTab = (ITable)SourceDataset;
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IDatasetName sourceDatasetName = (IDatasetName)SourceDataset.FullName;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
ITableName targetTableName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetTableName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetDataset;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFields;
IFields sourceFields = pSourceTab.Fields;
IEnumFieldError enumFieldError;
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError == null)
{
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertTable(sourceDatasetName, queryFilter, targetDatasetName, pSourceTab.Fields, "",
1000, 0);
}
return(true);
}
catch (Exception exp)
{
return(false);
}
}
public void TransferData_Test(string subDirectory, string inputPGDBFile, string inputFeatureClassName)
{
string temp = System.IO.Path.Combine(_dataDirectory, subDirectory);
string pgdb = System.IO.Path.Combine(temp, inputPGDBFile);
IWorkspace inWorkspace = GeodatabaseUtil.GetAccessWorkspace(pgdb);
IFeatureWorkspace inFeatureWorkspace = (IFeatureWorkspace)inWorkspace;
IFeatureClass inFeatureClass = FeatureClassUtil.OpenFeatureClass(inFeatureWorkspace, inputFeatureClassName);
IGeoDataset geoDataset = (IGeoDataset)inFeatureClass;
string[] files = Directory.GetFiles(temp, inputFeatureClassName + ".*", SearchOption.TopDirectoryOnly);
foreach (string item in files)
{
File.Delete(item);
}
IWorkspace outWorkspace = GeodatabaseUtil.GetShapefileWorkspace(temp);
IFeatureWorkspace outFeatureWorkspace = (IFeatureWorkspace)outWorkspace;
IWorkspaceName outWorkspaceName = GeodatabaseUtil.GetWorkspaceName(outWorkspace);
IFeatureClassName outFeatureclassName = GeodatabaseUtil.GetFeatureClassName(outWorkspaceName, inputFeatureClassName);
IEnumInvalidObject invalidObjects = GeodatabaseUtil.TransferData(inFeatureWorkspace, inFeatureClass, outFeatureWorkspace, outFeatureclassName, null, null, geoDataset.SpatialReference);
}
//public static ICursor UncheckGridCode(ITable pTable,string pVersionName)
//{
// //根据表格数据获取grid code：
// IQueryFilter filter = new QueryFilterClass();
// filter.WhereClause = "TaskName = '" + pVersionName + "'";
// ICursor cursor = pTable.Search(filter, true);
// return cursor;
//}
//public static void Check(IFeature pFeature, IWorkspace pWorkspace,string pVersionName)
//{
// //更新检查状态：
// int ii = 1;
// int fieldindex = pFeature.Fields.FindField("passed");
// if (pFeature.get_Value(pFeature.Fields.FindField("VersionName")).ToString() == pVersionName)
// {
// pFeature.set_Value(fieldindex, ii);
// pFeature.Store();
// }
//}
//public static void Check(IFeature pFeature, IWorkspace pWorkspace)
//{
// //更新检查状态：
// int ii = 1;
// int fieldindex = pFeature.Fields.FindFieldByAliasName("Pass");
// pFeature.set_Value(fieldindex, ii);
// pFeature.Store();
//}
public static bool ExportSHP(string pDestPath, IWorkspace pWorkspace)
{
IWorkspace sourceWorkspace = pWorkspace;
IFeatureClass sourceFeatureClass = DBOperator.getFeatureClass(pWorkspace, "CheckArea");
string shpFolderPath = pDestPath.Substring(0, pDestPath.LastIndexOf("\\"));
string shpFileName = pDestPath.Substring(pDestPath.LastIndexOf("\\") + 1);
shpFileName = shpFileName.Substring(0, shpFileName.Length - 4);
IWorkspace targetWorkspace = DBOperator.openShapeFileWorkspace(shpFolderPath);
if (File.Exists(pDestPath) == true)
{
DBOperator.DeleteFeatureClass(targetWorkspace, shpFileName);
}
IDataset sourcedataset = sourceWorkspace as IDataset;
IWorkspaceName sourceWorkspaceName = sourcedataset.FullName as IWorkspaceName;
IDataset targetdataset = targetWorkspace as IDataset;
IWorkspaceName targetWorkspaceName = targetdataset.FullName as IWorkspaceName;
sourcedataset = sourceFeatureClass as IDataset;
IFeatureClassName sourceFeatureClassName = sourcedataset.FullName as IFeatureClassName;
// Create a name object for the target dataset.
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = shpFileName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
// Create the objects and references necessary for field validation.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFields = sourceFeatureClass.Fields;
IFields targetFields = null;
IEnumFieldError enumFieldError = null;
// Validate the fields and check for errors.
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError != null)
{
IFieldError error = enumFieldError.Next();
while (error != null)
{
// Handle the errors in a way appropriate to your application.
Console.WriteLine("Errors were encountered during field validation.");
error = enumFieldError.Next();
}
}
// Find the shape field.
String shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
// Get the geometry definition from the shape field and clone it.
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
// Cast the IGeometryDef to the IGeometryDefEdit interface.
IGeometryDefEdit targetGeometryDefEdit = (IGeometryDefEdit)targetGeometryDef;
// Set the IGeometryDefEdit properties.
targetGeometryDefEdit.GridCount_2 = 1;
targetGeometryDefEdit.set_GridSize(0, 0.75);
// Set the required properties for the IFieldChecker interface.
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
// Create the converter and run the conversion.
IFeatureDataConverter2 featureDataConverter = new FeatureDataConverterClass();
IDatasetName sourceFClassName = sourceFeatureClassName as IDatasetName;
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass
(sourceFClassName, null, null, null, targetFeatureClassName,
targetGeometryDef, targetFields, "", 1000, 0);
// Check for errors.
IInvalidObjectInfo invalidObjectInfo = null;
enumInvalidObject.Reset();
while ((invalidObjectInfo = enumInvalidObject.Next()) != null)
{
// Handle the errors in a way appropriate to the application.
Console.WriteLine("Errors occurred for the following feature: {0}",
invalidObjectInfo.InvalidObjectID);
return(false);
}
return(true);
}
public static void ConvertFeatureClassToShapefile(string sourceWorkspacePath, string targetWorkspacePath, string sourceDataName, string targetDataName)
{
// Open the source and target workspaces.
//String sourceWorkspacePath = @"C:\arcgis\DeveloperKit\SamplesNET\data\Atlanta.gdb";
//String targetWorkspacePath = @"C:\Temp";
IWorkspaceFactory sourceWorkspaceFactory = new FileGDBWorkspaceFactoryClass();
IWorkspaceFactory targetWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
IWorkspace sourceWorkspace = sourceWorkspaceFactory.OpenFromFile
(sourceWorkspacePath, 0);
IWorkspace targetWorkspace = targetWorkspaceFactory.OpenFromFile
(targetWorkspacePath, 0);
// Cast the workspaces to the IDataset interface and get name objects.
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IName sourceWorkspaceDatasetName = sourceWorkspaceDataset.FullName;
IName targetWorkspaceDatasetName = targetWorkspaceDataset.FullName;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)
sourceWorkspaceDatasetName;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)
targetWorkspaceDatasetName;
// Create a name object for the shapefile and cast it to the IDatasetName interface.
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.Name = sourceDataName;//"streets";
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
// Create a name object for the FGDB feature class and cast it to the IDatasetName interface.
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = targetDataName;// "AtlantaStreets";
targetDatasetName.WorkspaceName = targetWorkspaceName;
// Open source feature class to get field definitions.
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
// Create the objects and references necessary for field validation.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFields = sourceFeatureClass.Fields;
IFields targetFields = null;
IEnumFieldError enumFieldError = null;
// Set the required properties for the IFieldChecker interface.
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
// Validate the fields and check for errors.
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError != null)
{
// Handle the errors in a way appropriate to your application.
Console.WriteLine("Errors were encountered during field validation.");
}
// Find the shape field.
String shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
// Get the geometry definition from the shape field and clone it.
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
// Create a query filter to remove ramps, interstates and highways.
IQueryFilter queryFilter = new QueryFilterClass();
//queryFilter.WhereClause = "NAME <> 'Ramp' AND PRE_TYPE NOT IN ('I', 'Hwy')";
queryFilter.WhereClause = "1=1";
// Create the converter and run the conversion.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject =
featureDataConverter.ConvertFeatureClass(sourceFeatureClassName,
queryFilter, null, targetFeatureClassName, targetGeometryDef, targetFields,
"", 1000, 0);
// Check for errors.
IInvalidObjectInfo invalidObjectInfo = null;
enumInvalidObject.Reset();
while ((invalidObjectInfo = enumInvalidObject.Next()) != null)
{
// Handle the errors in a way appropriate to the application.
Console.WriteLine("Errors occurred for the following feature: {0}",
invalidObjectInfo.InvalidObjectID);
}
}
//将mdb中要素类转换复制到GDB数据库中
private void ImportMDBToGDB(string file, string outfilename)
{
m_success = false;//初始化
try
{
string filepath = file.Substring(0, file.LastIndexOf("---"));
string filename = file.Substring(file.LastIndexOf("-") + 1);
//打开mdb文件所在的工作空间
ESRI.ArcGIS.Geodatabase.IWorkspaceFactory wf = new AccessWorkspaceFactory();
IFeatureWorkspace pFeatureWorkspaceMDB = wf.OpenFromFile(@filepath, 0) as IFeatureWorkspace;
IWorkspace pWorkspaceMDB = pFeatureWorkspaceMDB as IWorkspace;
// 创建源工作空间名称
IDataset sourceWorkspaceDataset = (IDataset)pWorkspaceMDB;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//创建源数据集名称
//IFeatureClassName sourceFeatureClassName = serverContext.CreateObject("esriGeoDatabase.FeatureClassName") as IFeatureClassName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = filename;
//打开存在的工作空间，作为导入的空间
IWorkspaceFactory Pwf = new FileGDBWorkspaceFactoryClass();
//IWorkspace pWorkspaceGDB = Pwf.OpenFromFile(GetSourcePath(comboBoxSource.Text), 0);
//IWorkspace2 pWorkspace2 = (IWorkspace2)(Pwf.OpenFromFile(GetSourcePath(comboBoxSource.Text), 0));
IWorkspace pWorkspaceGDB = GetWorkspace(comboBoxSource.Text);
if (pWorkspaceGDB == null)
{
m_strErr = "数据源未找到";
m_success = false;
return;
}
string username = GetSourceUser(comboBoxSource.Text);
if (username.Trim() != "")
{
outfilename = username + "." + outfilename;
}
IWorkspace2 pWorkspace2 = pWorkspaceGDB as IWorkspace2;
IFeatureWorkspace pFeatureWorkspace = (IFeatureWorkspace)pWorkspaceGDB;
//创建目标工作空间名称
IDataset targetWorkspaceDataset = (IDataset)pWorkspaceGDB;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//创建目标数据集名称
// IFeatureClassName targetFeatureClassName = serverContext.CreateObject("esriGeoDatabase.FeatureClassName") as IFeatureClassName;
//判断要素是否存在，若存在将删除源文件
if (pWorkspace2.get_NameExists(esriDatasetType.esriDTFeatureClass, outfilename))
{
if (m_newfile == true)
{
IFeatureClass tmpfeatureclass;
tmpfeatureclass = pFeatureWorkspace.OpenFeatureClass(outfilename);
IDataset set = tmpfeatureclass as IDataset;
fdr.DeleteSql(filename);
set.CanDelete();
set.Delete();
}
else
{
m_strErr = "存在相同文件名";
m_success = false;
return;
}
}
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = outfilename;
//打开输入的要素类以得到字段定义
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();//打开源要素类
//验证字段名称，因为你正在不同类型的工作空间之间进行数据转换
//IFieldChecker fieldChecker = serverContext.CreateObject("esriGeoDatabase.FieldChecker") as IFieldChecker;
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IFields targetFeatureClassFields;
IEnumFieldError enumFieldError;
//最重要的设置输入和验证工作空间
fieldChecker.InputWorkspace = pWorkspaceMDB;
fieldChecker.ValidateWorkspace = pWorkspaceGDB;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
//遍历所有输出字段找到几何字段
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
//得到几何字段的几何定义
IGeometryDef geometryDef = geometryField.GeometryDef;
//赋予几何定义一个空间索引格网数目和格网大小值
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
//允许ArcGIS为数据加载确定一个有效的格网大小
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
//转换要素类中所有的要素
//IQueryFilter queryFilter = serverContext.CreateObject("esriGeoDatabase.QueryFilter") as IQueryFilter; ;
QueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
//加载要素类
//IFeatureDataConverter fctofc = serverContext.CreateObject("esriGeoDatabase.FeatureDataConverter") as IFeatureDataConverter;
if (InsertIntoDatabase(outfilename))//更新数据库
{
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
}
}
}
m_success = true;
}
catch { m_success = false; m_strErr = ""; }
}
/// <summary>
/// Exports the source table using the query filter to the table in the output workspace.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filter">The filter.</param>
/// <param name="tableName">Name of the output table.</param>
/// <param name="workspace">The output workspace.</param>
/// <param name="requiredFields">The required fields.</param>
/// <param name="handle">The handle.</param>
/// <param name="surrogate">The surrogate for the event handler.</param>
/// <param name="invalid">The errors that occured during the export.</param>
/// <param name="errors">The field errors.</param>
/// <returns>
/// Returns a <see cref="IFeatureClass" /> representing the feature class that was exported.
/// </returns>
public static ITable Export(this ITable source, IQueryFilter filter, string tableName, IWorkspace workspace, IFields requiredFields, int handle, FeatureProgress surrogate, out IEnumInvalidObject invalid, out IEnumFieldError errors)
{
var ds = (IDataset)source;
var input = ds.Workspace.Define(ds.Name, new TableNameClass());
var output = workspace.Define(tableName, new TableNameClass());
workspace.Delete(output);
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = ds.Workspace;
fieldChecker.ValidateWorkspace = workspace;
IFields targetFields;
fieldChecker.Validate(requiredFields, out errors, out targetFields);
var featureDataConverter = new FeatureDataConverterClass();
if (surrogate != null)
{
surrogate.Advise(featureDataConverter);
}
invalid = featureDataConverter.ConvertTable(input, filter, null, output, targetFields, "", 1000, handle);
return(((IName)output).Open() as ITable);
}
/// <summary>
/// 将指定要素类复制到目标数据库中（在目标数据库中创建要素类）
/// </summary>
/// <param name="pSrcFC">源要素类</param>
/// <param name="pQueryFilter">查询条件</param>
/// <param name="pTargetWks">目标数据库</param>
/// <param name="sMessage">转换消息</param>
/// <param name="sTargetName">目标要素类名</param>
/// <param name="sAlias">目标要素类别名</param>
/// <param name="sFDatasetName">目标要素数据集</param>
/// <returns></returns>
public bool TranslateFeatureClass(IFeatureClass pSrcFC, IQueryFilter pQueryFilter, IWorkspace pTargetWks, string sTargetName = null, string sAlias = null, string sFDatasetName = null)
{
GeoDataUtils geoDataUtils = new GeoDataUtils();
IDataset pSrcDataset = pSrcFC as IDataset;
IFeatureClassName pSrcName = pSrcDataset.FullName as IFeatureClassName;
IFeatureDatasetName pFeatureDatasetName = null;
if (pTargetWks.Type != esriWorkspaceType.esriFileSystemWorkspace)
{
string sFeatureDatasetName = sFDatasetName;
if (string.IsNullOrEmpty(sFeatureDatasetName) && pSrcFC.FeatureDataset != null)
{
sFeatureDatasetName = geoDataUtils.ExtractDatasetName(pSrcFC.FeatureDataset.Name);
}
if (!string.IsNullOrEmpty(sFeatureDatasetName))
{
if (geoDataUtils.IsNameExist(pTargetWks, sFeatureDatasetName, esriDatasetType.esriDTFeatureDataset))
{
IFeatureDataset pTargetFeatureDataset = (pTargetWks as IFeatureWorkspace).OpenFeatureDataset(sFeatureDatasetName);
pFeatureDatasetName = pTargetFeatureDataset.FullName as IFeatureDatasetName;
Marshal.ReleaseComObject(pTargetFeatureDataset);
}
else
{
pFeatureDatasetName = new FeatureDatasetName() as IFeatureDatasetName;
IDatasetName pDatasetName = pFeatureDatasetName as IDatasetName;
pDatasetName.Name = sFeatureDatasetName;
pDatasetName.WorkspaceName = (pTargetWks as IDataset).FullName as IWorkspaceName;
}
}
}
//目标要素类名
FeatureClassName pTargetName = new FeatureClassName();
IDatasetName pTargetDatasetName = pTargetName as IDatasetName;
if (string.IsNullOrEmpty(sTargetName))
{
sTargetName = geoDataUtils.ExtractDatasetName(pSrcDataset.Name);
}
pTargetDatasetName.Name = sTargetName;
pTargetDatasetName.WorkspaceName = (pTargetWks as IDataset).FullName as IWorkspaceName;
geoDataUtils.DeleteDataset(pTargetWks, pTargetDatasetName);
// 验证字段
IFields pTargetFields;
string sShapeFieldName;
geoDataUtils.CheckFields(pSrcFC, pTargetWks, out pTargetFields, out sShapeFieldName);
IEnumInvalidObject pEnumInvalidObject = null;
IFeatureDataConverter pConverter = null;
try
{
int iIndex = pTargetFields.FindField(sShapeFieldName);
IGeometryDef pTargetGeometryDef = pTargetFields.get_Field(iIndex).GeometryDef;
// 执行批量转换
pConverter = new FeatureDataConverter();
pEnumInvalidObject = pConverter.ConvertFeatureClass(pSrcName, pQueryFilter, pFeatureDatasetName as IFeatureDatasetName,
pTargetName as IFeatureClassName, pTargetGeometryDef, pTargetFields, "", 1000, 0);
// 检查转换过程中是否产生错误
if (pEnumInvalidObject != null)
{
IInvalidObjectInfo pInvalidInfo = null;
pEnumInvalidObject.Reset();
while ((pInvalidInfo = pEnumInvalidObject.Next()) != null)
{
ErrorMessage += pSrcFC.AliasName + "图层要素：" + pInvalidInfo.InvalidObjectID + "执行失败！";
}
}
}
finally //释放资源
{
if (pEnumInvalidObject != null)
{
Marshal.ReleaseComObject(pEnumInvalidObject);
}
if (pConverter != null)
{
Marshal.ReleaseComObject(pConverter);
}
}
//修改要素类别名
if (string.IsNullOrEmpty(sAlias))
{
sAlias = pSrcFC.AliasName;
}
IFeatureClass pTargetFC = (pTargetWks as IFeatureWorkspace).OpenFeatureClass(sTargetName);
geoDataUtils.AlterDatasetAlias(pTargetFC, sAlias);
Marshal.ReleaseComObject(pTargetFC);
return(true);
}
/// <summary>
/// 实现导入导出
/// </summary>
/// <param name="inputFeatureClass"></param>
/// <param name="targetpath"></param>
/// <param name="targetname"></param>
public static void CopyData(IFeatureClass inputFeatureClass, IWorkspace pWorkspace, string targetname)
{
IDataset inputDataset = (IDataset)inputFeatureClass;
IFeatureClassName inputclassName = (IFeatureClassName)inputDataset.FullName;
// Get the layer's selection set.
//利用属性打开
// IPropertySet ps = new PropertySetClass();
// ps.SetProperty("DATABASE", targetpath);
// IWorkspaceFactory wsf = new FileGDBWorkspaceFactoryClass();
// IWorkspace ws = null;
// try
// {
// ws = wsf.Open(ps, 0);
// }
// catch (Exception e)
// {
//
// }
//设置输出要素属性
IDataset ds = (IDataset)pWorkspace;
IWorkspaceName wsName = (IWorkspaceName)ds.FullName;
IFeatureClassName featClsName = new FeatureClassNameClass();
IDatasetName dsName = (IDatasetName)featClsName;
dsName.WorkspaceName = wsName;
dsName.Name = targetname;
//// Use the IFieldChecker interface to make sure all of the field names are valid for a shapefile.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields shapefileFields = null;
IEnumFieldError enumFieldError = null;
fieldChecker.InputWorkspace = inputDataset.Workspace;
fieldChecker.ValidateWorkspace = pWorkspace;
//out and ref
//////////////////用Ref型参数时，传入的参数必须先被初始化。而Out则不要要，对Out而言，就必须在方法中对其完成初始化。
// ///////////////用Ref和Out时都必须注意，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。
/////////////////// Out更适合用在要要Return多个返回值的地方，而Ref则用在要要被调出使用的方法修改调出使用者的引用的时候。
fieldChecker.Validate(inputFeatureClass.Fields, out enumFieldError, out shapefileFields);
// At this point, reporting/inspecting invalid fields would be useful, but for this example it's omitted.
// We also need to retrieve the GeometryDef from the input feature class.
int shapeFieldPosition = inputFeatureClass.FindField(inputFeatureClass.ShapeFieldName);
IFields inputFields = inputFeatureClass.Fields;
IField shapeField = inputFields.get_Field(shapeFieldPosition);
IGeometryDef geometryDef = shapeField.GeometryDef;
IGeometryDef pGeometryDef = new GeometryDef();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = inputFeatureClass.ShapeType;
IFeature pFeature = inputFeatureClass.Search(null, true).NextFeature();
pGeometryDefEdit.SpatialReference_2 = pFeature.Shape.SpatialReference;
// Now we can create a feature data converter.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass(inputclassName, null,
null, featClsName, pGeometryDef, shapefileFields, "", 1000, 0);
// Again, checking for invalid objects would be useful at this point...
inputFeatureClass = null;
ds = null;
}
/// <summary>
/// 复制源图层到目标dataset中的目标图层
/// </summary>
/// <param name="sourceWorkspaceDataset">源图层集</param>
/// <param name="targetWorkspaceDataset">目标图层集</param>
/// <param name="sourceFeatureClass">源图层</param>
/// <param name="nameOfTargetFeatureClass">待创建的图层名</param>
public static IFeatureClass ConvertFeatureClass(IDataset sourceWorkspaceDataset, IDataset targetWorkspaceDataset,
IFeatureClass sourceFeatureClass,
string nameOfTargetFeatureClass)
{
IFeatureClass TragetFeatureClass = null;
try
{
IFeatureClassName nameOfSourceFeatureClass =
((IDataset)sourceFeatureClass).FullName as IFeatureClassName;
IDatasetName pSourceDsName = (IDatasetName)sourceWorkspaceDataset.FullName;
IDatasetName pTargetDsName = (IDatasetName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
targetFeatureClassName.FeatureDatasetName = pTargetDsName;
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspaceDataset.Workspace;
fieldChecker.ValidateWorkspace = targetWorkspaceDataset.Workspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
//targetFCGeoDefEdit.GridCount_2 = 1;
//targetFCGeoDefEdit.set_GridSize(0, 0);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertFeatureClass(nameOfSourceFeatureClass, queryFilter,
pTargetDsName as IFeatureDatasetName, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
string strTargetFtCls = ((IDatasetName)targetFeatureClassName).Name;
TragetFeatureClass =
((IFeatureWorkspace)targetWorkspaceDataset.Workspace).OpenFeatureClass(strTargetFtCls);
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return(null);
}
return(TragetFeatureClass);
}
public void ConvertTable(IWorkspace sourceWorkspace, IDataset sourceDataset)
{
IWorkspace targetWorkspace = calcWorkspace;
//Target dataset name
string temporarySuffix = MilSpace.DataAccess.Helper.GetTemporaryNameSuffix();
string datasetName = $"{visibilityCalcFeatureDataset}{temporarySuffix}";
string nameOfTargetDataset = $"{visibilityCalcFeatureClass}{temporarySuffix}";
try
{
//create source workspace name
ITable pSourceTab = (ITable)sourceDataset;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceDataset;
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IFeatureClassName sourceDatasetName = (IFeatureClassName)sourceDataset.FullName;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IFeatureWorkspace featureworkspace = (IFeatureWorkspace)calcWorkspace;
IFeatureDataset targetDataset = featureworkspace.CreateFeatureDataset(datasetName, EsriTools.Wgs84Spatialreference);
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetDataset;
////Open input Featureclass to get field definitions.
//ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceDatasetName;
//ITable sourceTable = (ITable)sourceName.Open();
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFields;
IFields sourceFields = pSourceTab.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
// Get the geometry definition from the shape field and clone it.
string shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
if (enumFieldError == null)
{
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertFeatureClass(sourceDatasetName, queryFilter, (IFeatureDatasetName)targetDataset.FullName, targetFeatureClassName, targetGeometryDef,
pSourceTab.Fields, "", 1000, 0);
}
}
catch (Exception exp)
{
logger.ErrorEx(exp.ToString());
return;
}
}
public IEnumInvalidObject ConvertFeatureClass(IFeatureClassName ifeatureClassName_0, IQueryFilter iqueryFilter_0,
IFeatureDatasetName ifeatureDatasetName_0, IFeatureClassName ifeatureClassName_1,
IGeometryDef igeometryDef_0, IFields ifields_0, string string_0, int int_0, int int_1)
{
IEnumFieldError enumFieldError;
IFields field;
string str;
IEnumInvalidObject enumInvalidObject = null;
IFieldChecker fieldCheckerClass = new FieldChecker();
IWorkspaceName workspaceName = null;
workspaceName = (ifeatureDatasetName_0 == null
? (ifeatureClassName_1 as IDatasetName).WorkspaceName
: (ifeatureDatasetName_0 as IDatasetName).WorkspaceName);
IWorkspace workspace = (workspaceName as IName).Open() as IWorkspace;
fieldCheckerClass.ValidateWorkspace = workspace;
fieldCheckerClass.Validate(ifields_0, out enumFieldError, out field);
string name = (ifeatureClassName_1 as IDatasetName).Name;
fieldCheckerClass.ValidateTableName(name, out str);
name = str;
IField field1 = null;
int num = 0;
while (true)
{
if (num >= field.FieldCount)
{
break;
}
else if (field.Field[num].Type == esriFieldType.esriFieldTypeGeometry)
{
field1 = field.Field[num];
break;
}
else
{
num++;
}
}
IFeatureClass featureClass = null;
if (ifeatureDatasetName_0 == null)
{
featureClass = (workspace as IFeatureWorkspace).CreateFeatureClass(name, field, null, null,
esriFeatureType.esriFTSimple, field1.Name, string_0);
}
else
{
IFeatureDataset featureDataset = (ifeatureDatasetName_0 as IName).Open() as IFeatureDataset;
featureClass = featureDataset.CreateFeatureClass(name, field, null, null, esriFeatureType.esriFTSimple,
field1.Name, string_0);
}
IFeatureClass featureClass1 = (ifeatureClassName_0 as IName).Open() as IFeatureClass;
IFeatureCursor featureCursor = featureClass1.Search(iqueryFilter_0, false);
IFeature feature = featureCursor.NextFeature();
int num1 = 0;
IFeatureCursor featureCursor1 = featureClass.Insert(true);
while (feature != null)
{
IFeatureBuffer featureBuffer = featureClass.CreateFeatureBuffer();
if (feature.Shape != null)
{
try
{
this.method_0(featureCursor1, featureBuffer, field, feature);
}
catch (Exception exception)
{
Logger.Current.Error("", exception, "");
}
}
num1++;
if (num1 == int_0)
{
num1 = 0;
featureCursor1.Flush();
}
feature = featureCursor.NextFeature();
if (this.ifeatureProgress_StepEventHandler_0 == null)
{
continue;
}
this.ifeatureProgress_StepEventHandler_0();
}
if (num1 > 0)
{
featureCursor1.Flush();
}
ComReleaser.ReleaseCOMObject(featureCursor);
ComReleaser.ReleaseCOMObject(featureCursor1);
return(enumInvalidObject);
}
/// <summary>
/// Exports the source table using the query filter to the table in the output workspace.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filter">The filter.</param>
/// <param name="tableName">Name of the output table.</param>
/// <param name="workspace">The output workspace.</param>
/// <param name="requiredFields">The required fields.</param>
/// <param name="handle">The handle.</param>
/// <param name="keepFeatureDatset">if set to <c>true</c> when the feature class should be created within feature datset.</param>
/// <param name="surrogate">The surrogate for the event handler.</param>
/// <param name="invalid">The errors that occured during the export.</param>
/// <param name="errors">The field errors.</param>
/// <returns>
/// Returns a <see cref="IFeatureClass" /> representing the feature class that was exported.
/// </returns>
public static IFeatureClass Export(this IFeatureClass source, IQueryFilter filter, string tableName, IWorkspace workspace, IFields requiredFields, int handle, bool keepFeatureDatset, FeatureProgress surrogate, out IEnumInvalidObject invalid, out IEnumFieldError errors)
{
var ds = (IDataset)source;
var input = ds.Workspace.Define(ds.Name, new FeatureClassNameClass());
var output = workspace.Define(tableName, new FeatureClassNameClass());
if (source.FeatureDataset != null && keepFeatureDatset)
{
output.FeatureDatasetName = source.FeatureDataset.FullName as IDatasetName;
}
var i = source.Fields.FindField(source.ShapeFieldName);
var field = source.Fields.Field[i];
var clone = (IClone)field.GeometryDef;
var geometryDef = (IGeometryDef)clone.Clone();
workspace.Delete(output);
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = ds.Workspace;
fieldChecker.ValidateWorkspace = workspace;
IFields targetFields;
fieldChecker.Validate(requiredFields, out errors, out targetFields);
var featureDataConverter = new FeatureDataConverterClass();
if (surrogate != null)
{
surrogate.Advise(featureDataConverter);
}
invalid = featureDataConverter.ConvertFeatureClass(input, filter, null, output, geometryDef, targetFields, "", 1000, handle);
return(((IName)output).Open() as IFeatureClass);
}
/// <summary>
/// Exports the source table using the query filter to the table in the output workspace.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filter">The filter.</param>
/// <param name="tableName">Name of the output table.</param>
/// <param name="workspace">The workspace.</param>
/// <param name="handle">The handle.</param>
/// <param name="keepFeatureDatset">if set to <c>true</c> when the feature class should be created within feature datset.</param>
/// <param name="errors">The errors that occured during the export.</param>
/// <returns>
/// Returns a <see cref="IFeatureClass" /> representing the feature class that was exported.
/// </returns>
public static IFeatureClass Export(this IFeatureClass source, IQueryFilter filter, string tableName, IWorkspace workspace, int handle, bool keepFeatureDatset, out IEnumInvalidObject errors)
{
IEnumFieldError fieldError;
return(source.Export(filter, tableName, workspace, source.Fields, handle, keepFeatureDatset, null, out errors, out fieldError));
}
public static void OperateConvertToShape(string sFileName, IFeatureClass pInFeatureClass)
{
try
{
string str = sFileName;
string str2 = str.Substring(str.LastIndexOf(@"\") + 1); //文件名
string str3 = str.Substring(0, (str.Length - str2.Length) - 1); //路径
IDataset pInDataset = pInFeatureClass as IDataset;
IDatasetName pInputDatasetName = (IDatasetName)pInDataset.FullName;
IFeatureClassName pInputFClassName = (IFeatureClassName)pInputDatasetName;
///////////////////////////////////////////// //创建一个输出shp文件的工作空间
IWorkspaceFactory pShpWorkspaceFactory = new ShapefileWorkspaceFactoryClass() as IWorkspaceFactory;
IWorkspace pWorkspace = pShpWorkspaceFactory.OpenFromFile(str3, 0);
IWorkspaceName pOutWorkspaceName = new WorkspaceNameClass();
IDataset pDataset = pWorkspace as IDataset;
pOutWorkspaceName = (IWorkspaceName)pDataset.FullName;
//创建一个要素集合
IFeatureDatasetName pOutFeatureDatasetName = null;
//创建一个要素类
IFeatureClassName pOutFeatureClassName = new FeatureClassNameClass();
IDatasetName pOutDatasetClassName = (IDatasetName)pOutFeatureClassName;
pOutDatasetClassName.Name = str2;
//作为输出参数
pOutDatasetClassName.WorkspaceName = pOutWorkspaceName;
//////////////////////////////////////////////////////////////// //创建输出文件属性字段
IFields pOutFields, pInFields;
IFieldChecker pFieldChecker;
IField pGeoField;
IEnumFieldError pEnumFieldError = null;
pInFields = pInFeatureClass.Fields;
pFieldChecker = new FieldChecker();
pFieldChecker.Validate(pInFields, out pEnumFieldError, out pOutFields);
///设置输出文件的几何定义
String shapeFieldName = pInFeatureClass.ShapeFieldName;
int shapeFieldIndex = pInFeatureClass.FindField(shapeFieldName);
IField shapeField = pInFeatureClass.Fields.get_Field(shapeFieldIndex);
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone outGeometryDefClone = geometryDefClone.Clone();
IGeometryDef outGeometryDef = (IGeometryDef)outGeometryDefClone;
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass(pInputFClassName, null, null, pOutFeatureClassName, outGeometryDef, pOutFields, "", 1000, 0);
// IFeatureDataConverter pFeatureDataConverter = new FeatureDataConverterClass();
//pFeatureDataConverter.ConvertFeatureClass(sFeatureClassName, null, null, pFeatureClassName, null, null, "", 0x3e8, 0);
MessageBox.Show("等值线计算完毕！", "信息", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception exception)
{
MessageBox.Show(exception.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
public void ConvertFileGDBToSDE(string fileGDBPath, string sourceFCName, string targetFCName)
{
// Create a name object for the source (fileGDB) workspace and open it.
IWorkspaceName sourceWorkspaceName = getWorkspaceName("esriDataSourcesGDB.FileGDBWorkspaceFactory", fileGDBPath);
IName sourceWorkspaceIName = (IName)sourceWorkspaceName;
IWorkspace sourceWorkspace = (IWorkspace)sourceWorkspaceIName.Open();
// Create a name object for the target (SDE) workspace and open it.
IWorkspaceName targetWorkspaceName = getWorkspaceName("esriDataSourcesGDB.SdeWorkspaceFactory", sdePath);
IName targetWorkspaceIName = (IName)targetWorkspaceName;
IWorkspace targetWorkspace = (IWorkspace)targetWorkspaceIName.Open();
// Create a name object for the source dataset.
IFeatureClassName sourceFeatureClassName = getFeatureClassName(sourceWorkspaceName, sourceFCName);
// Create a name object for the target dataset.
IFeatureClassName targetFeatureClassName = getFeatureClassName(targetWorkspaceName, targetFCName);
// Open source feature class to get field definitions.
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
// Create the objects and references necessary for field validation.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFields = sourceFeatureClass.Fields;
IFields targetFields = null;
IEnumFieldError enumFieldError = null;
// Set the required properties for the IFieldChecker interface.
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
// Validate the fields and check for errors.
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError != null)
{
// Handle the errors in a way appropriate to your application.
Console.WriteLine("Errors were encountered during field validation.");
}
// Find the shape field.
String shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
// Get the geometry definition from the shape field and clone it.
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
// Cast the IGeometryDef to the IGeometryDefEdit interface.
IGeometryDefEdit targetGeometryDefEdit = (IGeometryDefEdit)targetGeometryDef;
// Set the IGeometryDefEdit properties.
//targetGeometryDefEdit.GridCount_2 = 1;
//targetGeometryDefEdit.set_GridSize(0, 0.75);
// Create a query filter to only select features you want to convert
IQueryFilter queryFilter = new QueryFilterClass();
// Create the converter and run the conversion.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass
(sourceFeatureClassName, queryFilter, null, targetFeatureClassName,
targetGeometryDef, targetFields, "", 1000, 0);
// Check for errors.
IInvalidObjectInfo invalidObjectInfo = null;
enumInvalidObject.Reset();
while ((invalidObjectInfo = enumInvalidObject.Next()) != null)
{
// Handle the errors in a way appropriate to the application.
Console.WriteLine("Errors occurred for the following feature: {0}",
invalidObjectInfo.InvalidObjectID);
}
}
/// <summary>
/// shape图层入库
/// </summary>
/// <param name="sourceworkspace"></param>
/// <param name="targetworkspace"></param>
/// <param name="nameOfsourceFeatureClass"></param>
/// <param name="nameOftargetFeatureClass"></param>
/// <returns></returns>
public IFeatureClass ShapeFileIntoGDB(IWorkspace sourceworkspace, IWorkspace targetworkspace,
string nameOfsourceFeatureClass, string nameOftargetFeatureClass)
{
try
{
//创建源工作空间
IDataset sourceWorkspaceDataset = (IDataset)sourceworkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//创建源数据集
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfsourceFeatureClass;
//创建目标工作空间
IDataset targetWorkspaceDataset = (IDataset)targetworkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//创建目标数据集
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOftargetFeatureClass;
//源数据集的字段集
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//验证字段
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
//设置验证的对象
fieldChecker.InputWorkspace = sourceworkspace;
fieldChecker.ValidateWorkspace = targetworkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
//找到空间对象字段
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
//得到空间字段的定义
IGeometryDef geometryDef = geometryField.GeometryDef;
//得到空间字段的索引
IGeometryDefEdit targetFCGeometryDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeometryDefEdit.GridCount_2 = 1;
targetFCGeometryDefEdit.set_GridSize(0, 0);
//targetFCGeometryDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
ISpatialReferenceFactory spatialReferenceFactory = new SpatialReferenceEnvironmentClass();
ISpatialReference spatialReference = DataEditCommon.g_pMap.SpatialReference;
//spatialReferenceFactory.CreateProjectedCoordinateSystem((int)esriSRProjCSType.esriSRProjCS_NAD1983UTM_20N);
ISpatialReferenceResolution spatialReferenceResolution = (ISpatialReferenceResolution)spatialReference;
spatialReferenceResolution.ConstructFromHorizon();
spatialReferenceResolution.SetDefaultXYResolution();
spatialReferenceResolution.SetDefaultZResolution();
ISpatialReferenceTolerance spatialReferenceTolerance = (ISpatialReferenceTolerance)spatialReference;
spatialReferenceTolerance.SetMinimumXYTolerance();
spatialReferenceTolerance.SetMinimumZTolerance();
double XMin, XMax, YMin, YMax, ZMin, ZMax, MinXYTolerance, MinZTolerance;
XMin = 4054.3603997438;
XMax = 78088.6926632544;
YMin = 14424.8510028409;
YMax = 59609.4812606697;
ZMin = 30330.1483519995;
ZMax = 38389.3283520005;
//spatialReference.SetDomain(XMin, XMax, YMin, YMax);
//spatialReference.SetZDomain(ZMin, ZMax);
MinXYTolerance = 0.000000000008219;
MinZTolerance = 0.000000000007629;
//spatialReferenceTolerance.SetMinimumZTolerance( MinXYTolerance);
//spatialReference.GetDomain(out XMin, out XMax, out YMin, out YMax);
//spatialReference.GetZDomain(out ZMin, out ZMax);
targetFCGeometryDefEdit.SpatialReference_2 = spatialReference;
//开始导入
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
//导入所有的输入对象
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass(sourceFeatureClassName,
queryFilter, null, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
//导入后数据集的字段集
IName targetName = (IName)targetFeatureClassName;
IFeatureClass targetFeatureClass = (IFeatureClass)targetName.Open();
return(targetFeatureClass);
}
catch (Exception ex)
{
return(null);
}
}
/// <summary>
/// 将GDB的数据入到SDE中 xisheng 20110919
/// </summary>
private void ImportGDBToSDE(string file, string outfilename, out int featurecount)
{
m_success = false;//初始化
try
{
string filepath = file.Substring(0, file.LastIndexOf("---"));
string filename = file.Substring(file.LastIndexOf("-") + 1);
//打开mdb文件所在的工作空间
ESRI.ArcGIS.Geodatabase.IWorkspaceFactory wf = new FileGDBWorkspaceFactory();
IFeatureWorkspace pFeatureWorkspaceGDB = wf.OpenFromFile(@filepath, 0) as IFeatureWorkspace;
IWorkspace pWorkspaceGDB = pFeatureWorkspaceGDB as IWorkspace;
// 创建源工作空间名称
IDataset sourceWorkspaceDataset = (IDataset)pFeatureWorkspaceGDB;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//创建源数据集名称
//IFeatureClassName sourceFeatureClassName = serverContext.CreateObject("esriGeoDatabase.FeatureClassName") as IFeatureClassName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = filename;
//打开存在的工作空间，作为导入的空间;
IFeatureWorkspace pFeatureWorkspace = (IFeatureWorkspace)pTargetworkspace;
//创建目标工作空间名称
IDataset targetWorkspaceDataset = (IDataset)pTargetworkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
IWorkspace2 pWorkspace2 = pTargetworkspace as IWorkspace2;
IFeatureDataset tmpfeaturedataset;
//创建目标数据集名称
// IFeatureClassName targetFeatureClassName = serverContext.CreateObject("esriGeoDatabase.FeatureClassName") as IFeatureClassName;
//判断要素是否存在，若存在将删除源文件
if (pWorkspace2.get_NameExists(esriDatasetType.esriDTFeatureDataset, textBox.Text))
{
tmpfeaturedataset = pFeatureWorkspace.OpenFeatureDataset(textBox.Text);
if (text_prj.Text != "")
{
IGeoDatasetSchemaEdit pgeodataset = tmpfeaturedataset as IGeoDatasetSchemaEdit;
if (pgeodataset.CanAlterSpatialReference)
{
pgeodataset.AlterSpatialReference(GetSpatialReferenceformFile(text_prj.Text));
}
}
}
else
{
tmpfeaturedataset = CreateFeatureDataset(pTargetworkspace as IFeatureWorkspace, textBox.Text, text_prj.Text);
}
if (pWorkspace2.get_NameExists(esriDatasetType.esriDTFeatureClass, outfilename))
{
IFeatureClass tmpfeatureclass;
tmpfeatureclass = pFeatureWorkspace.OpenFeatureClass(outfilename);
IDataset tempset = tmpfeatureclass as IDataset;
tempset.Delete();
}
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = outfilename;
//目标数据集
IFeatureDatasetName outfeaturedatasetname = tmpfeaturedataset.FullName as IFeatureDatasetName;
//打开输入的要素类以得到字段定义
ESRI.ArcGIS.esriSystem.IName sourceName = (ESRI.ArcGIS.esriSystem.IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();//打开源要素类
//验证字段名称，因为你正在不同类型的工作空间之间进行数据转换
//IFieldChecker fieldChecker = serverContext.CreateObject("esriGeoDatabase.FieldChecker") as IFieldChecker;
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IFields targetFeatureClassFields;
IEnumFieldError enumFieldError;
//最重要的设置输入和验证工作空间
fieldChecker.InputWorkspace = pWorkspaceGDB;
fieldChecker.ValidateWorkspace = pTargetworkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
//遍历所有输出字段找到几何字段
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
if (targetFeatureClassFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = targetFeatureClassFields.get_Field(i);
//得到几何字段的几何定义
IGeometryDef geometryDef = geometryField.GeometryDef;
//赋予几何定义一个空间索引格网数目和格网大小值
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
//允许ArcGIS为数据加载确定一个有效的格网大小
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
//转换要素类中所有的要素
//IQueryFilter queryFilter = serverContext.CreateObject("esriGeoDatabase.QueryFilter") as IQueryFilter; ;
QueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
//加载要素类
//IFeatureDataConverter fctofc = serverContext.CreateObject("esriGeoDatabase.FeatureDataConverter") as IFeatureDataConverter;
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors = fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter, outfeaturedatasetname, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
}
}
featurecount = sourceFeatureClass.FeatureCount(null);
m_success = true;
}
catch (Exception ee) { m_success = false; m_strErr = ee.Message; featurecount = 0; }
}
/// <summary>
/// convert featureclass in shapefile
/// </summary>
/// <param name="sourceWorkspace">oggetto workspace</param>
/// <param name="outputName">nome feature class e nome shapefile</param>
/// <param name="targetWorkspacePath">cartella shapefile</param>
/// <param name="errorField">lista degli eventuali errori nella creazione dei campi</param>
/// <param name="invalidObject">lista degli eventuale errori di creazione record</param>
private void ConvertFeatureClassToShapefile(IWorkspace sourceWorkspace, string outputName, string targetWorkspacePath, ref List <string> errorField, ref List <string> invalidObject)
{
IWorkspace targetWorkspace = null;
try
{
Type factoryType = Type.GetTypeFromProgID("esriDataSourcesFile.ShapefileWorkspaceFactory");
IWorkspaceFactory targetWorkspaceFactory = (IWorkspaceFactory)Activator.CreateInstance(factoryType);
targetWorkspace = targetWorkspaceFactory.OpenFromFile(targetWorkspacePath, 0);
// Cast the workspaces to the IDataset interface and get name objects.
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IName sourceWorkspaceDatasetName = sourceWorkspaceDataset.FullName;
IName targetWorkspaceDatasetName = targetWorkspaceDataset.FullName;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDatasetName;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDatasetName;
// Create a name object for the shapefile and cast it to the IDatasetName interface.
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.Name = outputName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
// Create a name object for the FGDB feature class and cast it to the IDatasetName interface.
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = outputName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
// Open source feature class to get field definitions.
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
// Create the objects and references necessary for field validation.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFields = sourceFeatureClass.Fields;
IFields targetFields = null;
IEnumFieldError enumFieldError = null;
// Set the required properties for the IFieldChecker interface.
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
// Validate the fields and check for errors.
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
if (enumFieldError != null)
{
IFieldError fieldError = null;
enumFieldError.Reset();
while ((fieldError = enumFieldError.Next()) != null)
{
errorField.Add($"Errore: {Enum.GetName(typeof(esriFieldNameErrorType), fieldError.FieldError)} - Campo: {targetFields.get_Field(fieldError.FieldIndex).Name}");
}
}
// Find the shape field.
string shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
// Get the geometry definition from the shape field and clone it.
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
// Create the converter and run the conversion.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject =
featureDataConverter.ConvertFeatureClass(sourceFeatureClassName,
null, null, targetFeatureClassName, targetGeometryDef, targetFields,
string.Empty, 1000, 0);
// Check for errors.
IInvalidObjectInfo invalidObjectInfo = null;
enumInvalidObject.Reset();
while ((invalidObjectInfo = enumInvalidObject.Next()) != null)
{
invalidObject.Add($"{invalidObjectInfo.InvalidObjectID}");
}
}
catch
{
throw;
}
finally
{
if (targetWorkspace != null)
{
Marshal.FinalReleaseComObject(targetWorkspace);
}
}
}
/// <summary>
/// 拷贝源图层到空间数据集下的目标图层
/// </summary>
/// <param name="sourceWorkspace"></param>
/// <param name="targetWorkspace"></param>
/// <param name="nameOfSourceFeatureClass"></param>
/// <param name="nameOfTargetFeatureClass"></param>
public static void ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace,
string nameOfSourceFeatureClass, string nameOfTargetFeatureClass)
{
try
{
//create source workspace name
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
//create source dataset name
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = nameOfSourceFeatureClass;
//create target workspace name
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
//create target dataset name
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = nameOfTargetFeatureClass;
//Open input Featureclass to get field definitions.
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
//Validate the field names because you are converting between different workspace types.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
// Most importantly set the input and validate workspaces!
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
// Loop through the output fields to find the geomerty field
IField geometryField;
for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
{
geometryField = targetFeatureClassFields.get_Field(i);
if (geometryField.Type == esriFieldType.esriFieldTypeGeometry)
{
// Get the geometry field's geometry defenition
IGeometryDef geometryDef = geometryField.GeometryDef;
//Give the geometry definition a spatial index grid count and grid size
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
//targetFCGeoDefEdit.GridCount_2 = 1;
//targetFCGeoDefEdit.set_GridSize(0, 1000);
//Allow ArcGIS to determine a valid grid size for the data loaded
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
// we want to convert all of the features
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IEnumDataset pEnumDataset = targetWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
IFeatureDataset ipDataset = (IFeatureDataset)pEnumDataset.Next();
IDatasetName pTargetDsName = (IDatasetName)ipDataset.FullName;
// Load the feature class
IFeatureDataConverter fctofc = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fctofc.ConvertFeatureClass(sourceFeatureClassName, queryFilter,
pTargetDsName as IFeatureDatasetName, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
IInvalidObjectInfo obj = enumErrors.Next();
break;
}
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
/// <summary>
/// Exports the source table using the query filter to the table in the output workspace.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="filter">The filter.</param>
/// <param name="tableName">Name of the output table.</param>
/// <param name="workspace">The workspace.</param>
/// <param name="handle">The handle.</param>
/// <param name="surrogate">The surrogate for the event handler.</param>
/// <param name="errors">The errors that occured during the export.</param>
/// <returns>
/// Returns a <see cref="ITable" /> representing the feature class that was exported.
/// </returns>
public static ITable Export(this ITable source, IQueryFilter filter, string tableName, IWorkspace workspace, int handle, FeatureProgress surrogate, out IEnumInvalidObject errors)
{
IEnumFieldError fieldError;
return(source.Export(filter, tableName, workspace, source.Fields, handle, surrogate, out errors, out fieldError));
}
/// <summary>
/// 拷贝源图层到空间数据集下的目标图层
/// </summary>
/// <param name="sourceWorkspace">源Workspace</param>
/// <param name="targetWorkspace">目标Workspace</param>
/// <param name="sourceClassName">源图层</param>
/// <param name="destClassName">待创建的图层名</param>
public static bool ConvertFeatureClass(IWorkspace sourceWorkspace, IWorkspace targetWorkspace,
string sourceClassName, string destClassName)
{
try
{
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDataset.FullName;
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
sourceDatasetName.Name = sourceClassName;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDataset.FullName;
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.WorkspaceName = targetWorkspaceName;
targetDatasetName.Name = destClassName;
IName sourceName = (IName)sourceFeatureClassName;
IFeatureClass sourceFeatureClass = (IFeatureClass)sourceName.Open();
IFields targetFeatureClassFields;
IFields sourceFeatureClassFields = sourceFeatureClass.Fields;
IEnumFieldError enumFieldError;
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);
IField geometryField = targetFeatureClassFields.get_Field(targetFeatureClassFields.FindField(sourceFeatureClass.ShapeFieldName));
//for (int i = 0; i < targetFeatureClassFields.FieldCount; i++)
//{
// geometryField = targetFeatureClassFields.get_Field(i);
// if (geometryField.Type == esriFieldType.esriFieldTypeGeometry)
// {
IGeometryDef geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.WhereClause = "";
IEnumDataset pEnumDataset = targetWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
IFeatureDataConverter fConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumErrors =
fConverter.ConvertFeatureClass(sourceFeatureClassName, queryFilter,
null, targetFeatureClassName,
geometryDef, targetFeatureClassFields, "", 1000, 0);
IInvalidObjectInfo obj = enumErrors.Next();
// break;
// }
//}
return(true);
}
catch (Exception exp)
{
return(false);
}
}
public void DataImport(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, IFeatureClass sourceFeatureClass, IDataset targetFeatureDataset, string storeName)
{
int errorRowCount = 0;
int totalRowCount = 0;
Dictionary <int, string> dicError = new Dictionary <int, string>();
IDataset sourceWorkspaceDataset = (IDataset)sourceWorkspace;
IDataset targetWorkspaceDataset = (IDataset)targetWorkspace;
string sourceLayerName = ((IDataset)sourceFeatureClass).Name;
IName sourceWorkspaceDatasetName = sourceWorkspaceDataset.FullName;
IName targetWorkspaceDatasetName = targetWorkspaceDataset.FullName;
IWorkspaceName sourceWorkspaceName = (IWorkspaceName)sourceWorkspaceDatasetName;
IWorkspaceName targetWorkspaceName = (IWorkspaceName)targetWorkspaceDatasetName;
// Create a name object for the shapefile and cast it to the IDatasetName interface.
IFeatureClassName sourceFeatureClassName = new FeatureClassNameClass();
IDatasetName sourceDatasetName = (IDatasetName)sourceFeatureClassName;
sourceDatasetName.Name = sourceLayerName;
sourceDatasetName.WorkspaceName = sourceWorkspaceName;
// Create a name object for the FGDB feature class and cast it to the IDatasetName interface.
IFeatureClassName targetFeatureClassName = new FeatureClassNameClass();
IDatasetName targetDatasetName = (IDatasetName)targetFeatureClassName;
targetDatasetName.Name = storeName;// importMappingScheme.StoreDatasetName;"GEODATA.DLTB7"
targetDatasetName.WorkspaceName = targetWorkspaceName;
// Create the objects and references necessary for field validation.
IFieldChecker fieldChecker = new FieldCheckerClass();
IFields sourceFields = sourceFeatureClass.Fields;
IFields targetFields = null;
IEnumFieldError enumFieldError = null;
// Set the required properties for the IFieldChecker interface.
fieldChecker.InputWorkspace = sourceWorkspace;
fieldChecker.ValidateWorkspace = targetWorkspace;
// Validate the fields and check for errors.
fieldChecker.Validate(sourceFields, out enumFieldError, out targetFields);
// Find the shape field.
String shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFields.get_Field(shapeFieldIndex);
// Get the geometry definition from the shape field and clone it.
IGeometryDef geometryDef = shapeField.GeometryDef;
IClone geometryDefClone = (IClone)geometryDef;
IClone targetGeometryDefClone = geometryDefClone.Clone();
IGeometryDef targetGeometryDef = (IGeometryDef)targetGeometryDefClone;
// Cast the IGeometryDef to the IGeometryDefEdit interface.
IGeometryDefEdit targetGeometryDefEdit = (IGeometryDefEdit)targetGeometryDef;
// Set the IGeometryDefEdit properties.
targetGeometryDefEdit.GridCount_2 = 1;
targetGeometryDefEdit.set_GridSize(0, 0.75);
//修改目标字段
string fieldNameString = ChangeTargetFields(targetFields);
if (fieldNameString != string.Empty)
{
fieldNameString += string.Format(",{0}", shapeFieldName);
}
else
{
fieldNameString = shapeFieldName;
}
IQueryFilter queryFilter = new QueryFilterClass();
queryFilter.SubFields = fieldNameString;
//设置导出的要素集
IFeatureDatasetName featureDatasetName = null;
if (targetFeatureDataset != null)
{
featureDatasetName = (IFeatureDatasetName)targetFeatureDataset.FullName;
}
// Create the converter and run the conversion.
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
IEnumInvalidObject enumInvalidObject = featureDataConverter.ConvertFeatureClass
(sourceFeatureClassName, queryFilter, featureDatasetName, targetFeatureClassName,
targetGeometryDef, targetFields, "", 1000, 0);
// Check for errors.
IInvalidObjectInfo invalidObjectInfo = null;
enumInvalidObject.Reset();
while ((invalidObjectInfo = enumInvalidObject.Next()) != null)
{
if (dicError.ContainsKey(invalidObjectInfo.InvalidObjectID) == false)
{
// Handle the errors in a way appropriate to the application.
dicError.Add(invalidObjectInfo.InvalidObjectID, invalidObjectInfo.ErrorDescription);
errorRowCount++;
}
Console.WriteLine(invalidObjectInfo.InvalidObjectID + "" + invalidObjectInfo.ErrorDescription);
}
}
