private void btnPolygonDataset_Click(object sender, EventArgs e)
{
try
{
SaveFileDialog fbd = new SaveFileDialog();
fbd.Title = "新建File Geodatabase";
if (fbd.ShowDialog() == DialogResult.OK)
{
if (System.IO.Directory.Exists(fbd.FileName + ".gdb") == true)
{
MessageBox.Show("GDB已存在", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
//IWorkspaceFactory workspaceFactory = new FileGDBWorkspaceFactoryClass();
//IWorkspaceName workspaceName = workspaceFactory.Create(System.IO.Path.GetDirectoryName(fbd.FileName), System.IO.Path.GetFileName(fbd.FileName), null, 0);
ClsGDBDataCommon com = new ClsGDBDataCommon();
com.Create_FileGDB(System.IO.Path.GetDirectoryName(fbd.FileName), System.IO.Path.GetFileName(fbd.FileName) + ".gdb");
IWorkspace pws = com.OpenFromFileGDB(fbd.FileName + ".gdb");
pFeatureDataset = creatdataset(pws, System.IO.Path.GetFileName(fbd.FileName), pMapControl.SpatialReference);
creatfeatureclass(System.IO.Path.GetFileName(fbd.FileName));
txtPolygonDataset.Text = fbd.FileName + ".gdb";
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
public void Execute(ProgressReporterEvent reporter)
{
if (_serialized == null)
{
throw new Exception("can't execute. No config!");
}
#region Instance Creator
var assembly = Assembly.LoadFrom(SystemVariables.ApplicationDirectory + @"\" + _serialized.NetworkCreatorAssembly);
if (assembly == null)
{
throw new Exception("Assembly not found: " + _serialized.NetworkCreatorAssembly);
}
var creator = assembly.CreateInstance(_serialized.NetworkCreatorType) as INetworkCreator;
if (creator == null)
{
throw new Exception("Type " + _serialized.NetworkCreatorType + " is not a network creator");
}
#endregion
#region Open Dataset
IFeatureDataset dataset = PlugInManager.Create(new Guid(_serialized.DatasetGuid)) as IFeatureDataset;
if (dataset == null)
{
throw new Exception("Unable to crete dataset");
}
dataset.ConnectionString = _serialized.ConnectionString;
dataset.Open();
this.FeatureDataset = dataset;
this.FeatureDatabase = dataset.Database as IFeatureDatabase3;
if (this.FeatureDatabase == null)
{
throw new Exception("Featuredatabase no implements IFeatureDatabase3");
}
#endregion
creator.NetworkName = _serialized.FeatureClasses.NetworkName;
creator.FeatureDataset = this.FeatureDataset;
creator.EdgeFeatureClasses = this.EdgeFeatureclasses;
creator.NodeFeatureClasses = this.NodeFeatureclasses;
creator.SnapTolerance = this.SnapTolerance;
creator.ComplexEdgeFcIds = this.ComplexEdgeFcIds;
creator.GraphWeights = this.GraphWeights;
creator.SwitchNodeFcIdAndFieldnames = this.SwitchNodeFcIds;
creator.NodeTypeFcIds = this.NetworkNodeTypeFcIds;
if (reporter != null && creator is IProgressReporter)
{
((IProgressReporter)creator).ReportProgress += (ProgressReport progressEventReport) =>
{
reporter(progressEventReport);
};
}
creator.Run();
}
public CreateTileGridClass(
string name,
IFeatureDataset targetDataset,
ISpatialIndexDef spatialIndexDef,
IRasterDataset sourceDataset,
double tileSizeX, double tileSizeY,
double resX, double resY,
int levels,
string cacheDirectory,
TileGridType gridType)
{
_name = name;
_cacheDirectory = cacheDirectory;
_targetDataset = targetDataset;
_spatialIndexDef = spatialIndexDef;
_sourceDataset = sourceDataset;
_tileSizeX = tileSizeX;
_tileSizeY = tileSizeY;
_resX = resX;
_resY = resY;
_levels = levels;
_gridType = gridType;
_fdb = (SqlFDB)_targetDataset.Database;
_createLevels = new List <int>();
for (int i = 0; i < _levels; i++)
{
_createLevels.Add(i);
}
}
//在文件数据库中新建要素数据集
public IFeatureDataset CreateDatasetInGDB(IWorkspace pWorkspace, string name, ISpatialReference pSpatialReference)
{
IFeatureWorkspace pFeatureWorkspace = pWorkspace as IFeatureWorkspace;
IFeatureDataset pFeatureDataset = pFeatureWorkspace.CreateFeatureDataset(name, pSpatialReference);
return(pFeatureDataset);
}
private void AddFeatureDatasetToTree(TreeNode parentNode, IFeatureDataset featDataset)
{
TreeNode featDSNode = parentNode.Nodes.Add(featDataset.Name);
featDSNode.Tag = featDataset;
featDSNode.ImageIndex = 9;
featDSNode.SelectedImageIndex = 9;
featDSNode.StateImageIndex = 0;
IEnumDataset datasets = featDataset.Subsets;
datasets.Reset();
IDataset dataset = datasets.Next();
while (dataset != null)
{
if (dataset is IFeatureClass)
{
AddFeatureClassToTree(featDSNode, dataset as IFeatureClass);
}
else if (dataset is IFeatureDataset)
{
AddFeatureDatasetToTree(featDSNode, dataset as IFeatureDataset);
}
dataset = datasets.Next();
}
}
public void SpecialFeaClsTopoCheck2(IArcgisDataCheckHook hook, IFeatureDataset pFeaDataset, DataTable pTable, esriTopologyRuleType pTopoRule, out Exception eError)
{
eError = null;
List <string> feaclsNameList = new List <string>();
for (int i = 0; i < pTable.Rows.Count; i++)
{
string FeaClsName = pTable.Rows[i]["图层"].ToString().Trim(); //图层名
if (FeaClsName == "")
{
eError = new Exception("图层名为空!");
return;
}
if (!feaclsNameList.Contains(FeaClsName))
{
feaclsNameList.Add(FeaClsName);
}
}
if (feaclsNameList.Count == 0)
{
return;
}
CommonTopologyCheckClass commonTopologyCheckClass = new CommonTopologyCheckClass();
commonTopologyCheckClass.DataErrTreat += new DataErrTreatHandle(DataCheckRealize_DataErrTreat);
commonTopologyCheckClass.OrdinaryTopoCheck(hook, pFeaDataset, feaclsNameList, pTopoRule, out eError);
if (eError != null)
{
return;
}
}
public static IFeatureClass CreateFClassInPDB(IWorkspace accessworkspace, string feaDSname, string FCname, esriGeometryType esriGeometryType, ISpatialReference sprf)
{
try
{
IFeatureDataset featureDataset = ((IFeatureWorkspace)accessworkspace).OpenFeatureDataset(feaDSname);
//IGeoDataset geoDataset = featureDataset as IGeoDataset;
IFields pFields = new FieldsClass();
IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
IField pField = new FieldClass();
IFieldEdit pFieldEdit = pField as IFieldEdit;
pFieldEdit.Name_2 = "SHAPE";
pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
IGeometryDef pGeometryDef = new GeometryDefClass();
IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
pGeometryDefEdit.GeometryType_2 = esriGeometryType.esriGeometryPoint;
pFieldEdit.GeometryDef_2 = pGeometryDef;
pFieldsEdit.AddField(pField);
IFeatureClass fc = featureDataset.CreateFeatureClass(FCname, pFields, null, null, esriFeatureType.esriFTSimple, "Shape", "");
return(fc);
}
catch (Exception ee)
{
MessageBox.Show(ee.Message.ToString());
return(null);
}
}
private void buttonX_ok_Click(object sender, EventArgs e)
{
CGmpPoint xml = new CGmpPoint();
bool result = xml.ReadGmpXML(XMLPath);
Regex regNum = new Regex("^[0-9]");
if (regNum.IsMatch(textBoxX3.Text) == true)
{
MessageBox.Show("数据集名称不能以数字开头命名", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
if (result == true)
{
try
{
IWorkspaceFactory workspaceFactory = new FileGDBWorkspaceFactoryClass();
gdbPath = textBoxX2.Text;
IFeatureWorkspace pFeatureWorkspace = workspaceFactory.OpenFromFile(gdbPath, 0) as IFeatureWorkspace;
ISpatialReferenceFactory pSpatialReferenceFactory = new SpatialReferenceEnvironment();
//ISpatialReference pSpatialReference = new UnknownCoordinateSystemClass();
ISpatialReference pSpatialReference = ClsGDBDataCommon.CreateProjectedCoordinateSystem();
pSpatialReference.SetDomain(-8000000, 8000000, -800000, 8000000);
IFeatureDataset pFeatureDataset = pFeatureWorkspace.CreateFeatureDataset(textBoxX3.Text, pSpatialReference);
IFeatureClass pFeatureclass = CreatePointFeatureClass(pFeatureDataset, xml);
IFeatureClass pFCLine = CreatLineFC(pFeatureDataset, pFeatureclass);
if (pFeatureclass == null || pFCLine == null)
{
MessageBox.Show("数据生成失败", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
IFeatureLayer pFPointLayer = new FeatureLayerClass();
pFPointLayer.FeatureClass = pFeatureclass;
pFPointLayer.Name = textBoxX3.Text + "_Gmppoint";
IFeatureLayer pFLintLayer = new FeatureLayerClass();
pFLintLayer.FeatureClass = pFCLine;
pFLintLayer.Name = textBoxX3.Text + "_GmpLine";
m_pMapCtl.AddLayer(pFLintLayer as ILayer, 0);
m_pMapCtl.AddLayer(pFPointLayer as ILayer, 0);
m_pMapCtl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
if (cmbImpSymbol.Text != null && symFilePath != null)
{
ImpSymbolFromFile(symFilePath, pFPointLayer, pFLintLayer);
}
//MessageBox.Show("数据已经生成", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
}
async static Task <bool> ImportFiles(IFeatureDataset ds, string[] filenames, Dictionary <string, Guid> providers)
{
FDBImageDataset import = new FDBImageDataset(ds.Database as IImageDB, ds.DatasetName);
import.handleNonGeorefAsError = !(rootPath != String.Empty);
import.ReportProgress += (sender, progress) =>
{
ProgressCounter++;
if (ProgressCounter % 100 == 0)
{
Console.WriteLine($"... { ProgressCounter }");
}
};
foreach (string filename in filenames)
{
//Console.WriteLine("Import: " + filename);
if (!await import.Import(filename, providers))
{
Console.WriteLine("Error: " + import.lastErrorMessage);
if (!continueOnError)
{
return(false);
}
}
}
return(true);
}
public NetworkEdgeWeightsControl(IFeatureDataset dataset, SelectFeatureclassesControl selected)
{
InitializeComponent();
if (dataset != null)
{
_database = dataset.Database as IFeatureDatabase3;
}
if (_database == null)
{
throw new ArgumentException();
}
_selected = selected;
PlugInManager pluginMan = new PlugInManager();
foreach (var calcType in pluginMan.GetPlugins(Plugins.Type.ISimpleNumberCalculation))
{
ISimpleNumberCalculation calc = pluginMan.CreateInstance <ISimpleNumberCalculation>(calcType);
if (calc == null)
{
continue;
}
_calculators.Add(calc);
}
}
// Methods
public static IFeatureClass CreateAnnoFeatureClass(string string_0, IFeatureDataset ifeatureDataset_0,
double double_0)
{
IObjectClassDescription description = new AnnotationFeatureClassDescription();
IFeatureClassDescription description2 = (IFeatureClassDescription)description;
IFields requiredFields = description.RequiredFields;
IFeatureWorkspaceAnno workspace = (IFeatureWorkspaceAnno)ifeatureDataset_0.Workspace;
IGraphicsLayerScale referenceScale = new GraphicsLayerScale
{
ReferenceScale = double_0,
Units = esriUnits.esriMeters
};
UID instanceCLSID = description.InstanceCLSID;
UID classExtensionCLSID = description.ClassExtensionCLSID;
ISymbolCollection symbolCollection = new SymbolCollection();
symbolCollection.set_Symbol(0, (ISymbol)MakeTextSymbol("宋体", 3.0));
symbolCollection.set_Symbol(1, (ISymbol)MakeTextSymbol("宋体", 3.5));
symbolCollection.set_Symbol(2, (ISymbol)MakeTextSymbol("宋体", 3.0));
symbolCollection.set_Symbol(3, (ISymbol)MakeTextSymbol("宋体", 2.5));
symbolCollection.set_Symbol(4, (ISymbol)MakeTextSymbol("黑体", 2.0));
symbolCollection.set_Symbol(5, (ISymbol)MakeTextSymbol("黑体", 1.5));
symbolCollection.set_Symbol(6, (ISymbol)MakeTextSymbol("宋体", 1.0));
symbolCollection.set_Symbol(7, (ISymbol)MakeTextSymbol("宋体", 0.4));
symbolCollection.set_Symbol(8, (ISymbol)MakeTextSymbol("宋体", 0.3));
symbolCollection.set_Symbol(9, (ISymbol)MakeTextSymbol("黑体", 1.0));
symbolCollection.set_Symbol(10, (ISymbol)MakeTextSymbol("宋体", 0.5));
symbolCollection.set_Symbol(11, (ISymbol)MakeTextSymbol("宋体", 0.6));
symbolCollection.set_Symbol(12, (ISymbol)MakeTextSymbol("宋体", 0.7));
symbolCollection.set_Symbol(13, (ISymbol)MakeTextSymbol("宋体", 0.8));
symbolCollection.set_Symbol(14, (ISymbol)MakeTextSymbol("宋体", 0.9));
symbolCollection.set_Symbol(15, (ISymbol)MakeTextSymbol("宋体", 1.2));
return(workspace.CreateAnnotationClass(string_0, requiredFields, instanceCLSID, classExtensionCLSID,
description2.ShapeFieldName, "", ifeatureDataset_0, null, null, referenceScale, symbolCollection, true));
}
public FormNewFeatureclass(IFeatureDataset dataset)
{
InitializeComponent();
if (dataset == null)
{
return;
}
cmbGeometry.SelectedIndex = 0;
spatialIndexControl.SpatialReference = dataset.SpatialReference;
foreach (FieldType fieldType in Enum.GetValues(typeof(FieldType)))
{
if (fieldType == FieldType.unknown ||
fieldType == FieldType.ID ||
fieldType == FieldType.Shape)
{
continue;
}
colFieldtype.Items.Add(fieldType);
}
tabControl1.Invalidate();
this.IndexTypeIsEditable = false;
if (dataset is IFDBDataset)
{
this.SpatialIndexDef = ((IFDBDataset)dataset).SpatialIndexDef;
}
}
//3/10/2009 删除工作空间内的所有要素类 yh
public static void DeleteAllFeatCls(IWorkspace pworkspace)
{
IEnumDataset pEnumFeatDataset = default(IEnumDataset);
IDataset pDataset = default(IDataset);
IFeatureDataset pFeatDataset = default(IFeatureDataset);
pEnumFeatDataset = pworkspace.get_Datasets(esriDatasetType.esriDTAny);
pEnumFeatDataset.Reset();
pDataset = pEnumFeatDataset.Next();
while ((pDataset != null))
{
if (pDataset.CanDelete())
{
if (pDataset.Type == esriDatasetType.esriDTFeatureDataset)
{
pFeatDataset = (IFeatureDataset)pDataset;
pFeatDataset.Delete();
}
else
{
pDataset.Delete();
}
//pDataset.Delete()
pDataset = pEnumFeatDataset.Next();
}
}
}
/// <summary>
/// 获取要素集空间参考
/// </summary>
/// <param name="pFeatureDataset">要素集</param>
/// <returns></returns>
public static ISpatialReference GetSpatialReference(IFeatureDataset pFeatureDataset)
{
IGeoDataset pGeoDataset = pFeatureDataset as IGeoDataset;
ISpatialReference pSpatialReference = pGeoDataset.SpatialReference;
return(pSpatialReference);
}
async private Task ExportDatasetObject_fdb(object datasetObject)
{
if (datasetObject is IFeatureDataset)
{
IFeatureDataset dataset = (IFeatureDataset)datasetObject;
foreach (IDatasetElement element in await dataset.Elements())
{
if (element is IFeatureLayer)
{
await ExportDatasetObject(((IFeatureLayer)element).FeatureClass);
}
}
}
if (datasetObject is IFeatureClass)
{
if (_fdbExport == null)
{
_fdbExport = new FDBImport();
}
else
{
MessageBox.Show("ERROR: Import already runnung");
return;
}
FeatureClassImportProgressReporter reporter = await FeatureClassImportProgressReporter.CreateAsync(_fdbExport, (IFeatureClass)datasetObject);
FormTaskProgress progress = new FormTaskProgress(reporter, ExportAsync_fdb(datasetObject));
progress.Text = "Export Features: " + ((IFeatureClass)datasetObject).Name;
progress.ShowDialog();
_fdbExport = null;
}
}
// Adds barriers from object dataset
private void AddBarriersFromDataset(IDataset objDS)
{
if (objDS.Type == esriDatasetType.esriDTFeatureClass)
{
// It is Feature Class
AddBarriersFromFeatureClass(objDS as IFeatureClass);
}
else if (objDS.Type == esriDatasetType.esriDTFeatureDataset)
{
// It is Feature DatasetClass
IFeatureDataset objFeatureDS = null;
objFeatureDS = objDS as IFeatureDataset;
// Enum Dataset subsets
IEnumDataset objEnumDS = null;
objEnumDS = objFeatureDS.Subsets;
IDataset objSubDS = null;
objSubDS = objEnumDS.Next();
while ( objSubDS != null)
{
// Add Barriers from subset Feature Class
if (objSubDS.Type == esriDatasetType.esriDTFeatureClass)
AddBarriersFromFeatureClass(objSubDS as IFeatureClass);
objSubDS = objEnumDS.Next();
}
}
}
/// <summary>
/// 以迭代形式返回工作空间下的所有要素类，包括数据集中的要素类
/// </summary>
/// <param name="workspace">工作空间</param>
/// <returns>要素类枚举数（要素类集合）</returns>
private static IEnumerable GetDataset(this IWorkspace workspace)
{
//工作空间下的要素类
IEnumDataset enumDataset = workspace.Datasets[esriDatasetType.esriDTFeatureClass];
IFeatureClass featureClass = enumDataset.Next() as IFeatureClass;
while (featureClass != null)
{
yield return(featureClass);
featureClass = enumDataset.Next() as IFeatureClass;
}
//工作空间下的要素集
IEnumDataset dsEnumDataset = workspace.Datasets[esriDatasetType.esriDTFeatureDataset];
IDataset dataset = dsEnumDataset.Next();
while (dataset != null)//遍历要数集
{
IFeatureDataset featureDataset = (IFeatureDataset)dataset;
IFeatureClassContainer featureclassContainer = (IFeatureClassContainer)featureDataset;
IEnumFeatureClass enumFeatureClass = featureclassContainer.Classes;
IFeatureClass dsFeatureClass = enumFeatureClass.Next();
while (dsFeatureClass != null)//在每一个数据集中遍历数据层IFeatureClass
{
yield return(dsFeatureClass);
dsFeatureClass = enumFeatureClass.Next();
}
dataset = dsEnumDataset.Next();
}
}
private void Progarm()
{
IWorkspace workspace = ArcClass.GetmdbWorkspace(mdbFilePath);
if (workspace == null)
{
return;
}
IFeatureDataset featureDataset = ArcClass.GetFeatureDataset(workspace, "WJL");
ISchemaLock schemalock = featureDataset as ISchemaLock;
try
{
schemalock.ChangeSchemaLock(esriSchemaLock.esriExclusiveSchemaLock);
ITopologyContainer topologyContainer = featureDataset as ITopologyContainer;
ITopology topology = topologyContainer.CreateTopology("ttt", topologyContainer.DefaultClusterTolerance, -1, "");
IFeatureClass featureClass = ArcClass.GetFeatureClass(workspace, "PARK");
AddRuleToTopology(topology, esriTopologyRuleType.esriTRTAreaNoOverlap, "NO Block OverLap", featureClass);
IGeoDataset geoDataset = topology as IGeoDataset;
IEnvelope envelop = geoDataset.Extent;
ValidateTopology(topology, envelop);
}catch (COMException comEx)
{
}
}
//通过IWokspace和图层名称获取图层
public static List <IFeatureClass> GetFeatureClass(IWorkspace pWorkspace, string DatasetName)
{
List <IFeatureClass> newlist = new List <IFeatureClass>();
if (pWorkspace == null || DatasetName == "")
{
return(newlist);
}
IEnumDataset pEnumDataset = pWorkspace.get_Datasets(esriDatasetType.esriDTFeatureDataset);
pEnumDataset.Reset();
IFeatureDataset pFeaDataset = pEnumDataset.Next() as IFeatureDataset;
while (pFeaDataset != null)
{
if (pFeaDataset.Name == DatasetName)
{
IFeatureClassContainer pFeatureClassContainer = pFeaDataset as IFeatureClassContainer;
IEnumFeatureClass pEnumFeatureClass = pFeatureClassContainer.Classes;
IFeatureClass pFeatureClass = pEnumFeatureClass.Next();
while (pFeatureClass != null)
{
newlist.Add(pFeatureClass);
pFeatureClass = pEnumFeatureClass.Next();
}
}
pFeaDataset = pEnumDataset.Next() as IFeatureDataset;
}
return(newlist);
}
/// <summary>
/// 同层线重叠检查
/// </summary>
/// <param name="hook"></param>
/// <param name="pFeaDataset"></param>
/// <param name="pTable"></param>
/// <param name="eError"></param>
public void SpecialFeaClsTopoCheck(IArcgisDataCheckHook hook, IFeatureDataset pFeaDataset, DataTable pTable, esriTopologyRuleType pTopoRule, out Exception eError)
{
eError = null;
//设置进度条
ProgressChangeEvent eInfo = new ProgressChangeEvent();
eInfo.Max = pTable.Rows.Count;
int pValue = 0;
for (int i = 0; i < pTable.Rows.Count; i++)
{
string FeaClsName = pTable.Rows[i]["图层"].ToString().Trim(); //图层名
if (FeaClsName == "")
{
eError = new Exception("图层名为空!");
return;
}
CommonTopologyCheckClass commonTopologyCheckClass = new CommonTopologyCheckClass();
commonTopologyCheckClass.DataErrTreat += new DataErrTreatHandle(DataCheckRealize_DataErrTreat);
commonTopologyCheckClass.OrdinaryTopoCheck(hook, pFeaDataset, FeaClsName, pTopoRule, out eError);
if (eError != null)
{
return;
}
//进度条加1
pValue++;
eInfo.Value = pValue;
GeoDataChecker.GeoDataChecker_ProgressShow((object)GeoDataChecker._ProgressBarInner, eInfo);
}
}
//确定
private void button6_Click(object sender, EventArgs e)
{
if (textBox1.Text.Trim() == "" || textBox2.Text.Trim() == "" || textBox3.Text.Trim() == "")
{
MessageBox.Show("请输入正确的信息!", "提示");
return;
}
if (listBox1.Items.Count == 0)
{
MessageBox.Show("请选择要导入的要素类!", "提示");
return;
}
//数据库中新建要素数据集
IFeatureDataset pFeatureDataset = CreateDatasetInGDB(pWorkspace, textBox3.Text, pSpatialReference);
//建好的要素数据集中导入要素类
foreach (IFeatureClass eachFeatureClass in pFeatureClassList)
{
string f = pFeatureDataset.Workspace.PathName;
if (ImportFeatureIntoDS(eachFeatureClass, pFeatureDataset.Workspace.PathName + "\\" + pFeatureDataset.Name, eachFeatureClass.AliasName) == false)
{
return;
}
}
MessageBox.Show("创建成功!", "提示");
}
private void button5_Click(object sender, EventArgs e)
{
axMapControl1.Map.ClearLayers();
string _pInstance = "sde:oracle11g:172.31.2.90/orcl";
string _pUser = "******";
string _pPassword = "******";
string _pVersion = "sde.DEFAULT";
IWorkspace pWS = null;
pWS = GetSDEWorkspace(_pInstance, _pUser, _pPassword, _pVersion) as IWorkspace;
try
{
IEnumDatasetName pEDatasetNames = pWS.get_DatasetNames(esriDatasetType.esriDTAny);
IDatasetName pDatasetName = pEDatasetNames.Next();
while (pDatasetName != null)
{
string name = pDatasetName.Name;
if (pDatasetName.Name.Equals("CSTEST.QDTEST"))
{
if (pDatasetName.Type.Equals(esriDatasetType.esriDTFeatureDataset))
{
IFeatureWorkspace pFeatureWorkspace = (IFeatureWorkspace)pWS;
IFeatureDataset pFeatureDataset = pFeatureWorkspace.OpenFeatureDataset("CSTEST.QDTEST");
IEnumDataset pEnumDataset = pFeatureDataset.Subsets;
pEnumDataset.Reset();
IDataset pDataset = pEnumDataset.Next();
comboBox1.Items.Clear();
while (pDataset != null)
{
if (pDataset.Type == esriDatasetType.esriDTFeatureClass)
{
comboBox1.Items.Add(pDataset.Name);
if (pDataset is IFeatureClass)
{
IFeatureLayer pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.FeatureClass = pFeatureWorkspace.OpenFeatureClass(pDataset.Name);
pFeatureLayer.Name = pFeatureLayer.FeatureClass.AliasName;
axMapControl1.Map.AddLayer(pFeatureLayer);
}
}
pDataset = pEnumDataset.Next();
}
comboBox1.Text = comboBox1.Items[0].ToString();
}
}
pDatasetName = pEDatasetNames.Next();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.StackTrace);
}
}
//按照名称与类型打开数据集，针对featureDataset和rasterDataset
public static object openByTypeAndName(string name, string type)
{
try
{
if (type.Equals("featureDataset"))
{
IFeatureWorkspace w = vec_workspace as IFeatureWorkspace;
IFeatureDataset data = w.OpenFeatureDataset(name);
return(data);
}
else if (type.Equals("rasterDataset"))
{
IRasterWorkspace2 w = ras_workspace as IRasterWorkspace2;
IRasterDataset data = w.OpenRasterDataset(name);
return(data);
}
else
{
LogHelper.writeLog("error openByTypeAndName wrong type");
MessageBox.Show("wrong type");
}
}
catch (System.Exception ex)
{
LogHelper.writeLog("error openByTypeAndName " + ex.Message);
MessageBox.Show("error : " + ex.Message);
}
return(null);
}
private IFeatureClass GetUpdateRegionFC()
{
try
{
string path = Config.GetConfigValue("2DMdbPipe");
IWorkspaceFactory pWsF = new AccessWorkspaceFactory();
IFeatureWorkspace pFWs = pWsF.OpenFromFile(path, 0) as IFeatureWorkspace;
this.pCurWorkspace = pFWs;
IFeatureDataset pFDs = pFWs.OpenFeatureDataset("Assi_10");
if (pFDs == null)
{
return(null);
}
IEnumDataset pEnumDs = pFDs.Subsets;
IDataset fDs;
IFeatureClass fc = null;
while ((fDs = pEnumDs.Next()) != null)
{
if (fDs.Name == "UpdataRegionPLY500")
{
fc = fDs as IFeatureClass;
}
}
return(fc);
}
catch (System.Exception ex)
{
return(null);
}
}
/// <summary>
/// 面拓扑检查,面含面检查
/// </summary>
/// <param name="pDataCheckClass"></param>
/// <param name="pFeaDataset"></param>
/// <param name="pTable"></param>
/// <param name="topoRule"></param>
/// <param name="eError"></param>
public void AreaTopoCheck2(IArcgisDataCheckHook hook, IFeatureDataset pFeaDataset, DataTable pTable, esriTopologyRuleType topoRule, out Exception eError)
{
eError = null;
List <string> FeaClsNameDic = new List <string>();
for (int i = 0; i < pTable.Rows.Count; i++)
{
string FeaClsName = pTable.Rows[i]["图层"].ToString().Trim(); //图层名
if ((FeaClsName == "") || (!FeaClsName.Contains(";")))
{
eError = new Exception("图层名为空或配置不正确!");
return;
}
string[] feaNameArr = FeaClsName.Split(new char[] { ';' });
string oriFeaClsName = feaNameArr[0].Trim(); //源要素类名
string desFeaClsName = feaNameArr[1].Trim(); //目标要素名
if (!FeaClsNameDic.Contains(oriFeaClsName + ";" + desFeaClsName))
{
FeaClsNameDic.Add(oriFeaClsName + ";" + desFeaClsName);
}
}
CommonTopologyCheckClass commonTopologyCheckClass = new CommonTopologyCheckClass();
commonTopologyCheckClass.DataErrTreat += new DataErrTreatHandle(DataCheckRealize_DataErrTreat);
commonTopologyCheckClass.OrdinaryDicTopoCheck(hook, pFeaDataset, FeaClsNameDic, topoRule, out eError);
if (eError != null)
{
return;
}
}
/// <summary>
/// 线穿面检查
/// </summary>
/// <param name="hook"></param>
/// <param name="pFeaDataset"></param>
/// <param name="pTable"></param>
/// <param name="eError"></param>
public void LineCrossAreaCheck(IArcgisDataCheckHook hook, IFeatureDataset pFeaDataset, DataTable pTable, out Exception eError)
{
eError = null;
for (int i = 0; i < pTable.Rows.Count; i++)
{
string FeaClsName = pTable.Rows[i]["图层"].ToString().Trim(); //图层名
if ((FeaClsName == "") || (!FeaClsName.Contains(";")))
{
eError = new Exception("图层名为空或配置不正确!");
return;
}
string[] feaNameArr = FeaClsName.Split(new char[] { ';' });
string oriFeaClsName = feaNameArr[0].Trim(); //源要素类名
string desFeaClsName = feaNameArr[1].Trim(); //目标要素名
CommonTopologyCheckClass commonTopologyCheckClass = new CommonTopologyCheckClass();
commonTopologyCheckClass.DataErrTreat += new DataErrTreatHandle(DataCheckRealize_DataErrTreat);
commonTopologyCheckClass.CrossTopoCheck(hook, pFeaDataset, oriFeaClsName, desFeaClsName, out eError);
if (eError != null)
{
return;
}
}
}
/* private void FeatureLayer(object featureClass)
* {
* object[] dataName = GetData();
*
* IFeatureClass pFeatureClass = featureClass as IFeatureClass;
* // IFeatureLayer pFeaturelayer;
* // pFeaturelayer = new FeatureLayerClass();
* // pFeaturelayer.FeatureClass = pFeatureClass;
* // pFeaturelayer.Name = pFeaturelayer.FeatureClass.AliasName;
* m_pFeaturelayer.FeatureClass = pFeatureClass;
* }*/
/// <summary>
/// 加载Dataset
/// </summary>
/// <param name="fileFullPath"></param>
/// <param name="dsName"></param>
private void AddDataset(object dataSet, IMap pMap)
{
//获取FeatureDataset
IFeatureDataset pFeatureDataset = (IFeatureDataset)dataSet;
IWorkspace pWorkspace = pFeatureDataset.Workspace;
IFeatureWorkspace pFeatureWorkspace;
IFeatureLayer pFeatureLayer;
pFeatureWorkspace = pWorkspace as IFeatureWorkspace;
IEnumDataset pEnDS = pFeatureDataset.Subsets;
pEnDS.Reset();
//遍历Dataset
IDataset pDS = pEnDS.Next();
while (pDS is IFeatureClass)
{
pFeatureLayer = new FeatureLayerClass();
pFeatureLayer.FeatureClass = pFeatureWorkspace.OpenFeatureClass(pDS.Name);
pFeatureLayer.Name = pFeatureLayer.FeatureClass.AliasName;
m_pFeaturelayer = pFeatureLayer;
pMap.AddLayer(pFeatureLayer);//加载Dataset中的FeatureClass
pDS = pEnDS.Next();
}
m_pActiveView.Refresh();//刷新
}
private IFeatureClass LoadMetaData()
{
string path = Config.GetConfigValue("2DMdbPipe");
IWorkspaceFactory pWsF = new AccessWorkspaceFactory();
IFeatureWorkspace pFWs = pWsF.OpenFromFile(path, 0) as IFeatureWorkspace;
if (pFWs == null)
{
return(null);
}
IFeatureDataset pFDs = pFWs.OpenFeatureDataset("Assi_10");
if (pFDs == null)
{
return(null);
}
IEnumDataset pEnumDs = pFDs.Subsets;
IDataset fDs;
IFeatureClass fc = null;
while ((fDs = pEnumDs.Next()) != null)
{
if (fDs.Name == "Metadata")
{
fc = fDs as IFeatureClass;
}
}
return(fc);
}
public ITopology Create_Topology(IFeatureWorkspace featureWorkspace, string featuredatasetName, string featureClassName, string topologyName)
{
try
{
//1.---打开拓朴所在的要素数据集，并创建拓朴
IFeatureDataset featureDataset = featureWorkspace.OpenFeatureDataset(featuredatasetName);
if (featureDataset != null)
{
ITopologyContainer topologyContainer = (ITopologyContainer)featureDataset;
ITopology topology = topologyContainer.CreateTopology("topo", topologyContainer.DefaultClusterTolerance, -1, ""); //在这个地方报错
//2.---给拓朴加入要素集
IFeatureClassContainer featureclassContainer = (IFeatureClassContainer)featureDataset;
IFeatureClass featureClass = featureclassContainer.get_ClassByName(featureClassName);
topology.AddClass(featureClass, 5, 1, 1, false); // Parameters: AddClass(IClass, double weight, int xyrank, int zrank, Boolean EventNotificationOnValidate).
//3.---返回拓朴
return(topology);
}
}
catch (Exception ex)
{
//System.Diagnostics.Debug.WriteLine(ex.ToString());
MessageBox.Show(ex.ToString());
}
return(null);
}
/// <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;
}
}
}
public static IFeatureClass CreateFeatureClass(IFeatureDataset fds,FeatureClassInfo fcInfo)
{
if (fds == null || fcInfo == null)
return null;
if ((fds.Workspace as IWorkspace2).get_NameExists(esriDatasetType.esriDTFeatureClass, fcInfo.Name))
{
((fds.Workspace as IFeatureWorkspace).OpenFeatureClass(fcInfo.Name) as IDataset).Delete();
}
return fds.CreateFeatureClass(fcInfo.Name, CreateFields(fcInfo), null, null, fcInfo.FeatureType, fcInfo.ShapeFieldName, null);
}
/// <summary>
/// 检查数据集是否有锁,一旦检测到数据集内有图层含有锁，就返回有锁信息
/// </summary>
/// <param name="ipFeatDataset">被检查的数据集</param>
/// <returns>是否有锁</returns>
public static bool CheckFeatureDatasetHasLock(IFeatureDataset ipFeatDataset)
{
IFeatureClassContainer ipFeatClassContainer = (IFeatureClassContainer)ipFeatDataset;
int numFeatClasses = ipFeatClassContainer.ClassCount;
IFeatureClass ipFeatClass = null;
bool hasLock = false;
for (int i = 0; i < numFeatClasses; i++)
{
ipFeatClass = ipFeatClassContainer.get_Class(i);
if (CheckFeatureClassHasLock(ipFeatClass))
{
hasLock = true;
break;
}
}
return hasLock;
}
public static IGeometricNetwork getNetworkByName(IFeatureDataset pFeaDataset)
{
return null;
}
public static StandardItem Import(IFeatureDataset fds)
{
if (fds == null)
return null;
StandardItem sItem = new StandardItem();
sItem.Type = enumItemType.FeatureDataset;
sItem.Name = fds.Name;
sItem.SpatialReference = (fds as IGeoDataset).SpatialReference;
sItem.ID = Guid.NewGuid().ToString("N");
IList<StandardItem> subList = new List<StandardItem>();
sItem.SubItems = subList;
IFeatureClassContainer fcContianer = fds as IFeatureClassContainer;
for (int i = 0; i < fcContianer.ClassCount; i++)
{
StandardItem sItemClass = Import(fcContianer.get_Class(i));
sItemClass.Parent = sItem;
subList.Add(sItemClass);
}
return sItem;
}
//初始化几何网络和地图
private bool InitializeNetworkAndMap(IFeatureDataset FeatureDataset)
{
IFeatureClassContainer ipFeatureClassContainer;
IFeatureClass ipFeatureClass;
IGeoDataset ipGeoDataset;
ILayer ipLayer;
IFeatureLayer ipFeatureLayer;
IEnvelope ipEnvelope, ipMaxEnvelope;
double dblSearchTol;
INetworkCollection ipNetworkCollection = FeatureDataset as INetworkCollection;
int count = ipNetworkCollection.GeometricNetworkCount;
//获取第一个几何网络工作空间
m_ipGeometricNetwork = ipNetworkCollection.get_GeometricNetwork(0);
INetwork ipNetwork = m_ipGeometricNetwork.Network;
if (m_ipMap != null)
{
//m_ipMap = new MapClass();
ipFeatureClassContainer = m_ipGeometricNetwork as IFeatureClassContainer;
count = ipFeatureClassContainer.ClassCount;
for (int i = 0; i < count; i++)
{
ipFeatureClass = ipFeatureClassContainer.get_Class(i);
ipFeatureLayer = new FeatureLayerClass();
ipFeatureLayer.FeatureClass = ipFeatureClass;
for (int j = 0; j < m_ipMap.LayerCount; j++)
{
if (m_ipMap.get_Layer(j).Name.ToUpper() == ipFeatureLayer.Name.ToUpper())
{
continue;
}
}
m_ipMap.AddLayer(ipFeatureLayer);
}
m_ipActiveView.Refresh();
}
count = m_ipMap.LayerCount;
ipMaxEnvelope = new EnvelopeClass();
for (int i = 0; i < count; i++)
{
ipLayer = m_ipMap.get_Layer(i);
ipFeatureLayer = ipLayer as IFeatureLayer;
ipGeoDataset = ipFeatureLayer as IGeoDataset;
ipEnvelope = ipGeoDataset.Extent;
ipMaxEnvelope.Union(ipEnvelope);
}
m_ipPointToEID = new PointToEIDClass();
m_ipPointToEID.SourceMap = m_ipMap;
m_ipPointToEID.GeometricNetwork = m_ipGeometricNetwork;
double dblWidth = ipMaxEnvelope.Width;
double dblHeight = ipMaxEnvelope.Height;
if (dblWidth > dblHeight)
dblSearchTol = dblWidth / 100;
else
dblSearchTol = dblHeight / 100;
m_ipPointToEID.SnapTolerance = dblSearchTol;
return true;
}
public void OpenFeatureDatasetNetwork(IFeatureDataset FeatureDataset)
{
CloseWorkspace();
if (!InitializeNetworkAndMap(FeatureDataset))
Console.WriteLine("打开network出错");
}
/// <summary>
/// Sets the task.
/// </summary>
/// <param name="task">The task.</param>
public void SetTask(CheckTask task)
{
XGifProgress progressbar = new XGifProgress();
try
{
//���taskΪnull����Ϊ�ͷ���Դ
if (task == null)
{
UCDispose();
return;
}
//�����Ϊ�գ�������
m_CurrentTask = task;
//������½�������
progressbar.ShowHint("���ڴ�ǰ�ʼ�����.....");
//��ʼ��������
this.ucRulesTree.CurrentSchemaId = task.SchemaID;
this.ucRulesTree.CurrentTaskName = task.Name;
//����ί�У��ڴ����˿ؼ����߳��ϵ��ü���tree��������ֹ���֡���ǰ�������������ط�ʹ�á��Ĵ���;
LoadRules Load = new LoadRules(this.ucRulesTree.LoadRulesTree);
this.BeginInvoke(Load);
this.ucResult.CurrentTask = m_CurrentTask;
if (File.Exists(task.GetMXDFile()))
{
//�����õ�mxdģ��ͼ��
UcMap.LoadMxFile(task.GetMXDFile());
TocControl.SetBuddyControl(UcMap.Object);
TocControl.Update();
UcMap.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
m_MapLayersController = new MapLayersController(UcMap.Map);
}
else
{
progressbar.Hide();
MessageBoxApi.ShowErrorMessageBox(task.GetMXDFile() + "�����ڣ���������");
return;
}
//���ؽ��
if (task.ResultConnection != null)
{
//�����Ѿ������ɵ�����
this.TabCtrl.ShowTabHeader = DefaultBoolean.True;
this.TabCtrl.SelectedTabPage = this.TabPageCheckResults;
this.ucResultsTree.CurrentSchemaId = task.SchemaID;
this.ucResultsTree.CurrentTaskName = task.Name;
Sundary.ResultDbOper resultOper = new Hy.Check.UI.UC.Sundary.ResultDbOper(task.ResultConnection);
this.ucResultsTree.LayersResultsDt = resultOper.GetLayersResults();
this.ucResultsTree.ResultsDt = resultOper.GetAllResults();
this.ucResultsTree.CheckResultsCount = resultOper.GetResultsCount();
this.ucResultsTree.LoadResultsTree();
}
else
{
TabCtrl.SelectedTabPage = this.TabPageRules;
this.TabCtrl.ShowTabHeader = DefaultBoolean.False;
this.ucResultsTree.CurrentTreeList.Nodes.Clear();
}
//����top����ͼ�㵽map
if (task.TopoWorkspace != null)
{
//��ȡ��ǰ�����ӿ��е�ͼ�㼯��
m_pDatasetSon = TopoOperAPI.GetCurrentSonDataSet(task.TopoWorkspace as IFeatureWorkspace);
// ��ȡ�ӿ������е�Ҫ���������
TopoOperAPI.GetFcTopoNameInSon(UcMap, task.TopoWorkspace as IFeatureWorkspace, m_pDatasetSon);
}
this.dockTree.Visibility = DockVisibility.Visible;
this.dockTree.Text = "�����б�";
this.dockTree.Width = 260;
this.dockLegend.Visibility = DockVisibility.Visible;
}
catch (Exception ex)
{
progressbar.Hide();
//GT_CONST.LogAPI.CheckLog.AppendErrLogs(ex.Message);
XtraMessageBox.Show("�����ʧ�ܣ�", "��ʾ");
}
finally
{
progressbar.Hide(); //�رմ������ȷ���
}
}
/// <summary>
/// 创建注记层
/// </summary>
/// <param name="strFeaClsName">注记层名称</param>
/// <param name="destDataset">待创建的注记层所在的featuredataset</param>
/// <param name="ipInputFields">注记层字段</param>
public static IFeatureClass CreateAnnotation(IFeatureClass pInputCls, IFeatureDataset destDataset, IFields ipInputFields)
{
try
{
//要素类标识信息
IObjectClassDescription ipObjectClassDesc = new AnnotationFeatureClassDescription();
IFeatureClassDescription ipFeatClassDesc = (IFeatureClassDescription)ipObjectClassDesc;
IAnnoClass pAnnoClass = pInputCls.Extension as IAnnoClass;
double scale = pAnnoClass.ReferenceScale;
IUID ipCLSID = ipObjectClassDesc.InstanceCLSID;
ipCLSID.Value = "esriCore.AnnotationFeature";
IUID ipExtCLSID = ipObjectClassDesc.ClassExtensionCLSID;
ipExtCLSID.Value = "esriCore.AnnotationFeatureClassExtension";
//IField ipField;
IFields ipFields = ipObjectClassDesc.RequiredFields;
IFieldsEdit ipFieldsEdit = (IFieldsEdit)ipFields;
int numFields = ipInputFields.FieldCount;
esriFieldType type;
for (int i = 0; i < numFields; i++)
{
IField ipField = ipInputFields.get_Field(i);
type = ipField.Type;
if (type != esriFieldType.esriFieldTypeOID && type != esriFieldType.esriFieldTypeGeometry)
{
string fldName = ipField.Name;
int fldIndex = ipFields.FindField(fldName);
if (fldIndex == -1)
ipFieldsEdit.AddField(ipField);
}
}
//工作空间
IWorkspace ipWorkspace = destDataset.Workspace;
IFeatureWorkspaceAnno ipFeatureWorkspaceAnno = (IFeatureWorkspaceAnno)ipWorkspace;
//显示比例
IGraphicsLayerScale ipGraphicsLayerScale = new GraphicsLayerScaleClass();
ipGraphicsLayerScale.ReferenceScale = scale;
ipGraphicsLayerScale.Units = pAnnoClass.ReferenceScaleUnits;
//符号信息
//' set up symbol collection
ISymbolCollection pSymbolColl = new SymbolCollectionClass();
ITextSymbol myTxtSym = new TextSymbolClass();
//Set the font for myTxtSym
stdole.IFontDisp myFont = new stdole.StdFontClass() as stdole.IFontDisp;
IFont pFt = (IFont)myFont;
pFt.Name = "Courier New";
myTxtSym.Font = myFont;
// Set the Color for myTxtSym to be Dark Red
IRgbColor myColor = new RgbColorClass();
myColor.Red = 150;
myColor.Green = 0;
myColor.Blue = 0;
myTxtSym.Color = myColor;
// Set other properties for myTxtSym
myTxtSym.Angle = 0;
myTxtSym.RightToLeft = false;
myTxtSym.VerticalAlignment = esriTextVerticalAlignment.esriTVABaseline;
myTxtSym.HorizontalAlignment = esriTextHorizontalAlignment.esriTHAFull;
myTxtSym.Size = 9;
ISymbol pSymbol = (ISymbol)myTxtSym;
pSymbolColl.set_Symbol(0, pSymbol);
//set up the annotation labeling properties including the expression
IAnnotateLayerProperties pAnnoProps = new LabelEngineLayerPropertiesClass();
pAnnoProps.FeatureLinked = true;
pAnnoProps.AddUnplacedToGraphicsContainer = false;
pAnnoProps.CreateUnplacedElements = true;
pAnnoProps.DisplayAnnotation = true;
pAnnoProps.UseOutput = true;
ILabelEngineLayerProperties pLELayerProps = (ILabelEngineLayerProperties)pAnnoProps;
IAnnotationExpressionEngine aAnnoVBScriptEngine = new AnnotationVBScriptEngineClass();
pLELayerProps.ExpressionParser = aAnnoVBScriptEngine;
pLELayerProps.Expression = "[DESCRIPTION]";
pLELayerProps.IsExpressionSimple = true;
pLELayerProps.Offset = 0;
pLELayerProps.SymbolID = 0;
pLELayerProps.Symbol = myTxtSym;
IAnnotateLayerTransformationProperties pATP = (IAnnotateLayerTransformationProperties)pAnnoProps;
double dRefScale = ipGraphicsLayerScale.ReferenceScale;
pATP.ReferenceScale = dRefScale;
pATP.Units = esriUnits.esriMeters;
pATP.ScaleRatio = 1;
IAnnotateLayerPropertiesCollection pAnnoPropsColl = new AnnotateLayerPropertiesCollectionClass();
pAnnoPropsColl.Add(pAnnoProps);
//' use the AnnotationFeatureClassDescription co - class to get the list of required fields and the default name of the shape field
IObjectClassDescription pOCDesc = new AnnotationFeatureClassDescriptionClass();
IFeatureClassDescription pFDesc = (IFeatureClassDescription)pOCDesc;
IFields pReqFields = pOCDesc.RequiredFields;
IUID pInstCLSID = pOCDesc.InstanceCLSID;
IUID pExtCLSID = pOCDesc.ClassExtensionCLSID;
string bsShapeFieldName = pFDesc.ShapeFieldName;
IDataset pDs = (IDataset)pInputCls;
//创建
string bstName = ipFeatClassDesc.ShapeFieldName;
IFeatureClass pOutFcls =
ipFeatureWorkspaceAnno.CreateAnnotationClass(pDs.Name, ipFields, pOCDesc.InstanceCLSID,
pOCDesc.ClassExtensionCLSID, pInputCls.ShapeFieldName, "", destDataset, null, pAnnoPropsColl,
ipGraphicsLayerScale, pSymbolColl, true);
return pOutFcls;
}
catch(Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return null;
}
return null;
}
//初始化
private bool InitializeNetworkAndMap(IFeatureDataset Featuredataset,System.Collections.ArrayList array1,System.Collections.ArrayList array2,int flag)
{
IFeatureClassContainer ipFeatureClassContainer;
IFeatureClass ipFeatureClass;
IGeoDataset ipGeoDataset;
ILayer ipLayer;
IFeatureLayer ipFeatureLayer;
IEnvelope ipEnvelope, ipMaxEnvelope;
double dblSearchTol;
INetworkCollection ipNetworkCollection = Featuredataset as INetworkCollection;
int count = ipNetworkCollection.GeometricNetworkCount;
barrierarray1 =(System.Collections.ArrayList)array1.Clone();
barrierarray2 = (System.Collections.ArrayList)array2.Clone();
barrierflag = flag;
//获取几何网络工作空间
m_ipGeometricNetwork = ipNetworkCollection.get_GeometricNetwork(0);
INetwork ipNetwork = m_ipGeometricNetwork.Network;
if (m_ipMap != null)
{
m_ipMap = new MapClass();
ipFeatureClassContainer = m_ipGeometricNetwork as IFeatureClassContainer;
count = ipFeatureClassContainer.ClassCount;
for (int i = 0; i < count; i++)
{
ipFeatureClass = ipFeatureClassContainer.get_Class(i);
ipFeatureLayer = new FeatureLayerClass();
ipFeatureLayer.FeatureClass = ipFeatureClass;
m_ipMap.AddLayer(ipFeatureLayer);
}
}
count = m_ipMap.LayerCount;
ipMaxEnvelope = new EnvelopeClass();
for (int i = 0; i < count; i++)
{
ipLayer = m_ipMap.get_Layer(i);
ipFeatureLayer = ipLayer as IFeatureLayer;
ipGeoDataset = ipFeatureLayer as IGeoDataset;
ipEnvelope = ipGeoDataset.Extent;
ipMaxEnvelope.Union(ipEnvelope);
}
m_ipPointToEID = new PointToEIDClass();
m_ipPointToEID.SourceMap = m_ipMap;
m_ipPointToEID.GeometricNetwork = m_ipGeometricNetwork;
double dblWidth = ipMaxEnvelope.Width;
double dblHeight = ipMaxEnvelope.Height;
if (dblWidth > dblHeight)
dblSearchTol = dblWidth / 100;
else
dblSearchTol = dblHeight / 100;
m_ipPointToEID.SnapTolerance = dblSearchTol;
return true;
}
private static void WriteOutputBack(IFeatureDataset theInFDataset, IFeatureDataset theOutFDataset)
{
//Debug.Print("Can delete " + theInFDataset.Name + "? " + theInFDataset.CanDelete());
//Debug.Print("Can rename " + theOutFDataset.Name + "? " + theOutFDataset.CanRename());
string origName = theInFDataset.Name;
theInFDataset.Delete();
theOutFDataset.Rename(origName);
IEnumDataset theEnumDS = theOutFDataset.Subsets;
IDataset theDS = theEnumDS.Next();
while (theDS != null)
{
//Debug.Print("Need to rename " + theDS.Name);
string theNewName = theDS.Name;
while (theNewName.EndsWith("_1"))
theNewName = theNewName.Substring(0, theNewName.Length - 2);
theDS.Rename(theNewName);
//Debug.Print("Renamed to " + theNewName);
theDS = theEnumDS.Next();
}
}
public void ConvertFeatureClassToGDB(IWorkspace sourceWorkspace, IWorkspace targetWorkspace, string nameOfSourceFeatureClass, string nameOfTargetFeatureClass, IFeatureDataset feaDS)
{
//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;
IFeatureDatasetName feaName = null;
if (feaDS != null)
{
feaName = (IFeatureDatasetName)feaDS.FullName;
}
//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, feaName, targetFeatureClassName, geometryDef, targetFeatureClassFields, "", 1000, 0);
break;
}
}
}
private IFeatureClass CreateGridFeatureClass(Grid grid, IFeatureWorkspace workspace, IFeatureDataset dataset,
string featureClassName)
{
try
{
IFields fields;
if (workspace is IGxFolder)
{
MessageBox.Show(@"Creating Shapefile " + featureClassName + @" in " +
((IWorkspace)workspace).PathName);
if (!ValidateShapefileName())
{
MessageBox.Show(@"Shapefile may exist, name may be too long," +
@"folder may not exist, folder may be readonly,", @"Error");
return null;
}
fields = CreateShapefileFields();
}
else
{
string msg = dataset == null
? string.Format("Creating {0} in {1}", featureClassName,
((IWorkspace)workspace).PathName)
: string.Format("Creating {0} in {1}\\{2}", featureClassName,
((IWorkspace)workspace).PathName, dataset.Name);
MessageBox.Show(msg);
if (!ValidateGdbfileName())
return null;
fields = CreateGdbFields();
}
IFeatureClass generatedFeatureClass = CreateFeatureClass((IWorkspace2)workspace, dataset,
featureClassName, fields, null, null, "");
if (generatedFeatureClass == null)
return null;
PutGridInFeatureClass(generatedFeatureClass, grid);
return generatedFeatureClass;
}
catch (Exception)
{
//Debug.Print("Exception Creating Feature Class: {0}",ex);
return null;
}
}
/// <summary>
/// 获取IFeatureDataset所有的要素类，返回IFeatureClass列表
/// </summary>
/// <param name="ipDataset"></param>
/// <param name="arrayFeatLayer"></param>
public static void GetFeatLayerInDs(IFeatureDataset ipDataset, ref List<IFeatureLayer> arrayFeatLayer)
{
try
{
if (ipDataset == null)
{
return;
}
IFeatureClassContainer ipFcContain = (IFeatureClassContainer)ipDataset;
IEnumFeatureClass ipFcEnum = ipFcContain.Classes;
IFeatureClass ipFtClass = ipFcEnum.Next();
arrayFeatLayer = new List<IFeatureLayer>();
while (ipFtClass != null)
{
IFeatureLayer pFLayer = new FeatureLayer();
pFLayer.FeatureClass = ipFtClass;
pFLayer.Name = ipFtClass.AliasName;
arrayFeatLayer.Add(pFLayer);
Marshal.ReleaseComObject(ipFtClass);
ipFtClass = ipFcEnum.Next();
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
/// <summary>
/// 获取IFeatureDataset所有的要素类，返回IDataset列表
/// </summary>
/// <param name="ipDataset"></param>
/// <param name="arrayDs"></param>
public static void GetFcNameInDs(IFeatureDataset ipDataset, ref Hashtable arrayDs)
{
try
{
if (ipDataset == null)
{
return;
}
IFeatureClassContainer ipFcContain = (IFeatureClassContainer)ipDataset;
IEnumFeatureClass ipFcEnum = ipFcContain.Classes;
IFeatureClass ipFtClass = ipFcEnum.Next();
while (ipFtClass != null)
{
arrayDs.Add(((IDataset)ipFtClass).Name, (IDataset)ipFtClass);
ipFtClass = ipFcEnum.Next();
}
}
catch (Exception exp)
{
Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());
return;
}
}
public static void initNetwork(IFeatureDataset pFeaDataset,IMap pMap,out IGeometricNetwork m_ipGeometricNetwork)
{
INetworkCollection pNetworkCollection;
//IGeometricNetwork m_ipGeometricNetwork;
INetwork pNetwork;
IFeatureClassContainer ipFeatureClassContainer;
IFeatureClass ipFeatureClass;
IFeatureLayer ipFeatureLayer;
IDataset pDataset;
//get the network collection
pNetworkCollection=pFeaDataset as INetworkCollection;
if(pNetworkCollection.GeometricNetworkCount==0)
{
MessageBox.Show("������û������");
m_ipGeometricNetwork=null;
return;
}
m_ipGeometricNetwork=pNetworkCollection.get_GeometricNetworkByName("Water_Network");
//m_ipGeometricNetwork.
//Use the INetwork interface when you want to query the network for general information
//such as the status of the network or the number of edges in your network.
pNetwork=m_ipGeometricNetwork.Network;
//Add each of the Feature Classes in this Geometric Network as a map Layer
ipFeatureClassContainer=pNetworkCollection as IFeatureClassContainer;
if(ipFeatureClassContainer.ClassCount==0)
{
MessageBox.Show("û������featureClass");
m_ipGeometricNetwork=null;
return;
}
for(int ii=0;ii<ipFeatureClassContainer.ClassCount;ii++)
{
ipFeatureClass=ipFeatureClassContainer.get_Class(ii);
pDataset=ipFeatureClass as IDataset;
if(pDataset.Name=="water_arc"||pDataset.Name.Equals("water_point")||pDataset.Name.Equals("Water_Network_Junctions"))
{
ipFeatureLayer=new FeatureLayerClass();
ipFeatureLayer.FeatureClass=ipFeatureClass;
ipFeatureLayer.Name=pDataset.Name;
pMap.AddLayer(ipFeatureLayer);
}
}
}
private IFeatureClass CreateFeatureClass(IFeatureDataset featureDataset,TableStructureNode tableStructureNode, FeatureCodeNode featureCodeNode)
{
try
{
if (featureDataset != null)
{
IFeatureClassDescription fcDesc = new FeatureClassDescriptionClass();
IObjectClassDescription ocDesc = (IObjectClassDescription)fcDesc;
///�������ݱ��ֶ�
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = CreateFileds(tableStructureNode, featureCodeNode);
///�ֶ���Ϣ��֤
IFields fixFields = null;
fieldChecker.ValidateWorkspace = featureDataset.Workspace;
fieldChecker.Validate(validatedFields, out enumFieldError, out fixFields);
////����FeatureClass
IFeatureClass featureClass = null;
if (tableStructureNode.IsGeometryTable)
{
////������ע��FeatureClass
if (featureCodeNode.GeometryType != "")
{
featureClass = featureDataset.CreateFeatureClass(featureCodeNode.TableName,
fixFields, ocDesc.InstanceCLSID, ocDesc.ClassExtensionCLSID,
esriFeatureType.esriFTSimple, fcDesc.ShapeFieldName, "");
}
else
{
///����ע��
IFormattedTextSymbol pTxtSymbo=new TextSymbolClass();
IFeatureWorkspaceAnno pFeatureWorkspaceAnno = this.m_pIDataset.Workspace as IFeatureWorkspaceAnno;
IGraphicsLayerScale pGraphSacle = new GraphicsLayerScaleClass();
pGraphSacle.Units = ESRI.ArcGIS.esriSystem.esriUnits.esriFeet;
//pGraphSacle.ReferenceScale=1000;
ISymbolCollection pSymbolCollection = new SymbolCollectionClass();
IAnnotateLayerProperties pAnnoLayerProp = new LabelEngineLayerPropertiesClass();
pAnnoLayerProp.FeatureLinked = true;
pAnnoLayerProp.CreateUnplacedElements = false;
pAnnoLayerProp.DisplayAnnotation = true;
pAnnoLayerProp.UseOutput = true;
IAnnotationExpressionEngine pAnnoExpressionEngine =new AnnotationVBScriptEngineClass();
ILabelEngineLayerProperties pLabelEngineLayerProperties = pAnnoLayerProp as ILabelEngineLayerProperties;
pLabelEngineLayerProperties.ExpressionParser = pAnnoExpressionEngine;
pLabelEngineLayerProperties.Expression = "[DESCRIPTION]";
pLabelEngineLayerProperties.IsExpressionSimple = true;
pLabelEngineLayerProperties.Offset = 0;
pLabelEngineLayerProperties.SymbolID = 0;
pLabelEngineLayerProperties.Symbol = pTxtSymbo;
IAnnotateLayerTransformationProperties pAnnoLayerTransProp = pAnnoLayerProp as IAnnotateLayerTransformationProperties;
pAnnoLayerTransProp.ReferenceScale=200;
pAnnoLayerTransProp.Units= ESRI.ArcGIS.esriSystem.esriUnits.esriFeet;
pAnnoLayerTransProp.ScaleRatio=1;
IAnnotateLayerPropertiesCollection pAnnoLayerProptyCollection =new AnnotateLayerPropertiesCollectionClass();
pAnnoLayerProptyCollection.Add(pAnnoLayerProp);
featureClass= pFeatureWorkspaceAnno.CreateAnnotationClass(featureCodeNode.TableName,fixFields,ocDesc.InstanceCLSID
,ocDesc.ClassExtensionCLSID,fcDesc.ShapeFieldName,"",featureDataset,null,
pAnnoLayerProptyCollection, pGraphSacle, pSymbolCollection,true);
}
}
else
{
///�����ǿռ�����
}
return featureClass;
}
return null;
}
catch(Exception ex)
{
LogAPI.WriteErrorLog(ex);
return null;
}
}
public static IFeatureClass CreateFeatureClass(IWorkspace workspace, IFeatureDataset featureDataset, String featureClassName, IFields fields)
{
IFeatureClass featureClass;
String strShapeField = "";
var featureWorkspace = workspace as IFeatureWorkspace;
IObjectClassDescription objectClassDescription = new FeatureClassDescriptionClass();
#region 简单校验
if (featureClassName == "") return null;
//if (workspace.get_NameExists(esriDatasetType.esriDTFeatureClass, featureClassName))
//{
// featureClass = featureWorkspace.OpenFeatureClass(featureClassName);
// return featureClass;
//}
if (fields == null)
{
fields = objectClassDescription.RequiredFields;
IFieldsEdit fieldsEdit = (IFieldsEdit)fields;
IField field = new FieldClass();
IFieldEdit fieldEdit = (IFieldEdit)field;
fieldEdit.Name_2 = "Name";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldsEdit.AddField(field);
fields = (IFields)fieldsEdit;
}
var feaClsDes = objectClassDescription as IFeatureClassDescription;
strShapeField = feaClsDes.ShapeFieldName;
#endregion
//查询几何字段
if (strShapeField == "")
{
for (int j = 0; j < fields.FieldCount; j++)
{
if (fields.get_Field(j).Type == esriFieldType.esriFieldTypeGeometry)
{
strShapeField = fields.get_Field(j).Name;
}
}
}
// 字段检查
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError = null;
IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (IWorkspace)workspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
//创建要素类
if (featureDataset == null)
{
featureClass = featureWorkspace.CreateFeatureClass(featureClassName, validatedFields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, strShapeField, "");
}
else
{
featureClass = featureDataset.CreateFeatureClass(featureClassName, validatedFields, objectClassDescription.InstanceCLSID, objectClassDescription.ClassExtensionCLSID, esriFeatureType.esriFTSimple, strShapeField, "");
}
return featureClass;
}
/// <summary>
/// 创建无向网络
/// </summary>
/// <param name="_pFeatureDataset"></param>
/// <param name="_pDENetDataset"></param>
/// <returns></returns>
public INetworkDataset Create(IFeatureDataset _pFeatureDataset, IDENetworkDataset2 _pDENetDataset)
{
IFeatureDatasetExtensionContainer pFeatureDatasetExtensionContainer = (IFeatureDatasetExtensionContainer) _pFeatureDataset;
IFeatureDatasetExtension pFeatureDatasetExtension = pFeatureDatasetExtensionContainer.FindExtension
(esriDatasetType.esriDTNetworkDataset);
IDatasetContainer2 pDatasetContainer2 = (IDatasetContainer2)pFeatureDatasetExtension;
IDEDataset pDENetDataset = (IDEDataset)_pDENetDataset;
INetworkDataset pNetworkDataset = (INetworkDataset)pDatasetContainer2.CreateDataset
(pDENetDataset);
return pNetworkDataset;
}
public static IFeatureClass CreateFeatureClassInPGDB(IWorkspace2 workspace, IFeatureDataset featureDataset, string featureClassName, IFields fields, UID CLSID, UID CLSEXT, string strConfigKeyword, esriGeometryType esriGeometryType)
{
if (featureClassName == "") return null; // name was not passed in
ESRI.ArcGIS.Geodatabase.IFeatureClass featureClass;
ESRI.ArcGIS.Geodatabase.IFeatureWorkspace featureWorkspace = (ESRI.ArcGIS.Geodatabase.IFeatureWorkspace)workspace; // Explicit Cast
if (workspace.get_NameExists(ESRI.ArcGIS.Geodatabase.esriDatasetType.esriDTFeatureClass, featureClassName)) //feature class with that name already exists
{
featureClass = featureWorkspace.OpenFeatureClass(featureClassName);
return featureClass;
}
// assign the class id value if not assigned
if (CLSID == null)
{
CLSID = new ESRI.ArcGIS.esriSystem.UIDClass();
CLSID.Value = "esriGeoDatabase.Feature";
}
ESRI.ArcGIS.Geodatabase.IObjectClassDescription objectClassDescription = new ESRI.ArcGIS.Geodatabase.FeatureClassDescriptionClass();
// if a fields collection is not passed in then supply our own
if (fields == null)
{
// create the fields using the required fields method
fields = objectClassDescription.RequiredFields;
ESRI.ArcGIS.Geodatabase.IFieldsEdit fieldsEdit = (ESRI.ArcGIS.Geodatabase.IFieldsEdit)fields; // Explicit Cast
ESRI.ArcGIS.Geodatabase.IField field = new ESRI.ArcGIS.Geodatabase.FieldClass();
// create a user defined text field
ESRI.ArcGIS.Geodatabase.IFieldEdit fieldEdit = (ESRI.ArcGIS.Geodatabase.IFieldEdit)field; // Explicit Cast
// setup field properties
fieldEdit.Name_2 = "SampleField";
fieldEdit.Type_2 = ESRI.ArcGIS.Geodatabase.esriFieldType.esriFieldTypeString;
fieldEdit.IsNullable_2 = true;
fieldEdit.AliasName_2 = "Sample Field Column";
fieldEdit.DefaultValue_2 = "test";
fieldEdit.Editable_2 = true;
fieldEdit.Length_2 = 100;
// add field to field collection
fieldsEdit.AddField(field);
fields = (ESRI.ArcGIS.Geodatabase.IFields)fieldsEdit; // Explicit Cast
}
System.String strShapeField = "";
// locate the shape field
for (int j = 0; j < fields.FieldCount; j++)
{
if (fields.get_Field(j).Type == esriFieldType.esriFieldTypeGeometry)
{
strShapeField = fields.get_Field(j).Name;
((IGeometryDefEdit)fields.get_Field(j).GeometryDef).GeometryType_2 = esriGeometryType;
}
}
// Use IFieldChecker to create a validated fields collection.
ESRI.ArcGIS.Geodatabase.IFieldChecker fieldChecker = new ESRI.ArcGIS.Geodatabase.FieldCheckerClass();
ESRI.ArcGIS.Geodatabase.IEnumFieldError enumFieldError = null;
ESRI.ArcGIS.Geodatabase.IFields validatedFields = null;
fieldChecker.ValidateWorkspace = (ESRI.ArcGIS.Geodatabase.IWorkspace)workspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
// The enumFieldError enumerator can be inspected at this point to determine
// which fields were modified during validation.
// finally create and return the feature class
if (featureDataset == null)// if no feature dataset passed in, create at the workspace level
{
featureClass = featureWorkspace.CreateFeatureClass(featureClassName, validatedFields, CLSID, CLSEXT, ESRI.ArcGIS.Geodatabase.esriFeatureType.esriFTSimple, strShapeField, strConfigKeyword);
}
else
{
featureClass = featureDataset.CreateFeatureClass(featureClassName, validatedFields, CLSID, CLSEXT, ESRI.ArcGIS.Geodatabase.esriFeatureType.esriFTSimple, strShapeField, strConfigKeyword);
}
return featureClass;
}
/// <summary>
/// 获取子库中所有的拓扑图层
/// </summary>
/// <param name="axMapControl"></param>
/// <param name="strSonPath"></param>
/// <param name="ipSonFWS"></param>
/// <param name="ipDataset"></param>
/// <returns></returns>
public static bool GetFcTopoNameInSon(AxMapControl axMapControl, IFeatureWorkspace ipSonFWS,
IFeatureDataset ipDataset)
{
ITopologyWorkspace ipTopologyWS = null;
IFeatureClassContainer pFeatClassContainer = null;
try
{
ipTopologyWS = (ITopologyWorkspace)ipSonFWS;
if (ipDataset == null)
{
return false;
}
pFeatClassContainer = (IFeatureClassContainer)ipDataset;
List<string> arrayTopoLayers = new List<string>();
arrayTopoLayers.Add(COMMONCONST.Topology_Name);
//-------------------------------获取拓扑图层，并在地图上显示------------------------------------//
AddTopoLayer(ref axMapControl, arrayTopoLayers[0], ipTopologyWS, pFeatClassContainer, ipDataset);
}
catch (Exception ex)
{
//GT_CONST.LogAPI.CheckLog.AppendErrLogs(ex.Message);
return false;
}
finally
{
//释放接口
if (pFeatClassContainer != null)
{
Marshal.ReleaseComObject(pFeatClassContainer);
pFeatClassContainer = null;
}
if (ipTopologyWS != null)
{
Marshal.ReleaseComObject(ipTopologyWS);
ipTopologyWS = null;
}
}
return true;
//------------------------------------------------------------------------------------------------//
}
//加载拓扑图层
public static void AddTopoLayer(ref AxMapControl pMapCtrl, string strTopoLayerName, ITopologyWorkspace ipTopologyWS,IFeatureClassContainer ipFeatClassContainer, IFeatureDataset ipFeatDataset)
{
int nOriginClassID, nDestClassID;
ITopology ipTopology;
//打开数据集
//ITopologyContainer ipTopoContainer = (ITopologyContainer)ipFeatDataset;
IWorkspace2 pWorkspace = (IWorkspace2)ipFeatDataset.Workspace;
if (pWorkspace.get_NameExists(esriDatasetType.esriDTTopology, strTopoLayerName))
{
ipTopology = ipTopologyWS.OpenTopology(strTopoLayerName);
if (ipTopology == null)
{
return;
}
ITopologyLayer ipTopologyLayer = new TopologyLayerClass();
ipTopologyLayer.Topology = ipTopology;
ILegendInfo legendInfo = (ILegendInfo)ipTopologyLayer;
for (int i = 0; i < legendInfo.LegendGroupCount; i++)
{
ILegendGroup legendgroup = legendInfo.get_LegendGroup(i);
ILegendClass legendclass = legendgroup.get_Class(0);
switch (legendgroup.Heading)
{
case "Area Errors":
{
legendgroup.Heading = "";
legendclass.Label = "面状错误";
legendclass.Description = "面状错误";
break;
}
case "Line Errors":
{
legendgroup.Heading = "";
legendclass.Label = "线状错误";
legendclass.Description = "线状错误";
break;
}
case "Point Errors":
{
legendgroup.Heading = "";
legendclass.Label = "点状错误";
legendclass.Description = "点状错误";
break;
}
}
}
ILayer ipLayer = (ILayer)ipTopologyLayer;
ipLayer.Name = strTopoLayerName; //将拓扑检查合并后，将拓扑图层名指定为“拓扑错误”后，采用此方法命名 hehy20080724
/* 将拓扑检查合并后，将拓扑图层名指定为“拓扑错误”后，注销以下代码 hehy20080724
///////////////////////////////////////////////////
//得到拓扑层相对应的规则名称
CModelSchema pModelSchema = new CModelSchema();
string strRuleName = pModelSchema.GetRuleNameByTopoLayerName(m_pTask.pSchema, strTopoLayerName);
//////////////////////////////////////////////////
if (strRuleName.Length == 0)
{
ipLayer.Name = strTopoLayerName;
}
else
{
ipLayer.Name = strRuleName;
}
*/
//把拓扑图层加载到map控件中
//pMapCtrl.AddLayer(ipLayer, pMapCtrl.LayerCount);
pMapCtrl.Map.AddLayer(ipLayer);
//pMapCtrl.ActiveView.Extent = ipLayer.AreaOfInterest;
}
}
private INetworkDataset OpenNetworkDataset_Other(IWorkspace workspace, string strNDName, string strRoadFeatureDataset)
{
if (workspace == null || strNDName == "" || strRoadFeatureDataset == null)
{
return null;
}
IDatasetContainer3 pDatasetContainer3;
IFeatureWorkspace pFeatureWorkspace = workspace as IFeatureWorkspace;
pFeatureDataset = pFeatureWorkspace.OpenFeatureDataset(strRoadFeatureDataset);
IFeatureDatasetExtensionContainer pFeatureDatasetExtensionContainer = pFeatureDataset as IFeatureDatasetExtensionContainer;
IFeatureDatasetExtension pFeatureDatasetExtension = pFeatureDatasetExtensionContainer.FindExtension(esriDatasetType.esriDTNetworkDataset);
pDatasetContainer3 = pFeatureDatasetExtension as IDatasetContainer3;
if (pDatasetContainer3 == null)
return null;
IDataset pDataset = pDatasetContainer3.get_DatasetByName(esriDatasetType.esriDTNetworkDataset, strNDName);
return pDataset as INetworkDataset;
}
//打开网络
public void OpenFeatureDatasetNetwork(IFeatureDataset Featuredataset,System.Collections.ArrayList array1,System.Collections.ArrayList array2,int flag)
{
CloseWorkspace();
if (!InitializeNetworkAndMap(Featuredataset,array1,array2,flag))
Console.WriteLine("打开出错");
}
internal FeatureData(String theName, IFeatureClass theFClass)
{
this.Name = theName;
this.theGType = theFClass.ShapeType;
this.theAlias = theFClass.AliasName;
this.OIDName = theFClass.OIDFieldName;
this.ShapeName = theFClass.ShapeFieldName;
this.theDS = theFClass.FeatureDataset;
this.theST = (ISubtypes)theFClass;
this.theFlds = theFClass.Fields;
this.isIdentical = 0;
}
///<summary>Simple helper to create a featureclass in a geodatabase.</summary>
///
///<param name="workspace">An IWorkspace2 interface</param>
///<param name="featureDataset">An IFeatureDataset interface or Nothing</param>
///<param name="featureClassName">A System.String that contains the name of the feature class to open or create. Example: "states"</param>
///<param name="fields">An IFields interface</param>
///<param name="clsid">A UID value or Nothing. Example "esriGeoDatabase.Feature" or Nothing</param>
///<param name="clsext">A UID value or Nothing (this is the class extension if you want to reference a class extension when creating the feature class).</param>
///<param name="strConfigKeyword">An empty System.String or RDBMS table string for ArcSDE. Example: "myTable" or ""</param>
///
///<returns>An IFeatureClass interface or a Nothing</returns>
///
///<remarks>
/// (1) If a 'featureClassName' already exists in the workspace a reference to that feature class
/// object will be returned.
/// (2) If an IFeatureDataset is passed in for the 'featureDataset' argument the feature class
/// will be created in the dataset. If a Nothing is passed in for the 'featureDataset'
/// argument the feature class will be created in the workspace.
/// (3) When creating a feature class in a dataset the spatial reference is inherited
/// from the dataset object.
/// (4) If an IFields interface is supplied for the 'fields' collection it will be used to create the
/// table. If a Nothing value is supplied for the 'fields' collection, a table will be created using
/// default values in the method.
/// (5) The 'strConfigurationKeyword' parameter allows the application to control the physical layout
/// for this table in the underlying RDBMSfor example, in the case of an Oracle database, the
/// configuration keyword controls the tablespace in which the table is created, the initial and
/// next extents, and other properties. The 'strConfigurationKeywords' for an ArcSDE instance are
/// set up by the ArcSDE data administrator, the list of available keywords supported by a workspace
/// may be obtained using the IWorkspaceConfiguration interface. For more information on configuration
/// keywords, refer to the ArcSDE documentation. When not using an ArcSDE table use an empty
/// string (ex: "").
///</remarks>
internal IFeatureClass CreateFeatureClass(IWorkspace2 workspace, IFeatureDataset featureDataset,
string featureClassName,
IFields fields, ESRI.ArcGIS.esriSystem.UID clsid,
ESRI.ArcGIS.esriSystem.UID clsext, string strConfigKeyword)
{
if (string.IsNullOrEmpty(featureClassName))
return null;
IFeatureClass featureClass;
var featureWorkspace = (IFeatureWorkspace)workspace; // Cast may throw exception
if (workspace.NameExists[esriDatasetType.esriDTFeatureClass, featureClassName])
//feature class with that name already exists
{
featureClass = featureWorkspace.OpenFeatureClass(featureClassName);
return featureClass;
}
// assign the class id value if not assigned
if (clsid == null)
{
clsid = new ESRI.ArcGIS.esriSystem.UIDClass { Value = "esriGeoDatabase.Feature" };
//Works for shapefiles as well
}
IObjectClassDescription objectClassDescription = new FeatureClassDescriptionClass();
// if a fields collection is not passed in then supply our own
if (fields == null)
{
// create the fields using the required fields method
fields = objectClassDescription.RequiredFields;
var fieldsEdit = (IFieldsEdit)fields; // Explicit Cast
IField field = new FieldClass();
// create a user defined text field
var fieldEdit = (IFieldEdit)field; // Explicit Cast
// setup field properties
fieldEdit.Name_2 = "SampleField";
fieldEdit.Type_2 = esriFieldType.esriFieldTypeString;
fieldEdit.IsNullable_2 = true;
fieldEdit.AliasName_2 = "Sample Field Column";
fieldEdit.DefaultValue_2 = "test";
fieldEdit.Editable_2 = true;
fieldEdit.Length_2 = 100;
// add field to field collection
fieldsEdit.AddField(field);
fields = fieldsEdit;
}
string strShapeField = "";
// locate the shape field
for (int j = 0; j < fields.FieldCount; j++)
{
if (fields.Field[j].Type != esriFieldType.esriFieldTypeGeometry)
continue;
strShapeField = fields.Field[j].Name;
break;
}
// Use IFieldChecker to create a validated fields collection.
IFieldChecker fieldChecker = new FieldCheckerClass();
IEnumFieldError enumFieldError;
IFields validatedFields;
fieldChecker.ValidateWorkspace = (IWorkspace)workspace;
fieldChecker.Validate(fields, out enumFieldError, out validatedFields);
// The enumFieldError enumerator can be inspected at this point to determine
// which fields were modified during validation.
// finally create and return the feature class
featureClass = featureDataset == null
? featureWorkspace.CreateFeatureClass(featureClassName, validatedFields, clsid, clsext,
esriFeatureType.esriFTSimple, strShapeField,
strConfigKeyword)
: featureDataset.CreateFeatureClass(featureClassName, validatedFields, clsid, clsext,
esriFeatureType.esriFTSimple, strShapeField,
strConfigKeyword);
return featureClass;
}
/// <summary>
/// 获得需要的几何网络
/// </summary>
/// <param name="_pFeatureDataset"></param>
/// <param name="_pGeometricName"></param>
/// <returns></returns>
IGeometricNetwork GetGeometricNetwork(IFeatureDataset _pFeatureDataset,string _pGeometricName)
{
INetworkCollection pNetworkCollection = _pFeatureDataset as INetworkCollection;
return pNetworkCollection.get_GeometricNetworkByName(_pGeometricName);
}
