Breaking Change: Update dependencies (#3)

axunonb · web-flow · commit 811f592f9e72 · 2023-01-10T12:00:57.000+01:00
* breaking changes: Bump version to v2.0.0

breaking change(VirtualFileSystem): Update dependencies
* Microsoft.Extensions.FileProviders.Composite v6 =&gt; v7.0.0
* Microsoft.Extensions.FileProviders.Embedded v6 =&gt; v7.0.0
* Microsoft.Extensions.FileProviders.Physical" v6 =&gt; v7.0.0
* Microsoft.Extensions.Options v6 =&gt; v7.0.0
chore: Update .editorconfig

breaking change(VirtualFileSystem.Tests): Update dependencies
* Microsoft.Extensions.DependencyInjection v6 =&gt; v7.0.0
* Microsoft.Extensions.Logging.Abstractions v6 =&gt; v7.0.0
* Microsoft.NET.Test.Sdk v17.2.0 =&gt; v17.4.1
* NUnit3TestAdapter v4.2.1. =&gt; 4.3.1

chore: Update GitHub action
chore: disable warnings CS8766, CS1591
chore: Refacturing using latest language featrues

* chore: Update depreciated GitHub actions

* use actions/checkout@v3
* use actions/setup-dotnet@v2

* chore: Create artifacts with GitHub action
diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml
@@ -2,25 +2,50 @@ name: .NET
 
 on:
   push:
-    branches: [ main ]
+    branches: [ main, 'version/**', 'pr/**', 'pr-**' ]
+    paths-ignore:
+      - '**/*.md'
   pull_request:
-    branches: [ main ]
+    branches: [ main, 'version/**', 'pr/**', 'pr-**' ]
+    types: [opened, synchronize, reopened]
+    paths-ignore:
+      - '**/*.md'
 
 jobs:
   build:
-
-    runs-on: ubuntu-latest
+    name: Build
+    runs-on: ${{ matrix.os }}
+    env:
+      version: '2.0.0'
+      versionFile: '2.0.0'
+      packDotNetVersion: '6'
     strategy:
       matrix:
-        dotnet-version: [ '3.1.x', '5.0.x' ]
+        os: [ ubuntu-latest ]
+        dotnet-version: [ '3.x', '6.x' ]
 
     steps:
-    - uses: actions/checkout@v2
+    - name: Checkout
+      uses: actions/checkout@v3
     - name: Setup .NET
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: ${{ matrix.dotnet-version }}
     - name: Restore dependencies
       run: dotnet restore ./Src/VirtualFileSystem.sln
     - name: Build
       run: dotnet build --no-restore ./Src/VirtualFileSystem.sln
     - name: Test
       run: dotnet test --no-build --verbosity normal ./Src/VirtualFileSystem.sln
+    - name: Pack
+      if: startsWith(matrix.dotnet-version, env.packDotNetVersion)
+      run: |
+        echo "Packing Version: ${{ env.version }}, File Version: ${{ env.versionFile }}"
+        dotnet build ./Src/VirtualFileSystem.sln /verbosity:minimal --configuration release /p:IncludeSymbols=true /p:SymbolPackageFormat=snupkg /p:ContinuousIntegrationBuild=true /p:PackageOutputPath=${{ github.workspace }}/artifacts/ /p:Version=${{ env.version }} /p:FileVersion=${{ env.versionFile }}
+        dotnet pack ./Src/VirtualFileSystem.sln /verbosity:minimal --configuration release
+    - name: Upload Artifacts
+      uses: actions/upload-artifact@v3
+      if: startsWith(matrix.dotnet-version, env.packDotNetVersion)
+      with:
+        name: Packages_${{ env.version }}
+        path: ${{ github.workspace }}/artifacts/
diff --git a/COPYRIGHT.md b/COPYRIGHT.md
@@ -1,3 +1,3 @@
 # Copyright
 
-© 2013 - 2020 [Volosoft](https://volosoft.com/) Open source license with [LGPLv3.0](LICENSE.md)
+© 2013 - 2023 [Volosoft](https://volosoft.com/) Open source license with [LGPLv3.0](LICENSE.md)
diff --git a/README.md b/README.md
@@ -6,19 +6,19 @@
 
 The Virtual File System makes it possible to manage files that do not exist on a physical file system (e.g. disk).
 
-* The ```VirtualFileSystem``` can be extended by additional ```IVirtualFileProvider```s.
-* Out-of-the-box, ```Microsoft.Extensions.FileProviders.Composite```, ```Microsoft.Extensions.FileProviders.Embedded``` and ```Microsoft.Extensions.FileProviders.Physical``` are integrated.
+* The `VirtualFileSystem` can be extended by additional `IVirtualFileProvider`s.
+* Out-of-the-box, `Microsoft.Extensions.FileProviders.Composite`, `Microsoft.Extensions.FileProviders.Embedded` and `Microsoft.Extensions.FileProviders.Physical` are integrated.
 * Virtual files can be used just like static files in an application.
 * JavaScript, CSS, image files and all other file types can be embedded into assemblies and used just like the static files.
 * An application (or library) can override an embedded file just by placing a static file with the same name and extension into the same folder of the virtual file system.
 
 
-The library is a modified version of [Volo.Abp.VirtualFileSystem](https://github.com/abpframework/abp/tree/dev/framework/src/Volo.Abp.VirtualFileSystem) 4.1
-Modifications to the source code were made by axuno in 2020/21. Changes focused on:
+The library is a modified version of [Volo.Abp.VirtualFileSystem](https://github.com/abpframework/abp/tree/dev/framework/src/Volo.Abp.VirtualFileSystem) 7.0
+Modifications to the source code were made by axuno in 2020-23. Changes focused on:
 
 * Decouple Volo.Abp.VirtualFileSystem from all dependencies of the Abp Framework
 * Use Microsoft DependencyInjection instead of [AutoFac](https://autofac.org/)
-* Add a workaround, so that ```VirtualFileProvider``` will also find existing directories returned from ```PhysicalFileProvider```. This means, that ```VirtualFileProvider``` behaves the same, never mind whether files are retrieved using ```EmbeddedFileProvider``` or ```PhysicalFileProvider```.
+* Add a workaround, so that `VirtualFileProvider` will also find existing directories returned from `PhysicalFileProvider`. This means, that `VirtualFileProvider` behaves the same, never mind whether files are retrieved using `EmbeddedFileProvider` or `PhysicalFileProvider`.
 * Change of namespaces
 
 ### Get started
diff --git a/Src/.editorconfig b/Src/.editorconfig
@@ -147,7 +147,7 @@ dotnet_style_qualification_for_property = false:suggestion
 csharp_indent_labels = one_less_than_current
 csharp_using_directive_placement = outside_namespace:silent
 csharp_prefer_simple_using_statement = true:suggestion
-csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_namespace_declarations = file_scoped:silent
 csharp_style_expression_bodied_operators = false:silent
 csharp_style_expression_bodied_indexers = true:silent
 csharp_style_expression_bodied_lambdas = true:silent
diff --git a/Src/Axuno.VirtualFileSystem.Tests/Axuno.VirtualFileSystem.Tests.csproj b/Src/Axuno.VirtualFileSystem.Tests/Axuno.VirtualFileSystem.Tests.csproj
@@ -4,8 +4,6 @@
     <OutputType>Exe</OutputType>
     <TargetFrameworks>net60</TargetFrameworks>
     <SignAssembly>true</SignAssembly>
-    <Nullable>enable</Nullable>
-    <LangVersion>latest</LangVersion>
     <AssemblyOriginatorKeyFile>..\Axuno.VirtualFileSystem\Axuno.VirtualFileSystem.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
 
@@ -23,11 +21,11 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="7.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Src/Axuno.VirtualFileSystem/Axuno.VirtualFileSystem.csproj b/Src/Axuno.VirtualFileSystem/Axuno.VirtualFileSystem.csproj
@@ -3,29 +3,26 @@
     <PropertyGroup>
         <TargetFrameworks>netstandard2.1;net60</TargetFrameworks>
         <Nullable>enable</Nullable>
-        <LangVersion>latest</LangVersion>
+        <NoWarn>$(NoWarn);1591</NoWarn>
         <SignAssembly>true</SignAssembly>
         <!-- sn -k Axuno.VirtualFileSystem.snk -->
         <AssemblyOriginatorKeyFile>Axuno.VirtualFileSystem.snk</AssemblyOriginatorKeyFile>
-        <Version>1.0.1</Version>
-        <Authors>axuno gGmbH</Authors>
-        <Company>axuno gGmbH</Company>
         <PackageLicenseExpression>LGPL-3.0-only</PackageLicenseExpression>
-        <PackageIcon>VirtualFileSystem.png</PackageIcon>
         <RepositoryUrl>https://github.com/axuno/Axuno.VirtualFileSystem</RepositoryUrl>
         <RepositoryType>Git</RepositoryType>
+        <PublishRepositoryUrl>true</PublishRepositoryUrl>
+        <PackageIcon>VirtualFileSystem.png</PackageIcon>
         <PackageTags>virtual file system netstandard c#</PackageTags>
-        <PackageReleaseNotes>Fixed possible null reference issues
-Bumped to v1.0.1</PackageReleaseNotes>
-        <Copyright>© 2013 - 2021 Volosoft. Open source license with LGPLv3.0</Copyright>
+        <PackageReleaseNotes>Bumped to v2.0.0
+Breaking changes caused by updated dependencies</PackageReleaseNotes>
         <Description>The Virtual File System makes it possible to manage files that do not exist on a physical file system (e.g. disk).
 
 * The VirtualFileSystem can be extended by additional IVirtualFileProviders.
 * Out-of-the-box, Microsoft.Extensions.FileProviders.Composite, Microsoft.Extensions.FileProviders.Embedded and Microsoft.Extensions.FileProviders.Physical are integrated.
 * Virtual files can be used just like static files in an application.
 * JavaScript, CSS, image files and all other file types can be embedded into assemblies and used just like the static files.
 
-The library is a modified version of Volo.Abp.VirtualFileSystem 4.2</Description>
+The library is a modified version of Volo.Abp.VirtualFileSystem 7.0</Description>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     </PropertyGroup>
@@ -47,10 +44,10 @@ The library is a modified version of Volo.Abp.VirtualFileSystem 4.2</Description
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.Extensions.FileProviders.Composite" Version="6.0.0" />
-        <PackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="6.0.5" />
-        <PackageReference Include="Microsoft.Extensions.FileProviders.Physical" Version="6.0.0" />
-        <PackageReference Include="Microsoft.Extensions.Options" Version="6.0.0" />
+        <PackageReference Include="Microsoft.Extensions.FileProviders.Composite" Version="7.0.0" />
+        <PackageReference Include="Microsoft.Extensions.FileProviders.Embedded" Version="7.0.1" />
+        <PackageReference Include="Microsoft.Extensions.FileProviders.Physical" Version="7.0.0" />
+        <PackageReference Include="Microsoft.Extensions.Options" Version="7.0.0" />
         <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1">
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/Src/Axuno.VirtualFileSystem/DictionaryBasedFileProvider.cs b/Src/Axuno.VirtualFileSystem/DictionaryBasedFileProvider.cs
@@ -12,7 +12,7 @@ public virtual IFileInfo GetFileInfo(string subPath)
     {
         if (subPath == null)
         {
-            return new NotFoundFileInfo(subPath);
+            return new NotFoundFileInfo(subPath ?? "(null)");
         }
 
         var file = Files.GetOrDefault(NormalizePath(subPath));
@@ -44,8 +44,8 @@ public virtual IDirectoryContents GetDirectoryContents(string subPath)
                 continue;
             }
 
-            var relativePath = fullPath.Substring(directoryPath.Length);
-            if (relativePath.Contains("/"))
+            var relativePath = fullPath[directoryPath.Length..];
+            if (relativePath.Contains('/'))
             {
                 continue;
             }
diff --git a/Src/Axuno.VirtualFileSystem/Embedded/EmbeddedFileProvider.cs b/Src/Axuno.VirtualFileSystem/Embedded/EmbeddedFileProvider.cs
@@ -41,9 +41,9 @@ public void AddFiles(Dictionary<string, IFileInfo> files)
 
             var fullPath = ConvertToRelativePath(resourcePath).EnsureStartsWith('/');
 
-            if (fullPath.Contains("/"))
+            if (fullPath.Contains('/'))
             {
-                AddDirectoriesRecursively(files, fullPath.Substring(0, fullPath.LastIndexOf('/')), lastModificationTime);
+                AddDirectoriesRecursively(files, fullPath[..fullPath.LastIndexOf('/')], lastModificationTime);
             }
 
             files[fullPath] = new EmbeddedResourceFileInfo(
@@ -69,9 +69,9 @@ private static void AddDirectoriesRecursively(Dictionary<string, IFileInfo> file
             lastModificationTime
         );
 
-        if (directoryPath.Contains("/"))
+        if (directoryPath.Contains('/'))
         {
-            AddDirectoriesRecursively(files, directoryPath.Substring(0, directoryPath.LastIndexOf('/')), lastModificationTime);
+            AddDirectoriesRecursively(files, directoryPath[..directoryPath.LastIndexOf('/')], lastModificationTime);
         }
     }
 
@@ -100,7 +100,7 @@ private string ConvertToRelativePath(string resourceName)
     {
         if (!BaseNamespace.IsNullOrEmpty())
         {
-            resourceName = resourceName.Substring(BaseNamespace.Length + 1);
+            resourceName = resourceName[(BaseNamespace.Length + 1)..];
         }
 
         var pathParts = resourceName.Split('.');
@@ -110,19 +110,19 @@ private string ConvertToRelativePath(string resourceName)
         }
 
         var folder = string.Join("/", pathParts.Take(pathParts.Length - 2));
-        var fileName = pathParts[pathParts.Length - 2] + "." + pathParts[pathParts.Length - 1];
+        var fileName = pathParts[^2] + "." + pathParts[^1];
 
         return folder + "/" + fileName;
     }
 
     private static string CalculateFileName(string filePath)
     {
-        if (!filePath.Contains("/"))
+        if (!filePath.Contains('/'))
         {
             return filePath;
         }
 
-        return filePath.Substring(filePath.LastIndexOf("/", StringComparison.Ordinal) + 1);
+        return filePath[(filePath.LastIndexOf("/", StringComparison.Ordinal) + 1)..];
     }
         
     protected override string NormalizePath(string subpath)
@@ -136,4 +136,4 @@ private Dictionary<string, IFileInfo> CreateFiles()
         AddFiles(files);
         return files;
     }
-}
+}
diff --git a/Src/Axuno.VirtualFileSystem/Embedded/EmbeddedResourceFileInfo.cs b/Src/Axuno.VirtualFileSystem/Embedded/EmbeddedResourceFileInfo.cs
@@ -67,10 +67,12 @@ public long Length
     private readonly string _resourcePath;
 
     /// <inheritdoc />
+#pragma warning disable CS8766
     public Stream? CreateReadStream()
     {
+#pragma warning restore CS8766
         var stream = _assembly.GetManifestResourceStream(_resourcePath);
-
+        
         if (!_length.HasValue && stream != null)
         {
             _length = stream.Length;
@@ -81,6 +83,6 @@ public long Length
 
     public override string ToString()
     {
-        return $"[EmbeddedResourceFileInfo] {Name} ({this.VirtualPath})";
+        return $"[EmbeddedResourceFileInfo] {Name} ({VirtualPath})";
     }
-}
+}
diff --git a/Src/Axuno.VirtualFileSystem/StringExtensions.cs b/Src/Axuno.VirtualFileSystem/StringExtensions.cs
@@ -71,7 +71,7 @@ public static string Left(this string str, int len)
             throw new ArgumentException("len argument can not be bigger than given string's length!");
         }
 
-        return str.Substring(0, len);
+        return str[..len];
     }
 
     /// <summary>
@@ -191,7 +191,7 @@ public static string ReplaceFirst(this string str, string search, string replace
             return str;
         }
 
-        return str.Substring(0, pos) + replace + str[(pos + search.Length)..];
+        return str[..pos] + replace + str[(pos + search.Length)..];
     }
 
     /// <summary>
@@ -399,7 +399,9 @@ public static T ToEnum<T>(this string value, bool ignoreCase)
 
     public static string ToMd5(this string str)
     {
+#pragma warning disable CA5351
         using var md5 = MD5.Create();
+#pragma warning restore CA5351
         var inputBytes = Encoding.UTF8.GetBytes(str);
         var hashBytes = md5.ComputeHash(inputBytes);
 
@@ -531,4 +533,4 @@ public static string CheckNotNull(string value, string parameterName, int maxLen
 
         return value;
     }
-}
+}
diff --git a/Src/Axuno.VirtualFileSystem/VirtualFilePathHelper.cs b/Src/Axuno.VirtualFileSystem/VirtualFilePathHelper.cs
@@ -15,17 +15,17 @@ public static string NormalizePath(string fullPath)
         var fileName = fullPath;
         var extension = "";
 
-        if (fileName.Contains("."))
+        if (fileName.Contains('.'))
         {
-            extension = fullPath.Substring(fileName.LastIndexOf(".", StringComparison.Ordinal));
-            if (extension.Contains("/"))
+            extension = fullPath[fileName.LastIndexOf(".", StringComparison.Ordinal)..];
+            if (extension.Contains('/'))
             {
                 //That means the file does not have extension, but a directory has "." char. So, clear extension.
                 extension = "";
             }
             else
             {
-                fileName = fullPath.Substring(0, fullPath.Length - extension.Length);
+                fileName = fullPath[..^extension.Length];
             }
         }
 
@@ -43,4 +43,4 @@ private static string NormalizeChars(string fileName)
 
         return string.Join("/",folderParts.Take(folderParts.Length - 1).Select(s => s.Replace("-", "_"))) + "/" + folderParts.Last();
     }
-}
+}
diff --git a/Src/Axuno.VirtualFileSystem/VirtualFileProvider.cs b/Src/Axuno.VirtualFileSystem/VirtualFileProvider.cs
@@ -37,7 +37,7 @@ public virtual IFileInfo GetFileInfo(string subPath)
         var content = _compositeFileProvider.GetDirectoryContents(string.Join('/', pathSegments.SkipLast(1)));
         var directory = content.FirstOrDefault(fi => fi.Name == pathSegments[^1] && fi.IsDirectory);
 
-        return !(directory is null) ? new VirtualDirectoryFileInfo(directory.PhysicalPath, directory.Name, directory.LastModified) : fileInfo;
+        return directory is { } ? new VirtualDirectoryFileInfo(directory.PhysicalPath ?? string.Empty, directory.Name, directory.LastModified) : fileInfo;
     }
 
     public virtual IDirectoryContents GetDirectoryContents(string subPath)
diff --git a/Src/Directory.Build.props b/Src/Directory.Build.props
@@ -0,0 +1,20 @@
+<Project>
+
+    <PropertyGroup>
+        <Product>Axuno.VirtualFileSystem</Product>
+        <Version>2.0.0</Version>
+        <FileVersion>2.0.0</FileVersion>
+        <AssemblyVersion>2.0.0.0</AssemblyVersion> <!--only update AssemblyVersion with major releases -->
+        <Company>axuno gGmbH</Company>
+        <Authors>axuno gGmbH</Authors>
+        <CurrentYear>$([System.DateTime]::Now.ToString(yyyy))</CurrentYear>
+        <Copyright>© 2013-$(CurrentYear) Volosoft. Open source license with LGPLv3.0</Copyright>
+        <LangVersion>latest</LangVersion>
+        <EnableNETAnalyzers>true</EnableNETAnalyzers>
+        <AnalysisMode>Default</AnalysisMode>
+        <AnalysisModeSecurity>All</AnalysisModeSecurity>
+        <AnalysisLevel>latest</AnalysisLevel>
+        <Features>strict</Features>
+    </PropertyGroup>
+
+</Project>

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`	`1`	`# Copyright`
`2`	`2`
`3`		`-© 2013 - 2020 [Volosoft](https://volosoft.com/) Open source license with [LGPLv3.0](LICENSE.md)`
	`3`	`+© 2013 - 2023 [Volosoft](https://volosoft.com/) Open source license with [LGPLv3.0](LICENSE.md)`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public virtual IFileInfo GetFileInfo(string subPath)`
`12`	`12`	`{`
`13`	`13`	`if (subPath == null)`
`14`	`14`	`{`
`15`		`- return new NotFoundFileInfo(subPath);`
	`15`	`+ return new NotFoundFileInfo(subPath ?? "(null)");`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`var file = Files.GetOrDefault(NormalizePath(subPath));`
`@@ -44,8 +44,8 @@ public virtual IDirectoryContents GetDirectoryContents(string subPath)`
`44`	`44`	`continue;`
`45`	`45`	`}`
`46`	`46`
`47`		`- var relativePath = fullPath.Substring(directoryPath.Length);`
`48`		`- if (relativePath.Contains("/"))`
	`47`	`+ var relativePath = fullPath[directoryPath.Length..];`
	`48`	`+ if (relativePath.Contains('/'))`
`49`	`49`	`{`
`50`	`50`	`continue;`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,9 +41,9 @@ public void AddFiles(Dictionary<string, IFileInfo> files)`
`41`	`41`
`42`	`42`	`var fullPath = ConvertToRelativePath(resourcePath).EnsureStartsWith('/');`
`43`	`43`
`44`		`- if (fullPath.Contains("/"))`
	`44`	`+ if (fullPath.Contains('/'))`
`45`	`45`	`{`
`46`		`- AddDirectoriesRecursively(files, fullPath.Substring(0, fullPath.LastIndexOf('/')), lastModificationTime);`
	`46`	`+ AddDirectoriesRecursively(files, fullPath[..fullPath.LastIndexOf('/')], lastModificationTime);`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`files[fullPath] = new EmbeddedResourceFileInfo(`
`@@ -69,9 +69,9 @@ private static void AddDirectoriesRecursively(Dictionary<string, IFileInfo> file`
`69`	`69`	`lastModificationTime`
`70`	`70`	`);`
`71`	`71`
`72`		`- if (directoryPath.Contains("/"))`
	`72`	`+ if (directoryPath.Contains('/'))`
`73`	`73`	`{`
`74`		`- AddDirectoriesRecursively(files, directoryPath.Substring(0, directoryPath.LastIndexOf('/')), lastModificationTime);`
	`74`	`+ AddDirectoriesRecursively(files, directoryPath[..directoryPath.LastIndexOf('/')], lastModificationTime);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`
`@@ -100,7 +100,7 @@ private string ConvertToRelativePath(string resourceName)`
`100`	`100`	`{`
`101`	`101`	`if (!BaseNamespace.IsNullOrEmpty())`
`102`	`102`	`{`
`103`		`- resourceName = resourceName.Substring(BaseNamespace.Length + 1);`
	`103`	`+ resourceName = resourceName[(BaseNamespace.Length + 1)..];`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`var pathParts = resourceName.Split('.');`
`@@ -110,19 +110,19 @@ private string ConvertToRelativePath(string resourceName)`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`var folder = string.Join("/", pathParts.Take(pathParts.Length - 2));`
`113`		`- var fileName = pathParts[pathParts.Length - 2] + "." + pathParts[pathParts.Length - 1];`
	`113`	`+ var fileName = pathParts[^2] + "." + pathParts[^1];`
`114`	`114`
`115`	`115`	`return folder + "/" + fileName;`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`private static string CalculateFileName(string filePath)`
`119`	`119`	`{`
`120`		`- if (!filePath.Contains("/"))`
	`120`	`+ if (!filePath.Contains('/'))`
`121`	`121`	`{`
`122`	`122`	`return filePath;`
`123`	`123`	`}`
`124`	`124`
`125`		`- return filePath.Substring(filePath.LastIndexOf("/", StringComparison.Ordinal) + 1);`
	`125`	`+ return filePath[(filePath.LastIndexOf("/", StringComparison.Ordinal) + 1)..];`
`126`	`126`	`}`
`127`	`127`
`128`	`128`	`protected override string NormalizePath(string subpath)`
`@@ -136,4 +136,4 @@ private Dictionary<string, IFileInfo> CreateFiles()`
`136`	`136`	`AddFiles(files);`
`137`	`137`	`return files;`
`138`	`138`	`}`
`139`		`-}`
	`139`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -67,10 +67,12 @@ public long Length`
`67`	`67`	`private readonly string _resourcePath;`
`68`	`68`
`69`	`69`	`/// <inheritdoc />`
	`70`	`+#pragma warning disable CS8766`
`70`	`71`	`public Stream? CreateReadStream()`
`71`	`72`	`{`
	`73`	`+#pragma warning restore CS8766`
`72`	`74`	`var stream = _assembly.GetManifestResourceStream(_resourcePath);`
`73`		`-`
	`75`	`+`
`74`	`76`	`if (!_length.HasValue && stream != null)`
`75`	`77`	`{`
`76`	`78`	`_length = stream.Length;`
`@@ -81,6 +83,6 @@ public long Length`
`81`	`83`
`82`	`84`	`public override string ToString()`
`83`	`85`	`{`
`84`		`- return $"[EmbeddedResourceFileInfo] {Name} ({this.VirtualPath})";`
	`86`	`+ return $"[EmbeddedResourceFileInfo] {Name} ({VirtualPath})";`
`85`	`87`	`}`
`86`		`-}`
	`88`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public static string Left(this string str, int len)`
`71`	`71`	`throw new ArgumentException("len argument can not be bigger than given string's length!");`
`72`	`72`	`}`
`73`	`73`
`74`		`- return str.Substring(0, len);`
	`74`	`+ return str[..len];`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`/// <summary>`
`@@ -191,7 +191,7 @@ public static string ReplaceFirst(this string str, string search, string replace`
`191`	`191`	`return str;`
`192`	`192`	`}`
`193`	`193`
`194`		`- return str.Substring(0, pos) + replace + str[(pos + search.Length)..];`
	`194`	`+ return str[..pos] + replace + str[(pos + search.Length)..];`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`/// <summary>`
`@@ -399,7 +399,9 @@ public static T ToEnum<T>(this string value, bool ignoreCase)`
`399`	`399`
`400`	`400`	`public static string ToMd5(this string str)`
`401`	`401`	`{`
	`402`	`+#pragma warning disable CA5351`
`402`	`403`	`using var md5 = MD5.Create();`
	`404`	`+#pragma warning restore CA5351`
`403`	`405`	`var inputBytes = Encoding.UTF8.GetBytes(str);`
`404`	`406`	`var hashBytes = md5.ComputeHash(inputBytes);`
`405`	`407`
`@@ -531,4 +533,4 @@ public static string CheckNotNull(string value, string parameterName, int maxLen`
`531`	`533`
`532`	`534`	`return value;`
`533`	`535`	`}`
`534`		`-}`
	`536`	`+}`