protected Release ReadRelease(XmlReader reader)
        {
            reader.AssertElementStart(Keys.Release);

            Release release = new Release();
            release.JoinedAlbumArtists = reader.GetAttributeOrNull(Keys.JoinedAlbumArtists);
            release.Title = reader.GetAttributeOrNull(Keys.Title);
            release.ReleaseDate = ReleaseDate.Parse(reader.GetAttributeOrNull(Keys.ReleaseDate));
            release.OriginalReleaseDate = ReleaseDate.Parse(reader.GetAttributeOrNull(Keys.OriginalReleaseDate));
            release.CatalogNumber = reader.GetAttributeOrNull(Keys.CatalogNumber);
            release.Label = reader.GetAttributeOrNull(Keys.Label);
            release.Country = reader.GetAttributeOrNull(Keys.Country);
            release.FlagMessage = reader.GetAttributeOrNull(Keys.FlagMessage);
            release.IsFlagged = release.FlagMessage != null;
            release.Notes = reader.GetAttributeOrNull(Keys.Notes);
            release.WikipediaPageName = reader.GetAttributeOrNull(Keys.WikipediaPageName);

            release.DiscogsReleaseId = reader.GetAttributeInt32(Keys.DiscogsReleaseId, 0);
            release.DiscogsMasterId = reader.GetAttributeInt32(Keys.DiscogsMasterId, 0);
            release.Genre = reader.GetAttributeOrNull(Keys.Genre);
            release.Score = reader.GetAttributeInt32(Keys.Score, 0);
            release.DynamicRange = reader.GetAttributeDouble(Keys.DynamicRange, double.NaN);
            release.ReplayGainAlbumGain = reader.GetAttributeDouble(Keys.AlbumGain, double.NaN);
            release.ReplayGainAlbumPeak = reader.GetAttributeDouble(Keys.AlbumPeak, double.NaN);

            if (reader.GetAttributeOrNull(Keys.DateAdded) != null)
            {
                release.DateAdded = new DateTime(reader.GetAttributeInt64(Keys.DateAdded, 0));
            }
            if (reader.GetAttributeOrNull(Keys.DateAudioModified) != null)
            {
                release.DateAudioModified = new DateTime(reader.GetAttributeInt64(Keys.DateAudioModified, 0));
            }
            if (reader.GetAttributeOrNull(Keys.DateModified) != null)
            {
                release.DateModified = new DateTime(reader.GetAttributeInt64(Keys.DateModified, 0));
            }

            if (reader.IsEmptyElement)
            {
                throw new FormatException(InvalidXmlDatabase);
            }

            while (reader.Read())
            {
                if (reader.IsElementEnd(Keys.Release))
                {
                    break;
                }

                if (reader.IsElementStart(Keys.Artists))
                {
                    this.ReadArtists(reader, release);
                }
                else if (reader.IsElementStart(Keys.Tracks))
                {
                    this.ReadTracks(reader, release);
                }
                else if (reader.IsElementStart(Keys.Images))
                {
                    this.ReadImages(reader, release);
                }
                else if (reader.IsElementStart(Keys.AdditionalFiles))
                {
                    this.ReadAdditionalFiles(reader, release);
                }
            }

            return release;
        }
        private void ReadTrackArtists(XmlReader reader, Track track)
        {
            reader.AssertElementStart(Keys.Artists);

            if (reader.IsEmptyElement)
            {
                throw new FormatException(InvalidXmlDatabase);
            }

            while (reader.Read())
            {
                if (reader.IsElementEnd(Keys.Artists))
                {
                    break;
                }

                reader.AssertElementStart(Keys.Artist);
                track.Artists.Add(new TrackArtist()
                {
                    Artist = this.collectionManager.GetOrCreateArtist(reader.GetAttributeOrNull(Keys.Name)),
                    JoinString = reader.GetAttributeOrNull(Keys.JoinString)
                });
            }
        }
        private void ReadImages(XmlReader reader, Release release)
        {
            reader.AssertElementStart(Keys.Images);

            if (reader.IsEmptyElement)
            {
                return;
            }

            bool skipRead = false;
            while (skipRead || reader.Read())
            {
                skipRead = false;

                if (reader.IsElementEnd(Keys.Images))
                {
                    break;
                }

                reader.AssertElementStart(Keys.Image);
                Image image = new Image()
                {
                    Type = Utility.ParseEnum<ImageType>(reader.GetAttributeOrNull(Keys.Type)),
                    MimeType = reader.GetAttributeOrNull(Keys.MimeType),
                    Extension = reader.GetAttributeOrNull(Keys.Extension),
                    Description = reader.GetAttributeOrNull(Keys.Description),
                    IsMain = bool.Parse(reader.GetAttributeOrNull(Keys.IsMain))
                };
                release.Images.Add(image);

                release.UpdateDynamicProperties();

                this.collectionManager.ImageHandler.StoreImageFromXml(image, reader);

                skipRead = true;
            }
        }
        private Track ReadTrack(XmlReader reader)
        {
            reader.AssertElementStart(Keys.Track);

            Track track = new Track()
            {
                Disc = reader.GetAttributeInt32(Keys.Disc, 0),
                Position = reader.GetAttributeInt32(Keys.Position, 0),
                Title = reader.GetAttributeOrNull(Keys.Title),
                JoinedArtists = reader.GetAttributeOrNull(Keys.JoinedArtists),
                RelativeFilename = reader.GetAttributeOrNull(Keys.RelativeFilename),
                DynamicRange = reader.GetAttributeDouble(Keys.DynamicRange, double.NaN),
                ReplayGainTrackGain = reader.GetAttributeDouble(Keys.TrackGain, double.NaN),
                ReplayGainTrackPeak = reader.GetAttributeDouble(Keys.TrackPeak, double.NaN),
            };

            if (reader.IsEmptyElement)
            {
                return track;
            }

            while (reader.Read())
            {
                if (reader.IsElementEnd(Keys.Track))
                {
                    break;
                }

                if (reader.IsElementStart(Keys.Artists))
                {
                    this.ReadTrackArtists(reader, track);
                }
                else
                {
                    throw new FormatException(InvalidXmlDatabase);
                }
            }

            return track;
        }
        private void ReadAdditionalFiles(XmlReader reader, Release release)
        {
            reader.AssertElementStart(Keys.AdditionalFiles);

            if (reader.IsEmptyElement)
            {
                return;
            }

            bool skipRead = false;
            while (skipRead || reader.Read())
            {
                skipRead = false;

                if (reader.IsElementEnd(Keys.AdditionalFiles))
                {
                    break;
                }

                reader.AssertElementStart(Keys.AdditionalFile);
                ReleaseAdditionalFile file = new ReleaseAdditionalFile()
                {
                    Type = Utility.ParseEnum<ReleaseAdditionalFileType>(reader.GetAttributeOrNull(Keys.Type)),
                    Description = reader.GetAttributeOrNull(Keys.Description),
                    OriginalFilename = reader.GetAttributeOrNull(Keys.OriginalFilename)
                };

                byte[] resultBuffer = new byte[0];
                int read;
                while ((read = reader.ReadElementContentAsBase64(this.readBuffer, 0, this.readBuffer.Length)) > 0)
                {
                    byte[] newResultBuffer = new byte[resultBuffer.Length + read];
                    Array.Copy(resultBuffer, newResultBuffer, resultBuffer.Length);
                    Array.Copy(this.readBuffer, 0, newResultBuffer, resultBuffer.Length, read);
                    resultBuffer = newResultBuffer;
                }
                file.File = resultBuffer;

                release.AdditionalFiles.Add(file);

                skipRead = true;
            }
        }