/// <summary>
        /// 转换
        /// </summary>
        /// <param name="pFeatureClass">要素类</param>
        /// <param name="fieldName">栅格采用的字段</param>
        /// <param name="rasterWorkSpace">输出栅格的工作空间</param>
        /// <param name="newRasterName">新的栅格名称</param>
        public void Convert(IFeatureClass pFeatureClass,
            string fieldName,
            string rasterWorkSpace,
            string newRasterName)
        {
            FileHelper.DeleteFile(rasterWorkSpace, newRasterName, ".tif", ".tfw",".tif.aux");
            IFeatureClassDescriptor featureClassDescriptor = new FeatureClassDescriptorClass();
            featureClassDescriptor.Create(pFeatureClass, null, fieldName);
            IGeoDataset geoDataset = (IGeoDataset)featureClassDescriptor;
            IWorkspaceFactory workspaceFactory = new RasterWorkspaceFactoryClass();           
            IWorkspace workspace = workspaceFactory.OpenFromFile(rasterWorkSpace, 0);
            IConversionOp conversionOp = new RasterConversionOpClass();
            IRasterAnalysisEnvironment rasterAnalysisEnvironment = (IRasterAnalysisEnvironment)conversionOp;
            rasterAnalysisEnvironment.OutWorkspace = workspace;

       
            //set cell size
            rasterAnalysisEnvironment.SetCellSize(esriRasterEnvSettingEnum.esriRasterEnvValue, ref _cellSize);
            //set output extent  
            object objectMissing = Type.Missing;
            rasterAnalysisEnvironment.SetExtent(esriRasterEnvSettingEnum.esriRasterEnvValue, ref _extentEnvelope, ref objectMissing);
            //set output spatial reference 
            rasterAnalysisEnvironment.OutSpatialReference = ((IGeoDataset)pFeatureClass).SpatialReference;
            //convertion
            conversionOp.ToRasterDataset(geoDataset, _rasterType, workspace, newRasterName);              
        }    

        public static void LoadListView(IFeatureClass pFC, ListView listView1)
        {
            try
            {

                listView1.Columns.Clear();
                //添加一个空
                ColumnHeader columnHeader = new ColumnHeader();

                listView1.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
                columnHeader
                });
                columnHeader.Text = "";

                for (int i = 0; i < pFC.Fields.FieldCount; i++)
                {
                    ColumnHeader columnHeader1 = new ColumnHeader();

                    listView1.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] {
                columnHeader1
                });
                    IFields pFields = pFC.Fields;

                    IField pField = pFields.get_Field(i);

                    columnHeader1.Text = pField.AliasName;

                }

            }
            catch (Exception ex)
            { }
        }

        public Dictionary<string,object> FindValue(IFeatureClass pFeatureClass, string keyName, string targetName)
        {
            //int keyFieldIndex = pFeatureClass.Fields.FindField(keyField);
            //int targetFieldIndex = pFeatureClass.Fields.FindField(targetField);
            //IFeatureCursor pFeatureCursor = pFeatureClass.Search(null, false);
            //IFeature pFeature;
            //while ((pFeature = pFeatureCursor.NextFeature()) != null)
            //{
            //    if (pFeature.Value[keyFieldIndex].ToString() == keyValue) break;

            //}
            //Marshal.ReleaseComObject(pFeatureCursor);
            //return pFeature == null ? null : pFeature.Value[targetFieldIndex];
            int keyFieldIndex = pFeatureClass.Fields.FindField(keyName);
            int targetFieldIndex = pFeatureClass.Fields.FindField(targetName);
            Dictionary<string,object> dic=new Dictionary<string, object>(pFeatureClass.FeatureCount(null));
            IFeatureCursor pFeatureCursor = pFeatureClass.Search(null, false);
            IFeature pFeature;
            while ((pFeature = pFeatureCursor.NextFeature()) != null)
            {
                if (!dic.ContainsKey(pFeature.Value[keyFieldIndex].ToString()))
                {
                    dic.Add(pFeature.Value[keyFieldIndex].ToString(), pFeature.Value[targetFieldIndex]);
                    
                }
            }
            Marshal.ReleaseComObject(pFeatureCursor);
            return dic;
        }

        public IFeatureClass Intsect(IFeatureClass _pFtClass, IFeatureClass _pFtOverlay, string _FilePath, string _pFileName)
        {
            IFeatureClassName pOutPut = new FeatureClassNameClass();

            pOutPut.ShapeType = _pFtClass.ShapeType;

            pOutPut.ShapeFieldName = _pFtClass.ShapeFieldName;

            pOutPut.FeatureType = esriFeatureType.esriFTSimple;

            IWorkspaceName pWsN = new WorkspaceNameClass();

            pWsN.WorkspaceFactoryProgID = "esriDataSourcesFile.ShapefileWorkspaceFactory";

            pWsN.PathName = _FilePath;

            IDatasetName pDatasetName = pOutPut as IDatasetName;

            pDatasetName.Name = _pFileName;

            pDatasetName.WorkspaceName = pWsN;

            IBasicGeoprocessor pBasicGeo = new BasicGeoprocessorClass();

            IFeatureClass pFeatureClass = pBasicGeo.Intersect(_pFtClass as ITable, false, _pFtOverlay as ITable, false, 0.1, pOutPut);

            return pFeatureClass;
        }

        public static void BufferAnalysis(IFeatureClass feacls,string dist)
        {
            IGeoProcessor2 gp = new GeoProcessorClass();
            gp.OverwriteOutput = true;

            IGeoProcessorResult result = new GeoProcessorResultClass();

            //gp.SetEnvironmentValue("workspace", @"e:\data");

            IVariantArray vararr = new VarArrayClass();
            object sev = null;
            try
            {
                vararr.Add(feacls);
                vararr.Add(@"e:\data\wwwwwww.shp");
                vararr.Add(dist);

                result = gp.Execute("Buffer_analysis", vararr, null);

                while (result.Status == esriJobStatus.esriJobExecuting)
                    Thread.Sleep(1000);

                MessageBox.Show(gp.GetMessages(ref sev));
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message);
                MessageBox.Show(gp.GetMessages(ref sev));
            }
        }

 public GradePartition(IFeatureClass feacls,string divideField,double[] interval)
 {
     _feacls = feacls;
     _divideFiled = divideField;
     _isDivideOnInterval = true;
     _interval = interval;
 }

        /// <summary>
        /// 获得字段唯一值
        /// </summary>
        public List<object> GetDistinctValue(IFeatureClass FC, string FieldName)
        {
            if (FC.Fields.FindField(FieldName) < 0)
                return null;

            try
            {
                List<object> DistinctValue = new List<object>();

                IDataset Dataset = (IDataset)FC;
                IFeatureWorkspace FWS = (IFeatureWorkspace)Dataset.Workspace;
                IQueryDef QueryDef = FWS.CreateQueryDef();
                QueryDef.Tables = Dataset.Name;
                QueryDef.SubFields = "DISTINCT(" + FieldName + ")";
                ICursor Cursor = QueryDef.Evaluate();
                IRow Row = Cursor.NextRow();
                while (Row != null)
                {
                    object o = Row.get_Value(0);
                    DistinctValue.Add(o);

                    Row = Cursor.NextRow();
                }
                return DistinctValue;
            }
            catch
            {
                return null;
            }
        }

        public ZFeatureClass(IFeatureClass featureClass)
            : base(featureClass as IDataset)
        {
            this.Subtypes = new ObservableCollection<ZSubtype>();
            this.Fields = new ObservableCollection<ZField>();
            this.Id = featureClass.FeatureClassID;

            ISubtypes subtypes = (ISubtypes)featureClass;
            if (subtypes.HasSubtype) {
                IEnumSubtype enumSubtype = subtypes.Subtypes;
                int code;
                string subtypeName = enumSubtype.Next(out code);
                while (!string.IsNullOrEmpty(subtypeName)) {
                    this.Subtypes.Add(new ZSubtype(this, code, subtypeName));
                    subtypeName = enumSubtype.Next(out code);
                }
            }
            else {
                this.Subtypes.Add(new ZDefaultSubtype(this));
            }

            IFields fields = featureClass.Fields;
            for (int i = 0; i < fields.FieldCount; i++) {
                IField field = fields.get_Field(i);
                this.Fields.Add(new ZField(this, field));
            }
        }

 public dataPrepAdjustAccuracyAssessment(IFeatureClass ProjectArea, IFeatureClass Map, string originalAccuracyAssessmentModel, string adjustedAccuracyAssessmentModel)
 {
     projectArea = ProjectArea;
     ftrMap = Map;
     oModel = originalAccuracyAssessmentModel;
     aModel = adjustedAccuracyAssessmentModel;
 }

        public QAExceptionStorage(IWorkspace isdutWorkspace, string schemaOwner, string operationalDSName)
        {
            if (isdutWorkspace == null)
                throw new ArgumentNullException("isdutWorkspace", "Cannot pass null workspace to QAExceptionStorage");

            // Locate the ISDUT.ISDUT_DATA_EXCEPTION_POINTS featureclass in the workspace
            IFeatureClass theFC = null;
            string theFCName = "";
            try
            {
                theFCName = FEATURECLASS_NAME;
                theFC = ((IFeatureWorkspace)isdutWorkspace).OpenFeatureClass(theFCName);
            }
            catch (Exception) {}

            if (theFC == null)
                throw new ErrorStorageException("isdutWorkspace does not contain a featureclass named '" + theFCName + "'", null);

            // Check the featureclass definition
            string theMessage = this.FeatureClassSchemaCheck(theFC);
            if (theMessage != null && theMessage.Length > 0)
            {
                throw new ErrorStorageException(theMessage, null);
            }

            this._operationalDSName = operationalDSName;
            this._exceptionFC = theFC;
        }

        protected override void OnActivate()
        {
            //get the cadastral editor and target fabric
              m_pCadEd = (ICadastralEditor)ArcMap.Application.FindExtensionByName("esriCadastralUI.CadastralEditorExtension");
              m_pCadFab = m_pCadEd.CadastralFabric;

              if (m_pCadFab == null)
              {
            MessageBox.Show("No target fabric found. Please add a fabric to the map start editing, and try again.");
            return;
              }

              m_pFabricLines = (IFeatureClass)m_pCadFab.get_CadastralTable(esriCadastralFabricTable.esriCFTLines);

              m_editor.CurrentTask = null;
              m_edSketch = m_editor as IEditSketch3;
              m_edSketch.GeometryType = esriGeometryType.esriGeometryPolyline;
              m_csc = new TraceConstructorClass();
              m_csc.Initialize(m_editor);
              m_edSketch.ShapeConstructor = m_csc;
              m_csc.Activate();

              // Setup events
              m_editEvents.OnSketchModified += OnSketchModified;
              m_editEvents5.OnShapeConstructorChanged += OnShapeConstructorChanged;
              m_editEvents.OnSketchFinished += OnSketchFinished;
        }

 void IAppend.Append(IFeatureClass fcSource, IFeatureClass fcTarget)
 {
     Geoprocessor gp = new Geoprocessor();
        ESRI.ArcGIS.DataManagementTools.Append pAppend = new ESRI.ArcGIS.DataManagementTools.Append(fcSource, fcTarget);
        gp.SetEnvironmentValue("workspace",this._environment);
        pAppend.schema_type = "NO_TEST";
        runTool(gp, pAppend, null);
 }

 //����һ��FeatureClassΪ�ļ� by gisoracle
 //public void saveFeatureClass(IFeatureClass pFeatureClass, string fileName)
 //{
 //    try
 //    {
 //        string sFileName = System.IO.Path.GetFileName(fileName);
 //        string sFilePath = System.IO.Path.GetDirectoryName(fileName);
 //        IDataset pDataset = pFeatureClass as IDataset;
 //        IWorkspaceFactory pWorkspaceFactory = new ShapefileWorkspaceFactoryClass();
 //        IFeatureWorkspace pFeatureWorkspace = pWorkspaceFactory.OpenFromFile(sFilePath, 0) as IFeatureWorkspace;
 //        IWorkspace pWorkspace = pFeatureWorkspace as IWorkspace;
 //        if (pWorkspace.Exists() == true)
 //        {
 //            //DelFeatureFile(sFilePath, sFileName);
 //        }
 //        //pDataset.Copy(sFileName, pFeatureWorkspace as IWorkspace);
 //    }
 //    catch { MessageBox.Show("����"); }
 //}
 //by gisoracle
 public static void DelFeatureFile(IFeatureClass pFeatureClass, string sName)
 {
     if (pFeatureClass!= null)
     {
         IDataset dataset = pFeatureClass as IDataset;
         dataset.Delete();
     }
 }

 public OperateForm(IFeatureClass FeatureClass, IFeature Feature)
 {
     this.FeatureClass = FeatureClass;
     this.Feature = Feature;
     this.FieldIndexDict = GISHelper.GetFieldIndexDict(FeatureClass);
     Init();
     InitializeComponent();
 }

        /// <summary>
        /// Converts feature class to a recordset.
        /// </summary>
        /// <param name="fc">The fc.</param>
        /// <returns></returns>
        public IRecordSet2 ConvertToRecordset(IFeatureClass fc)
        {
            IRecordSet recSet = new RecordSetClass();
            IRecordSetInit recSetInit = recSet as IRecordSetInit;
            recSetInit.SetSourceTable(fc as ITable, null);

            return (IRecordSet2)recSetInit;
        }

 public BusResultForm(IFeatureClass FeatureClass,IFeatureClass BusStopFeatureClass,string WhereClause)
 {
     InitializeComponent();
     this.FeatureClass = FeatureClass;
     this.WhereClause = WhereClause;
     this.BusStopFeatureClass=BusStopFeatureClass;
     this.IndexDirect = FeatureClass.Fields.FindField("lineDirect");
     this.IndexNameShort = FeatureClass.Fields.FindField("nameshort");
 }

 public static List<Dictionary<int, List<IPoint>>> QueryIntersectPoints(List<IPolyline> lines, IFeatureClass roadFC)
 {
     var list = new List<Dictionary<int, List<IPoint>>>();
     foreach(var line in lines)
     {
         list.Add(QueryIntersectPoints(line, roadFC));
     }
     return list;
 }

 public GHYT(IFeatureClass pFeatureClass, IFeature pFeatrue)
 {
     this.BSM = pFeatrue.get_Value(pFeatureClass.Fields.FindField(this.BSM)).ToString();
     this.YSDM = pFeatrue.get_Value(pFeatureClass.Fields.FindField(this.YSDM)).ToString();
     this.XZQHDM = pFeatrue.get_Value(pFeatureClass.Fields.FindField(this.XZQHDM)).ToString();
     this.GNFQLXDM = pFeatrue.get_Value(pFeatureClass.Fields.FindField(this.GNFQLXDM)).ToString();
     this.TDLYGNFQBH = pFeatrue.get_Value(pFeatureClass.Fields.FindField(this.TDLYGNFQBH)).ToString();
     this.GNFQMJ = pFeatrue.get_Value(pFeatureClass.Fields.FindField(this.GNFQMJ)).ToString();
 }

 public HistoryForm(int fid, IFeatureClass roadFC, IFeatureClass roadHistoryFC, IFeatureClass roadNodeFC, MainForm parent)
 {
     InitializeComponent();
     m_fid = fid;
     m_RoadFC = roadFC;
     m_RoadHistoryFC = roadHistoryFC;
     m_RoadNodeFC = roadNodeFC;
     m_Parent = parent;
 }

 public AttributeForm(IFeature feature, IFeatureClass featureClass, IFeatureClass historyFC, IFeatureClass crossFC, string LayerName)
 {
     InitializeComponent();
     this.Feature = feature;
     this.FeatureClass = featureClass;
     this.LayerName = LayerName;
     this.HistoryFC = historyFC;
     this.CrossFC = crossFC;
 }