C# SqlDataReader.ReadAsync方法代码示例

        /// <summary>
        /// Maps the gangway event status asynchronous.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>Gangway Event Status</returns>
        internal static async Task<string> MapGangwayEventStatusAsync(SqlDataReader dataReader)
        {
            var value = default(string);
            if (dataReader != null && dataReader.HasRows)
            {
                await dataReader.ReadAsync();
                value = dataReader.StringField(StatusField);
            }

            return value;
        }

        /// <summary>
        /// Maps the ship time data.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>Gets the ship time</returns>
        internal static async Task<ShipTime> MapShipTimeData(SqlDataReader dataReader)
        {
            var shipTime = new ShipTime();
            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    shipTime.ShipId = dataReader.Int16Field(ShipId).ToString();
                    shipTime.UtcOffset = dataReader.Int16Field(UtcOffset);
                }
            }

            return shipTime;
        }

        /// <summary>
        /// Maps the event type list.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>List of Event Type.</returns>
        internal static async Task<ListResult<EventType>> MapEventTypeList(SqlDataReader dataReader)
        {
            var eventTypeList = new ListResult<EventType>();

            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    eventTypeList.Items.Add(await MapEventTypes(dataReader));
                }

                if (!dataReader.IsClosed)
                {
                    dataReader.Close();
                }
            }

            return await Task.FromResult(eventTypeList);
        }

        /// <summary>
        /// Maps the configuration data.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>The component setting collection</returns>
        internal static async Task<ComponentSettingCollection> MapConfigurationData(SqlDataReader dataReader)
        {
            var componentSettingCollection = new ComponentSettingCollection();
            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    var ComponentSettings = new ComponentSetting
                    {
                        Id = dataReader.GuidField(Id).ToString(),
                        Name = dataReader.StringField(Name),
                        Value = dataReader.StringField(Value)
                    };

                    componentSettingCollection.Add(ComponentSettings);
                }
            }

            return componentSettingCollection;
        }

        /// <summary>
        /// Maps the person ids.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>returns personIds</returns>
        internal static async Task<string> MapPersonIds(SqlDataReader dataReader)
        {
            var personIdList = string.Empty;

            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    var personId = dataReader.Int32Field(PersonId);
                    personIdList = string.Concat(personIdList, personId, CommaSeparator);
                }

                if (!dataReader.IsClosed)
                {
                    dataReader.Close();
                }
            }

            return personIdList;
        }

        public async Task<int> LoadSafeReaderAsync(SqlDataReader dr)
        {
            _fieldCount = dr.FieldCount;
            _depth = dr.Depth;

            while (await dr.ReadAsync())
            {

                Dictionary<string, object> row = new Dictionary<string, object>();
                for (int i = 0; i < dr.FieldCount; i++)
                {
                    string name = dr.GetName(i);
                    object value = dr.GetValue(i);
                    row.Add(name, value);
                }
                _data.Add(row);
            }

            return _data.Count();
        }

        /// <summary>
        /// Maps the specified data reader.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>Media Item Address</returns>
        internal static async Task<string> MapMediaItemAddress(SqlDataReader dataReader)
        {
            var mediaItemAddress = string.Empty;

            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    var mediaItemId = dataReader.Int32Field(MediaItemId).ToString();
                    var baseAddress = dataReader.StringField(Mediapath);
                    mediaItemAddress = string.Concat(mediaItemId, CommonConstants.Comma, baseAddress);
                }

                if (!dataReader.IsClosed)
                {
                    dataReader.Close();
                }
            }

            return await Task.FromResult(mediaItemAddress);
        }

 private static async Task ReadQueryResults(SqlDataReader dataReader)
 {
     while (await dataReader.ReadAsync())
     {
         string formatStringWithMiddleName = "Person ({0}) is named {1} {2} {3}";
         string formatStringWithoutMiddleName = "Person ({0}) is named {1} {3}";
         if (dataReader["middlename"] != null)
         {
             Console.WriteLine(formatStringWithoutMiddleName,
                 dataReader["id"],
                 dataReader["firstname"],
                 dataReader["lastname"]);
         }
         else
         {
             Console.WriteLine(formatStringWithMiddleName,
                 dataReader["id"],
                 dataReader["firstname"],
                 dataReader["middlename"],
                 dataReader["lastname"]);
         }
     }
 }

        /// <summary>
        /// Maps the person status.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>Person Status List.</returns>
        internal static async Task<List<PersonStatus>> MapPersonStatus(SqlDataReader dataReader)
        {
            var personStatusList = new List<PersonStatus>();

            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    var personStatus = new PersonStatus();
                    personStatus.PersonId = dataReader.Int32Field(PersonId);
                    personStatus.Status = dataReader.StringField(Status);
                    personStatus.StatusChangedDate = dataReader.DateTimeNullableField(StatusChangedDate);
                    personStatusList.Add(personStatus);
                }

                if (!dataReader.IsClosed)
                {
                    dataReader.Close();
                }
            }

            return personStatusList;
        }

        private static async Task ReadQueryResults(SqlDataReader dataReader)
        {
            while (await dataReader.ReadAsync())
            {
                string formatStringWithMiddleName = "Person ({0}) is named {1} {2} {3}";
                string formatStringWithoutMiddleName = "Person ({0}) is named {1} {3}";

                if ((dataReader["Name"] == null))
                {
                    Console.WriteLine(formatStringWithoutMiddleName,
                        dataReader["Id"],
                        dataReader["Name"],
                        dataReader["Email"]);
                }
                else
                {
                    Console.WriteLine(formatStringWithMiddleName,
                        dataReader["Id"],
                        dataReader["Name"],
                        dataReader["Email"],
                        dataReader["Adress"]);
                }
            }
        }

        /// <summary>
        /// Maps the visitor personal detail.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>Visitor collection</returns>
        private static async Task<VisitorCollection> RetrieveVisitorPersonalDetail(SqlDataReader dataReader)
        {
            var visitors = new VisitorCollection();

            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    var visitor = new Visitor();
                    visitor.VisitorId = dataReader.Int32Field(VisitorId).ToString();
                    visitor.PersonalDetail = new PersonalDetail();
                    visitor.VisitorInfo = new VisitorInfo();
                    visitor.PersonalDetail.Age = dataReader.Int16NullableField(Age);
                    visitor.PersonalDetail.AnniversaryDate = dataReader.DateTimeNullableField(AnniversaryDate);
                    visitor.PersonalDetail.BirthCountryId = dataReader.Int32NullableField(BirthCountryId).ToString();
                    visitor.PersonalDetail.Birthdate = dataReader.DateTimeNullableField(BirthDate);
                    visitor.PersonalDetail.CitizenshipCountryId = dataReader.Int32NullableField(CitizenshipCountryId).ToString();
                    visitor.PersonalDetail.FirstName = dataReader.StringField(FirstName);
                    visitor.PersonalDetail.Gender = dataReader.StringField(Gender);
                    visitor.PersonalDetail.LastName = dataReader.StringField(LastName);
                    visitor.PersonalDetail.MaritalStatus = dataReader.StringField(MaritalStatus);
                    visitor.PersonalDetail.MiddleName = dataReader.StringField(MiddleName);
                    visitor.PersonalDetail.Nickname = dataReader.StringField(NickName);
                    visitor.PersonalDetail.Occupation = dataReader.StringField(Occupation);
                    visitor.PersonalDetail.DocumentNumber = dataReader.StringField(DocumentNumber);
                    visitor.PersonalDetail.Suffix = dataReader.StringField(Suffix);
                    visitor.PersonalDetail.Title = dataReader.StringField(Title);
                    visitor.PersonalDetail.DepartmentName = dataReader.StringField(Department);
                    visitor.PersonalDetail.DepartmentPOC = dataReader.StringField(Contact);
                    visitor.VisitorInfo.CompanyName = dataReader.StringField(Company);
                    visitor.PersonalDetail.DocumentNumber = dataReader.StringField(DocumentNumber);
                    visitor.PersonalDetail.DocumentType = dataReader.StringField(DocumentType);
                    ////visitor.VisitorInfo.ContactNumber = dataReader.StringField(ContactPhoneNumber);
                    visitor.VisitorInfo.CompanyContactNumber = dataReader.StringField(ContactPhoneNumber);
                    visitor.PersonalDetail.DocumentTypeId = dataReader.Int16Field(DocumentTypeId).ToString();
                    visitors.Add(visitor);
                }
            }

            return visitors;
        }

        /// <summary>
        /// Maps the visitors.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>The visitor collection</returns>
        private static async Task<VisitorCollection> MapVisitors(SqlDataReader dataReader)
        {
            var visitors = new VisitorCollection();
            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    var visitor = new Visitor
                    {
                        HasAlert = dataReader.BooleanNullableField(HasAlert).HasValue ? dataReader.BooleanNullableField(HasAlert).Value : false,
                        HasMessage = dataReader.BooleanNullableField(HasMessage).HasValue ? dataReader.BooleanNullableField(HasMessage).Value : false,
                        LastDateTime = dataReader.DateTimeNullableField(LastDateTime),
                        LastEvent = dataReader.StringField(LastEvent),
                        SecurityPhotoAddress = dataReader.StringField(SecurityPhotoAddress),
                        VisitorId = dataReader.Int32Field(VisitorId).ToString(),
                        VisitorTypeId = dataReader.ByteField(VisitorTypeId).ToString(),
                        VisitorType = dataReader.StringField(VisitorType),
                        VisitPurpose = dataReader.StringField(VisitPurpose)
                    };

                    byte[] bytes = await visitor.SecurityPhotoAddress.ImageAddressToByteArray();
                    visitor.Photo = bytes.ToBitmapSource();
                    visitor.AssignPhotoByteArray(new Collection<byte>(bytes));
                    visitors.Add(visitor);
                }
            }

            return visitors;
        }

        /// <summary>
        /// Maps the crew.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>Crew member collection</returns>
        private static async Task<CrewmemberCollection> MapCrew(SqlDataReader dataReader)
        {
            var crewmemberCollection = new CrewmemberCollection();
            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    var crew = new Crewmember();

                    crew.CrewmemberId = dataReader.Int32Field(CrewMemberId).ToString();
                    crew.CrewmemberTypeId = dataReader.ByteField(CrewMemberTypeId).ToString();
                    crew.EmployeeNo = dataReader.StringField(EmployeeNo);
                    var hasAlert = dataReader.BooleanNullableField(HasAlert);
                    var hasMessage = dataReader.BooleanNullableField(HasMessage);
                    crew.HasAlert = hasAlert.HasValue ? hasAlert.Value : false;
                    crew.HasMessage = hasMessage.HasValue ? hasMessage.Value : false;
                    crew.Position = dataReader.StringField(Position);
                    crew.LastDateTime = dataReader.DateTimeNullableField(LastDateTime);
                    crew.LastEvent = dataReader.StringField(LastEvent);
                    crew.SafetyNumber = dataReader.StringField(SafetyNumber);
                    crew.SecurityPhotoAddress = dataReader.StringField(SecurityPhotoAddress);
                    crew.Stateroom = dataReader.StringField(Stateroom);
                    crew.StateroomOccupancy = dataReader.ByteField(StateroomOccupancy).ToString();
                    crew.Department = dataReader.StringField(Department);
                    crew.PortAssignedDate = dataReader.DateTimeNullableField(PortAssignedDate);

                    byte[] bytes = await crew.SecurityPhotoAddress.ImageAddressToByteArray();
                    crew.Photo = bytes.ToBitmapSource();
                    crew.AssignPhotoByteArray(new Collection<byte>(bytes));
                    crewmemberCollection.Add(crew);
                }
            }

            return crewmemberCollection;
        }

        /// <summary>
        /// Maps the guest personal detail.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>Guest Collection.</returns>
        private static async Task<GuestCollection> MapGuests(SqlDataReader dataReader)
        {
            var guestCollection = new GuestCollection();
            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    var guest = new Guest();

                    guest.GuestId = dataReader.Int32Field(GuestId).ToString();
                    var hasAlert = dataReader.BooleanNullableField(HasAlert);
                    guest.HasAlert = hasAlert.HasValue ? hasAlert.Value : false;
                    var hasMessage = dataReader.BooleanNullableField(HasMessage);
                    guest.HasMessage = hasMessage.HasValue ? hasMessage.Value : false;
                    guest.LastDateTime = dataReader.DateTimeNullableField(LastDateTime);
                    guest.LastEvent = dataReader.StringField(LastEvent);
                    guest.SecurityPhotoAddress = dataReader.StringField(SecurityPhotoMediaItemAddress);

                    byte[] bytes = await guest.SecurityPhotoAddress.ImageAddressToByteArray();
                    guest.Photo = bytes.ToBitmapSource();
                    guest.AssignPhotoByteArray(new Collection<byte>(bytes));
                    guestCollection.Add(guest);
                }
            }

            return guestCollection;
        }

        /// <summary>
        /// Maps the gangway history.
        /// </summary>
        /// <param name="dataReader">The data reader.</param>
        /// <returns>List result of Gangway History</returns>
        internal static async Task<ListResult<GangwayHistory>> MapGangwayHistory(SqlDataReader dataReader)
        {
            var historyList = new ListResult<GangwayHistory>();
            var gangwayHistoryCollection = new Collection<GangwayHistory>();

            if (dataReader != null)
            {
                while (await dataReader.ReadAsync())
                {
                    gangwayHistoryCollection.Add(MapHistory(dataReader));
                }

                if (!dataReader.IsClosed)
                {
                    dataReader.Close();
                }
            }

            historyList.AssignItems(gangwayHistoryCollection);
            return await Task.FromResult(historyList);
        }