ArcGIS Engine基础（18）之拓扑检查（根据数据集创建拓扑、添加拓扑规则、添加参与拓扑图层、验证拓扑、输出错误信息等）

  /// <summary>
        /// 建立拓扑
        /// </summary>
        /// <param name="featureDataset">拓扑分析的数据集</param>
        /// <param name="TopologyName">拓扑名</param>
        /// <param name="insteadIfExit">取代原拓扑</param>
        /// <returns></returns>
        public ITopology CreateTopology(IFeatureDataset featureDataset, string TopologyName, bool insteadIfExit)
        {
            ITopologyContainer2 topologyContainer = (ITopologyContainer2)featureDataset;
            ITopology topology = null;

            try
            {
                topology = topologyContainer.get_TopologyByName(TopologyName);
            }
            catch
            {
            }

            if (topology != null && insteadIfExit == true)
                (topology as IDataset).Delete();

            try
            {
                topology = topologyContainer.CreateTopology(TopologyName,
                    topologyContainer.DefaultClusterTolerance, -1, "");
            }
            catch (Exception ex)
            {
                throw new ApplicationException("创建拓扑失败:\r\n");
            }

            return topology;
        }

        /// <summary>
        /// 向拓扑添加要素类
        /// </summary>
        /// <param name="pTopology"></param>
        /// <param name="pFeatureClass"></param>
        public void AddClass(ITopology pTopology, IFeatureClass pFeatureClass)
        {
            try
            {
                pTopology.AddClass(pFeatureClass, 1, 1, 1, false);
            }
            catch
            { throw new ApplicationException("拓扑分析，添加数据出错。"); }
        }


        /// <summary>
        /// 添加拓扑规则
        /// </summary>
        /// <param name="topology">拓扑</param>
        /// <param name="ruleType">拓扑规则类型</param>
        /// <param name="ruleName">规则名</param>
        /// <param name="originClass">源图层</param>
        /// <param name="destinationClass">目标图层</param>
        public void AddRuleToTopology(ITopology topology, esriTopologyRuleType ruleType,
            string ruleName, IFeatureClass originClass, IFeatureClass destinationClass)
        {
            ITopologyRule topologyRule = new TopologyRuleClass();
            topologyRule.TopologyRuleType = ruleType;
            topologyRule.Name = ruleName;
            topologyRule.OriginClassID = originClass.FeatureClassID;
            topologyRule.AllOriginSubtypes = true;

            if (destinationClass != null)
            {
                topologyRule.DestinationClassID = destinationClass.FeatureClassID;
                topologyRule.AllDestinationSubtypes = true;
            }

            ITopologyRuleContainer topologyRuleContainer = (ITopologyRuleContainer)topology;
            if (topologyRuleContainer.get_CanAddRule(topologyRule))
            {
                topologyRuleContainer.AddRule(topologyRule);
            }
            else
            {
                throw new ArgumentException(string.Format("不能添加{0}规则到拓扑里面，请检查此规则是否正确。",ruleName));
            }
        }


        /// <summary>
        /// 验证拓扑并输出错误信息
        /// </summary>
        /// <param name="topology"></param>
        /// <param name="featureDataset"></param>
        /// <returns></returns>
        public Dictionary<string,int> ValidateTopologyReport(ITopology topology, IFeatureDataset featureDataset)
        {
            Dictionary<string, int> errorInfo = new Dictionary<string, int>();
            IFeatureClassContainer featureClassContainer = featureDataset as IFeatureClassContainer;
            IGeoDataset geoDataset = topology as IGeoDataset;
            //验证拓扑
            ValidateTopology(topology, geoDataset.Extent);
            //获取错误信息
            List<ITopologyRule> topologyRuleList = GetAllesriTopologyRules(topology);
            string layerName;
            //string errorids ;
            int countTopo = 0;
            List<int> ids ;
            IFeatureClass originFeatureClass = null;
            foreach (ITopologyRule topologyRule in topologyRuleList)
            {
                layerName = "";
                countTopo = 0;
                ids = new List<int>();
                originFeatureClass = featureClassContainer.get_ClassByID(topologyRule.OriginClassID);
                layerName = (originFeatureClass as IDataset).Name;

                IEnumTopologyErrorFeature enumTopologyErrorFeature = GetErrorFeaturesForRule(topology, topologyRule);
                ITopologyErrorFeature topologyErrorFeature = enumTopologyErrorFeature.Next();

                while (topologyErrorFeature != null)
                {
                    if (ids.Contains(topologyErrorFeature.OriginOID)) 
                    {
                        topologyErrorFeature = enumTopologyErrorFeature.Next(); 
                        continue; 
                    }
                    countTopo++;
                    ids.Add(topologyErrorFeature.OriginOID);
                    topologyErrorFeature = enumTopologyErrorFeature.Next();
                }
                if (countTopo > 0) errorInfo.Add(layerName +","+ topologyRule.Name, countTopo);
                //ComObject.Release<IFeatureClass>(ref originFeatureClass);
            }

            return errorInfo;
        }

        /// <summary>
        /// 验证拓扑
        /// </summary>
        /// <param name="topology"></param>
        /// <param name="envelope"></param>
        public void ValidateTopology(ITopology topology, IEnvelope envelope)
        {
            IPolygon locationPolygon = new PolygonClass();
            ISegmentCollection segmentCollection = (ISegmentCollection)locationPolygon;
            segmentCollection.SetRectangle(envelope);
            IPolygon polygon = topology.get_DirtyArea(locationPolygon);

            if (!polygon.IsEmpty)
            {
                IEnvelope areaToValidate = polygon.Envelope;
                IEnvelope areaValidated = topology.ValidateTopology(areaToValidate);
            }
        }

        /// <summary>
        /// 获取所有拓扑规则
        /// </summary>
        /// <param name="topology"></param>
        /// <returns></returns>
        public List<ITopologyRule> GetAllesriTopologyRules(ITopology topology)
        {
            List<ITopologyRule> allEsriTopologyRulesList = new List<ITopologyRule>();
            ITopologyRuleContainer topologyRuleContainer = topology as ITopologyRuleContainer;
            IEnumRule enumRule = topologyRuleContainer.Rules;

            enumRule.Reset();
            IRule rule = null;
            while ((rule = enumRule.Next()) != null)
            {
                ITopologyRule topologyRule = (ITopologyRule)rule;
                allEsriTopologyRulesList.Add(topologyRule);
            }

            return allEsriTopologyRulesList;
        }

        /// <summary>
        /// 从拓扑规则获取拓扑错误要素
        /// </summary>
        /// <param name="topology"></param>
        /// <param name="topologyRule"></param>
        /// <returns></returns>
        public IEnumTopologyErrorFeature GetErrorFeaturesForRule(ITopology topology, ITopologyRule topologyRule)
        {
            IErrorFeatureContainer errorFeatureContainer = (IErrorFeatureContainer)topology;
            IGeoDataset geoDataset = (IGeoDataset)topology;
            ISpatialReference spatialReference = geoDataset.SpatialReference;

            IEnumTopologyErrorFeature enumTopologyErrorFeature =
                errorFeatureContainer.get_ErrorFeatures(spatialReference, topologyRule,
                geoDataset.Extent, true, false);

            return enumTopologyErrorFeature;
        }

        /// <summary>
        /// 获取参与拓扑分析的图层
        /// </summary>
        /// <param name="topology">拓扑</param>
        /// <param name="layerName">图层名</param>
        /// <returns></returns>
        public ILayer GetParticipateLayer(ITopology topology, string layerName)
        {
            ILayer layer = null;
            IFeatureClassContainer featureContainer = topology.FeatureDataset as IFeatureClassContainer;
            List<ITopologyRule> rules = GetAllesriTopologyRules(topology);
            List<int> participateClassId = new List<int>();
            //获取参加拓扑分析的要素类
            List<IFeatureClass> participateClasses = new List<IFeatureClass>();
            foreach (ITopologyRule rule in rules)
            {
                if (!participateClassId.Contains(rule.OriginClassID))
                {
                    participateClassId.Add(rule.OriginClassID);
                    participateClasses.Add(featureContainer.get_ClassByID(rule.OriginClassID));
                }
                if (!participateClassId.Contains(rule.DestinationClassID))
                {
                    participateClassId.Add(rule.DestinationClassID);
                    participateClasses.Add(featureContainer.get_ClassByID(rule.DestinationClassID));
                }
            }
            IGroupLayer groupLayer = new GroupLayerClass();
            //添加拓扑图层
            ITopologyLayer topologyLayer = new TopologyLayerClass();
            topologyLayer.Topology = topology;
            groupLayer.Add(topologyLayer as ILayer);

            if (participateClasses.Count > 0)
            {
                // 按面、MultiPatch、线、点的顺序进行排序
                esriGeometryType[] sortGeometryTypes = new esriGeometryType[] {
                esriGeometryType.esriGeometryPolygon, esriGeometryType.esriGeometryMultiPatch,
                esriGeometryType.esriGeometryPolyline,esriGeometryType.esriGeometryPoint };
                List<IFeatureClass> sortedFeatureClass = new List<IFeatureClass>();
                foreach (esriGeometryType sortGeometryType in sortGeometryTypes)
                {
                    IEnumerable<IFeatureClass> sortClass = null;

                    sortClass = from cls in participateClasses
                                where cls.ShapeType == sortGeometryType
                                select cls;
                    sortedFeatureClass.AddRange(sortClass);
                }
                foreach (IFeatureClass fc in sortedFeatureClass)
                {
                    IFeatureLayer featureLayer = new FeatureLayerClass();
                    featureLayer.FeatureClass = fc;
                    groupLayer.Add(featureLayer as ILayer);
                }
                layer = groupLayer;
                layer.Name = layerName;
            }

            return layer;
        }