/// <summary>
        /// convert FeatureClass in Recordset
        /// </summary>
        /// <param name="featureClass">feature class input</param>
        /// <param name="queryFilter">query filter</param>
        /// <returns>return Recordset</returns>
        internal static IRecordSet2 ConvertToRecordset(IFeatureClass featureClass, IQueryFilter2 queryFilter)
        {
            IRecordSet     recordSet     = new RecordSetClass();
            IRecordSetInit recordSetInit = recordSet as IRecordSetInit;

            recordSetInit.SetSourceTable(featureClass as ITable, queryFilter);

            return((IRecordSet2)recordSetInit);
        }
 public static IRecordSet2 ConvertToRecordset(IFeatureClass featureClass, IQueryFilter2 queryFilter)
 {
     if (null != featureClass)
     {
         IRecordSet     recordSet     = new RecordSetClass();
         IRecordSetInit recordSetInit = recordSet as IRecordSetInit;
         recordSetInit.SetSourceTable(featureClass as ITable, queryFilter);
         return((IRecordSet2)recordSetInit);
     }
     else
     {
         return(null);
     }
 }
        /// <summary>
        /// Uses MatchAddress to geocode a cursor of addresses to a RecordSet 
        /// This is called by ArcGIS Server Geocode Addresses
        /// </summary>
        /// <param name="addressCursor">Cursor containing address to be geocoded</param>
        /// <param name="addressFieldNames">The address fields that make up a record in the cursor</param>
        /// <param name="outputRecordSet">The output record set</param>
        /// <param name="outputFieldNames">The output field names</param>
        /// <param name="fieldsToCopy"></param>
        /// <param name="cancelTracker"></param>
        public void MatchRecordSet(ICursor addressCursor, string addressFieldNames, IRecordSetInit outputRecordSet,
          string outputFieldNames, IPropertySet fieldsToCopy, ITrackCancel cancelTracker)
        {
            _log.Debug("IBatchGeocoding MatchRecordSet");

              _log.Debug("MatchRecordSet addressFieldNames:" + addressFieldNames);
              _log.Debug("MatchRecordSet outputFieldNames:" + outputFieldNames);

              ICursor resultCursor = outputRecordSet.Insert();
              IRow row = addressCursor.NextRow();
              IRowBuffer rowBuffer = null;
              IFields fields = row.Fields;
              IFields bufferFields = null;
              String[] fieldNames = addressFieldNames.Split(',');
              String[] outputFields = outputFieldNames.Split(',');
              int addressFieldsSize = fieldNames.Length;
              int outputFieldsSize = outputFields.Length;
              int copyFieldsSize = 0;
              String addressValue = "";
              IPropertySet addressProperty;
              IPropertySet results;
              object value, values, names;
              String[] nameArray;
              object[] valueArray;
              Dictionary<string, int> addressFieldInds = new Dictionary<string,int>();
              Dictionary<string, int> outputFieldInds = new Dictionary<string, int>();
              string fieldName;
              string outFieldName;

              // Get all address field indexes
              for (int i = 0; i < addressFieldsSize; i++)
              {
              fieldName = fieldNames[i].Trim();
              if(!addressFieldInds.ContainsKey(fieldName))
                  addressFieldInds.Add(fieldName, fields.FindField(fieldName));
              }

              //loop through each record
              while (row != null)
              {
              addressProperty = new PropertySetClass();
              rowBuffer = outputRecordSet.CreateRowBuffer();
              bufferFields = rowBuffer.Fields;

              //populate a property set of search values
              for (int i = 0; i < addressFieldsSize; i++)
              {
                  fieldName = fieldNames[i].Trim();
                  addressValue = row.get_Value(addressFieldInds[fieldName])  as String;

                  if(!string.IsNullOrEmpty(addressValue))
                      addressProperty.SetProperty(fieldName, addressValue);
              }

              // Geocode the Address
              results = MatchAddress(addressProperty);

              // Get all output field indexes, only do this once to save processing
              if (outputFieldInds.Count == 0)
              {
                  for (int i = 0; i < outputFieldsSize; i++)
                  {
                      outFieldName = outputFields[i].Trim();
                      outputFieldInds.Add(outFieldName, bufferFields.FindField(outFieldName));
                  }
              }

              //add the result to the recordset
              for (int i = 0; i < outputFieldsSize; i++)
              {
                  outFieldName = outputFields[i].Trim();
                  value = results.GetProperty(outFieldName);
                  _log.Debug("MatchRecordSet outputFields[i]:" + outFieldName);
                  rowBuffer.set_Value(outputFieldInds[outFieldName], value);
              }

              //copy extra fields
              fieldsToCopy.GetAllProperties(out names, out values);
              nameArray = names as String[];
              valueArray = values as object[];
              copyFieldsSize = nameArray.Length;

              for (int i = 0; i < copyFieldsSize; i++)
              {
                  string fieldToCopy = nameArray[i];
                  if(fieldToCopy == "ResultID")
                      rowBuffer.set_Value(bufferFields.FindField(fieldToCopy), row.OID);
                  else
                      rowBuffer.set_Value(bufferFields.FindField(fieldToCopy), row.get_Value(fields.FindField(fieldToCopy)));
              }

              //insert row
              resultCursor.InsertRow(rowBuffer);

              row = addressCursor.NextRow();
              }

              // Clean up the cursors
              resultCursor.Flush();
              Marshal.ReleaseComObject(resultCursor);
              Marshal.ReleaseComObject(addressCursor);
        }