Merge branch 'jellyfin:master' into master

16 files changed, 1073 insertions, 864 deletions

diff --git a/MediaBrowser.LocalMetadata/BaseXmlProvider.cs b/MediaBrowser.LocalMetadata/BaseXmlProvider.cs
index a6553563f..9f8e921b4 100644
--- a/MediaBrowser.LocalMetadata/BaseXmlProvider.cs
+++ b/MediaBrowser.LocalMetadata/BaseXmlProvider.cs
@@ -7,12 +7,43 @@ using MediaBrowser.Model.IO;
 
 namespace MediaBrowser.LocalMetadata
 {
+    /// <summary>
+    /// The BaseXmlProvider.
+    /// </summary>
+    /// <typeparam name="T">Type of provider.</typeparam>
     public abstract class BaseXmlProvider<T> : ILocalMetadataProvider<T>, IHasItemChangeMonitor, IHasOrder
         where T : BaseItem, new()
     {
-        protected IFileSystem FileSystem;
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseXmlProvider{T}"/> class.
+        /// </summary>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        protected BaseXmlProvider(IFileSystem fileSystem)
+        {
+            this.FileSystem = fileSystem;
+        }
+
+        /// <inheritdoc />
+        public string Name => XmlProviderUtils.Name;
 
-        public Task<MetadataResult<T>> GetMetadata(ItemInfo info,
+        /// After Nfo
+        /// <inheritdoc />
+        public virtual int Order => 1;
+
+        /// <summary>
+        /// Gets the IFileSystem.
+        /// </summary>
+        protected IFileSystem FileSystem { get; }
+
+        /// <summary>
+        /// Gets metadata for item.
+        /// </summary>
+        /// <param name="info">The item info.</param>
+        /// <param name="directoryService">Instance of the <see cref="IDirectoryService"/> interface.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The metadata for item.</returns>
+        public Task<MetadataResult<T>> GetMetadata(
+            ItemInfo info,
             IDirectoryService directoryService,
             CancellationToken cancellationToken)
         {
@@ -46,15 +77,23 @@ namespace MediaBrowser.LocalMetadata
             return Task.FromResult(result);
         }
 
+        /// <summary>
+        /// Get metadata from path.
+        /// </summary>
+        /// <param name="result">Resulting metadata.</param>
+        /// <param name="path">The path.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
         protected abstract void Fetch(MetadataResult<T> result, string path, CancellationToken cancellationToken);
 
-        protected BaseXmlProvider(IFileSystem fileSystem)
-        {
-            FileSystem = fileSystem;
-        }
-
-        protected abstract FileSystemMetadata GetXmlFile(ItemInfo info, IDirectoryService directoryService);
+        /// <summary>
+        /// Get metadata from xml file.
+        /// </summary>
+        /// <param name="info">Item inf.</param>
+        /// <param name="directoryService">Instance of the <see cref="IDirectoryService"/> interface.</param>
+        /// <returns>The file system metadata.</returns>
+        protected abstract FileSystemMetadata? GetXmlFile(ItemInfo info, IDirectoryService directoryService);
 
+        /// <inheritdoc />
         public bool HasChanged(BaseItem item, IDirectoryService directoryService)
         {
             var file = GetXmlFile(new ItemInfo(item), directoryService);
@@ -66,15 +105,5 @@ namespace MediaBrowser.LocalMetadata
 
             return file.Exists && FileSystem.GetLastWriteTimeUtc(file) > item.DateLastSaved;
         }
-
-        public string Name => XmlProviderUtils.Name;
-
-        //After Nfo
-        public virtual int Order => 1;
-    }
-
-    static class XmlProviderUtils
-    {
-        public static string Name => "Emby Xml";
     }
 }
diff --git a/MediaBrowser.LocalMetadata/Images/CollectionFolderImageProvider.cs b/MediaBrowser.LocalMetadata/Images/CollectionFolderLocalImageProvider.cs
index 206e761bb..b6189bcdd 100644
--- a/MediaBrowser.LocalMetadata/Images/CollectionFolderImageProvider.cs
+++ b/MediaBrowser.LocalMetadata/Images/CollectionFolderLocalImageProvider.cs
@@ -5,30 +5,41 @@ using MediaBrowser.Model.IO;
 
 namespace MediaBrowser.LocalMetadata.Images
 {
-    public class CollectionFolderLocalImageProvider : ILocalImageFileProvider, IHasOrder
+    /// <summary>
+    /// Collection folder local image provider.
+    /// </summary>
+    public class CollectionFolderLocalImageProvider : ILocalImageProvider, IHasOrder
     {
         private readonly IFileSystem _fileSystem;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CollectionFolderLocalImageProvider"/> class.
+        /// </summary>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
         public CollectionFolderLocalImageProvider(IFileSystem fileSystem)
         {
             _fileSystem = fileSystem;
         }
 
+        /// <inheritdoc />
         public string Name => "Collection Folder Images";
 
+        /// Run after LocalImageProvider
+        /// <inheritdoc />
+        public int Order => 1;
+
+        /// <inheritdoc />
         public bool Supports(BaseItem item)
         {
             return item is CollectionFolder && item.SupportsLocalMetadata;
         }
 
-        // Run after LocalImageProvider
-        public int Order => 1;
-
-        public List<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService)
+        /// <inheritdoc />
+        public IEnumerable<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService)
         {
             var collectionFolder = (CollectionFolder)item;
 
-            return new LocalImageProvider(_fileSystem).GetImages(item, collectionFolder.PhysicalLocations, true, directoryService);
+            return new LocalImageProvider(_fileSystem).GetImages(item, collectionFolder.PhysicalLocations, directoryService);
         }
     }
 }
diff --git a/MediaBrowser.LocalMetadata/Images/EpisodeLocalImageProvider.cs b/MediaBrowser.LocalMetadata/Images/EpisodeLocalImageProvider.cs
index 443f3fbb5..dc13bf4f6 100644
--- a/MediaBrowser.LocalMetadata/Images/EpisodeLocalImageProvider.cs
+++ b/MediaBrowser.LocalMetadata/Images/EpisodeLocalImageProvider.cs
@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using Jellyfin.Extensions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Providers;
@@ -10,38 +11,42 @@ using MediaBrowser.Model.IO;
 
 namespace MediaBrowser.LocalMetadata.Images
 {
-    public class EpisodeLocalLocalImageProvider : ILocalImageFileProvider, IHasOrder
+    /// <summary>
+    /// Episode local image provider.
+    /// </summary>
+    public class EpisodeLocalImageProvider : ILocalImageProvider, IHasOrder
     {
-        private readonly IFileSystem _fileSystem;
-
-        public EpisodeLocalLocalImageProvider(IFileSystem fileSystem)
-        {
-            _fileSystem = fileSystem;
-        }
-
+        /// <inheritdoc />
         public string Name => "Local Images";
 
+        /// <inheritdoc />
         public int Order => 0;
 
+        /// <inheritdoc />
         public bool Supports(BaseItem item)
         {
             return item is Episode && item.SupportsLocalMetadata;
         }
 
-        public List<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService)
+        /// <inheritdoc />
+        public IEnumerable<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService)
         {
             var parentPath = Path.GetDirectoryName(item.Path);
+            if (parentPath == null)
+            {
+                return Enumerable.Empty<LocalImageInfo>();
+            }
 
             var parentPathFiles = directoryService.GetFiles(parentPath);
 
-            var nameWithoutExtension = Path.GetFileNameWithoutExtension(item.Path);
+            var nameWithoutExtension = Path.GetFileNameWithoutExtension(item.Path.AsSpan());
 
             return GetFilesFromParentFolder(nameWithoutExtension, parentPathFiles);
         }
 
-        private List<LocalImageInfo> GetFilesFromParentFolder(string filenameWithoutExtension, List<FileSystemMetadata> parentPathFiles)
+        private List<LocalImageInfo> GetFilesFromParentFolder(ReadOnlySpan<char> filenameWithoutExtension, List<FileSystemMetadata> parentPathFiles)
         {
-            var thumbName = filenameWithoutExtension + "-thumb";
+            var thumbName = string.Concat(filenameWithoutExtension, "-thumb");
 
             var list = new List<LocalImageInfo>(1);
 
@@ -52,29 +57,21 @@ namespace MediaBrowser.LocalMetadata.Images
                     continue;
                 }
 
-                if (BaseItem.SupportedImageExtensions.Contains(i.Extension, StringComparer.OrdinalIgnoreCase))
+                if (BaseItem.SupportedImageExtensions.Contains(i.Extension.AsSpan(), StringComparison.OrdinalIgnoreCase))
                 {
-                    var currentNameWithoutExtension = _fileSystem.GetFileNameWithoutExtension(i);
+                    var currentNameWithoutExtension = Path.GetFileNameWithoutExtension(i.FullName.AsSpan());
 
-                    if (string.Equals(filenameWithoutExtension, currentNameWithoutExtension, StringComparison.OrdinalIgnoreCase))
+                    if (filenameWithoutExtension.Equals(currentNameWithoutExtension, StringComparison.OrdinalIgnoreCase))
                     {
-                        list.Add(new LocalImageInfo
-                        {
-                            FileInfo = i,
-                            Type = ImageType.Primary
-                        });
+                        list.Add(new LocalImageInfo { FileInfo = i, Type = ImageType.Primary });
                     }
-
-                    else if (string.Equals(thumbName, currentNameWithoutExtension, StringComparison.OrdinalIgnoreCase))
+                    else if (currentNameWithoutExtension.Equals(thumbName, StringComparison.OrdinalIgnoreCase))
                     {
-                        list.Add(new LocalImageInfo
-                        {
-                            FileInfo = i,
-                            Type = ImageType.Primary
-                        });
+                        list.Add(new LocalImageInfo { FileInfo = i, Type = ImageType.Primary });
                     }
                 }
             }
+
             return list;
         }
     }
diff --git a/MediaBrowser.LocalMetadata/Images/InternalMetadataFolderImageProvider.cs b/MediaBrowser.LocalMetadata/Images/InternalMetadataFolderImageProvider.cs
index c0706ceeb..10d691b3e 100644
--- a/MediaBrowser.LocalMetadata/Images/InternalMetadataFolderImageProvider.cs
+++ b/MediaBrowser.LocalMetadata/Images/InternalMetadataFolderImageProvider.cs
@@ -1,26 +1,48 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.IO;
+using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Images
 {
-    public class InternalMetadataFolderImageProvider : ILocalImageFileProvider, IHasOrder
+    /// <summary>
+    /// Internal metadata folder image provider.
+    /// </summary>
+    public class InternalMetadataFolderImageProvider : ILocalImageProvider, IHasOrder
     {
         private readonly IServerConfigurationManager _config;
         private readonly IFileSystem _fileSystem;
+        private readonly ILogger<InternalMetadataFolderImageProvider> _logger;
 
-        public InternalMetadataFolderImageProvider(IServerConfigurationManager config, IFileSystem fileSystem)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InternalMetadataFolderImageProvider"/> class.
+        /// </summary>
+        /// <param name="config">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger{InternalMetadataFolderImageProvider}"/> interface.</param>
+        public InternalMetadataFolderImageProvider(
+            IServerConfigurationManager config,
+            IFileSystem fileSystem,
+            ILogger<InternalMetadataFolderImageProvider> logger)
         {
             _config = config;
             _fileSystem = fileSystem;
+            _logger = logger;
         }
 
+        /// Make sure this is last so that all other locations are scanned first
+        /// <inheritdoc />
+        public int Order => 1000;
+
+        /// <inheritdoc />
         public string Name => "Internal Images";
 
+        /// <inheritdoc />
         public bool Supports(BaseItem item)
         {
             if (item is Photo)
@@ -46,20 +68,25 @@ namespace MediaBrowser.LocalMetadata.Images
 
             return true;
         }
-        // Make sure this is last so that all other locations are scanned first
-        public int Order => 1000;
 
-        public List<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService)
+        /// <inheritdoc />
+        public IEnumerable<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService)
         {
             var path = item.GetInternalMetadataPath();
 
+            if (!Directory.Exists(path))
+            {
+                return Enumerable.Empty<LocalImageInfo>();
+            }
+
             try
             {
-                return new LocalImageProvider(_fileSystem).GetImages(item, path, false, directoryService);
+                return new LocalImageProvider(_fileSystem).GetImages(item, path, directoryService);
             }
-            catch (IOException)
+            catch (IOException ex)
             {
-                return new List<LocalImageInfo>();
+                _logger.LogError(ex, "Error while getting images for {Library}", item.Name);
+                return Enumerable.Empty<LocalImageInfo>();
             }
         }
     }
diff --git a/MediaBrowser.LocalMetadata/Images/LocalImageProvider.cs b/MediaBrowser.LocalMetadata/Images/LocalImageProvider.cs
index 1a7654bfd..988581df9 100644
--- a/MediaBrowser.LocalMetadata/Images/LocalImageProvider.cs
+++ b/MediaBrowser.LocalMetadata/Images/LocalImageProvider.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
@@ -12,24 +13,74 @@ using MediaBrowser.Model.IO;
 
 namespace MediaBrowser.LocalMetadata.Images
 {
-    public class LocalImageProvider : ILocalImageFileProvider, IHasOrder
+    /// <summary>
+    /// Local image provider.
+    /// </summary>
+    public class LocalImageProvider : ILocalImageProvider, IHasOrder
     {
+        private static readonly string[] _commonImageFileNames =
+        {
+            "poster",
+            "folder",
+            "cover",
+            "default"
+        };
+
+        private static readonly string[] _musicImageFileNames =
+        {
+            "folder",
+            "poster",
+            "cover",
+            "default"
+        };
+
+        private static readonly string[] _personImageFileNames =
+        {
+            "folder",
+            "poster"
+        };
+
+        private static readonly string[] _seriesImageFileNames =
+        {
+            "poster",
+            "folder",
+            "cover",
+            "default",
+            "show"
+        };
+
+        private static readonly string[] _videoImageFileNames =
+        {
+            "poster",
+            "folder",
+            "cover",
+            "default",
+            "movie"
+        };
+
         private readonly IFileSystem _fileSystem;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LocalImageProvider"/> class.
+        /// </summary>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
         public LocalImageProvider(IFileSystem fileSystem)
         {
             _fileSystem = fileSystem;
         }
 
+        /// <inheritdoc />
         public string Name => "Local Images";
 
+        /// <inheritdoc />
         public int Order => 0;
 
+        /// <inheritdoc />
         public bool Supports(BaseItem item)
         {
             if (item.SupportsLocalMetadata)
             {
-                // Episode has it's own provider
+                // Episode has its own provider
                 if (item is Episode || item is Audio || item is Photo)
                 {
                     return false;
@@ -41,15 +92,10 @@ namespace MediaBrowser.LocalMetadata.Images
             if (item.LocationType == LocationType.Virtual)
             {
                 var season = item as Season;
-
-                if (season != null)
+                var series = season?.Series;
+                if (series != null && series.IsFileProtocol)
                 {
-                    var series = season.Series;
-
-                    if (series != null && series.IsFileProtocol)
-                    {
-                        return true;
-                    }
+                    return true;
                 }
             }
 
@@ -60,11 +106,17 @@ namespace MediaBrowser.LocalMetadata.Images
         {
             if (!item.IsFileProtocol)
             {
-                return new List<FileSystemMetadata>();
+                return Enumerable.Empty<FileSystemMetadata>();
             }
 
             var path = item.ContainingFolderPath;
 
+            // Exit if the cache dir does not exist, alternative solution is to create it, but that's a lot of empty dirs...
+            if (!Directory.Exists(path))
+            {
+                return Enumerable.Empty<FileSystemMetadata>();
+            }
+
             if (includeDirectories)
             {
                 return directoryService.GetFileSystemEntries(path)
@@ -78,7 +130,8 @@ namespace MediaBrowser.LocalMetadata.Images
                 .OrderBy(i => Array.IndexOf(BaseItem.SupportedImageExtensions, i.Extension ?? string.Empty));
         }
 
-        public List<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService)
+        /// <inheritdoc />
+        public IEnumerable<LocalImageInfo> GetImages(BaseItem item, IDirectoryService directoryService)
         {
             var files = GetFiles(item, true, directoryService).ToList();
 
@@ -89,12 +142,26 @@ namespace MediaBrowser.LocalMetadata.Images
             return list;
         }
 
-        public List<LocalImageInfo> GetImages(BaseItem item, string path, bool isPathInMediaFolder, IDirectoryService directoryService)
+        /// <summary>
+        /// Get images for item.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="path">The images path.</param>
+        /// <param name="directoryService">Instance of the <see cref="IDirectoryService"/> interface.</param>
+        /// <returns>The local image info.</returns>
+        public IEnumerable<LocalImageInfo> GetImages(BaseItem item, string path, IDirectoryService directoryService)
         {
-            return GetImages(item, new[] { path }, isPathInMediaFolder, directoryService);
+            return GetImages(item, new[] { path }, directoryService);
         }
 
-        public List<LocalImageInfo> GetImages(BaseItem item, IEnumerable<string> paths, bool arePathsInMediaFolders, IDirectoryService directoryService)
+        /// <summary>
+        /// Get images for item from multiple paths.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="paths">The image paths.</param>
+        /// <param name="directoryService">Instance of the <see cref="IDirectoryService"/> interface.</param>
+        /// <returns>The local image info.</returns>
+        public IEnumerable<LocalImageInfo> GetImages(BaseItem item, IEnumerable<string> paths, IDirectoryService directoryService)
         {
             IEnumerable<FileSystemMetadata> files = paths.SelectMany(i => _fileSystem.GetFiles(i, BaseItem.SupportedImageExtensions, true, false));
 
@@ -112,9 +179,7 @@ namespace MediaBrowser.LocalMetadata.Images
         {
             if (supportParentSeriesFiles)
             {
-                var season = item as Season;
-
-                if (season != null)
+                if (item is Season season)
                 {
                     PopulateSeasonImagesFromSeriesFolder(season, images, directoryService);
                 }
@@ -189,7 +254,7 @@ namespace MediaBrowser.LocalMetadata.Images
 
             if (!isEpisode && !isSong && !isPerson)
             {
-                PopulateBackdrops(item, images, files, imagePrefix, isInMixedFolder, directoryService);
+                PopulateBackdrops(item, images, files, imagePrefix, isInMixedFolder);
             }
 
             if (item is IHasScreenshots)
@@ -198,46 +263,6 @@ namespace MediaBrowser.LocalMetadata.Images
             }
         }
 
-        private static readonly string[] CommonImageFileNames = new[]
-        {
-            "poster",
-            "folder",
-            "cover",
-            "default"
-        };
-
-        private static readonly string[] MusicImageFileNames = new[]
-        {
-            "folder",
-            "poster",
-            "cover",
-            "default"
-        };
-
-        private static readonly string[] PersonImageFileNames = new[]
-        {
-            "folder",
-            "poster"
-        };
-
-        private static readonly string[] SeriesImageFileNames = new[]
-        {
-            "poster",
-            "folder",
-            "cover",
-            "default",
-            "show"
-        };
-
-        private static readonly string[] VideoImageFileNames = new[]
-        {
-            "poster",
-            "folder",
-            "cover",
-            "default",
-            "movie"
-        };
-
         private void PopulatePrimaryImages(BaseItem item, List<LocalImageInfo> images, List<FileSystemMetadata> files, string imagePrefix, bool isInMixedFolder)
         {
             string[] imageFileNames;
@@ -245,24 +270,24 @@ namespace MediaBrowser.LocalMetadata.Images
             if (item is MusicAlbum || item is MusicArtist || item is PhotoAlbum)
             {
                 // these prefer folder
-                imageFileNames = MusicImageFileNames;
+                imageFileNames = _musicImageFileNames;
             }
             else if (item is Person)
             {
                 // these prefer folder
-                imageFileNames = PersonImageFileNames;
+                imageFileNames = _personImageFileNames;
             }
             else if (item is Series)
             {
-                imageFileNames = SeriesImageFileNames;
+                imageFileNames = _seriesImageFileNames;
             }
-            else if (item is Video && !(item is Episode))
+            else if (item is Video && item is not Episode)
             {
-                imageFileNames = VideoImageFileNames;
+                imageFileNames = _videoImageFileNames;
             }
             else
             {
-                imageFileNames = CommonImageFileNames;
+                imageFileNames = _commonImageFileNames;
             }
 
             var fileNameWithoutExtension = item.FileNameWithoutExtension;
@@ -294,7 +319,7 @@ namespace MediaBrowser.LocalMetadata.Images
             }
         }
 
-        private void PopulateBackdrops(BaseItem item, List<LocalImageInfo> images, List<FileSystemMetadata> files, string imagePrefix, bool isInMixedFolder, IDirectoryService directoryService)
+        private void PopulateBackdrops(BaseItem item, List<LocalImageInfo> images, List<FileSystemMetadata> files, string imagePrefix, bool isInMixedFolder)
         {
             if (!string.IsNullOrEmpty(item.Path))
             {
@@ -321,13 +346,13 @@ namespace MediaBrowser.LocalMetadata.Images
 
             if (extraFanartFolder != null)
             {
-                PopulateBackdropsFromExtraFanart(extraFanartFolder.FullName, images, directoryService);
+                PopulateBackdropsFromExtraFanart(extraFanartFolder.FullName, images);
             }
 
             PopulateBackdrops(images, files, imagePrefix, "backdrop", "backdrop", isInMixedFolder, ImageType.Backdrop);
         }
 
-        private void PopulateBackdropsFromExtraFanart(string path, List<LocalImageInfo> images, IDirectoryService directoryService)
+        private void PopulateBackdropsFromExtraFanart(string path, List<LocalImageInfo> images)
         {
             var imageFiles = _fileSystem.GetFiles(path, BaseItem.SupportedImageExtensions, false, false);
 
@@ -388,8 +413,6 @@ namespace MediaBrowser.LocalMetadata.Images
             }
         }
 
-        private readonly CultureInfo _usCulture = new CultureInfo("en-US");
-
         private void PopulateSeasonImagesFromSeriesFolder(Season season, List<LocalImageInfo> images, IDirectoryService directoryService)
         {
             var seasonNumber = season.IndexNumber;
@@ -403,13 +426,13 @@ namespace MediaBrowser.LocalMetadata.Images
             var seriesFiles = GetFiles(series, false, directoryService).ToList();
 
             // Try using the season name
-            var prefix = season.Name.ToLowerInvariant().Replace(" ", string.Empty);
+            var prefix = season.Name.Replace(" ", string.Empty, StringComparison.Ordinal).ToLowerInvariant();
 
             var filenamePrefixes = new List<string> { prefix };
 
             var seasonMarker = seasonNumber.Value == 0
                                    ? "-specials"
-                                   : seasonNumber.Value.ToString("00", _usCulture);
+                                   : seasonNumber.Value.ToString("00", CultureInfo.InvariantCulture);
 
             // Get this one directly from the file system since we have to go up a level
             if (!string.Equals(prefix, seasonMarker, StringComparison.OrdinalIgnoreCase))
@@ -441,7 +464,7 @@ namespace MediaBrowser.LocalMetadata.Images
             return added;
         }
 
-        private bool AddImage(IEnumerable<FileSystemMetadata> files, List<LocalImageInfo> images, string name, ImageType type)
+        private bool AddImage(List<FileSystemMetadata> files, List<LocalImageInfo> images, string name, ImageType type)
         {
             var image = GetImage(files, name);
 
@@ -459,9 +482,20 @@ namespace MediaBrowser.LocalMetadata.Images
             return false;
         }
 
-        private FileSystemMetadata GetImage(IEnumerable<FileSystemMetadata> files, string name)
+        private static FileSystemMetadata? GetImage(IReadOnlyList<FileSystemMetadata> files, string name)
         {
-            return files.FirstOrDefault(i => !i.IsDirectory && string.Equals(name, _fileSystem.GetFileNameWithoutExtension(i), StringComparison.OrdinalIgnoreCase) && i.Length > 0);
+            for (var i = 0; i < files.Count; i++)
+            {
+                var file = files[i];
+                if (!file.IsDirectory
+                    && file.Length > 0
+                    && Path.GetFileNameWithoutExtension(file.FullName.AsSpan()).Equals(name, StringComparison.OrdinalIgnoreCase))
+                {
+                    return file;
+                }
+            }
+
+            return null;
         }
     }
 }
diff --git a/MediaBrowser.LocalMetadata/MediaBrowser.LocalMetadata.csproj b/MediaBrowser.LocalMetadata/MediaBrowser.LocalMetadata.csproj
index 867b82ede..a3db717b9 100644
--- a/MediaBrowser.LocalMetadata/MediaBrowser.LocalMetadata.csproj
+++ b/MediaBrowser.LocalMetadata/MediaBrowser.LocalMetadata.csproj
@@ -1,17 +1,30 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
+  <!-- ProjectGuid is only included as a requirement for SonarQube analysis -->
+  <PropertyGroup>
+    <ProjectGuid>{7EF9F3E0-697D-42F3-A08F-19DEB5F84392}</ProjectGuid>
+  </PropertyGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\MediaBrowser.Controller\MediaBrowser.Controller.csproj" />
     <ProjectReference Include="..\MediaBrowser.Model\MediaBrowser.Model.csproj" />
   </ItemGroup>
 
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+  </PropertyGroup>
+
   <ItemGroup>
     <Compile Include="..\SharedVersion.cs" />
   </ItemGroup>
 
-  <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-  </PropertyGroup>
+  <!-- Code Analyzers-->
+  <ItemGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <PackageReference Include="SerilogAnalyzer" Version="0.15.0" PrivateAssets="All" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
+    <PackageReference Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" PrivateAssets="All" />
+  </ItemGroup>
 
 </Project>
diff --git a/MediaBrowser.LocalMetadata/Parsers/BaseItemXmlParser.cs b/MediaBrowser.LocalMetadata/Parsers/BaseItemXmlParser.cs
index 38458e34c..5a36c1663 100644
--- a/MediaBrowser.LocalMetadata/Parsers/BaseItemXmlParser.cs
+++ b/MediaBrowser.LocalMetadata/Parsers/BaseItemXmlParser.cs
@@ -6,52 +6,51 @@ using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Xml;
+using Jellyfin.Extensions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Entities;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Xml;
 using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Parsers
 {
     /// <summary>
-    /// Provides a base class for parsing metadata xml
+    /// Provides a base class for parsing metadata xml.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="T">Type of item xml parser.</typeparam>
     public class BaseItemXmlParser<T>
         where T : BaseItem
     {
-        /// <summary>
-        /// The logger
-        /// </summary>
-        protected ILogger Logger { get; private set; }
-        protected IProviderManager ProviderManager { get; private set; }
-
-        private Dictionary<string, string> _validProviderIds;
-
-        protected IXmlReaderSettingsFactory XmlReaderSettingsFactory { get; private set; }
-        protected IFileSystem FileSystem { get; private set; }
+        private Dictionary<string, string>? _validProviderIds;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="BaseItemXmlParser{T}" /> class.
         /// </summary>
-        /// <param name="logger">The logger.</param>
-        public BaseItemXmlParser(ILogger logger, IProviderManager providerManager, IXmlReaderSettingsFactory xmlReaderSettingsFactory, IFileSystem fileSystem)
+        /// <param name="logger">Instance of the <see cref="ILogger{BaseItemXmlParser}"/> interface.</param>
+        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
+        public BaseItemXmlParser(ILogger<BaseItemXmlParser<T>> logger, IProviderManager providerManager)
         {
             Logger = logger;
             ProviderManager = providerManager;
-            XmlReaderSettingsFactory = xmlReaderSettingsFactory;
-            FileSystem = fileSystem;
         }
 
         /// <summary>
-        /// Fetches metadata for an item from one xml file
+        /// Gets the logger.
+        /// </summary>
+        protected ILogger<BaseItemXmlParser<T>> Logger { get; private set; }
+
+        /// <summary>
+        /// Gets the provider manager.
+        /// </summary>
+        protected IProviderManager ProviderManager { get; private set; }
+
+        /// <summary>
+        /// Fetches metadata for an item from one xml file.
         /// </summary>
         /// <param name="item">The item.</param>
         /// <param name="metadataFile">The metadata file.</param>
         /// <param name="cancellationToken">The cancellation token.</param>
-        /// <exception cref="ArgumentNullException"></exception>
+        /// <exception cref="ArgumentNullException">Item is null.</exception>
         public void Fetch(MetadataResult<T> item, string metadataFile, CancellationToken cancellationToken)
         {
             if (item == null)
@@ -64,11 +63,13 @@ namespace MediaBrowser.LocalMetadata.Parsers
                 throw new ArgumentException("The metadata file was empty or null.", nameof(metadataFile));
             }
 
-            var settings = XmlReaderSettingsFactory.Create(false);
-
-            settings.CheckCharacters = false;
-            settings.IgnoreProcessingInstructions = true;
-            settings.IgnoreComments = true;
+            var settings = new XmlReaderSettings
+            {
+                ValidationType = ValidationType.None,
+                CheckCharacters = false,
+                IgnoreProcessingInstructions = true,
+                IgnoreComments = true
+            };
 
             _validProviderIds = _validProviderIds = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
 
@@ -83,10 +84,10 @@ namespace MediaBrowser.LocalMetadata.Parsers
                 }
             }
 
-            //Additional Mappings
+            // Additional Mappings
             _validProviderIds.Add("IMDB", "Imdb");
 
-            //Fetch(item, metadataFile, settings, Encoding.GetEncoding("ISO-8859-1"), cancellationToken);
+            // Fetch(item, metadataFile, settings, Encoding.GetEncoding("ISO-8859-1"), cancellationToken);
             Fetch(item, metadataFile, settings, Encoding.UTF8, cancellationToken);
         }
 
@@ -102,39 +103,30 @@ namespace MediaBrowser.LocalMetadata.Parsers
         {
             item.ResetPeople();
 
-            using (var fileStream = File.OpenRead(metadataFile))
-            {
-                using (var streamReader = new StreamReader(fileStream, encoding))
-                {
-                    // Use XmlReader for best performance
-                    using (var reader = XmlReader.Create(streamReader, settings))
-                    {
-                        reader.MoveToContent();
-                        reader.Read();
+            using var fileStream = File.OpenRead(metadataFile);
+            using var streamReader = new StreamReader(fileStream, encoding);
+            using var reader = XmlReader.Create(streamReader, settings);
+            reader.MoveToContent();
+            reader.Read();
 
-                        // Loop through each element
-                        while (!reader.EOF && reader.ReadState == ReadState.Interactive)
-                        {
-                            cancellationToken.ThrowIfCancellationRequested();
+            // Loop through each element
+            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
 
-                            if (reader.NodeType == XmlNodeType.Element)
-                            {
-                                FetchDataFromXmlNode(reader, item);
-                            }
-                            else
-                            {
-                                reader.Read();
-                            }
-                        }
-                    }
+                if (reader.NodeType == XmlNodeType.Element)
+                {
+                    FetchDataFromXmlNode(reader, item);
+                }
+                else
+                {
+                    reader.Read();
                 }
             }
         }
 
-        private readonly CultureInfo _usCulture = new CultureInfo("en-US");
-
         /// <summary>
-        /// Fetches metadata from one Xml Element
+        /// Fetches metadata from one Xml Element.
         /// </summary>
         /// <param name="reader">The reader.</param>
         /// <param name="itemResult">The item result.</param>
@@ -146,607 +138,569 @@ namespace MediaBrowser.LocalMetadata.Parsers
             {
                 // DateCreated
                 case "Added":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(val))
+                    if (!string.IsNullOrWhiteSpace(val))
+                    {
+                        if (DateTime.TryParse(val, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out var added))
                         {
-                            if (DateTime.TryParse(val, out var added))
-                            {
-                                item.DateCreated = added.ToUniversalTime();
-                            }
-                            else
-                            {
-                                Logger.LogWarning("Invalid Added value found: " + val);
-                            }
+                            item.DateCreated = added;
+                        }
+                        else
+                        {
+                            Logger.LogWarning("Invalid Added value found: " + val);
                         }
-                        break;
                     }
 
+                    break;
+                }
+
                 case "OriginalTitle":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrEmpty(val))
-                        {
-                            item.OriginalTitle = val;
-                        }
-                        break;
+                    if (!string.IsNullOrEmpty(val))
+                    {
+                        item.OriginalTitle = val;
                     }
 
+                    break;
+                }
+
                 case "LocalTitle":
                     item.Name = reader.ReadElementContentAsString();
                     break;
 
                 case "CriticRating":
-                    {
-                        var text = reader.ReadElementContentAsString();
+                {
+                    var text = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrEmpty(text))
+                    if (!string.IsNullOrEmpty(text))
+                    {
+                        if (float.TryParse(text, NumberStyles.Any, CultureInfo.InvariantCulture, out var value))
                         {
-                            if (float.TryParse(text, NumberStyles.Any, _usCulture, out var value))
-                            {
-                                item.CriticRating = value;
-                            }
+                            item.CriticRating = value;
                         }
-
-                        break;
                     }
 
+                    break;
+                }
+
                 case "SortTitle":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(val))
-                        {
-                            item.ForcedSortName = val;
-                        }
-                        break;
+                    if (!string.IsNullOrWhiteSpace(val))
+                    {
+                        item.ForcedSortName = val;
                     }
 
+                    break;
+                }
+
                 case "Overview":
                 case "Description":
-                    {
-                        var val = reader.ReadElementContentAsString();
-
-                        if (!string.IsNullOrWhiteSpace(val))
-                        {
-                            item.Overview = val;
-                        }
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        break;
+                    if (!string.IsNullOrWhiteSpace(val))
+                    {
+                        item.Overview = val;
                     }
 
+                    break;
+                }
+
                 case "Language":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        item.PreferredMetadataLanguage = val;
+                    item.PreferredMetadataLanguage = val;
 
-                        break;
-                    }
+                    break;
+                }
 
                 case "CountryCode":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        item.PreferredMetadataCountryCode = val;
+                    item.PreferredMetadataCountryCode = val;
 
-                        break;
-                    }
+                    break;
+                }
 
                 case "PlaceOfBirth":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(val))
+                    if (!string.IsNullOrWhiteSpace(val))
+                    {
+                        if (item is Person person)
                         {
-                            var person = item as Person;
-                            if (person != null)
-                            {
-                                person.ProductionLocations = new string[] { val };
-                            }
+                            person.ProductionLocations = new[] { val };
                         }
-
-                        break;
                     }
 
+                    break;
+                }
+
                 case "LockedFields":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(val))
+                    if (!string.IsNullOrWhiteSpace(val))
+                    {
+                        item.LockedFields = val.Split('|').Select(i =>
                         {
-                            item.LockedFields = val.Split('|').Select(i =>
+                            if (Enum.TryParse(i, true, out MetadataField field))
                             {
-                                if (Enum.TryParse(i, true, out MetadataFields field))
-                                {
-                                    return (MetadataFields?)field;
-                                }
-
-                                return null;
-
-                            }).Where(i => i.HasValue).Select(i => i.Value).ToArray();
-                        }
+                                return (MetadataField?)field;
+                            }
 
-                        break;
+                            return null;
+                        }).Where(i => i.HasValue).Select(i => i!.Value).ToArray();
                     }
 
+                    break;
+                }
+
                 case "TagLines":
+                {
+                    if (!reader.IsEmptyElement)
                     {
-                        if (!reader.IsEmptyElement)
+                        using (var subtree = reader.ReadSubtree())
                         {
-                            using (var subtree = reader.ReadSubtree())
-                            {
-                                FetchFromTaglinesNode(subtree, item);
-                            }
+                            FetchFromTaglinesNode(subtree, item);
                         }
-                        else
-                        {
-                            reader.Read();
-                        }
-                        break;
                     }
+                    else
+                    {
+                        reader.Read();
+                    }
+
+                    break;
+                }
 
                 case "Countries":
+                {
+                    if (!reader.IsEmptyElement)
                     {
-                        if (!reader.IsEmptyElement)
-                        {
-                            using (var subtree = reader.ReadSubtree())
-                            {
-                                FetchFromCountriesNode(subtree, item);
-                            }
-                        }
-                        else
+                        using (var subtree = reader.ReadSubtree())
                         {
-                            reader.Read();
+                            FetchFromCountriesNode(subtree);
                         }
-                        break;
+                    }
+                    else
+                    {
+                        reader.Read();
                     }
 
+                    break;
+                }
+
                 case "ContentRating":
                 case "MPAARating":
-                    {
-                        var rating = reader.ReadElementContentAsString();
+                {
+                    var rating = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(rating))
-                        {
-                            item.OfficialRating = rating;
-                        }
-                        break;
+                    if (!string.IsNullOrWhiteSpace(rating))
+                    {
+                        item.OfficialRating = rating;
                     }
 
+                    break;
+                }
+
                 case "CustomRating":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(val))
-                        {
-                            item.CustomRating = val;
-                        }
-                        break;
+                    if (!string.IsNullOrWhiteSpace(val))
+                    {
+                        item.CustomRating = val;
                     }
 
+                    break;
+                }
+
                 case "RunningTime":
-                    {
-                        var text = reader.ReadElementContentAsString();
+                {
+                    var text = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(text))
+                    if (!string.IsNullOrWhiteSpace(text))
+                    {
+                        if (int.TryParse(text.AsSpan().LeftPart(' '), NumberStyles.Integer, CultureInfo.InvariantCulture, out var runtime))
                         {
-                            if (int.TryParse(text.Split(' ')[0], NumberStyles.Integer, _usCulture, out var runtime))
-                            {
-                                item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
-                            }
+                            item.RunTimeTicks = TimeSpan.FromMinutes(runtime).Ticks;
                         }
-                        break;
                     }
 
+                    break;
+                }
+
                 case "AspectRatio":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        var hasAspectRatio = item as IHasAspectRatio;
-                        if (!string.IsNullOrWhiteSpace(val) && hasAspectRatio != null)
-                        {
-                            hasAspectRatio.AspectRatio = val;
-                        }
-                        break;
+                    if (!string.IsNullOrWhiteSpace(val) && item is IHasAspectRatio hasAspectRatio)
+                    {
+                        hasAspectRatio.AspectRatio = val;
                     }
 
+                    break;
+                }
+
                 case "LockData":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(val))
-                        {
-                            item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
-                        }
-                        break;
+                    if (!string.IsNullOrWhiteSpace(val))
+                    {
+                        item.IsLocked = string.Equals("true", val, StringComparison.OrdinalIgnoreCase);
                     }
 
+                    break;
+                }
+
                 case "Network":
+                {
+                    foreach (var name in SplitNames(reader.ReadElementContentAsString()))
                     {
-                        foreach (var name in SplitNames(reader.ReadElementContentAsString()))
+                        if (string.IsNullOrWhiteSpace(name))
                         {
-                            if (string.IsNullOrWhiteSpace(name))
-                            {
-                                continue;
-                            }
-                            item.AddStudio(name);
+                            continue;
                         }
-                        break;
+
+                        item.AddStudio(name);
                     }
 
+                    break;
+                }
+
                 case "Director":
+                {
+                    foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo { Name = v.Trim(), Type = PersonType.Director }))
                     {
-                        foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo { Name = v.Trim(), Type = PersonType.Director }))
+                        if (string.IsNullOrWhiteSpace(p.Name))
                         {
-                            if (string.IsNullOrWhiteSpace(p.Name))
-                            {
-                                continue;
-                            }
-                            itemResult.AddPerson(p);
+                            continue;
                         }
-                        break;
+
+                        itemResult.AddPerson(p);
                     }
+
+                    break;
+                }
+
                 case "Writer":
+                {
+                    foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo { Name = v.Trim(), Type = PersonType.Writer }))
                     {
-                        foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo { Name = v.Trim(), Type = PersonType.Writer }))
+                        if (string.IsNullOrWhiteSpace(p.Name))
                         {
-                            if (string.IsNullOrWhiteSpace(p.Name))
-                            {
-                                continue;
-                            }
-                            itemResult.AddPerson(p);
+                            continue;
                         }
-                        break;
+
+                        itemResult.AddPerson(p);
                     }
 
-                case "Actors":
-                    {
+                    break;
+                }
 
-                        var actors = reader.ReadInnerXml();
+                case "Actors":
+                {
+                    var actors = reader.ReadInnerXml();
 
-                        if (actors.Contains("<"))
-                        {
-                            // This is one of the mis-named "Actors" full nodes created by MB2
-                            // Create a reader and pass it to the persons node processor
-                            FetchDataFromPersonsNode(XmlReader.Create(new StringReader("<Persons>" + actors + "</Persons>")), itemResult);
-                        }
-                        else
-                        {
-                            // Old-style piped string
-                            foreach (var p in SplitNames(actors).Select(v => new PersonInfo { Name = v.Trim(), Type = PersonType.Actor }))
-                            {
-                                if (string.IsNullOrWhiteSpace(p.Name))
-                                {
-                                    continue;
-                                }
-                                itemResult.AddPerson(p);
-                            }
-                        }
-                        break;
+                    if (actors.Contains("<", StringComparison.Ordinal))
+                    {
+                        // This is one of the mis-named "Actors" full nodes created by MB2
+                        // Create a reader and pass it to the persons node processor
+                        using var xmlReader = XmlReader.Create(new StringReader($"<Persons>{actors}</Persons>"));
+                        FetchDataFromPersonsNode(xmlReader, itemResult);
                     }
-
-                case "GuestStars":
+                    else
                     {
-                        foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo { Name = v.Trim(), Type = PersonType.GuestStar }))
+                        // Old-style piped string
+                        foreach (var p in SplitNames(actors).Select(v => new PersonInfo { Name = v.Trim(), Type = PersonType.Actor }))
                         {
                             if (string.IsNullOrWhiteSpace(p.Name))
                             {
                                 continue;
                             }
+
                             itemResult.AddPerson(p);
                         }
-                        break;
                     }
 
-                case "Trailer":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                    break;
+                }
 
-                        if (!string.IsNullOrWhiteSpace(val))
+                case "GuestStars":
+                {
+                    foreach (var p in SplitNames(reader.ReadElementContentAsString()).Select(v => new PersonInfo { Name = v.Trim(), Type = PersonType.GuestStar }))
+                    {
+                        if (string.IsNullOrWhiteSpace(p.Name))
                         {
-                            item.AddTrailerUrl(val);
+                            continue;
                         }
-                        break;
+
+                        itemResult.AddPerson(p);
                     }
 
-                case "DisplayOrder":
+                    break;
+                }
+
+                case "Trailer":
+                {
+                    var val = reader.ReadElementContentAsString();
+
+                    if (!string.IsNullOrWhiteSpace(val))
                     {
-                        var val = reader.ReadElementContentAsString();
+                        item.AddTrailerUrl(val);
+                    }
+
+                    break;
+                }
 
-                        var hasDisplayOrder = item as IHasDisplayOrder;
-                        if (hasDisplayOrder != null)
+                case "DisplayOrder":
+                {
+                    var val = reader.ReadElementContentAsString();
+
+                    if (item is IHasDisplayOrder hasDisplayOrder)
+                    {
+                        if (!string.IsNullOrWhiteSpace(val))
                         {
-                            if (!string.IsNullOrWhiteSpace(val))
-                            {
-                                hasDisplayOrder.DisplayOrder = val;
-                            }
+                            hasDisplayOrder.DisplayOrder = val;
                         }
-                        break;
                     }
 
+                    break;
+                }
+
                 case "Trailers":
+                {
+                    if (!reader.IsEmptyElement)
                     {
-                        if (!reader.IsEmptyElement)
-                        {
-                            using (var subtree = reader.ReadSubtree())
-                            {
-                                FetchDataFromTrailersNode(subtree, item);
-                            }
-                        }
-                        else
-                        {
-                            reader.Read();
-                        }
-                        break;
+                        using var subtree = reader.ReadSubtree();
+                        FetchDataFromTrailersNode(subtree, item);
+                    }
+                    else
+                    {
+                        reader.Read();
                     }
 
+                    break;
+                }
+
                 case "ProductionYear":
-                    {
-                        var val = reader.ReadElementContentAsString();
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(val))
+                    if (!string.IsNullOrWhiteSpace(val))
+                    {
+                        if (int.TryParse(val, out var productionYear) && productionYear > 1850)
                         {
-                            if (int.TryParse(val, out var productionYear) && productionYear > 1850)
-                            {
-                                item.ProductionYear = productionYear;
-                            }
+                            item.ProductionYear = productionYear;
                         }
-
-                        break;
                     }
 
+                    break;
+                }
+
                 case "Rating":
                 case "IMDBrating":
-                    {
-
-                        var rating = reader.ReadElementContentAsString();
+                {
+                    var rating = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(rating))
+                    if (!string.IsNullOrWhiteSpace(rating))
+                    {
+                        // All external meta is saving this as '.' for decimal I believe...but just to be sure
+                        if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var val))
                         {
-                            // All external meta is saving this as '.' for decimal I believe...but just to be sure
-                            if (float.TryParse(rating.Replace(',', '.'), NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out var val))
-                            {
-                                item.CommunityRating = val;
-                            }
+                            item.CommunityRating = val;
                         }
-                        break;
                     }
 
+                    break;
+                }
+
                 case "BirthDate":
                 case "PremiereDate":
                 case "FirstAired":
-                    {
-                        var firstAired = reader.ReadElementContentAsString();
+                {
+                    var firstAired = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(firstAired))
+                    if (!string.IsNullOrWhiteSpace(firstAired))
+                    {
+                        if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out var airDate) && airDate.Year > 1850)
                         {
-                            if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var airDate) && airDate.Year > 1850)
-                            {
-                                item.PremiereDate = airDate.ToUniversalTime();
-                                item.ProductionYear = airDate.Year;
-                            }
+                            item.PremiereDate = airDate;
+                            item.ProductionYear = airDate.Year;
                         }
-
-                        break;
                     }
 
+                    break;
+                }
+
                 case "DeathDate":
                 case "EndDate":
-                    {
-                        var firstAired = reader.ReadElementContentAsString();
+                {
+                    var firstAired = reader.ReadElementContentAsString();
 
-                        if (!string.IsNullOrWhiteSpace(firstAired))
+                    if (!string.IsNullOrWhiteSpace(firstAired))
+                    {
+                        if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal | DateTimeStyles.AdjustToUniversal, out var airDate) && airDate.Year > 1850)
                         {
-                            if (DateTime.TryParseExact(firstAired, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var airDate) && airDate.Year > 1850)
-                            {
-                                item.EndDate = airDate.ToUniversalTime();
-                            }
+                            item.EndDate = airDate;
                         }
-
-                        break;
                     }
 
+                    break;
+                }
+
                 case "CollectionNumber":
                     var tmdbCollection = reader.ReadElementContentAsString();
                     if (!string.IsNullOrWhiteSpace(tmdbCollection))
                     {
-                        item.SetProviderId(MetadataProviders.TmdbCollection, tmdbCollection);
+                        item.SetProviderId(MetadataProvider.TmdbCollection, tmdbCollection);
                     }
+
                     break;
 
                 case "Genres":
+                {
+                    if (!reader.IsEmptyElement)
                     {
-                        if (!reader.IsEmptyElement)
-                        {
-                            using (var subtree = reader.ReadSubtree())
-                            {
-                                FetchFromGenresNode(subtree, item);
-                            }
-                        }
-                        else
-                        {
-                            reader.Read();
-                        }
-                        break;
+                        using var subtree = reader.ReadSubtree();
+                        FetchFromGenresNode(subtree, item);
                     }
+                    else
+                    {
+                        reader.Read();
+                    }
+
+                    break;
+                }
 
                 case "Tags":
+                {
+                    if (!reader.IsEmptyElement)
                     {
-                        if (!reader.IsEmptyElement)
-                        {
-                            using (var subtree = reader.ReadSubtree())
-                            {
-                                FetchFromTagsNode(subtree, item);
-                            }
-                        }
-                        else
-                        {
-                            reader.Read();
-                        }
-                        break;
+                        using var subtree = reader.ReadSubtree();
+                        FetchFromTagsNode(subtree, item);
+                    }
+                    else
+                    {
+                        reader.Read();
                     }
 
+                    break;
+                }
+
                 case "Persons":
+                {
+                    if (!reader.IsEmptyElement)
                     {
-                        if (!reader.IsEmptyElement)
-                        {
-                            using (var subtree = reader.ReadSubtree())
-                            {
-                                FetchDataFromPersonsNode(subtree, itemResult);
-                            }
-                        }
-                        else
-                        {
-                            reader.Read();
-                        }
-                        break;
+                        using var subtree = reader.ReadSubtree();
+                        FetchDataFromPersonsNode(subtree, itemResult);
+                    }
+                    else
+                    {
+                        reader.Read();
                     }
 
+                    break;
+                }
+
                 case "Studios":
+                {
+                    if (!reader.IsEmptyElement)
                     {
-                        if (!reader.IsEmptyElement)
-                        {
-                            using (var subtree = reader.ReadSubtree())
-                            {
-                                FetchFromStudiosNode(subtree, item);
-                            }
-                        }
-                        else
-                        {
-                            reader.Read();
-                        }
-                        break;
+                        using var subtree = reader.ReadSubtree();
+                        FetchFromStudiosNode(subtree, item);
+                    }
+                    else
+                    {
+                        reader.Read();
                     }
 
+                    break;
+                }
+
                 case "Shares":
+                {
+                    if (!reader.IsEmptyElement)
                     {
-                        if (!reader.IsEmptyElement)
+                        using var subtree = reader.ReadSubtree();
+                        if (item is IHasShares hasShares)
                         {
-                            using (var subtree = reader.ReadSubtree())
-                            {
-                                var hasShares = item as IHasShares;
-                                if (hasShares != null)
-                                {
-                                    FetchFromSharesNode(subtree, hasShares);
-                                }
-                            }
+                            FetchFromSharesNode(subtree, hasShares);
                         }
-                        else
-                        {
-                            reader.Read();
-                        }
-                        break;
                     }
-
-                case "Format3D":
+                    else
                     {
-                        var val = reader.ReadElementContentAsString();
+                        reader.Read();
+                    }
 
-                        var video = item as Video;
+                    break;
+                }
 
-                        if (video != null)
-                        {
-                            if (string.Equals("HSBS", val, StringComparison.OrdinalIgnoreCase))
-                            {
-                                video.Video3DFormat = Video3DFormat.HalfSideBySide;
-                            }
-                            else if (string.Equals("HTAB", val, StringComparison.OrdinalIgnoreCase))
-                            {
-                                video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
-                            }
-                            else if (string.Equals("FTAB", val, StringComparison.OrdinalIgnoreCase))
-                            {
-                                video.Video3DFormat = Video3DFormat.FullTopAndBottom;
-                            }
-                            else if (string.Equals("FSBS", val, StringComparison.OrdinalIgnoreCase))
-                            {
-                                video.Video3DFormat = Video3DFormat.FullSideBySide;
-                            }
-                            else if (string.Equals("MVC", val, StringComparison.OrdinalIgnoreCase))
-                            {
-                                video.Video3DFormat = Video3DFormat.MVC;
-                            }
-                        }
-                        break;
-                    }
+                case "Format3D":
+                {
+                    var val = reader.ReadElementContentAsString();
 
-                default:
+                    if (item is Video video)
                     {
-                        string readerName = reader.Name;
-                        if (_validProviderIds.TryGetValue(readerName, out string providerIdValue))
+                        if (string.Equals("HSBS", val, StringComparison.OrdinalIgnoreCase))
                         {
-                            var id = reader.ReadElementContentAsString();
-                            if (!string.IsNullOrWhiteSpace(id))
-                            {
-                                item.SetProviderId(providerIdValue, id);
-                            }
+                            video.Video3DFormat = Video3DFormat.HalfSideBySide;
                         }
-                        else
+                        else if (string.Equals("HTAB", val, StringComparison.OrdinalIgnoreCase))
                         {
-                            reader.Skip();
+                            video.Video3DFormat = Video3DFormat.HalfTopAndBottom;
+                        }
+                        else if (string.Equals("FTAB", val, StringComparison.OrdinalIgnoreCase))
+                        {
+                            video.Video3DFormat = Video3DFormat.FullTopAndBottom;
+                        }
+                        else if (string.Equals("FSBS", val, StringComparison.OrdinalIgnoreCase))
+                        {
+                            video.Video3DFormat = Video3DFormat.FullSideBySide;
+                        }
+                        else if (string.Equals("MVC", val, StringComparison.OrdinalIgnoreCase))
+                        {
+                            video.Video3DFormat = Video3DFormat.MVC;
                         }
-
-                        break;
-
                     }
-            }
-        }
-        private void FetchFromSharesNode(XmlReader reader, IHasShares item)
-        {
-            var list = new List<Share>();
 
-            reader.MoveToContent();
-            reader.Read();
+                    break;
+                }
 
-            // Loop through each element
-            while (!reader.EOF && reader.ReadState == ReadState.Interactive)
-            {
-                if (reader.NodeType == XmlNodeType.Element)
+                default:
                 {
-                    switch (reader.Name)
+                    string readerName = reader.Name;
+                    if (_validProviderIds!.TryGetValue(readerName, out string? providerIdValue))
                     {
-                        case "Share":
-                            {
-                                if (reader.IsEmptyElement)
-                                {
-                                    reader.Read();
-                                    continue;
-                                }
-
-                                using (var subReader = reader.ReadSubtree())
-                                {
-                                    var child = GetShare(subReader);
-
-                                    if (child != null)
-                                    {
-                                        list.Add(child);
-                                    }
-                                }
-
-                                break;
-                            }
-                        default:
-                            {
-                                reader.Skip();
-                                break;
-                            }
+                        var id = reader.ReadElementContentAsString();
+                        if (!string.IsNullOrWhiteSpace(id))
+                        {
+                            item.SetProviderId(providerIdValue, id);
+                        }
                     }
-                }
-                else
-                {
-                    reader.Read();
+                    else
+                    {
+                        reader.Skip();
+                    }
+
+                    break;
                 }
             }
-
-            item.Shares = list.ToArray();
         }
 
-        private Share GetShareFromNode(XmlReader reader)
+        private void FetchFromSharesNode(XmlReader reader, IHasShares item)
         {
-            var share = new Share();
+            var list = new List<Share>();
 
             reader.MoveToContent();
             reader.Read();
@@ -758,21 +712,32 @@ namespace MediaBrowser.LocalMetadata.Parsers
                 {
                     switch (reader.Name)
                     {
-                        case "UserId":
+                        case "Share":
+                        {
+                            if (reader.IsEmptyElement)
                             {
-                                share.UserId = reader.ReadElementContentAsString();
-                                break;
+                                reader.Read();
+                                continue;
                             }
 
-                        case "CanEdit":
+                            using (var subReader = reader.ReadSubtree())
                             {
-                                share.CanEdit = string.Equals(reader.ReadElementContentAsString(), true.ToString(), StringComparison.OrdinalIgnoreCase);
-                                break;
+                                var child = GetShare(subReader);
+
+                                if (child != null)
+                                {
+                                    list.Add(child);
+                                }
                             }
 
+                            break;
+                        }
+
                         default:
+                        {
                             reader.Skip();
                             break;
+                        }
                     }
                 }
                 else
@@ -781,10 +746,10 @@ namespace MediaBrowser.LocalMetadata.Parsers
                 }
             }
 
-            return share;
+            item.Shares = list.ToArray();
         }
 
-        private void FetchFromCountriesNode(XmlReader reader, T item)
+        private void FetchFromCountriesNode(XmlReader reader)
         {
             reader.MoveToContent();
             reader.Read();
@@ -797,15 +762,16 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "Country":
-                            {
-                                var val = reader.ReadElementContentAsString();
+                        {
+                            var val = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(val))
-                                {
-                                }
-                                break;
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
                             }
 
+                            break;
+                        }
+
                         default:
                             reader.Skip();
                             break;
@@ -836,15 +802,17 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "Tagline":
-                            {
-                                var val = reader.ReadElementContentAsString();
+                        {
+                            var val = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(val))
-                                {
-                                    item.Tagline = val;
-                                }
-                                break;
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
+                                item.Tagline = val;
                             }
+
+                            break;
+                        }
+
                         default:
                             reader.Skip();
                             break;
@@ -875,16 +843,17 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "Genre":
-                            {
-                                var genre = reader.ReadElementContentAsString();
+                        {
+                            var genre = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(genre))
-                                {
-                                    item.AddGenre(genre);
-                                }
-                                break;
+                            if (!string.IsNullOrWhiteSpace(genre))
+                            {
+                                item.AddGenre(genre);
                             }
 
+                            break;
+                        }
+
                         default:
                             reader.Skip();
                             break;
@@ -912,16 +881,17 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "Tag":
-                            {
-                                var tag = reader.ReadElementContentAsString();
+                        {
+                            var tag = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(tag))
-                                {
-                                    tags.Add(tag);
-                                }
-                                break;
+                            if (!string.IsNullOrWhiteSpace(tag))
+                            {
+                                tags.Add(tag);
                             }
 
+                            break;
+                        }
+
                         default:
                             reader.Skip();
                             break;
@@ -955,26 +925,29 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     {
                         case "Person":
                         case "Actor":
+                        {
+                            if (reader.IsEmptyElement)
                             {
-                                if (reader.IsEmptyElement)
-                                {
-                                    reader.Read();
-                                    continue;
-                                }
-                                using (var subtree = reader.ReadSubtree())
+                                reader.Read();
+                                continue;
+                            }
+
+                            using (var subtree = reader.ReadSubtree())
+                            {
+                                foreach (var person in GetPersonsFromXmlNode(subtree))
                                 {
-                                    foreach (var person in GetPersonsFromXmlNode(subtree))
+                                    if (string.IsNullOrWhiteSpace(person.Name))
                                     {
-                                        if (string.IsNullOrWhiteSpace(person.Name))
-                                        {
-                                            continue;
-                                        }
-                                        item.AddPerson(person);
+                                        continue;
                                     }
+
+                                    item.AddPerson(person);
                                 }
-                                break;
                             }
 
+                            break;
+                        }
+
                         default:
                             reader.Skip();
                             break;
@@ -1000,16 +973,17 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "Trailer":
-                            {
-                                var val = reader.ReadElementContentAsString();
+                        {
+                            var val = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(val))
-                                {
-                                    item.AddTrailerUrl(val);
-                                }
-                                break;
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
+                                item.AddTrailerUrl(val);
                             }
 
+                            break;
+                        }
+
                         default:
                             reader.Skip();
                             break;
@@ -1040,16 +1014,17 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "Studio":
-                            {
-                                var studio = reader.ReadElementContentAsString();
+                        {
+                            var studio = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(studio))
-                                {
-                                    item.AddStudio(studio);
-                                }
-                                break;
+                            if (!string.IsNullOrWhiteSpace(studio))
+                            {
+                                item.AddStudio(studio);
                             }
 
+                            break;
+                        }
+
                         default:
                             reader.Skip();
                             break;
@@ -1070,7 +1045,7 @@ namespace MediaBrowser.LocalMetadata.Parsers
         private IEnumerable<PersonInfo> GetPersonsFromXmlNode(XmlReader reader)
         {
             var name = string.Empty;
-            var type = PersonType.Actor;  // If type is not specified assume actor
+            var type = PersonType.Actor; // If type is not specified assume actor
             var role = string.Empty;
             int? sortOrder = null;
 
@@ -1085,44 +1060,48 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "Name":
-                            name = reader.ReadElementContentAsString() ?? string.Empty;
+                            name = reader.ReadElementContentAsString();
                             break;
 
                         case "Type":
-                            {
-                                var val = reader.ReadElementContentAsString();
+                        {
+                            var val = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(val))
-                                {
-                                    type = val;
-                                }
-                                break;
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
+                                type = val;
                             }
 
+                            break;
+                        }
+
                         case "Role":
-                            {
-                                var val = reader.ReadElementContentAsString();
+                        {
+                            var val = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(val))
-                                {
-                                    role = val;
-                                }
-                                break;
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
+                                role = val;
                             }
+
+                            break;
+                        }
+
                         case "SortOrder":
-                            {
-                                var val = reader.ReadElementContentAsString();
+                        {
+                            var val = reader.ReadElementContentAsString();
 
-                                if (!string.IsNullOrWhiteSpace(val))
+                            if (!string.IsNullOrWhiteSpace(val))
+                            {
+                                if (int.TryParse(val, NumberStyles.Integer, CultureInfo.InvariantCulture, out var intVal))
                                 {
-                                    if (int.TryParse(val, NumberStyles.Integer, _usCulture, out var intVal))
-                                    {
-                                        sortOrder = intVal;
-                                    }
+                                    sortOrder = intVal;
                                 }
-                                break;
                             }
 
+                            break;
+                        }
+
                         default:
                             reader.Skip();
                             break;
@@ -1134,23 +1113,19 @@ namespace MediaBrowser.LocalMetadata.Parsers
                 }
             }
 
-            var personInfo = new PersonInfo
-            {
-                Name = name.Trim(),
-                Role = role,
-                Type = type,
-                SortOrder = sortOrder
-            };
+            var personInfo = new PersonInfo { Name = name.Trim(), Role = role, Type = type, SortOrder = sortOrder };
 
             return new[] { personInfo };
         }
 
-        protected LinkedChild GetLinkedChild(XmlReader reader)
+        /// <summary>
+        /// Get linked child.
+        /// </summary>
+        /// <param name="reader">The xml reader.</param>
+        /// <returns>The linked child.</returns>
+        protected LinkedChild? GetLinkedChild(XmlReader reader)
         {
-            var linkedItem = new LinkedChild
-            {
-                Type = LinkedChildType.Manual
-            };
+            var linkedItem = new LinkedChild { Type = LinkedChildType.Manual };
 
             reader.MoveToContent();
             reader.Read();
@@ -1163,15 +1138,16 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "Path":
-                            {
-                                linkedItem.Path = reader.ReadElementContentAsString();
-                                break;
-                            }
+                        {
+                            linkedItem.Path = reader.ReadElementContentAsString();
+                            break;
+                        }
+
                         case "ItemId":
-                            {
-                                linkedItem.LibraryItemId = reader.ReadElementContentAsString();
-                                break;
-                            }
+                        {
+                            linkedItem.LibraryItemId = reader.ReadElementContentAsString();
+                            break;
+                        }
 
                         default:
                             reader.Skip();
@@ -1193,7 +1169,12 @@ namespace MediaBrowser.LocalMetadata.Parsers
             return null;
         }
 
-        protected Share GetShare(XmlReader reader)
+        /// <summary>
+        /// Get share.
+        /// </summary>
+        /// <param name="reader">The xml reader.</param>
+        /// <returns>The share.</returns>
+        protected Share? GetShare(XmlReader reader)
         {
             var item = new Share();
 
@@ -1208,21 +1189,22 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "UserId":
-                            {
-                                item.UserId = reader.ReadElementContentAsString();
-                                break;
-                            }
+                        {
+                            item.UserId = reader.ReadElementContentAsString();
+                            break;
+                        }
 
                         case "CanEdit":
-                            {
-                                item.CanEdit = string.Equals(reader.ReadElementContentAsString(), "true", StringComparison.OrdinalIgnoreCase);
-                                break;
-                            }
+                        {
+                            item.CanEdit = string.Equals(reader.ReadElementContentAsString(), "true", StringComparison.OrdinalIgnoreCase);
+                            break;
+                        }
+
                         default:
-                            {
-                                reader.Skip();
-                                break;
-                            }
+                        {
+                            reader.Skip();
+                            break;
+                        }
                     }
                 }
                 else
@@ -1240,19 +1222,17 @@ namespace MediaBrowser.LocalMetadata.Parsers
             return null;
         }
 
-
         /// <summary>
-        /// Used to split names of comma or pipe delimeted genres and people
+        /// Used to split names of comma or pipe delimited genres and people.
         /// </summary>
         /// <param name="value">The value.</param>
         /// <returns>IEnumerable{System.String}.</returns>
         private IEnumerable<string> SplitNames(string value)
         {
-            value = value ?? string.Empty;
-
             // Only split by comma if there is no pipe in the string
             // We have to be careful to not split names like Matthew, Jr.
-            var separator = value.IndexOf('|') == -1 && value.IndexOf(';') == -1 ? new[] { ',' } : new[] { '|', ';' };
+            var separator = !value.Contains('|', StringComparison.Ordinal)
+                            && !value.Contains(';', StringComparison.Ordinal) ? new[] { ',' } : new[] { '|', ';' };
 
             value = value.Trim().Trim(separator);
 
@@ -1260,7 +1240,7 @@ namespace MediaBrowser.LocalMetadata.Parsers
         }
 
         /// <summary>
-        /// Provides an additional overload for string.split
+        /// Provides an additional overload for string.split.
         /// </summary>
         /// <param name="val">The val.</param>
         /// <param name="separators">The separators.</param>
@@ -1270,6 +1250,5 @@ namespace MediaBrowser.LocalMetadata.Parsers
         {
             return val.Split(separators, options);
         }
-
     }
 }
diff --git a/MediaBrowser.LocalMetadata/Parsers/BoxSetXmlParser.cs b/MediaBrowser.LocalMetadata/Parsers/BoxSetXmlParser.cs
index e595e9d06..7df800971 100644
--- a/MediaBrowser.LocalMetadata/Parsers/BoxSetXmlParser.cs
+++ b/MediaBrowser.LocalMetadata/Parsers/BoxSetXmlParser.cs
@@ -3,15 +3,27 @@ using System.Xml;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
 using MediaBrowser.Controller.Providers;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Xml;
 using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Parsers
 {
+    /// <summary>
+    /// The box set xml parser.
+    /// </summary>
     public class BoxSetXmlParser : BaseItemXmlParser<BoxSet>
     {
-        protected override void FetchDataFromXmlNode(XmlReader reader, MetadataResult<BoxSet> item)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BoxSetXmlParser"/> class.
+        /// </summary>
+        /// <param name="logger">Instance of the <see cref="ILogger{BoxSetXmlParset}"/> interface.</param>
+        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
+        public BoxSetXmlParser(ILogger<BoxSetXmlParser> logger, IProviderManager providerManager)
+            : base(logger, providerManager)
+        {
+        }
+
+        /// <inheritdoc />
+        protected override void FetchDataFromXmlNode(XmlReader reader, MetadataResult<BoxSet> itemResult)
         {
             switch (reader.Name)
             {
@@ -21,17 +33,18 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     {
                         using (var subReader = reader.ReadSubtree())
                         {
-                            FetchFromCollectionItemsNode(subReader, item);
+                            FetchFromCollectionItemsNode(subReader, itemResult);
                         }
                     }
                     else
                     {
                         reader.Read();
                     }
+
                     break;
 
                 default:
-                    base.FetchDataFromXmlNode(reader, item);
+                    base.FetchDataFromXmlNode(reader, itemResult);
                     break;
             }
         }
@@ -51,31 +64,32 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "CollectionItem":
+                        {
+                            if (!reader.IsEmptyElement)
                             {
-                                if (!reader.IsEmptyElement)
+                                using (var subReader = reader.ReadSubtree())
                                 {
-                                    using (var subReader = reader.ReadSubtree())
-                                    {
-                                        var child = GetLinkedChild(subReader);
+                                    var child = GetLinkedChild(subReader);
 
-                                        if (child != null)
-                                        {
-                                            list.Add(child);
-                                        }
+                                    if (child != null)
+                                    {
+                                        list.Add(child);
                                     }
                                 }
-                                else
-                                {
-                                    reader.Read();
-                                }
-
-                                break;
                             }
-                        default:
+                            else
                             {
-                                reader.Skip();
-                                break;
+                                reader.Read();
                             }
+
+                            break;
+                        }
+
+                        default:
+                        {
+                            reader.Skip();
+                            break;
+                        }
                     }
                 }
                 else
@@ -86,9 +100,5 @@ namespace MediaBrowser.LocalMetadata.Parsers
 
             item.Item.LinkedChildren = list.ToArray();
         }
-
-        public BoxSetXmlParser(ILogger logger, IProviderManager providerManager, IXmlReaderSettingsFactory xmlReaderSettingsFactory, IFileSystem fileSystem) : base(logger, providerManager, xmlReaderSettingsFactory, fileSystem)
-        {
-        }
     }
 }
diff --git a/MediaBrowser.LocalMetadata/Parsers/PlaylistXmlParser.cs b/MediaBrowser.LocalMetadata/Parsers/PlaylistXmlParser.cs
index ff69cb023..b84307cb2 100644
--- a/MediaBrowser.LocalMetadata/Parsers/PlaylistXmlParser.cs
+++ b/MediaBrowser.LocalMetadata/Parsers/PlaylistXmlParser.cs
@@ -3,26 +3,38 @@ using System.Xml;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Playlists;
 using MediaBrowser.Controller.Providers;
-using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Xml;
 using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Parsers
 {
+    /// <summary>
+    /// Playlist xml parser.
+    /// </summary>
     public class PlaylistXmlParser : BaseItemXmlParser<Playlist>
     {
-        protected override void FetchDataFromXmlNode(XmlReader reader, MetadataResult<Playlist> result)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PlaylistXmlParser"/> class.
+        /// </summary>
+        /// <param name="logger">Instance of the <see cref="ILogger{PlaylistXmlParser}"/> interface.</param>
+        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
+        public PlaylistXmlParser(ILogger<PlaylistXmlParser> logger, IProviderManager providerManager)
+            : base(logger, providerManager)
         {
-            var item = result.Item;
+        }
+
+        /// <inheritdoc />
+        protected override void FetchDataFromXmlNode(XmlReader reader, MetadataResult<Playlist> itemResult)
+        {
+            var item = itemResult.Item;
 
             switch (reader.Name)
             {
                 case "PlaylistMediaType":
-                    {
-                        item.PlaylistMediaType = reader.ReadElementContentAsString();
+                {
+                    item.PlaylistMediaType = reader.ReadElementContentAsString();
 
-                        break;
-                    }
+                    break;
+                }
 
                 case "PlaylistItems":
 
@@ -37,10 +49,11 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     {
                         reader.Read();
                     }
+
                     break;
 
                 default:
-                    base.FetchDataFromXmlNode(reader, result);
+                    base.FetchDataFromXmlNode(reader, itemResult);
                     break;
             }
         }
@@ -60,30 +73,31 @@ namespace MediaBrowser.LocalMetadata.Parsers
                     switch (reader.Name)
                     {
                         case "PlaylistItem":
+                        {
+                            if (reader.IsEmptyElement)
                             {
-                                if (reader.IsEmptyElement)
-                                {
-                                    reader.Read();
-                                    continue;
-                                }
+                                reader.Read();
+                                continue;
+                            }
 
-                                using (var subReader = reader.ReadSubtree())
-                                {
-                                    var child = GetLinkedChild(subReader);
+                            using (var subReader = reader.ReadSubtree())
+                            {
+                                var child = GetLinkedChild(subReader);
 
-                                    if (child != null)
-                                    {
-                                        list.Add(child);
-                                    }
+                                if (child != null)
+                                {
+                                    list.Add(child);
                                 }
-
-                                break;
                             }
+
+                            break;
+                        }
+
                         default:
-                            {
-                                reader.Skip();
-                                break;
-                            }
+                        {
+                            reader.Skip();
+                            break;
+                        }
                     }
                 }
                 else
@@ -94,9 +108,5 @@ namespace MediaBrowser.LocalMetadata.Parsers
 
             item.LinkedChildren = list.ToArray();
         }
-
-        public PlaylistXmlParser(ILogger logger, IProviderManager providerManager, IXmlReaderSettingsFactory xmlReaderSettingsFactory, IFileSystem fileSystem) : base(logger, providerManager, xmlReaderSettingsFactory, fileSystem)
-        {
-        }
     }
 }
diff --git a/MediaBrowser.LocalMetadata/Properties/AssemblyInfo.cs b/MediaBrowser.LocalMetadata/Properties/AssemblyInfo.cs
index 3eac83708..580cef9da 100644
--- a/MediaBrowser.LocalMetadata/Properties/AssemblyInfo.cs
+++ b/MediaBrowser.LocalMetadata/Properties/AssemblyInfo.cs
@@ -9,8 +9,8 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Jellyfin Project")]
-[assembly: AssemblyProduct("Jellyfin: The Free Software Media System")]
-[assembly: AssemblyCopyright("Copyright ©  2019 Jellyfin Contributors. Code released under the GNU General Public License Version 2")]
+[assembly: AssemblyProduct("Jellyfin Server")]
+[assembly: AssemblyCopyright("Copyright ©  2019 Jellyfin Contributors. Code released under the GNU General Public License")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 [assembly: NeutralResourcesLanguage("en")]
diff --git a/MediaBrowser.LocalMetadata/Providers/BoxSetXmlProvider.cs b/MediaBrowser.LocalMetadata/Providers/BoxSetXmlProvider.cs
index 539f818c6..ea123bbf2 100644
--- a/MediaBrowser.LocalMetadata/Providers/BoxSetXmlProvider.cs
+++ b/MediaBrowser.LocalMetadata/Providers/BoxSetXmlProvider.cs
@@ -4,7 +4,6 @@ using MediaBrowser.Controller.Entities.Movies;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.LocalMetadata.Parsers;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Xml;
 using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Providers
@@ -14,24 +13,30 @@ namespace MediaBrowser.LocalMetadata.Providers
     /// </summary>
     public class BoxSetXmlProvider : BaseXmlProvider<BoxSet>
     {
-        private readonly ILogger _logger;
+        private readonly ILogger<BoxSetXmlParser> _logger;
         private readonly IProviderManager _providerManager;
-        protected IXmlReaderSettingsFactory XmlReaderSettingsFactory { get; private set; }
 
-        public BoxSetXmlProvider(IFileSystem fileSystem, ILogger logger, IProviderManager providerManager, IXmlReaderSettingsFactory xmlReaderSettingsFactory)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BoxSetXmlProvider"/> class.
+        /// </summary>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger{BoxSetXmlParser}"/> interface.</param>
+        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
+        public BoxSetXmlProvider(IFileSystem fileSystem, ILogger<BoxSetXmlParser> logger, IProviderManager providerManager)
             : base(fileSystem)
         {
             _logger = logger;
             _providerManager = providerManager;
-            XmlReaderSettingsFactory = xmlReaderSettingsFactory;
         }
 
+        /// <inheritdoc />
         protected override void Fetch(MetadataResult<BoxSet> result, string path, CancellationToken cancellationToken)
         {
-            new BoxSetXmlParser(_logger, _providerManager, XmlReaderSettingsFactory, FileSystem).Fetch(result, path, cancellationToken);
+            new BoxSetXmlParser(_logger, _providerManager).Fetch(result, path, cancellationToken);
         }
 
-        protected override FileSystemMetadata GetXmlFile(ItemInfo info, IDirectoryService directoryService)
+        /// <inheritdoc />
+        protected override FileSystemMetadata? GetXmlFile(ItemInfo info, IDirectoryService directoryService)
         {
             return directoryService.GetFile(Path.Combine(info.Path, "collection.xml"));
         }
diff --git a/MediaBrowser.LocalMetadata/Providers/PlaylistXmlProvider.cs b/MediaBrowser.LocalMetadata/Providers/PlaylistXmlProvider.cs
index 442a18cb9..899035652 100644
--- a/MediaBrowser.LocalMetadata/Providers/PlaylistXmlProvider.cs
+++ b/MediaBrowser.LocalMetadata/Providers/PlaylistXmlProvider.cs
@@ -4,33 +4,44 @@ using MediaBrowser.Controller.Providers;
 using MediaBrowser.LocalMetadata.Parsers;
 using MediaBrowser.LocalMetadata.Savers;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Xml;
 using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Providers
 {
+    /// <summary>
+    /// Playlist xml provider.
+    /// </summary>
     public class PlaylistXmlProvider : BaseXmlProvider<Playlist>
     {
-        private readonly ILogger _logger;
+        private readonly ILogger<PlaylistXmlParser> _logger;
         private readonly IProviderManager _providerManager;
-        protected IXmlReaderSettingsFactory XmlReaderSettingsFactory { get; private set; }
 
-        public PlaylistXmlProvider(IFileSystem fileSystem, ILogger logger, IProviderManager providerManager, IXmlReaderSettingsFactory xmlReaderSettingsFactory)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PlaylistXmlProvider"/> class.
+        /// </summary>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger{PlaylistXmlParser}"/> interface.</param>
+        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
+        public PlaylistXmlProvider(
+            IFileSystem fileSystem,
+            ILogger<PlaylistXmlParser> logger,
+            IProviderManager providerManager)
             : base(fileSystem)
         {
             _logger = logger;
             _providerManager = providerManager;
-            XmlReaderSettingsFactory = xmlReaderSettingsFactory;
         }
 
+        /// <inheritdoc />
         protected override void Fetch(MetadataResult<Playlist> result, string path, CancellationToken cancellationToken)
         {
-            new PlaylistXmlParser(_logger, _providerManager, XmlReaderSettingsFactory, FileSystem).Fetch(result, path, cancellationToken);
+            new PlaylistXmlParser(_logger, _providerManager).Fetch(result, path, cancellationToken);
         }
 
-        protected override FileSystemMetadata GetXmlFile(ItemInfo info, IDirectoryService directoryService)
+        /// <inheritdoc />
+        protected override FileSystemMetadata? GetXmlFile(ItemInfo info, IDirectoryService directoryService)
         {
-            return directoryService.GetFile(PlaylistXmlSaver.GetSavePath(info.Path, FileSystem));
+            return directoryService.GetFile(PlaylistXmlSaver.GetSavePath(info.Path));
         }
     }
 }
diff --git a/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs b/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
index 438b84252..5e7af23fc 100644
--- a/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
+++ b/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -14,38 +13,57 @@ using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Playlists;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Xml;
 using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Savers
 {
+    /// <inheritdoc />
     public abstract class BaseXmlSaver : IMetadataFileSaver
     {
-        private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
+        /// <summary>
+        /// Gets the date added format.
+        /// </summary>
+        public const string DateAddedFormat = "yyyy-MM-dd HH:mm:ss";
 
-        public BaseXmlSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager, ILogger logger, IXmlReaderSettingsFactory xmlReaderSettingsFactory)
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BaseXmlSaver"/> class.
+        /// </summary>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="configurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
+        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger{BaseXmlSaver}"/> interface.</param>
+        protected BaseXmlSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, ILogger<BaseXmlSaver> logger)
         {
             FileSystem = fileSystem;
             ConfigurationManager = configurationManager;
             LibraryManager = libraryManager;
-            UserManager = userManager;
-            UserDataManager = userDataManager;
             Logger = logger;
-            XmlReaderSettingsFactory = xmlReaderSettingsFactory;
         }
 
+        /// <summary>
+        /// Gets the file system.
+        /// </summary>
         protected IFileSystem FileSystem { get; private set; }
+
+        /// <summary>
+        /// Gets the configuration manager.
+        /// </summary>
         protected IServerConfigurationManager ConfigurationManager { get; private set; }
+
+        /// <summary>
+        /// Gets the library manager.
+        /// </summary>
         protected ILibraryManager LibraryManager { get; private set; }
-        protected IUserManager UserManager { get; private set; }
-        protected IUserDataManager UserDataManager { get; private set; }
-        protected ILogger Logger { get; private set; }
-        protected IXmlReaderSettingsFactory XmlReaderSettingsFactory { get; private set; }
 
-        protected ItemUpdateType MinimumUpdateType => ItemUpdateType.MetadataDownload;
+        /// <summary>
+        /// Gets the logger.
+        /// </summary>
+        protected ILogger<BaseXmlSaver> Logger { get; private set; }
 
+        /// <inheritdoc />
         public string Name => XmlProviderUtils.Name;
 
+        /// <inheritdoc />
         public string GetSavePath(BaseItem item)
         {
             return GetLocalSavePath(item);
@@ -76,29 +94,38 @@ namespace MediaBrowser.LocalMetadata.Savers
         /// <returns><c>true</c> if [is enabled for] [the specified item]; otherwise, <c>false</c>.</returns>
         public abstract bool IsEnabledFor(BaseItem item, ItemUpdateType updateType);
 
+        /// <inheritdoc />
         public void Save(BaseItem item, CancellationToken cancellationToken)
         {
             var path = GetSavePath(item);
 
-            using (var memoryStream = new MemoryStream())
-            {
-                Save(item, memoryStream, path);
+            using var memoryStream = new MemoryStream();
+            Save(item, memoryStream);
 
-                memoryStream.Position = 0;
+            memoryStream.Position = 0;
 
-                cancellationToken.ThrowIfCancellationRequested();
+            cancellationToken.ThrowIfCancellationRequested();
 
-                SaveToFile(memoryStream, path);
-            }
+            SaveToFile(memoryStream, path);
         }
 
         private void SaveToFile(Stream stream, string path)
         {
-            Directory.CreateDirectory(Path.GetDirectoryName(path));
+            var directory = Path.GetDirectoryName(path) ?? throw new ArgumentException($"Provided path ({path}) is not valid.", nameof(path));
+            Directory.CreateDirectory(directory);
+
             // On Windows, savint the file will fail if the file is hidden or readonly
             FileSystem.SetAttributes(path, false, false);
 
-            using (var filestream = FileSystem.GetFileStream(path, FileOpenMode.Create, FileAccessMode.Write, FileShareMode.Read))
+            var fileStreamOptions = new FileStreamOptions()
+            {
+                Mode = FileMode.Create,
+                Access = FileAccess.Write,
+                Share = FileShare.None,
+                PreallocationSize = stream.Length
+            };
+
+            using (var filestream = new FileStream(path, fileStreamOptions))
             {
                 stream.CopyTo(filestream);
             }
@@ -121,7 +148,7 @@ namespace MediaBrowser.LocalMetadata.Savers
             }
         }
 
-        private void Save(BaseItem item, Stream stream, string xmlPath)
+        private void Save(BaseItem item, Stream stream)
         {
             var settings = new XmlWriterSettings
             {
@@ -142,7 +169,7 @@ namespace MediaBrowser.LocalMetadata.Savers
 
                 if (baseItem != null)
                 {
-                    AddCommonNodes(baseItem, writer, LibraryManager, UserManager, UserDataManager, FileSystem, ConfigurationManager);
+                    AddCommonNodes(baseItem, writer, LibraryManager);
                 }
 
                 WriteCustomElements(item, writer);
@@ -153,35 +180,38 @@ namespace MediaBrowser.LocalMetadata.Savers
             }
         }
 
+        /// <summary>
+        /// Write custom elements.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="writer">The xml writer.</param>
         protected abstract void WriteCustomElements(BaseItem item, XmlWriter writer);
 
-        public const string DateAddedFormat = "yyyy-MM-dd HH:mm:ss";
-
         /// <summary>
         /// Adds the common nodes.
         /// </summary>
-        /// <returns>Task.</returns>
-        public static void AddCommonNodes(BaseItem item, XmlWriter writer, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepo, IFileSystem fileSystem, IServerConfigurationManager config)
+        /// <param name="item">The item.</param>
+        /// <param name="writer">The xml writer.</param>
+        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
+        public static void AddCommonNodes(BaseItem item, XmlWriter writer, ILibraryManager libraryManager)
         {
-            var writtenProviderIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-
             if (!string.IsNullOrEmpty(item.OfficialRating))
             {
                 writer.WriteElementString("ContentRating", item.OfficialRating);
             }
 
-            writer.WriteElementString("Added", item.DateCreated.ToLocalTime().ToString("G"));
+            writer.WriteElementString("Added", item.DateCreated.ToLocalTime().ToString("G", CultureInfo.InvariantCulture));
 
             writer.WriteElementString("LockData", item.IsLocked.ToString(CultureInfo.InvariantCulture).ToLowerInvariant());
 
             if (item.LockedFields.Length > 0)
             {
-                writer.WriteElementString("LockedFields", string.Join("|", item.LockedFields));
+                writer.WriteElementString("LockedFields", string.Join('|', item.LockedFields));
             }
 
             if (item.CriticRating.HasValue)
             {
-                writer.WriteElementString("CriticRating", item.CriticRating.Value.ToString(UsCulture));
+                writer.WriteElementString("CriticRating", item.CriticRating.Value.ToString(CultureInfo.InvariantCulture));
             }
 
             if (!string.IsNullOrEmpty(item.Overview))
@@ -193,12 +223,13 @@ namespace MediaBrowser.LocalMetadata.Savers
             {
                 writer.WriteElementString("OriginalTitle", item.OriginalTitle);
             }
+
             if (!string.IsNullOrEmpty(item.CustomRating))
             {
                 writer.WriteElementString("CustomRating", item.CustomRating);
             }
 
-            if (!string.IsNullOrEmpty(item.Name) && !(item is Episode))
+            if (!string.IsNullOrEmpty(item.Name) && item is not Episode)
             {
                 writer.WriteElementString("LocalTitle", item.Name);
             }
@@ -213,11 +244,11 @@ namespace MediaBrowser.LocalMetadata.Savers
             {
                 if (item is Person)
                 {
-                    writer.WriteElementString("BirthDate", item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd"));
+                    writer.WriteElementString("BirthDate", item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
                 }
-                else if (!(item is Episode))
+                else if (item is not Episode)
                 {
-                    writer.WriteElementString("PremiereDate", item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd"));
+                    writer.WriteElementString("PremiereDate", item.PremiereDate.Value.ToLocalTime().ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
                 }
             }
 
@@ -225,15 +256,15 @@ namespace MediaBrowser.LocalMetadata.Savers
             {
                 if (item is Person)
                 {
-                    writer.WriteElementString("DeathDate", item.EndDate.Value.ToLocalTime().ToString("yyyy-MM-dd"));
+                    writer.WriteElementString("DeathDate", item.EndDate.Value.ToLocalTime().ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
                 }
-                else if (!(item is Episode))
+                else if (item is not Episode)
                 {
-                    writer.WriteElementString("EndDate", item.EndDate.Value.ToLocalTime().ToString("yyyy-MM-dd"));
+                    writer.WriteElementString("EndDate", item.EndDate.Value.ToLocalTime().ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
                 }
             }
 
-            if (item.RemoteTrailers.Length > 0)
+            if (item.RemoteTrailers.Count > 0)
             {
                 writer.WriteStartElement("Trailers");
 
@@ -257,24 +288,22 @@ namespace MediaBrowser.LocalMetadata.Savers
                 writer.WriteEndElement();
             }
 
-            var hasDisplayOrder = item as IHasDisplayOrder;
-            if (hasDisplayOrder != null && !string.IsNullOrEmpty(hasDisplayOrder.DisplayOrder))
+            if (item is IHasDisplayOrder hasDisplayOrder && !string.IsNullOrEmpty(hasDisplayOrder.DisplayOrder))
             {
                 writer.WriteElementString("DisplayOrder", hasDisplayOrder.DisplayOrder);
             }
 
             if (item.CommunityRating.HasValue)
             {
-                writer.WriteElementString("Rating", item.CommunityRating.Value.ToString(UsCulture));
+                writer.WriteElementString("Rating", item.CommunityRating.Value.ToString(CultureInfo.InvariantCulture));
             }
 
-            if (item.ProductionYear.HasValue && !(item is Person))
+            if (item.ProductionYear.HasValue && item is not Person)
             {
-                writer.WriteElementString("ProductionYear", item.ProductionYear.Value.ToString(UsCulture));
+                writer.WriteElementString("ProductionYear", item.ProductionYear.Value.ToString(CultureInfo.InvariantCulture));
             }
 
-            var hasAspectRatio = item as IHasAspectRatio;
-            if (hasAspectRatio != null)
+            if (item is IHasAspectRatio hasAspectRatio)
             {
                 if (!string.IsNullOrEmpty(hasAspectRatio.AspectRatio))
                 {
@@ -286,6 +315,7 @@ namespace MediaBrowser.LocalMetadata.Savers
             {
                 writer.WriteElementString("Language", item.PreferredMetadataLanguage);
             }
+
             if (!string.IsNullOrEmpty(item.PreferredMetadataCountryCode))
             {
                 writer.WriteElementString("CountryCode", item.PreferredMetadataCountryCode);
@@ -298,7 +328,7 @@ namespace MediaBrowser.LocalMetadata.Savers
             {
                 var timespan = TimeSpan.FromTicks(runTimeTicks.Value);
 
-                writer.WriteElementString("RunningTime", Math.Floor(timespan.TotalMinutes).ToString(UsCulture));
+                writer.WriteElementString("RunningTime", Math.Floor(timespan.TotalMinutes).ToString(CultureInfo.InvariantCulture));
             }
 
             if (item.ProviderIds != null)
@@ -371,7 +401,7 @@ namespace MediaBrowser.LocalMetadata.Savers
 
                     if (person.SortOrder.HasValue)
                     {
-                        writer.WriteElementString("SortOrder", person.SortOrder.Value.ToString(UsCulture));
+                        writer.WriteElementString("SortOrder", person.SortOrder.Value.ToString(CultureInfo.InvariantCulture));
                     }
 
                     writer.WriteEndElement();
@@ -380,20 +410,17 @@ namespace MediaBrowser.LocalMetadata.Savers
                 writer.WriteEndElement();
             }
 
-            var boxset = item as BoxSet;
-            if (boxset != null)
+            if (item is BoxSet boxset)
             {
                 AddLinkedChildren(boxset, writer, "CollectionItems", "CollectionItem");
             }
 
-            var playlist = item as Playlist;
-            if (playlist != null && !Playlist.IsPlaylistFile(playlist.Path))
+            if (item is Playlist playlist && !Playlist.IsPlaylistFile(playlist.Path))
             {
                 AddLinkedChildren(playlist, writer, "PlaylistItems", "PlaylistItem");
             }
 
-            var hasShares = item as IHasShares;
-            if (hasShares != null)
+            if (item is IHasShares hasShares)
             {
                 AddShares(hasShares, writer);
             }
@@ -401,6 +428,11 @@ namespace MediaBrowser.LocalMetadata.Savers
             AddMediaInfo(item, writer);
         }
 
+        /// <summary>
+        /// Add shares.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="writer">The xml writer.</param>
         public static void AddShares(IHasShares item, XmlWriter writer)
         {
             writer.WriteStartElement("Shares");
@@ -423,13 +455,13 @@ namespace MediaBrowser.LocalMetadata.Savers
         /// <summary>
         /// Appends the media info.
         /// </summary>
-        /// <typeparam name="T"></typeparam>
+        /// <param name="item">The item.</param>
+        /// <param name="writer">The xml writer.</param>
+        /// <typeparam name="T">Type of item.</typeparam>
         public static void AddMediaInfo<T>(T item, XmlWriter writer)
             where T : BaseItem
         {
-            var video = item as Video;
-
-            if (video != null)
+            if (item is Video video)
             {
                 if (video.Video3DFormat.HasValue)
                 {
@@ -455,6 +487,13 @@ namespace MediaBrowser.LocalMetadata.Savers
             }
         }
 
+        /// <summary>
+        /// ADd linked children.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="writer">The xml writer.</param>
+        /// <param name="pluralNodeName">The plural node name.</param>
+        /// <param name="singularNodeName">The singular node name.</param>
         public static void AddLinkedChildren(Folder item, XmlWriter writer, string pluralNodeName, string singularNodeName)
         {
             var items = item.LinkedChildren
@@ -489,10 +528,5 @@ namespace MediaBrowser.LocalMetadata.Savers
 
             writer.WriteEndElement();
         }
-
-        private bool IsPersonType(PersonInfo person, string type)
-        {
-            return string.Equals(person.Type, type, StringComparison.OrdinalIgnoreCase) || string.Equals(person.Role, type, StringComparison.OrdinalIgnoreCase);
-        }
     }
 }
diff --git a/MediaBrowser.LocalMetadata/Savers/BoxSetXmlSaver.cs b/MediaBrowser.LocalMetadata/Savers/BoxSetXmlSaver.cs
index b4d5440a5..8a5da95bf 100644
--- a/MediaBrowser.LocalMetadata/Savers/BoxSetXmlSaver.cs
+++ b/MediaBrowser.LocalMetadata/Savers/BoxSetXmlSaver.cs
@@ -5,13 +5,28 @@ using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Xml;
 using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Savers
 {
+    /// <summary>
+    /// Box set xml saver.
+    /// </summary>
     public class BoxSetXmlSaver : BaseXmlSaver
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BoxSetXmlSaver"/> class.
+        /// </summary>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="configurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
+        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger{BoxSetXmlSaver}"/> interface.</param>
+        public BoxSetXmlSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, ILogger<BoxSetXmlSaver> logger)
+            : base(fileSystem, configurationManager, libraryManager, logger)
+        {
+        }
+
+        /// <inheritdoc />
         public override bool IsEnabledFor(BaseItem item, ItemUpdateType updateType)
         {
             if (!item.SupportsLocalMetadata)
@@ -22,17 +37,15 @@ namespace MediaBrowser.LocalMetadata.Savers
             return item is BoxSet && updateType >= ItemUpdateType.MetadataDownload;
         }
 
+        /// <inheritdoc />
         protected override void WriteCustomElements(BaseItem item, XmlWriter writer)
         {
         }
 
+        /// <inheritdoc />
         protected override string GetLocalSavePath(BaseItem item)
         {
             return Path.Combine(item.Path, "collection.xml");
         }
-
-        public BoxSetXmlSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager, ILogger logger, IXmlReaderSettingsFactory xmlReaderSettingsFactory) : base(fileSystem, configurationManager, libraryManager, userManager, userDataManager, logger, xmlReaderSettingsFactory)
-        {
-        }
     }
 }
diff --git a/MediaBrowser.LocalMetadata/Savers/PlaylistXmlSaver.cs b/MediaBrowser.LocalMetadata/Savers/PlaylistXmlSaver.cs
index 09bb6d8f7..76252bc09 100644
--- a/MediaBrowser.LocalMetadata/Savers/PlaylistXmlSaver.cs
+++ b/MediaBrowser.LocalMetadata/Savers/PlaylistXmlSaver.cs
@@ -5,13 +5,33 @@ using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Playlists;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Xml;
 using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.LocalMetadata.Savers
 {
+    /// <summary>
+    /// Playlist xml saver.
+    /// </summary>
     public class PlaylistXmlSaver : BaseXmlSaver
     {
+        /// <summary>
+        /// The default file name to use when creating a new playlist.
+        /// </summary>
+        public const string DefaultPlaylistFilename = "playlist.xml";
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PlaylistXmlSaver"/> class.
+        /// </summary>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="configurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
+        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger{PlaylistXmlSaver}"/> interface.</param>
+        public PlaylistXmlSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, ILogger<PlaylistXmlSaver> logger)
+            : base(fileSystem, configurationManager, libraryManager, logger)
+        {
+        }
+
+        /// <inheritdoc />
         public override bool IsEnabledFor(BaseItem item, ItemUpdateType updateType)
         {
             if (!item.SupportsLocalMetadata)
@@ -22,6 +42,7 @@ namespace MediaBrowser.LocalMetadata.Savers
             return item is Playlist && updateType >= ItemUpdateType.MetadataImport;
         }
 
+        /// <inheritdoc />
         protected override void WriteCustomElements(BaseItem item, XmlWriter writer)
         {
             var game = (Playlist)item;
@@ -32,12 +53,18 @@ namespace MediaBrowser.LocalMetadata.Savers
             }
         }
 
+        /// <inheritdoc />
         protected override string GetLocalSavePath(BaseItem item)
         {
-            return GetSavePath(item.Path, FileSystem);
+            return GetSavePath(item.Path);
         }
 
-        public static string GetSavePath(string itemPath, IFileSystem fileSystem)
+        /// <summary>
+        /// Get the save path.
+        /// </summary>
+        /// <param name="itemPath">The item path.</param>
+        /// <returns>The save path.</returns>
+        public static string GetSavePath(string itemPath)
         {
             var path = itemPath;
 
@@ -46,11 +73,7 @@ namespace MediaBrowser.LocalMetadata.Savers
                 return Path.ChangeExtension(itemPath, ".xml");
             }
 
-            return Path.Combine(path, "playlist.xml");
-        }
-
-        public PlaylistXmlSaver(IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataManager, ILogger logger, IXmlReaderSettingsFactory xmlReaderSettingsFactory) : base(fileSystem, configurationManager, libraryManager, userManager, userDataManager, logger, xmlReaderSettingsFactory)
-        {
+            return Path.Combine(path, DefaultPlaylistFilename);
         }
     }
 }
diff --git a/MediaBrowser.LocalMetadata/XmlProviderUtils.cs b/MediaBrowser.LocalMetadata/XmlProviderUtils.cs
new file mode 100644
index 000000000..e247b8bb8
--- /dev/null
+++ b/MediaBrowser.LocalMetadata/XmlProviderUtils.cs
@@ -0,0 +1,13 @@
+namespace MediaBrowser.LocalMetadata
+{
+    /// <summary>
+    /// The xml provider utils.
+    /// </summary>
+    public static class XmlProviderUtils
+    {
+        /// <summary>
+        /// Gets the name.
+        /// </summary>
+        public static string Name => "Emby Xml";
+    }
+}