C# SqlDataReader.GetInt64方法代码示例

        /// <summary>
        /// Loads the entity from a <b>SqlDataReader</b> object.
        /// </summary>
        /// <param name="dr">The data reader to read from.</param>
        /// <returns>Returns the number of columns read.</returns>
        /// <remarks>
        /// Always reads at the current cursor position, doesn't calls the <b>Read</b> function
        /// on the <b>SqlDataReader</b> object. Reads data columns by their ordinal position in
        /// the query and not by their names.
        /// </remarks>
        internal override int LoadFromDataReader(SqlDataReader dr)
        {
            int o = base.LoadFromDataReader(dr);

            ++o;    // skip guid
            this.workflowTypeName = dr.GetString(++o);
            this.dateStarted = dr.IsDBNull(++o) ? DateTime.MinValue : dr.GetDateTime(o);
            this.dateFinished = dr.IsDBNull(++o) ? DateTime.MinValue : dr.GetDateTime(o);
            this.jobExecutionStatus = (JobExecutionState)dr.GetInt32(++o);
            this.suspendTimeout = dr.IsDBNull(++o) ? DateTime.MinValue : dr.GetDateTime(o);
            this.scheduleType = (ScheduleType)dr.GetInt32(++o);
            this.scheduleTime = dr.IsDBNull(++o) ? DateTime.MinValue : dr.GetDateTime(o);
            this.recurringPeriod = (RecurringPeriod)dr.GetInt32(++o);
            this.recurringInterval = dr.GetInt32(++o);
            this.recurringMask = dr.GetInt64(++o);
            this.workflowInstanceId = dr.IsDBNull(++o) ? Guid.Empty : dr.GetGuid(o);
            this.adminRequestTime = dr.IsDBNull(++o) ? DateTime.MinValue : dr.GetDateTime(o);
            if (!dr.IsDBNull(++o))
            {
                XmlSerializer ser = new XmlSerializer(typeof(JobAdminRequestData));
                StringReader sr = new StringReader(dr.GetString(o));
                this.adminRequestData = (JobAdminRequestData)ser.Deserialize(sr);
            }
            else
            {
                this.adminRequestData = null;
            }
            this.adminRequestResult = dr.GetInt32(++o);
            this.exceptionMessage = dr.IsDBNull(++o) ? null : dr.GetString(o);

            return o;
        }

        protected override string getItemKey(SqlDataReader reader)
        {
            var userId = reader.GetInt64(0);
            var friendId = reader.GetInt64(1);

            return String.Format("{0}_{1}", userId, friendId);
        }

        public LoginDB(System.Data.SqlClient.SqlDataReader reader)
        {
            this.reader = reader;
            this.ID = reader.GetInt64(reader.GetOrdinal("Id"));
            this.Login = reader.GetString(reader.GetOrdinal("Login"));
            this.Senha = reader.GetString(reader.GetOrdinal("Senha"));

        }

 private static void FillModelFrom(SqlDataReader reader, DeliveryAddressModel obj)
 {
     #region
     if (reader != null && !reader.IsClosed)
     {
         obj.DeliveryAddressID = reader.IsDBNull(reader.GetOrdinal("DeliveryAddressID")) ? 0 : reader.GetInt64(reader.GetOrdinal("DeliveryAddressID"));
         obj.UserID = reader.IsDBNull(reader.GetOrdinal("UserID")) ? 0 : reader.GetInt64(reader.GetOrdinal("UserID"));
         obj.Consignee = reader.IsDBNull(reader.GetOrdinal("Consignee")) ? String.Empty : reader.GetString(reader.GetOrdinal("Consignee"));
         obj.AreaID = reader.IsDBNull(reader.GetOrdinal("AreaID")) ? 0 : reader.GetInt32(reader.GetOrdinal("AreaID"));
         obj.CityID = reader.IsDBNull(reader.GetOrdinal("CityID")) ? 0 : reader.GetInt32(reader.GetOrdinal("CityID"));
         obj.Address = reader.IsDBNull(reader.GetOrdinal("Address")) ? String.Empty : reader.GetString(reader.GetOrdinal("Address"));
         obj.Postcode = reader.IsDBNull(reader.GetOrdinal("Postcode")) ? String.Empty : reader.GetString(reader.GetOrdinal("Postcode"));
         obj.Phone = reader.IsDBNull(reader.GetOrdinal("Phone")) ? String.Empty : reader.GetString(reader.GetOrdinal("Phone"));
         obj.Mobile = reader.IsDBNull(reader.GetOrdinal("Mobile")) ? String.Empty : reader.GetString(reader.GetOrdinal("Mobile"));
         obj.IsDefault = reader.IsDBNull(reader.GetOrdinal("IsDefault")) ? false : reader.GetBoolean(reader.GetOrdinal("IsDefault"));
     }
     #endregion
 }

 internal static Message Load(SqlDataReader reader) {
     var message = new Message
                       {
                           ConversationGroupId = reader.GetGuid(0),
                           ConversationHandle = reader.GetGuid(1),
                           MessageSequenceNumber = reader.GetInt64(2),
                           ServiceName = reader.GetString(3),
                           ServiceContractName = reader.GetString(4),
                           MessageTypeName = reader.GetString(5),
                           Body = reader.IsDBNull(7) ? new byte[0] : reader.GetSqlBytes(7).Buffer
                       };
     return message;
 }

 private static void FillModelFrom(SqlDataReader reader, UserInfoModel obj)
 {
     #region
     if (reader != null && !reader.IsClosed)
     {
         obj.UserID = reader.IsDBNull(reader.GetOrdinal("UserID")) ? 0 : reader.GetInt64(reader.GetOrdinal("UserID"));
         obj.Email = reader.IsDBNull(reader.GetOrdinal("Email")) ? String.Empty : reader.GetString(reader.GetOrdinal("Email"));
         obj.LoginName = reader.IsDBNull(reader.GetOrdinal("LoginName")) ? String.Empty : reader.GetString(reader.GetOrdinal("LoginName"));
         obj.Password = reader.IsDBNull(reader.GetOrdinal("Password")) ? String.Empty : reader.GetString(reader.GetOrdinal("Password"));
         obj.Sex = reader.IsDBNull(reader.GetOrdinal("Sex")) ? false : reader.GetBoolean(reader.GetOrdinal("Sex"));
         obj.Mobile = reader.IsDBNull(reader.GetOrdinal("Mobile")) ? String.Empty : reader.GetString(reader.GetOrdinal("Mobile"));
         obj.RealName = reader.IsDBNull(reader.GetOrdinal("RealName")) ? String.Empty : reader.GetString(reader.GetOrdinal("RealName"));
     }
     #endregion
 }

 internal static Message Load(SqlDataReader reader) {
     var message = new Message();
     //			RECEIVE conversation_group_id, conversation_handle, 
     //				message_sequence_number, service_name, service_contract_name, 
     //				message_type_name, validation, message_body
     //			FROM Queue
     message.ConversationGroupId = reader.GetGuid(0);
     message.ConversationHandle = reader.GetGuid(1);
     message.MessageSequenceNumber = reader.GetInt64(2);
     message.ServiceName = reader.GetString(3);
     message.ServiceContractName = reader.GetString(4);
     message.MessageTypeName = reader.GetString(5);
     //m_validation = reader.GetString(6);
     if (!reader.IsDBNull(7)) {
         message.Body = reader.GetSqlBytes(7).Buffer;
     } else
         message.Body = new byte[0];
     return message;
 }

 private EventDataRow ReadDataRow(SqlDataReader eventReader)
 {
     return new EventDataRow
            {
                EventJson = eventReader.GetString(1),
                EventType = eventReader.GetInt32(0),
                AggregateRootId = eventReader.GetGuid(2),
                AggregateRootVersion = eventReader[3] as int? ?? eventReader.GetInt32(10),
                EventId = eventReader.GetGuid(4),
                UtcTimeStamp = DateTime.SpecifyKind(eventReader.GetDateTime(5), DateTimeKind.Utc),
                //Without this the datetime will be DateTimeKind.Unspecified and will not convert correctly into Local time....
                InsertionOrder = eventReader.GetInt64(6),
                InsertAfter = eventReader[7] as long?,
                InsertBefore = eventReader[8] as long?,
                Replaces = eventReader[9] as long?,
                InsertedVersion = eventReader.GetInt32(10),
                ManualVersion = eventReader[11] as int?,
                EffectiveVersion = eventReader[3] as int?
     };
 }

        public int LoadFromDataReader(SqlDataReader dr)
        {
            int o = -1;

            this.eventId = dr.GetInt64(++o);
            this.userGuid = dr.GetGuid(++o);
            this.jobGuid = dr.GetGuid(++o);
            this.contextGuid = dr.GetGuid(++o);
            this.eventSource = (EventSource)dr.GetInt32(++o);
            this.eventSeverity = (EventSeverity)dr.GetInt32(++o);
            this.eventDateTime = dr.GetDateTime(++o);
            this.eventOrder = dr.GetInt64(++o);
            this.executionStatus = (ExecutionStatus)dr.GetInt32(++o);
            this.operation = dr.GetString(++o);
            this.entityGuid = dr.GetGuid(++o);
            this.entityGuidFrom = dr.GetGuid(++o);
            this.entityGuidTo = dr.GetGuid(++o);
            this.exceptionType = dr.IsDBNull(++o) ? null : dr.GetString(o);
            this.message = dr.IsDBNull(++o) ? null : dr.GetString(o);
            this.site = dr.IsDBNull(++o) ? null : dr.GetString(o);
            this.stackTrace = dr.IsDBNull(++o) ? null : dr.GetString(o);
            this.exception = null;

            return o;
        }

        protected override Exception ProcessSqlResult(SqlDataReader reader)
        {
            Exception exception = StoreUtilities.GetNextResultSet(this.InstancePersistenceCommand.Name, reader);

            if (exception == null)
            {
                base.InstancePersistenceContext.BindInstanceOwner(this.lockOwnerId, this.lockOwnerId);
                long surrogateLockOwnerId = reader.GetInt64(1);

                // Activatable takes precendence over Runnable.  (Activation owners cannot run instances.)
                if (this.fireActivatableInstancesEvent)
                {
                    base.InstancePersistenceContext.BindEvent(HasActivatableWorkflowEvent.Value);
                }
                else if (this.fireRunnableInstancesEvent)
                {
                    base.InstancePersistenceContext.BindEvent(HasRunnableWorkflowEvent.Value);
                }

                base.StoreLock.MarkInstanceOwnerCreated(this.lockOwnerId, surrogateLockOwnerId, base.InstancePersistenceContext.InstanceHandle, this.fireRunnableInstancesEvent, this.fireActivatableInstancesEvent);
            }

            return exception;
        }

 protected override Exception ProcessSqlResult(SqlDataReader reader)
 {
     Exception nextResultSet = StoreUtilities.GetNextResultSet(base.InstancePersistenceCommand.Name, reader);
     if (nextResultSet == null)
     {
         Guid instanceId = reader.GetGuid(1);
         reader.GetInt64(2);
         byte[] primitiveDataProperties = reader.IsDBNull(3) ? null : ((byte[]) reader.GetValue(3));
         byte[] complexDataProperties = reader.IsDBNull(4) ? null : ((byte[]) reader.GetValue(4));
         byte[] serializedMetadataProperties = reader.IsDBNull(5) ? null : ((byte[]) reader.GetValue(5));
         InstanceEncodingOption @byte = (InstanceEncodingOption) reader.GetByte(6);
         InstanceEncodingOption instanceEncodingOption = (InstanceEncodingOption) reader.GetByte(7);
         long instanceVersion = reader.GetInt64(8);
         bool boolean = reader.GetBoolean(9);
         bool flag2 = reader.GetBoolean(10);
         InstancePersistenceCommand instancePersistenceCommand = base.InstancePersistenceCommand;
         LoadWorkflowByInstanceKeyCommand command = base.InstancePersistenceCommand as LoadWorkflowByInstanceKeyCommand;
         if (!base.InstancePersistenceContext.InstanceView.IsBoundToInstance)
         {
             base.InstancePersistenceContext.BindInstance(instanceId);
         }
         if (!base.InstancePersistenceContext.InstanceView.IsBoundToInstanceOwner)
         {
             base.InstancePersistenceContext.BindInstanceOwner(base.StoreLock.LockOwnerId, base.StoreLock.LockOwnerId);
         }
         if (!base.InstancePersistenceContext.InstanceView.IsBoundToLock)
         {
             ((InstanceLockTracking) base.InstancePersistenceContext.UserContext).TrackStoreLock(instanceId, instanceVersion, base.DependentTransaction);
             base.InstancePersistenceContext.BindAcquiredLock(instanceVersion);
         }
         this.instanceData = SerializationUtilities.DeserializePropertyBag(primitiveDataProperties, complexDataProperties, @byte);
         this.instanceMetadata = SerializationUtilities.DeserializeMetadataPropertyBag(serializedMetadataProperties, instanceEncodingOption);
         if (!flag2)
         {
             this.ReadInstanceMetadataChanges(reader, this.instanceMetadata);
             this.ReadKeyData(reader, this.associatedInstanceKeys, this.completedInstanceKeys);
         }
         else if (command != null)
         {
             foreach (KeyValuePair<Guid, IDictionary<XName, InstanceValue>> pair in command.InstanceKeysToAssociate)
             {
                 this.associatedInstanceKeys.Add(pair.Key, pair.Value);
             }
             if (!this.associatedInstanceKeys.ContainsKey(command.LookupInstanceKey))
             {
                 base.InstancePersistenceContext.AssociatedInstanceKey(command.LookupInstanceKey);
                 this.associatedInstanceKeys.Add(command.LookupInstanceKey, new Dictionary<XName, InstanceValue>());
             }
         }
         if (command != null)
         {
             foreach (KeyValuePair<Guid, IDictionary<XName, InstanceValue>> pair2 in command.InstanceKeysToAssociate)
             {
                 base.InstancePersistenceContext.AssociatedInstanceKey(pair2.Key);
                 if (pair2.Value != null)
                 {
                     foreach (KeyValuePair<XName, InstanceValue> pair3 in pair2.Value)
                     {
                         base.InstancePersistenceContext.WroteInstanceKeyMetadataValue(pair2.Key, pair3.Key, pair3.Value);
                     }
                 }
             }
         }
         base.InstancePersistenceContext.LoadedInstance(boolean ? InstanceState.Initialized : InstanceState.Uninitialized, this.instanceData, this.instanceMetadata, this.associatedInstanceKeys, this.completedInstanceKeys);
         return nextResultSet;
     }
     if (nextResultSet is InstanceLockLostException)
     {
         base.InstancePersistenceContext.InstanceHandle.Free();
     }
     return nextResultSet;
 }

        private static MembershipEntry ConvertFromRow(SqlDataReader results, out string eTag, out int tableVersion, out string versionETag)
        {
            var entry = new MembershipEntry();

            int port = results.GetInt32(PortIdx);
            int gen = results.GetInt32(GenerationIdx);
            entry.SiloAddress = SiloAddress.New(new IPEndPoint(IPAddress.Parse(results.GetString(AddressIdx)), port), gen);

            entry.HostName = results.GetString(HostNameIdx);
            entry.Status = (SiloStatus)results.GetInt32(StatusIdx);
            if (!results.GetSqlInt32(ProxyPortIdx).IsNull)
                entry.ProxyPort = results.GetInt32(ProxyPortIdx);
            if (!results.GetSqlBoolean(PrimaryIdx).IsNull)
                entry.IsPrimary = results.GetBoolean(PrimaryIdx);

            entry.RoleName = results.GetString(RoleNameIdx);
            entry.InstanceName = results.GetString(InstanceNameIdx);
            if (!results.GetSqlInt32(UpdateZoneIdx).IsNull)
                entry.UpdateZone = results.GetInt32(UpdateZoneIdx);
            if (!results.GetSqlInt32(FaultZoneIdx).IsNull)
                entry.FaultZone = results.GetInt32(FaultZoneIdx);

            if (!results.GetSqlDateTime(StartTimeIdx).IsNull)
                entry.StartTime = results.GetDateTime(StartTimeIdx);
            if (!results.GetSqlDateTime(IAmAliveTimeIdx).IsNull)
                entry.IAmAliveTime = results.GetDateTime(IAmAliveTimeIdx);
            eTag = results.GetString(ETagIdx);
            tableVersion = (int)results.GetInt64(VersionIdx);
            versionETag = results.GetString(VersionETagIdx);

            var suspectingSilosString = results.GetSqlString(SuspectingSilosIdx);
            var suspectingTimesString = results.GetSqlString(SuspectingTimesIdx);

            List<SiloAddress> suspectingSilos = new List<SiloAddress>();
            List<DateTime> suspectingTimes = new List<DateTime>();
            if (!suspectingSilosString.IsNull && !string.IsNullOrEmpty(suspectingSilosString.Value))
            {
                string[] silos = suspectingSilosString.Value.Split('|');
                foreach (string silo in silos)
                {
                    suspectingSilos.Add(SiloAddress.FromParsableString(silo));
                }
            }

            if (!suspectingTimesString.IsNull && !string.IsNullOrEmpty(suspectingTimesString.Value))
            {
                string[] times = suspectingTimesString.Value.Split('|');
                foreach (string time in times)
                {
                    suspectingTimes.Add(TraceLogger.ParseDate(time));
                }
            }

            if (suspectingSilos.Count != suspectingTimes.Count)
                throw new OrleansException(String.Format("SuspectingSilos.Length of {0} as read from SQL table is not eqaul to SuspectingTimes.Length of {1}", suspectingSilos.Count, suspectingTimes.Count));

            for (int i = 0; i < suspectingSilos.Count; i++)
            {
                entry.AddSuspector(suspectingSilos[i], suspectingTimes[i]);
            }
            return entry;
        }

        private static void ReadLookupTableRows(LookupTable ratingTable, SqlDataReader reader)
        {
            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    var LookupTableRow = new LookupTableRow();
                    var index = 0;
                    LookupTableRow.RowId = reader.GetInt64(index++).ToString();
                    LookupTableRow.ChangeId = reader.GetGuid(index++).ToString();
                    LookupTableRow.EffectiveDate = reader.GetDateTime(index++);
                    LookupTableRow.Active = reader.GetBoolean(index++);

                    foreach (var key in ratingTable.Keys)
                    {
                        var value = reader.GetString(index);
                        if (value.Contains("::"))
                        {
                            var lhValues = value.Split("::".ToCharArray(),
                                                       StringSplitOptions.RemoveEmptyEntries);
                            LookupTableRow.KeyValues.Add(new LookupTableKey(lhValues[0],
                                                                            lhValues[1]));
                        }
                        else
                        {
                            LookupTableRow.KeyValues.Add(new LookupTableKey(value, null));
                        }

                        index++;
                    }
                    foreach (var column in ratingTable.Columns)
                    {
                        LookupTableRow.ColumnValues.Add(column.Name, reader.GetString(index));
                        index++;
                    }
                    ratingTable.Rows.Add(LookupTableRow);
                }
            }
        }

 public static string getFieldValue(SqlDataReader dr, int ind, string def)
 {
     string val = def;
     if (!dr.IsDBNull(ind))
     {
         switch (System.Type.GetTypeCode(dr.GetFieldType(ind)))
         {
             case System.TypeCode.Boolean:
                 val = (dr.GetBoolean(ind) ? "1" : "0");
                 break;
             case System.TypeCode.Int16:
                 val = dr.GetInt16(ind).ToString();
                 break;
             case System.TypeCode.Int32:
                 val = dr.GetInt32(ind).ToString();
                 break;
             case System.TypeCode.Int64:
                 val = dr.GetInt64(ind).ToString();
                 break;
             case System.TypeCode.Single:
                 val = dr.GetFloat(ind).ToString();
                 break;
             case System.TypeCode.Double:
                 val = dr.GetDouble(ind).ToString();
                 break;
             case System.TypeCode.Decimal:
                 val = dr.GetDecimal(ind).ToString();
                 break;
             case System.TypeCode.DateTime:
                 val = DBManagerSQL.DBDateToFormatedDate(dr.GetDateTime(ind));
                 break;
             case System.TypeCode.String:
                 val = dr.GetString(ind);
                 break;
         }
     }
     return val;
 }

 protected Int64 getRsInt64(SqlDataReader cReader, int idx)
 {
     try
     {
         if (cReader[idx] != null)
         {
             return cReader.GetInt64(idx);
         }
         else
         {
             return 0;
         }
     }
     catch
     {
         return 0;
     }
 }