🧱 Update to .Net 8 GA

Author: russkyc

Nitefox.App/Ffmpeg/FfmpegService.cs

@@ -16,16 +16,8 @@
 using SharpCompress.Readers;
 namespace Nitefox.App.Ffmpeg;
 
-public class FfmpegService
+public class FfmpegService(NitefoxConfig nitefoxConfig)
 {
-    private readonly NitefoxConfig _nitefoxConfig;
-
-    public FfmpegService(NitefoxConfig nitefoxConfig)
-    {
-        _nitefoxConfig = nitefoxConfig;
-        
-    }
-
     public async Task<bool> StreamConvert(string url, string fileName)
     {
         return await FFMpegArguments
@@ -38,14 +30,14 @@ public void ConfigureFfmpeg()
     {
         GlobalFFOptions.Configure(new FFOptions
         {
-            BinaryFolder = _nitefoxConfig.FfmpegLocation,
-            TemporaryFilesFolder = _nitefoxConfig.TempFilesLocation
+            BinaryFolder = nitefoxConfig.FfmpegLocation,
+            TemporaryFilesFolder = nitefoxConfig.TempFilesLocation
         });
     }
 
     public async Task<bool> DownloadFfmpeg()
     {
-        if (new DirectoryInfo(_nitefoxConfig.FfmpegLocation).EnumerateFiles()
+        if (new DirectoryInfo(nitefoxConfig.FfmpegLocation).EnumerateFiles()
                 .Count() >= 3)
         {
             return true;
@@ -76,7 +68,7 @@ public async Task<bool> DownloadFfmpeg()
             releaseAsset = release.Assets.First(asset => asset.Name.EndsWith("osx-arm64.zip"));
         }
 
-        var downloadInfo = await AssetDownloader.Instance.DownloadAssetAsync(releaseAsset, _nitefoxConfig.FfmpegLocation);
+        var downloadInfo = await AssetDownloader.Instance.DownloadAssetAsync(releaseAsset, nitefoxConfig.FfmpegLocation);
 
         await Task.Run(async () =>
         {
@@ -87,7 +79,7 @@ await Task.Run(async () =>
             {
                 if (!reader.Entry.IsDirectory)
                 {
-                    reader.WriteEntryToDirectory(_nitefoxConfig.FfmpegLocation, new ExtractionOptions()
+                    reader.WriteEntryToDirectory(nitefoxConfig.FfmpegLocation, new ExtractionOptions()
                     {
                         ExtractFullPath = true,
                         Overwrite = true

Nitefox.App/Media/MediaDownloader.cs

@@ -17,28 +17,16 @@
 
 namespace Nitefox.App.Media;
 
-public class MediaDownloader
+public class MediaDownloader(
+    IFileService fileService,
+    FfmpegService ffmpegService,
+    NitefoxConfig nitefoxConfig,
+    MetadataService metadataService)
 {
-    private readonly IFileService _fileService;
-    private readonly DataStore _mediaDataStore;
-    private readonly FfmpegService _ffmpegService;
-    private readonly NitefoxConfig _nitefoxConfig;
-    private readonly MetadataService _metadataService;
-
-    public MediaDownloader(
-        IFileService fileService,
-        FfmpegService ffmpegService,
-        NitefoxConfig nitefoxConfig,
-        MetadataService metadataService)
-    {
-        _fileService = fileService;
-        _ffmpegService = ffmpegService;
-        _nitefoxConfig = nitefoxConfig;
-        _metadataService = metadataService;
-        _mediaDataStore = new DataStore($"{_nitefoxConfig.DownloadLocation}downloads.json",
-            reloadBeforeGetCollection: true);
-    }
 
+    private readonly DataStore _mediaDataStore = new ($"{nitefoxConfig.DownloadLocation}downloads.json",
+        reloadBeforeGetCollection: true);
+
     public async Task<TrackDownload> Download(string title, string url, string author, string? collection = null)
     {
         var trackDownload = new TrackDownload
@@ -51,12 +39,12 @@ public async Task<TrackDownload> Download(string title, string url, string autho
 
         try
         {
-            await _ffmpegService.DownloadFfmpeg();
+            await ffmpegService.DownloadFfmpeg();
 
-            _ffmpegService.ConfigureFfmpeg();
-            _fileService.SetupDirectories();
+            ffmpegService.ConfigureFfmpeg();
+            fileService.SetupDirectories();
 
-            var streamUrl = await _metadataService.GetYoutubeSongStream(url);
+            var streamUrl = await metadataService.GetYoutubeSongStream(url);
 
             if (string.IsNullOrWhiteSpace(streamUrl))
             {
@@ -65,12 +53,12 @@ public async Task<TrackDownload> Download(string title, string url, string autho
 
             if (collection is not null)
             {
-                var songAlbumPath = $"{_nitefoxConfig.DownloadLocation}{collection}\\";
+                var songAlbumPath = $"{nitefoxConfig.DownloadLocation}{collection}\\";
 
                 trackDownload.Collection = collection;
                 trackDownload.SavePath = $"{songAlbumPath}{songSaveName}";
                 trackDownload.IsDownloaded =
-                    await _ffmpegService.StreamConvert(streamUrl, $"{songAlbumPath}{songSaveName}");
+                    await ffmpegService.StreamConvert(streamUrl, $"{songAlbumPath}{songSaveName}");
 
                 if (trackDownload.IsDownloaded)
                 {
@@ -81,9 +69,9 @@ await _mediaDataStore.GetCollection<TrackDownload>()
                 return trackDownload;
             }
 
-            trackDownload.SavePath = $"{_nitefoxConfig.DownloadLocation}{songSaveName}";
+            trackDownload.SavePath = $"{nitefoxConfig.DownloadLocation}{songSaveName}";
             trackDownload.IsDownloaded =
-                await _ffmpegService.StreamConvert(streamUrl, $"{_nitefoxConfig.DownloadLocation}{songSaveName}");
+                await ffmpegService.StreamConvert(streamUrl, $"{nitefoxConfig.DownloadLocation}{songSaveName}");
 
             if (trackDownload.IsDownloaded)
             {
@@ -102,9 +90,9 @@ await _mediaDataStore.GetCollection<TrackDownload>()
 
     public async IAsyncEnumerable<TrackDownload> DownloadAlbum(string title, string id)
     {
-        _fileService.CreateMediaDirectory(_nitefoxConfig.DownloadLocation, title.ToPathSafeString());
+        fileService.CreateMediaDirectory(nitefoxConfig.DownloadLocation, title.ToPathSafeString());
 
-        foreach (var track in await _metadataService.GetAlbumTracksMetadata(id, title))
+        foreach (var track in await metadataService.GetAlbumTracksMetadata(id, title))
         {
             var authors = track.Artists.Select(artist => artist.Name).Take(3).ToDelimitedString();
             yield return await Download(track.Title, track.Url, authors, title.ToPathSafeString());
@@ -113,9 +101,9 @@ public async IAsyncEnumerable<TrackDownload> DownloadAlbum(string title, string
 
     public async IAsyncEnumerable<TrackDownload> DownloadPlaylist(string title, string id)
     {
-        _fileService.CreateMediaDirectory(_nitefoxConfig.DownloadLocation, title.ToPathSafeString());
+        fileService.CreateMediaDirectory(nitefoxConfig.DownloadLocation, title.ToPathSafeString());
 
-        foreach (var track in await _metadataService.GetPlaylistTracksMetadata(id, title))
+        foreach (var track in await metadataService.GetPlaylistTracksMetadata(id, title))
         {
             var authors = track.Artists.Select(artist => artist.Name).Take(3).ToDelimitedString();
             yield return await Download(track.Title, track.Url, authors, title.ToPathSafeString());

Nitefox.App/Media/MediaSearch.cs

@@ -14,15 +14,8 @@
 
 namespace Nitefox.App.Media;
 
-public class MediaSearch
+public class MediaSearch(SpotifyClient spotifyClient)
 {
-    private readonly SpotifyClient _spotifyClient;
-
-    public MediaSearch(SpotifyClient spotifyClient)
-    {
-        _spotifyClient = spotifyClient;
-    }
-
     public async Task<IEnumerable<ISearchResult>> SearchAsync(string query, int limit = Int32.MaxValue, int skip = 0)
     {
         try
@@ -31,15 +24,15 @@ public async Task<IEnumerable<ISearchResult>> SearchAsync(string query, int limi
 
             if (query.Contains("album", StringComparison.InvariantCultureIgnoreCase))
             {
-                return await _spotifyClient.Search.GetAlbumsAsync(cleanQuery, skip, limit);
+                return await spotifyClient.Search.GetAlbumsAsync(cleanQuery, skip, limit);
             }
 
             if (query.Contains("playlist", StringComparison.InvariantCultureIgnoreCase))
             {
-                return await _spotifyClient.Search.GetPlaylistsAsync(cleanQuery, skip, limit);
+                return await spotifyClient.Search.GetPlaylistsAsync(cleanQuery, skip, limit);
             }
 
-            return await _spotifyClient.Search.GetTracksAsync(cleanQuery, skip, limit);
+            return await spotifyClient.Search.GetTracksAsync(cleanQuery, skip, limit);
         }
         catch (Exception e)
         {

Nitefox.App/Media/MetadataService.cs

@@ -15,34 +15,25 @@
 
 namespace Nitefox.App.Media;
 
-public class MetadataService
+public class MetadataService(SpotifyClient spotifyClient, YoutubeClient youtubeClient)
 {
-    private readonly SpotifyClient _spotifyClient;
-    private readonly YoutubeClient _youtubeClient;
-
-    public MetadataService(SpotifyClient spotifyClient, YoutubeClient youtubeClient)
-    {
-        _spotifyClient = spotifyClient;
-        _youtubeClient = youtubeClient;
-    }
-
     public async Task<int> GetAlbumTrackCount(string id)
     {
-        var album = await _spotifyClient.Albums.GetAsync(id);
+        var album = await spotifyClient.Albums.GetAsync(id);
         return album.Tracks.Count;
     }
 
     public async Task<int> GetPlaylistTrackCount(string id)
     {
-        var playlists = await _spotifyClient.Playlists.GetAsync(id);
+        var playlists = await spotifyClient.Playlists.GetAsync(id);
         return playlists.Tracks.Count;
     }
 
     public async Task<string> GetAlbumImageUrl(string id)
     {
         try
         {
-            var album = await _spotifyClient.Albums.GetAsync(id);
+            var album = await spotifyClient.Albums.GetAsync(id);
             var image = album.Images.FirstOrDefault(image => !string.IsNullOrWhiteSpace(image.Url));
             if (image is null) return string.Empty;
             return image.Url;
@@ -61,7 +52,7 @@ public async Task<string> GetPlaylistImageUrl(string id)
     {
         try
         {
-            var tracks = await _spotifyClient.Playlists.GetTracksAsync(id, limit: 5);
+            var tracks = await spotifyClient.Playlists.GetTracksAsync(id, limit: 5);
             var playlistImages = tracks.SelectMany(track => track.Album.Images)
                 .Where(image => !string.IsNullOrWhiteSpace(image.Url));
             var image = playlistImages.FirstOrDefault(image => !string.IsNullOrWhiteSpace(image.Url));
@@ -80,30 +71,30 @@ public async Task<string> GetPlaylistImageUrl(string id)
 
     public async Task<string> GetYoutubeSongStream(string url)
     {
-        var youtubeId = await _spotifyClient.Tracks.GetYoutubeIdAsync(url);
-        var streamManifest = await _youtubeClient.Videos.Streams.GetManifestAsync($"https://youtube.com/watch?v={youtubeId}");
+        var youtubeId = await spotifyClient.Tracks.GetYoutubeIdAsync(url);
+        var streamManifest = await youtubeClient.Videos.Streams.GetManifestAsync($"https://youtube.com/watch?v={youtubeId}");
         return streamManifest.GetAudioOnlyStreams().GetWithHighestBitrate().Url;
     }
 
     public async Task<string> GetPreviewStream(string url)
     {
-        var youtubeId = await _spotifyClient.Tracks.GetYoutubeIdAsync(url);
-        var streamManifest = await _youtubeClient.Videos.Streams.GetManifestAsync($"https://youtube.com/watch?v={youtubeId}");
+        var youtubeId = await spotifyClient.Tracks.GetYoutubeIdAsync(url);
+        var streamManifest = await youtubeClient.Videos.Streams.GetManifestAsync($"https://youtube.com/watch?v={youtubeId}");
         return streamManifest.GetAudioOnlyStreams()
             .OrderByDescending(stream => stream.Size)
             .First().Url;
     }
 
     public async Task<IEnumerable<Track>> GetAlbumTracksMetadata(string id, string title)
     {
-        var tracks = await _spotifyClient.Albums.GetAllTracksAsync(id);
+        var tracks = await spotifyClient.Albums.GetAllTracksAsync(id);
         return tracks.AsEnumerable();
     }
 
 
     public async Task<IEnumerable<Track>> GetPlaylistTracksMetadata(string id, string title)
     {
-        var tracks = await _spotifyClient.Playlists.GetAllTracksAsync(id);
+        var tracks = await spotifyClient.Playlists.GetAllTracksAsync(id);
         return tracks.AsEnumerable();
     }
 

Nitefox.App/Nitefox.App.csproj

@@ -1,10 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <PublishAot>true</PublishAot>
+        <LangVersion>12</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
@@ -17,6 +18,7 @@
       <PackageReference Include="Russkyc.Configuration" Version="1.0.1" />
       <PackageReference Include="SharpCompress" Version="0.34.1" />
       <PackageReference Include="SpotifyExplode" Version="1.0.7" />
+      <PackageReference Include="TagLibSharp" Version="2.3.0" />
       <PackageReference Include="YoutubeExplode" Version="6.3.6" />
     </ItemGroup>
 

Nitefox.App/States/MediaPlayerState.cs

@@ -22,7 +22,6 @@ public void Play(string track, string url)
     {
         Track = track;
         StreamUrl = url;
-        Loaded = true;
     }
 
     public void Stop()

Nitefox.Client.Photino/Nitefox.Client.Photino.csproj

@@ -2,8 +2,9 @@
 
     <PropertyGroup>
         <OutputType>WinExe</OutputType>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <ApplicationIcon>nitefox_icon.ico</ApplicationIcon>
+        <LangVersion>12</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>

Nitefox.Client.Photino/Services/PhotinoFileService.cs

@@ -16,26 +16,18 @@
 
 namespace Nitefox.Client.Photino.Services;
 
-public class PhotinoFileService : IFileService
+public class PhotinoFileService(NitefoxConfig nitefoxConfig) : IFileService
 {
-    private readonly NitefoxConfig _nitefoxConfig;
-
-    public PhotinoFileService(NitefoxConfig nitefoxConfig)
-    {
-        _nitefoxConfig = nitefoxConfig;
-        SetupDirectories();
-    }
-    
-    public async Task<string> OpenFolder()
+    public Task<string> OpenFolder()
     {
         try
         {
             var path = Program.App.MainWindow.ShowOpenFolder();
-            return path[0];
+            return Task.FromResult(path[0]);
         }
         catch (Exception)
         {
-            return "";
+            return Task.FromResult("");
         }
     }
 
@@ -54,34 +46,34 @@ public bool CreateMediaDirectory(string basePath, string directoryName)
 
     public void SetupDirectories()
     {
-        if (string.IsNullOrWhiteSpace(_nitefoxConfig.DownloadLocation))
+        if (string.IsNullOrWhiteSpace(nitefoxConfig.DownloadLocation))
         {
-            _nitefoxConfig.DownloadLocation = Environment.CurrentDirectory + "\\songs\\";
+            nitefoxConfig.DownloadLocation = Environment.CurrentDirectory + "\\songs\\";
         }
 
-        if (!Directory.Exists(_nitefoxConfig.DownloadLocation))
+        if (!Directory.Exists(nitefoxConfig.DownloadLocation))
         {
-            Directory.CreateDirectory(_nitefoxConfig.DownloadLocation);
+            Directory.CreateDirectory(nitefoxConfig.DownloadLocation);
         }
 
-        if (string.IsNullOrWhiteSpace(_nitefoxConfig.TempFilesLocation))
+        if (string.IsNullOrWhiteSpace(nitefoxConfig.TempFilesLocation))
         {
-            _nitefoxConfig.TempFilesLocation = Environment.CurrentDirectory + "\\temp\\";
+            nitefoxConfig.TempFilesLocation = Environment.CurrentDirectory + "\\temp\\";
         }
 
-        if (!Directory.Exists(_nitefoxConfig.TempFilesLocation))
+        if (!Directory.Exists(nitefoxConfig.TempFilesLocation))
         {
-            Directory.CreateDirectory(_nitefoxConfig.TempFilesLocation);
+            Directory.CreateDirectory(nitefoxConfig.TempFilesLocation);
         }
 
-        if (string.IsNullOrWhiteSpace(_nitefoxConfig.FfmpegLocation))
+        if (string.IsNullOrWhiteSpace(nitefoxConfig.FfmpegLocation))
         {
-            _nitefoxConfig.FfmpegLocation = Environment.CurrentDirectory + "\\ffmpeg\\";
+            nitefoxConfig.FfmpegLocation = Environment.CurrentDirectory + "\\ffmpeg\\";
         }
 
-        if (!Directory.Exists(_nitefoxConfig.FfmpegLocation))
+        if (!Directory.Exists(nitefoxConfig.FfmpegLocation))
         {
-            Directory.CreateDirectory(_nitefoxConfig.FfmpegLocation);
+            Directory.CreateDirectory(nitefoxConfig.FfmpegLocation);
         }
     }
 }