NDBGJK5.0/Kingo.Plugins/单图斑建库/Kingo.Plugin.DTBYCL/Commands/CmdTaskSLDataExportForJK.cs

using ESRI.ArcGIS.Carto;
using ESRI.ArcGIS.Controls;
using ESRI.ArcGIS.DataSourcesGDB;
using ESRI.ArcGIS.Geodatabase;
using KGIS.Framework.Commands;
using KGIS.Framework.Maps;
using KGIS.Framework.Utils;
using KGIS.Framework.Utils.Helper;
using Kingo.PluginServiceInterface;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using KUI.Windows;

namespace Kingo.Plugin.DTBYCL.Commands
{
    /// <summary>
    /// 建库预处理矢量数据导出
    /// </summary>
    public class CmdTaskSLDataExportForJK : BaseMenuCommand
    {
        public IHookHelper m_hookHelper;
        public override void OnClick()
        {
            try
            {
                ProjectInfo projectInfo = MapsManager.Instance.MapService.GetProjectInfo() as ProjectInfo;
                IFeatureLayer ZZTBLayer = MapsManager.Instance.MapService.GetFeatureLayerByName("ZZTB");
                //IWorkspaceFactory pFtWsFct = new FileGDBWorkspaceFactory();
                KGIS.Framework.Utils.Dialog.FolderBrowserDialog folderBrowserDialog = new KGIS.Framework.Utils.Dialog.FolderBrowserDialog();
                if (folderBrowserDialog.ShowDialog() != DialogResult.OK)
                    return;
                string path = Path.Combine(folderBrowserDialog.SelectedPath, DateTime.Now.ToString("yyyyMMddHHmmssfff"));
                if (!Directory.Exists(path))
                    Directory.CreateDirectory(path);
                //pFtWsFct.Create(path, "YCLSLGDB", null, 0);
                ExportFeaturesToShp(ZZTBLayer.FeatureClass, null, path, ZZTBLayer.FeatureClass.AliasName);
                MessageHelper.ShowTips("数据导出成功！");
            }
            catch (Exception ex)
            {
                LogAPI.Debug("建库预处理矢量数据导出异常：" + ex);
            }
        }

        /// <summary>
        /// 导出SHP数据
        /// </summary>
        /// <param name="pSourceFeatureClass"></param>
        /// <param name="pQueryFilter"></param>
        /// <param name="forlder"></param>
        /// <param name="fileName"></param>
        public void ExportFeaturesToShp(IFeatureClass pSourceFeatureClass, IQueryFilter pQueryFilter, string forlder, string fileName)
        {
            IWorkspaceFactory workFactory = null;
            IFeatureWorkspace pFeatureWorkspace = null;
            IFeatureCursor pFeatureCursor = null;
            IFeatureClass pFeatureClass = null;
            IFeatureCursor pInsertFeatureCursor = null;
            int count = 0;
            try
            {
                if (pSourceFeatureClass == null)
                {
                    MessageHelper.ShowTips("未获取到要素集！");
                    return;
                }
                if (!Directory.Exists(forlder))
                    Directory.CreateDirectory(forlder);
                count = pSourceFeatureClass.FeatureCount(pQueryFilter);
                pFeatureCursor = pSourceFeatureClass.Search(pQueryFilter, true);
                this.ShowLoading("正在导出，请稍候...", 0, 0);
                workFactory = new ESRI.ArcGIS.DataSourcesFile.ShapefileWorkspaceFactoryClass();
                pFeatureWorkspace = workFactory.OpenFromFile(forlder, 0) as IFeatureWorkspace;

                //创建字段信息
                IFields pFields = new FieldsClass();
                IFieldsEdit pFieldsEdit = pFields as IFieldsEdit;
                List<string> fieldNames = new List<string>();

                for (int i = 0; i < pSourceFeatureClass.Fields.FieldCount; i++)
                {
                    IField field = pSourceFeatureClass.Fields.get_Field(i);

                    if ((field.Type == esriFieldType.esriFieldTypeBlob || field.Type == esriFieldType.esriFieldTypeRaster) && field.Type != esriFieldType.esriFieldTypeGeometry)
                        continue;
                    if (field.Type == esriFieldType.esriFieldTypeGeometry)
                    {
                        IField pField = new FieldClass();
                        IFieldEdit pFieldEdit = pField as IFieldEdit;
                        pFieldEdit.Name_2 = "Shape";
                        pFieldEdit.Type_2 = esriFieldType.esriFieldTypeGeometry;
                        IGeometryDef pGeometryDef = new GeometryDef();
                        IGeometryDefEdit pGeometryDefEdit = pGeometryDef as IGeometryDefEdit;
                        pGeometryDefEdit.GeometryType_2 = pSourceFeatureClass.ShapeType;
                        if ((pSourceFeatureClass as IGeoDataset) != null)
                        {
                            pGeometryDefEdit.SpatialReference_2 = (pSourceFeatureClass as IGeoDataset).SpatialReference;
                        }
                        pFieldEdit.GeometryDef_2 = pGeometryDef;
                        pFieldsEdit.AddField(pField);
                    }
                    else
                    {
                        IField pField = new FieldClass();
                        IFieldEdit pFieldEdit = pField as IFieldEdit;
                        pFieldEdit.Length_2 = field.Length;
                        if (field.Name.Length > 10)
                        {
                            string fname = field.Name.Substring(0, 10);
                            int n = 1;
                            while (fieldNames.Contains(fname))
                            {
                                string end = n.ToString();
                                fname = fname.Remove(10 - end.Length) + end;
                                n++;
                            }
                            pFieldEdit.Name_2 = fname;
                        }
                        else
                        {
                            pFieldEdit.Name_2 = field.Name;
                        }
                        fieldNames.Add(pFieldEdit.Name);
                        pFieldEdit.AliasName_2 = field.AliasName;
                        pFieldEdit.Type_2 = field.Type;
                        pFieldsEdit.AddField(pField);
                    }
                }
                pFeatureClass = pFeatureWorkspace.CreateFeatureClass(fileName, pFields, null, null, pSourceFeatureClass.FeatureType, "SHAPE", "");
                pInsertFeatureCursor = pFeatureClass.Insert(true);
                int num = 0;

                Dictionary<int, int> dicMatchFields = new Dictionary<int, int>();
                GetMatchFieldsDirectory(pSourceFeatureClass, pFeatureClass, ref dicMatchFields, true);
                IFeatureBuffer featureAdd = pFeatureClass.CreateFeatureBuffer();
                IFeature pFeature = null;
                while ((pFeature = pFeatureCursor.NextFeature()) != null)
                {
                    featureAdd.Shape = pFeature.Shape;
                    foreach (KeyValuePair<int, int> kvpMatchField in dicMatchFields)
                    {
                        if (pFeature.Value[kvpMatchField.Value] != DBNull.Value)
                        {
                            featureAdd.set_Value(kvpMatchField.Key, pFeature.get_Value(kvpMatchField.Value));
                        }
                        else
                        {
                            featureAdd.set_Value(kvpMatchField.Key, null);
                        }
                    }
                    pInsertFeatureCursor.InsertFeature(featureAdd);
                    num++;
                    if (num % 100 == 0 || num == count)
                    {
                        //ProgressHelper.CurrentProgress = num;
                    }
                }
                pInsertFeatureCursor.Flush();
                this.CloseLoading();
                //关闭lock
                IWorkspaceFactoryLockControl ipWsFactoryLock = (IWorkspaceFactoryLockControl)workFactory;
                if (ipWsFactoryLock.SchemaLockingEnabled)
                {
                    ipWsFactoryLock.DisableSchemaLocking();
                }
            }
            catch (Exception ex)
            {
                this.CloseLoading();
                MessageHelper.ShowError("导出SHAPE文件出错:" + ex.Message);
                LogAPI.Debug("导出SHAPE文件出错，可能的原因是：" + ex.Message);
            }
            finally
            {
                if (pFeatureCursor != null)
                {
                    Marshal.ReleaseComObject(pFeatureCursor);
                }
                if (pFeatureClass != null)
                {
                    Marshal.ReleaseComObject(pFeatureClass);
                }
                if (pInsertFeatureCursor != null)
                {
                    Marshal.ReleaseComObject(pInsertFeatureCursor);
                }
                if (pFeatureWorkspace != null)
                {
                    Marshal.ReleaseComObject(pFeatureWorkspace);
                }
                if (workFactory != null)
                {
                    Marshal.ReleaseComObject(workFactory);
                }
                this.CloseLoading();
            }
        }
        /// <summary>
        /// 获得匹配的字段索引集合
        /// </summary>
        /// <param name="pSourceFeatureClass">源要素类</param>
        /// <param name="pTargetClass">目标要素类</param>
        /// <param name="dicMatchFields">匹配字段集合-KEY为目标图层字段，VALUE为源图层字段</param>
        /// <param name="isGetRequired">是否获取必须字段</param>
        public static void GetMatchFieldsDirectory(IClass pSourceClass, IClass pTargetClass, ref Dictionary<int, int> dicMatchFields, bool isGetRequired = false)
        {
            for (int i = 0; i < pTargetClass.Fields.FieldCount; i++)
            {
                IField pTargetField = pTargetClass.Fields.get_Field(i);
                //目标图层的字段必须为可编辑并且不是必须字段
                if (pTargetField.Required == false && pTargetField.Editable == true)
                {
                    int iSourceFeatureClassIndex = pSourceClass.Fields.FindField(pTargetField.Name);
                    if (pTargetField.Name == "SHAPE_Leng")
                    {
                        iSourceFeatureClassIndex = pSourceClass.Fields.FindField("SHAPE_Length");
                    }
                    //源要素类中该字段存在
                    if (iSourceFeatureClassIndex > -1)
                    {
                        IField pSourceField = pSourceClass.Fields.get_Field(iSourceFeatureClassIndex);
                        if ("XZQTZLX,BGZT,JCZT,BGFW,WBGLX,SJLY,SFJCTB,ONLYZLBG".Contains(pSourceField.Name))
                            continue;
                        //目标图层的字段也必须为可编辑并且不是必须字段
                        if (pSourceField.Required == false && pSourceField.Editable == true)
                        {
                            //添加到字段匹配集合中
                            dicMatchFields.Add(i, iSourceFeatureClassIndex);
                        }
                        else if (isGetRequired)
                        {
                            dicMatchFields.Add(i, iSourceFeatureClassIndex);
                        }
                    }
                }
                //此处为了保留原有要素ObjectID字段值
                if (pTargetField.Name.Equals("OIDCOPY", StringComparison.CurrentCultureIgnoreCase))
                {
                    dicMatchFields.Add(i, pSourceClass.FindField(pSourceClass.OIDFieldName));
                }
            }
        }


        public override void OnCreate(object Hook)
        {
            if (Hook == null) return;
            try
            {
                if (m_hookHelper == null)
                {
                    m_hookHelper = new HookHelperClass
                    {
                        Hook = Hook
                    };
                }
            }
            catch
            {
                m_hookHelper = null;
                return;
            }
        }

        public override bool Enabled
        {
            get
            {
                if (!(MapsManager.Instance.MapService.GetProjectInfo() is ProjectInfo prj))
                {
                    return false;
                }
                else if (string.IsNullOrWhiteSpace(prj.DTBYCLYHDatabase))
                {
                    return false;
                }
                return true;
            }
        }

    }
}