C# DbDataReader.GetOrdinal方法代码示例

 public ResourceRecord(DbDataReader reader)
 {
     Page = reader.GetString(reader.GetOrdinal("resourcepage"));
     CultureCode = reader.GetString(reader.GetOrdinal("culturecode"));
     Key = reader.GetString(reader.GetOrdinal("resourcekey"));
     Value = reader.GetString(reader.GetOrdinal("resourcevalue"));
 }

        protected Conversation GetCurrentConversation(DbDataReader reader)
        {
            int colID = reader.GetOrdinal("grupoid_grupo");
            int colName = reader.GetOrdinal("nombre");

            Conversation conversation = new Conversation();
            if (!reader.IsDBNull(colID))
            {
                conversation.ID = reader.GetInt32(colID);
            }
            if (!reader.IsDBNull(colName))
            {
                conversation.Name = reader.GetString(colName);
            }

            return conversation;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        protected static string GetTableType(DbDataReader reader)
        {
            const string TABLE_TYPE = @"TABLE_TYPE";

            var ordinal = reader.GetOrdinal(TABLE_TYPE);
            var type = reader.GetString(ordinal);

            return type;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        protected static string GetTableName(DbDataReader reader)
        {
            const string TABLE_NAME = @"TABLE_NAME";

            var ordinal = reader.GetOrdinal(TABLE_NAME);
            var name = reader.GetString(ordinal);

            return name;
        }

        protected ProjectInfo_LH GetProjectInfo(DbDataReader reader)
        {
            ProjectInfo_LH row = new ProjectInfo_LH();

            row.Id = Convert.ToInt32(reader.GetValue(reader.GetOrdinal(ProjectInfo_LH.C_id)));
            row.Projname = Convert.ToString(reader.GetValue(reader.GetOrdinal(ProjectInfo_LH.C_projName)));
            row.Xmdm = Convert.ToInt32(reader.GetValue(reader.GetOrdinal(ProjectInfo_LH.C_xmdm)));
            row.Zjdm = Convert.ToInt32(reader.GetValue(reader.GetOrdinal(ProjectInfo_LH.C_zjdm)));
            row.Zmdm = Convert.ToInt32(reader.GetValue(reader.GetOrdinal(ProjectInfo_LH.C_zmdm)));
            row.Sc = Convert.ToChar(reader.GetValue(reader.GetOrdinal(ProjectInfo_LH.C_sc)));

            return row;
        }

        public DataTable(DbDataReader reader)
        {
            this.fields = new List<string>();
            this.data = new List<object[]>();

            for (int i = 0; i < reader.FieldCount; i++)
            {
                fields.Add(reader.GetName(i));
            }

            while (reader.Read())
            {
                object[] values = new object[reader.FieldCount];
                for (int i = 0; i < fields.Count; i++)
                {
                    values[i] = reader.GetValue(reader.GetOrdinal(fields[i]));
                }
                data.Add(values);
            }
        }

        private void mapValues(DbDataReader reader, object record)
        {
            foreach (var accessor in this.accessors) {
                var index = reader.GetOrdinal(accessor.Name);

                if (reader.IsDBNull(index)) {
                    continue;
                }

                if (accessor.PropertyType == typeof(string)) {
                    accessor.Set(record, reader.GetString(index));
                } else if (accessor.PropertyType == typeof(int) || accessor.PropertyType == typeof(int?)) {
                    accessor.Set(record, reader.GetInt32(index));
                } else if (accessor.PropertyType == typeof(long) || accessor.PropertyType == typeof(long?)) {
                    accessor.Set(record, reader.GetInt64(index));
                } else if (accessor.PropertyType == typeof(DateTime) || accessor.PropertyType == typeof(DateTime?)) {
                    accessor.Set(record, reader.GetDateTime(index));
                } else if (accessor.PropertyType == typeof(char) || accessor.PropertyType == typeof(char?)) {
                    accessor.Set(record, reader.GetChar(index));
                }
            }
        }

        /// <summary>
        /// Given a store datareader and a column name, try to find the column ordinal
        /// in the datareader with the name of the column.
        /// </summary>
        /// <param name="storeDataReader"></param>
        /// <param name="columnName"></param>
        /// <param name="ordinal"></param>
        /// <returns>true if found, false otherwise.</returns>
        private static bool TryGetColumnOrdinalFromReader(DbDataReader storeDataReader, string columnName, out int ordinal)
        {
            if (0 == storeDataReader.FieldCount)
            {
                // If there are no fields, there can't be a match (this check avoids
                // an InvalidOperationException on the call to GetOrdinal)
                ordinal = default(int);
                return false;
            }

            // Wrap ordinal lookup for the member so that we can throw a nice exception.
            try
            {
                ordinal = storeDataReader.GetOrdinal(columnName);
                return true;
            }
            catch (IndexOutOfRangeException)
            {
                // No column matching the column name found
                ordinal = default(int);
                return false;
            }
        }

        private LogEntry ReadEntry(DbDataReader dataReader)
        {
            var entry = new LogEntry();

            int idOrd = dataReader.GetOrdinal("ID");
            entry.ID = dataReader.GetFieldValue<int>(idOrd);

            int applicationOrd = dataReader.GetOrdinal("Application");
            entry.Application = dataReader.IsDBNull(applicationOrd) ? null : dataReader.GetFieldValue<string>(applicationOrd);

            int machineOrd = dataReader.GetOrdinal("MachineName");
            entry.MachineName = dataReader.IsDBNull(machineOrd) ? null : dataReader.GetFieldValue<string>(machineOrd);

            int timestampOrd = dataReader.GetOrdinal("TimeStamp");
            entry.TimeStamp = dataReader.GetFieldValue<DateTime>(timestampOrd);

            int threadOrd = dataReader.GetOrdinal("Thread");
            entry.Thread = dataReader.IsDBNull(threadOrd) ? null : dataReader.GetFieldValue<string>(threadOrd);

            int levelOrd = dataReader.GetOrdinal("Level");
            entry.Level = dataReader.IsDBNull(levelOrd) ? null : dataReader.GetFieldValue<string>(levelOrd);

            int loggerOrd = dataReader.GetOrdinal("Logger");
            entry.Logger = dataReader.IsDBNull(loggerOrd) ? null : dataReader.GetFieldValue<string>(loggerOrd);

            int messageOrd = dataReader.GetOrdinal("Message");
            entry.Message = dataReader.IsDBNull(messageOrd) ? null : dataReader.GetFieldValue<string>(messageOrd);

            int exceptionOrd = dataReader.GetOrdinal("Exception");
            entry.Exception = dataReader.IsDBNull(exceptionOrd) ? null : dataReader.GetFieldValue<string>(exceptionOrd);

            int ntUserOrd = dataReader.GetOrdinal("NTUser");
            entry.NTUser = dataReader.IsDBNull(ntUserOrd) ? null : dataReader.GetFieldValue<string>(ntUserOrd);

            return entry;
        }

 private int GetColumnOrdinal(UpdateTranslator translator, DbDataReader reader, string columnName)
 {
     int columnOrdinal;
     try
     {
         columnOrdinal = reader.GetOrdinal(columnName);
     }
     catch (IndexOutOfRangeException)
     {
         throw new UpdateException(
             Strings.Update_MissingResultColumn(columnName), null, GetStateEntries(translator).Cast<ObjectStateEntry>().Distinct());
     }
     return columnOrdinal;
 }

 public void Build(DbDataReader reader)
 {
     var tableSchema = reader.GetSchemaTable();
     if (tableSchema == null)
     {
         return;
     }
     FetchTableColumnsName(tableSchema);
     //reader.Read();
     BuildHandle((colName, property) =>
         {
             var propertyType = property.PropertyType;
             var exists = CurrentTableSchemaColumnsName.Find(s => String.Equals(s, colName, StringComparison.InvariantCultureIgnoreCase));
             if (String.IsNullOrWhiteSpace(exists))
             {
                 return false;
             }
             var index = reader.GetOrdinal(exists);
             try
             {
                 if (reader.IsDBNull(index))
                 {
                     return false;
                 }
                 var value = ChangeType(reader.GetValue(index), propertyType);
                 property.SetValue(this, value, null);
             }
             catch (Exception ex)
             {
                 Error.ErrorCode = ErrorMapping.BUSINESS_FFFF;
                 Error.SimpleErrorDescription = ex.Message;
                 return false;
             }
             return true;
         });
 }

 public TimeSpan? ReadTimeSpan(DbDataReader reader, string name)
 {
     int ordinal = reader.GetOrdinal(name);
     return ReadTimeSpan(reader, ordinal);
 }

 public int? ReadInt(DbDataReader reader, string name)
 {
     int ordina = reader.GetOrdinal(name);
     return ReadInt(reader, ordina);
 }

 public DateTime? ReadDateTime(DbDataReader reader, string name)
 {
     int ordinal = reader.GetOrdinal(name);
     return ReadDateTime(reader, ordinal);
 }

 private int GetColumnOrdinal(UpdateTranslator translator, DbDataReader reader, string columnName)
 {
     int columnOrdinal;
     try
     {
         columnOrdinal = reader.GetOrdinal(columnName);
     }
     catch (IndexOutOfRangeException)
     {
         throw EntityUtil.Update(System.Data.Entity.Strings.Update_MissingResultColumn(columnName), null,
             this.GetStateEntries(translator));
     }
     return columnOrdinal;
 }