Newer
Older
EMS_SZ / FrmValiData.cs
root on 21 Mar 2016 44 KB first
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using GeoScene.Engine;
using GeoScene.Globe;
using System.IO;
using System.Xml;
using System.Collections;
using GeoScene.Data;
using DevComponents.DotNetBar;
using System.IO;
namespace Cyberpipe
{
    public partial class FrmValiData : Office2007Form
    {
        private GeoScene.Globe.GSOGlobeControl ctl;
        private GSOLayer layerShp = null;

        private Hashtable en_cns = new Hashtable();
        private Hashtable fields_types = new Hashtable();

        private Hashtable gj_cns = new Hashtable();
        private Hashtable gj_types = new Hashtable();

        private Hashtable yb_cns = new Hashtable();
        private Hashtable yb_types = new Hashtable();

        private Hashtable jyd_cns = new Hashtable();
        private Hashtable jyd_types = new Hashtable();

        public FrmValiData(GeoScene.Globe.GSOGlobeControl _ctl)
        {
            InitializeComponent();
            ctl = _ctl;
        }
        /// <summary>
        /// 窗体初始化事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FrmValiData_Load(object sender, EventArgs e)
        {
        
            cmbLayerType.SelectedIndex = -1;            
            string filename = Application.StartupPath + "\\FormText.xml";
            if (File.Exists(filename))
            {
                XmlTextReader XmlReader = new XmlTextReader(filename);
                try
                {
                    while (XmlReader.Read())
                    {
                        if (XmlReader.Name == "Field")
                        {
                            string str1 = XmlReader["label"];
                            string str3 = XmlReader["type"];
                            string str2 = XmlReader.ReadElementString();
                            en_cns.Add(str1, str2);
                            fields_types.Add(str1, str3);
                        }
                        else if (XmlReader.Name == "FuShuWu")
                        {
                            string str1 = XmlReader["label"];
                            string str3 = XmlReader["type"];
                            string str2 = XmlReader.ReadElementString();
                            gj_cns.Add(str1, str2);
                            gj_types.Add(str1, str3);
                        }
                        else if (XmlReader.Name == "TeZhengGuanDian")
                        {
                            string str1 = XmlReader["label"];
                            string str3 = XmlReader["type"];
                            string str2 = XmlReader.ReadElementString();
                            yb_cns.Add(str1, str2);
                            yb_types.Add(str1, str3);

                        }
                        else if (XmlReader.Name == "JiaoYueDian")
                        {
                            string str1 = XmlReader["label"];
                            string str3 = XmlReader["type"];
                            string str2 = XmlReader.ReadElementString();
                            jyd_cns.Add(str1, str2);
                            jyd_types.Add(str1, str3);

                        }

                    }

                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }
            }

            if (ctl != null)
            {
                for (int i = 0; i < ctl.Globe.Layers.Count; i++)
                {
                    GSOLayer layer = ctl.Globe.Layers[i];
                    if (layer != null && layer.Name.ToLower().EndsWith(".shp"))
                    {
                        string lay = layer.Caption; 
                        cmbShps.Items.Add(layer.Caption);
                    }
                }
            }
        }

        /// <summary>
        /// 验证按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnVali_Click(object sender, EventArgs e)
        {
            if (cmbShps.Text.Trim() == "")
            {
                MessageBox.Show("请选择一个shape图层文件!","提示!",
                    MessageBoxButtons.OK,MessageBoxIcon.Warning);
                return;
            }
            if (cmbLayerType.SelectedItem == null)
            {
                MessageBox.Show("请选择shape图层类型!", "提示!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }

            if (layerShp == null)
            {
                MessageBox.Show("选择的shape图层不符合要求!", "提示!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                cmbShps.Text = "";
                return;
            }
            if (cmbLayerType.SelectedItem.ToString() == "管线")
            {
                valiPipedata(layerShp);
            }
            if (cmbLayerType.SelectedItem.ToString() == "附属物")
            {
                valiFuShuWudata(layerShp);
            }
            if (cmbLayerType.SelectedItem.ToString() == "特征管点")
            {
                valiTZGDdata(layerShp);
            }
            if (cmbLayerType.SelectedItem.ToString() == "交越点")
            {
                valiJYDdata(layerShp);
            }
            if (txtMessage.Text == "")
            {
                txtMessage.Text = "数据正确";
            }
        }

        #region 验证
        //
        //验证交越点
        //
        private void valiJYDdata(GSOLayer layer)
        {
            txtMessage.Text = "";
            if (layer != null)
            {
                GSOFeatureDataset featDataSet = layer.Dataset as GSOFeatureDataset;
                List<string> lstField = new List<string>();
                List<string> listFieldType_Text = new List<string>();
                for (int i = 0; i < featDataSet.FieldCount; i++)
                {
                    string fieldName = featDataSet.GetField(i).Name;
                    lstField.Add(fieldName);
                    if (jyd_types.ContainsKey(fieldName))
                    {
                        string fieldType = jyd_types[fieldName].ToString().ToUpper();
                        switch (featDataSet.GetField(i).Type)
                        {
                            case EnumFieldType.Text:
                                if (fieldType != "string".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                listFieldType_Text.Add(fieldName);
                                break;
                            case EnumFieldType.INT32:
                                if (fieldType != "int".ToUpper() && fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.INT16:
                                if (fieldType != "int".ToUpper() && fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.Double:
                                if (fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.Date:
                                if (fieldType != "date".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                        }
                    }
                    else
                    {
                        txtMessage.Text += "警告:配置文件中不包含\"" + fieldName + "\"字段\r\n";
                    }
                }
                if (!lstField.Contains("编号"))
                {
                    txtMessage.Text += "编号字段不存在!\r\n";
                }
                if (!lstField.Contains("所属道路"))
                {
                    txtMessage.Text += "所属道路字段不存在!\r\n";
                }
                if (!lstField.Contains("图层编号"))
                {
                    txtMessage.Text += "图层编号字段不存在!\r\n";
                }
                if (!lstField.Contains("上层管编号"))
                {
                    txtMessage.Text += "上层管编号字段不存在!\r\n";
                }
                if (!lstField.Contains("上层管种类"))
                {
                    txtMessage.Text += "上层管种类字段不存在!\r\n";
                }
                if (!lstField.Contains("上层管埋深"))
                {
                    txtMessage.Text += "上层管埋深字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("上层管埋深");
                    if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"上层管埋深\"字段必须为数值类型 \r\n";
                    }
                }
                //if (!lstField.Contains("上层管直径"))
                //{
                //    txtMessage.Text += "上层管直径字段不存在!\r\n";
                //}
                //else
                //{
                //    GSOFieldAttr fieldZ = featDataSet.GetField("上层管直径");
                //    if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                //    {
                //        txtMessage.Text += "\"上层管直径\"字段必须为数值类型 \r\n";
                //    }
                //}
                if (!lstField.Contains("上层管材料"))
                {
                    txtMessage.Text += "上层管材料字段不存在!\r\n";
                }
                if (lstField.Contains("中层管编号"))
                {
                    if (!lstField.Contains("中层管种类"))
                    {
                        txtMessage.Text += "中层管种类字段不存在!\r\n";
                    }
                    if (!lstField.Contains("中层管埋深"))
                    {
                        txtMessage.Text += "中层管埋深字段不存在!\r\n";
                    }
                    else
                    {
                        GSOFieldAttr fieldZ = featDataSet.GetField("中层管埋深");
                        if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                        {
                            txtMessage.Text += "\"中层管埋深\"字段必须为数值类型 \r\n";
                        }
                    }


                     if (!lstField.Contains("中层管直径"))
                    {
                        txtMessage.Text += "中层管直径字段不存在!\r\n";
                    }
                    else
                    {
                        GSOFieldAttr fieldZ = featDataSet.GetField("中层管直径");
                        if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                        {
                            txtMessage.Text += "\"中层管直径\"字段必须为数值类型 \r\n";
                        }
                    }
                     if (!lstField.Contains("中层管材料"))
                    {
                        txtMessage.Text += "中层管材料字段不存在!\r\n";
                    }
                }
                if (!lstField.Contains("下层管编号"))
                {
                    txtMessage.Text += "下层管编号字段不存在!\r\n";
                }
                if (!lstField.Contains("下层管种类"))
                {
                    txtMessage.Text += "下层管种类字段不存在!\r\n";
                }
                if (!lstField.Contains("下层管埋深"))
                {
                    txtMessage.Text += "下层管埋深字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("下层管埋深");
                    if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"下层管埋深\"字段必须为数值类型 \r\n";
                    }
                }
                //if (!lstField.Contains("下层管直径"))
                //{
                //    txtMessage.Text += "下层管直径字段不存在!\r\n";
                //}
                //else
                //{
                //    GSOFieldAttr fieldZ = featDataSet.GetField("下层管直径");
                //    if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                //    {
                //        txtMessage.Text += "\"下层管直径\"字段必须为数值类型 \r\n";
                //    }
                //}
                if (!lstField.Contains("下层管材料"))
                {
                    txtMessage.Text += "下层管材料字段不存在!\r\n";
                }
                if (!lstField.Contains("X坐标"))
                {
                    txtMessage.Text += "X坐标字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("X坐标");
                    if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"X坐标\"字段必须为数值类型 \r\n";
                    }
                }
                if
                    (!lstField.Contains("两管线间隙") && !lstField.Contains("上中间隙") && !lstField.Contains("中下间隙"))
                {
                    txtMessage.Text += "间隙字段不存在!\r\n";
                }
                else
                {
                    if (lstField.Contains("两管线间隙"))
                    {
                        GSOFieldAttr fieldZ = featDataSet.GetField("两管线间隙");
                        if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                        {
                            txtMessage.Text += "\"两管线间隙\"字段必须为数值类型 \r\n";
                        }
                    }
                    else if (lstField.Contains("上中间隙") && lstField.Contains("中下间隙"))
                    {
                        GSOFieldAttr fieldZ = featDataSet.GetField("上中间隙");
                        GSOFieldAttr fieldT = featDataSet.GetField("中下间隙");
                        if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32 && fieldT.Type != EnumFieldType.Double && fieldT.Type != EnumFieldType.Float && fieldT.Type != EnumFieldType.INT16 && fieldT.Type != EnumFieldType.INT32)
                        {
                            txtMessage.Text += "\"间隙\"字段必须为数值类型 \r\n";
                        }
                    }

                }
                for (int i = 0; i < layer.GetAllFeatures().Length; i++)
                {
                    GSOFeature f = layer.GetAt(i);
                    for (int j = 0; j < listFieldType_Text.Count; j++)
                    {
                        string fieldName = listFieldType_Text[j];
                        if (yb_types.ContainsKey(fieldName))
                        {
                            if (f.GetValue(fieldName).ToString().Trim().Length > 8000)
                            {
                                txtMessage.Text += "名称为" + f.Name + "的要素的字段" + fieldName + "的长度大于8000 !\r\n";
                            }
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 验证特征管点
        /// </summary>
        /// <param name="layer"></param>
        private void valiTZGDdata(GSOLayer layer)
        { 
            txtMessage.Text = "";            
            if (layer != null)
            {
                GSOFeatureDataset featDataSet = layer.Dataset as GSOFeatureDataset;
                List<string> lstField = new List<string>();
                List<string> listFieldType_Text = new List<string>();
                for (int i = 0; i < featDataSet.FieldCount; i++)
                {
                    string fieldName = featDataSet.GetField(i).Name;
                    lstField.Add(fieldName);
                    if (yb_types.ContainsKey(fieldName))
                    {
                        string fieldType = yb_types[fieldName].ToString().ToUpper();
                        int n = featDataSet.GetField(i).Precision;
                        int w = featDataSet.GetField(i).Width;
                        switch (featDataSet.GetField(i).Type)
                        {
                            case EnumFieldType.Text:
                                if (fieldType != "string".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                listFieldType_Text.Add(fieldName);
                                break;
                            case EnumFieldType.INT32:
                                if (fieldType != "int".ToUpper() && fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.INT16:
                                if (fieldType != "int".ToUpper() && fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.Double:
                                if (fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.Date:
                                if (fieldType != "date".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                        }
                    }
                    else
                    {
                        txtMessage.Text += "警告:配置文件中不包含\"" + fieldName + "\"字段\r\n";
                    }
                }
                if (!lstField.Contains("编号"))
                {
                    txtMessage.Text += "编号字段不存在!\r\n";
                } 
                if (!lstField.Contains("管点编码"))
                {
                    txtMessage.Text += "管点编码字段不存在!\r\n";
                }
                if (!lstField.Contains("符号角度"))
                {
                    txtMessage.Text += "符号角度字段不存在!\r\n";
                }
                if (!lstField.Contains("管点特征"))
                {
                    txtMessage.Text += "管点特征字段不存在!\r\n";
                }
                if (!lstField.Contains("X坐标"))
                {
                    txtMessage.Text += "X坐标字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldT = featDataSet.GetField("X坐标");
                    if (fieldT.Type != EnumFieldType.Double && fieldT.Type != EnumFieldType.Float && fieldT.Type != EnumFieldType.INT16 && fieldT.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"X坐标\"字段必须为数值类型 \r\n";
                    }
                }
                if (!lstField.Contains("地面高程"))
                {
                    txtMessage.Text += "地面高程字段不存在!\r\n";
                }
                else 
                {
                    GSOFieldAttr fieldT = featDataSet.GetField("地面高程");
                    if (fieldT.Type != EnumFieldType.Double && fieldT.Type != EnumFieldType.Float && fieldT.Type != EnumFieldType.INT16 && fieldT.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"地面高程\"字段必须为数值类型 \r\n";
                    }
                }
                if (!lstField.Contains("Z坐标"))
                {
                    txtMessage.Text += "Z坐标字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldT = featDataSet.GetField("Z坐标");
                    if (fieldT.Type != EnumFieldType.Double && fieldT.Type != EnumFieldType.Float && fieldT.Type != EnumFieldType.INT16 && fieldT.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"Z坐标\"字段必须为数值类型 \r\n";
                    }
                }
                if (!lstField.Contains("Y坐标"))
                {
                    txtMessage.Text += "Y坐标字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldT = featDataSet.GetField("Y坐标");
                    if (fieldT.Type != EnumFieldType.Double && fieldT.Type != EnumFieldType.Float && fieldT.Type != EnumFieldType.INT16 && fieldT.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"Y坐标\"字段必须为数值类型 \r\n";
                    }
                }
                if (!lstField.Contains("所属道路"))
                {
                    txtMessage.Text += "所属道路字段不存在!\r\n";
                }


                for (int i = 0; i < layer.GetAllFeatures().Length; i++)
                {
                    GSOFeature f = layer.GetAt(i);
                    for (int j = 0; j < listFieldType_Text.Count; j++)
                    {
                        string fieldName = listFieldType_Text[j];
                        if (yb_types.ContainsKey(fieldName))
                        {
                            if (f.GetValue(fieldName).ToString().Trim().Length > 8000)
                            {
                                txtMessage.Text += "名称为" + f.Name + "的要素的字段" + fieldName + "的长度大于8000 !\r\n";
                            }
                        }
                    }
                }      
            }
        }
        /// <summary>
        /// 验证附属物
        /// </summary>
        /// <param name="layer"></param>
        private void valiFuShuWudata(GSOLayer layer)
        { 
            txtMessage.Text = "";            
            if (layer != null)
            {
                GSOFeatureDataset featDataSet = layer.Dataset as GSOFeatureDataset;
                List<string> lstField = new List<string>();
                List<string> listFieldType_Text = new List<string>();
                for (int i = 0; i < featDataSet.FieldCount; i++)
                {
                    string fieldName = featDataSet.GetField(i).Name;
                    lstField.Add(fieldName);
                    if (gj_types.ContainsKey(fieldName))
                    {
                        string fieldType = gj_types[fieldName].ToString().ToUpper();
                        switch (featDataSet.GetField(i).Type)
                        {
                            case EnumFieldType.Text:
                                if (fieldType != "string".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                listFieldType_Text.Add(fieldName);
                                break;
                            case EnumFieldType.INT32:
                                if (fieldType != "int".ToUpper() && fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.INT16:
                                if (fieldType != "int".ToUpper() && fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.Double:
                                if (fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.Date:
                                if (fieldType != "date".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                        }
                    }
                    else
                    {
                        txtMessage.Text += "警告:配置文件中不包含\"" + fieldName + "\"字段\r\n";
                    }
                   
                }
                if (!lstField.Contains("编号"))
                {
                    txtMessage.Text += "编号字段不存在!\r\n";
                }
                if (!lstField.Contains("附属物编码"))
                {
                    txtMessage.Text += "附属物编码字段不存在!\r\n";
                }

                if (!lstField.Contains("地面高程"))
                {
                    txtMessage.Text += "地面高程字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("地面高程");
                    if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"地面高程\"字段必须为数值类型 \r\n";
                    }
                }
                if (!lstField.Contains("X坐标"))
                {
                    txtMessage.Text += "X坐标字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("X坐标");
                    if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"X坐标\"字段必须为数值类型 \r\n";
                    }
                }
                if (!lstField.Contains("Y坐标"))
                {
                    txtMessage.Text += "Y坐标字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("Y坐标");
                    if (fieldZ.Type != EnumFieldType.Double && fieldZ.Type != EnumFieldType.Float && fieldZ.Type != EnumFieldType.INT16 && fieldZ.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "\"Y坐标\"字段必须为数值类型 \r\n";
                    }
                }
                if (!lstField.Contains("附属物名称"))
                {
                    txtMessage.Text += "附属物名称字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("附属物名称");
                    if (fieldZ.Type != EnumFieldType.Text)
                    {
                        txtMessage.Text += "\"附属物名称\"字段必须为文本类型 \r\n";
                    }
                }
                if (!lstField.Contains("所属道路"))
                {
                    txtMessage.Text += "所属道路字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("所属道路");
                    if (fieldZ.Type != EnumFieldType.Text)
                    {
                        txtMessage.Text += "\"所属道路\"字段必须为文本类型 \r\n";
                    }
                }
         /**       if (!lstField.Contains("所含管线"))
                {
                    txtMessage.Text += "所含管线字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldZ = featDataSet.GetField("所含管线");
                    if (fieldZ.Type != EnumFieldType.Text)
                    {
                        txtMessage.Text += "\"所含管线\"字段必须为文本类型 \r\n";
                    }
                }**/
                for (int i = 0; i < layer.GetAllFeatures().Length; i++)
                {
                    GSOFeature f = layer.GetAt(i);
                    for (int j = 0; j < listFieldType_Text.Count; j++)
                    {
                        string fieldName = listFieldType_Text[j];
                        if (gj_types.ContainsKey(fieldName))
                        {
                            if (f.GetValue(fieldName).ToString().Trim().Length > 8000)
                            {
                                txtMessage.Text += "名称为" + f.Name + "的要素的字段" + fieldName + "的长度大于8000 !\r\n";
                            }
                        }
                    }
                }      
            }
        }
        /// <summary>
        /// 验证管线
        /// </summary>
        /// <param name="layer"></param>
        private void valiPipedata(GSOLayer layer)
        {
            txtMessage.Text = "";
            if (layer != null)
            {
                GSOFeatureDataset featDataSet = layer.Dataset as GSOFeatureDataset;
                List<string> lstField = new List<string>();
                List<string> listFieldType_Text = new List<string>();
                for (int i = 0; i < featDataSet.FieldCount; i++)
                {
                    string fieldName = featDataSet.GetField(i).Name;
                    lstField.Add(fieldName);
                    if (fields_types.ContainsKey(fieldName))
                    {
                        string fieldType = fields_types[fieldName].ToString().ToUpper();
                        switch (featDataSet.GetField(i).Type)
                        {
                            case EnumFieldType.Text:

                                if (fieldType != "string".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                listFieldType_Text.Add(fieldName);
                                break;

                            case EnumFieldType.INT32:
                                if (fieldType != "int".ToUpper() && fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.INT16:
                                if (fieldType != "int".ToUpper() && fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.Double:
                                if (fieldType != "double".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                            case EnumFieldType.Date:
                                if (fieldType != "date".ToUpper())
                                {
                                    txtMessage.Text += "" + fieldName + "数据类型不正确\r\n";
                                }
                                break;
                        }
                    }
                    else
                    {
                        txtMessage.Text += "警告:配置文件中不包含\"" + fieldName + "\"字段\r\n";
                    }
                }

            /**    if (!lstField.Contains("Laser_Num"))
                {
                    txtMessage.Text += "Laser_Num字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldLaser_Num = featDataSet.GetField("Laser_Num");

                    if (fieldLaser_Num.Type != EnumFieldType.Double && fieldLaser_Num.Type != EnumFieldType.Float && fieldLaser_Num.Type != EnumFieldType.INT16 && fieldLaser_Num.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "Laser_Num字段必须为数值类型\r\n";
                    }
                }**/

            /**   if (!lstField.Contains("Hor_Num"))
                {
                    txtMessage.Text += "Hor_Num字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldHor_Num = featDataSet.GetField("Hor_Num");

                    if (fieldHor_Num.Type != EnumFieldType.Double && fieldHor_Num.Type != EnumFieldType.Float && fieldHor_Num.Type != EnumFieldType.INT16 && fieldHor_Num.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "Hor_Num字段必须为数值类型\r\n";
                    }
                }
                if (!lstField.Contains("Ver_Num"))
                {
                    txtMessage.Text += "Ver_Num字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldVer_Num = featDataSet.GetField("Ver_Num");

                    if (fieldVer_Num.Type != EnumFieldType.Double && fieldVer_Num.Type != EnumFieldType.Float && fieldVer_Num.Type != EnumFieldType.INT16 && fieldVer_Num.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "Ver_Num字段必须为数值类型\r\n";
                    }
                }**/

                if (!lstField.Contains("Street") && !lstField.Contains("Crossing"))
                {
                    txtMessage.Text += "管线所在街道名称不存在!\r\n";
                }
                else 
                {
		         if(lstField.Contains("Street"))
                 {
		    	    GSOFieldAttr fieldDeep1 = featDataSet.GetField("Street");
			     if (fieldDeep1.Type != EnumFieldType.Text)
			        {
			    	     txtMessage.Text += "街道名称必须为文本类型\r\n";
      		    	}
			
		          }
                 else if(lstField.Contains("Crossing"))
                  {
		             GSOFieldAttr fieldDeep1 = featDataSet.GetField("Crossing");
		        	 if (fieldDeep1.Type != EnumFieldType.Text)
	        		{
		        		 txtMessage.Text += "街道名称必须为文本类型\r\n";
         			}
		          }                                      
                }

                if (!lstField.Contains("Deep1"))
                {
                    txtMessage.Text += "Deep1字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldDeep1 = featDataSet.GetField("Deep1");
                    if (fieldDeep1.Type != EnumFieldType.Double && fieldDeep1.Type != EnumFieldType.Float && fieldDeep1.Type != EnumFieldType.INT16 && fieldDeep1.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "Deep1字段必须为数值类型\r\n";
                    }
                }
                if (!lstField.Contains("Deep2"))
                {
                    txtMessage.Text += "Deep2字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldDeep1 = featDataSet.GetField("Deep2");
                    if (fieldDeep1.Type != EnumFieldType.Double && fieldDeep1.Type != EnumFieldType.Float && fieldDeep1.Type != EnumFieldType.INT16 && fieldDeep1.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "Deep2字段必须为数值类型\r\n";
                    }
                }
                if (!lstField.Contains("Diameter"))
                {
                    txtMessage.Text += "Diameter字段不存在!\r\n";
                }
                else
                {
                    GSOFieldAttr fieldDeep1 = featDataSet.GetField("Diameter");
                    if (fieldDeep1.Type != EnumFieldType.Double && fieldDeep1.Type != EnumFieldType.Float && fieldDeep1.Type != EnumFieldType.INT16 && fieldDeep1.Type != EnumFieldType.INT32)
                    {
                        txtMessage.Text += "Diameter字段必须为数值类型\r\n";
                    }
                }
                if (!lstField.Contains("Handle"))
                {
                    txtMessage.Text += "Handle字段不存在!\r\n";
                }
                List<string> lstDiameter = new List<string>();
                for (int i = 0; i < layer.GetAllFeatures().Length; i++)
                {
                    GSOFeature f = layer.GetAt(i);
                    for (int j = 0; j < listFieldType_Text.Count; j++)
                    {
                        string fieldName = listFieldType_Text[j];
                        if (fields_types.ContainsKey(fieldName))
                        {
                            if (f.GetValue(fieldName).ToString().Trim().Length > 8000)
                            {
                                txtMessage.Text += "ID为" + f.ID + "的要素的字段" + fieldName + "的长度大于8000 !\r\n";
                            }
                        }
                    }
                    if (f.GetFieldAsFloat("Diameter") <= 0)
                    {
                        txtMessage.Text += "ID为" + f.ID + "\"Diameter\"字段中的值必须大于0 \r\n";
                    }
                    if (!lstDiameter.Contains(f.GetFieldAsString("Handle")))
                    {
                        lstDiameter.Add(f.GetFieldAsString("Handle"));
                    }
                    else
                    {
                        txtMessage.Text += "ID为" + f.ID + "的\"Handle\"字段中的值重复\r\n";
                    }
                }
              /***   List<string> lstCrossing = new List<string>();
                for (int i = 0; i < layer.GetAllFeatures().Length; i++)
                {
                    GSOFeature f = layer.GetAt(i);
                    for (int j = 0; j < listFieldType_Text.Count; j++)
                    {
                        string fieldName = listFieldType_Text[j];
                        if (fields_types.ContainsKey(fieldName))
                        {
                            if (f.GetValue(fieldName).ToString().Trim().Length > 8000)
                            {
                                txtMessage.Text += "名字" + f.ID + "的要素的字段" + fieldName + "的长度大于8000 !\r\n";
                            }
                        }
                    }
                    if (f.GetFieldAsString("Crossing") == "")
                    {
                        txtMessage.Text += "ID" + f.ID + "\"Crossing\"字段中的值必须为字母 \r\n";
                    }
                    if (!lstDiameter.Contains(f.GetFieldAsString("Crossing")))
                    {
                        lstDiameter.Add(f.GetFieldAsString("Crossing"));
                    }
                }
               List<string> Crossing = new List<string>();
                for (int i = 0; i < layer.GetAllFeatures().Length; i++)
                {
                    GSOFeature f = layer.GetAt(i);
                    for (int j = 0; j < listFieldType_Text.Count; j++)
                    {
                        string fieldName = listFieldType_Text[j];
                        if (fields_types.ContainsKey(fieldName))
                        {
                            if (f.GetValue(fieldName).ToString().Trim().Length > 8000)
                            {
                                txtMessage.Text += "名字" + f.ID + "的要素的字段" + fieldName + "的长度大于8000 !\r\n";
                            }
                        }
                    }
                    if (f.GetFieldAsString("Crossing") == "")
                    {
                        txtMessage.Text += "ID" + f.ID + "\"Crossing\"字段中的值必须存在 \r\n";
                    }
                    if (!lstDiameter.Contains(f.GetFieldAsString("Crossing")))
                    {
                        lstDiameter.Add(f.GetFieldAsString("Crossing"));
                    }
                }**/

            }
        }

        #endregion

        /// <summary>
        /// 取消按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCancel_Click(object sender, EventArgs e)
        {
            this.Close();
        } 
        /// <summary>
        /// 导出错误信息按钮事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void buttonXExportErrorMessage_Click(object sender, EventArgs e)
        {
            if (txtMessage.Text == "")
            {
                MessageBox.Show("错误信息为空!","提示");
                return;
            }
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.Filter = "*.txt|*.txt";
            if (dlg.ShowDialog() == DialogResult.OK)
            {
                string errorFilePath = dlg.FileName;
                string strErrorMessage = txtMessage.Text.Trim();
                StreamWriter writer = new StreamWriter(errorFilePath, false);
                writer.Write(strErrorMessage);
                writer.Close();
                MessageBox.Show("导出成功!","提示");
            }
        }
        /// <summary>
        /// 窗体关闭事件处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FrmValiData_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (layerShp != null)
            {
               // ctl.Globe.Layers.Remove(layerShp);
            }
        }

        private void cmbShps_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (cmbShps.SelectedIndex != -1)
            {
                string layerCaption = cmbShps.SelectedItem.ToString().Trim();
                layerShp = ctl.Globe.Layers.GetLayerByCaption(layerCaption); 
            }          
        } 
         
    }
}