NDBGJK5.0/IDEForNDBG/Helper/CZCDYDHelper.cs

using ESRI.ArcGIS.Carto;
using ESRI.ArcGIS.DataSourcesGDB;
using ESRI.ArcGIS.Geodatabase;
using ESRI.ArcGIS.Geometry;
using IDEParameter;
using KGIS.Framework.AE;
using KGIS.Framework.AE.Enum;
using KGIS.Framework.AE.ExtensionMethod;
//using KGIS.Framework.AE.GPHelper;
using KGIS.Framework.DBOperator;
using KGIS.Framework.Platform;
using KGIS.Framework.Platform.Helper;
using KGIS.Framework.ThreadManager;
using KGIS.Framework.Utils;
using KGIS.Framework.Utils.ExtensionMethod;
using KGIS.Framework.Utils.Helper;
using KGIS.Framework.Utils.Utility;
using Kingo.PluginServiceInterface;
using Kingo.PluginServiceInterface.Model;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;

namespace IDGForNDBG
{
    public class CZCDYDHelper : BaseIDG
    {
        //private IFeatureLayer _DLTBFc = null;
        public string IDataChangeName { get => "CZCDYDHelper"; }
        private string TempGDBPath = string.Empty;
        private string TempDBPath = string.Empty;
        #region ExecuteDataChange
        public void Execute(IDGParameter3 pParm)
        {
            try
            {

                ThreadManager.Instance.QueueUserWorkItem(new System.Threading.WaitCallback(ExtractExe), pParm);
                
                //IFeatureClass _CZCFc = MapsManager.Instance.MapService.GetFeatureLayerByLayerName("城镇村等用地").FeatureClass;
                //Implement(_CZCFc, true, false);
                //ExtractExe(pParm, bgParm);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        public void OpenDB(IDGParameter3 parm, ref CZC_Param pCzcParm)
        {
            IFeatureClassAPI BgTBFcAPI = null;
            IFeatureClassAPI JcTBFcAPI = null;
            IFeatureClassAPI JcCZCFcAPI = null;
            IFeatureClassAPI GxTBFcAPI = null;
            IFeatureClassAPI GxGcCZCFcAPI = null;
            IFeatureClassAPI GxCZCFcAPI = null;
            GPParamClass paramClass = null;// new GPParamClass();
            //GeoprocessorHelper gpHelper = new GeoprocessorHelper();
            try
            {
                BgWsAPI = new WorkspaceAPI(parm.BgDbPath, WorkspaceTypeEnum.GDBFile);
                if (BgWsAPI.CurrentWorkspace == null)
                {
                    Console.WriteLine("打开变更数据库失败！");
                    return;
                }
                JcWsAPI = new WorkspaceAPI(parm.JcDbPath, WorkspaceTypeEnum.GDBFile);
                if (JcWsAPI.CurrentWorkspace == null)
                {
                    Console.WriteLine("打开基础数据库失败！");
                    return;
                }
                ZlWsAPI = new WorkspaceAPI(parm.ZLDbPath, WorkspaceTypeEnum.GDBFile);
                if (ZlWsAPI.CurrentWorkspace == null)
                {
                    Console.WriteLine("打开增量数据库失败！");
                    return;
                }
                NmWsAPI = new WorkspaceAPI(parm.NmDbPath, WorkspaceTypeEnum.GDBFile);

                BgTBFcAPI = BgWsAPI.OpenFeatureClass("DLTBBG");
                JcTBFcAPI = JcWsAPI.OpenFeatureClass("DLTB");
                JcCZCFcAPI = JcWsAPI.OpenFeatureClass("CZCDYD");
                GxTBFcAPI = ZlWsAPI.OpenFeatureClass("DLTBGX");
                GxCZCFcAPI = ZlWsAPI.OpenFeatureClass("CZCDYDGX");
                GxGcCZCFcAPI = ZlWsAPI.OpenFeatureClass("CZCDYDGXGC");

                IFeatureLayer pJCTBLayer = null;
                if (JcTBFcAPI.FeatureClass != null)
                {
                    //paramClass = new GPParamClass();
                    //paramClass.FirstFeatureClass = JcTBFcAPI.FeatureClass;
                    //paramClass.OutFeatureClassPath = "DLTB";
                    //paramClass.IsGetOutPutFeature = true;
                    //gpHelper.MakeFeatureLayer(paramClass, ref pJCTBLayer);
                    IFeatureLayer pFeatureLayer = new FeatureLayerClass();
                    pFeatureLayer.FeatureClass = JcTBFcAPI.FeatureClass;
                    pFeatureLayer.Name = JcTBFcAPI.FeatureClass.AliasName;
                    pCzcParm.JCTBLayer = pFeatureLayer;
                }
                IFeatureLayer pJCCZCLayer = null;
                if (JcCZCFcAPI.FeatureClass != null)
                {
                    //paramClass = new GPParamClass();
                    //paramClass.FirstFeatureClass = JcCZCFcAPI.FeatureClass;
                    //paramClass.OutFeatureClassPath = "CZCDYD";
                    //paramClass.IsGetOutPutFeature = true;
                    //gpHelper.MakeFeatureLayer(paramClass, ref pJCCZCLayer);

                    IFeatureLayer pFeatureLayer = new FeatureLayerClass();
                    pFeatureLayer.FeatureClass = JcCZCFcAPI.FeatureClass;
                    pFeatureLayer.Name = JcCZCFcAPI.FeatureClass.AliasName;
                    pCzcParm.JCCZCLayer = pFeatureLayer;
                }
                IFeatureLayer pGXTBLayer = null;
                if (GxTBFcAPI.FeatureClass != null)
                {
                    //paramClass = new GPParamClass();
                    //paramClass.FirstFeatureClass = GxTBFcAPI.FeatureClass;
                    //paramClass.OutFeatureClassPath = "DLTBGX";
                    //paramClass.IsGetOutPutFeature = true;
                    //gpHelper.MakeFeatureLayer(paramClass, ref pGXTBLayer);

                    IFeatureLayer pFeatureLayer = new FeatureLayerClass();
                    pFeatureLayer.FeatureClass = GxTBFcAPI.FeatureClass;
                    pFeatureLayer.Name = GxTBFcAPI.FeatureClass.AliasName;
                    pCzcParm.GXTBLayer = pFeatureLayer;
                }
                IFeatureLayer pGXCZCLayer = null;
                if (GxCZCFcAPI.FeatureClass != null)
                {
                    //paramClass = new GPParamClass();
                    //paramClass.FirstFeatureClass = GxCZCFcAPI.FeatureClass;
                    //paramClass.OutFeatureClassPath = "CZCDYDGX";
                    //paramClass.IsGetOutPutFeature = true;
                    //gpHelper.MakeFeatureLayer(paramClass, ref pGXCZCLayer);

                    IFeatureLayer pFeatureLayer = new FeatureLayerClass();
                    pFeatureLayer.FeatureClass = GxCZCFcAPI.FeatureClass;
                    pFeatureLayer.Name = GxCZCFcAPI.FeatureClass.AliasName;
                    pCzcParm.GXCZCLayer = pFeatureLayer;
                }
                IFeatureLayer pGXGCCZCLayer = null;
                if (GxGcCZCFcAPI.FeatureClass != null)
                {
                    //paramClass = new GPParamClass();
                    //paramClass.FirstFeatureClass = GxGcCZCFcAPI.FeatureClass;
                    //paramClass.OutFeatureClassPath = "CZCDYDGXGC";
                    //paramClass.IsGetOutPutFeature = true;
                    //gpHelper.MakeFeatureLayer(paramClass, ref pGXGCCZCLayer);

                    IFeatureLayer pFeatureLayer = new FeatureLayerClass();
                    pFeatureLayer.FeatureClass = GxGcCZCFcAPI.FeatureClass;
                    pFeatureLayer.Name = GxGcCZCFcAPI.FeatureClass.AliasName;
                    pCzcParm.GXGCCZCLayer = pFeatureLayer;
                }
                IFeatureLayer pBGTBLayer = null;
                if (BgTBFcAPI.FeatureClass != null)
                {
                    //paramClass = new GPParamClass();
                    //paramClass.FirstFeatureClass = BgTBFcAPI.FeatureClass;
                    //paramClass.OutFeatureClassPath = "DLTBBG";
                    //paramClass.IsGetOutPutFeature = true;
                    //gpHelper.MakeFeatureLayer(paramClass, ref pBGTBLayer);

                    IFeatureLayer pFeatureLayer = new FeatureLayerClass();
                    pFeatureLayer.FeatureClass = BgTBFcAPI.FeatureClass;
                    pFeatureLayer.Name = BgTBFcAPI.FeatureClass.AliasName;
                    pCzcParm.BGTBLayer = pFeatureLayer;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }



        private void ExtractExe(object parm)
        {
            IFeatureLayer jc_czcLayer = null;
            IFeatureLayer dltbgxLayer = null;
            IFeatureLayer dltbhrLayer = null;
            IFeatureLayer jcdltbLayer = null;
            IFeatureLayer dltbTempNMKLayer = null;
            IWorkspaceAPI Tempworkspace = null;
            IWorkspaceAPI Schemeworkspace = null;
            IFeatureClassAPI dltbFeatureClassAPI = null;
            IFeatureClassAPI czcdydFeatureClassAPI = null;
            IFeatureCursor pFeatureCursor = null;
            IFeatureCursor pInsertCursor = null;
            IFeatureClassAPI LSczcdydFeatureclassAPI = null;
            //IFeatureClassAPI pFeatureClass_4 = null;
            IFeatureClassAPI CZCDLTBFeatureClass = null;
            IWorkspaceFactory outputWorkspaceFactory = null;
            IWorkspaceFactory pOutWorkFactory = null;
            string TempfilePath = string.Empty;
            try
            {
                IDGParameter3 pParm = parm as IDGParameter3;
                CZC_Param bgParm = new CZC_Param();
                OpenDB(pParm, ref bgParm);
                string TempDir = CreateTempDB("CZC");
                TempGDBPath = System.IO.Path.Combine(TempDir, "TempGDB.gdb");
                TempDBPath = TempDir + @"\Temp" + ".sqlite";

                IRDBHelper rdbHelper = null;
                List<DataDicTionary> qsDic = null;
                try
                {

                    rdbHelper = RDBFactory.CreateDbHelper(System.IO.Path.Combine(pParm.ProjDir, "BGTJ.sqlite"), DatabaseType.SQLite);
                    DataTable dicDt = rdbHelper.ExecuteDatatable("Dic", string.Format("SELECT * from Sys_Dicdetail where OWNERDIC=1"), true);

                    //jccjdcqLayer = Parm.JC_CJDCQLay as IFeatureLayer;
                    qsDic = KGIS.Framework.Utils.Utility.TBToList.ToList<DataDicTionary>(dicDt);// Platform.Instance.DicHelper.GetNoGroupDic(DicTypeEnum.QSDM);

                }
                catch (Exception ex)
                {
                    Console.WriteLine("获取权属字典失败！" + ex.Message);
                    LogAPI.Debug(ex);
                }
                finally
                {
                    if (rdbHelper != null)
                        rdbHelper.DisConnect();
                }
                if (qsDic == null)
                {
                    LogAPI.Debug($"权属单位代码表获取失败。");
                    return;
                }
                //string filePath = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).GetProjDBPath();
                //string schemeDBPath = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).GetSchemeDBPath();
                //ProjGDBwkspace = new WorkspaceAPI(filePath, WorkspaceTypeEnum.GDBFile);
                //Schemeworkspace = new WorkspaceAPI(schemeDBPath, WorkspaceTypeEnum.GDBFile);

                #region 临时数据
                Console.WriteLine("正在提取城镇村等用地数据......");
                //TempfilePath = GetTempPath();//临时数据存放路径
                TempfilePath = TempGDBPath;
                if (string.IsNullOrEmpty(TempfilePath))
                {
                    LogAPI.Debug($"获取到城镇村等用地数据模板失败。");
                    return;
                }

                #region 地类图斑
                IFeatureClass bgtbFc = bgParm.BGTBLayer.FeatureClass;// MapsManager.Instance.MapService.GetFeatureClassByName("DLTBBG");
                dltbgxLayer = bgParm.GXTBLayer;// MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBGX");
                //dltbhrLayer = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBHR");
                jcdltbLayer = bgParm.JCTBLayer;// MapsManager.Instance.MapService.GetFeatureLayerByLayerName("地类图斑");
                jc_czcLayer = bgParm.JCCZCLayer;// MapsManager.Instance.MapService.GetFeatureLayerByLayerName("城镇村等用地");
                FeatureClass featureClass = jc_czcLayer.FeatureClass as FeatureClass;
                if (jc_czcLayer.FeatureClass.FeatureCount(null) == 0)
                {
                    Console.WriteLine("基础城镇村等用地图层未找到数据，请确认基础城镇村数据是否导入！");
                    return;
                }

                IFeatureLayer tempJCCZCLayer = null;
                //设置基础地类图斑选中
                GPParamClass gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = jc_czcLayer;
                gPParamClass.SecondFeatureLayer = dltbgxLayer;
                //gPParamClass.Tolerance = "-0.0001655555";
                //GeoprocessorHelper gpHelper = new GeoprocessorHelper();
                gPParamClass.GPType = EnumGPType.SelectLayerByLocation;
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.Overlap_type = "INTERSECT";
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref tempJCCZCLayer);

                IFeatureLayer _TempLayer = null;
                //选中的基础地类图斑导出至临时gdb
                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer= tempJCCZCLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath;
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.GPType = EnumGPType.FcToFc;
                gPParamClass.FcName = "JC_CZCDYD";
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref _TempLayer);
                try
                {
                    ESRI.ArcGIS.Carto.IFeatureSelection selection = jc_czcLayer as IFeatureSelection;
                    selection.Clear();
                }
                catch (Exception ex)
                {
                    LogAPI.Debug(ex.Message);
                }
                tempJCCZCLayer = _TempLayer;
                IFeatureLayer TempJCDLTB = null;// GeoDBAPI.CreateFeatureLayerInmemeory("CZC203", "城镇村203范围", (jcdltbLayer.FeatureClass as IGeoDataset).SpatialReference, jcdltbLayer.FeatureClass.ShapeType, jcdltbLayer.FeatureClass.Fields);

                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = jcdltbLayer;
                gPParamClass.SecondFeatureLayer = tempJCCZCLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath + "\\" + "TempJCDLTB20X";
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.GPType = EnumGPType.Intersect;
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref dltbTempNMKLayer);
                IWorkspace tempWs = (dltbTempNMKLayer.FeatureClass as FeatureClass).Workspace;

                tempWs.ExecuteSQL("Update TempJCDLTB20X set CZCSXM='201' where CZCLX='201'");
                tempWs.ExecuteSQL("Update TempJCDLTB20X set CZCSXM='201A' where CZCLX='201A'");
                tempWs.ExecuteSQL("Update TempJCDLTB20X set CZCSXM='202' where CZCLX='202'");
                tempWs.ExecuteSQL("Update TempJCDLTB20X set CZCSXM='202A' where CZCLX='202A'");
                tempWs.ExecuteSQL("Update TempJCDLTB20X set CZCSXM='203' where CZCLX='203'");
                tempWs.ExecuteSQL("Update TempJCDLTB20X set CZCSXM='203A' where CZCLX='203A'");
                tempWs.ExecuteSQL("Update TempJCDLTB20X set CZCSXM='204' where CZCLX='204'");
                tempWs.ExecuteSQL("Update TempJCDLTB20X set CZCSXM='205' where CZCLX='205'");

                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = dltbTempNMKLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath;
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.GPType = EnumGPType.FcToFc;
                gPParamClass.FcName = "CZC203";
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref TempJCDLTB);

                //IFeatureClassAPI dltb20xAPI = new FeatureClassAPI(dltbTempNMKLayer.FeatureClass);
                //dltb20xAPI.FcToFc(TempJCDLTB.FeatureClass, null, false);

                IFeatureLayer msTBLayer = GeoDBAPI.CreateFeatureLayerInmemeory("MSDLTB", "灭失图斑", (bgtbFc as IGeoDataset).SpatialReference, bgtbFc.ShapeType, bgtbFc.Fields);
                IQueryFilter filter2 = new QueryFilterClass();
                filter2.WhereClause = " XZQTZLX='2' or XZQTZLX='4'";
                (msTBLayer.FeatureClass as ITable).DeleteSearchedRows(null);
                InsertDataToMemeoryLayer(bgtbFc, msTBLayer.FeatureClass, filter2);

                IFeatureLayer pjbntFeatureLayer = null;
                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = TempJCDLTB;
                gPParamClass.SecondFeatureLayer = msTBLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath + "\\" + "TempDLTBNM";
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.GPType = EnumGPType.Erase;
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref pjbntFeatureLayer);

                IFeatureLayer TempDLTB_MToS = null;
                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = pjbntFeatureLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath + "\\" + "TempDLTBNM_MToS";
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.GPType = EnumGPType.MultipartToSinglePath;
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref TempDLTB_MToS);

                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = TempDLTB_MToS;
                gPParamClass.SecondFeatureLayer = dltbgxLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath + "\\" + "DLTBGXGC";
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.GPType = EnumGPType.Erase;
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref dltbTempNMKLayer);


                IFeatureClassAPI fcAPI = new FeatureClassAPI(dltbgxLayer.FeatureClass);
                fcAPI.FcToFc(dltbTempNMKLayer.FeatureClass, null, false);
                //fcAPI = new FeatureClassAPI(dltbhrLayer.FeatureClass);
                //fcAPI.FcToFc(dltbTempNMKLayer.FeatureClass, null, false);
                fcAPI = new FeatureClassAPI(dltbTempNMKLayer.FeatureClass);

                //string dbPath = $"{pParm.ProjDir}\\BGTJ.sqlite";
                rdbHelper = RDBFactory.CreateDbHelper("Data Source=" + TempDBPath, DatabaseType.SQLite);


                ITable nmkTable = dltbTempNMKLayer.FeatureClass as ITable;
                IQueryFilter filter = new QueryFilterClass();
                //foreach (string bsm in hcbghbsmList)
                //{
                //    filter.WhereClause = string.Format("BSM ='{0}' ", bsm);
                //    nmkTable.DeleteSearchedRows(filter);
                //}

                ICursor nmkCur = nmkTable.Update(null, true);
                IRow nmkRow = null;
                int bsmIdx = nmkTable.FindField("BSM");
                int zldwIdx = nmkTable.FindField("ZLDWDM");
                int zldwmcIdx = nmkTable.FindField("ZLDWMC");
                int sjnfIdx = nmkTable.FindField("SJNF");//数据年份
                int num1 = 0;
                while ((nmkRow = nmkCur.NextRow()) != null)
                {
                    num1++;
                    string bsm = nmkRow.Value[bsmIdx].ToTrim();
                    //if (zlbgList.ContainsKey(bsm))
                    //{
                    //    DataRow dr = zlbgList[bsm];
                    //    nmkRow.Value[zldwIdx] = dr["BGHZLDWDM"];
                    //    nmkRow.Value[zldwmcIdx] = dr["BGHZLDWMC"];
                    //}
                    //else
                    //if (bhxxDic.ContainsKey(bsm))
                    //{
                    //    for (int i = 0; i < nmkRow.Fields.FieldCount; i++)
                    //    {
                    //        IField field = nmkRow.Fields.Field[i];
                    //        string bghField = "BGH" + field.Name;
                    //        DataRow dr = bhxxDic[bsm];
                    //        if (!dr.Table.Columns.Contains(bghField))
                    //            bghField = "BGHTB" + field.Name;
                    //        if (dr.Table.Columns.Contains(bghField))
                    //        {
                    //            if (field.Type == esriFieldType.esriFieldTypeString)
                    //                nmkRow.Value[i] = dr[bghField];
                    //            else if (field.Type == esriFieldType.esriFieldTypeDouble)
                    //                nmkRow.Value[i] = dr[bghField].ToDouble();
                    //        }
                    //    }
                    //}

                    if (sjnfIdx != -1)
                    {
                        nmkRow.Value[sjnfIdx] = "2020";
                    }
                    nmkCur.UpdateRow(nmkRow);

                    if (num1 % 1000 == 0)
                    {
                        nmkCur.Flush();
                    }
                }
                nmkCur.Flush();
                #endregion 


                IWorkspaceFactory TempWorkspaceFactory = new ESRI.ArcGIS.DataSourcesGDB.FileGDBWorkspaceFactoryClass();
                Tempworkspace = new WorkspaceAPI(TempWorkspaceFactory.OpenFromFile(TempfilePath, 0));
                dltbFeatureClassAPI = Tempworkspace.OpenFeatureClass("DLTBGXGC");
                #endregion

                czcdydFeatureClassAPI = new FeatureClassAPI(bgParm.GXCZCLayer.FeatureClass);// Schemeworkspace.OpenFeatureClass("CZCDYDGX");
                if (dltbFeatureClassAPI.FeatureClass.FeatureCount(null) <= 0)
                {
                    return;
                }
                if (Tempworkspace.ExistFeatureClass("LSczcdyd"))
                {
                    Tempworkspace.DeleteFeatureClass("LSczcdyd");
                }
                //  创建临时层
                LSczcdydFeatureclassAPI = Tempworkspace.CreateFeatureClass("LSczcdyd", (czcdydFeatureClassAPI.FeatureClass as IGeoDataset).SpatialReference, null);
                LSczcdydFeatureclassAPI.AddField("CZCLX", esriFieldType.esriFieldTypeString, "CZCLX");
                LSczcdydFeatureclassAPI.AddField("CZCDM", esriFieldType.esriFieldTypeString, "CZCDM");
                LSczcdydFeatureclassAPI.AddField("CZCMC", esriFieldType.esriFieldTypeString, "CZCMC");
                LSczcdydFeatureclassAPI.AddField("ZLDWDM", esriFieldType.esriFieldTypeString, "ZLDWDM");
                LSczcdydFeatureclassAPI.AddField("ZLDWMC", esriFieldType.esriFieldTypeString, "ZLDWMC");
                if (czcdydFeatureClassAPI == null || czcdydFeatureClassAPI.FeatureClass == null)
                {
                    Console.WriteLine("当前工程数据库未找到城镇村等用地(CZCDYDGX)图层！");
                    return;
                }
                int czcsxmIndex = dltbFeatureClassAPI.FeatureClass.Fields.FindField("CZCSXM");
                int czclxIndex = czcdydFeatureClassAPI.FeatureClass.Fields.FindField("CZCLX");
                int LSczclxIndex = LSczcdydFeatureclassAPI.FeatureClass.Fields.FindField("CZCLX");
                IQueryFilter queryFilter = new QueryFilter()
                {
                    WhereClause = "CZCSXM IN('201','202','203','204','205','201A','202A','203A')"
                };
                int count = dltbFeatureClassAPI.FeatureClass.FeatureCount(queryFilter);
                if (czcdydFeatureClassAPI.FeatureClass.FeatureCount(null) > 0)
                {
                    ITable pTable = czcdydFeatureClassAPI.FeatureClass as ITable;
                    if (pTable != null)
                    {
                        pTable.DeleteSearchedRows(null);
                    }
                    else
                    {
                        Console.WriteLine("城镇村等用地数据清除失败！");
                        return;
                    }
                }
                pFeatureCursor = dltbFeatureClassAPI.FeatureClass.Search(queryFilter, false);
                pInsertCursor = LSczcdydFeatureclassAPI.FeatureClass.Insert(true);

                IFeatureBuffer featureAdd = LSczcdydFeatureclassAPI.FeatureClass.CreateFeatureBuffer();
                IFeature pFeature = null;
                int num = 0;
                int zldwdm = dltbFeatureClassAPI.FeatureClass.Fields.FindField("ZLDWDM");
                int zldwmc = dltbFeatureClassAPI.FeatureClass.Fields.FindField("ZLDWMC");
                int lszldwdm = LSczcdydFeatureclassAPI.FeatureClass.Fields.FindField("ZLDWDM");
                int lszldwmc = LSczcdydFeatureclassAPI.FeatureClass.Fields.FindField("ZLDWMC");
                while ((pFeature = pFeatureCursor.NextFeature()) != null)
                {
                    featureAdd.Shape = pFeature.Shape;
                    if (LSczclxIndex > -1)
                    {
                        featureAdd.set_Value(LSczclxIndex, pFeature.get_Value(czcsxmIndex));
                    }
                    if (lszldwdm != -1)
                    {
                        featureAdd.set_Value(lszldwdm, pFeature.get_Value(zldwdm));
                    }
                    if (lszldwmc != -1)
                    {
                        featureAdd.set_Value(lszldwmc, pFeature.get_Value(zldwmc));
                    }
                    pInsertCursor.InsertFeature(featureAdd);
                }
                pInsertCursor.Flush();
                Console.WriteLine("正在对城镇村等用地更新进行赋值......");
                pOutWorkFactory = new SqlWorkspaceFactoryClass();
                IWorkspace pOutWork = pOutWorkFactory.OpenFromFile(TempDBPath, 0);
                //IFeatureWorkspace SchemeWork = GetGdbWorkspace(schemeDBPath);
                IFeatureWorkspace TempWork2 = GetGdbWorkspace(TempfilePath);
                rdbHelper.ExecuteSQL(" drop table LSczcdyd ");
                TableToTable(TempWork2, pOutWork, "LSczcdyd");

                string updateSQL = string.Format("update {0} set CZCDM = substr(ZLDWDM,1,6) || '0000000000000' where CZCLX in ('201','201A')", "LSczcdyd");
                rdbHelper.ExecuteSQL(updateSQL);
                updateSQL = string.Format("update {0} set CZCDM =  substr(ZLDWDM,1,9) || '0000000000' where CZCLX in ('202','202A')", "LSczcdyd");
                rdbHelper.ExecuteSQL(updateSQL);
                updateSQL = string.Format("update {0} set CZCDM = [ZLDWDM],CZCMC = [ZLDWMC] where CZCLX in ('203','203A','204','205')", "LSczcdyd");
                var x = rdbHelper.ExecuteSQL(updateSQL);

                DataTable dtLSczcdyd = rdbHelper.ExecuteDatatable("LSczcdyd", "select OBJECTID,CZCDM,CZCMC from LSczcdyd", true);
                pFeatureCursor = Tempworkspace.OpenFeatureClass("LSczcdyd").FeatureClass.Update(null, false);
                while ((pFeature = pFeatureCursor.NextFeature()) != null)
                {
                    object czcdm = dtLSczcdyd.Select(string.Format(" OBJECTID={0} ", pFeature.get_Value(pFeature.Fields.FindField("OBJECTID"))))[0]["CZCDM"];
                    pFeature.set_Value(pFeature.Fields.FindField("CZCDM"), czcdm);
                    object czcmc = dtLSczcdyd.Select(string.Format(" OBJECTID={0} ", pFeature.get_Value(pFeature.Fields.FindField("OBJECTID"))))[0]["CZCMC"];
                    pFeature.set_Value(pFeature.Fields.FindField("CZCMC"), czcmc);
                    pFeatureCursor.UpdateFeature(pFeature);
                }
                pFeatureCursor.Flush();
                LSczcdydFeatureclassAPI = Tempworkspace.OpenFeatureClass("LSczcdyd");
                // 根据城镇村等用地类型及城镇村代码相同且相邻进行融合
                List<string> columns = new List<string>() { "CZCLX", "CZCDM", "CZCMC" };
                var beforeCount = LSczcdydFeatureclassAPI.FeatureClass.FeatureCount(null);
                var outFilePath = TempfilePath + "\\CZCDYD_Dissolve";
                gPParamClass = new GPParamClass()
                {
                    FirstFeatureLayer =new FeatureLayerClass() { FeatureClass = LSczcdydFeatureclassAPI.FeatureClass },
                    OutFeatureClassPath = outFilePath,
                    IsGetOutPutFeature = true,
                    ListDissolveFiledName = columns,
                    //Statistics_Fields = "BSM COUNT",
                };
                if (Tempworkspace.ExistFeatureClass("CZCDYD_Dissolve"))
                {
                    Tempworkspace.DeleteFeatureClass("CZCDYD_Dissolve");
                }
                if (Tempworkspace.ExistFeatureClass("CZCDYD_Dissolve_Result"))
                {
                    Tempworkspace.DeleteFeatureClass("CZCDYD_Dissolve_Result");
                }
                string path = gPParamClass.OutFeatureClassPath;
                IFeatureLayer featureLayer = null;
                gPParamClass.GPType = EnumGPType.Dissolve;
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref featureLayer);

                gPParamClass.FirstFeatureLayer = featureLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath;
                gPParamClass.FcName = "CZCDYD_Dissolve_Result";
                gPParamClass.GPType = EnumGPType.FcToFc;
                IFeatureLayer tempLayer = null;
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref tempLayer); ;
                //pFeatureClass_4 = tempLayer.FeatureClass;// Tempworkspace.OpenFeatureClass("CZCDYD_Dissolve_Result");

                int countt = tempLayer.FeatureClass.FeatureCount(null);
                if (countt <= 0)
                {
                    //Console.WriteLineTips("融合之后出错！，数据异常");
                    return;
                }
                pFeatureCursor = tempLayer.FeatureClass.Search(null, false);
                //网格大小引发的错误
                if (czcdydFeatureClassAPI.FeatureClass is IFeatureClassLoad pFclsLoad)
                    pFclsLoad.LoadOnlyMode = true;
                pInsertCursor = czcdydFeatureClassAPI.FeatureClass.Insert(true);
                int cxmIndex = tempLayer.FeatureClass.FindField("CZCLX");
                int Index_1 = tempLayer.FeatureClass.FindField("CZCDM");
                int Index_2 = czcdydFeatureClassAPI.FeatureClass.FindField("CZCDM");
                int Index_3 = tempLayer.FeatureClass.FindField("CZCMC");
                int Index_4 = czcdydFeatureClassAPI.FeatureClass.FindField("CZCMC");
                featureAdd = czcdydFeatureClassAPI.FeatureClass.CreateFeatureBuffer();
                pFeature = null;
                string substr = "";
                num = 0;
                while ((pFeature = pFeatureCursor.NextFeature()) != null)
                {
                    featureAdd.Shape = pFeature.Shape;
                    if (czclxIndex > -1)
                    {
                        featureAdd.set_Value(czclxIndex, pFeature.get_Value(cxmIndex));
                        featureAdd.set_Value(Index_2, pFeature.get_Value(Index_1));
                        featureAdd.set_Value(Index_4, pFeature.get_Value(Index_3));
                        if (string.IsNullOrEmpty(substr))
                        {
                            substr = pFeature.get_Value(Index_1).ToString();
                        }
                    }
                    pInsertCursor.InsertFeature(featureAdd);
                }
                pInsertCursor.Flush();
                if (czcdydFeatureClassAPI.FeatureClass is IFeatureClassLoad pFclsLoads)
                    pFclsLoads.LoadOnlyMode = false;
                path = TempfilePath;// GetTempPath();
                rdbHelper.ExecuteSQL(" drop table CZCDYDGX ");
                IFeatureWorkspace TempfeatureWorkspace = (bgParm.GXCZCLayer.FeatureClass as FeatureClass).Workspace as IFeatureWorkspace;
                TableToTable(TempfeatureWorkspace, pOutWork, "CZCDYDGX");

                #region 201 201A
                {
                    var result = GetXZQDic().Find(p => p.CODE == substr.Substring(0, 6));
                    if (result != null)
                    {
                        string SQLstr = $"UPDATE CZCDYDGX SET CZCMC = '{result.NAME}' WHERE CZCLX in ('201','201A')";
                        rdbHelper.ExecuteSQL(SQLstr);
                    }
                }
                #endregion

                rdbHelper.ExecuteSQL(" drop table CJDCQGX ");
                TableToTable(TempfeatureWorkspace, pOutWork, "CJDCQGX");

                DataTable dt = rdbHelper.ExecuteDatatable("CZCDYDGX", "select objectid,CZCMC from CZCDYDGX", true);

                string time = new DateTime(DateTime.Now.Year - 1, 12, 31).ToShortDateString();
                // 标识码赋值
                int maxValue = 1;

                string MaxBSM = GetMaxBSM(new List<IFeatureClass>() { bgParm.JCCZCLayer.FeatureClass });

                string BSM = pParm.XZQDM + "2931";
                IFeatureCursor pFeatureCursor_LS = czcdydFeatureClassAPI.FeatureClass.Update(null, true);
                count = czcdydFeatureClassAPI.FeatureClass.FeatureCount(null);
                Console.WriteLine("正在对城镇村等用地更新进行赋值......");
                int bsmIndexof = czcdydFeatureClassAPI.FeatureClass.FindField("BSM");
                int czclxindex = czcdydFeatureClassAPI.FeatureClass.FindField("CZCLX");
                num = 0;
                IFeature pfeaFeature = pFeatureCursor_LS.NextFeature();
                int czcdmIdx = czcdydFeatureClassAPI.FeatureClass.Fields.FindField("CZCDM");
                while (pfeaFeature != null)
                {
                    string bsmPrefix = pParm.XZQDM + MaxBSM.Substring(6, 4);
                    int MaxNum = Convert.ToInt32(MaxBSM.Substring(10));
                    MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');
                    pfeaFeature.set_Value(bsmIndexof, MaxBSM);
                    pfeaFeature.set_Value(czcdydFeatureClassAPI.FeatureClass.FindField("YSDM"), "2099030100");
                    string czclx = pfeaFeature.Value[czclxindex].ToTrim();
                    string czcmc = string.Empty;
                    DataRow[] drSet = dt.Select(string.Format(" objectid='{0}' ", pfeaFeature.Value[0]));
                    if (drSet != null && drSet.Length > 0)
                    {
                        czcmc = drSet[0]["CZCMC"].ToString();
                    }
                    if (string.IsNullOrWhiteSpace(czcmc) && czcdmIdx != -1 && qsDic != null)
                    {
                        string strCZCDM = pfeaFeature.Value[czcdmIdx].ToTrim();
                        if (czclx == "203" || czclx == "203A" || czclx == "204" || czclx == "205")
                        {
                            if (strCZCDM.Length > 12)
                            {
                                DataDicTionary dic = qsDic.FirstOrDefault(qs => qs.CODE == strCZCDM || qs.CODE.StartsWith(strCZCDM.Substring(0, 12)));
                                if (dic != null)
                                    czcmc = dic.NAME;
                            }
                        }
                        else if (czclx == "202" || czclx == "202A")
                        {
                            if (strCZCDM.Length > 9)
                            {
                                DataDicTionary dic = qsDic.FirstOrDefault(qs => qs.CODE == strCZCDM || qs.CODE.StartsWith(strCZCDM.Substring(0, 9)));
                                if (dic != null)
                                    czcmc = dic.NAME;
                            }
                        }
                        else if (czclx == "201" || czclx == "201A")
                        {
                            if (strCZCDM.Length > 6)
                            {
                                DataDicTionary dic = qsDic.FirstOrDefault(qs => qs.CODE == strCZCDM || qs.CODE.StartsWith(strCZCDM.Substring(0, 6)));
                                if (dic != null)
                                    czcmc = dic.NAME;
                            }
                        }
                    }
                    pfeaFeature.set_Value(czcdydFeatureClassAPI.FeatureClass.FindField("CZCMC"), czcmc);
                    pfeaFeature.set_Value(czcdydFeatureClassAPI.FeatureClass.FindField("GXSJ"), time);
                    pfeaFeature.set_Value(czcdydFeatureClassAPI.FeatureClass.FindField("CZCMJ"), pfeaFeature.ShapeCopy.GetEllipseArea());
                    pFeatureCursor_LS.UpdateFeature(pfeaFeature);
                    maxValue++;
                    pfeaFeature = pFeatureCursor_LS.NextFeature();
                }
                pFeatureCursor_LS.Flush();

                //设置基础城镇村选中
                gPParamClass = new GPParamClass();

                IFeatureWorkspace inWs = GetGdbWorkspace(path);

                IFeatureLayer czcUnionLayer = null;
                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = bgParm.JCCZCLayer;// MapsManager.Instance.MapService.GetFeatureLayerByLayerName("城镇村等用地");
                gPParamClass.SecondFeatureLayer = new FeatureLayerClass() { FeatureClass = czcdydFeatureClassAPI.FeatureClass };
                gPParamClass.OutFeatureClassPath = path + "\\" + "TempCZCGXGC2";
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.GPType = EnumGPType.Union;
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref czcUnionLayer);

                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = czcUnionLayer;
                gPParamClass.OutFeatureClassPath = path + "\\" + "TempCZCGXGC";
                gPParamClass.IsGetOutPutFeature = true;
                gPParamClass.GPType = EnumGPType.MultipartToSinglePath;
                GPHelper.Instance.ExeGPForProces(gPParamClass, ref czcUnionLayer);

                rdbHelper.ExecuteSQL(" drop table TempCZCGXGC ");
                TableToTable(inWs, pOutWork, "TempCZCGXGC");
                string FID_JC_CZCDYD = $"FID_{featureClass.Name}";
                string strSql = $"select objectid,fid_czcdydgx from (select count(1) num,objectid,{FID_JC_CZCDYD},czclx bgqczclx,czclx_1 bghczclx,czcdm bgqczcdm,czcdm_1 bghczcdm,czcmc bgqczcmc,czcmc_1 bghczcmc,FID_CZCDYDGX from TempCZCGXGC  group by {FID_JC_CZCDYD}) where num=1 and bgqczclx=bghczclx and bgqczcdm=bghczcdm and bgqczcmc=bghczcmc";
                DataTable gxgcDT = rdbHelper.ExecuteDatatable("tempgxgc", strSql, true);

                strSql = $"select objectid,fid_czcdydgx from (select count(1) num,objectid,{FID_JC_CZCDYD},czclx bgqczclx,czclx_1 bghczclx,czcdm bgqczcdm,czcdm_1 bghczcdm,czcmc bgqczcmc,czcmc_1 bghczcmc,FID_CZCDYDGX from TempCZCGXGC  group by FID_CZCDYDGX) where num=1 and bgqczclx=bghczclx and bgqczcdm=bghczcdm and bgqczcmc=bghczcmc";
                DataTable gxgcDT2 = rdbHelper.ExecuteDatatable("tempgxgc", strSql, true);
                List<int> AllowDelOIDs = new List<int>();
                if (gxgcDT2 != null)
                {
                    foreach (DataRow row in gxgcDT2.Rows)
                    {
                        AllowDelOIDs.Add(Convert.ToInt32(row["FID_CZCDYDGX"]));
                    }
                }
                if (gxgcDT != null)
                {
                    List<string> SqlList = new List<string>();
                    foreach (DataRow row in gxgcDT.Rows)
                    {
                        int oid = Convert.ToInt32(row["OBJECTID"]);
                        int gxOID = Convert.ToInt32(row["FID_CZCDYDGX"]);
                        if (!AllowDelOIDs.Contains(gxOID))
                            continue;
                        IFeature gx = czcdydFeatureClassAPI.FeatureClass.GetFeature(gxOID);
                        gx.Delete();
                        IFeature gcF = czcUnionLayer.FeatureClass.GetFeature(oid);
                        gcF.Delete();
                        SqlList.Add(string.Format("Delete from TempCZCGXGC where OBJECTID={0}", oid));
                    }
                    rdbHelper.BeginTransaction();
                    try
                    {
                        foreach (var item in SqlList)
                        {
                            rdbHelper.ExecuteSQL(item);
                        }
                        rdbHelper.Commit();
                    }
                    catch (Exception ex)
                    {
                        rdbHelper.Rollback();
                    }
                }

                IFeatureClassAPI czcGXGCAPI = new FeatureClassAPI(bgParm.GXGCCZCLayer.FeatureClass);// .OpenFeatureClass("CZCDYDGXGC");
                (czcGXGCAPI.FeatureClass as ITable).DeleteSearchedRows(null);
                IFeatureCursor cursor = czcUnionLayer.FeatureClass.Search(null, true);
                IFeature f = null;
                int idxBGQBSM = czcUnionLayer.FeatureClass.FindField("BSM");
                int idxBGHBSM = czcUnionLayer.FeatureClass.FindField("BSM_1");
                int idxBGQCZCLX = czcUnionLayer.FeatureClass.FindField("CZCLX");
                int idxBGHCZCLX = czcUnionLayer.FeatureClass.FindField("CZCLX_1");
                int idxBGQCZCDM = czcUnionLayer.FeatureClass.FindField("CZCDM");
                int idxBGHCZCDM = czcUnionLayer.FeatureClass.FindField("CZCDM_1");
                int idxBGQCZCMC = czcUnionLayer.FeatureClass.FindField("CZCMC");
                int idxBGHCZCMC = czcUnionLayer.FeatureClass.FindField("CZCMC_1");
                int idxCZCMJ = czcUnionLayer.FeatureClass.FindField("CZCMJ");


                int t_idxBGQBSM = czcGXGCAPI.FeatureClass.FindField("BGQBSM");
                int t_idxBGHBSM = czcGXGCAPI.FeatureClass.FindField("BGHBSM");
                int t_idxBGQCZCLX = czcGXGCAPI.FeatureClass.FindField("BGQCZCLX");
                int t_idxBGHCZCLX = czcGXGCAPI.FeatureClass.FindField("BGHCZCLX");
                int t_idxBGQCZCDM = czcGXGCAPI.FeatureClass.FindField("BGQCZCDM");
                int t_idxBGHCZCDM = czcGXGCAPI.FeatureClass.FindField("BGHCZCDM");
                int t_idxBGQCZCMC = czcGXGCAPI.FeatureClass.FindField("BGQCZCMC");
                int t_idxBGHCZCMC = czcGXGCAPI.FeatureClass.FindField("BGHCZCMC");
                int t_idxBGMJ = czcGXGCAPI.FeatureClass.FindField("BGMJ");
                int t_idxBGXW = czcGXGCAPI.FeatureClass.FindField("BGXW");
                int t_idxGXSJ = czcGXGCAPI.FeatureClass.FindField("GXSJ");
                //网格大小报错
                if (czcGXGCAPI.FeatureClass is IFeatureClassLoad pFclsLoad2)
                    pFclsLoad2.LoadOnlyMode = true;
                IFeatureCursor insertCur = czcGXGCAPI.FeatureClass.Insert(true);
                IFeatureBuffer buf = null;
                List<PCModel> pcList = new List<PCModel>();
                IFeatureLayer czcgxLayer = bgParm.GXCZCLayer;// MapsManager.Instance.MapService.GetFeatureLayerByName("CZCDYDGX");
                IFeatureLayer jcczcLayer = bgParm.JCCZCLayer;// MapsManager.Instance.MapService.GetFeatureLayerByLayerName("城镇村等用地");
                int idxGXBSM = czcgxLayer.FeatureClass.FindField("BSM");

                strSql = $"select BSM from (select count(1) num,objectid,bsm from TempCZCGXGC  group by {FID_JC_CZCDYD}) where num>1";
                DataTable txbgData = rdbHelper.ExecuteDatatable("tempgxgc", strSql, true);
                count = czcUnionLayer.FeatureClass.FeatureCount(null);
                num = 0;
                while ((f = cursor.NextFeature()) != null)
                {
                    string s_bgqbsm = f.Value[idxBGQBSM].ToTrim();
                    string s_bghbsm = f.Value[idxBGHBSM].ToTrim();
                    string s_bgqczclx = f.Value[idxBGQCZCLX].ToTrim();
                    string s_bghczclx = f.Value[idxBGHCZCLX].ToTrim();
                    string s_bgqczcdm = f.Value[idxBGQCZCDM].ToTrim();
                    string s_bghczcdm = f.Value[idxBGHCZCDM].ToTrim();
                    string s_bgqczcmc = f.Value[idxBGQCZCMC].ToTrim();
                    string s_bghczcmc = f.Value[idxBGHCZCMC].ToTrim();
                    double czcmj = f.Value[idxCZCMJ].ToDouble(2);
                    if ((s_bgqczclx == "203" || s_bgqczclx == "203A") && s_bgqczclx == s_bghczclx && s_bgqczcdm.Substring(0, 12) == s_bghczcdm.Substring(0, 12))
                    {
                        List<IFeature> jcList = FeatureAPI.Identify2(f.ShapeCopy, jcczcLayer);
                        if (jcList.Count == 1 && FeatureAPI.GetEqual(jcList[0].ShapeCopy, f.ShapeCopy))
                        {
                            List<IFeature> gxList = FeatureAPI.Identify2(f.ShapeCopy, czcgxLayer);
                            foreach (var tempGxItem in gxList)
                            {
                                tempGxItem.Shape = FeatureAPI.Difference(tempGxItem.ShapeCopy, f.ShapeCopy);
                                tempGxItem.Store();
                                if (tempGxItem.Shape.IsEmpty)
                                {
                                    tempGxItem.Delete();
                                }
                            }
                            continue;
                        }
                        else
                        {
                        }
                    }
                    string bgxw = string.Empty;
                    if (string.IsNullOrWhiteSpace(s_bghczclx))
                    {
                        bgxw = "0";
                        List<IFeature> gxList = FeatureAPI.Identify2(f.ShapeCopy, dltbgxLayer);
                        if (gxList.Count == 0)
                        {
                            continue;
                        }
                    }
                    else if (string.IsNullOrWhiteSpace(s_bgqczcdm))
                    {
                        bgxw = "3";
                        List<IFeature> gxList = FeatureAPI.Identify2(f.ShapeCopy, dltbgxLayer);
                        if (gxList.Count == 0)
                        {
                            List<IFeature> gxList2 = FeatureAPI.Identify2(f.ShapeCopy, czcgxLayer);
                            foreach (var item in gxList2)
                            {
                                if (FeatureAPI.GetEqual(item.ShapeCopy, f.ShapeCopy))
                                    item.Delete();
                                else
                                {
                                    item.Shape = FeatureAPI.Difference(item.ShapeCopy, f.ShapeCopy);
                                    item.Store();
                                }
                            }
                            continue;
                        }
                    }
                    else
                    {
                        bgxw = "2";
                        if (txbgData.Select(string.Format("BSM='{0}'", s_bgqbsm)).Length == 0)
                        {
                            List<IFeature> gxList = FeatureAPI.Identify2(f.ShapeCopy, czcgxLayer);
                            if (gxList.Count == 1)
                            {
                                if (FeatureAPI.GetEqual(f.ShapeCopy, gxList[0].ShapeCopy))
                                {
                                    bgxw = "1";
                                    s_bghbsm = s_bgqbsm;
                                    gxList[0].Value[idxGXBSM] = s_bghbsm;
                                    gxList[0].Store();
                                }
                            }
                        }
                    }
                    buf = czcGXGCAPI.FeatureClass.CreateFeatureBuffer();
                    buf.Shape = f.ShapeCopy;
                    buf.Value[t_idxBGQCZCLX] = s_bgqczclx;
                    buf.Value[t_idxBGQCZCDM] = s_bgqczcdm;
                    buf.Value[t_idxBGQCZCMC] = s_bgqczcmc;
                    buf.Value[t_idxBGQBSM] = s_bgqbsm;
                    buf.Value[t_idxGXSJ] = time;

                    buf.Value[t_idxBGXW] = bgxw;
                    buf.Value[t_idxBGHCZCLX] = s_bghczclx;
                    buf.Value[t_idxBGHCZCDM] = s_bghczcdm;
                    buf.Value[t_idxBGHCZCMC] = s_bghczcmc;
                    buf.Value[t_idxBGHBSM] = s_bghbsm;

                    double bgmj = f.ShapeCopy.GetEllipseArea().ToDouble(2);
                    if (bgxw == "3")
                    {
                        buf.Value[t_idxBGMJ] = bgmj;
                    }
                    object oid = insertCur.InsertFeature(buf);

                    if (bgxw != "3")
                    {
                        PCModel pc = pcList.FirstOrDefault(e => e.BGQBSM == s_bgqbsm);
                        if (pc == null)
                        {
                            pc = new PCModel();
                            pc.BGQBSM = s_bgqbsm;
                            pc.KZMJ = czcmj;
                            pc.GCData.Add(new GCMJModel() { OID = Convert.ToInt32(oid), MJ = bgmj });
                            pcList.Add(pc);
                        }
                        else
                        {
                            pc.GCData.Add(new GCMJModel() { OID = Convert.ToInt32(oid), MJ = bgmj });
                        }
                    }
                }
                insertCur.Flush();
                if (czcGXGCAPI.FeatureClass is IFeatureClassLoad pFclsLoad3)
                    pFclsLoad3.LoadOnlyMode = false;
                foreach (var item in pcList)
                {
                    item.PC2();
                    foreach (var gcOID in item.GCData)
                    {
                        IFeature gc = czcGXGCAPI.FeatureClass.GetFeature(gcOID.OID);
                        gc.Value[t_idxBGMJ] = gcOID.MJ;
                        gc.Store();
                    }
                }
                DataTable tempGcDt = new DataTable();
                IQueryFilter filt = new QueryFilterClass();
                filt.SubFields = "BGMJ,BGHBSM,BGQBSM,OBJECTID,BGXW";
                filt.WhereClause = "BGXW <> '0'";
                czcGXGCAPI.QueryFeaturesToDataTable(filt, -1, out tempGcDt);

                Dictionary<string, double> bghMJs = new Dictionary<string, double>();
                foreach (DataRow item in tempGcDt.Rows)
                {
                    string bsm = item["BGHBSM"].ToTrim();
                    if (string.IsNullOrWhiteSpace(bsm)) continue;
                    if (bghMJs.ContainsKey(bsm))
                    {
                        bghMJs[bsm] += item["BGMJ"].ToDouble(2);
                    }
                    else
                    {
                        bghMJs.Add(bsm, item["BGMJ"].ToDouble(2));
                    }
                }
                //List<string> upMJSqlList = new List<string>();
                //foreach (var item in bghMJs.Keys)
                //{
                //    upMJSqlList.Add(string.Format("Update CZCDYDGX set CZCMJ={0} where BSM='{1}'", bghMJs[item].ToDouble(2), item));
                //}
                ICursor upCursor = (czcgxLayer.FeatureClass as ITable).Update(null, true);
                IRow upRow = null;
                int idxGXCZCMJ = czcgxLayer.FeatureClass.FindField("CZCMJ");
                while ((upRow = upCursor.NextRow()) != null)
                {
                    string bsm = upRow.Value[idxGXBSM].ToTrim();
                    if (bghMJs.ContainsKey(bsm))
                    {
                        upRow.Value[idxGXCZCMJ] = bghMJs[bsm].ToDouble(2);
                        upCursor.UpdateRow(upRow);
                    }
                }

                IFeatureLayer JC_CZC203Layer_Mem = GeoDBAPI.CreateFeatureLayerInmemeory("JCCZC203", "城镇村203范围", (bgParm.JCCZCLayer.FeatureClass as IGeoDataset).SpatialReference, bgParm.JCCZCLayer.FeatureClass.ShapeType, bgParm.JCCZCLayer.FeatureClass.Fields);
                filter.WhereClause = "CZCLX='203' or CZCLX='203A'";
                InsertDataToMemeoryLayer(tempJCCZCLayer.FeatureClass, JC_CZC203Layer_Mem.FeatureClass, filter);
                cursor = czcgxLayer.FeatureClass.Search(new QueryFilterClass() { WhereClause = " CZCLX='203' or CZCLX='203A'" }, true);
                f = null;
                List<int> feaOIDs = new List<int>();
                //int czclxIdx = czcgxLayer.FeatureClass.FindField("CZCLX");
                int jcczclxIdx = JC_CZC203Layer_Mem.FeatureClass.FindField("CZCLX");
                while ((f = cursor.NextFeature()) != null)
                {
                    List<IFeature> jc203Features = FeatureAPI.Identify(f.ShapeCopy, JC_CZC203Layer_Mem);
                    if (jc203Features != null)
                    {
                        foreach (var jcF in jc203Features)
                        {
                            if (FeatureAPI.GetEqual(jcF.ShapeCopy, f.ShapeCopy)) break;
                            if (!FeatureAPI.IsInterSect(jcF.ShapeCopy, f.ShapeCopy)) continue;

                            IGeometry InterGeo = FeatureAPI.InterSect(jcF.ShapeCopy, f.ShapeCopy);
                            IGeometry DiffGeo = FeatureAPI.Difference(f.ShapeCopy, jcF.ShapeCopy);
                            if (DiffGeo.IsEmpty)
                            {
                                break;
                            }
                            if (!feaOIDs.Contains(f.OID))
                                feaOIDs.Add(f.OID);
                        }
                    }
                }
                idxGXBSM = czcgxLayer.FeatureClass.FindField("BSM");
                int idxGXCZCLX = czcgxLayer.FeatureClass.FindField("CZCLX");
                int idxGXCZCDM = czcgxLayer.FeatureClass.FindField("CZCDM");
                int idxGXCZCMC = czcgxLayer.FeatureClass.FindField("CZCMC");
                idxGXCZCMJ = czcgxLayer.FeatureClass.FindField("CZCMJ");
                int idxGXGXSJ = czcgxLayer.FeatureClass.FindField("GXSJ");
                IFeatureLayer czcgxgcLayer = bgParm.GXGCCZCLayer;// MapsManager.Instance.MapService.GetFeatureLayerByName("CZCDYDGXGC");
                int idxGXGCBGMJ = czcgxgcLayer.FeatureClass.FindField("BGMJ");
                int idxGXGCBGHBSM = czcgxgcLayer.FeatureClass.FindField("BGHBSM");
                insertCur = czcgxLayer.FeatureClass.Insert(true);
                foreach (int oid in feaOIDs)
                {
                    f = czcgxLayer.FeatureClass.GetFeature(oid);
                    string bsm = f.Value[idxGXBSM].ToTrim();
                    string czclx = f.Value[idxGXCZCLX].ToTrim();
                    List<IFeature> jc203Features = FeatureAPI.Identify(f.ShapeCopy, JC_CZC203Layer_Mem);
                    if (jc203Features != null)
                    {
                        IGeometry jc203 = null;
                        foreach (var jcF in jc203Features)
                        {
                            bool IsEquql = FeatureAPI.GetEqual(jcF.ShapeCopy, f.ShapeCopy);
                            string jcczclx = jcF.Value[jcczclxIdx].ToTrim();
                            if (IsEquql && jcczclx == czclx)
                            {
                                f.Delete();
                                break;
                            }
                            if (!FeatureAPI.IsInterSect(jcF.ShapeCopy, f.ShapeCopy)) continue;
                            if (FeatureAPI.IsContains(jcF.ShapeCopy, f.ShapeCopy))
                            {
                                break;
                            }
                            if (jc203 == null)
                                jc203 = jcF.ShapeCopy;
                            else
                                jc203 = FeatureAPI.Union(jc203, jcF.ShapeCopy);
                        }
                        IGeometry InterGeo = FeatureAPI.InterSect(jc203, f.ShapeCopy);
                        IGeometry DiffGeo = FeatureAPI.Difference(f.ShapeCopy, jc203);

                        if (DiffGeo.IsEmpty)
                        {
                            continue;
                        }
                        List<IGeometry> Rings = FeatureAPI.DissolveGeometryByRing(InterGeo);
                        List<IGeometry> Rings2 = FeatureAPI.DissolveGeometryByRing(DiffGeo);
                        if (Rings == null) Rings = new List<IGeometry>();
                        if (Rings2 == null) Rings2 = new List<IGeometry>();
                        if (Rings2.Count == 0)
                        {
                            f.Delete();
                        }
                        else
                        {
                            IGeometry tempGeo = f.ShapeCopy;
                            if (Rings2.Count > 0)
                                tempGeo = Rings2[0];
                            ITopologicalOperator topo = tempGeo as ITopologicalOperator;
                            IGeometry tempGeo2 = topo.Buffer(-0.00015);
                            List<IFeature> gcList = FeatureAPI.Identify(tempGeo2, czcgxgcLayer);
                            Marshal.ReleaseComObject(tempGeo2);
                            double czcmj = 0;
                            foreach (IFeature gcF in gcList)
                            {
                                if (!FeatureAPI.IsInterSect(tempGeo, gcF.ShapeCopy)) continue;
                                czcmj += gcF.Value[idxGXGCBGMJ].ToDouble(2);
                                gcF.Store();
                            }
                            f.Value[idxGXCZCMJ] = czcmj.ToDouble(2);

                            f.Shape = tempGeo;
                            f.Store();
                            if (Rings2.Count > 0)
                                Rings2.RemoveAt(0);
                        }
                        if (Rings2.Count > 0)
                            Rings.AddRange(Rings2);
                        foreach (var GeoRing in Rings)
                        {

                            string bsmPrefix = pParm.XZQDM + MaxBSM.Substring(6, 4);
                            int MaxNum = Convert.ToInt32(MaxBSM.Substring(10));
                            MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');

                            IFeatureBuffer buff = czcgxLayer.FeatureClass.CreateFeatureBuffer();
                            buff.Value[idxGXBSM] = MaxBSM;
                            buff.Value[idxGXCZCLX] = f.Value[idxGXCZCLX];
                            buff.Value[idxGXCZCDM] = f.Value[idxGXCZCDM];
                            buff.Value[idxGXCZCMC] = f.Value[idxGXCZCMC];
                            buff.Value[idxGXGXSJ] = time;
                            buff.Shape = GeoRing;
                            List<IFeature> gcList = FeatureAPI.Identify2(GeoRing, czcgxgcLayer);
                            double czcmj = 0;
                            foreach (IFeature gcF in gcList)
                            {
                                if (!FeatureAPI.IsInterSect(GeoRing, gcF.ShapeCopy)) continue;
                                czcmj += gcF.Value[idxGXGCBGMJ].ToDouble(2);
                                gcF.Value[idxGXGCBGHBSM] = MaxBSM;
                                gcF.Store();
                            }
                            buff.Value[idxGXCZCMJ] = czcmj.ToDouble(2);
                            object addOid = insertCur.InsertFeature(buff);
                        }
                    }
                    insertCur.Flush();
                    Marshal.ReleaseComObject(f);
                }
                cursor = czcgxLayer.FeatureClass.Search(null, true);
                f = null;
                List<int> oids = new List<int>();
                while ((f = cursor.NextFeature()) != null)
                {
                    List<IGeometry> Rings = FeatureAPI.DissolveGeometryByRing(f.ShapeCopy);
                    if (Rings == null) continue;
                    if (Rings.Count == 1) continue;
                    oids.Add(f.OID);
                }
                foreach (int oid in oids)
                {
                    IFeature gxFeature = czcgxLayer.FeatureClass.GetFeature(oid);

                    List<IGeometry> Rings = FeatureAPI.DissolveGeometryByRing(gxFeature.ShapeCopy);
                    if (Rings.Count > 1)
                    {
                        gxFeature.Shape = Rings[0];
                        {
                            List<IFeature> gcList = FeatureAPI.Identify2(Rings[0], czcgxgcLayer);
                            double czcmj = 0;
                            foreach (IFeature gcF in gcList)
                            {
                                czcmj += gcF.Value[idxGXGCBGMJ].ToDouble(2);
                                gcF.Store();
                            }
                            gxFeature.Value[idxGXCZCMJ] = czcmj.ToDouble(2);
                        }
                        gxFeature.Store();
                        for (int i = 1; i < Rings.Count; i++)
                        {
                            if (Rings[i].IsEmpty) continue;
                            string bsmPrefix = pParm.XZQDM + MaxBSM.Substring(6, 4);
                            int MaxNum = Convert.ToInt32(MaxBSM.Substring(10));
                            MaxBSM = bsmPrefix + (MaxNum + 1).ToString().PadLeft(8, '0');

                            IFeatureBuffer buff = czcgxLayer.FeatureClass.CreateFeatureBuffer();
                            buff.Value[idxGXBSM] = MaxBSM;
                            buff.Value[idxGXCZCLX] = gxFeature.Value[idxGXCZCLX];
                            buff.Value[idxGXCZCDM] = gxFeature.Value[idxGXCZCDM];
                            buff.Value[idxGXCZCMC] = gxFeature.Value[idxGXCZCMC];
                            buff.Value[idxGXGXSJ] = time;
                            buff.Shape = Rings[i];
                            List<IFeature> gcList = FeatureAPI.Identify2(Rings[i], czcgxgcLayer);
                            double czcmj = 0;
                            foreach (IFeature gcF in gcList)
                            {
                                czcmj += gcF.Value[idxGXGCBGMJ].ToDouble(2);
                                gcF.Value[idxGXGCBGHBSM] = MaxBSM;
                                gcF.Store();
                            }
                            buff.Value[idxGXCZCMJ] = czcmj.ToDouble(2);
                            insertCur.InsertFeature(buff);
                        }
                    }
                }
                insertCur.Flush();
                if (false)
                {
                    (czcgxLayer.FeatureClass as FeatureClass).Workspace.ExecuteSQL("Delete from CZCDYDGX where CZCMJ=0");
                    (czcgxgcLayer.FeatureClass as FeatureClass).Workspace.ExecuteSQL("Delete from CZCDYDGXGC where BGMJ=0");
                }
                rdbHelper.ExecuteSQL(" drop table CZCDYDGXGC ");
                TableToTable(TempfeatureWorkspace, pOutWork, "CZCDYDGXGC");
                rdbHelper.ExecuteSQL(" drop table CZCDYDGX ");
                TableToTable(TempfeatureWorkspace, pOutWork, "CZCDYDGX");
                string sql = "select a.bsm aoid,b.objectid boid from czcdydgx a left join czcdydgxgc b on a.bsm=b.bghbsm where boid is null";
                DataTable gxDT = rdbHelper.ExecuteDatatable("tempgx", sql, true);
                if (gxDT != null && gxDT.Rows.Count > 0)
                {
                    foreach (DataRow dr in gxDT.Rows)
                    {
                        (czcgxLayer.FeatureClass as FeatureClass).Workspace.ExecuteSQL(string.Format("Delete from CZCDYDGX where bsm='{0}'", dr["AOID"]));
                    }
                }
                rdbHelper.ExecuteSQL(" drop table CZCDYDGXGC ");
                TableToTable(TempfeatureWorkspace, pOutWork, "CZCDYDGXGC");
                rdbHelper.ExecuteSQL(" drop table CZCDYDGX ");
                TableToTable(TempfeatureWorkspace, pOutWork, "CZCDYDGX");
                sql = "select bgqbsm from czcdydgxgc where bgqbsm in (select bgqbsm from czcdydgxgc where bghbsm in (select bghbsm from czcdydgxgc group by bghbsm HAVING count(1)=1) and bgqbsm!='')group by bgqbsm HAVING count(1)=1";
                gxgcDT = rdbHelper.ExecuteDatatable("tempgxgc", sql, true);
                string PrjCode = pParm.XZQDM;
                sql = "select * from CZCDYDGXGC";
                DataTable gxgcDTAll = rdbHelper.ExecuteDatatable("CZCDYDGXGC", sql, true);
                if (gxgcDT != null && gxgcDT.Rows.Count > 0)
                {
                    foreach (DataRow dr in gxgcDT.Rows)
                    {
                        DataRow[] drs = gxgcDTAll.Select(string.Format("BGQBSM='{0}'", dr["BGQBSM"]));
                        if (drs != null && drs.Length == 1)
                        {
                            if (drs[0]["BGQCZCLX"].ToTrim() == drs[0]["BGHCZCLX"].ToTrim() &&
                                drs[0]["BGQCZCDM"].ToTrim() == drs[0]["BGHCZCDM"].ToTrim() &&
                                drs[0]["BGQCZCMC"].ToTrim() == drs[0]["BGHCZCMC"].ToTrim())
                            {
                                (czcgxLayer.FeatureClass as FeatureClass).Workspace.ExecuteSQL(string.Format("Delete from CZCDYDGX where bsm='{0}'", drs[0]["BGHBSM"]));
                                (czcgxgcLayer.FeatureClass as FeatureClass).Workspace.ExecuteSQL(string.Format("Delete from CZCDYDGXGC where BGQBSM='{0}'", drs[0]["BGQBSM"]));
                            }
                            else
                            {
                                string bsm = dr["BGQBSM"].ToTrim();
                                if (!dr["BGQBSM"].ToTrim().StartsWith(PrjCode))
                                    bsm = bsm.Replace(bsm.Substring(0, 6), PrjCode);
                                (czcgxLayer.FeatureClass as FeatureClass).Workspace.ExecuteSQL(string.Format("Update CZCDYDGX set BSM='{0}' where bsm='{1}'", bsm, drs[0]["BGHBSM"]));

                                (czcgxgcLayer.FeatureClass as FeatureClass).Workspace.ExecuteSQL(string.Format("Update CZCDYDGXGC set BGXW='1',BGHBSM='{0}' where BGQBSM='{1}' and BGHBSM='{2}'", bsm, dr["BGQBSM"], drs[0]["BGHBSM"]));
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogAPI.Debug("提取城镇村等用地数据异常：" + ex.Message);
                throw ex;
            }
            finally
            {
                if (LSczcdydFeatureclassAPI != null)
                    LSczcdydFeatureclassAPI.CloseFeatureClass();
                if (CZCDLTBFeatureClass != null)
                    CZCDLTBFeatureClass.CloseFeatureClass();
                //if (pFeatureClass_4 != null)
                //    pFeatureClass_4.CloseFeatureClass();
                if (pFeatureCursor != null)
                    Marshal.ReleaseComObject(pFeatureCursor);
                if (pInsertCursor != null)
                    Marshal.ReleaseComObject(pInsertCursor);
                if (czcdydFeatureClassAPI != null)
                    czcdydFeatureClassAPI.CloseFeatureClass();
                if (dltbFeatureClassAPI != null)
                    dltbFeatureClassAPI.CloseFeatureClass();
                if (Schemeworkspace != null)
                    Schemeworkspace.CloseWorkspace();
                if (Tempworkspace != null)
                    Tempworkspace.CloseWorkspace();
                if (pOutWorkFactory != null)
                    Marshal.ReleaseComObject(pOutWorkFactory);
                if (outputWorkspaceFactory != null)
                    Marshal.ReleaseComObject(outputWorkspaceFactory);
            }
        }
        private void InsertDataToMemeoryLayer(IFeatureClass pSource, IFeatureClass pTarget, IQueryFilter pFilter = null)
        {
            try
            {
                if (pSource == null || pTarget == null) return;
                IFeatureClassAPI fcAPI = new FeatureClassAPI(pSource);
                if (pTarget != null)
                    fcAPI.FcToFc(pTarget, pFilter, false);
            }
            catch (Exception ex)
            {
                LogAPI.Debug($"获取城镇村范围数据失败：{ex.Message}");
                LogAPI.Debug(ex);
            }
        }
        private string GetMaxBSM(List<IFeatureClass> fcList)
        {
            int xh = 0;
            string MaxBSM = "";
            string leftStr = string.Empty;
            foreach (var fc in fcList)
            {
                string BSM = string.Empty;
                int BSMIndex = fc.FindField("BSM");
                if (BSMIndex == -1) return BSM;

                ITable table = (ITable)fc;
                // 创建一个ITableSort接口对象
                ITableSort tableSort = new TableSortClass();
                tableSort.Table = table;
                tableSort.Fields = "BSM";
                tableSort.set_Ascending("BSM", false);
                tableSort.Sort(null);
                ICursor cursor = tableSort.Rows;
                IRow row = cursor.NextRow();
                if (row != null)
                {
                    int maxBSM = 0;
                    int currBSM = 0;
                    string BSMStr = row.Value[BSMIndex].ToString();
                    if (BSMStr.Length != 18) return BSM;
                    string subBSMStr = BSMStr.Substring(9);
                    try
                    {
                        currBSM = Convert.ToInt32(subBSMStr);
                    }
                    catch (Exception)
                    {
                        return BSM;
                    }
                    if (currBSM > maxBSM) maxBSM = currBSM;

                    if (BSMStr.Length != 18) return BSM;
                    string maxStr = maxBSM.ToString();
                    int zeroNum = 9 - maxStr.Length;
                    for (int i = 0; i < zeroNum; i++)
                    {
                        maxStr = 0 + maxStr;
                    }
                    BSM = BSMStr.Substring(0, 9) + maxStr;
                }
                if (BSM.Length != 18)
                    continue;
                int xh2 = Convert.ToInt32(BSM.Substring(10));
                leftStr = BSM.Substring(0, 10);
                if (xh < xh2)
                {
                    xh = xh2;
                    MaxBSM = BSM;
                }
            }
            return MaxBSM;

        }
        public static void DelectDir(string srcPath)
        {
            try
            {
                DirectoryInfo dir = new DirectoryInfo(srcPath);
                FileSystemInfo[] fileinfo = dir.GetFileSystemInfos();  //返回目录中所有文件和子目录
                foreach (FileSystemInfo i in fileinfo)
                {
                    if (i is DirectoryInfo)            //判断是否文件夹
                    {
                        DirectoryInfo subdir = new DirectoryInfo(i.FullName);
                        subdir.Delete(true);          //删除子目录和文件
                    }
                    else
                    {
                        File.Delete(i.FullName);      //删除指定文件
                    }
                }
            }
            catch (Exception ex)
            {
                LogAPI.Debug(ex + ":删除错误不处理");
            }
        }

        private string GetTempPath()
        {
            string path = string.Empty;
            try
            {
                string gdbFolder = Directory.GetCurrentDirectory() + "\\Temp\\城镇村用地变更临时数据";
                if (!System.IO.Directory.Exists(gdbFolder))
                {
                    System.IO.Directory.CreateDirectory(gdbFolder);
                }
                try
                {
                    DelectDir(gdbFolder);//能删除就删除   删除报错不处理
                }
                catch
                { }
                string mdbFileName = Guid.NewGuid().ToString() + ".gdb";
                path = System.IO.Path.Combine(gdbFolder, mdbFileName);
                var TempGDBPath = SysAppPath.GetTemplatePath() + "TempGDB.gdb";//模板
                if (Directory.Exists(path))
                {
                    Directory.Delete(path, true);
                }
                Directory.CreateDirectory(path);
                CopyDirectInfo(TempGDBPath, path);
                return path;
            }
            catch (Exception ex)
            {
                LogAPI.Debug("提取城镇村等用地错误:" + ex.Message.ToString());
                return path;
            }
        }
        private void CopyDirectInfo(string sourceDir, string toDir)
        {
            if (!Directory.Exists(sourceDir))
            {
                throw new ApplicationException("未找到文件：" + sourceDir);
            }
            if (!Directory.Exists(toDir))
            {
                Directory.CreateDirectory(toDir);
            }
            DirectoryInfo directInfo = new DirectoryInfo(sourceDir);
            FileInfo[] filesInfos = directInfo.GetFiles();
            foreach (FileInfo fileinfo in filesInfos)
            {
                string fileName = fileinfo.Name;
                File.Copy(fileinfo.FullName, toDir + @"/" + fileName, true);
            }
        }

        /// <summary>
        /// 获取全国区县代码字典
        /// </summary>
        /// <returns></returns>
        public static List<DataDicTionary> GetXZQDic()
        {
            List<DataDicTionary> result = new List<DataDicTionary>();
            IRDBHelper rdbHelper = null;
            try
            {
                string systemPath = SysAppPath.GetDataBasePath() + "System.mdb";
                if (System.IO.File.Exists(systemPath))
                {
                    string connStr = SysConfigsOprator.GetDBConnectionByName("MDBOledbConnection");
                    connStr = string.Format(connStr, systemPath);
                    rdbHelper = RDBFactory.CreateDbHelper(connStr, DatabaseType.MSAccess);
                    string strSQL = "select OBJECTID AS ID, XZQ AS CODE,XZQMC AS NAME from XZQ";
                    DataTable dt = rdbHelper.ExecuteDatatable("Dic", strSQL, true);
                    if (dt != null)
                    {
                        result = TBToList.ToList<DataDicTionary>(dt);
                        foreach (var item in result)
                        {
                            item.DisplayName = item.CODE + "-" + item.NAME;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogAPI.Debug(ex);
            }
            finally
            {
                if (rdbHelper != null)
                {
                    rdbHelper.DisConnect();
                }
            }
            return result;
        }

        public IFeatureWorkspace GetGdbWorkspace(string pPathName)
        {
            try
            {
                IWorkspaceFactory factoryGdb = new FileGDBWorkspaceFactoryClass();
                IWorkspace worckspace = factoryGdb.OpenFromFile(pPathName, 0);
                return worckspace as IFeatureWorkspace;
            }
            catch (Exception ex)
            {
                LogAPI.Debug(ex);
                return null;
            }
        }

        public bool TableToTable(IFeatureWorkspace pInWork, IWorkspace pOutWork, string tableName, IQueryFilter queryFilter = null)
        {
            try
            {
                if (pInWork == null || pOutWork == null || string.IsNullOrEmpty(tableName)) return false;
                IWorkspace2 workspace2 = pInWork as IWorkspace2;
                if (workspace2 != null)
                {
                    if (!workspace2.get_NameExists(esriDatasetType.esriDTFeatureClass, tableName))
                    {
                        return false;
                    }
                }
                ITable pInTable = pInWork.OpenTable(tableName);
                if (pInTable == null) return false;

                IDataset pIndataset = (IDataset)pInTable;
                IDatasetName pInDatasetName = (IDatasetName)pIndataset.FullName;

                IEnumDataset enumDataset = pOutWork.get_Datasets(esriDatasetType.esriDTTable);
                IDataset dataset;
                enumDataset.Reset();
                while ((dataset = enumDataset.Next()) != null)
                {
                    string[] names = dataset.Name.Split('.');
                    if (string.Equals(names[names.Length - 1], tableName, StringComparison.CurrentCultureIgnoreCase))
                    {
                        dataset.Delete();
                        break;
                    }
                }

                IDataset pOutDataset = (IDataset)pOutWork;
                IDatasetName pOutDatasetName = new TableNameClass();
                pOutDatasetName.WorkspaceName = (IWorkspaceName)pOutDataset.FullName;
                pOutDatasetName.Name = tableName;


                //Validate the field names because you are converting between different workspace types.
                IFieldChecker fieldChecker = new FieldCheckerClass();
                IFields targetFeatureClassFields = pInTable.Fields;
                IFields sourceFeatureClassFields = pInTable.Fields;
                IEnumFieldError enumFieldError;


                // Most importantly set the input and validate workspaces!
                fieldChecker.InputWorkspace = pInWork as IWorkspace;
                fieldChecker.ValidateWorkspace = pOutWork;
                fieldChecker.Validate(sourceFeatureClassFields, out enumFieldError, out targetFeatureClassFields);

                IFeatureDataConverter one2another = new FeatureDataConverterClass();
                try
                {
                    one2another.ConvertTable(pInDatasetName, queryFilter, pOutDatasetName, targetFeatureClassFields, "", 1000, 0);
                }
                finally
                {
                    Marshal.ReleaseComObject(one2another);
                }
                return true;
            }
            catch (Exception ex)
            {
                LogAPI.Debug(ex);
                throw ex;
            }
        }

        public class PCModel
        {
            public string BGQBSM { get; set; }
            public string BGHBSM { get; set; }
            public double BGHMJ { get; set; }
            public double KZMJ { get; set; }
            //public Dictionary<int, double> GCData { get; set; }
            public List<GCMJModel> GCData { get; set; }
            public PCModel()
            {
                GCData = new List<GCMJModel>();
            }
            public void PC()
            {
                //IOrderedEnumerable<KeyValuePair<int, double>> GCData2 = GCData.OrderByDescending(e => e.Value);
                //GCData = new Dictionary<int, double>();
                //foreach (var item in GCData2)
                //{
                //    GCData.Add(item.Key, item.Value);
                //}
                GCData = GCData.OrderByDescending(o => o.MJ).ToList();
                double zmj = GCData.Sum(s => s.MJ);
                double mjc = Math.Round(zmj - KZMJ, 2);
                if (Math.Round(mjc, 2) == 0)
                {
                    return;
                }
                int num = 0;
                //平差
                while (Math.Round(mjc, 2) != 0 && num < 10)
                {
                    num++;
                    int tpsm = (int)(Math.Abs(Math.Round(mjc, 2)) / 0.01);
                    int e = tpsm / GCData.Count;
                    int f = tpsm % GCData.Count;
                    if (f != 0)
                    {
                        double tpmj = (e + 1) * 0.01;
                        for (int j = 0; j < f; j++)
                        {
                            if (mjc < 0)
                                GCData[j].MJ = GCData[j].MJ + tpmj;
                            else if (GCData[j].MJ > 0.01)
                                GCData[j].MJ = GCData[j].MJ - tpmj;
                        }
                    }
                    if (e != 0)
                    {
                        double tpmj = e * 0.01;
                        for (int j = f; j < GCData.Count; j++)
                        {
                            if (mjc < 0)
                                GCData[j].MJ = GCData[j].MJ + tpmj;
                            else if (GCData[j].MJ > 0.01)
                                GCData[j].MJ = GCData[j].MJ - tpmj;
                        }
                    }
                    zmj = GCData.Sum(s => s.MJ);
                    mjc = Math.Round(zmj - KZMJ, 2);
                    //mjc = Math.Round(shpList.Sum(s => s.MJ), 2) - pKZMJ;
                }
            }
            public void PC2()
            {
                //IOrderedEnumerable<KeyValuePair<int, double>> GCData2 = GCData.OrderByDescending(e => e.Value);
                //GCData = new Dictionary<int, double>();
                //foreach (var item in GCData2)
                //{
                //    GCData.Add(item.Key, item.Value);
                //}
                GCData = GCData.OrderByDescending(o => o.MJ).ToList();
                double zmj = GCData.Sum(s => s.MJ);
                double mjc = Math.Round(zmj - KZMJ, 2);
                if (Math.Round(mjc, 2) == 0 || (zmj == 0 && mjc < 0))
                {
                    return;
                }
                int num = 0;
                while (Math.Round(mjc, 2) != 0 && num < 10)
                {
                    foreach (var item in GCData)
                    {
                        if (Math.Round(mjc, 2) == 0) break;
                        if (mjc < 0)
                        {
                            if (item.MJ <= 0.01) continue;
                            item.MJ = Math.Round(item.MJ + 0.01, 2);
                            zmj = GCData.Sum(s => s.MJ);
                            mjc = Math.Round(zmj - KZMJ, 2);
                        }
                        else
                        {
                            if (item.MJ <= 0.01) continue;
                            item.MJ = Math.Round(item.MJ - 0.01, 2);
                            zmj = GCData.Sum(s => s.MJ);
                            mjc = Math.Round(zmj - KZMJ, 2);
                        }
                    }
                }
                ////平差
                //while (Math.Round(mjc, 2) != 0 && num < 10)
                //{
                //    num++;
                //    int tpsm = (int)(Math.Abs(Math.Round(mjc, 2)) / (double)0.01);
                //    int e = tpsm / GCData.Count;
                //    int f = tpsm % GCData.Count;
                //    if (f != 0)
                //    {
                //        double tpmj = (e + 1) * 0.01;
                //        for (int j = 0; j < f; j++)
                //        {
                //            if (mjc < 0)
                //                GCData[j].MJ = GCData[j].MJ + tpmj;
                //            else if (GCData[j].MJ > 0.01)
                //                GCData[j].MJ = GCData[j].MJ - tpmj;
                //        }
                //    }
                //    if (e != 0)
                //    {
                //        double tpmj = e * 0.01;
                //        for (int j = f; j < GCData.Count; j++)
                //        {
                //            if (mjc < 0)
                //                GCData[j].MJ = GCData[j].MJ + tpmj;
                //            else if (GCData[j].MJ > 0.01)
                //                GCData[j].MJ = GCData[j].MJ - tpmj;
                //        }
                //    }
                //    zmj = GCData.Sum(s => s.MJ);
                //    mjc = Math.Round(zmj - KZMJ, 2);
                //    //mjc = Math.Round(shpList.Sum(s => s.MJ), 2) - pKZMJ;
                //}
            }
        }

        public class GCMJModel
        {
            public int OID { get; set; }
            public double MJ { get; set; }
        }
        public class CZC_Param
        {
            public IFeatureLayer GXCZCLayer { get; set; }
            public IFeatureLayer GXGCCZCLayer { get; set; }
            public IFeatureLayer GXTBLayer { get; set; }
            public IFeatureLayer JCCZCLayer { get; set; }
            public IFeatureLayer JCTBLayer { get; set; }
            public IFeatureLayer BGTBLayer { get; set; }

        }
    }
}