public void InitializeFieldMapping(string fieldMappingFile)
        {
            InputFieldToOutputFieldAllDatasets.Clear();

            if (!System.IO.File.Exists(fieldMappingFile))
            {
                Console.WriteLine("No Field Mapping Selected");

                // if no mapping file exists, set any hard coded values here:
                InputFieldToOutputFieldAllDatasets["Name"] = "uniquedesignation";

                return;
            }

            Console.WriteLine("Using Field Mapping File: " + fieldMappingFile);

            // Load mapping file
            XmlSerializer mappingSerializer = new XmlSerializer(typeof(FieldMapping));

            System.IO.FileStream readFileStream = new System.IO.FileStream(fieldMappingFile, FileMode.Open, FileAccess.Read, FileShare.Read);

            FieldMapping mapping = (FieldMapping)mappingSerializer.Deserialize(readFileStream);

            readFileStream.Close();

            foreach (FieldMappingField field in mapping.Items)
            {
                string keyInputField    = field.InputName;
                string valueOutputField = field.OutputName;

                InputFieldToOutputFieldAllDatasets[keyInputField] = valueOutputField;
            }
        }
        private void doFieldMapping(IFeatureClass inputFeatureClass, IFeatureClass outputFeatureClass, string sidcFieldName)
        {
            try
            {
                // reset the field mapping on each new FeatureClass
                OutputFieldToInputField.Clear();

                int fieldCount = inputFeatureClass.Fields.FieldCount;

                for (int i = 0; i < fieldCount; i++)
                {
                    IField inputField = inputFeatureClass.Fields.get_Field(i);

                    if (!(inputField.Type == esriFieldType.esriFieldTypeOID || inputField.Type == esriFieldType.esriFieldTypeGeometry ||
                          inputField.Name.ToUpper().StartsWith("SHAPE_")))
                    {
                        string inputName = inputField.Name;

                        string mapToOutputFieldName = inputName; // default output to same as input name

                        if (mapToOutputFieldName == sidcFieldName)
                        {
                            // TRICKY: Handle the 2 different output SIC/SIDC names in Military Features
                            if (outputFeatureClass.Fields.FindField(
                                    MilitaryFeatureClassHelper.SIDC_FIELD_NAME1) >= 0)
                            {
                                mapToOutputFieldName = MilitaryFeatureClassHelper.SIDC_FIELD_NAME1;
                            }
                            else
                            if (outputFeatureClass.Fields.FindField(
                                    MilitaryFeatureClassHelper.SIDC_FIELD_NAME2) >= 0)
                            {
                                mapToOutputFieldName = MilitaryFeatureClassHelper.SIDC_FIELD_NAME2;
                            }
                            else
                            {
                                Console.WriteLine("WARNING: Could not find SIDC field in output");
                            }
                        }
                        else
                        if (InputFieldToOutputFieldAllDatasets.ContainsKey(inputName))
                        {
                            mapToOutputFieldName = InputFieldToOutputFieldAllDatasets[inputName];
                        }

                        if (!OutputFieldToInputField.ContainsKey(mapToOutputFieldName))
                        {
                            int outputFieldIndex = outputFeatureClass.Fields.FindField(mapToOutputFieldName);
                            if (outputFieldIndex >= 0)
                            {
                                IField outputField = outputFeatureClass.Fields.get_Field(outputFieldIndex);

                                if (inputField.Type == outputField.Type)
                                {
                                    Console.WriteLine("Mapping Input Field: " + inputName + " to Output Field: " + mapToOutputFieldName);
                                    OutputFieldToInputField.Add(mapToOutputFieldName, inputName);
                                }
                                else
                                {
                                    Console.WriteLine("Failed to Map (Types Don't Match) Input Field: " + inputName + " to Output Field: " + mapToOutputFieldName);
                                }
                            }
                        }
                    }
                }

                return;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }