/// <summary>
/// 导出要素类到目标工作空间
/// </summary>
/// <param name="featureClass"></param>
/// <param name="workspace"></param>
/// <param name="queryGeometry"></param>
/// <param name="spatialRelEnum"></param>
/// <param name="whereClause"></param>
/// <returns></returns>
public static Boolean ExportToWorkspace(IFeatureClass featureClass, IWorkspace workspace, IGeometry queryGeometry = null, esriSpatialRelEnum spatialRelEnum = esriSpatialRelEnum.esriSpatialRelIntersects, string whereClause = "")
{
IDataset inDataSet = featureClass as IDataset;
IFeatureClassName inFCName = inDataSet.FullName as IFeatureClassName;
IWorkspace inWorkspace = inDataSet.Workspace;
IDataset outDataSet = workspace as IDataset;
IWorkspaceName outWorkspaceName = outDataSet.FullName as IWorkspaceName;
IFeatureClassName outFCName = new FeatureClassNameClass();
IDatasetName dataSetName = outFCName as IDatasetName;
dataSetName.WorkspaceName = outWorkspaceName;
dataSetName.Name = inDataSet.Name;
IFieldChecker fieldChecker = new FieldCheckerClass
{
InputWorkspace = inWorkspace,
ValidateWorkspace = workspace
};
IFields fields = featureClass.Fields;
fieldChecker.Validate(fields, out IEnumFieldError enumFieldError, out IFields outFields);
IFeatureDataConverter featureDataConverter = null;
IField geometryField;
try
{
IGeometryDef geometryDef = null;
ISpatialFilter pSF = new SpatialFilterClass();
for (int i = 0; i < outFields.FieldCount; i++)
{
if (outFields.get_Field(i).Type == esriFieldType.esriFieldTypeGeometry)
{
geometryField = outFields.get_Field(i);
geometryDef = geometryField.GeometryDef;
IGeometryDefEdit targetFCGeoDefEdit = (IGeometryDefEdit)geometryDef;
targetFCGeoDefEdit.GridCount_2 = 1;
targetFCGeoDefEdit.set_GridSize(0, 0);
targetFCGeoDefEdit.SpatialReference_2 = geometryField.GeometryDef.SpatialReference;
pSF.Geometry = queryGeometry;
pSF.GeometryField = featureClass.ShapeFieldName;
pSF.SpatialRel = spatialRelEnum;
pSF.WhereClause = whereClause;
break;
}
}
featureDataConverter = new FeatureDataConverterClass();
featureDataConverter.ConvertFeatureClass(inFCName, pSF, null, outFCName, geometryDef, outFields, " ", 1000, 0);
return(true);
}
catch (Exception ex)
{
LOG.Error("图层数据导出出错！" + ex.Message);
throw ex;
}
}
private void ExportFeature(IFeatureClass pInFeatureClass, string pPath)
{
//创建一个输出shp文件的工作空间
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
string parentPath = pPath.Substring(0, pPath.LastIndexOf("\\"));
string fileName = pPath.Substring(pPath.LastIndexOf("\\") + 1, pPath.Length - pPath.LastIndexOf("\\") - 1);
IWorkspaceName pWorkspaceName = pWorkspaceFactory.Create(parentPath, fileName, null, 0);
//创建一个要素类
IName name = (IName)pWorkspaceName;
IWorkspace pOutWorkspace = (IWorkspace)name.Open();
IDataset pInDataset = pInFeatureClass as IDataset;
IFeatureClassName pInFCName = pInDataset.FullName as IFeatureClassName;
IWorkspace pInWorkspace = pInDataset.Workspace;
IDataset pOutDataset = pOutWorkspace as IDataset;
IWorkspaceName pOutWorkspaceName = pOutDataset.FullName as IWorkspaceName;
IFeatureClassName pOutFCName = new FeatureClassNameClass();
IDatasetName pDatasetName = pOutFCName as IDatasetName;
pDatasetName.WorkspaceName = pOutWorkspaceName;
pDatasetName.Name = pInFeatureClass.AliasName;
IFieldChecker pFieldChecker = new FieldCheckerClass();
pFieldChecker.InputWorkspace = pInWorkspace;
pFieldChecker.ValidateWorkspace = pOutWorkspace;
IFields pFields = pInFeatureClass.Fields;
IFields pOutFields;
IEnumFieldError pEnumFieldError;
pFieldChecker.Validate(pFields, out pEnumFieldError, out pOutFields);
IFeatureDataConverter pFeatureDataConverter = new FeatureDataConverterClass();
pFeatureDataConverter.ConvertFeatureClass(pInFCName, null, null, pOutFCName, null, pOutFields, "", 100, 0);
}
public void ExportFeature(IFeatureClass pInFeatureClass, string pPath)
{
// create a new Access workspace factory
IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
string parentPath = pPath.Substring(0, pPath.LastIndexOf('\\'));
string fileName = pPath.Substring(pPath.LastIndexOf('\\') + 1, pPath.Length - pPath.LastIndexOf('\\') - 1);
IWorkspaceName pWorkspaceName = pWorkspaceFactory.Create(parentPath, fileName, null, 0);
// Cast for IName
IName name = (IName)pWorkspaceName;
//Open a reference to the access workspace through the name object
IWorkspace pOutWorkspace = (IWorkspace)name.Open();
IDataset pInDataset = pInFeatureClass as IDataset;
IFeatureClassName pInFCName = pInDataset.FullName as IFeatureClassName;
IWorkspace pInWorkspace = pInDataset.Workspace;
IDataset pOutDataset = pOutWorkspace as IDataset;
IWorkspaceName pOutWorkspaceName = pOutDataset.FullName as IWorkspaceName;
IFeatureClassName pOutFCName = new FeatureClassNameClass();
IDatasetName pDatasetName = pOutFCName as IDatasetName;
pDatasetName.WorkspaceName = pOutWorkspaceName;
pDatasetName.Name = pInFeatureClass.AliasName;
IFieldChecker pFieldChecker = new FieldCheckerClass();
pFieldChecker.InputWorkspace = pInWorkspace;
pFieldChecker.ValidateWorkspace = pOutWorkspace;
IFields pFields = pInFeatureClass.Fields;
IFields pOutFields;
IEnumFieldError pEnumFieldError;
pFieldChecker.Validate(pFields, out pEnumFieldError, out pOutFields);
IFeatureDataConverter pFeatureDataConverter = new FeatureDataConverterClass();
pFeatureDataConverter.ConvertFeatureClass(pInFCName, null, null, pOutFCName, null, pOutFields, "", 100, 0);
}
/// <summary>
///
/// </summary>
/// <param name="featureClass"></param>
public static void ExportFeatureClassToShpDlg(IFeatureClassName featureClassName)
{
IName name = featureClassName as IName;
IFeatureClass featureClass = name.Open() as IFeatureClass;
ExportFeatureClassToShpDlg(featureClass);
}
public static IFeatureClassName GetFeatureClassName(IFeatureDatasetName pFeatureDatasetName, string featureClassName)
{
IDatasetName pContainDSName;
pContainDSName = (IDatasetName)pFeatureDatasetName;
IEnumDatasetName pEnumDsName4FC = (IEnumDatasetName)pFeatureDatasetName.FeatureClassNames;
IFeatureClassName pfeaClsName = (IFeatureClassName)pEnumDsName4FC.Next();
IDatasetName pFC_DSName;
try
{
while (pfeaClsName != null)
{
pFC_DSName = (IDatasetName)pfeaClsName;
if (pFC_DSName.Name == featureClassName)
{
return(pfeaClsName);
}
pfeaClsName = (IFeatureClassName)pEnumDsName4FC.Next();
}
}
catch
{
}
return(null);
}
IEnumInvalidObject ESRI.ArcGIS.Geodatabase.IFeatureDataConverter2.ConvertFeatureClass(
IDatasetName idatasetName_0, IQueryFilter iqueryFilter_0, ISelectionSet iselectionSet_0,
IFeatureDatasetName ifeatureDatasetName_0, IFeatureClassName ifeatureClassName_0,
IGeometryDef igeometryDef_0, IFields ifields_0, string string_0, int int_0, int int_1)
{
return(null);
}
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>
/// Saves as shpfile.
/// </summary>
/// <param name="inputFeatureClass">The input feature class.</param>
/// <param name="pInDataset">The p in dataset.</param>
/// <param name="fileName">Name of the file.</param>
/// <param name="pOutWorkspace">The p out workspace.</param>
private void SaveAsShpfile(IFeatureClass inputFeatureClass, IDataset pInDataset, string fileName, IWorkspace pOutWorkspace)
{
IFeatureClassName inputDatasetName = pInDataset.FullName as IFeatureClassName;
IWorkspace workspace = pInDataset.Workspace;
IDataset dataset = pOutWorkspace as IDataset;
IWorkspaceName workspaceName = dataset.FullName as IWorkspaceName;
IFeatureClassName featureClassName = new FeatureClassNameClass();
IDatasetName datasetName = featureClassName as IDatasetName;
datasetName.WorkspaceName = workspaceName;
datasetName.Name = fileName;
IFieldChecker fieldChecker = new FieldCheckerClass();
fieldChecker.InputWorkspace = workspace;
fieldChecker.ValidateWorkspace = pOutWorkspace;
IFields fields = inputFeatureClass.Fields;
IEnumFieldError enumFieldError;
IFields outputFields;
fieldChecker.Validate(fields, out enumFieldError, out outputFields);
IFeatureDataConverter featureDataConverter = new FeatureDataConverterClass();
featureDataConverter.ConvertFeatureClass(inputDatasetName, null, null, featureClassName, null, outputFields, "", 100, 0);
XtraMessageBox.Show(AppMessage.MSG0029, AppMessage.MSG0000, System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Asterisk);
}
public void TransferMapDataWithinExtents_Test(string subDirectory, string mapDocumentFilename, string dataframeName, string outputShapefileDirectory)
{
string temp = System.IO.Path.Combine(_dataDirectory, subDirectory);
string mapDoc = System.IO.Path.Combine(temp, mapDocumentFilename);
IMapDocument mapDocument = new MapDocumentClass();
mapDocument.Open(mapDoc, null);
IMap map = GeodatabaseUtil.GetMap(mapDocument, dataframeName);
List <IFeatureLayer> layers = GeodatabaseUtil.GetFeatureLayers(map);
IDataset dataset = (IDataset)layers[0].FeatureClass;
IGeoDataset geoDataset = (IGeoDataset)layers[0].FeatureClass;
string destination = System.IO.Path.Combine(temp, outputShapefileDirectory);
if (Directory.Exists(destination))
{
Directory.Delete(destination, true);
}
Directory.CreateDirectory(destination);
IWorkspace outWorkspace = GeodatabaseUtil.GetShapefileWorkspace(destination);
IFeatureWorkspace outFeatureWorkspace = (IFeatureWorkspace)outWorkspace;
IWorkspaceName outWorkspaceName = GeodatabaseUtil.GetWorkspaceName(outWorkspace);
IFeatureClassName outFeatureclassName = GeodatabaseUtil.GetFeatureClassName(outWorkspaceName, dataset.Name);
//ESRI.ArcGIS.ADF.Web.Geometry.Envelope envelope = new ESRI.ArcGIS.ADF.Web.Geometry.Envelope(227884.141, 4167884.377, 602406.528, 4470244.455);
ESRI.ArcGIS.ADF.Web.Geometry.Envelope envelope = new ESRI.ArcGIS.ADF.Web.Geometry.Envelope(445092.693, 4360557.744, 541068.565, 4418287.592);
Dictionary <int, KeyValuePair <string, IEnumInvalidObject> > invalidObjects = GeodatabaseUtil.TransferMapDataWithinExtents(map, outFeatureWorkspace, null, envelope, geoDataset.SpatialReference);
}
private void ExportDatasetToXML(string fileGdbPath, string sourceFCName, string outputXmlFile)
{
// Open the source geodatabase and create a name object for it.
IWorkspaceName sourceWorkspaceName = getWorkspaceName("esriDataSourcesGDB.FileGDBWorkspaceFactory", fileGdbPath);
IFeatureClassName sourceFeatureClassName = getFeatureClassName(sourceWorkspaceName, sourceFCName);
IName sourceName = (IName)sourceFeatureClassName;
// Create a new names enumerator and add the feature dataset name.
IEnumNameEdit enumNameEdit = new NamesEnumeratorClass();
enumNameEdit.Add(sourceName);
IEnumName enumName = (IEnumName)enumNameEdit;
// Create a GeoDBDataTransfer object and create a name mapping.
IGeoDBDataTransfer geoDBDataTransfer = new GeoDBDataTransferClass();
IEnumNameMapping enumNameMapping = null;
geoDBDataTransfer.GenerateNameMapping(enumName, sourceWorkspaceName as IName, out enumNameMapping);
// Create an exporter and export the dataset with binary geometry, not compressed,
// and including metadata.
IGdbXmlExport gdbXmlExport = new GdbExporterClass();
gdbXmlExport.ExportDatasets(enumNameMapping, outputXmlFile, true, false, true);
}
/// <summary>
/// 重置图层数据源
/// </summary>
/// <param name="pLayer"></param>
/// <param name="pNewWksp"></param>
/// <returns></returns>
public static bool ResetLayerDatasource(IDataLayer2 pLayer, IWorkspace pNewWksp)
{
if (pLayer == null || pNewWksp == null)
{
return(false);
}
//// 2012-06-15 张航宇
//// 直接获取Layer的数据源名称，从新的Workspace打开FeatureClass进行替换
//IDatasetName fClassName = pLayer.DataSourceName as IDatasetName;
//if (fClassName != null)
//{
// string strClassName = fClassName.Name;
// try
// {
// IFeatureClass fClass = (pNewWksp as IFeatureWorkspace).OpenFeatureClass(strClassName);
// pLayer.DataSourceName = (fClass as IDataset).FullName;
// }
// catch
// {
// return false;
// }
//}
IEnumDatasetName pEnumDsName = pNewWksp.get_DatasetNames(esriDatasetType.esriDTFeatureDataset);
IDatasetName pFtDsName = pEnumDsName.Next();
try
{
if (!pLayer.InWorkspace(pNewWksp))
{
IFeatureClassName pOldName = pLayer.DataSourceName as IFeatureClassName;
// 2012-06-15 张航宇
// 修改对没有Dataset的Workspace，直接将Workspace重置
if (pOldName != null)
{
if (pOldName.FeatureDatasetName == null || pFtDsName == null)
{
(pOldName as IDatasetName).WorkspaceName = (pNewWksp as IDataset).FullName as IWorkspaceName;
}
else
{
pOldName.FeatureDatasetName = pFtDsName;
pOldName.FeatureDatasetName.WorkspaceName = ((IDataset)pNewWksp).FullName as IWorkspaceName;
}
}
pLayer.Connect(pOldName as IName);
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return(false);
}
return(true);
}
/// <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));
}
/// <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);
}
}
public bool CanDisplayObject(IGxObject igxObject_0)
{
try
{
if ((igxObject_0 is IGxDiskConnection) || (igxObject_0 is IGxFolder))
{
return(true);
}
if (igxObject_0 is IGxDatabase)
{
return(true);
}
if (igxObject_0 is IGxDataset)
{
switch ((igxObject_0 as IGxDataset).Type)
{
case esriDatasetType.esriDTFeatureDataset:
return(true);
case esriDatasetType.esriDTFeatureClass:
{
IFeatureClassName datasetName = (igxObject_0 as IGxDataset).DatasetName as IFeatureClassName;
if (datasetName.FeatureType == esriFeatureType.esriFTSimple)
{
if (datasetName.ShapeType == esriGeometryType.esriGeometryNull)
{
IFeatureClass dataset = (igxObject_0 as IGxDataset).Dataset as IFeatureClass;
if (dataset.ShapeType == esriGeometryType.esriGeometryPolyline)
{
return(true);
}
}
else if (datasetName.ShapeType == esriGeometryType.esriGeometryPolyline)
{
return(true);
}
goto Label_00E5;
}
break;
}
}
}
else if (igxObject_0 is IGxObjectContainer)
{
return(true);
}
}
catch
{
}
Label_00E5:
return(false);
}
protected Dataset GetVectorDataset(IDatasetName datasetName)
{
IFeatureClassName fcName = (IFeatureClassName)datasetName;
var verifiedVectorDataset = new VerifiedVectorDataset(datasetName.Name)
{
GeometryType = fcName == null
? null
: GetGeometryType(
DatasetUtils
.GetShapeType(fcName))
};
return(verifiedVectorDataset);
}
public static IFeatureClass SelectFeatureClassDialog()
{
frmOpenFile frm = new frmOpenFile();
frm.AllowMultiSelect = false;
frm.AddFilter(new MyGxFilterFeatureClasses(), true);
frm.Text = @"选择要素类";
if (frm.DoModalOpen() == DialogResult.OK)
{
IGxObject gxObject = frm.Items.get_Element(0) as ArcGIS.Catalog.IGxObject;
IFeatureClassName className = gxObject.InternalObjectName as IFeatureClassName;
return(((IName)className).Open() as IFeatureClass);
}
return(null);
}
public void ExportOperationFileGDBToSDE(string fileGDBPath, string sourceFCName, string targetFCName)
{
// Create a name object for the source (file GDB) 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);
// 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();
// Find the shape field.
String shapeFieldName = sourceFeatureClass.ShapeFieldName;
int shapeFieldIndex = sourceFeatureClass.FindField(shapeFieldName);
IField shapeField = sourceFeatureClass.Fields.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.
IExportOperation exportOperation = new ExportOperationClass();
exportOperation.ExportFeatureClass(sourceFeatureClassName as IDatasetName, queryFilter, null, targetGeometryDef, targetFeatureClassName, 0);
}
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);
}
}
/// <summary>
/// 重置图层数据源
/// </summary>
/// <param name="pLayer"></param>
/// <param name="pNewWksp"></param>
/// <returns></returns>
public static bool ResetLayerDatasource2(IDataLayer2 pLayer, IWorkspace pNewWksp)
{
if (pLayer == null || pNewWksp == null)
{
return(false);
}
IEnumDataset pEnumDsName = pNewWksp.get_Datasets(esriDatasetType.esriDTFeatureDataset);
IDataset pFtDsName = pEnumDsName.Next();
IEnumDataset pEnumDs = pFtDsName.Subsets;
try
{
if (!pLayer.InWorkspace(pNewWksp))
{
IFeatureClassName pOldName = pLayer.DataSourceName as IFeatureClassName;
if (pOldName != null)
{
IDatasetName dsName = pOldName as IDatasetName;
IDataset pDs = null;
while ((pDs = pEnumDs.Next()) != null)
{
if (dsName.Name.Equals(pDs.Name, StringComparison.OrdinalIgnoreCase) ||
pDs.Name.Contains(dsName.Name.ToUpper()))
{
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
if (pFeatureLayer == null)
{
return(true);
}
pFeatureLayer.FeatureClass = pDs as IFeatureClass;
return(true);
}
}
}
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return(false);
}
return(true);
}
//从数据库中读取数据
//遍历选择的featureclass
public void Read_EntitiesFromDatabase()
{
string layerName;
IName pName;
IFeatureClassName pFcn;
IFeatureClass pFC;
//默认的输入图层与输出图层名字一样
//需要修改的时候与对照表对照
for (int i = 0; i < inputDs.Count; i++)
{
IDatasetName datasetName = inputDs.get_Item(i);
//feactureclass
if (datasetName.Type == esriDatasetType.esriDTFeatureClass)
{
pFcn = (IFeatureClassName)datasetName;
pName = (IName)pFcn;
pFC = (IFeatureClass)pName.Open();
layerName = datasetName.Name;
Read_Entity_0(pFC, layerName);
}
//dataset
if (datasetName.Type == esriDatasetType.esriDTFeatureDataset)
{
IFeatureDatasetName featureDatasetName = (IFeatureDatasetName)datasetName;
IEnumDatasetName enumDatasetNameFC = featureDatasetName.FeatureClassNames;
IDatasetName datasetNameFC = enumDatasetNameFC.Next();
while (datasetNameFC != null)
{
IFeatureClassName featureClassName = (IFeatureClassName)datasetNameFC;
pName = (IName)featureClassName;
pFC = (IFeatureClass)pName.Open();
layerName = datasetNameFC.Name;
Read_Entity_0(pFC, layerName);
datasetNameFC = enumDatasetNameFC.Next();
}
}
}
}
private string GetShapeTypeString(IFeatureClassName fName)
{
switch (fName.ShapeType)
{
case esriGeometryType.esriGeometryPoint:
return(" POINT");
case esriGeometryType.esriGeometryMultipoint:
return(" POINT");
case esriGeometryType.esriGeometryPolyline:
return(" LINE");
case esriGeometryType.esriGeometryPolygon:
return(" FILL");
}
return("");
}
public static IFeatureClass SelectFeatureClassDialog()
{
frmOpenFile frm = new frmOpenFile()
{
Text = @"添加数据",
AllowMultiSelect = false
};
frm.AddFilter(new MyGxFilterFeatureClasses(), true);
if (frm.DoModalOpen() == DialogResult.OK)
{
IGxObject gxObject = frm.Items.get_Element(0) as IGxObject;
IFeatureClassName className = gxObject.InternalObjectName as IFeatureClassName;
IFeatureClass featureClass = ((IName)className).Open() as IFeatureClass;
return(featureClass);
}
return(null);
}
private string method_1(IFeatureClassName ifeatureClassName_0)
{
switch (ifeatureClassName_0.ShapeType)
{
case esriGeometryType.esriGeometryPoint:
return(" POINT");
case esriGeometryType.esriGeometryMultipoint:
return(" POINT");
case esriGeometryType.esriGeometryPolyline:
return(" LINE");
case esriGeometryType.esriGeometryPolygon:
return(" FILL");
}
return("");
}
public void GetFeatureClassName_Test(string subDirectory, string pgdbFileName, string featureClassName)
{
string temp = System.IO.Path.Combine(_dataDirectory, subDirectory);
string pgdbFile = System.IO.Path.Combine(temp, pgdbFileName);
IFeatureClassName fcName = GeodatabaseUtil.GetFeatureClassName(GeodatabaseUtil.GetPGDBWorkspaceName(pgdbFile), featureClassName);
Assert.IsNotNull(fcName, "Unable to get the IFeatureClassName for the FeatureClass '" + featureClassName + "' in the pgdb file '" + pgdbFile + "'.");
IName name = (IName)fcName;
if (name != null)
{
Assert.IsNotNull(name.Open(), "FeatureClass name obtained was invalid.");
}
else
{
Assert.Fail("Unable to run test. A valid IName reference could not be obtained.");
}
}
/// <summary>
/// 复制数据到另一张表
/// </summary>
/// <param name="outZWorkspace">目标工作空间</param>
/// <param name="name">目标图层名</param>
/// <param name="filter">查询条件</param>
public void CopyTo(ZWorkspace outZWorkspace, string name, ZFilter filter)
{
// 数据源
IFeatureClassName inputFClassName = ((IDataset)featureClass).FullName as IFeatureClassName;
// 目标数据集
IDataset outDataSet = outZWorkspace.workspace as IDataset;
IWorkspaceName outWorkspaceName = outDataSet.FullName as IWorkspaceName;
// 目标图层
IFeatureClassName outputFClassName = new FeatureClassNameClass();
IDatasetName dataSetName = outputFClassName as IDatasetName;
dataSetName.WorkspaceName = outWorkspaceName;
dataSetName.Name = name;
// 导出
FeatureDataConverterClass converter = new FeatureDataConverterClass();
converter.ConvertFeatureClass(inputFClassName, filter.Value, null, outputFClassName, null, featureClass.Fields, "", 100, 0);
// 释放资源
Marshal.ReleaseComObject(converter);
}
/// <summary>
/// 叠置分析
/// </summary>
/// <param name="axmapcontrol"></param>
/// <param name="i">图层索引</param>
/// <param name="name">输出图层名字</param>
/// <returns></returns>
public static FeatureLayer Stastic(AxMapControl axmapcontrol, int i, string name)
{
if (axmapcontrol == null || axmapcontrol.LayerCount < 2)
{
return(null);
}
// pLayer = axmapcontrol.Map.Layer(0);
ILayer pLayer = axmapcontrol.ActiveView.FocusMap.get_Layer(i);
IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
ITable table = pFeatureClass as ITable;
pLayer = axmapcontrol.ActiveView.FocusMap.get_Layer(axmapcontrol.LayerCount - 1);
IFeatureLayer ppFeatureLayer = (IFeatureLayer)pLayer;
IFeatureClass ppFeatureClass = ppFeatureLayer.FeatureClass;
ITable ptable = (ITable)ppFeatureClass;
//Intersect intersect=new Intersect()
Double tol = 0.0;
IWorkspaceFactory wspfctry = new ShapefileWorkspaceFactory();
IWorkspace pWorkSpace = wspfctry.OpenFromFile(SystemSet.Base_Map + "\\处理数据库\\实验数据", 0);
IDataset pDataset = (IDataset)pWorkSpace;
IName pName = pDataset.FullName;
IDatasetName pDatasetName = new FeatureClassNameClass();
pDatasetName.Name = name;
pDatasetName.WorkspaceName = (IWorkspaceName)pName;
IFeatureClassName fcn = (IFeatureClassName)pDatasetName;
IBasicGeoprocessor pBG = new BasicGeoprocessor();
IFeatureClass pOutFeatureClass = pBG.Intersect(table, false, ptable, false, tol, fcn);
IFeatureLayer pOutFeatLayer = new FeatureLayerClass();
FeatureLayer featurelayer = (FeatureLayer)pOutFeatLayer;
featurelayer.FeatureClass = pOutFeatureClass;
featurelayer.Name = pOutFeatureClass.AliasName;
return(featurelayer);
}
private string method_2(IFeatureClassName ifeatureClassName_0)
{
if (ifeatureClassName_0.FeatureType == esriFeatureType.esriFTAnnotation)
{
return(" Annontion");
}
switch (ifeatureClassName_0.ShapeType)
{
case esriGeometryType.esriGeometryPoint:
return(" POINT");
case esriGeometryType.esriGeometryMultipoint:
return(" POINT");
case esriGeometryType.esriGeometryPolyline:
return(" LINE");
case esriGeometryType.esriGeometryPolygon:
return(" FILL");
}
return("");
}
/// <summary>
/// 导出图层中选定要素到单独的shp文件
/// </summary>
/// <param name="featureLayer">要素图层</param>
/// <param name="selectionSet">要素选择集</param>
/// <param name="outName">输出shp文件路径</param>
public void exportSelectedFeatureToShp(IFeatureLayer featureLayer, ISelectionSet selectionSet, string outName)
{
if (featureLayer == null)
{
return;
}
if (!Directory.Exists(System.IO.Path.GetDirectoryName(outName)))
{
return;
}
// 裁剪要素
IDataset dataset = featureLayer as IDataset;
IFeatureClassName infeatClassName = dataset.FullName as IFeatureClassName;
IDatasetName datasetName = infeatClassName as IDatasetName;
// 输出要素类
IFeatureClassName outFeatClassName = new FeatureClassName() as IFeatureClassName;
outFeatClassName.FeatureType = esriFeatureType.esriFTSimple;
outFeatClassName.ShapeType = ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryAny;
outFeatClassName.ShapeFieldName = "Shape";
// 输出文件
IDatasetName outDatasetName = outFeatClassName as IDatasetName;
outDatasetName.Name = System.IO.Path.GetFileNameWithoutExtension(outName);
IWorkspaceName workspaceName = new WorkspaceName() as IWorkspaceName;
workspaceName.PathName = System.IO.Path.GetDirectoryName(outName);
workspaceName.WorkspaceFactoryProgID = "esriDataSourcesGDB.ShapefileWorkspaceFactory";
outDatasetName.WorkspaceName = workspaceName;
// 导出
IExportOperation exportOper = new ExportOperation();
exportOper.ExportFeatureClass(datasetName, null, selectionSet, null, outFeatClassName, 0);
}
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);
}
private void btnLayer_Click(object sender, EventArgs e)
{
frmOpenFile openFile = new frmOpenFile();
openFile.AllowMultiSelect = false;
openFile.AddFilter(new MyGxFilterFeatureClasses(), true);
if (openFile.ShowDialog() != DialogResult.OK)
{
return;
}
IGxObject gxObject = openFile.Items.get_Element(0) as IGxObject;
IFeatureClassName pClassName = gxObject.InternalObjectName as IFeatureClassName;
//IWorkspace pWorkspace=((IName) pClassName.FeatureDatasetName.WorkspaceName).Open();
IFeatureClass pClass = ((IName)pClassName).Open();
if (pClass.ShapeType != esriGeometryType.esriGeometryPolygon)
{
MessageService.Current.Warn("索引图层只能是多边形图层，请重新选择!");
return;
}
txtLayer.Text = ((IDataset)pClass).Name;
txtLayer.Tag = ((IDataset)pClass).Workspace.ConnectionProperties;
LoadField(pClass);
}
public static void OpenFeatureClass(AxMapControl MapControl,
IFeatureClassName pFcName, ListView listview1)
{
try
{
MapControl.Map.ClearLayers();
MapControl.SpatialReference = null;
IName pName = pFcName as IName;
IFeatureClass pFc = pName.Open() as IFeatureClass;
listview1.Items.Clear();
listview1.Columns.Clear();
LoadListView(pFc, listview1);
IFeatureCursor pCursor = pFc.Search(null, false);
IFeature pfea = pCursor.NextFeature();
int j = 0;
while (pfea != null)
{
ListViewItem lv = new ListViewItem();
for (int i = 0; i < pfea.Fields.FieldCount; i++)
{
string sFieldName = pfea.Fields.get_Field(i).Name;
lv.SubItems.Add(FeatureHelper.GetFeatureValue(pfea, sFieldName).ToString());
}
lv.Tag = pfea;
if (j % 2 == 0)
{
lv.BackColor = System.Drawing.Color.GreenYellow;
}
listview1.Items.Add(lv);
pfea = pCursor.NextFeature();
j++;
}
LSGISHelper.OtherHelper.ReleaseObject(pCursor);
//最后加载图形数据
if (pFcName.FeatureType == esriFeatureType.esriFTRasterCatalogItem)
{
ESRI.ArcGIS.Carto.IGdbRasterCatalogLayer pGdbRCLayer = new ESRI.ArcGIS.Carto.GdbRasterCatalogLayerClass();
pGdbRCLayer.Setup(pFc as ITable);
MapControl.Map.AddLayer(pGdbRCLayer as ILayer);
}
else if ((pFcName.FeatureType == esriFeatureType.esriFTSimple) ||
(pFcName.FeatureType == esriFeatureType.esriFTComplexEdge) ||
(pFcName.FeatureType == esriFeatureType.esriFTComplexJunction) ||
(pFcName.FeatureType == esriFeatureType.esriFTSimpleEdge) ||
(pFcName.FeatureType == esriFeatureType.esriFTSimpleJunction))
{
IFeatureLayer pLayer = new FeatureLayerClass();
pLayer.FeatureClass = pFc;
pLayer.Name = (pFc as IDataset).Name;
MapControl.Map.AddLayer(pLayer as ILayer);
}
else if (pFcName.FeatureType == esriFeatureType.esriFTAnnotation)
{
ILayer pLayer = OpenAnnotationLayer(pFc);
pLayer.Name = (pFc as IDataset).Name;
MapControl.Map.AddLayer(pLayer as ILayer);
}
MapControl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
}
catch (Exception ex)
{ }
}
