using ESRI.ArcGIS.Carto;
using ESRI.ArcGIS.Controls;
using ESRI.ArcGIS.DataSourcesGDB;
using ESRI.ArcGIS.Geodatabase;
using ESRI.ArcGIS.Geometry;
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.Maps;
using KGIS.Framework.Platform;
using KGIS.Framework.Platform.Helper;
using KGIS.Framework.Utils;
using KGIS.Framework.Utils.ExtensionMethod;
using KGIS.Framework.Utils.Helper;
using KGIS.Framework.Utils.Utility;
using Kingo.PluginServiceInterface;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;

namespace Kingo.Plugin.DataCheck.Helper
{
    public class CZCDYDHelper
    {
        private EngineEditorClass m_EngineEditor;
        public void ExtractExe(IFeatureClass jc_Fc, bool IsDelMinMJ)
        {
            IFeatureLayer jc_czcLayer = null;
            IFeatureLayer dltbgxLayer = null;
            IFeatureLayer dltbhrLayer = null;
            IFeatureLayer jcdltbLayer = null;
            IFeatureLayer dltbTempNMKLayer = null;
            IWorkspaceAPI Tempworkspace = null;
            IWorkspaceAPI Schemeworkspace = null;
            IWorkspaceAPI ProjGDBwkspace = 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
            {
                ProjectInfo projectInfo = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo);
                if (m_EngineEditor == null)
                {
                    m_EngineEditor = new EngineEditorClass();
                }
                if (m_EngineEditor.EditState != esriEngineEditState.esriEngineStateNotEditing)
                {
                    MessageHelper.ShowTips("请先停止編輯！");
                    return;
                }
                var QHDM = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).CODE;
                if (string.IsNullOrWhiteSpace(QHDM))
                {
                    MessageHelper.Show("县行政区划代码不能为空，请在工程属性界面中填写6位县区划代码！");
                    return;
                }
                List<DataDicTionary> qsDic = Platform.Instance.DicHelper.GetNoGroupDic(DicTypeEnum.QSDM);
                if (qsDic == null)
                {
                    MessageHelper.ShowError("请到字典处生成权属单位代码表，否则不予赋值...");
                    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 临时数据
                ProgressHelper.ShowProcessBar("正在提取城镇村等用地数据......");
                TempfilePath = GetTempPath();//临时数据存放路径
                if (string.IsNullOrEmpty(TempfilePath))
                {
                    MessageHelper.ShowError("未获取到城镇村等用地数据模板...");
                    return;
                }

                #region 地类图斑
                IFeatureClass bgtbFc = MapsManager.Instance.MapService.GetFeatureClassByName("DLTBBG");
                dltbgxLayer = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBGX");
                dltbhrLayer = MapsManager.Instance.MapService.GetFeatureLayerByName("DLTBHR");
                jcdltbLayer = GetLayerFromPath(projectInfo.ProjDir + "\\PrjDB.gdb", "JC_DLTB");//MapsManager.Instance.MapService.GetFeatureLayerByName("JC_DLTB");
                jc_czcLayer = GetLayerFromPath(projectInfo.ProjDir + "\\PrjDB.gdb", "JC_CZCDYD"); //MapsManager.Instance.MapService.GetFeatureLayerByName("JC_CZCDYD");
                if (jc_czcLayer.FeatureClass.FeatureCount(null) == 0)
                {
                    MessageHelper.Show("基础城镇村等用地图层未找到数据，请确认基础城镇村数据是否导入！");
                    return;
                }

                IFeatureLayer tempJCCZCLayer = null;
                //设置基础地类图斑选中
                GPParamClass gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = jc_czcLayer;
                gPParamClass.SecondFeatureClass = dltbgxLayer.FeatureClass;
                //gPParamClass.Tolerance = "-0.0001655555";
                GeoprocessorHelper.SelectLayerByLocationAnalysis(gPParamClass, "INTERSECT", ref tempJCCZCLayer);

                //选中的基础地类图斑导出至临时gdb
                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = jc_czcLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath;
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.FeatureClassToFeatureClass(gPParamClass, "JC_CZCDYD", ref tempJCCZCLayer);
                try
                {
                    ESRI.ArcGIS.Carto.IFeatureSelection selection = jc_czcLayer as IFeatureSelection;
                    selection.Clear();
                }
                catch (Exception ex)
                {
                    LogAPI.Debug(ex.Message);
                }

                IFeatureLayer TempJCDLTB = GeoDBAPI.CreateFeatureLayerInmemeory("CZC203", "城镇村203范围", (jcdltbLayer.FeatureClass as IGeoDataset).SpatialReference, jcdltbLayer.FeatureClass.ShapeType, jcdltbLayer.FeatureClass.Fields);

                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = jcdltbLayer;
                gPParamClass.SecondFeatureClass = tempJCCZCLayer.FeatureClass;
                gPParamClass.OutFeatureClassPath = TempfilePath + "\\" + "TempJCDLTB20X";
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.IntersectAnalysis(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'");


                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.FirstFeatureClass = TempJCDLTB.FeatureClass;
                gPParamClass.SecondFeatureClass = msTBLayer.FeatureClass;
                gPParamClass.OutFeatureClassPath = TempfilePath + "\\" + "TempDLTBNM";
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.EraseAnalysis(gPParamClass, ref pjbntFeatureLayer);

                IFeatureLayer TempDLTB_MToS = null;
                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureClass = pjbntFeatureLayer.FeatureClass;
                gPParamClass.OutFeatureClassPath = TempfilePath + "\\" + "TempDLTBNM_MToS";
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.MultipartToSinglePath(gPParamClass, ref TempDLTB_MToS);

                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = TempDLTB_MToS;
                gPParamClass.SecondFeatureLayer = dltbgxLayer;
                gPParamClass.OutFeatureClassPath = TempfilePath + "\\" + "DLTBGXGC";
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.EraseAnalysis(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 = System.IO.Path.GetDirectoryName((MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).GetProjDBPath()) + @"\BGTJ.sqlite";
                IRDBHelper rdbHelper = RDBFactory.CreateDbHelper("Data Source=" + dbPath, DatabaseType.SQLite);
                DataTable bhxxbDt = new DataTable();
                Dictionary<string, DataRow> bhxxDic = new Dictionary<string, DataRow>();
                List<string> hcbghbsmList = new List<string>();
                Dictionary<string, DataRow> zlbgList = new Dictionary<string, DataRow>();
                if (rdbHelper.TableIsExist("BHXXB"))
                {
                    bhxxbDt = rdbHelper.ExecuteDatatable("BHXXB", "select * from BHXXB", true);
                    if (bhxxbDt != null)
                    {
                        foreach (DataRow row in bhxxbDt.Rows)
                        {
                            if (row["BZ"].ToTrim() == "ZLBG" && row["BGXW"].ToTrim() == "1")
                            {
                                string bgqbsm = row["BGQTBBSM"].ToTrim();
                                if (!zlbgList.ContainsKey(bgqbsm))
                                    zlbgList.Add(bgqbsm, row);
                                continue;
                            }
                            string bghBSM = row["BGHTBBSM"].ToTrim();
                            if (row["BGXW"].ToTrim() == "1")
                            {
                                bghBSM = row["BGQTBBSM"].ToTrim();
                            }
                            if (bhxxDic.ContainsKey(bghBSM))
                                continue;
                            bhxxDic.Add(bghBSM, row);
                            string xzqtzlx = row["XZQTZLX"].ToTrim();

                            if (xzqtzlx == "2" && !string.IsNullOrWhiteSpace(bghBSM))
                            {
                                hcbghbsmList.Add(bghBSM);
                            }
                        }
                    }
                }

                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 (bsm == "350825211000164977")
                    {
                    }
                    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 = 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)
                {
                    ProgressHelper.CloseProcessBar();
                    MessageHelper.ShowTips("当前工程数据库未找到城镇村等用地(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
                    {
                        ProgressHelper.CloseProcessBar();
                        MessageHelper.ShowTips("城镇村等用地数据清除失败！");
                        return;
                    }
                }
                ProgressHelper.CountProgress = count;
                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);
                    num++;
                    if (num % 100 == 0 || num == count)
                    {
                        ProgressHelper.CurrentProgress = num;
                    }
                }

                pInsertCursor.Flush();
                ProgressHelper.CloseProcessBar();
                ProgressHelper.ShowProcessBar("正在对城镇村等用地更新进行赋值......");



                pOutWorkFactory = new SqlWorkspaceFactoryClass();
                IWorkspace pOutWork = pOutWorkFactory.OpenFromFile(dbPath, 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);
                    //pFeature.Store();
                    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()
                {
                    FirstFeatureClass = 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;
                GeoprocessorHelper.DissolveAnalysis(gPParamClass, ref featureLayer);
                GeoprocessorHelper.FeatureClassToFeatureClass(featureLayer, TempfilePath, "CZCDYD_Dissolve_Result");
                pFeatureClass_4 = Tempworkspace.OpenFeatureClass("CZCDYD_Dissolve_Result");

                int countt = pFeatureClass_4.FeatureClass.FeatureCount(null);
                if (countt <= 0)
                {
                    //MessageHelper.ShowTips("融合之后出错！，数据异常");
                    return;
                }

                ProgressHelper.CountProgress = countt;
                pFeatureCursor = pFeatureClass_4.FeatureClass.Search(null, false);
                //网格大小引发的错误
                if (czcdydFeatureClassAPI.FeatureClass is IFeatureClassLoad pFclsLoad)
                    pFclsLoad.LoadOnlyMode = true;
                pInsertCursor = czcdydFeatureClassAPI.FeatureClass.Insert(true);
                int cxmIndex = pFeatureClass_4.FeatureClass.FindField("CZCLX");
                int Index_1 = pFeatureClass_4.FeatureClass.FindField("CZCDM");
                int Index_2 = czcdydFeatureClassAPI.FeatureClass.FindField("CZCDM");
                int Index_3 = pFeatureClass_4.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);
                    num++;
                    if (num % 100 == 0 || num == countt)
                    {
                        ProgressHelper.CurrentProgress = num;
                    }
                }
                pInsertCursor.Flush();
                if (czcdydFeatureClassAPI.FeatureClass is IFeatureClassLoad pFclsLoads)
                    pFclsLoads.LoadOnlyMode = false;
                path = GetTempPath();
                rdbHelper.ExecuteSQL(" drop table CZCDYDGX ");
                TableToTable(SchemeWork, 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(SchemeWork, pOutWork, "CJDCQGX");

                ProgressHelper.CloseProcessBar();


                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>() { jc_Fc });

                string BSM = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).CODE + "2931";
                IFeatureCursor pFeatureCursor_LS = czcdydFeatureClassAPI.FeatureClass.Update(null, true);
                count = czcdydFeatureClassAPI.FeatureClass.FeatureCount(null);
                ProgressHelper.ShowProcessBar("正在对城镇村等用地更新进行赋值......");
                ProgressHelper.CountProgress = count;
                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 = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).CODE + 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++;
                    num++;
                    if (num % 100 == 0 || num == count)
                    {
                        ProgressHelper.CurrentProgress = num;
                    }
                    pfeaFeature = pFeatureCursor_LS.NextFeature();
                }
                pFeatureCursor_LS.Flush();

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

                IFeatureWorkspace inWs = GetGdbWorkspace(path);

                IFeatureLayer czcUnionLayer = null;
                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureLayer = GetLayerFromPath(projectInfo.ProjDir + "\\PrjDB.gdb", "JC_CZCDYD"); //MapsManager.Instance.MapService.GetFeatureLayerByName("JC_CZCDYD");
                gPParamClass.SecondFeatureClass = czcdydFeatureClassAPI.FeatureClass;
                gPParamClass.OutFeatureClassPath = path + "\\" + "TempCZCGXGC2";
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.UnionAnalysis(gPParamClass, ref czcUnionLayer);

                gPParamClass = new GPParamClass();
                gPParamClass.FirstFeatureClass = czcUnionLayer.FeatureClass;
                gPParamClass.OutFeatureClassPath = path + "\\" + "TempCZCGXGC";
                gPParamClass.IsGetOutPutFeature = true;
                GeoprocessorHelper.MultipartToSinglePath(gPParamClass, ref czcUnionLayer);

                rdbHelper.ExecuteSQL(" drop table TempCZCGXGC ");
                TableToTable(inWs, pOutWork, "TempCZCGXGC");
                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 = Schemeworkspace.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 = MapsManager.Instance.MapService.GetFeatureLayerByName("CZCDYDGX");
                IFeatureLayer jcczcLayer = GetLayerFromPath(projectInfo.ProjDir + "\\PrjDB.gdb", "JC_CZCDYD"); //MapsManager.Instance.MapService.GetFeatureLayerByName("JC_CZCDYD");
                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);
                ProgressHelper.CountProgress = count;
                num = 0;
                while ((f = cursor.NextFeature()) != null)
                {
                    num++;
                    if (num % 100 == 0 || num == count)
                    {
                        ProgressHelper.CurrentProgress = num;
                    }
                    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);
                    }
                }
                //foreach (var item in upMJSqlList)
                //{
                //    Schemeworkspace.CurrentWorkspace.ExecuteSQL(item);
                //}

                IFeatureLayer JC_CZC203Layer_Mem = GeoDBAPI.CreateFeatureLayerInmemeory("JCCZC203", "城镇村203范围", (jc_Fc as IGeoDataset).SpatialReference, jc_Fc.ShapeType, jc_Fc.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)
                {
                    if (f.OID == 2073)
                    {

                    }
                    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 = 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)
                {
                    if (oid == 2073)
                    {

                    }
                    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);
                        }

                        //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;
                        //    }
                        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.Value[idxGXGCBGHBSM] = MaxBSM;
                                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 = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).CODE + 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;
                            //ITopologicalOperator topo = GeoRing as ITopologicalOperator;
                            //IGeometry tempGeo = topo.Buffer(-0.00015);
                            List<IFeature> gcList = FeatureAPI.Identify2(GeoRing, czcgxgcLayer);
                            //Marshal.ReleaseComObject(tempGeo);
                            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)
                {
                    if (f.OID == 275)
                    {
                    }
                    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];
                        {
                            //ITopologicalOperator topo = Rings[0] as ITopologicalOperator;
                            //IGeometry tempGeo = topo.Buffer(-0.00015);
                            List<IFeature> gcList = FeatureAPI.Identify2(Rings[0], czcgxgcLayer);
                            //Marshal.ReleaseComObject(tempGeo);
                            double czcmj = 0;
                            foreach (IFeature gcF in gcList)
                            {
                                czcmj += gcF.Value[idxGXGCBGMJ].ToDouble(2);
                                //gcF.Value[idxGXGCBGHBSM] = MaxBSM;
                                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 = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).CODE + 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];
                            //ITopologicalOperator topo = Rings[i] as ITopologicalOperator;
                            //IGeometry tempGeo = topo.Buffer(-0.00015);
                            List<IFeature> gcList = FeatureAPI.Identify2(Rings[i], czcgxgcLayer);
                            //Marshal.ReleaseComObject(tempGeo);
                            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 (IsDelMinMJ)
                {
                    (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(SchemeWork, pOutWork, "CZCDYDGXGC");

                rdbHelper.ExecuteSQL(" drop table CZCDYDGX ");
                TableToTable(SchemeWork, 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(SchemeWork, pOutWork, "CZCDYDGXGC");

                rdbHelper.ExecuteSQL(" drop table CZCDYDGX ");
                TableToTable(SchemeWork, 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 = (MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo).CODE;
                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"]));
                            }
                        }
                    }
                }

                ProgressHelper.CloseProcessBar();
                //MessageHelper.ShowTips("提取城镇村等用地数据完成！");
            }
            catch (Exception ex)
            {
                ProgressHelper.CloseProcessBar();
                MessageHelper.ShowError("提取城镇村等用地数据异常：" + ex.Message);
                LogAPI.Debug(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 (cjdcqFeatureClassAPI != null)
                //{
                //    cjdcqFeatureClassAPI.CloseFeatureClass();
                //}
                if (dltbFeatureClassAPI != null)
                {
                    dltbFeatureClassAPI.CloseFeatureClass();
                }
                //if (xzqFeatureclassAPI != null)
                //{
                //    xzqFeatureclassAPI.CloseFeatureClass();
                //}
                if (Schemeworkspace != null)
                {
                    Schemeworkspace.CloseWorkspace();
                }
                if (Tempworkspace != null)
                {
                    Tempworkspace.CloseWorkspace();
                }
                if (pOutWorkFactory != null)
                {
                    Marshal.ReleaseComObject(pOutWorkFactory);
                }
                if (outputWorkspaceFactory != null)
                {
                    Marshal.ReleaseComObject(outputWorkspaceFactory);
                }
                ProgressHelper.CloseProcessBar();
            }
        }
        private static IFeatureLayer GetLayerFromPath(string filePath, string fileName)
        {
            ESRI.ArcGIS.Geodatabase.IWorkspaceFactory workspcFac = new FileGDBWorkspaceFactoryClass();
            IFeatureWorkspace featureWorkspace;
            IFeatureLayer featureLayer = new FeatureLayerClass();
            //打开路径
            featureWorkspace = workspcFac.OpenFromFile(filePath, 0) as IFeatureWorkspace;
            //打开类要素
            featureLayer.FeatureClass = featureWorkspace.OpenFeatureClass(fileName);
            return featureLayer;
        }
        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("获取城镇村范围数据失败：");
                LogAPI.Debug(ex);
            }
        }
        private string GetMaxBSM(List<IFeatureClass> fcList)
        {
            //System.Windows.Forms.Application.DoEvents();
            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 Path = Directory.GetCurrentDirectory() + "\\Temp\\城镇村用地变更临时数据.gdb";
                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)
            {
                ProgressHelper.CloseProcessBar();
                LogAPI.Debug("提取城镇村等用地错误:" + ex.Message.ToString());
                LogAPI.Debug(ex);
                MessageHelper.ShowError("提取城镇村等用地错误：" + ex.Message);
                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; }
    }
}