System.Xml.XmlReader.ReadElementContentAsStringAsync()

Here are the examples of the csharp api System.Xml.XmlReader.ReadElementContentAsStringAsync() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

11 Examples 7

19 Source : DocumentationCache.cs
with MIT License
from fuse-open

static async Task<Dictionary<string, Entry>> LoadCache()
        {
            var doreplacedentation = new Dictionary<string, Entry>();

            using(var fileStream = new FileStream(CacheFilePath, FileMode.Open, FileAccess.Read))
            using (var reader = XmlReader.Create(fileStream, new XmlReaderSettings { Async = true }))
            while (await reader.ReadAsync())
            {
                if (reader.NodeType != XmlNodeType.Element || reader.Name != "Element") continue;

                string key = null;
                string value = null;
                string url = null;
                var hasMoreContent = false;

                using (var subReader = reader.ReadSubtree())
                while (await subReader.ReadAsync())
                {
                    if (subReader.Name == "Key")
                        key = await subReader.ReadElementContentreplacedtringAsync();

                    if (subReader.Name == "Value")
                        value = await subReader.ReadElementContentreplacedtringAsync();

                    if (subReader.Name == "Url")
                        url = await subReader.ReadElementContentreplacedtringAsync();

                    if (subReader.Name == "HasMoreContent")
                        hasMoreContent = subReader.ReadElementContentAsBoolean();
                }

                if (key != null) doreplacedentation.Add(key, new Entry(value, url, hasMoreContent));
            }
            return doreplacedentation;
        }

19 Source : AniDbEpisodeProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task ParseAdditionalEpisodeXml(FileInfo xml, Episode episode, string metadataLanguage)
        {
            var settings = new XmlReaderSettings
            {
                CheckCharacters = false,
                IgnoreProcessingInstructions = true,
                IgnoreComments = true,
                ValidationType = ValidationType.None
            };

            using (var streamReader = xml.OpenText())
            using (var reader = XmlReader.Create(streamReader, settings))
            {
                await reader.MoveToContentAsync().ConfigureAwait(false);

                var replacedles = new List<replacedle>();

                while (await reader.ReadAsync().ConfigureAwait(false))
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                            case "length":
                                var length = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                                if (!string.IsNullOrEmpty(length))
                                {
                                    long duration;
                                    if (long.TryParse(length, out duration))
                                    {
                                        episode.RunTimeTicks += TimeSpan.FromMinutes(duration).Ticks;
                                    }
                                }

                                break;

                            case "replacedle":
                                var language = reader.GetAttribute("xml:lang");
                                var name = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);

                                replacedles.Add(new replacedle
                                {
                                    Language = language,
                                    Type = "main",
                                    Name = name
                                });

                                break;
                        }
                    }
                }

                var replacedle = replacedles.Localize(Plugin.Instance.Configuration.replacedlePreference, metadataLanguage).Name;
                if (!string.IsNullOrEmpty(replacedle))
                {
                    replacedle = ", " + replacedle;
                    episode.Name += Plugin.Instance.Configuration.AniDbReplaceGraves
                        ? replacedle.Replace('`', '\'')
                        : replacedle;
                }
            }
        }

19 Source : AniDbSeriesProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task FetchSeriesInfo(MetadataResult<Series> result, string seriesDataPath, string preferredMetadataLangauge)
        {
            var series = result.Item;
            var settings = new XmlReaderSettings
            {
                Async = true,
                CheckCharacters = false,
                IgnoreProcessingInstructions = true,
                IgnoreComments = true,
                ValidationType = ValidationType.None
            };

            using (var streamReader = File.Open(seriesDataPath, FileMode.Open, FileAccess.Read))
            using (var reader = XmlReader.Create(streamReader, settings))
            {
                await reader.MoveToContentAsync().ConfigureAwait(false);

                while (await reader.ReadAsync().ConfigureAwait(false))
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                            case "startdate":
                                var val = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);

                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    if (DateTime.TryParse(val, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out DateTime date))
                                    {
                                        date = date.ToUniversalTime();
                                        series.PremiereDate = date;
                                    }
                                }

                                break;

                            case "enddate":
                                var endDate = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);

                                if (!string.IsNullOrWhiteSpace(endDate))
                                {
                                    if (DateTime.TryParse(endDate, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out DateTime date))
                                    {
                                        date = date.ToUniversalTime();
                                        series.EndDate = date;
                                    }
                                }

                                break;

                            case "replacedles":
                                using (var subtree = reader.ReadSubtree())
                                {
                                    var replacedle = await Parsereplacedle(subtree, preferredMetadataLangauge).ConfigureAwait(false);
                                    if (!string.IsNullOrEmpty(replacedle))
                                    {
                                        series.Name = Plugin.Instance.Configuration.AniDbReplaceGraves
                                            ? replacedle.Replace('`', '\'')
                                            : replacedle;
                                    }
                                }

                                break;

                            case "creators":
                                using (var subtree = reader.ReadSubtree())
                                {
                                    await ParseCreators(result, subtree).ConfigureAwait(false);
                                }

                                break;

                            case "description":
                                series.Overview = ReplaceLineFeedWithNewLine(
                                    StripAniDbLinks(
                                        await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false)));

                                break;

                            case "ratings":
                                using (var subtree = reader.ReadSubtree())
                                {
                                    ParseRatings(series, subtree);
                                }

                                break;

                            case "resources":
                                using (var subtree = reader.ReadSubtree())
                                {
                                    await ParseResources(series, subtree).ConfigureAwait(false);
                                }

                                break;

                            case "characters":
                                using (var subtree = reader.ReadSubtree())
                                {
                                    await ParseActors(result, subtree).ConfigureAwait(false);
                                }

                                break;

                            case "tags":
                                using (var subtree = reader.ReadSubtree())
                                {
                                    await ParseTags(series, subtree).ConfigureAwait(false);
                                }

                                break;

                            case "episodes":
                                using (var subtree = reader.ReadSubtree())
                                {
                                    await ParseEpisodes(series, subtree).ConfigureAwait(false);
                                }

                                break;
                        }
                    }
                }
            }

            GenreHelper.CleanupGenres(series);
        }

19 Source : AniDbTitleMatcher.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task ReadreplacedlesFile()
        {
            _logger.LogDebug("Loading AniDB replacedles");

            var replacedlesFile = _downloader.replacedlesFilePath;

            var settings = new XmlReaderSettings
            {
                CheckCharacters = false,
                IgnoreProcessingInstructions = true,
                IgnoreComments = true,
                ValidationType = ValidationType.None
            };

            using (var stream = new StreamReader(replacedlesFile, Encoding.UTF8))
            using (var reader = XmlReader.Create(stream, settings))
            {
                string aid = null;

                while (await reader.ReadAsync().ConfigureAwait(false))
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                            case "anime":
                                reader.MoveToAttribute("aid");
                                aid = reader.Value;
                                break;

                            case "replacedle":
                                var replacedle = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                                if (!string.IsNullOrEmpty(aid) && !string.IsNullOrEmpty(replacedle))
                                {
                                    var type = ParseType(reader.GetAttribute("type"));

                                    if (!_replacedles.TryGetValue(replacedle, out replacedleInfo currentreplacedleInfo) || (int)currentreplacedleInfo.Type < (int)type)
                                    {
                                        _replacedles[replacedle] = new replacedleInfo { AniDbId = aid, Type = type, replacedle = replacedle };
                                    }
                                }
                                break;
                        }
                    }
                }
            }

            var comparable = (from pair in _replacedles
                              let comp = GetComparableName(pair.Key)
                              where !_replacedles.ContainsKey(comp)
                              select new { replacedle = comp, Id = pair.Value })
                             .ToArray();

            foreach (var pair in comparable)
            {
                _replacedles[pair.replacedle] = pair.Id;
            }
        }

19 Source : AniDbSeriesProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task ParseTags(Series series, XmlReader reader)
        {
            var genres = new List<GenreInfo>();

            while (await reader.ReadAsync().ConfigureAwait(false))
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "tag")
                {
                    if (!int.TryParse(reader.GetAttribute("weight"), out int weight) || weight < 400)
                    {
                        continue;
                    }

                    if (int.TryParse(reader.GetAttribute("id"), out int id) && IgnoredTagIds.Contains(id))
                    {
                        continue;
                    }

                    if (int.TryParse(reader.GetAttribute("parentid"), out int parentId)
                        && IgnoredTagIds.Contains(parentId))
                    {
                        continue;
                    }

                    using (var tagSubtree = reader.ReadSubtree())
                    {
                        while (await tagSubtree.ReadAsync().ConfigureAwait(false))
                        {
                            if (tagSubtree.NodeType == XmlNodeType.Element && tagSubtree.Name == "name")
                            {
                                var name = await tagSubtree.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                                genres.Add(new GenreInfo { Name = name, Weight = weight });
                            }
                        }
                    }
                }
            }

            series.Genres = genres.OrderBy(g => g.Weight).Select(g => g.Name).ToArray();
        }

19 Source : AniDbSeriesProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task ParseActor(MetadataResult<Series> series, XmlReader reader)
        {
            string name = null;
            string role = null;

            while (await reader.ReadAsync().ConfigureAwait(false))
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                        case "name":
                            role = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                            break;

                        case "seiyuu":
                            name = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                            break;
                    }
                }
            }

            if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(role)) // && series.People.All(p => p.Name != name))
            {
                series.AddPerson(CreatePerson(name, PersonType.Actor, role));
            }
        }

19 Source : AniDbSeriesProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private static async Task<string> ParseEpisodeNumber(string xml)
        {
            var settings = new XmlReaderSettings
            {
                Async = true,
                CheckCharacters = false,
                IgnoreProcessingInstructions = true,
                IgnoreComments = true,
                ValidationType = ValidationType.None
            };

            using (var streamReader = new StringReader(xml))
            {
                // Use XmlReader for best performance
                using (var reader = XmlReader.Create(streamReader, settings))
                {
                    reader.MoveToContent();

                    // Loop through each element
                    while (await reader.ReadAsync().ConfigureAwait(false))
                    {
                        if (reader.NodeType == XmlNodeType.Element)
                        {
                            if (reader.Name == "epno")
                            {
                                var val = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                                if (!string.IsNullOrWhiteSpace(val))
                                {
                                    return val;
                                }
                            }
                            else
                            {
                                await reader.SkipAsync().ConfigureAwait(false);
                            }
                        }
                    }
                }
            }

            return null;
        }

19 Source : AniDbEpisodeProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task ParseEpisodeXml(FileInfo xml, Episode episode, string preferredMetadataLanguage)
        {
            var settings = new XmlReaderSettings
            {
                CheckCharacters = false,
                IgnoreProcessingInstructions = true,
                IgnoreComments = true,
                ValidationType = ValidationType.None
            };

            using (var streamReader = xml.OpenText())
            using (var reader = XmlReader.Create(streamReader, settings))
            {
                await reader.MoveToContentAsync().ConfigureAwait(false);

                var replacedles = new List<replacedle>();

                while (await reader.ReadAsync().ConfigureAwait(false))
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                            case "length":
                                var length = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                                if (!string.IsNullOrEmpty(length))
                                {
                                    long duration;
                                    if (long.TryParse(length, out duration))
                                    {
                                        episode.RunTimeTicks = TimeSpan.FromMinutes(duration).Ticks;
                                    }
                                }

                                break;

                            case "airdate":
                                var airdate = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                                if (!string.IsNullOrEmpty(airdate))
                                {
                                    DateTime date;
                                    if (DateTime.TryParse(airdate, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out date))
                                    {
                                        episode.PremiereDate = date;
                                    }
                                }

                                break;

                            case "rating":
                                int count;
                                float rating;
                                if (int.TryParse(reader.GetAttribute("count"), NumberStyles.Any, CultureInfo.InvariantCulture, out count) &&
                                    float.TryParse(reader.ReadElementContentreplacedtring(), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out rating))
                                {
                                    episode.CommunityRating = rating;
                                }

                                break;

                            case "replacedle":
                                var language = reader.GetAttribute("xml:lang");
                                var name = reader.ReadElementContentreplacedtring();

                                replacedles.Add(new replacedle
                                {
                                    Language = language,
                                    Type = "main",
                                    Name = name
                                });

                                break;
                        }
                    }
                }

                var replacedle = replacedles.Localize(Plugin.Instance.Configuration.replacedlePreference, preferredMetadataLanguage).Name;
                if (!string.IsNullOrEmpty(replacedle))
                {
                    episode.Name = Plugin.Instance.Configuration.AniDbReplaceGraves
                        ? replacedle.Replace('`', '\'')
                        : replacedle;
                }
            }
        }

19 Source : AniDbSeriesProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task ParseResources(Series series, XmlReader reader)
        {
            while (await reader.ReadAsync().ConfigureAwait(false))
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "resource")
                {
                    var type = reader.GetAttribute("type");
                    switch (type)
                    {
                        case "4":
                            while (reader.Read())
                            {
                                if (reader.NodeType == XmlNodeType.Element && reader.Name == "url")
                                {
                                    await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);
                                    break;
                                }
                            }
                            break;
                    }
                }
            }
        }

19 Source : AniDbSeriesProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task<string> Parsereplacedle(XmlReader reader, string preferredMetadataLangauge)
        {
            var replacedles = new List<replacedle>();

            while (await reader.ReadAsync().ConfigureAwait(false))
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "replacedle")
                {
                    var language = reader.GetAttribute("xml:lang");
                    var type = reader.GetAttribute("type");
                    var name = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);

                    replacedles.Add(new replacedle
                    {
                        Language = language,
                        Type = type,
                        Name = name
                    });
                }
            }

            return replacedles.Localize(Plugin.Instance.Configuration.replacedlePreference, preferredMetadataLangauge).Name;
        }

19 Source : AniDbSeriesProvider.cs
with GNU General Public License v2.0
from jellyfin-archive

private async Task ParseCreators(MetadataResult<Series> series, XmlReader reader)
        {
            while (await reader.ReadAsync().ConfigureAwait(false))
            {
                if (reader.NodeType == XmlNodeType.Element && reader.Name == "name")
                {
                    var type = reader.GetAttribute("type");
                    var name = await reader.ReadElementContentreplacedtringAsync().ConfigureAwait(false);

                    if (type == "Animation Work")
                    {
                        series.Item.AddStudio(name);
                    }
                    else
                    {
                        series.AddPerson(CreatePerson(name, type));
                    }
                }
            }
        }