add task register check and delete script if register is failed

Co-authored-by: DismissedLight <1686188646@qq.com>

.config/dotnet-tools.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "cake.tool": {
+      "version": "4.0.0",
+      "commands": [
+        "dotnet-cake"
+      ]
+    }
+  }
+}

.github/ISSUE_TEMPLATE/CHS-bug-report.yml

@@ -22,7 +22,7 @@ body:
         - label: 我知道文档站的导航栏中有**搜索功能**，且已经搜索过相关关键词
           required: true
 
-        - label: 我的问题不是[已修复](https://github.com/DGP-Studio/Snap.Hutao/issues?q=is%3Aopen+is%3Aissue+label%3A%E5%B7%B2%E4%BF%AE%E5%A4%8D)的问题也不是一个别人已发布的**重复的**问题
+        - label: 我的问题不是[已完成](https://github.com/DGP-Studio/Snap.Hutao/issues?q=is%3Aopen+is%3Aissue+label%3A%E5%B7%B2%E5%AE%8C%E6%88%90)的问题也不是一个别人已发布的**重复的**问题
           required: true
 
   - type: input
@@ -51,7 +51,7 @@ body:
       description: | 
         在胡桃工具箱的设置界面，你可以找到并复制你的设备 ID
         如果你的问题涉及程序崩溃，请填写该项，这将有助于我们定位问题
-        如果你的程序已经无法启动，请下载并运行[此PowerShell脚本](https://github.com/DGP-Studio/ISSUE_TEMPLATES/releases/download/get_device_id/GetHutaoDeviceId.ps1)，它将显示你的设备 ID
+        如果你的程序已经无法启动，请下载并运行[此工具](https://github.com/DGP-Automation/ISSUE_TEMPLATES/releases/download/diagnosis_tools/Snap.Hutao.DiagTools.exe)，它将显示你的设备 ID
     validations:
       required: false
 
@@ -85,7 +85,9 @@ body:
     id: what-happened
     attributes:
       label: 发生了什么？
-      description: 详细的描述问题发生前后的行为，以便我们解决问题。**如果你的问题涉及程序崩溃，你应当检查 Windows 事件查看器，并将相关的 `.Net 错误`详情附上**
+      description: |
+        详细的描述问题发生前后的行为，以便我们解决问题。**如果你的问题涉及程序崩溃，你应当检查 Windows 事件查看器，并将相关的 `.Net 错误`详情附上**
+        如果你无法找到该日志，请下载并运行[此工具](https://github.com/DGP-Automation/ISSUE_TEMPLATES/releases/download/diagnosis_tools/Snap.Hutao.DiagTools.exe)，它将转储问题日志至工具运行目录中的 `Snap.Hutao Error Log.txt`
     validations:
       required: true
 

.github/ISSUE_TEMPLATE/ENG-bug-report.yml

@@ -22,7 +22,7 @@ body:
         - label: I and tried **search feature** in Snap Hutao document site, and no associated article
           required: true
 
-        - label: My issue is not a [fixed issue](https://github.com/DGP-Studio/Snap.Hutao/issues?q=is%3Aopen+is%3Aissue+label%3A%E5%B7%B2%E4%BF%AE%E5%A4%8D), and it's not a duplicated issue
+        - label: My issue is not a [finished issue](https://github.com/DGP-Studio/Snap.Hutao/issues?q=is%3Aopen+is%3Aissue+label%3A%E5%B7%B2%E5%AE%8C%E6%88%90), and it's not a duplicated issue
           required: true
 
   - type: input
@@ -51,7 +51,7 @@ body:
       description: | 
         In Snap Hutao's settings page, you can find and copy your device ID
         If your issue is about program crash, please fill this so we can dump the log and locate the source easier
-        If your program cannot startup, please download and run [this PowerShell script](https://github.com/DGP-Studio/ISSUE_TEMPLATES/releases/download/get_device_id/GetHutaoDeviceId.ps1), it will shows your device ID.
+        If your program cannot startup, please download and run [this tool](https://github.com/DGP-Automation/ISSUE_TEMPLATES/releases/download/diagnosis_tools/Snap.Hutao.DiagTools.exe), it will shows your device ID.
     validations:
       required: false
 
@@ -85,7 +85,9 @@ body:
     id: what-happened
     attributes:
       label: What Happened?
-      description: Describe your issue in detail to help us identify the issue. **If your issue is about program crash, you should check Windows Event Viewer, and attach associated `.Net Error` details here**
+      description: |
+        Describe your issue in detail to help us identify the issue. **If your issue is about program crash, you should check Windows Event Viewer, and attach associated `.Net Error` details here**If your program cannot startup, please download and run [this PowerShell script](https://github.com/DGP-Studio/ISSUE_TEMPLATES/releases/download/get_device_id/GetHutaoDeviceId.ps1), it will shows your device ID.
+        If you cannot find it, please download and run [this tool](https://github.com/DGP-Automation/ISSUE_TEMPLATES/releases/download/diagnosis_tools/Snap.Hutao.DiagTools.exe), it will dump the error log to `Snap.Hutao Error Log.txt` in the working directory of the tool.
     validations:
       required: true
 

.github/ISSUE_TEMPLATE/MGMT-publish.yml

@@ -12,44 +12,26 @@ body:
     value: |
 
       ## 创建版本
-    
+
       - [ ]  同步一次 [Crowdin](https://crowdin.com/project/snap-hutao) 翻译
       - [ ]  发布 RC 版本（Optional）
       - [ ]  合并入主分支
       - [ ]  整理更新内容，等待翻译
-      - [ ]  打包
-      - [ ]  提交微软商店
-          - [ ]  包含更新日志
       - [ ]  在 [Snap.Hutao.Docs@next-patch](https://github.com/DGP-Studio/Snap.Hutao.Docs/tree/next-patch) 分支更新文档并直接开 PR
           - [ ]  更新日志
           - [ ]  功能文档更新
-    
-      ## 发布版本
-    
-      - [ ]  在 https://store.rg-adguard.net/ 下载新版本安装包
-          - [ ]  Store URL: https://apps.microsoft.com/store/detail/snap-hutao/9PH4NXJ2JN52
-          - [ ]  命名格式为 `Snap.Hutao x.x.x.msix`
-      - [ ]  Merge 文档 PR
-      - [ ]  发布 Release
-          - [ ]  更新日志格式（以 1.6.2 版本为例）
-    
-      ```jsx
-      ## Update log
-      https://hut.ao/en/statements/update-log.html#_1-6-2
-    
-      ## 更新日志
-      [此处从文档复制]
-    
-      ## What's Changed
-      **Full Changelog**: https://github.com/DGP-Studio/Snap.Hutao/compare/1.6.0...1.6.2
-      ```
-    
-      - [ ]  通知用户
+
+       ***
+
+      - [ ] 主分支合并入 release 分支
+      - [ ] 等待 Release 自动发布
+      - [ ] 检查极狐是否同步完成 Release
+      - [ ] 通知用户
 - type: checkboxes
   id: checklist-final
   attributes:
     label: Final Check
-    description: Understand what you are doing 
+    description: Understand what you are doing
     options:
       - label: I understand that I will get banned from repository if I don't have permission to use this template
-        required: true   
+        required: true

.github/workflows/PublishDistribution.yml

@@ -17,4 +17,4 @@ jobs:
         env:
           PURGE_URL: ${{ secrets.PURGE_URL }}
         run: |
-          curl -X PATCH PURGE_URL
+          curl -X PATCH $PURGE_URL

.github/workflows/alpha.yml

@@ -0,0 +1,66 @@
+name: Snap Hutao Alpha
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+      - develop
+    paths-ignore:
+      - '.gitattributes'
+      - '.github/**'
+      - '.gitignore'
+      - '.gitmodules'
+      - '**.md'
+      - 'LICENSE'
+      - '**.yml'
+
+jobs:
+  build:
+    runs-on: self-hosted
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4.1.1
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4.0.0
+        with:
+          dotnet-version: 8.0
+
+      - name: Cake
+        id: cake
+        shell: pwsh
+        run: dotnet tool restore && dotnet cake
+        env:
+          VERSION_API_TOKEN: ${{ secrets.VERSION_API_TOKEN }}
+
+      - name: Sign Msix
+        shell: pwsh
+        run: |
+          [System.Convert]::FromBase64String("${{ secrets.CERTIFICATE }}") | Set-Content -AsByteStream temp.pfx
+          signtool.exe sign /debug /v /a /fd SHA256 /f temp.pfx /p ${{ secrets.PW }} ${{ github.workspace }}\src\output\Snap.Hutao.Alpha-${{ steps.cake.outputs.version }}.msix
+
+      - name: Upload signed msix
+        if: success()
+        uses: actions/upload-artifact@v3
+        with:
+          name: Snap.Hutao.Alpha-${{ steps.cake.outputs.version }}
+          path: ${{ github.workspace }}/src/output/Snap.Hutao.Alpha-${{ steps.cake.outputs.version }}.msix
+
+      - name: Add summary
+        if: success()
+        shell: pwsh
+        run: |
+          $summary = "
+          > [!WARNING]
+          > 该版本是由 CI 程序自动打包生成的 `Alpha` 测试版本，**仅供开发者测试使用**
+
+          > [!TIP]
+          > 普通用户请[点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/)下载最新的稳定版本
+
+          > [!IMPORTANT]
+          > 请注意，从 Snap Hutao Alpha 2023.12.21.3 开始，我们将使用全新的 CI 证书，原有的 Snap.Hutao.CI.cer 将在几天后过期停止使用。
+          >
+          > 请安装 [DGP_Studio_CA.crt](https://github.com/DGP-Automation/Hutao-Auto-Release/releases/download/certificate-ca/DGP_Studio_CA.crt) 以安装测试版安装包
+          "
+
+          echo $summary >> $Env:GITHUB_STEP_SUMMARY

.gitignore

@@ -1,7 +1,6 @@
 desktop.ini
 
 *.csproj.user
-*.pubxml
 *.DotSettings.user
 
 .vs/
@@ -16,8 +15,7 @@ src/Snap.Hutao/Snap.Hutao/Snap.Hutao_TemporaryKey.pfx
 src/Snap.Hutao/Snap.Hutao.Win32/bin/
 src/Snap.Hutao/Snap.Hutao.Win32/obj/
 
-src/Snap.Hutao/Snap.Hutao.SourceGeneration/bin/
-src/Snap.Hutao/Snap.Hutao.SourceGeneration/obj/
-
 src/Snap.Hutao/Snap.Hutao.Test/bin/
-src/Snap.Hutao/Snap.Hutao.Test/obj/
+src/Snap.Hutao/Snap.Hutao.Test/obj/
+
+src/Snap.Hutao/Snap.Hutao/Properties/PublishProfiles/FolderProfile.pubxml.user

.gitlab-ci.yml

@@ -0,0 +1,73 @@
+stages:
+  - fetch
+  - release
+  - refresh
+
+Fetch:
+  stage: fetch
+  rules:
+    - if: $CI_COMMIT_TAG
+  tags:
+    - us3
+  script:
+    - apt-get update -qy
+    - apt-get install -y curl jq
+    - RELEASE_INFO=$(curl -sSL "https://api.github.com/repos/$CI_PROJECT_PATH/releases/latest")
+    - ASSET_URL=$(echo "$RELEASE_INFO" | jq -r '.assets[] | select(.name | endswith(".msix")) | .browser_download_url')
+    - SHA256SUMS_URL=$(echo "$RELEASE_INFO" | jq -r '.assets[] | select(.name == "SHA256SUMS") | .browser_download_url')
+    - curl -LJO "$ASSET_URL"
+    - curl -LJO "$SHA256SUMS_URL"
+    - FILE_NAME=$(basename "$ASSET_URL")
+    - SHA256SUMS_NAME=$(basename "$SHA256SUMS_URL")
+    - echo "File name at script stage is $FILE_NAME"
+    - echo "SHA256SUMS name at script stage is $SHA256SUMS_NAME"
+    - echo "THIS_FILE_NAME=$FILE_NAME" >> next.env
+    - echo "THIS_SHA256SUMS_NAME=$SHA256SUMS_NAME" >> next.env
+  after_script:
+    - echo "Current Job ID is $CI_JOB_ID"
+    - echo "THIS_JOB_ID=$CI_JOB_ID" >> next.env
+  artifacts:
+    paths:
+      - "*.msix"
+      - "SHA256SUMS"
+    expire_in: 180 days
+    reports:
+      dotenv: next.env
+
+release:
+  stage: release
+  image: registry.gitlab.com/gitlab-org/release-cli:latest
+  rules:
+    - if: $CI_COMMIT_TAG
+  needs:
+    - job: Fetch
+      artifacts: true
+  variables:
+    TAG: '$CI_COMMIT_TAG'
+  script:
+    - echo "Create Release $TAG"
+    - echo "$THIS_JOB_ID"
+    - echo "$THIS_FILE_NAME"
+  release:
+    name: '$TAG'
+    tag_name: '$TAG'
+    ref: '$TAG'
+    description: 'Release $TAG by CI'
+    assets:
+      links:
+        - name: "$THIS_FILE_NAME"
+          url: "https://$CI_SERVER_SHELL_SSH_HOST/$CI_PROJECT_PATH/-/jobs/$THIS_JOB_ID/artifacts/raw/$THIS_FILE_NAME?inline=false"
+          link_type: package
+        - name: "$THIS_SHA256SUMS_NAME"
+          url: "https://$CI_SERVER_SHELL_SSH_HOST/$CI_PROJECT_PATH/-/jobs/$THIS_JOB_ID/artifacts/raw/$THIS_SHA256SUMS_NAME?inline=false"
+          link_type: other
+          
+Refresh:
+  stage: refresh
+  rules:
+    - if: $CI_COMMIT_TAG
+  needs:
+    - job: release
+  script:
+    - apt-get install -y curl
+    - curl -X PATCH "$PURGE_URL"

CONTRIBUTING.md

@@ -4,13 +4,15 @@
 
 ### Setup Snap.Hutao Project
 
-1. Download and install [Visual Studio 2022 Community](https://visualstudio.microsoft.com/downloads/)
-2. Open Visual Studio Installer to complete Visual Studio installation
-   - You need to install `.NET desktop development`, `Desktop development with C++` and `Universal Windows Platform development` components
-3. Install `Single-project MSIX Packaging Tools for VS 2022` provided by Microsoft in Visual Studio marketplace
-4. Use git to clone the project `https://github.com/DGP-Studio/Snap.Hutao.git` to your local device 
-5. Switch git branch to `develop`
-6. Open project solution with your Visual Studio and then you are ready to go
+1. Download and install [Visual Studio 2022 Community](https://visualstudio.microsoft.com/downloads/).
+   - No need to select workloads; Visual Studio will handle it automatically.
+   - Close Visual Studio Installer to ensure a smooth installation experience for workloads.
+   - If using Visual Studio 2022 17.9 preview, skip step 5, as automatic extension installation is supported in this version.
+2. Use git to clone the project `https://github.com/DGP-Studio/Snap.Hutao.git` to your local device.
+3. Switch to the`develop` branch using git.
+4. Open the project solution with your Visual Studio. Visual Studio will prompt you to install the necessary workloads, closing and reopening automatically.
+5. (For Visual Studio 2022 17.8) Install the [Single-project MSIX Packaging Tools for VS 2022](https://marketplace.visualstudio.com/items?itemName=ProjectReunion.MicrosoftSingleProjectMSIXPackagingToolsDev17) provided by Microsoft in Visual Studio marketplace.
+6. Open the project solution with your Visual Studio, and you are ready to go.
 
 ### Start Pull Request
 

README.md

@@ -1,4 +1,5 @@
-![](res/HutaoRepoBanner2.png)
+![HutaoRepoBanner2-20231222](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/2d178de1-95bc-44a1-a95e-20c5f11a8628)
+
 
 胡桃工具箱是一款以 MIT 协议开源的原神工具箱，专为现代化 Windows 平台设计，旨在改善桌面端玩家的游戏体验。通过将既有的官方资源与开发团队设计的全新 功能相结合，它提供了一套完整且实用的工具集，且无需依赖任何移动设备。它不对游戏客户端进行任何破坏性修改以确保工具箱的安全性
 
@@ -6,7 +7,29 @@ Snap Hutao is an open-source Genshin Impact toolkit under MIT license, designed
 
 ## 下载使用 / Download
 
-[<img src="https://get.microsoft.com/images/zh-cn%20light.svg"  width="30%" height="30%">](https://apps.microsoft.com/store/detail/snap-hutao/9PH4NXJ2JN52)
+![](https://ci.appveyor.com/api/projects/status/n4s40t9llru4si9y?svg=true) [![GitHub Release](https://img.shields.io/github/release/DGP-Studio/Snap.Hutao?style=flat)](https://github.com/DGP-Studio/Snap.Hutao/releases/latest) [![Github All Releases](https://img.shields.io/github/downloads/DGP-Studio/Snap.Hutao/total.svg?style=flat)]() 
+
+---
+
+#### 使用安装器安装 / Install with Snap.Hutao.Depolyment Installer
+
+Snap.Hutao.Depolyment 是一个由 DGP-Studio 重新包装的 Windows 应用安装器，适用于缺少专业计算机知识的一般用户，可以在安装时同时解决缺少必要系统环境的问题。
+
+Snap.Hutao.Depolyment is a Windows application installer repackaged by DGP-Studio for the users who lacks computer knowledge and can solve the problem of missing necessary system environment at the same time as the installation.
+
+[从 GitHub 发布页获取 / Download from GitHub release](https://github.com/DGP-Studio/Snap.Hutao.Deployment/releases/latest) 
+
+[从极狐Lab 发布页获取 / Download from Jihu Gitlab release](https://jihulab.com/DGP-Studio/Snap.Hutao.Deployment/-/releases)
+
+#### 使用 MSIX 包安装 / Install with MSIX Package
+
+直接使用 Snap Hutao MSIX 安装包，使用 Windows 内置的 App Installer 即可安装。如在安装中出现问题，请查阅我们的[常见问题](https://hut.ao/zh/advanced/FAQ.html)文档
+
+Install with Snap Hutao MSIX package, can be installed with Windows built-in App Installer. If you faced any issue, please check our [FAQ](https://hut.ao/en/advanced/FAQ.html) document.
+
+[从 GitHub 发布页获取 / Download from GitHub release](https://github.com/DGP-Studio/Snap.Hutao/releases/latest) 
+
+[从极狐Lab 发布页获取 / Download from Jihu Gitlab release](https://jihulab.com/DGP-Studio/Snap.Hutao/-/releases)
 
 ## 贡献 / Contribute
 
@@ -44,7 +67,29 @@ Snap Hutao is an open-source Genshin Impact toolkit under MIT license, designed
 * [Snap.Hutao.Server](https://github.com/DGP-Studio/Snap.Hutao.Server)
 * [Snap.Metadata](https://github.com/DGP-Studio/Snap.Metadata)
 
+## 赞助商 / Sponsorship
+
+Snap Hutao is currently using sponsored software from the following service providers.
+
+| [![](https://www.netlify.com/v3/img/components/netlify-light.svg)](https://www.netlify.com/) | [![](https://support.crowdin.com/assets/logos/core-logo/svg/crowdin-core-logo-cDark.svg)](https://crowdin.com/) | [![](https://gitlab.cn/images/icons/logos/logo-121-75.svg)](https://gitlab.cn/) |
+|:----------------------------------------------------------------------------------------------------:|:-----------------------------------------------------------------------------------------------------------------------:|:---------------------------------------------------------------------------------------:|
+|              [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/73ae8b90-f3c7-4033-b2b7-f4126331ce66)](https://about.signpath.io)              |                        [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/49aed8ee-9f19-4a8a-998c-7b93ee286d65)](https://1password.com/)                         |  [![](https://github.com/DGP-Studio/Snap.Hutao/assets/10614984/ad121220-d2d3-4f49-b215-b6d063dc229d)](https://about.signpath.io)   |
+
+
+- Netlify provides document and home page hosting service for Snap Hutao
+
+- Crowdin provides its SaaS platform to help Snap Hutao's localization
+
+- Jihu GitLab (极狐) provides Git repository and CI/CD SaaS service for Snap Hutao in China
+
+- Free code signing provided by [SignPath.io](https://signpath.io/), certificate by [SignPath Foundation](https://signpath.org/)
+
+- 1Password provides Snap Hutao development team with their amazing password management software
+  
+- DigitalOcean provides reliable cloud database for Snap Hutao database backup
+
 ## 开发 / Development
+
 ![Snap.Hutao](https://repobeats.axiom.co/api/embed/f029553fbe0c60689b1710476ec8512452163fc9.svg)
 
-[![Star History Chart](https://api.star-history.com/svg?repos=DGP-Studio/Snap.Hutao&type=Date)](https://star-history.com/#DGP-Studio/Snap.Hutao&Date)
+[![Star History Chart](https://api.star-history.com/svg?repos=DGP-Studio/Snap.Hutao&type=Date)](https://star-history.com/#DGP-Studio/Snap.Hutao&Date)

appveyor.yml

@@ -0,0 +1,20 @@
+version: 1.0.{build}
+branches:
+  only:
+    - "release"
+build_cloud: HUTAO-SERVER
+image: Visual Studio 2022
+clone_depth: 3
+clone_folder: D:\appveyor\project\Snap.Hutao.Project
+install:
+- pwsh: dotnet tool restore
+build_script:
+- pwsh: dotnet cake
+artifacts:
+- path: src/output/*.msix
+  type: file
+deploy:
+- provider: Webhook
+  url: https://app.signpath.io/API/v1/7a941fa3-64d8-4c45-bd03-92a02bcd4964/Integrations/AppVeyor?ProjectSlug=Snap.Hutao&SigningPolicySlug=release-signing&ArtifactConfigurationSlug=msix
+  authorization:
+    secure: j8srQ5/UYWhI+jlm3Vo3D3QfXoRyQ9hOn3ynJGtwusKui4+uDi4gykdUFYCITZxK+C/fOCAZNJ+YaKSm/OaiXw==

azure-pipelines.yml

@@ -7,30 +7,32 @@
 # 5. Connect the GitHub in project settings
 # 6. Run
 
-trigger:
-  branches:
-    include:
-    - main
-    - develop
-  paths:
-    exclude:
-    - README.md
-    - azure-pipelines.yml
-    - .github/ISSUE_TEMPLATE/*.yml
-    - .github/workflows/*.yml
-    - src/Snap.Hutao/Snap.Hutao/Resource/Localization/*.resx
-pr:
-  branches:
-   include:
-   - main
-  paths:
-   exclude:
-     - README.md
-     - azure-pipelines.yml
-     - .github/ISSUE_TEMPLATE/*.yml
-     - .github/workflows/*.yml
-     - src/Snap.Hutao/Snap.Hutao/Resource/Localization/*.resx
-    
+trigger: none
+pr: none
+# trigger:
+#   branches:
+#     include:
+#     - main
+#     - develop
+#   paths:
+#     exclude:
+#     - README.md
+#     - azure-pipelines.yml
+#     - .github/ISSUE_TEMPLATE/*.yml
+#     - .github/workflows/*.yml
+#     - src/Snap.Hutao/Snap.Hutao/Resource/Localization/*.resx
+# pr:
+#   branches:
+#    include:
+#    - main
+#   paths:
+#    exclude:
+#      - README.md
+#      - azure-pipelines.yml
+#      - .github/ISSUE_TEMPLATE/*.yml
+#      - .github/workflows/*.yml
+#      - src/Snap.Hutao/Snap.Hutao/Resource/Localization/*.resx
+
 
 pool:
   name: Default
@@ -42,15 +44,9 @@ variables:
   project: $(Build.SourcesDirectory)/src/Snap.Hutao/Snap.Hutao/Snap.Hutao.csproj'
   buildPlatform: 'x64'
   buildConfiguration: 'Release'
-  build_date: $[ format('{0:yyyy}.{0:M}.{0:d}', pipeline.startTime) ]
 
 
 steps:
-- task: GetRevision@1
-  displayName: get Pipelines revision number
-  inputs:
-    VariableName: 'rev_number'
-
 - task: UseDotNet@2
   displayName: Install dotNet
   inputs:
@@ -58,134 +54,66 @@ steps:
     version: '8.x'
     includePreviewVersions: true
 
-- task: NuGetToolInstaller@1
-  name: 'NuGetToolInstaller'
-  displayName: 'NuGet Installer'
-
-- task: NuGetCommand@2
-  displayName: NuGet restore
-  inputs:
-    command: 'restore'
-    restoreSolution: '$(solution)'
-    feedsToUse: 'config'
-    nugetConfigPath: '$(Build.SourcesDirectory)/NuGet.Config'
-
-- task: MsixPackaging@1
-  displayName: Build binary package
-  inputs:
-    outputPath: '$(Build.ArtifactStagingDirectory)/'
-    solution: '$(solution)'
-    clean: false
-    generateBundle: false
-    buildConfiguration: 'Release'
-    buildPlatform: 'x64'
-    updateAppVersion: false
-    appPackageDistributionMode: 'SideloadOnly'
-    msbuildLocationMethod: 'location'
-    msbuildLocation: 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Msbuild\Current\Bin\MSBuild.exe'
-
-- task: MagicChunks@2
-  inputs:
-    sourcePath: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net8.0-windows10.0.22621.0\win-x64\AppxManifest.xml'
-    fileType: 'Xml'
-    targetPathType: 'source'
-    transformationType: 'json'
-    transformations: |
-      {
-        "Package/Identity/@Name": "7f0db578-026f-4e0b-a75b-d5d06bb0a74c",
-        "Package/Identity/@Publisher": "CN=DGP Studio CI",
-        "Package/Identity/@Version": "$(build_date).$(rev_number)",
-        "Package/Properties/DisplayName": "胡桃 Alpha",
-        "Package/Properties/PublisherDisplayName":"DGP Studio CI",
-        "Package/Applications/Application/uap:VisualElements/@DisplayName": "胡桃 Alpha"
-      }
-
 - task: CmdLine@2
-  displayName: Create resources folder
+  displayName: dotnet cake
   inputs:
-    script: |
-      mkdir Assets
-      
-      mkdir Resource
-    workingDirectory: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net8.0-windows10.0.22621.0\win-x64'
-      
-
-- task: CopyFiles@2
-  displayName: Copy Assets Folder
-  inputs:
-    SourceFolder: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\Assets'
-    Contents: '**'
-    TargetFolder: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net8.0-windows10.0.22621.0\win-x64\Assets'
-
-- task: CopyFiles@2
-  displayName: Copy Resource Folder
-  inputs:
-    SourceFolder: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\Resource'
-    Contents: '**'
-    TargetFolder: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net8.0-windows10.0.22621.0\win-x64\Resource'
-
-- task: CmdLine@2
-  displayName: Build MSIX
-  inputs:
-    script: '"C:\Program Files (x86)\Windows Kits\10\bin\10.0.22621.0\x64\makeappx.exe" pack /d $(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net8.0-windows10.0.22621.0\win-x64 /p $(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(build_date).$(rev_number).msix'
+    script: dotnet tool restore && dotnet cake
 
 - task: MsixSigning@1
   name: signMsix
   displayName: Sign MSIX package
   inputs:
-    package: '$(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(build_date).$(rev_number).msix'
+    package: '$(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(version).msix'
     certificate: 'DGP_Studio_CI.pfx'
     passwordVariable: 'pw'
   condition: succeeded()
 
-
-#- task: PublishPipelineArtifact@1
-#  displayName: 'Upload Output'
-#  inputs:
-#    targetPath: '$(Build.ArtifactStagingDirectory)/'
-#    artifact: 'Output'
-#    publishLocation: 'pipeline'
-
 - task: DownloadSecureFile@1
   name: cerFile
   displayName: Download Root CA
   inputs:
     secureFile: 'Snap.Hutao.CI.cer'
 
-- task: GitHubRelease@1
+- task: PublishPipelineArtifact@1
   inputs:
-    gitHubConnection: 'github.com_Masterain'
-    repositoryName: 'DGP-Studio/Snap.Hutao'
-    action: 'create'
-    target: '$(Build.SourceVersion)'
-    tagSource: 'userSpecifiedTag'
-    tag: '$(build_date).$(rev_number)'
-    title: '$(build_date).$(rev_number)'
-    releaseNotesSource: 'inline'
-    releaseNotesInline: |
-      ## 普通用户请勿下载
-      该版本是由 CI 程序自动打包生成的 `Alpha` 测试版本，**仅供开发者测试使用**
+    targetPath: '$(Build.ArtifactStagingDirectory)'
+    artifact: 'Snap.Hutao.Alpha-$(version).msix'
+    publishLocation: 'pipeline'
 
-      普通用户请[点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/)下载最新的稳定版本
-
-    assets: |
-      $(Build.ArtifactStagingDirectory)/*
-      $(cerFile.secureFilePath)
-    isPreRelease: true
-    changeLogCompareToRelease: 'lastFullRelease'
-    changeLogType: 'commitBased'
+#- task: GitHubRelease@1
+#  inputs:
+#    gitHubConnection: 'github.com_Masterain'
+#    repositoryName: 'DGP-Automation/Hutao-Auto-Release'
+#    action: 'create'
+#    target: '$(Build.SourceVersion)'
+#    tagSource: 'userSpecifiedTag'
+#    tag: '$(version)'
+#    title: '$(version)'
+#    releaseNotesSource: 'inline'
+#    releaseNotesInline: |
+#      ## 普通用户请勿下载
+#      该版本是由 CI 程序自动打包生成的 `Alpha` 测试版本，**仅供开发者测试使用**
+#
+#      普通用户请[点击这里](https://github.com/DGP-Studio/Snap.Hutao/releases/latest/)下载最新的稳定版本
+#
+#    assets: |
+#      $(Build.ArtifactStagingDirectory)/*
+#      $(cerFile.secureFilePath)
+#    isPreRelease: true
+#    changeLogCompareToRelease: 'lastFullRelease'
+#    changeLogType: 'commitBased'
 
 
 - task: rclone@1
   displayName: Upload CI via Rclone
   condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
   inputs:
-    arguments: 'copy $(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(build_date).$(rev_number).msix downloadDGPCN:/releases/Alpha/'
+    arguments: 'copy $(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(version).msix downloadDGPCN:/releases/Alpha/'
     configPath: 'C:\agent\_work\_tasks\rclone.conf'
 
 - task: rclone@1
   displayName: Upload PR CI via Rclone
   condition: and(succeeded(), eq(variables['Build.Reason'], 'PullRequest'))
   inputs:
-    arguments: 'copy $(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(build_date).$(rev_number).msix downloadDGPCN:/releases/PR/'
+    arguments: 'copy $(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(version).msix downloadDGPCN:/releases/PR/'
     configPath: 'C:\agent\_work\_tasks\rclone.conf'

build.cake

@@ -0,0 +1,199 @@
+#tool "nuget:?package=nuget.commandline&version=6.5.0"
+#addin nuget:?package=Cake.Http&version=3.0.2
+
+var target = Argument("target", "Build");
+var configuration = Argument("configuration", "Release");
+
+// Pre-define
+
+var version = "version";
+
+var repoDir = "repoDir";
+var outputPath = "outputPath";
+
+string solution
+{
+    get => System.IO.Path.Combine(repoDir, "src", "Snap.Hutao", "Snap.Hutao.sln");
+}
+string project
+{
+    get => System.IO.Path.Combine(repoDir, "src", "Snap.Hutao", "Snap.Hutao", "Snap.Hutao.csproj");
+}
+string binPath
+{
+    get => System.IO.Path.Combine(repoDir, "src", "Snap.Hutao", "Snap.Hutao", "bin", "x64", "Release", "net8.0-windows10.0.22621.0", "win-x64");
+}
+string manifest
+{
+    get => System.IO.Path.Combine(repoDir, "src", "Snap.Hutao", "Snap.Hutao", "Package.appxmanifest");
+}
+
+if (AzurePipelines.IsRunningOnAzurePipelines)
+{
+    repoDir = AzurePipelines.Environment.Build.SourcesDirectory.FullPath;
+    outputPath = AzurePipelines.Environment.Build.ArtifactStagingDirectory.FullPath;
+
+    var versionAuth = HasEnvironmentVariable("VERSION_API_TOKEN") ? EnvironmentVariable("VERSION_API_TOKEN") : throw new Exception("Cannot find VERSION_API_TOKEN");
+    version = HttpGet(
+        "https://internal.snapgenshin.cn/BuildIntergration/RequestNewVersion",
+        new HttpSettings
+        {
+            Headers = new Dictionary<string, string>
+                {
+                    { "Authorization", versionAuth }
+                }
+        }
+    );
+    Information($"Version: {version}");
+
+    AzurePipelines.Commands.SetVariable("version", version);
+}
+else if (GitHubActions.IsRunningOnGitHubActions)
+{
+    repoDir = GitHubActions.Environment.Workflow.Workspace.FullPath;
+    outputPath = System.IO.Path.Combine(repoDir, "src", "output");
+
+    var versionAuth = HasEnvironmentVariable("VERSION_API_TOKEN") ? EnvironmentVariable("VERSION_API_TOKEN") : throw new Exception("Cannot find VERSION_API_TOKEN");
+    version = HttpGet(
+        "https://internal.snapgenshin.cn/BuildIntergration/RequestNewVersion",
+        new HttpSettings
+        {
+            Headers = new Dictionary<string, string>
+                {
+                    { "Authorization", versionAuth }
+                }
+        }
+    );
+    Information($"Version: {version}");
+
+    GitHubActions.Commands.SetOutputParameter("version", version);
+}
+else if (AppVeyor.IsRunningOnAppVeyor)
+{
+    repoDir = AppVeyor.Environment.Build.Folder;
+    outputPath = System.IO.Path.Combine(repoDir, "src", "output");
+
+    version = XmlPeek(manifest, "appx:Package/appx:Identity/@Version", new XmlPeekSettings
+    {
+        Namespaces = new Dictionary<string, string> { { "appx", "http://schemas.microsoft.com/appx/manifest/foundation/windows10" } }
+    })[..^2];
+    Information($"Version: {version}");
+}
+
+Task("Build")
+    .IsDependentOn("Build binary package")
+    .IsDependentOn("Copy files")
+    .IsDependentOn("Build MSIX");
+
+Task("NuGet Restore")
+    .Does(() =>
+{
+    Information("Restoring packages...");
+
+    var nugetConfig = System.IO.Path.Combine(repoDir, "NuGet.Config");
+    DotNetRestore(project, new DotNetRestoreSettings
+    {
+        Verbosity = DotNetVerbosity.Detailed,
+        Interactive = false,
+        ConfigFile = nugetConfig
+    });
+});
+
+Task("Generate AppxManifest")
+    .Does(() =>
+{
+    Information("Generating AppxManifest...");
+
+    var content = System.IO.File.ReadAllText(manifest);
+
+    if (AzurePipelines.IsRunningOnAzurePipelines || GitHubActions.IsRunningOnGitHubActions)
+    {
+        Information("Using CI configuraion");
+        content = content
+            .Replace("Snap Hutao", "Snap Hutao Alpha")
+            .Replace("胡桃", "胡桃 Alpha")
+            .Replace("DGP Studio", "DGP Studio CI");
+        content = System.Text.RegularExpressions.Regex.Replace(content, "  Name=\"([^\"]*)\"", "  Name=\"7f0db578-026f-4e0b-a75b-d5d06bb0a74c\"");
+        content = System.Text.RegularExpressions.Regex.Replace(content, "  Publisher=\"([^\"]*)\"", "  Publisher=\"E=admin@dgp-studio.cn, CN=DGP Studio CI, OU=CI, O=DGP-Studio, L=San Jose, S=CA, C=US\"");
+        content = System.Text.RegularExpressions.Regex.Replace(content, "  Version=\"([0-9\\.]+)\"", $"  Version=\"{version}\"");
+    }
+    else if (AppVeyor.IsRunningOnAppVeyor)
+    {
+        Information("Using Release configuration");
+        content = System.Text.RegularExpressions.Regex.Replace(content, "  Publisher=\"([^\"]*)\"", "  Publisher=\"CN=SignPath Foundation, O=SignPath Foundation, L=Lewes, S=Delaware, C=US\"");
+    }
+
+    System.IO.File.WriteAllText(manifest, content);
+
+    Information("Generated.");
+});
+
+Task("Build binary package")
+    .IsDependentOn("NuGet Restore")
+    .IsDependentOn("Generate AppxManifest")
+    .Does(() =>
+{
+    Information("Building binary package...");
+
+    var settings = new DotNetBuildSettings
+    {
+        Configuration = configuration
+    };
+
+    settings.MSBuildSettings = new DotNetMSBuildSettings
+    {
+        ArgumentCustomization = args => args.Append("/p:Platform=x64")
+                                            .Append("/p:UapAppxPackageBuildMode=SideloadOnly")
+                                            .Append("/p:AppxPackageSigningEnabled=false")
+                                            .Append("/p:AppxBundle=Never")
+                                            .Append("/p:AppxPackageOutput=" + outputPath)
+    };
+
+    DotNetBuild(project, settings);
+});
+
+Task("Copy files")
+    .IsDependentOn("Build binary package")
+    .Does(() =>
+{
+    Information("Copying assets...");
+    CopyDirectory(
+        System.IO.Path.Combine(repoDir, "src", "Snap.Hutao", "Snap.Hutao", "Assets"),
+        System.IO.Path.Combine(binPath, "Assets")
+    );
+
+    Information("Copying resource...");
+    CopyDirectory(
+        System.IO.Path.Combine(repoDir, "src", "Snap.Hutao", "Snap.Hutao", "Resource"),
+        System.IO.Path.Combine(binPath, "Resource")
+    );
+});
+
+Task("Build MSIX")
+    .IsDependentOn("Build binary package")
+    .IsDependentOn("Copy files")
+    .Does(() =>
+{
+    var arguments = "arguments";
+    if (AzurePipelines.IsRunningOnAzurePipelines || GitHubActions.IsRunningOnGitHubActions)
+    {
+        arguments = "pack /d " + binPath + " /p " + System.IO.Path.Combine(outputPath, $"Snap.Hutao.Alpha-{version}.msix");
+    }
+    else if (AppVeyor.IsRunningOnAppVeyor)
+    {
+        arguments = "pack /d " + binPath + " /p " + System.IO.Path.Combine(outputPath, $"Snap.Hutao-{version}.msix");
+    }
+    var p = StartProcess(
+        "makeappx.exe",
+        new ProcessSettings
+        {
+            Arguments = arguments
+        }
+    );
+    if (p != 0)
+    {
+        throw new InvalidOperationException("Build failed with exit code " + p);
+    }
+});
+
+RunTarget(target);

src/Snap.Hutao/.vsconfig

@@ -0,0 +1,11 @@
+{
+    "version": "1.0",
+    "components": [
+        "Microsoft.VisualStudio.Workload.ManagedDesktop",
+        "Microsoft.VisualStudio.Workload.NativeDesktop",
+        "Microsoft.VisualStudio.Workload.Universal"
+    ],
+    "extensions": [
+        "https://marketplace.visualstudio.com/items?itemName=ProjectReunion.MicrosoftSingleProjectMSIXPackagingToolsDev17"
+    ]
+}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Automation/AttributeGenerator.cs

@@ -1,167 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-
-namespace Snap.Hutao.SourceGeneration.Automation;
-
-[Generator(LanguageNames.CSharp)]
-internal sealed class AttributeGenerator : IIncrementalGenerator
-{
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        context.RegisterPostInitializationOutput(GenerateAllAttributes);
-    }
-
-    public static void GenerateAllAttributes(IncrementalGeneratorPostInitializationContext context)
-    {
-        string coreAnnotations = """
-            using System.Diagnostics;
-
-            namespace Snap.Hutao.Core.Annotation;
-
-            [AttributeUsage(AttributeTargets.Method, Inherited = false)]
-            internal sealed class CommandAttribute : Attribute
-            {
-                public CommandAttribute(string name)
-                {
-                }
-
-                public bool AllowConcurrentExecutions { get; set; }
-            }
-
-            [AttributeUsage(AttributeTargets.Class, Inherited = false)]
-            internal sealed class ConstructorGeneratedAttribute : Attribute
-            {
-                public ConstructorGeneratedAttribute()
-                {
-                }
-
-                public bool CallBaseConstructor { get; set; }
-                public bool ResolveHttpClient { get; set; }
-            }
-
-            [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
-            internal sealed class DependencyPropertyAttribute : Attribute
-            {
-                public DependencyPropertyAttribute(string name, Type type)
-                {
-                }
-
-                public DependencyPropertyAttribute(string name, Type type, object defaultValue)
-                {
-                }
-
-                public DependencyPropertyAttribute(string name, Type type, object defaultValue, string valueChangedCallbackName)
-                {
-                }
-
-                public bool IsAttached { get; set; }
-                public Type AttachedType { get; set; } = default;
-            }
-
-            [AttributeUsage(AttributeTargets.All, Inherited = false)]
-            [Conditional("DEBUG")]
-            internal sealed class HighQualityAttribute : Attribute
-            {
-            }
-            """;
-        context.AddSource("Snap.Hutao.Core.Annotation.Attributes.g.cs", coreAnnotations);
-
-        string coreDependencyInjectionAnnotationHttpClients = """
-            namespace Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient;
-
-            [AttributeUsage(AttributeTargets.Class, Inherited = false)]
-            internal sealed class HttpClientAttribute : Attribute
-            {
-                public HttpClientAttribute(HttpClientConfiguration configuration)
-                {
-                }
-
-                public HttpClientAttribute(HttpClientConfiguration configuration, Type interfaceType)
-                {
-                }
-            }
-
-            internal enum HttpClientConfiguration
-            {
-                /// <summary>
-                /// 默认配置
-                /// </summary>
-                Default,
-
-                /// <summary>
-                /// 米游社请求配置
-                /// </summary>
-                XRpc,
-
-                /// <summary>
-                /// 米游社登录请求配置
-                /// </summary>
-                XRpc2,
-
-                /// <summary>
-                /// Hoyolab app
-                /// </summary>
-                XRpc3,
-            }
-
-            [AttributeUsage(AttributeTargets.Class, Inherited = false)]
-            internal sealed class PrimaryHttpMessageHandlerAttribute : Attribute
-            {
-                /// <inheritdoc cref="System.Net.Http.HttpClientHandler.MaxConnectionsPerServer"/>
-                public int MaxConnectionsPerServer { get; set; }
-
-                /// <summary>
-                /// <inheritdoc cref="System.Net.Http.HttpClientHandler.UseCookies"/>
-                /// </summary>
-                public bool UseCookies { get; set; }
-            }
-            """;
-        context.AddSource("Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.Attributes.g.cs", coreDependencyInjectionAnnotationHttpClients);
-
-        string coreDependencyInjectionAnnotations = """
-            namespace Snap.Hutao.Core.DependencyInjection.Annotation;
-
-            internal enum InjectAs
-            {
-                Singleton,
-                Transient,
-                Scoped,
-            }
-
-            [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
-            internal sealed class InjectionAttribute : Attribute
-            {
-                public InjectionAttribute(InjectAs injectAs)
-                {
-                }
-
-                public InjectionAttribute(InjectAs injectAs, Type interfaceType)
-                {
-                }
-
-                public object Key { get; set; }
-            }
-            """;
-        context.AddSource("Snap.Hutao.Core.DependencyInjection.Annotation.Attributes.g.cs", coreDependencyInjectionAnnotations);
-
-        string resourceLocalization = """
-            namespace Snap.Hutao.Resource.Localization;
-
-            [AttributeUsage(AttributeTargets.Enum)]
-            internal sealed class LocalizationAttribute : Attribute
-            {
-            }
-
-            [AttributeUsage(AttributeTargets.Field)]
-            internal sealed class LocalizationKeyAttribute : Attribute
-            {
-                public LocalizationKeyAttribute(string key)
-                {
-                }
-            }
-            """;
-        context.AddSource("Snap.Hutao.Resource.Localization.Attributes.g.cs", resourceLocalization);
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Automation/CommandGenerator.cs

@@ -1,98 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Snap.Hutao.SourceGeneration.Primitive;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Threading;
-
-namespace Snap.Hutao.SourceGeneration.Automation;
-
-[Generator(LanguageNames.CSharp)]
-internal sealed class CommandGenerator : IIncrementalGenerator
-{
-    public const string AttributeName = "Snap.Hutao.Core.Annotation.CommandAttribute";
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        IncrementalValueProvider<ImmutableArray<GeneratorSyntaxContext2<IMethodSymbol>>> commands =
-            context.SyntaxProvider.CreateSyntaxProvider(FilterAttributedMethods, CommandMethod)
-            .Where(GeneratorSyntaxContext2<IMethodSymbol>.NotNull)
-            .Collect();
-
-        context.RegisterImplementationSourceOutput(commands, GenerateCommandImplementations);
-    }
-
-    private static bool FilterAttributedMethods(SyntaxNode node, CancellationToken token)
-    {
-        return node is MethodDeclarationSyntax methodDeclarationSyntax
-            && methodDeclarationSyntax.Parent is ClassDeclarationSyntax classDeclarationSyntax
-            && classDeclarationSyntax.Modifiers.Count > 1
-            && methodDeclarationSyntax.HasAttributeLists();
-    }
-
-    private static GeneratorSyntaxContext2<IMethodSymbol> CommandMethod(GeneratorSyntaxContext context, CancellationToken token)
-    {
-        if (context.TryGetDeclaredSymbol(token, out IMethodSymbol? methodSymbol))
-        {
-            ImmutableArray<AttributeData> attributes = methodSymbol.GetAttributes();
-            if (attributes.Any(data => data.AttributeClass!.ToDisplayString() == AttributeName))
-            {
-                return new(context, methodSymbol, attributes);
-            }
-        }
-
-        return default;
-    }
-
-    private static void GenerateCommandImplementations(SourceProductionContext production, ImmutableArray<GeneratorSyntaxContext2<IMethodSymbol>> context2s)
-    {
-        foreach (GeneratorSyntaxContext2<IMethodSymbol> context2 in context2s.DistinctBy(c => c.Symbol.ToDisplayString()))
-        {
-            GenerateCommandImplementation(production, context2);
-        }
-    }
-
-    private static void GenerateCommandImplementation(SourceProductionContext production, GeneratorSyntaxContext2<IMethodSymbol> context2)
-    {
-        INamedTypeSymbol classSymbol = context2.Symbol.ContainingType;
-
-        AttributeData commandInfo = context2.SingleAttribute(AttributeName);
-        string commandName = (string)commandInfo.ConstructorArguments[0].Value!;
-
-        string commandType = context2.Symbol.ReturnType.IsOrInheritsFrom("System.Threading.Tasks.Task")
-            ? "AsyncRelayCommand"
-            : "RelayCommand";
-
-        string genericParameter = context2.Symbol.Parameters.ElementAtOrDefault(0) is IParameterSymbol parameter
-            ? $"<{parameter.Type.ToDisplayString(SymbolDisplayFormats.FullyQualifiedNonNullableFormat)}>"
-            : string.Empty;
-
-        string concurrentExecution = commandInfo.HasNamedArgumentWith<bool>("AllowConcurrentExecutions", value => value)
-            ? ", AsyncRelayCommandOptions.AllowConcurrentExecutions"
-            : string.Empty;
-
-        string className = classSymbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
-
-        string code = $$"""
-            using CommunityToolkit.Mvvm.Input;
-
-            namespace {{classSymbol.ContainingNamespace}};
-
-            partial class {{className}}
-            {
-                private ICommand _{{commandName}};
-
-                public ICommand {{commandName}}
-                {
-                    get => _{{commandName}} ??= new {{commandType}}{{genericParameter}}({{context2.Symbol.Name}}{{concurrentExecution}});
-                }
-            }
-            """;
-
-        string normalizedClassName = classSymbol.ToDisplayString().Replace('<', '{').Replace('>', '}');
-        production.AddSource($"{normalizedClassName}.{commandName}.g.cs", code);
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Automation/ConstructorGenerator.cs

@@ -1,193 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Snap.Hutao.SourceGeneration.Primitive;
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-using System.Threading;
-
-namespace Snap.Hutao.SourceGeneration.Automation;
-
-[Generator(LanguageNames.CSharp)]
-internal sealed class ConstructorGenerator : IIncrementalGenerator
-{
-    private const string AttributeName = "Snap.Hutao.Core.Annotation.ConstructorGeneratedAttribute";
-    private const string CompilerGenerated = "System.Runtime.CompilerServices.CompilerGeneratedAttribute";
-
-    //private static readonly DiagnosticDescriptor genericTypeNotSupportedDescriptor = new("SH102", "Generic type is not supported to generate .ctor", "Type [{0}] is not supported", "Quality", DiagnosticSeverity.Error, true);
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        IncrementalValueProvider<ImmutableArray<GeneratorSyntaxContext2>> injectionClasses =
-            context.SyntaxProvider.CreateSyntaxProvider(FilterAttributedClasses, ConstructorGeneratedClass)
-            .Where(GeneratorSyntaxContext2.NotNull)
-            .Collect();
-
-        context.RegisterSourceOutput(injectionClasses, GenerateConstructorImplementations);
-    }
-
-    private static bool FilterAttributedClasses(SyntaxNode node, CancellationToken token)
-    {
-        return node is ClassDeclarationSyntax classDeclarationSyntax
-            && classDeclarationSyntax.Modifiers.Count > 1
-            && classDeclarationSyntax.HasAttributeLists();
-    }
-
-    private static GeneratorSyntaxContext2 ConstructorGeneratedClass(GeneratorSyntaxContext context, CancellationToken token)
-    {
-        if (context.TryGetDeclaredSymbol(token, out INamedTypeSymbol? classSymbol))
-        {
-            ImmutableArray<AttributeData> attributes = classSymbol.GetAttributes();
-            if (attributes.Any(data => data.AttributeClass!.ToDisplayString() == AttributeName))
-            {
-                return new(context, classSymbol, attributes);
-            }
-        }
-
-        return default;
-    }
-
-    private static void GenerateConstructorImplementations(SourceProductionContext production, ImmutableArray<GeneratorSyntaxContext2> context2s)
-    {
-        foreach (GeneratorSyntaxContext2 context2 in context2s.DistinctBy(c => c.Symbol.ToDisplayString()))
-        {
-            GenerateConstructorImplementation(production, context2);
-        }
-    }
-
-    private static void GenerateConstructorImplementation(SourceProductionContext production, GeneratorSyntaxContext2 context2)
-    {
-        AttributeData constructorInfo = context2.SingleAttribute(AttributeName);
-
-        bool resolveHttpClient = constructorInfo.HasNamedArgumentWith<bool>("ResolveHttpClient", value => value);
-        bool callBaseConstructor = constructorInfo.HasNamedArgumentWith<bool>("CallBaseConstructor", value => value);
-        string httpclient = resolveHttpClient ? ", System.Net.Http.HttpClient httpClient" : string.Empty;
-
-        FieldValueAssignmentOptions options = new(resolveHttpClient, callBaseConstructor);
-
-        StringBuilder sourceBuilder = new StringBuilder().Append($$"""
-            namespace {{context2.Symbol.ContainingNamespace}};
-
-            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("{{nameof(ConstructorGenerator)}}", "1.0.0.0")]
-            partial class {{context2.Symbol.ToDisplayString(SymbolDisplayFormats.QualifiedNonNullableFormat)}}
-            {
-                public {{context2.Symbol.Name}}(System.IServiceProvider serviceProvider{{httpclient}}){{(options.CallBaseConstructor ? " : base(serviceProvider)" : string.Empty)}}
-                {
-
-            """);
-
-        FillUpWithFieldValueAssignment(sourceBuilder, context2, options);
-
-        sourceBuilder.Append("""
-                }
-            }
-            """);
-
-        string normalizedClassName = context2.Symbol.ToDisplayString().Replace('<', '{').Replace('>', '}');
-        production.AddSource($"{normalizedClassName}.ctor.g.cs", sourceBuilder.ToString());
-    }
-
-    private static void FillUpWithFieldValueAssignment(StringBuilder builder, GeneratorSyntaxContext2 context2, FieldValueAssignmentOptions options)
-    {
-        IEnumerable<IFieldSymbol> fields = context2.Symbol.GetMembers()
-            .Where(m => m.Kind == SymbolKind.Field)
-            .OfType<IFieldSymbol>();
-
-        foreach (IFieldSymbol fieldSymbol in fields)
-        {
-            if (fieldSymbol.Name.AsSpan()[0] is '<')
-            {
-                continue;
-            }
-
-            bool shoudSkip = false;
-            foreach (SyntaxReference syntaxReference in fieldSymbol.DeclaringSyntaxReferences)
-            {
-                if (syntaxReference.GetSyntax() is VariableDeclaratorSyntax declarator)
-                {
-                    if (declarator.Initializer is not null)
-                    {
-                        // Skip field with initializer
-                        builder.Append("        // Skip field with initializer: ").AppendLine(fieldSymbol.Name);
-                        shoudSkip = true;
-                        break;
-                    }
-                }
-            }
-
-            if (shoudSkip)
-            {
-                continue;
-            }
-
-            if (fieldSymbol.IsReadOnly && !fieldSymbol.IsStatic)
-            {
-                switch (fieldSymbol.Type.ToDisplayString())
-                {
-                    case "System.IServiceProvider":
-                        builder
-                            .Append("        this.")
-                            .Append(fieldSymbol.Name)
-                            .AppendLine(" = serviceProvider;");
-                        break;
-
-                    case "System.Net.Http.HttpClient":
-                        if (options.ResolveHttpClient)
-                        {
-                            builder
-                                .Append("        this.")
-                                .Append(fieldSymbol.Name)
-                                .AppendLine(" = httpClient;");
-                        }
-                        else
-                        {
-                            builder
-                                .Append("        this.")
-                                .Append(fieldSymbol.Name)
-                                .Append(" = serviceProvider.GetRequiredService<System.Net.Http.IHttpClientFactory>().CreateClient(nameof(")
-                                .Append(context2.Symbol.Name)
-                                .AppendLine("));");
-                        }
-                        break;
-
-                    default:
-                        builder
-                            .Append("        this.")
-                            .Append(fieldSymbol.Name)
-                            .Append(" = serviceProvider.GetRequiredService<")
-                            .Append(fieldSymbol.Type)
-                            .AppendLine(">();");
-                        break;
-                }
-            }
-        }
-
-        foreach (INamedTypeSymbol interfaceSymbol in context2.Symbol.Interfaces)
-        {
-            if (interfaceSymbol.Name == "IRecipient")
-            {
-                builder
-                    .Append("        CommunityToolkit.Mvvm.Messaging.IMessengerExtensions.Register<")
-                    .Append(interfaceSymbol.TypeArguments[0])
-                    .AppendLine(">(serviceProvider.GetRequiredService<CommunityToolkit.Mvvm.Messaging.IMessenger>(), this);");
-            }
-        }
-    }
-
-    private readonly struct FieldValueAssignmentOptions
-    {
-        public readonly bool ResolveHttpClient;
-        public readonly bool CallBaseConstructor;
-
-        public FieldValueAssignmentOptions(bool resolveHttpClient, bool callBaseConstructor)
-        {
-            ResolveHttpClient = resolveHttpClient;
-            CallBaseConstructor = callBaseConstructor;
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Automation/DependencyPropertyGenerator.cs

@@ -1,130 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Snap.Hutao.SourceGeneration.Primitive;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Threading;
-
-namespace Snap.Hutao.SourceGeneration.Automation;
-
-[Generator(LanguageNames.CSharp)]
-internal sealed class DependencyPropertyGenerator : IIncrementalGenerator
-{
-    private const string AttributeName = "Snap.Hutao.Core.Annotation.DependencyPropertyAttribute";
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        IncrementalValueProvider<ImmutableArray<GeneratorSyntaxContext2>> commands =
-            context.SyntaxProvider.CreateSyntaxProvider(FilterAttributedClasses, CommandMethod)
-            .Where(GeneratorSyntaxContext2.NotNull)
-            .Collect();
-
-        context.RegisterImplementationSourceOutput(commands, GenerateDependencyPropertyImplementations);
-    }
-
-    private static bool FilterAttributedClasses(SyntaxNode node, CancellationToken token)
-    {
-        return node is ClassDeclarationSyntax classDeclarationSyntax
-            && classDeclarationSyntax.Modifiers.Count > 1
-            && classDeclarationSyntax.HasAttributeLists();
-    }
-
-    private static GeneratorSyntaxContext2 CommandMethod(GeneratorSyntaxContext context, CancellationToken token)
-    {
-        if (context.TryGetDeclaredSymbol(token, out INamedTypeSymbol? methodSymbol))
-        {
-            ImmutableArray<AttributeData> attributes = methodSymbol.GetAttributes();
-            if (attributes.Any(data => data.AttributeClass!.ToDisplayString() == AttributeName))
-            {
-                return new(context, methodSymbol, attributes);
-            }
-        }
-
-        return default;
-    }
-
-    private static void GenerateDependencyPropertyImplementations(SourceProductionContext production, ImmutableArray<GeneratorSyntaxContext2> context2s)
-    {
-        foreach (GeneratorSyntaxContext2 context2 in context2s.DistinctBy(c => c.Symbol.ToDisplayString()))
-        {
-            GenerateDependencyPropertyImplementation(production, context2);
-        }
-    }
-
-    private static void GenerateDependencyPropertyImplementation(SourceProductionContext production, GeneratorSyntaxContext2 context2)
-    {
-        foreach (AttributeData propertyInfo in context2.Attributes.Where(attr => attr.AttributeClass!.ToDisplayString() == AttributeName))
-        {
-            string owner = context2.Symbol.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
-            Dictionary<string, TypedConstant> namedArguments = propertyInfo.NamedArguments.ToDictionary();
-            bool isAttached = namedArguments.TryGetValue("IsAttached", out TypedConstant constant) && (bool)constant.Value!;
-            string register = isAttached ? "RegisterAttached" : "Register";
-
-            ImmutableArray<TypedConstant> arguments = propertyInfo.ConstructorArguments;
-
-            string propertyName = (string)arguments[0].Value!;
-            string propertyType = arguments[1].Value!.ToString();
-            string defaultValue = arguments.ElementAtOrDefault(2).ToCSharpString() ?? "default";
-            defaultValue = defaultValue == "null" ? "default" : defaultValue;
-            string propertyChangedCallback = arguments.ElementAtOrDefault(3) is { IsNull: false } arg3 ? $", {arg3.Value}" : string.Empty;
-
-            string code;
-            if (isAttached)
-            {
-                string objType = namedArguments.TryGetValue("AttachedType", out TypedConstant attachedType)
-                    ? attachedType.Value!.ToString()
-                    : "object";
-
-                code = $$"""
-                    using Microsoft.UI.Xaml;
-
-                    namespace {{context2.Symbol.ContainingNamespace}};
-
-                    partial class {{owner}}
-                    {
-                        private static readonly DependencyProperty {{propertyName}}Property =
-                            DependencyProperty.RegisterAttached("{{propertyName}}", typeof({{propertyType}}), typeof({{owner}}), new PropertyMetadata(({{propertyType}}){{defaultValue}}{{propertyChangedCallback}}));
-
-                        public static {{propertyType}} Get{{propertyName}}({{objType}} obj)
-                        {
-                            return ({{propertyType}})obj?.GetValue({{propertyName}}Property);
-                        }
-
-                        public static void Set{{propertyName}}({{objType}} obj, {{propertyType}} value)
-                        {
-                            obj.SetValue({{propertyName}}Property, value);
-                        }
-                    }
-                    """;
-            }
-            else
-            {
-                code = $$"""
-                    using Microsoft.UI.Xaml;
-
-                    namespace {{context2.Symbol.ContainingNamespace}};
-
-                    partial class {{owner}}
-                    {
-                        private static readonly DependencyProperty {{propertyName}}Property =
-                            DependencyProperty.Register(nameof({{propertyName}}), typeof({{propertyType}}), typeof({{owner}}), new PropertyMetadata(({{propertyType}}){{defaultValue}}{{propertyChangedCallback}}));
-
-                        public {{propertyType}} {{propertyName}}
-                        {
-                            get => ({{propertyType}})GetValue({{propertyName}}Property);
-                            set => SetValue({{propertyName}}Property, value);
-                        }
-                    }
-                    """;
-            }
-
-            string normalizedClassName = context2.Symbol.ToDisplayString().Replace('<', '{').Replace('>', '}');
-            production.AddSource($"{normalizedClassName}.{propertyName}.g.cs", code);
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Automation/SaltConstantGenerator.cs

@@ -1,72 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using System;
-using System.Net.Http;
-using System.Runtime.Serialization;
-
-namespace Snap.Hutao.SourceGeneration.Automation;
-
-[Generator(LanguageNames.CSharp)]
-internal sealed class SaltConstantGenerator : IIncrementalGenerator
-{
-    private static readonly HttpClient httpClient;
-    private static readonly Lazy<Response<SaltLatest>> lazySaltInfo;
-
-    static SaltConstantGenerator()
-    {
-        httpClient = new();
-        lazySaltInfo = new Lazy<Response<SaltLatest>>(() =>
-        {
-            string body = httpClient.GetStringAsync("https://internal.snapgenshin.cn/Archive/Salt/Latest").GetAwaiter().GetResult();
-            return JsonParser.FromJson<Response<SaltLatest>>(body)!;
-        });
-    }
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        context.RegisterPostInitializationOutput(GenerateSaltContstants);
-    }
-
-    private static void GenerateSaltContstants(IncrementalGeneratorPostInitializationContext context)
-    {
-        Response<SaltLatest> saltInfo = lazySaltInfo.Value;
-        string code = $$"""
-            namespace Snap.Hutao.Web.Hoyolab;
-
-            internal sealed class SaltConstants
-            {
-                public const string CNVersion = "{{saltInfo.Data.CNVersion}}";
-                public const string CNK2 = "{{saltInfo.Data.CNK2}}";
-                public const string CNLK2 = "{{saltInfo.Data.CNLK2}}";
-
-                public const string OSVersion = "{{saltInfo.Data.OSVersion}}";
-                public const string OSK2 = "{{saltInfo.Data.OSK2}}";
-                public const string OSLK2 = "{{saltInfo.Data.OSLK2}}";
-            }
-            """;
-        context.AddSource("SaltConstants.g.cs", code);
-    }
-
-    private sealed class Response<T>
-    {
-        [DataMember(Name = "data")]
-        public T Data { get; set; } = default!;
-    }
-
-    internal sealed class SaltLatest
-    {
-        public string CNVersion { get; set; } = default!;
-
-        public string CNK2 { get; set; } = default!;
-
-        public string CNLK2 { get; set; } = default!;
-
-        public string OSVersion { get; set; } = default!;
-
-        public string OSK2 { get; set; } = default!;
-
-        public string OSLK2 { get; set; } = default!;
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/CodeAnalysis/NotNullWhenAttribute.cs

@@ -1,18 +0,0 @@
-namespace System.Diagnostics.CodeAnalysis;
-
-/// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
-[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-internal sealed class NotNullWhenAttribute : Attribute
-{
-    /// <summary>Initializes the attribute with the specified return value condition.</summary>
-    /// <param name="returnValue">
-    /// The return value condition. If the method returns this value, the associated parameter will not be null.
-    /// </param>
-    public NotNullWhenAttribute(bool returnValue)
-    {
-        ReturnValue = returnValue;
-    }
-
-    /// <summary>Gets the return value condition.</summary>
-    public bool ReturnValue { get; }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/DependencyInjection/HttpClientGenerator.cs

@@ -1,145 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Snap.Hutao.SourceGeneration.Primitive;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-using System.Threading;
-
-namespace Snap.Hutao.SourceGeneration.DependencyInjection;
-
-[Generator(LanguageNames.CSharp)]
-internal sealed class HttpClientGenerator : IIncrementalGenerator
-{
-    private const string AttributeName = "Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.HttpClientAttribute";
-
-    private const string HttpClientConfiguration = "Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.HttpClientConfiguration.";
-    private const string PrimaryHttpMessageHandlerAttributeName = "Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.PrimaryHttpMessageHandlerAttribute";
-    private const string CRLF = "\r\n";
-
-    private static readonly DiagnosticDescriptor injectionShouldOmitDescriptor = new("SH201", "Injection 特性可以省略", "HttpClient 特性已将 {0} 注册为 Transient 服务", "Quality", DiagnosticSeverity.Warning, true);
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        IncrementalValueProvider<ImmutableArray<GeneratorSyntaxContext2>> injectionClasses = context.SyntaxProvider
-            .CreateSyntaxProvider(FilterAttributedClasses, HttpClientClass)
-            .Where(GeneratorSyntaxContext2.NotNull)
-            .Collect();
-
-        context.RegisterImplementationSourceOutput(injectionClasses, GenerateAddHttpClientsImplementation);
-    }
-
-    private static bool FilterAttributedClasses(SyntaxNode node, CancellationToken token)
-    {
-        return node is ClassDeclarationSyntax classDeclarationSyntax
-            && classDeclarationSyntax.HasAttributeLists();
-    }
-
-    private static GeneratorSyntaxContext2 HttpClientClass(GeneratorSyntaxContext context, CancellationToken token)
-    {
-        if (context.TryGetDeclaredSymbol(token, out INamedTypeSymbol? classSymbol))
-        {
-            ImmutableArray<AttributeData> attributes = classSymbol.GetAttributes();
-            if (attributes.Any(data => data.AttributeClass!.ToDisplayString() == AttributeName))
-            {
-                return new(context, classSymbol, attributes);
-            }
-        }
-
-        return default;
-    }
-
-    private static void GenerateAddHttpClientsImplementation(SourceProductionContext context, ImmutableArray<GeneratorSyntaxContext2> context2s)
-    {
-        StringBuilder sourceBuilder = new StringBuilder().Append($$"""
-            // Copyright (c) DGP Studio. All rights reserved.
-            // Licensed under the MIT license.
-
-            using System.Net.Http;
-            
-            namespace Snap.Hutao.Core.DependencyInjection;
-            
-            internal static partial class IocHttpClientConfiguration
-            {
-                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("{{nameof(HttpClientGenerator)}}", "1.0.0.0")]
-                public static partial IServiceCollection AddHttpClients(this IServiceCollection services)
-                {
-            """);
-
-        FillUpWithAddHttpClient(sourceBuilder, context, context2s);
-
-        sourceBuilder.Append("""
-
-                    return services;
-                }
-            }
-            """);
-
-        context.AddSource("IocHttpClientConfiguration.g.cs", sourceBuilder.ToString());
-    }
-
-    private static void FillUpWithAddHttpClient(StringBuilder sourceBuilder, SourceProductionContext production, ImmutableArray<GeneratorSyntaxContext2> contexts)
-    {
-        List<string> lines = [];
-        StringBuilder lineBuilder = new();
-
-        foreach (GeneratorSyntaxContext2 context in contexts.DistinctBy(c => c.Symbol.ToDisplayString()))
-        {
-            if (context.SingleOrDefaultAttribute(InjectionGenerator.AttributeName) is AttributeData injectionData)
-            {
-                if (injectionData.ConstructorArguments[0].ToCSharpString() == InjectionGenerator.InjectAsTransientName)
-                {
-                    if (injectionData.ConstructorArguments.Length < 2)
-                    {
-                        production.ReportDiagnostic(Diagnostic.Create(injectionShouldOmitDescriptor, context.Context.Node.GetLocation(), context.Context.Node));
-                    }
-                }
-            }
-
-            lineBuilder.Clear().Append(CRLF);
-            lineBuilder.Append(@"        services.AddHttpClient<");
-
-            AttributeData httpClientData = context.SingleAttribute(AttributeName);
-            ImmutableArray<TypedConstant> arguments = httpClientData.ConstructorArguments;
-
-            if (arguments.Length == 2)
-            {
-                lineBuilder.Append($"{arguments[1].Value}, ");
-            }
-
-            lineBuilder.Append($"{context.Symbol.ToDisplayString()}>(");
-            lineBuilder.Append(arguments[0].ToCSharpString().Substring(HttpClientConfiguration.Length)).Append("Configuration)");
-
-            if (context.SingleOrDefaultAttribute(PrimaryHttpMessageHandlerAttributeName) is AttributeData handlerData)
-            {
-                ImmutableArray<KeyValuePair<string, TypedConstant>> properties = handlerData.NamedArguments;
-                lineBuilder.Append(@".ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler() {");
-
-                foreach (KeyValuePair<string, TypedConstant> property in properties)
-                {
-                    lineBuilder.Append(' ');
-                    lineBuilder.Append(property.Key);
-                    lineBuilder.Append(" = ");
-                    lineBuilder.Append(property.Value.ToCSharpString());
-                    lineBuilder.Append(',');
-                }
-
-                lineBuilder.Append(" })");
-            }
-
-            lineBuilder.Append(';');
-
-            lines.Add(lineBuilder.ToString());
-        }
-
-        foreach (string line in lines.OrderBy(x => x))
-        {
-            sourceBuilder.Append(line);
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/DependencyInjection/InjectionGenerator.cs

@@ -1,145 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Snap.Hutao.SourceGeneration.Primitive;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-using System.Threading;
-
-namespace Snap.Hutao.SourceGeneration.DependencyInjection;
-
-[Generator(LanguageNames.CSharp)]
-internal sealed class InjectionGenerator : IIncrementalGenerator
-{
-    public const string AttributeName = "Snap.Hutao.Core.DependencyInjection.Annotation.InjectionAttribute";
-    public const string InjectAsSingletonName = "Snap.Hutao.Core.DependencyInjection.Annotation.InjectAs.Singleton";
-    public const string InjectAsTransientName = "Snap.Hutao.Core.DependencyInjection.Annotation.InjectAs.Transient";
-    public const string InjectAsScopedName = "Snap.Hutao.Core.DependencyInjection.Annotation.InjectAs.Scoped";
-
-    private static readonly DiagnosticDescriptor invalidInjectionDescriptor = new("SH101", "无效的 InjectAs 枚举值", "尚未支持生成 {0} 配置", "Quality", DiagnosticSeverity.Error, true);
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        IncrementalValueProvider<ImmutableArray<GeneratorSyntaxContext2>> injectionClasses = context.SyntaxProvider
-            .CreateSyntaxProvider(FilterAttributedClasses, HttpClientClass)
-            .Where(GeneratorSyntaxContext2.NotNull)
-            .Collect();
-
-        context.RegisterImplementationSourceOutput(injectionClasses, GenerateAddInjectionsImplementation);
-    }
-
-    private static bool FilterAttributedClasses(SyntaxNode node, CancellationToken token)
-    {
-        return node is ClassDeclarationSyntax classDeclarationSyntax
-            && classDeclarationSyntax.HasAttributeLists();
-    }
-
-    private static GeneratorSyntaxContext2 HttpClientClass(GeneratorSyntaxContext context, CancellationToken token)
-    {
-        if (context.TryGetDeclaredSymbol(token, out INamedTypeSymbol? classSymbol))
-        {
-            ImmutableArray<AttributeData> attributes = classSymbol.GetAttributes();
-            if (attributes.Any(data => data.AttributeClass!.ToDisplayString() == AttributeName))
-            {
-                return new(context, classSymbol, attributes);
-            }
-        }
-
-        return default;
-    }
-
-    private static void GenerateAddInjectionsImplementation(SourceProductionContext context, ImmutableArray<GeneratorSyntaxContext2> context2s)
-    {
-        StringBuilder sourceBuilder = new StringBuilder().Append($$"""
-            // Copyright (c) DGP Studio. All rights reserved.
-            // Licensed under the MIT license.
-
-            namespace Snap.Hutao.Core.DependencyInjection;
-            
-            internal static partial class ServiceCollectionExtension
-            {
-                [global::System.CodeDom.Compiler.GeneratedCodeAttribute("{{nameof(InjectionGenerator)}}", "1.0.0.0")]
-                public static partial IServiceCollection AddInjections(this IServiceCollection services)
-                {
-            """);
-
-        FillUpWithAddServices(sourceBuilder, context, context2s);
-        sourceBuilder.Append("""
-
-                    return services;
-                }
-            }
-            """);
-
-        context.AddSource("ServiceCollectionExtension.g.cs", sourceBuilder.ToString());
-    }
-
-    private static void FillUpWithAddServices(StringBuilder sourceBuilder, SourceProductionContext production, ImmutableArray<GeneratorSyntaxContext2> contexts)
-    {
-        List<string> lines = [];
-        StringBuilder lineBuilder = new();
-
-        foreach (GeneratorSyntaxContext2 context in contexts.DistinctBy(c => c.Symbol.ToDisplayString()))
-        {
-            lineBuilder.Clear().AppendLine();
-
-            AttributeData injectionInfo = context.SingleAttribute(AttributeName);
-            ImmutableArray<TypedConstant> arguments = injectionInfo.ConstructorArguments;
-
-            string injectAsName = arguments[0].ToCSharpString();
-
-            bool hasKey = injectionInfo.TryGetNamedArgumentValue("Key", out TypedConstant key);
-
-            switch (injectAsName, hasKey)
-            {
-                case (InjectAsSingletonName, false):
-                    lineBuilder.Append("        services.AddSingleton<");
-                    break;
-                case (InjectAsSingletonName, true):
-                    lineBuilder.Append("        services.AddKeyedSingleton<");
-                    break;
-                case (InjectAsTransientName, false):
-                    lineBuilder.Append("        services.AddTransient<");
-                    break;
-                case (InjectAsTransientName, true):
-                    lineBuilder.Append("        services.AddKeyedTransient<");
-                    break;
-                case (InjectAsScopedName, false):
-                    lineBuilder.Append("        services.AddScoped<");
-                    break;
-                case (InjectAsScopedName, true):
-                    lineBuilder.Append("        services.AddKeyedScoped<");
-                    break;
-                default:
-                    production.ReportDiagnostic(Diagnostic.Create(invalidInjectionDescriptor, context.Context.Node.GetLocation(), injectAsName));
-                    break;
-            }
-
-            if (arguments.Length == 2)
-            {
-                lineBuilder.Append($"{arguments[1].Value}, ");
-            }
-
-            if (hasKey)
-            {
-                lineBuilder.Append($"{context.Symbol.ToDisplayString()}>({key.ToCSharpString()});");
-            }
-            else
-            {
-                lineBuilder.Append($"{context.Symbol.ToDisplayString()}>();");
-            }
-
-            lines.Add(lineBuilder.ToString());
-        }
-
-        foreach (string line in lines.OrderBy(x => x))
-        {
-            sourceBuilder.Append(line);
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/DependencyInjection/ServiceAnalyzer.cs

@@ -1,78 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Snap.Hutao.SourceGeneration.Primitive;
-using System.Collections.Immutable;
-using System.Linq;
-
-namespace Snap.Hutao.SourceGeneration.DependencyInjection;
-
-[DiagnosticAnalyzer(LanguageNames.CSharp)]
-internal class ServiceAnalyzer : DiagnosticAnalyzer
-{
-    private static readonly DiagnosticDescriptor NonSingletonUseServiceProviderDescriptor = new("SH301", "Non Singleton service should avoid direct use of IServiceProvider", "Non Singleton service should avoid direct use of IServiceProvider", "Quality", DiagnosticSeverity.Info, true);
-    private static readonly DiagnosticDescriptor SingletonServiceCaptureNonSingletonServiceDescriptor = new("SH302", "Singleton service should avoid keep reference of non singleton service", "Singleton service should avoid keep reference of non singleton service", "Quality", DiagnosticSeverity.Info, true);
-
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-    {
-        get => new DiagnosticDescriptor[]
-    {
-        NonSingletonUseServiceProviderDescriptor,
-        SingletonServiceCaptureNonSingletonServiceDescriptor,
-    }.ToImmutableArray();
-    }
-
-    public override void Initialize(AnalysisContext context)
-    {
-        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
-        context.EnableConcurrentExecution();
-
-        context.RegisterCompilationStartAction(CompilationStart);
-    }
-
-    private static void CompilationStart(CompilationStartAnalysisContext context)
-    {
-        context.RegisterSyntaxNodeAction(HandleNonSingletonUseServiceProvider, SyntaxKind.ClassDeclaration);
-        context.RegisterSyntaxNodeAction(HandleSingletonServiceCaptureNonSingletonService, SyntaxKind.ClassDeclaration);
-    }
-
-    private static void HandleNonSingletonUseServiceProvider(SyntaxNodeAnalysisContext context)
-    {
-        ClassDeclarationSyntax classDeclarationSyntax = (ClassDeclarationSyntax)context.Node;
-        if (classDeclarationSyntax.HasAttributeLists())
-        {
-            INamedTypeSymbol? classSymbol = context.SemanticModel.GetDeclaredSymbol(classDeclarationSyntax);
-            if (classSymbol is not null)
-            {
-                foreach (AttributeData attributeData in classSymbol.GetAttributes())
-                {
-                    if (attributeData.AttributeClass!.ToDisplayString() is InjectionGenerator.AttributeName)
-                    {
-                        string serviceType = attributeData.ConstructorArguments[0].ToCSharpString();
-                        if (serviceType is InjectionGenerator.InjectAsTransientName or InjectionGenerator.InjectAsScopedName)
-                        {
-                            HandleNonSingletonUseServiceProviderActual(context, classSymbol);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private static void HandleNonSingletonUseServiceProviderActual(SyntaxNodeAnalysisContext context, INamedTypeSymbol classSymbol)
-    {
-        ISymbol? symbol = classSymbol.GetMembers().Where(m => m is IFieldSymbol f && f.Type.ToDisplayString() == "System.IServiceProvider").SingleOrDefault();
-
-        if (symbol is not null)
-        {
-            Diagnostic diagnostic = Diagnostic.Create(NonSingletonUseServiceProviderDescriptor, symbol.Locations.FirstOrDefault());
-            context.ReportDiagnostic(diagnostic);
-        }
-    }
-
-    private static void HandleSingletonServiceCaptureNonSingletonService(SyntaxNodeAnalysisContext context)
-    {
-        //classSymbol.GetMembers().Where(m => m is IFieldSymbol { IsReadOnly: true, DeclaredAccessibility: Accessibility.Private } f);
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Enum/LocalizedEnumGenerator.cs

@@ -1,136 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Snap.Hutao.SourceGeneration.Primitive;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-using System.Threading;
-
-namespace Snap.Hutao.SourceGeneration.Enum;
-
-[Generator(LanguageNames.CSharp)]
-internal class LocalizedEnumGenerator : IIncrementalGenerator
-{
-    private const string AttributeName = "Snap.Hutao.Resource.Localization.LocalizationAttribute";
-    private const string LocalizationKeyName = "Snap.Hutao.Resource.Localization.LocalizationKeyAttribute";
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        IncrementalValuesProvider<GeneratorSyntaxContext2> localizationEnums = context.SyntaxProvider
-            .CreateSyntaxProvider(FilterAttributedEnums, LocalizationEnum)
-            .Where(GeneratorSyntaxContext2.NotNull);
-
-        context.RegisterSourceOutput(localizationEnums, GenerateGetLocalizedDescriptionImplementation);
-    }
-
-    private static bool FilterAttributedEnums(SyntaxNode node, CancellationToken token)
-    {
-        return node is EnumDeclarationSyntax enumDeclarationSyntax
-            && enumDeclarationSyntax.HasAttributeLists();
-    }
-
-    private static GeneratorSyntaxContext2 LocalizationEnum(GeneratorSyntaxContext context, CancellationToken token)
-    {
-        if (context.SemanticModel.GetDeclaredSymbol(context.Node, token) is INamedTypeSymbol enumSymbol)
-        {
-            ImmutableArray<AttributeData> attributes = enumSymbol.GetAttributes();
-            if (attributes.Any(data => data.AttributeClass!.ToDisplayString() == AttributeName))
-            {
-                return new(context, enumSymbol, attributes);
-            }
-        }
-
-        return default;
-    }
-
-    private static void GenerateGetLocalizedDescriptionImplementation(SourceProductionContext context, GeneratorSyntaxContext2 context2)
-    {
-        StringBuilder sourceBuilder = new StringBuilder().Append($$"""
-            // Copyright (c) DGP Studio. All rights reserved.
-            // Licensed under the MIT license.
-            
-            using System.Globalization;
-
-            namespace Snap.Hutao.Resource.Localization;
-
-            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("{{nameof(LocalizedEnumGenerator)}}", "1.0.0.0")]
-            internal static class {{context2.Symbol.Name}}Extension
-            {
-                /// <summary>
-                /// 获取本地化的描述
-                /// </summary>
-                /// <param name="value">枚举值</param>
-                /// <returns>本地化的描述</returns>
-                public static string GetLocalizedDescription(this {{context2.Symbol}} value)
-                {
-                    string key = value switch
-                    {
-
-            """);
-
-        FillUpWithSwitchBranches(sourceBuilder, context2);
-
-        sourceBuilder.Append($$"""
-                        _ => string.Empty,
-                    };
-
-                    if (string.IsNullOrEmpty(key))
-                    {
-                        return Enum.GetName(value);
-                    }
-                    else
-                    {
-                        return SH.ResourceManager.GetString(key, CultureInfo.CurrentCulture);
-                    }
-                }
-
-                /// <summary>
-                /// 获取本地化的描述
-                /// </summary>
-                /// <param name="value">枚举值</param>
-                /// <returns>本地化的描述</returns>
-                [return:MaybeNull]
-                public static string GetLocalizedDescriptionOrDefault(this {{context2.Symbol}} value)
-                {
-                    string key = value switch
-                    {
-
-            """);
-
-        FillUpWithSwitchBranches(sourceBuilder, context2);
-
-        sourceBuilder.Append($$"""
-                        _ => string.Empty,
-                    };
-
-                    return SH.ResourceManager.GetString(key, CultureInfo.CurrentCulture);
-                }
-            }
-            """);
-
-        context.AddSource($"{context2.Symbol.Name}Extension.g.cs", sourceBuilder.ToString());
-    }
-
-    private static void FillUpWithSwitchBranches(StringBuilder sourceBuilder, GeneratorSyntaxContext2 context)
-    {
-        IEnumerable<IFieldSymbol> fields = context.Symbol.GetMembers()
-            .Where(m => m.Kind == SymbolKind.Field)
-            .Cast<IFieldSymbol>();
-
-        foreach (IFieldSymbol fieldSymbol in fields)
-        {
-            AttributeData? localizationKeyInfo = fieldSymbol.GetAttributes()
-                .SingleOrDefault(data => data.AttributeClass!.ToDisplayString() == LocalizationKeyName);
-            if (localizationKeyInfo != null)
-            {
-                sourceBuilder
-                    .Append("            ")
-                    .Append(fieldSymbol)
-                    .Append(" => \"")
-                    .Append(localizationKeyInfo.ConstructorArguments[0].Value)
-                    .AppendLine("\",");
-            }
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/GlobalSuppressions.cs

@@ -1,8 +0,0 @@
-// This file is used by Code Analysis to maintain SuppressMessage
-// attributes that are applied to this project.
-// Project-level suppressions either have no target or are given
-// a specific target and scoped to a namespace, type, member, etc.
-
-using System.Diagnostics.CodeAnalysis;
-
-[assembly: SuppressMessage("", "RS2008")]

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Identity/IdentityGenerator.cs

@@ -1,202 +0,0 @@
-using Microsoft.CodeAnalysis;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.IO;
-using System.Linq;
-using System.Text;
-
-namespace Snap.Hutao.SourceGeneration.Identity;
-
-[Generator(LanguageNames.CSharp)]
-internal sealed class IdentityGenerator : IIncrementalGenerator
-{
-    private const string FileName = "IdentityStructs.json";
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        IncrementalValueProvider<ImmutableArray<AdditionalText>> provider = context.AdditionalTextsProvider.Where(MatchFileName).Collect();
-
-        context.RegisterImplementationSourceOutput(provider, GenerateIdentityStructs);
-    }
-
-    private static bool MatchFileName(AdditionalText text)
-    {
-        return Path.GetFileName(text.Path) == FileName;
-    }
-
-    private static void GenerateIdentityStructs(SourceProductionContext context, ImmutableArray<AdditionalText> texts)
-    {
-        AdditionalText jsonFile = texts.Single();
-
-        string identityJson = jsonFile.GetText(context.CancellationToken)!.ToString();
-        List<IdentityStructMetadata> identities = identityJson.FromJson<List<IdentityStructMetadata>>()!;
-
-        if (identities.Any())
-        {
-            foreach (IdentityStructMetadata identityStruct in identities)
-            {
-                GenerateIdentityStruct(context, identityStruct);
-            }
-        }
-    }
-
-    private static void GenerateIdentityStruct(SourceProductionContext context, IdentityStructMetadata metadata)
-    {
-        string name = metadata.Name;
-
-        StringBuilder sourceBuilder = new StringBuilder().AppendLine($$"""
-            // Copyright (c) DGP Studio. All rights reserved.
-            // Licensed under the MIT license.
-
-            using Snap.Hutao.Model.Primitive.Converter;
-            using System.Numerics;
-
-            namespace Snap.Hutao.Model.Primitive;
-
-            /// <summary>
-            /// {{metadata.Documentation}}
-            /// </summary>
-            [JsonConverter(typeof(IdentityConverter<{{name}}>))]
-            [global::System.CodeDom.Compiler.GeneratedCodeAttribute("{{nameof(IdentityGenerator)}}","1.0.0.0")]
-            internal readonly partial struct {{name}}
-            {
-                /// <summary>
-                /// 值
-                /// </summary>
-                public readonly uint Value;
-
-                /// <summary>
-                /// Initializes a new instance of the <see cref="{{name}}"/> struct.
-                /// </summary>
-                /// <param name="value">value</param>
-                public {{name}}(uint value)
-                {
-                    Value = value;
-                }
-
-                public static implicit operator uint({{name}} value)
-                {
-                    return value.Value;
-                }
-
-                public static implicit operator {{name}}(uint value)
-                {
-                    return new(value);
-                }
-
-                /// <inheritdoc/>
-                public override int GetHashCode()
-                {
-                    return Value.GetHashCode();
-                }
-
-                /// <inheritdoc/>
-                public override string ToString()
-                {
-                    return Value.ToString();
-                }
-            }
-            """);
-
-        if (metadata.Equatable)
-        {
-            sourceBuilder.AppendLine($$"""
-
-                internal readonly partial struct {{name}} : IEquatable<{{name}}>
-                {
-                    /// <inheritdoc/>
-                    public override bool Equals(object obj)
-                    {
-                        return obj is {{name}} other && Equals(other);
-                    }
-
-                    /// <inheritdoc/>
-                    public bool Equals({{name}} other)
-                    {
-                        return Value == other.Value;
-                    }
-                }
-                """);
-        }
-
-        if (metadata.EqualityOperators)
-        {
-            sourceBuilder.AppendLine($$"""
-
-                internal readonly partial struct {{name}} : IEqualityOperators<{{name}}, {{name}}, bool>, IEqualityOperators<{{name}}, uint, bool>
-                {
-                    public static bool operator ==({{name}} left, {{name}} right)
-                    {
-                        return left.Value == right.Value;
-                    }
-                
-                    public static bool operator ==({{name}} left, uint right)
-                    {
-                        return left.Value == right;
-                    }
-
-                    public static bool operator !=({{name}} left, {{name}} right)
-                    {
-                        return !(left == right);
-                    }
-
-                    public static bool operator !=({{name}} left, uint right)
-                    {
-                        return !(left == right);
-                    }
-                }
-                """);
-        }
-
-        if (metadata.AdditionOperators)
-        {
-            sourceBuilder.AppendLine($$"""
-
-                internal readonly partial struct {{name}} : IAdditionOperators<{{name}}, {{name}}, {{name}}>, IAdditionOperators<{{name}}, uint, {{name}}>
-                {
-                    public static {{name}} operator +({{name}} left, {{name}} right)
-                    {
-                        return left.Value + right.Value;
-                    }
-
-                    public static {{name}} operator +({{name}} left, uint right)
-                    {
-                        return left.Value + right;
-                    }
-                }
-                """);
-        }
-
-        if (metadata.IncrementOperators)
-        {
-            sourceBuilder.AppendLine($$"""
-
-                internal readonly partial struct {{name}} : IIncrementOperators<{{name}}>
-                {
-                    public static unsafe {{name}} operator ++({{name}} value)
-                    {
-                        ++*(uint*)&value;
-                        return value;
-                    }
-                }
-                """);
-        }
-
-        context.AddSource($"{name}.g.cs", sourceBuilder.ToString());
-    }
-
-    private sealed class IdentityStructMetadata
-    {
-        public string Name { get; set; } = default!;
-
-        public string? Documentation { get; set; }
-
-        public bool Equatable { get; set; }
-
-        public bool EqualityOperators { get; set; }
-
-        public bool AdditionOperators { get; set; }
-
-        public bool IncrementOperators { get; set; }
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/JsonParser.cs

@@ -1,439 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Runtime.Serialization;
-using System.Text;
-
-namespace Snap.Hutao.SourceGeneration;
-
-// Really simple JSON parser in ~300 lines
-// - Attempts to parse JSON files with minimal GC allocation
-// - Nice and simple "[1,2,3]".FromJson<List<int>>() API
-// - Classes and structs can be parsed too!
-//      class Foo { public int Value; }
-//      "{\"Value\":10}".FromJson<Foo>()
-// - Can parse JSON without type information into Dictionary<string,object> and List<object> e.g.
-//      "[1,2,3]".FromJson<object>().GetType() == typeof(List<object>)
-//      "{\"Value\":10}".FromJson<object>().GetType() == typeof(Dictionary<string,object>)
-// - No JIT Emit support to support AOT compilation on iOS
-// - Attempts are made to NOT throw an exception if the JSON is corrupted or invalid: returns null instead.
-// - Only public fields and property setters on classes/structs will be written to
-//
-// Limitations:
-// - No JIT Emit support to parse structures quickly
-// - Limited to parsing <2GB JSON files (due to int.MaxValue)
-// - Parsing of abstract classes or interfaces is NOT supported and will throw an exception.
-public static class JsonParser
-{
-    [ThreadStatic]
-    private static Stack<List<string>>? splitArrayPool;
-
-    [ThreadStatic]
-    private static StringBuilder? stringBuilder;
-
-    [ThreadStatic]
-    private static Dictionary<Type, Dictionary<string, FieldInfo>>? fieldInfoCache;
-
-    [ThreadStatic]
-    private static Dictionary<Type, Dictionary<string, PropertyInfo>>? propertyInfoCache;
-
-    public static T? FromJson<T>(this string json)
-    {
-        // Initialize, if needed, the ThreadStatic variables
-        propertyInfoCache ??= [];
-        fieldInfoCache ??= [];
-        stringBuilder ??= new();
-        splitArrayPool ??= [];
-
-        // Remove all whitespace not within strings to make parsing simpler
-        stringBuilder.Length = 0;
-        for (int i = 0; i < json.Length; i++)
-        {
-            char c = json[i];
-            if (c == '"')
-            {
-                i = AppendUntilStringEnd(true, i, json);
-                continue;
-            }
-            if (char.IsWhiteSpace(c))
-            {
-                continue;
-            }
-
-            stringBuilder.Append(c);
-        }
-
-        // Parse the thing!
-        return (T?)ParseValue(typeof(T), stringBuilder.ToString());
-    }
-
-    private static int AppendUntilStringEnd(bool appendEscapeCharacter, int startIdx, string json)
-    {
-        stringBuilder!.Append(json[startIdx]);
-        for (int i = startIdx + 1; i < json.Length; i++)
-        {
-            if (json[i] == '\\')
-            {
-                if (appendEscapeCharacter)
-                {
-                    stringBuilder.Append(json[i]);
-                }
-
-                stringBuilder.Append(json[i + 1]);
-                i++;//Skip next character as it is escaped
-            }
-            else if (json[i] == '"')
-            {
-                stringBuilder.Append(json[i]);
-                return i;
-            }
-            else
-            {
-                stringBuilder.Append(json[i]);
-            }
-        }
-        return json.Length - 1;
-    }
-
-    // Splits { <value>:<value>, <value>:<value> } and [ <value>, <value> ] into a list of <value> strings
-    private static List<string> Split(string json)
-    {
-        List<string> splitArray = splitArrayPool!.Count > 0 ? splitArrayPool.Pop() : [];
-        splitArray.Clear();
-        if (json.Length == 2)
-        {
-            return splitArray;
-        }
-
-        int parseDepth = 0;
-        stringBuilder!.Length = 0;
-        for (int i = 1; i < json.Length - 1; i++)
-        {
-            switch (json[i])
-            {
-                case '[':
-                case '{':
-                    parseDepth++;
-                    break;
-                case ']':
-                case '}':
-                    parseDepth--;
-                    break;
-                case '"':
-                    i = AppendUntilStringEnd(true, i, json);
-                    continue;
-                case ',':
-                case ':':
-                    if (parseDepth == 0)
-                    {
-                        splitArray.Add(stringBuilder.ToString());
-                        stringBuilder.Length = 0;
-                        continue;
-                    }
-                    break;
-            }
-
-            stringBuilder.Append(json[i]);
-        }
-
-        splitArray.Add(stringBuilder.ToString());
-
-        return splitArray;
-    }
-
-    internal static object? ParseValue(Type type, string json)
-    {
-        if (type == typeof(string))
-        {
-            if (json.Length <= 2)
-            {
-                return string.Empty;
-            }
-
-            StringBuilder parseStringBuilder = new(json.Length);
-            for (int i = 1; i < json.Length - 1; ++i)
-            {
-                if (json[i] == '\\' && i + 1 < json.Length - 1)
-                {
-                    int j = "\"\\nrtbf/".IndexOf(json[i + 1]);
-                    if (j >= 0)
-                    {
-                        parseStringBuilder.Append("\"\\\n\r\t\b\f/"[j]);
-                        ++i;
-                        continue;
-                    }
-                    if (json[i + 1] == 'u' && i + 5 < json.Length - 1)
-                    {
-                        if (uint.TryParse(json.Substring(i + 2, 4), System.Globalization.NumberStyles.AllowHexSpecifier, null, out uint c))
-                        {
-                            parseStringBuilder.Append((char)c);
-                            i += 5;
-                            continue;
-                        }
-                    }
-                }
-                parseStringBuilder.Append(json[i]);
-            }
-            return parseStringBuilder.ToString();
-        }
-        if (type.IsPrimitive)
-        {
-            object result = Convert.ChangeType(json, type, System.Globalization.CultureInfo.InvariantCulture);
-            return result;
-        }
-        if (type == typeof(decimal))
-        {
-            decimal.TryParse(json, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out decimal result);
-            return result;
-        }
-        if (type == typeof(DateTime))
-        {
-            DateTime.TryParse(json.Replace("\"", ""), System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out DateTime result);
-            return result;
-        }
-        if (json == "null")
-        {
-            return null;
-        }
-        if (type.IsEnum)
-        {
-            if (json[0] == '"')
-            {
-                json = json.Substring(1, json.Length - 2);
-            }
-
-            try
-            {
-                return System.Enum.Parse(type, json, false);
-            }
-            catch
-            {
-                return 0;
-            }
-        }
-        if (type.IsArray)
-        {
-            Type arrayType = type.GetElementType();
-            if (json[0] != '[' || json[json.Length - 1] != ']')
-            {
-                return null;
-            }
-
-            List<string> elems = Split(json);
-            Array newArray = Array.CreateInstance(arrayType, elems.Count);
-            for (int i = 0; i < elems.Count; i++)
-            {
-                newArray.SetValue(ParseValue(arrayType, elems[i]), i);
-            }
-
-            splitArrayPool!.Push(elems);
-            return newArray;
-        }
-        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
-        {
-            Type listType = type.GetGenericArguments()[0];
-            if (json[0] != '[' || json[json.Length - 1] != ']')
-            {
-                return null;
-            }
-
-            List<string> elems = Split(json);
-            IList list = (IList)type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { elems.Count });
-            for (int i = 0; i < elems.Count; i++)
-            {
-                list.Add(ParseValue(listType, elems[i]));
-            }
-
-            splitArrayPool!.Push(elems);
-            return list;
-        }
-        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>))
-        {
-            Type keyType, valueType;
-            {
-                Type[] args = type.GetGenericArguments();
-                keyType = args[0];
-                valueType = args[1];
-            }
-
-            //Refuse to parse dictionary keys that aren't of type string
-            if (keyType != typeof(string))
-            {
-                return null;
-            }
-            //Must be a valid dictionary element
-            if (json[0] != '{' || json[json.Length - 1] != '}')
-            {
-                return null;
-            }
-            //The list is split into key/value pairs only, this means the split must be divisible by 2 to be valid JSON
-            List<string> elems = Split(json);
-            if (elems.Count % 2 != 0)
-            {
-                return null;
-            }
-
-            IDictionary dictionary = (IDictionary)type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { elems.Count / 2 });
-            for (int i = 0; i < elems.Count; i += 2)
-            {
-                if (elems[i].Length <= 2)
-                {
-                    continue;
-                }
-
-                string keyValue = elems[i].Substring(1, elems[i].Length - 2);
-                object? val = ParseValue(valueType, elems[i + 1]);
-                dictionary[keyValue] = val;
-            }
-            return dictionary;
-        }
-        if (type == typeof(object))
-        {
-            return ParseAnonymousValue(json);
-        }
-        if (json[0] == '{' && json[json.Length - 1] == '}')
-        {
-            return ParseObject(type, json);
-        }
-
-        return null;
-    }
-
-    private static object? ParseAnonymousValue(string json)
-    {
-        if (json.Length == 0)
-        {
-            return null;
-        }
-
-        if (json[0] == '{' && json[json.Length - 1] == '}')
-        {
-            List<string> elems = Split(json);
-            if (elems.Count % 2 != 0)
-            {
-                return null;
-            }
-
-            Dictionary<string, object?> dict = new(elems.Count / 2);
-            for (int i = 0; i < elems.Count; i += 2)
-            {
-                dict[elems[i].Substring(1, elems[i].Length - 2)] = ParseAnonymousValue(elems[i + 1]);
-            }
-
-            return dict;
-        }
-        if (json[0] == '[' && json[json.Length - 1] == ']')
-        {
-            List<string> items = Split(json);
-            List<object?> finalList = new(items.Count);
-            for (int i = 0; i < items.Count; i++)
-            {
-                finalList.Add(ParseAnonymousValue(items[i]));
-            }
-
-            return finalList;
-        }
-        if (json[0] == '"' && json[json.Length - 1] == '"')
-        {
-            string str = json.Substring(1, json.Length - 2);
-            return str.Replace("\\", string.Empty);
-        }
-        if (char.IsDigit(json[0]) || json[0] == '-')
-        {
-            if (json.Contains("."))
-            {
-                double.TryParse(json, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out double result);
-                return result;
-            }
-            else
-            {
-                int.TryParse(json, out int result);
-                return result;
-            }
-        }
-        if (json == "true")
-        {
-            return true;
-        }
-
-        if (json == "false")
-        {
-            return false;
-        }
-        // handles json == "null" as well as invalid JSON
-        return null;
-    }
-
-    private static Dictionary<string, T> CreateMemberNameDictionary<T>(T[] members) where T : MemberInfo
-    {
-        Dictionary<string, T> nameToMember = new(StringComparer.OrdinalIgnoreCase);
-        for (int i = 0; i < members.Length; i++)
-        {
-            T member = members[i];
-            if (member.IsDefined(typeof(IgnoreDataMemberAttribute), true))
-            {
-                continue;
-            }
-
-            string name = member.Name;
-            if (member.IsDefined(typeof(DataMemberAttribute), true))
-            {
-                DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)Attribute.GetCustomAttribute(member, typeof(DataMemberAttribute), true);
-                if (!string.IsNullOrEmpty(dataMemberAttribute.Name))
-                {
-                    name = dataMemberAttribute.Name;
-                }
-            }
-
-            nameToMember.Add(name, member);
-        }
-
-        return nameToMember;
-    }
-
-    private static object ParseObject(Type type, string json)
-    {
-        object instance = FormatterServices.GetUninitializedObject(type);
-
-        // The list is split into key/value pairs only, this means the split must be divisible by 2 to be valid JSON
-        List<string> elems = Split(json);
-        if (elems.Count % 2 != 0)
-        {
-            return instance;
-        }
-
-        if (!fieldInfoCache!.TryGetValue(type, out Dictionary<string, FieldInfo> nameToField))
-        {
-            nameToField = CreateMemberNameDictionary(type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy));
-            fieldInfoCache.Add(type, nameToField);
-        }
-        if (!propertyInfoCache!.TryGetValue(type, out Dictionary<string, PropertyInfo> nameToProperty))
-        {
-            nameToProperty = CreateMemberNameDictionary(type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy));
-            propertyInfoCache.Add(type, nameToProperty);
-        }
-
-        for (int i = 0; i < elems.Count; i += 2)
-        {
-            if (elems[i].Length <= 2)
-            {
-                continue;
-            }
-
-            string key = elems[i].Substring(1, elems[i].Length - 2);
-            string value = elems[i + 1];
-
-            if (nameToField.TryGetValue(key, out FieldInfo fieldInfo))
-            {
-                fieldInfo.SetValue(instance, ParseValue(fieldInfo.FieldType, value));
-            }
-            else if (nameToProperty.TryGetValue(key, out PropertyInfo propertyInfo))
-            {
-                propertyInfo.SetValue(instance, ParseValue(propertyInfo.PropertyType, value), null);
-            }
-        }
-
-        return instance;
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Primitive/AttributeDataExtension.cs

@@ -1,32 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Snap.Hutao.SourceGeneration.Primitive;
-
-internal static class AttributeDataExtension
-{
-    public static bool HasNamedArgumentWith<TValue>(this AttributeData data, string key, Func<TValue, bool> predicate)
-    {
-        return data.NamedArguments.Any(a => a.Key == key && predicate((TValue)a.Value.Value!));
-    }
-
-    public static bool TryGetNamedArgumentValue(this AttributeData data, string key, out TypedConstant value)
-    {
-        foreach (KeyValuePair<string, TypedConstant> pair in data.NamedArguments)
-        {
-            if (pair.Key == key)
-            {
-                value = pair.Value;
-                return true;
-            }
-        }
-
-        value = default;
-        return false;
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Primitive/EnumerableExtension.cs

@@ -1,41 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Snap.Hutao.SourceGeneration.Primitive;
-
-internal static class EnumerableExtension
-{
-    public static IEnumerable<TSource> DistinctBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
-    {
-        return DistinctByIterator(source, keySelector);
-    }
-
-    private static IEnumerable<TSource> DistinctByIterator<TSource, TKey>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
-    {
-        using IEnumerator<TSource> enumerator = source.GetEnumerator();
-
-        if (enumerator.MoveNext())
-        {
-            HashSet<TKey> set = [];
-
-            do
-            {
-                TSource element = enumerator.Current;
-                if (set.Add(keySelector(element)))
-                {
-                    yield return element;
-                }
-            }
-            while (enumerator.MoveNext());
-        }
-    }
-
-    public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source)
-    {
-        return source.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Primitive/GeneratorSyntaxContext2.cs

@@ -1,77 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using System.Collections.Immutable;
-using System.Linq;
-
-namespace Snap.Hutao.SourceGeneration.Primitive;
-
-internal readonly struct GeneratorSyntaxContext2
-{
-    public readonly GeneratorSyntaxContext Context;
-    public readonly INamedTypeSymbol Symbol;
-    public readonly ImmutableArray<AttributeData> Attributes;
-    public readonly bool HasValue = false;
-
-    public GeneratorSyntaxContext2(GeneratorSyntaxContext context, INamedTypeSymbol symbol, ImmutableArray<AttributeData> attributes)
-    {
-        Context = context;
-        Symbol = symbol;
-        Attributes = attributes;
-        HasValue = true;
-    }
-
-    public static bool NotNull(GeneratorSyntaxContext2 context)
-    {
-        return context.HasValue;
-    }
-
-    public bool HasAttributeWithName(string name)
-    {
-        return Attributes.Any(attr => attr.AttributeClass!.ToDisplayString() == name);
-    }
-
-    public AttributeData SingleAttribute(string name)
-    {
-        return Attributes.Single(attribute => attribute.AttributeClass!.ToDisplayString() == name);
-    }
-
-    public AttributeData? SingleOrDefaultAttribute(string name)
-    {
-        return Attributes.SingleOrDefault(attribute => attribute.AttributeClass!.ToDisplayString() == name);
-    }
-
-    public TSyntaxNode Node<TSyntaxNode>()
-        where TSyntaxNode : SyntaxNode
-    {
-        return (TSyntaxNode)Context.Node;
-    }
-}
-
-internal readonly struct GeneratorSyntaxContext2<TSymbol>
-    where TSymbol : ISymbol
-{
-    public readonly GeneratorSyntaxContext Context;
-    public readonly TSymbol Symbol;
-    public readonly ImmutableArray<AttributeData> Attributes;
-    public readonly bool HasValue = false;
-
-    public GeneratorSyntaxContext2(GeneratorSyntaxContext context, TSymbol symbol, ImmutableArray<AttributeData> attributes)
-    {
-        Context = context;
-        Symbol = symbol;
-        Attributes = attributes;
-        HasValue = true;
-    }
-
-    public static bool NotNull(GeneratorSyntaxContext2<TSymbol> context)
-    {
-        return context.HasValue;
-    }
-
-    public AttributeData SingleAttribute(string name)
-    {
-        return Attributes.Single(attribute => attribute.AttributeClass!.ToDisplayString() == name);
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Primitive/GeneratorSyntaxContextExtension.cs

@@ -1,18 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using System.Diagnostics.CodeAnalysis;
-
-namespace Snap.Hutao.SourceGeneration.Primitive;
-
-internal static class GeneratorSyntaxContextExtension
-{
-    public static bool TryGetDeclaredSymbol<TSymbol>(this GeneratorSyntaxContext context, System.Threading.CancellationToken token, [NotNullWhen(true)] out TSymbol? symbol)
-        where TSymbol : class, ISymbol
-    {
-        symbol = context.SemanticModel.GetDeclaredSymbol(context.Node, token) as TSymbol;
-        return symbol != null;
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Primitive/SymbolDisplayFormats.cs

@@ -1,21 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-
-namespace Snap.Hutao.SourceGeneration.Primitive;
-
-internal static class SymbolDisplayFormats
-{
-    public static SymbolDisplayFormat FullyQualifiedNonNullableFormat { get; } = new(
-        globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Omitted,
-        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
-        genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
-        miscellaneousOptions: SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers | SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
-
-    public static SymbolDisplayFormat QualifiedNonNullableFormat { get; } = new(
-        globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.Omitted,
-        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameOnly,
-        genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
-        miscellaneousOptions: SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers | SymbolDisplayMiscellaneousOptions.UseSpecialTypes);
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Primitive/SyntaxExtension.cs

@@ -1,20 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-namespace Snap.Hutao.SourceGeneration.Primitive;
-
-internal static class SyntaxExtension
-{
-    /// <summary>
-    /// Checks whether a given <see cref="MemberDeclarationSyntax"/> has or could potentially have any attribute lists.
-    /// </summary>
-    /// <param name="declaration">The input <see cref="MemberDeclarationSyntax"/> to check.</param>
-    /// <returns>Whether <paramref name="declaration"/> has or potentially has any attribute lists.</returns>
-    public static bool HasAttributeLists<TSyntax>(this TSyntax declaration)
-        where TSyntax : MemberDeclarationSyntax
-    {
-        return declaration.AttributeLists.Count > 0;
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Primitive/TypeSymbolExtension.cs

@@ -1,28 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.CodeAnalysis;
-
-namespace Snap.Hutao.SourceGeneration.Primitive;
-
-internal static class TypeSymbolExtension
-{
-    /// <summary>
-    /// Checks whether or not a given <see cref="ITypeSymbol"/> has or inherits from a specified type.
-    /// </summary>
-    /// <param name="typeSymbol">The target <see cref="ITypeSymbol"/> instance to check.</param>
-    /// <param name="name">The full name of the type to check for inheritance.</param>
-    /// <returns>Whether or not <paramref name="typeSymbol"/> is or inherits from <paramref name="name"/>.</returns>
-    public static bool IsOrInheritsFrom(this ITypeSymbol typeSymbol, string name)
-    {
-        for (ITypeSymbol? currentType = typeSymbol; currentType is not null; currentType = currentType.BaseType)
-        {
-            if (currentType.ToDisplayString() == name)
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Resx/ResxGenerator.cs

@@ -1,629 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Text;
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Xml.Linq;
-using System.Xml.XPath;
-
-namespace Snap.Hutao.SourceGeneration.Resx;
-
-[Generator]
-public sealed class ResxGenerator : IIncrementalGenerator
-{
-    private static readonly DiagnosticDescriptor InvalidResx = new("SH401", "Couldn't parse Resx file", "Couldn't parse Resx file '{0}'", "ResxGenerator", DiagnosticSeverity.Warning, true);
-    private static readonly DiagnosticDescriptor InvalidPropertiesForNamespace = new("SH402", "Couldn't compute namespace", "Couldn't compute namespace for file '{0}'", "ResxGenerator", DiagnosticSeverity.Warning, true);
-    private static readonly DiagnosticDescriptor InvalidPropertiesForResourceName = new("SH403", "Couldn't compute resource name", "Couldn't compute resource name for file '{0}'", "ResxGenerator", DiagnosticSeverity.Warning, true);
-    private static readonly DiagnosticDescriptor InconsistentProperties = new("SH404", "Inconsistent properties", "Property '{0}' values for '{1}' are inconsistent", "ResxGenerator", DiagnosticSeverity.Warning, true);
-
-    public void Initialize(IncrementalGeneratorInitializationContext context)
-    {
-        IncrementalValueProvider<(string? AssemblyName, bool SupportNullableReferenceTypes)> compilationProvider = context.CompilationProvider
-            .Select(static (compilation, cancellationToken) => (compilation.AssemblyName, SupportNullableReferenceTypes: compilation.GetTypeByMetadataName("System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute") is not null));
-
-        IncrementalValueProvider<ImmutableArray<AdditionalText>> resxProvider = context.AdditionalTextsProvider
-            .Where(text => text.Path.EndsWith(".resx", StringComparison.OrdinalIgnoreCase))
-            .Collect();
-
-        context.RegisterSourceOutput(
-            source: context.AnalyzerConfigOptionsProvider.Combine(compilationProvider.Combine(resxProvider)),
-            action: (ctx, source) => Execute(ctx, source.Left, source.Right.Left.AssemblyName, source.Right.Left.SupportNullableReferenceTypes, source.Right.Right));
-    }
-
-    private static void Execute(SourceProductionContext context, AnalyzerConfigOptionsProvider options, string? assemblyName, bool supportNullableReferenceTypes, ImmutableArray<AdditionalText> files)
-    {
-        // Group additional file by resource kind ((a.resx, a.en.resx, a.en-us.resx), (b.resx, b.en-us.resx))
-        IOrderedEnumerable<IGrouping<string, AdditionalText>> group = files
-            .GroupBy(file => GetResourceName(file.Path), StringComparer.OrdinalIgnoreCase)
-            .OrderBy(x => x.Key, StringComparer.Ordinal);
-        List<IGrouping<string, AdditionalText>> resxGroups = [.. group];
-
-        foreach (IGrouping<string, AdditionalText>? resxGroup in resxGroups)
-        {
-            string? rootNamespaceConfiguration = GetMetadataValue(context, options, "RootNamespace", resxGroup);
-            string? projectDirConfiguration = GetMetadataValue(context, options, "ProjectDir", resxGroup);
-            string? namespaceConfiguration = GetMetadataValue(context, options, "Namespace", "DefaultResourcesNamespace", resxGroup);
-            string? resourceNameConfiguration = GetMetadataValue(context, options, "ResourceName", globalName: null, resxGroup);
-            string? classNameConfiguration = GetMetadataValue(context, options, "ClassName", globalName: null, resxGroup);
-
-            string rootNamespace = rootNamespaceConfiguration ?? assemblyName ?? "";
-            string projectDir = projectDirConfiguration ?? assemblyName ?? "";
-            string? defaultResourceName = ComputeResourceName(rootNamespace, projectDir, resxGroup.Key);
-            string? defaultNamespace = ComputeNamespace(rootNamespace, projectDir, resxGroup.Key);
-
-            string? ns = namespaceConfiguration ?? defaultNamespace;
-            string? resourceName = resourceNameConfiguration ?? defaultResourceName;
-            string className = classNameConfiguration ?? ToCSharpNameIdentifier(Path.GetFileName(resxGroup.Key));
-
-            if (ns == null)
-            {
-                context.ReportDiagnostic(Diagnostic.Create(InvalidPropertiesForNamespace, location: null, resxGroup.First().Path));
-            }
-
-            if (resourceName == null)
-            {
-                context.ReportDiagnostic(Diagnostic.Create(InvalidPropertiesForResourceName, location: null, resxGroup.First().Path));
-            }
-
-            List<ResxEntry>? entries = LoadResourceFiles(context, resxGroup);
-
-            string content = $"""
-                // Debug info:
-                // key: {resxGroup.Key}
-                // files: {string.Join(", ", resxGroup.Select(f => f.Path))}
-                // RootNamespace (metadata): {rootNamespaceConfiguration}
-                // ProjectDir (metadata): {projectDirConfiguration}
-                // Namespace / DefaultResourcesNamespace (metadata): {namespaceConfiguration}
-                // ResourceName (metadata): {resourceNameConfiguration}
-                // ClassName (metadata): {classNameConfiguration}
-                // AssemblyName: {assemblyName}
-                // RootNamespace (computed): {rootNamespace}
-                // ProjectDir (computed): {projectDir}
-                // defaultNamespace: {defaultNamespace}
-                // defaultResourceName: {defaultResourceName}
-                // Namespace: {ns}
-                // ResourceName: {resourceName}
-                // ClassName: {className}
-                """;
-
-            if (resourceName != null && entries != null)
-            {
-                content += GenerateCode(ns, className, resourceName, entries, supportNullableReferenceTypes);
-            }
-
-            context.AddSource($"{Path.GetFileName(resxGroup.Key)}.resx.g.cs", SourceText.From(content, Encoding.UTF8));
-        }
-    }
-
-    private static string GenerateCode(string? ns, string className, string resourceName, List<ResxEntry> entries, bool enableNullableAttributes)
-    {
-        StringBuilder sb = new();
-        sb.AppendLine();
-        sb.AppendLine("#nullable enable");
-
-        if (ns != null)
-        {
-            sb.AppendLine($$"""
-
-                namespace {{ns}};
-
-                """);
-        }
-
-        sb.AppendLine($$"""
-            internal partial class {{className}}
-            {
-                private static global::System.Resources.ResourceManager? resourceMan;
-
-                public {{className}}()
-                {
-                }
-
-                [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-                public static global::System.Resources.ResourceManager ResourceManager
-                {
-                    get
-                    {
-                        if (resourceMan is null) 
-                        {
-                            resourceMan = new global::System.Resources.ResourceManager("{{resourceName}}", typeof({{className}}).Assembly);
-                        }
-
-                        return resourceMan;
-                    }
-                }
-
-                [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
-                public static global::System.Globalization.CultureInfo? Culture { get; set; }
-
-                [return:global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute("defaultValue")]
-                public static object? GetObject(global::System.Globalization.CultureInfo? culture, string name, object? defaultValue)
-                {
-                    culture ??= Culture;
-                    object? obj = ResourceManager.GetObject(name, culture);
-                    if (obj == null)
-                    {
-                        return defaultValue;
-                    }
-            
-                    return obj;
-                }
-
-                public static object? GetObject(global::System.Globalization.CultureInfo? culture, string name)
-                {
-                    return GetObject(culture: culture, name: name, defaultValue: null);
-                }
-            
-                public static object? GetObject(string name)
-                {
-                    return GetObject(culture: null, name: name, defaultValue: null);
-                }
-
-                [return:global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute("defaultValue")]
-                public static object? GetObject(string name, object? defaultValue)
-                {
-                    return GetObject(culture: null, name: name, defaultValue: defaultValue);
-                }
-            
-                public static global::System.IO.Stream? GetStream(string name)
-                {
-                    return GetStream(culture: null, name: name);
-                }
-            
-                public static global::System.IO.Stream? GetStream(global::System.Globalization.CultureInfo? culture, string name)
-                {
-                    culture ??= Culture;
-                    return ResourceManager.GetStream(name, culture);
-                }
-            
-                public static string? GetString(global::System.Globalization.CultureInfo? culture, string name)
-                {
-                    return GetString(culture: culture, name: name, args: null);
-                }
-            
-                public static string? GetString(global::System.Globalization.CultureInfo? culture, string name, params object?[]? args)
-                {
-                    culture ??= Culture;
-                    string? str = ResourceManager.GetString(name, culture);
-                    if (str == null)
-                    {
-                        return null;
-                    }
-            
-                    if (args != null)
-                    {
-                        return string.Format(culture, str, args);
-                    }
-                    else
-                    {
-                        return str;
-                    }
-                }
-                
-                public static string? GetString(string name, params object?[]? args)
-                {
-                    return GetString(culture: null, name: name, args: args);
-                }
-
-                [return: global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute("defaultValue")]
-                public static string? GetString(string name, string? defaultValue)
-                {
-                    return GetStringOrDefault(culture: null, name: name, defaultValue: defaultValue, args: null);
-                }
-            
-                public static string? GetString(string name)
-                {
-                    return GetStringOrDefault(culture: null, name: name, defaultValue: null, args: null);
-                }
-
-                [return:global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute("defaultValue")]
-                public static string? GetStringOrDefault(global::System.Globalization.CultureInfo? culture, string name, string? defaultValue)
-                {
-                    return GetStringOrDefault(culture: culture, name: name, defaultValue: defaultValue, args: null);
-                }
-
-                [return:global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute("defaultValue")]
-                public static string? GetStringOrDefault(global::System.Globalization.CultureInfo? culture, string name, string? defaultValue, params object?[]? args)
-                {
-                    culture ??= Culture;
-                    string? str = ResourceManager.GetString(name, culture);
-                    if (str == null)
-                    {
-                        if (defaultValue == null || args == null)
-                        {
-                            return defaultValue;
-                        }
-                        else
-                        {
-                            return string.Format(culture, defaultValue, args);
-                        }
-                    }
-            
-                    if (args != null)
-                    {
-                        return string.Format(culture, str, args);
-                    }
-                    else
-                    {
-                        return str;
-                    }
-                }
-
-                [return:global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute("defaultValue")]
-                public static string? GetStringOrDefault(string name, string? defaultValue, params object?[]? args)
-                {
-                    return GetStringOrDefault(culture: null, name: name, defaultValue: defaultValue, args: args);
-                }
-
-                [return:global::System.Diagnostics.CodeAnalysis.NotNullIfNotNullAttribute("defaultValue")]
-                public static string? GetStringOrDefault(string name, string? defaultValue)
-                {
-                    return GetStringOrDefault(culture: null, name: name, defaultValue: defaultValue, args: null);
-                }
-            """);
-
-        foreach (ResxEntry? entry in entries.OrderBy(e => e.Name, StringComparer.Ordinal))
-        {
-            if (string.IsNullOrEmpty(entry.Name))
-            {
-                continue;
-            }
-
-            if (entry.IsText)
-            {
-                XElement summary = new("summary", new XElement("para", $"Looks up a localized string for \"{entry.Name}\"."));
-                if (!string.IsNullOrWhiteSpace(entry.Comment))
-                {
-                    summary.Add(new XElement("para", entry.Comment));
-                }
-
-                if (!entry.IsFileRef)
-                {
-                    foreach((string? each, string locale) in entry.Values.Zip(entry.Locales,(x,y)=>(x,y)))
-                    {
-                        summary.Add(new XElement("para", $"{GetStringWithPadding(locale, 8)} Value: \"{each}\""));
-                    }
-                }
-
-                string comment = summary.ToString().Replace("\r\n", "\r\n   /// ", StringComparison.Ordinal);
-
-                sb.AppendLine($$"""
-                        /// {{comment}}
-                        public static string {{ToCSharpNameIdentifier(entry.Name!)}}
-                        {
-                            get => GetString("{{entry.Name}}")!;
-                        }
-
-                    """);
-
-                if (entry.Values.FirstOrDefault() is string value)
-                {
-                    int args = Regex.Matches(value, "\\{(?<num>[0-9]+)(\\:[^}]*)?\\}", RegexOptions.ExplicitCapture | RegexOptions.CultureInvariant)
-                        .Cast<Match>()
-                        .Select(m => int.Parse(m.Groups["num"].Value, CultureInfo.InvariantCulture))
-                        .Distinct()
-                        .DefaultIfEmpty(-1)
-                        .Max();
-
-                    if (args >= 0)
-                    {
-                        string inParams = string.Join(", ", Enumerable.Range(0, args + 1).Select(arg => "object? arg" + arg.ToString(CultureInfo.InvariantCulture)));
-                        string callParams = string.Join(", ", Enumerable.Range(0, args + 1).Select(arg => "arg" + arg.ToString(CultureInfo.InvariantCulture)));
-
-                        sb.AppendLine($$"""
-                                /// {{comment}}
-                                public static string Format{{ToCSharpNameIdentifier(entry.Name!)}}({{inParams}})
-                                {
-                                    return GetString("{{entry.Name}}", {{callParams}})!;
-                                }
-
-                            """);
-                    }
-                }
-            }
-            else
-            {
-                sb.AppendLine($$"""
-                        public static global::{{entry.FullTypeName}}? {{ToCSharpNameIdentifier(entry.Name!)}}
-                        {
-                            get => (global::{{entry.FullTypeName}}?)GetObject("{{entry.Name}}");
-                        }
-
-                    """);
-            }
-        }
-
-        sb.AppendLine($$"""
-            }
-
-            internal partial class {{className}}Names
-            {
-            """);
-
-        foreach (ResxEntry entry in entries)
-        {
-            if (string.IsNullOrEmpty(entry.Name))
-            {
-                continue;
-            }
-
-            sb.AppendLine($$"""
-                    public const string {{ToCSharpNameIdentifier(entry.Name!)}} = "entry.Name";
-                """);
-        }
-
-        sb.AppendLine("}");
-
-        return sb.ToString();
-    }
-
-    private static string GetStringWithPadding(string source, int length)
-    {
-        if (source.Length >= length)
-        {
-            return source;
-        }
-
-        return source + new string('_', length - source.Length);
-    }
-
-    private static string? ComputeResourceName(string rootNamespace, string projectDir, string resourcePath)
-    {
-        string fullProjectDir = EnsureEndSeparator(Path.GetFullPath(projectDir));
-        string fullResourcePath = Path.GetFullPath(resourcePath);
-
-        if (fullProjectDir == fullResourcePath)
-        {
-            return rootNamespace;
-        }
-
-        if (fullResourcePath.StartsWith(fullProjectDir, StringComparison.Ordinal))
-        {
-            string relativePath = fullResourcePath.Substring(fullProjectDir.Length);
-            return rootNamespace + '.' + relativePath.Replace('/', '.').Replace('\\', '.');
-        }
-
-        return null;
-    }
-
-    private static string? ComputeNamespace(string rootNamespace, string projectDir, string resourcePath)
-    {
-        string fullProjectDir = EnsureEndSeparator(Path.GetFullPath(projectDir));
-        string fullResourcePath = EnsureEndSeparator(Path.GetDirectoryName(Path.GetFullPath(resourcePath))!);
-
-        if (fullProjectDir == fullResourcePath)
-        {
-            return rootNamespace;
-        }
-
-        if (fullResourcePath.StartsWith(fullProjectDir, StringComparison.Ordinal))
-        {
-            string relativePath = fullResourcePath.Substring(fullProjectDir.Length);
-            return rootNamespace + '.' + relativePath.Replace('/', '.').Replace('\\', '.').TrimEnd('.');
-        }
-
-        return null;
-    }
-
-    private static List<ResxEntry>? LoadResourceFiles(SourceProductionContext context, IGrouping<string, AdditionalText> resxGroug)
-    {
-        List<ResxEntry> entries = [];
-        foreach (AdditionalText? entry in resxGroug.OrderBy(file => file.Path, StringComparer.Ordinal))
-        {
-            SourceText? content = entry.GetText(context.CancellationToken);
-            if (content is null)
-            {
-                continue;
-            }
-
-            try
-            {
-                XDocument document = XDocument.Parse(content.ToString());
-                foreach (XElement? element in document.XPathSelectElements("/root/data"))
-                {
-                    string? name = element.Attribute("name")?.Value;
-                    string? type = element.Attribute("type")?.Value;
-                    string? comment = element.Attribute("comment")?.Value;
-                    string? value = element.Element("value")?.Value;
-
-                    ResxEntry existingEntry = entries.Find(e => e.Name == name);
-                    if (existingEntry != null)
-                    {
-                        existingEntry.Comment ??= comment;
-                        existingEntry.Values.Add(value);
-                        existingEntry.Locales.Add(GetLocaleName(entry.Path));
-                    }
-                    else
-                    {
-                        entries.Add(new() { Name = name, Values = [value], Locales = [GetLocaleName(entry.Path)], Comment = comment, Type = type });
-                    }
-                }
-            }
-            catch
-            {
-                context.ReportDiagnostic(Diagnostic.Create(InvalidResx, location: null, entry.Path));
-                return null;
-            }
-        }
-
-        return entries;
-    }
-
-    private static string? GetMetadataValue(SourceProductionContext context, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, string name, IEnumerable<AdditionalText> additionalFiles)
-    {
-        return GetMetadataValue(context, analyzerConfigOptionsProvider, name, name, additionalFiles);
-    }
-
-    private static string? GetMetadataValue(SourceProductionContext context, AnalyzerConfigOptionsProvider analyzerConfigOptionsProvider, string name, string? globalName, IEnumerable<AdditionalText> additionalFiles)
-    {
-        string? result = null;
-        foreach (AdditionalText file in additionalFiles)
-        {
-            if (analyzerConfigOptionsProvider.GetOptions(file).TryGetValue("build_metadata.AdditionalFiles." + name, out string? value))
-            {
-                if (result != null && value != result)
-                {
-                    context.ReportDiagnostic(Diagnostic.Create(InconsistentProperties, location: null, name, file.Path));
-                    return null;
-                }
-
-                result = value;
-            }
-        }
-
-        if (!string.IsNullOrEmpty(result))
-        {
-            return result;
-        }
-
-        if (globalName != null && analyzerConfigOptionsProvider.GlobalOptions.TryGetValue("build_property." + globalName, out string? globalValue) && !string.IsNullOrEmpty(globalValue))
-        {
-            return globalValue;
-        }
-
-        return null;
-    }
-
-    private static string ToCSharpNameIdentifier(string name)
-    {
-        // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/lexical-structure#identifiers
-        // https://docs.microsoft.com/en-us/dotnet/api/system.globalization.unicodecategory?view=net-5.0
-        StringBuilder sb = new();
-        foreach (char c in name)
-        {
-            UnicodeCategory category = char.GetUnicodeCategory(c);
-            switch (category)
-            {
-                case UnicodeCategory.UppercaseLetter:
-                case UnicodeCategory.LowercaseLetter:
-                case UnicodeCategory.TitlecaseLetter:
-                case UnicodeCategory.ModifierLetter:
-                case UnicodeCategory.OtherLetter:
-                case UnicodeCategory.LetterNumber:
-                    sb.Append(c);
-                    break;
-
-                case UnicodeCategory.DecimalDigitNumber:
-                case UnicodeCategory.ConnectorPunctuation:
-                case UnicodeCategory.Format:
-                    if (sb.Length == 0)
-                    {
-                        sb.Append('_');
-                    }
-                    sb.Append(c);
-                    break;
-
-                default:
-                    sb.Append('_');
-                    break;
-            }
-        }
-
-        return sb.ToString();
-    }
-
-    private static string EnsureEndSeparator(string path)
-    {
-        if (path[path.Length - 1] == Path.DirectorySeparatorChar)
-        {
-            return path;
-        }
-
-        return path + Path.DirectorySeparatorChar;
-    }
-
-    private static string GetResourceName(string path)
-    {
-        string pathWithoutExtension = Path.Combine(Path.GetDirectoryName(path)!, Path.GetFileNameWithoutExtension(path));
-        int indexOf = pathWithoutExtension.LastIndexOf('.');
-        if (indexOf < 0)
-        {
-            return pathWithoutExtension;
-        }
-
-        return Regex.IsMatch(pathWithoutExtension.Substring(indexOf + 1), "^[a-zA-Z]{2}(-[a-zA-Z]{2,4})?$", RegexOptions.ExplicitCapture | RegexOptions.CultureInvariant, TimeSpan.FromSeconds(1))
-            ? pathWithoutExtension.Substring(0, indexOf)
-            : pathWithoutExtension;
-    }
-
-    private static string GetLocaleName(string path)
-    {
-        string fileName = Path.GetFileNameWithoutExtension(path);
-        int indexOf = fileName.LastIndexOf('.');
-        if (indexOf < 0)
-        {
-            return "Neutral";
-        }
-
-        return fileName.Substring(indexOf + 1);
-    }
-
-    private sealed class ResxEntry
-    {
-        public string? Name { get; set; }
-        public List<string?> Values { get; set; } = default!;
-        public List<string> Locales { get; set; } = default!;
-        public string? Comment { get; set; }
-        public string? Type { get; set; }
-
-        public bool IsText
-        {
-            get
-            {
-                if (Type == null)
-                {
-                    return true;
-                }
-
-                if (Values.FirstOrDefault() is string value)
-                {
-                    string[] parts = value.Split(';');
-                    if (parts.Length > 1)
-                    {
-                        string type = parts[1];
-                        if (type.StartsWith("System.String,", StringComparison.Ordinal))
-                        {
-                            return true;
-                        }
-                    }
-                }
-
-                return false;
-            }
-        }
-
-        public string? FullTypeName
-        {
-            get
-            {
-                if (IsText)
-                {
-                    return "string";
-                }
-
-                if (Values.FirstOrDefault() is string value)
-                {
-                    string[] parts = value.Split(';');
-                    if (parts.Length > 1)
-                    {
-                        string type = parts[1];
-                        return type.Split(',')[0];
-                    }
-                }
-
-                return null;
-            }
-        }
-
-        public bool IsFileRef
-        {
-            get => Type != null && Type.StartsWith("System.Resources.ResXFileRef,", StringComparison.Ordinal);
-        }
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Resx/StringExtensions.cs

@@ -1,27 +0,0 @@
-using System;
-using System.Text;
-
-namespace Snap.Hutao.SourceGeneration.Resx;
-
-internal static class StringExtensions
-{
-    public static string Replace(this string str, string oldValue, string newValue, StringComparison comparison)
-    {
-        StringBuilder sb = new();
-
-        int previousIndex = 0;
-        int index = str.IndexOf(oldValue, comparison);
-        while (index is not -1)
-        {
-            sb.Append(str, previousIndex, index - previousIndex);
-            sb.Append(newValue);
-            index += oldValue.Length;
-
-            previousIndex = index;
-            index = str.IndexOf(oldValue, index, comparison);
-        }
-
-        sb.Append(str, previousIndex, str.Length - previousIndex);
-        return sb.ToString();
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/Snap.Hutao.SourceGeneration.csproj

@@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <LangVersion>latest</LangVersion>
-    <Nullable>enable</Nullable>
-    <Platforms>x64</Platforms>
-    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
-    <Configurations>Debug;Release</Configurations>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" PrivateAssets="all" Version="3.3.4" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.7.0" />
-  </ItemGroup>
-
-</Project>

src/Snap.Hutao/Snap.Hutao.SourceGeneration/UniversalAnalyzer.cs

@@ -1,302 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Snap.Hutao.SourceGeneration.Primitive;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-
-namespace Snap.Hutao.SourceGeneration;
-
-/// <summary>
-/// 通用分析器
-/// </summary>
-[DiagnosticAnalyzer(LanguageNames.CSharp)]
-internal sealed class UniversalAnalyzer : DiagnosticAnalyzer
-{
-    private static readonly DiagnosticDescriptor typeInternalDescriptor = new("SH001", "Type should be internal", "Type [{0}] should be internal", "Quality", DiagnosticSeverity.Info, true);
-    private static readonly DiagnosticDescriptor readOnlyStructRefDescriptor = new("SH002", "ReadOnly struct should be passed with ref-like key word", "ReadOnly Struct [{0}] should be passed with ref-like key word", "Quality", DiagnosticSeverity.Info, true);
-    private static readonly DiagnosticDescriptor useValueTaskIfPossibleDescriptor = new("SH003", "Use ValueTask instead of Task whenever possible", "Use ValueTask instead of Task", "Quality", DiagnosticSeverity.Info, true);
-    private static readonly DiagnosticDescriptor useIsNotNullPatternMatchingDescriptor = new("SH004", "Use \"is not null\" instead of \"!= null\" whenever possible", "Use \"is not null\" instead of \"!= null\"", "Quality", DiagnosticSeverity.Info, true);
-    private static readonly DiagnosticDescriptor useIsNullPatternMatchingDescriptor = new("SH005", "Use \"is null\" instead of \"== null\" whenever possible", "Use \"is null\" instead of \"== null\"", "Quality", DiagnosticSeverity.Info, true);
-    private static readonly DiagnosticDescriptor useIsPatternRecursiveMatchingDescriptor = new("SH006", "Use \"is { } obj\" whenever possible", "Use \"is {{ }} {0}\"", "Quality", DiagnosticSeverity.Info, true);
-    private static readonly DiagnosticDescriptor useArgumentNullExceptionThrowIfNullDescriptor = new("SH007", "Use \"ArgumentNullException.ThrowIfNull()\" instead of \"!\"", "Use \"ArgumentNullException.ThrowIfNull()\"", "Quality", DiagnosticSeverity.Info, true);
-
-
-    private static readonly ImmutableHashSet<string> RefLikeKeySkipTypes = new HashSet<string>()
-    {
-        "System.Threading.CancellationToken",
-        "System.Guid"
-    }.ToImmutableHashSet();
-
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-    {
-        get
-        {
-            return new DiagnosticDescriptor[]
-            {
-                typeInternalDescriptor,
-                readOnlyStructRefDescriptor,
-                useValueTaskIfPossibleDescriptor,
-                useIsNotNullPatternMatchingDescriptor,
-                useIsNullPatternMatchingDescriptor,
-                useIsPatternRecursiveMatchingDescriptor,
-                useArgumentNullExceptionThrowIfNullDescriptor
-            }.ToImmutableArray();
-        }
-    }
-
-    public override void Initialize(AnalysisContext context)
-    {
-        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
-        context.EnableConcurrentExecution();
-
-        context.RegisterCompilationStartAction(CompilationStart);
-    }
-
-    private static void CompilationStart(CompilationStartAnalysisContext context)
-    {
-        SyntaxKind[] types = [SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.EnumDeclaration,];
-        context.RegisterSyntaxNodeAction(HandleTypeShouldBeInternal, types);
-        context.RegisterSyntaxNodeAction(HandleMethodParameterShouldUseRefLikeKeyword, SyntaxKind.MethodDeclaration);
-        context.RegisterSyntaxNodeAction(HandleMethodReturnTypeShouldUseValueTaskInsteadOfTask, SyntaxKind.MethodDeclaration);
-        context.RegisterSyntaxNodeAction(HandleConstructorParameterShouldUseRefLikeKeyword, SyntaxKind.ConstructorDeclaration);
-
-        SyntaxKind[] expressions = [SyntaxKind.EqualsExpression, SyntaxKind.NotEqualsExpression,];
-        context.RegisterSyntaxNodeAction(HandleEqualsAndNotEqualsExpressionShouldUsePatternMatching, expressions);
-        context.RegisterSyntaxNodeAction(HandleIsPatternShouldUseRecursivePattern, SyntaxKind.IsPatternExpression);
-        context.RegisterSyntaxNodeAction(HandleArgumentNullExceptionThrowIfNull, SyntaxKind.SuppressNullableWarningExpression);
-
-        // TODO add analyzer for unnecessary IServiceProvider registration
-        // TODO add analyzer for Singlton service use Scoped or Transient services
-    }
-
-    private static void HandleTypeShouldBeInternal(SyntaxNodeAnalysisContext context)
-    {
-        BaseTypeDeclarationSyntax syntax = (BaseTypeDeclarationSyntax)context.Node;
-
-        bool privateExists = false;
-        bool internalExists = false;
-        bool fileExists = false;
-
-        foreach (SyntaxToken token in syntax.Modifiers)
-        {
-            if (token.IsKind(SyntaxKind.PrivateKeyword))
-            {
-                privateExists = true;
-            }
-
-            if (token.IsKind(SyntaxKind.InternalKeyword))
-            {
-                internalExists = true;
-            }
-
-            if (token.IsKind(SyntaxKind.FileKeyword))
-            {
-                fileExists = true;
-            }
-        }
-
-        if (!privateExists && !internalExists && !fileExists)
-        {
-            Location location = syntax.Identifier.GetLocation();
-            Diagnostic diagnostic = Diagnostic.Create(typeInternalDescriptor, location, syntax.Identifier);
-            context.ReportDiagnostic(diagnostic);
-        }
-    }
-
-    private static void HandleMethodReturnTypeShouldUseValueTaskInsteadOfTask(SyntaxNodeAnalysisContext context)
-    {
-        MethodDeclarationSyntax methodSyntax = (MethodDeclarationSyntax)context.Node;
-        IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodSyntax)!;
-
-        // 跳过重载方法
-        if (methodSyntax.Modifiers.Any(token => token.IsKind(SyntaxKind.OverrideKeyword)))
-        {
-            return;
-        }
-
-        // ICommand can only use Task or Task<T>
-        if (methodSymbol.GetAttributes().Any(attr => attr.AttributeClass!.ToDisplayString() == Automation.CommandGenerator.AttributeName))
-        {
-            return;
-        }
-
-        if (methodSymbol.ReturnType.IsOrInheritsFrom("System.Threading.Tasks.Task"))
-        {
-            Location location = methodSyntax.ReturnType.GetLocation();
-            Diagnostic diagnostic = Diagnostic.Create(useValueTaskIfPossibleDescriptor, location);
-            context.ReportDiagnostic(diagnostic);
-        }
-    }
-
-    private static void HandleMethodParameterShouldUseRefLikeKeyword(SyntaxNodeAnalysisContext context)
-    {
-        MethodDeclarationSyntax methodSyntax = (MethodDeclarationSyntax)context.Node;
-
-        // 跳过方法定义 如 接口
-        if (methodSyntax.Body == null)
-        {
-            return;
-        }
-
-        IMethodSymbol methodSymbol = context.SemanticModel.GetDeclaredSymbol(methodSyntax)!;
-
-        if (methodSymbol.ReturnType.IsOrInheritsFrom("System.Threading.Tasks.Task"))
-        {
-            return;
-        }
-
-        if (methodSymbol.ReturnType.IsOrInheritsFrom("System.Threading.Tasks.ValueTask"))
-        {
-            return;
-        }
-
-        foreach (SyntaxToken token in methodSyntax.Modifiers)
-        {
-            // 跳过异步方法，因为异步方法无法使用 ref/in/out
-            if (token.IsKind(SyntaxKind.AsyncKeyword))
-            {
-                return;
-            }
-
-            // 跳过重载方法
-            if (token.IsKind(SyntaxKind.OverrideKeyword))
-            {
-                return;
-            }
-        }
-
-        foreach (ParameterSyntax parameter in methodSyntax.ParameterList.Parameters)
-        {
-            if (context.SemanticModel.GetDeclaredSymbol(parameter) is IParameterSymbol symbol)
-            {
-                if (IsBuiltInType(symbol.Type))
-                {
-                    continue;
-                }
-
-                if (RefLikeKeySkipTypes.Contains(symbol.Type.ToDisplayString()))
-                {
-                    continue;
-                }
-
-                if (symbol.Type.IsReadOnly && symbol.RefKind == RefKind.None)
-                {
-                    Location location = parameter.GetLocation();
-                    Diagnostic diagnostic = Diagnostic.Create(readOnlyStructRefDescriptor, location, symbol.Type);
-                    context.ReportDiagnostic(diagnostic);
-                }
-            }
-        }
-    }
-
-    private static void HandleConstructorParameterShouldUseRefLikeKeyword(SyntaxNodeAnalysisContext context)
-    {
-        ConstructorDeclarationSyntax constructorSyntax = (ConstructorDeclarationSyntax)context.Node;
-
-        foreach (ParameterSyntax parameter in constructorSyntax.ParameterList.Parameters)
-        {
-            if (context.SemanticModel.GetDeclaredSymbol(parameter) is IParameterSymbol symbol)
-            {
-                if (IsBuiltInType(symbol.Type))
-                {
-                    continue;
-                }
-
-                // 跳过 CancellationToken
-                if (symbol.Type.ToDisplayString() == "System.Threading.CancellationToken")
-                {
-                    continue;
-                }
-
-                if (symbol.Type.IsReadOnly && symbol.RefKind == RefKind.None)
-                {
-                    Location location = parameter.GetLocation();
-                    Diagnostic diagnostic = Diagnostic.Create(readOnlyStructRefDescriptor, location, symbol.Type);
-                    context.ReportDiagnostic(diagnostic);
-                }
-            }
-        }
-    }
-
-    public static void HandleEqualsAndNotEqualsExpressionShouldUsePatternMatching(SyntaxNodeAnalysisContext context)
-    {
-        BinaryExpressionSyntax syntax = (BinaryExpressionSyntax)context.Node;
-        if (syntax.IsKind(SyntaxKind.NotEqualsExpression) && syntax.Right.IsKind(SyntaxKind.NullLiteralExpression))
-        {
-            Location location = syntax.OperatorToken.GetLocation();
-            Diagnostic diagnostic = Diagnostic.Create(useIsNotNullPatternMatchingDescriptor, location);
-            context.ReportDiagnostic(diagnostic);
-        }
-        else if (syntax.IsKind(SyntaxKind.EqualsExpression) && syntax.Right.IsKind(SyntaxKind.NullLiteralExpression))
-        {
-            Location location = syntax.OperatorToken.GetLocation();
-            Diagnostic diagnostic = Diagnostic.Create(useIsNullPatternMatchingDescriptor, location);
-            context.ReportDiagnostic(diagnostic);
-        }
-    }
-
-    private static void HandleIsPatternShouldUseRecursivePattern(SyntaxNodeAnalysisContext context)
-    {
-        IsPatternExpressionSyntax syntax = (IsPatternExpressionSyntax)context.Node;
-        if (syntax.Pattern is DeclarationPatternSyntax declaration)
-        {
-            ITypeSymbol? leftType = context.SemanticModel.GetTypeInfo(syntax.Expression).ConvertedType;
-            ITypeSymbol? rightType = context.SemanticModel.GetTypeInfo(declaration).ConvertedType;
-            if (SymbolEqualityComparer.Default.Equals(leftType, rightType))
-            {
-                Location location = declaration.GetLocation();
-                Diagnostic diagnostic = Diagnostic.Create(useIsPatternRecursiveMatchingDescriptor, location, declaration.Designation);
-                context.ReportDiagnostic(diagnostic);
-            }
-        }
-    }
-
-    private static void HandleArgumentNullExceptionThrowIfNull(SyntaxNodeAnalysisContext context)
-    {
-        PostfixUnaryExpressionSyntax syntax = (PostfixUnaryExpressionSyntax)context.Node;
-
-        if (syntax.Operand is LiteralExpressionSyntax literal)
-        {
-            if (literal.IsKind(SyntaxKind.DefaultLiteralExpression))
-            {
-                return;
-            }
-        }
-
-        if (syntax.Operand is DefaultExpressionSyntax expression)
-        {
-            return;
-        }
-
-
-        Location location = syntax.GetLocation();
-        Diagnostic diagnostic = Diagnostic.Create(useArgumentNullExceptionThrowIfNullDescriptor, location);
-        context.ReportDiagnostic(diagnostic);
-    }
-
-    private static bool IsBuiltInType(ITypeSymbol symbol)
-    {
-        return symbol.SpecialType switch
-        {
-            SpecialType.System_Boolean => true,
-            SpecialType.System_Char => true,
-            SpecialType.System_SByte => true,
-            SpecialType.System_Byte => true,
-            SpecialType.System_Int16 => true,
-            SpecialType.System_UInt16 => true,
-            SpecialType.System_Int32 => true,
-            SpecialType.System_UInt32 => true,
-            SpecialType.System_Int64 => true,
-            SpecialType.System_UInt64 => true,
-            SpecialType.System_Decimal => true,
-            SpecialType.System_Single => true,
-            SpecialType.System_Double => true,
-            SpecialType.System_IntPtr => true,
-            SpecialType.System_UIntPtr => true,
-            _ => false,
-        };
-    }
-}

src/Snap.Hutao/Snap.Hutao.SourceGeneration/stylecop.json

@@ -1,23 +0,0 @@
-{
-  "$schema": "https://raw.githubusercontent.com/DotNetAnalyzers/StyleCopAnalyzers/master/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json",
-  "settings": {
-    "documentationRules": {
-      "companyName": "DGP Studio",
-      "copyrightText": "Copyright (c) {companyName}. All rights reserved.\nLicensed under the {licenseName} license.",
-      "xmlHeader": false,
-      "variables": {
-        "licenseName": "MIT"
-      }
-    },
-    "orderingRules": {
-      "elementOrder": [
-        "kind",
-        "accessibility",
-        "constant",
-        "static",
-        "readonly"
-      ],
-      "usingDirectivesPlacement": "outsideNamespace"
-    }
-  }
-}

src/Snap.Hutao/Snap.Hutao.Test/BaseClassLibrary/CollectionsMarshalTest.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Snap.Hutao.Test.BaseClassLibrary;
+
+[TestClass]
+public class CollectionsMarshalTest
+{
+    [TestMethod]
+    public void DictionaryMarshalGetValueRefOrNullRefIsNullRef()
+    {
+        Dictionary<uint, string> dictionaryValueKeyRefValue = [];
+        Dictionary<uint, uint> dictionaryValueKeyValueValue = [];
+        Dictionary<string, uint> dictionaryRefKeyValueValue = [];
+        Dictionary<string, string> dictionaryRefKeyRefValue = [];
+
+        Assert.IsTrue(Unsafe.IsNullRef(ref CollectionsMarshal.GetValueRefOrNullRef(dictionaryValueKeyRefValue, 1U)));
+        Assert.IsTrue(Unsafe.IsNullRef(ref CollectionsMarshal.GetValueRefOrNullRef(dictionaryValueKeyValueValue, 1U)));
+        Assert.IsTrue(Unsafe.IsNullRef(ref CollectionsMarshal.GetValueRefOrNullRef(dictionaryRefKeyValueValue, "no such key")));
+        Assert.IsTrue(Unsafe.IsNullRef(ref CollectionsMarshal.GetValueRefOrNullRef(dictionaryRefKeyRefValue, "no such key")));
+    }
+
+    [TestMethod]
+    public void DictionaryMarshalGetValueRefOrAddDefaultIsDefault()
+    {
+        Dictionary<uint, string> dictionaryValueKeyRefValue = [];
+        Dictionary<uint, uint> dictionaryValueKeyValueValue = [];
+        Dictionary<string, uint> dictionaryRefKeyValueValue = [];
+        Dictionary<string, string> dictionaryRefKeyRefValue = [];
+
+        Assert.IsTrue(CollectionsMarshal.GetValueRefOrAddDefault(dictionaryValueKeyRefValue, 1U, out _) == default);
+        Assert.IsTrue(CollectionsMarshal.GetValueRefOrAddDefault(dictionaryValueKeyValueValue, 1U, out _) == default);
+        Assert.IsTrue(CollectionsMarshal.GetValueRefOrAddDefault(dictionaryRefKeyValueValue, "no such key", out _) == default);
+        Assert.IsTrue(CollectionsMarshal.GetValueRefOrAddDefault(dictionaryRefKeyRefValue, "no such key", out _) == default);
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/BaseClassLibrary/JsonSerializeTest.cs

@@ -1,16 +1,13 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
 namespace Snap.Hutao.Test.BaseClassLibrary;
 
 [TestClass]
-public class JsonSerializeTest
+public sealed class JsonSerializeTest
 {
-    private TestContext? testContext;
-
-    public TestContext? TestContext { get => testContext; set => testContext = value; }
-
     private readonly JsonSerializerOptions AlowStringNumberOptions = new()
     {
         NumberHandling = JsonNumberHandling.AllowReadingFromString,
@@ -38,7 +35,7 @@ public class JsonSerializeTest
     [TestMethod]
     public void DelegatePropertyCanSerialize()
     {
-        Sample sample = JsonSerializer.Deserialize<Sample>(SmapleObjectJson)!;
+        SampleDelegatePropertyClass sample = JsonSerializer.Deserialize<SampleDelegatePropertyClass>(SmapleObjectJson)!;
         Assert.AreEqual(sample.B, 1);
     }
 
@@ -46,7 +43,7 @@ public class JsonSerializeTest
     [ExpectedException(typeof(JsonException))]
     public void EmptyStringCannotSerializeAsNumber()
     {
-        StringNumberSample sample = JsonSerializer.Deserialize<StringNumberSample>(SmapleEmptyStringObjectJson)!;
+        SampleStringReadWriteNumberPropertyClass sample = JsonSerializer.Deserialize<SampleStringReadWriteNumberPropertyClass>(SmapleEmptyStringObjectJson)!;
         Assert.AreEqual(sample.A, 0);
     }
 
@@ -60,38 +57,61 @@ public class JsonSerializeTest
     [TestMethod]
     public void ByteArraySerializeAsBase64()
     {
-        byte[] array =
-#if NET8_0_OR_GREATER
-            [1, 2, 3, 4, 5];
-#else
-            { 1, 2, 3, 4, 5 };
-#endif
-        ByteArraySample sample = new()
+        SampleByteArrayPropertyClass sample = new()
         {
-            Array = array,
+            Array = [1, 2, 3, 4, 5],
         };
 
         string result = JsonSerializer.Serialize(sample);
-        TestContext!.WriteLine($"ByteArray Serialize Result: {result}");
-        Assert.AreEqual(result, """
-            {"Array":"AQIDBAU="}
-            """);
+        Assert.AreEqual(result, """{"Array":"AQIDBAU="}""");
     }
 
-    private sealed class Sample
+    [TestMethod]
+    public void InterfaceDefaultMethodCanSerializeActualInstanceMember()
+    {
+        ISampleInterface sample = new SampleClassImplementedInterface()
+        {
+            A = 1,
+            B = 2,
+        };
+
+        string result = sample.ToJson();
+        Console.WriteLine(result);
+        Assert.AreEqual(result, """{"A":1,"B":2}""");
+    }
+
+    private sealed class SampleDelegatePropertyClass
     {
         public int A { get => B; set => B = value; }
         public int B { get; set; }
     }
 
-    private sealed class StringNumberSample
+    private sealed class SampleStringReadWriteNumberPropertyClass
     {
         [JsonNumberHandling(JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString)]
         public int A { get; set; }
     }
 
-    private sealed class ByteArraySample
+    private sealed class SampleByteArrayPropertyClass
     {
         public byte[]? Array { get; set; }
     }
+
+    private sealed class SampleClassImplementedInterface : ISampleInterface
+    {
+        public int A { get; set; }
+
+        public int B { get; set; }
+    }
+
+    [JsonDerivedType(typeof(SampleClassImplementedInterface))]
+    private interface ISampleInterface
+    {
+        int A { get; set; }
+
+        string ToJson()
+        {
+            return JsonSerializer.Serialize(this);
+        }
+    }
 }

src/Snap.Hutao/Snap.Hutao.Test/BaseClassLibrary/LinqTest.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Snap.Hutao.Test.BaseClassLibrary;
+
+[TestClass]
+public sealed class LinqTest
+{
+    [TestMethod]
+    [ExpectedException(typeof(InvalidOperationException))]
+    public void LinqOrderByWithWrapperStructThrow()
+    {
+        List<MyUInt32> list = [1, 5, 2, 6, 3, 7, 4, 8];
+        string result = string.Join(", ", list.OrderBy(i => i).Select(i => i.Value));
+        Console.WriteLine(result);
+    }
+
+    private readonly struct MyUInt32
+    {
+        public readonly uint Value;
+
+        public MyUInt32(uint value)
+        {
+            Value = value;
+        }
+
+        public static implicit operator MyUInt32(uint value)
+        {
+            return new(value);
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/BaseClassLibrary/TypeReflectionTest.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace Snap.Hutao.Test.BaseClassLibrary;
+
+[TestClass]
+public sealed class TypeReflectionTest
+{
+    [TestMethod]
+    public void TypeCodeOfEnumIsUserlyingTypeTypeCode()
+    {
+        Assert.AreEqual(Type.GetTypeCode(typeof(TestEnum)), TypeCode.Int32);
+    }
+
+    private enum TestEnum
+    {
+        A,
+        B,
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/IncomingFeature/GameRegistryContentTest.cs

@@ -0,0 +1,67 @@
+using Microsoft.Win32;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Text;
+using System.Text.Json;
+
+namespace Snap.Hutao.Test.IncomingFeature;
+
+[TestClass]
+public class GameRegistryContentTest
+{
+    private static readonly JsonSerializerOptions RegistryContentSerializerOptions = new()
+    {
+        WriteIndented = true,
+        Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+    };
+
+    [TestMethod]
+    [SupportedOSPlatform("windows")]
+    public void GetRegistryContent()
+    {
+        GetRegistryContentCore(@"Software\miHoYo\原神");
+        GetRegistryContentCore(@"Software\miHoYo\Genshin Impact");
+    }
+
+    [SupportedOSPlatform("windows")]
+    private static void GetRegistryContentCore(string subkey)
+    {
+        using (RegistryKey key = RegistryKey.OpenBaseKey(RegistryHive.CurrentUser, RegistryView.Registry64))
+        {
+            RegistryKey? gameKey = key.OpenSubKey(subkey);
+            Assert.IsNotNull(gameKey);
+
+            Dictionary<string, object> data = [];
+            foreach (string valueName in gameKey.GetValueNames())
+            {
+                data[valueName] = gameKey.GetValueKind(valueName) switch
+                {
+                    RegistryValueKind.DWord => (int)gameKey.GetValue(valueName)!,
+                    RegistryValueKind.Binary => GetStringOrObject((byte[])gameKey.GetValue(valueName)!),
+                    _ => throw new NotImplementedException()
+                };
+            }
+
+            Console.WriteLine($"Subkey: {subkey}");
+            Console.WriteLine(JsonSerializer.Serialize(data, RegistryContentSerializerOptions));
+        }
+    }
+
+    private static unsafe object GetStringOrObject(byte[] bytes)
+    {
+        fixed (byte* pByte = bytes)
+        {
+            ReadOnlySpan<byte> span = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pByte);
+            string temp = Encoding.UTF8.GetString(span);
+
+            if (temp.AsSpan()[0] is '{' or '[')
+            {
+                return JsonSerializer.Deserialize<JsonElement>(temp);
+            }
+
+            return temp;
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/IncomingFeature/GeniusInvokationDecoding.cs

@@ -0,0 +1,209 @@
+using System;
+using System.Buffers.Binary;
+using System.Globalization;
+using System.Text;
+
+namespace Snap.Hutao.Test.IncomingFeature;
+
+[TestClass]
+public sealed class GeniusInvokationDecoding
+{
+    public TestContext? TestContext { get; set; }
+
+    /// <summary>
+    /// https://www.bilibili.com/video/av278125720
+    /// </summary>
+    [TestMethod]
+    public unsafe void GeniusInvokationShareCodeDecoding()
+    {
+        // 51 bytes obfuscated data
+        byte[] bytes = Convert.FromBase64String("BCHBwxQNAYERyVANCJGBynkOCZER2pgOCrFx8poQChGR9bYQDEGB9rkQDFKRD7oRDeEB");
+
+        // ---------------------------------------------
+        // |   Data   | Caesar Cipher Key |
+        // |----------|-------------------|
+        // | 50 Bytes |       1 Byte      |
+        // ---------------------------------------------
+        // Data:
+        // 00000100 00100001 11000001 11000011 00010100
+        // 00001101 00000001 10000001 00010001 11001001
+        // 01010000 00001101 00001000 10010001 10000001
+        // 11001010 01111001 00001110 00001001 10010001
+        // 00010001 11011010 10011000 00001110 00001010
+        // 10110001 01110001 11110010 10011010 00010000
+        // 00001010 00010001 10010001 11110101 10110110
+        // 00010000 00001100 01000001 10000001 11110110
+        // 10111001 00010000 00001100 01010010 10010001
+        // 00001111 10111010 00010001 00001101 11100001
+        // ---------------------------------------------
+        // Caesar Cipher Key:
+        // 00000001
+        // ---------------------------------------------
+        fixed (byte* ptr = bytes)
+        {
+            // Reinterpret as 50 byte actual data and 1 deobfuscate key byte
+            EncryptedDataAndKey* data = (EncryptedDataAndKey*)ptr;
+            byte* dataPtr = data->Data;
+
+            // ----------------------------------------------------------
+            // |   First   |  Second  | Padding |
+            // |-----------|----------|---------|
+            // |  25 Bytes | 25 Bytes |  1 Byte |
+            // ----------------------------------------------------------
+            // We are doing two things here:
+            // 1. Retrieve actual data by subtracting key
+            // 2. Store data into two halves by alternating between them
+            // ----------------------------------------------------------
+            // What we will get after this step:
+            // ----------------------------------------------------------
+            // First:
+            // 00000011 11000000 00010011 00000000 00010000
+            // 01001111 00000111 10000000 01111000 00001000
+            // 00010000 10010111 00001001 01110000 10011001
+            // 00001001 10010000 10110101 00001011 10000000
+            // 10111000 00001011 10010000 10111001 00001100
+            // ----------------------------------------------------------
+            // Second:
+            // 00100000 11000010 00001100 10000000 11001000
+            // 00001100 10010000 11001001 00001101 10010000
+            // 11011001 00001101 10110000 11110001 00001111
+            // 00010000 11110100 00001111 01000000 11110101
+            // 00001111 01010001 00001110 00010000 11100000
+            // ----------------------------------------------------------
+            RearrangeBuffer rearranged = default;
+            byte* pFirst = rearranged.First;
+            byte* pSecond = rearranged.Second;
+            for (int i = 0; i < 50; i++)
+            {
+                // Determine which half are we going to insert
+                byte** ppTarget = i % 2 == 0 ? &pFirst : &pSecond;
+
+                // (actual data = data - key) and store it directly to the target half
+                **ppTarget = unchecked((byte)(dataPtr[i] - data->Key));
+
+                (*ppTarget)++;
+            }
+
+            // Prepare decoded data result storage
+            DecryptedData decoded = default;
+            ushort* pDecoded = decoded.Data;
+
+            // ----------------------------------------------------------
+            // |   Data   |
+            // |----------| x 17 = 51 Bytes
+            // |  3 Bytes |
+            // ----------------------------------------------------------
+            // Grouping each 3 bytes and read out as 2 ushort with
+            // 12 bits each (Big Endian)
+            // ----------------------------------------------------------
+            // 00000011 1100·0000 00010011|                                    
+            // 00000000 0001·0000 01001111|              
+            // 00000111 1000·0000 01111000|              
+            // 00001000 0001·0000 10010111|              
+            // 00001001 0111·0000 10011001|              
+            // 00001001 1001·0000 10110101|              
+            // 00001011 1000·0000 10111000|              
+            // 00001011 1001·0000 10111001|              
+            // 00001100 0010·0000 11000010|
+            // 00001100 1000·0000 11001000|              
+            // 00001100 1001·0000 11001001|              
+            // 00001101 1001·0000 11011001|              
+            // 00001101 1011·0000 11110001|              
+            // 00001111 0001·0000 11110100|              
+            // 00001111 0100·0000 11110101|              
+            // 00001111 0101·0001 00001110|              
+            // 00010000 1110·0000 -padding|[padding32]   
+            // ----------------------------------------------------------
+            // reinterpret as DecodeGroupingHelper for each 3 bytes
+            DecodeGroupingHelper* pGroup = (DecodeGroupingHelper*)&rearranged;
+            for (int i = 0; i < 17; i++)
+            {
+                (ushort first, ushort second) = pGroup->GetData();
+
+                *pDecoded = first;
+                *(pDecoded + 1) = second;
+
+                pDecoded += 2;
+                pGroup++;
+            }
+
+            // Now we get
+            //  60, 19,  1,
+            //  79,120,120,
+            // 129,151,151,
+            // 153,153,181,
+            // 184,184,185,
+            // 185,194,194,
+            // 200,200,201,
+            // 201,217,217,
+            // 219,241,241,
+            // 244,244,245,
+            // 245,270,270,
+            StringBuilder stringBuilder = new();
+            for (int i = 0; i < 33; i++)
+            {
+                stringBuilder
+                    .AppendFormat(CultureInfo.InvariantCulture, "{0,3}", decoded.Data[i])
+                    .Append(',');
+
+                if (i % 11 == 10)
+                {
+                    stringBuilder.Append('\n');
+                }
+            }
+
+            TestContext?.WriteLine(stringBuilder.ToString(0, stringBuilder.Length - 1));
+
+            ushort[] resultArray = new ushort[33];
+            Span<ushort> result = new((ushort*)&decoded, 33);
+            result.CopyTo(resultArray);
+
+            ushort[] testKnownResult =
+            [
+                060, 019, 001, 079, 120, 120, 129, 151, 151, 153, 153,
+                181, 184, 184, 185, 185, 194, 194, 200, 200, 201, 201,
+                217, 217, 219, 241, 241, 244, 244, 245, 245, 270, 270,
+            ];
+
+            CollectionAssert.AreEqual(resultArray, testKnownResult);
+        }
+    }
+
+    private struct EncryptedDataAndKey
+    {
+        public unsafe fixed byte Data[50];
+        public byte Key;
+    }
+
+    private struct RearrangeBuffer
+    {
+        public unsafe fixed byte First[25];
+        public unsafe fixed byte Second[25];
+
+        // Make it 51 bytes
+        // allow to be group as 17 DecodeGroupingHelper later
+        public byte padding;
+
+        // prevent accidently int32 cast access violation
+        public byte paddingTo32;
+    }
+
+    private struct DecodeGroupingHelper
+    {
+        public unsafe fixed byte Data[3];
+
+        public unsafe (ushort First, ushort Second) GetData()
+        {
+            fixed (byte* ptr = Data)
+            {
+                uint value = BinaryPrimitives.ReverseEndianness((*(uint*)ptr) & 0x00FFFFFF) >> 8; // keep low 24 bits only
+                return ((ushort)((value >> 12) & 0x0FFF), (ushort)(value & 0x0FFF));
+            }
+        }
+    }
+
+    private struct DecryptedData
+    {
+        public unsafe fixed ushort Data[33];
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/IncomingFeature/SpiralAbyssScheduleIdTest.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace Snap.Hutao.Test.IncomingFeature;
+
+[TestClass]
+public class SpiralAbyssScheduleIdTest
+{
+    private static readonly TimeSpan Utc8 = new(8, 0, 0);
+
+    [TestMethod]
+    public void Test()
+    {
+        Console.WriteLine($"当前第 {GetForDateTimeOffset(DateTimeOffset.Now)} 期");
+
+        DateTimeOffset dateTimeOffset = new(2020, 7, 1, 4, 0, 0, Utc8);
+        Console.WriteLine($"2020-07-01 04:00:00 为第 {GetForDateTimeOffset(dateTimeOffset)} 期");
+    }
+
+    public static int GetForDateTimeOffset(DateTimeOffset dateTimeOffset)
+    {
+        // Force time in UTC+08
+        dateTimeOffset = dateTimeOffset.ToOffset(Utc8);
+
+        ((int year, int mouth, int day), (int hour, _), _) = dateTimeOffset;
+
+        // 2020-07-01 04:00:00 为第 1 期
+        int periodNum = (((year - 2020) * 12) + (mouth - 6)) * 2;
+
+        // 上半月：1-15 日, 以及 16 日 00:00-04:00
+        if (day < 16 || (day == 16 && hour < 4))
+        {
+            periodNum--;
+        }
+
+        // 上个月：1 日 00:00-04:00
+        if (day is 1 && hour < 4)
+        {
+            periodNum--;
+        }
+
+        return periodNum;
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/RuntimeBehavior/UnsafeRuntimeBehaviorTest.cs

@@ -1,10 +1,14 @@
-namespace Snap.Hutao.Test.RuntimeBehavior;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace Snap.Hutao.Test.RuntimeBehavior;
 
 [TestClass]
 public sealed class UnsafeRuntimeBehaviorTest
 {
     [TestMethod]
-    public unsafe void UInt32AllSetIs()
+    public unsafe void UInt32AllSetIsUInt32MaxValue()
     {
         byte[] bytes =
 #if NET8_0_OR_GREATER
@@ -18,23 +22,50 @@ public sealed class UnsafeRuntimeBehaviorTest
             Assert.AreEqual(uint.MaxValue, *(uint*)pBytes);
         }
     }
-}
 
-[TestClass]
-public sealed class NewModifierRuntimeBehaviorTest
-{
-    private interface IBase
+    [TestMethod]
+    public unsafe void UInt32LayoutIsLittleEndian()
     {
-        int GetValue();
+        ulong testValue = 0x1234567887654321;
+        ref BuildVersion version = ref Unsafe.As<ulong, BuildVersion>(ref testValue);
+
+        Assert.AreEqual(0x1234, version.Major);
+        Assert.AreEqual(0x5678, version.Minor);
+        Assert.AreEqual(0x8765, version.Patch);
+        Assert.AreEqual(0x4321, version.Build);
     }
 
-    private interface IBaseImpl : IBase
+    [TestMethod]
+    public unsafe void ReadOnlyStructCanBeModifiedInCtor()
     {
-        new int GetValue();
+        TestStruct testStruct = new([4444, 7878, 5656, 1212]);
+
+        Assert.AreEqual(4444, testStruct.Value1);
+        Assert.AreEqual(7878, testStruct.Value2);
+        Assert.AreEqual(5656, testStruct.Value3);
+        Assert.AreEqual(1212, testStruct.Value4);
     }
 
-    private sealed class Impl : IBaseImpl
+
+
+    private readonly struct TestStruct
     {
-        public int GetValue() => 1;
+        public readonly int Value1;
+        public readonly int Value2;
+        public readonly int Value3;
+        public readonly int Value4;
+
+        public TestStruct(List<int> list)
+        {
+            CollectionsMarshal.AsSpan(list).CopyTo(MemoryMarshal.CreateSpan(ref Unsafe.As<TestStruct, int>(ref this), 4));
+        }
+    }
+
+    private readonly struct BuildVersion
+    {
+        public readonly ushort Build;
+        public readonly ushort Patch;
+        public readonly ushort Minor;
+        public readonly ushort Major;
     }
 }

src/Snap.Hutao/Snap.Hutao.Test/Snap.Hutao.Test.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net7.0;net8.0</TargetFrameworks>
+    <TargetFrameworks>net8.0</TargetFrameworks>
     <ImplicitUsings>disable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <IsPackable>false</IsPackable>

src/Snap.Hutao/Snap.Hutao.Win32/NativeMethods.txt

@@ -10,15 +10,21 @@ DwmSetWindowAttribute
 GetDeviceCaps
 
 // KERNEL32
+AllocConsole
 CloseHandle
 CreateEventW
 CreateRemoteThread
+FreeConsole
+GetConsoleMode
 GetModuleHandleW
 GetProcAddress
+GetStdHandle
 K32EnumProcessModules
 K32GetModuleBaseNameW
 K32GetModuleInformation
 ReadProcessMemory
+SetConsoleMode
+SetConsoleTitle
 SetEvent
 VirtualAlloc
 VirtualAllocEx
@@ -55,6 +61,7 @@ FileSaveDialog
 IFileOpenDialog
 IFileSaveDialog
 IPersistFile
+IShellLinkDataList
 IShellLinkW
 ShellLink
 SHELL_LINK_DATA_FLAGS
@@ -63,7 +70,9 @@ SHELL_LINK_DATA_FLAGS
 IMemoryBufferByteAccess
 
 // Const value
+E_FAIL
 INFINITE
+RPC_E_WRONG_THREAD
 MAX_PATH
 WM_GETMINMAXINFO
 WM_HOTKEY

src/Snap.Hutao/Snap.Hutao.Win32/Snap.Hutao.Win32.csproj

@@ -16,7 +16,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Windows.CsWin32" Version="0.3.46-beta">
+    <PackageReference Include="Microsoft.Windows.CsWin32" Version="0.3.49-beta">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

src/Snap.Hutao/Snap.Hutao.sln

@@ -8,10 +8,9 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{9A95A964-04B1-477A-BDE7-505525B3CAD8}"
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
+		.vsconfig = .vsconfig
 	EndProjectSection
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Snap.Hutao.SourceGeneration", "Snap.Hutao.SourceGeneration\Snap.Hutao.SourceGeneration.csproj", "{8B96721E-5604-47D2-9B72-06FEBAD0CE00}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Snap.Hutao.Test", "Snap.Hutao.Test\Snap.Hutao.Test.csproj", "{D691BA9F-904C-4229-87A5-E14F2EFF2F64}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Snap.Hutao.Win32", "Snap.Hutao.Win32\Snap.Hutao.Win32.csproj", "{0F7ABEB2-5107-4037-B9DC-84D288FB0801}"
@@ -52,22 +51,6 @@ Global
 		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Release|x86.ActiveCfg = Release|x86
 		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Release|x86.Build.0 = Release|x86
 		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Release|x86.Deploy.0 = Release|x86
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|Any CPU.ActiveCfg = Debug|x64
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|Any CPU.Build.0 = Debug|x64
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|arm64.Build.0 = Debug|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|x64.ActiveCfg = Debug|x64
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|x64.Build.0 = Debug|x64
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|x86.Build.0 = Debug|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Release|Any CPU.Build.0 = Release|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Release|arm64.ActiveCfg = Release|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Release|arm64.Build.0 = Release|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Release|x64.ActiveCfg = Release|x64
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Release|x64.Build.0 = Release|x64
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Release|x86.ActiveCfg = Release|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Release|x86.Build.0 = Release|Any CPU
 		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug|arm64.ActiveCfg = Debug|Any CPU

src/Snap.Hutao/Snap.Hutao/.filenesting.json

@@ -4,12 +4,18 @@
     "add": {
       "extensionToExtension": {
         "add": {
-          ".json": [ ".txt" ]
+          ".json": [
+            ".txt"
+          ]
         }
       },
       "pathSegment": {
         "add": {
-          ".*": [ ".cs", ".resx" ]
+          ".*": [
+            ".cs",
+            ".resx",
+            ".appxmanifest"
+          ]
         }
       },
       "fileSuffixToExtension": {
@@ -19,12 +25,24 @@
       },
       "fileToFile": {
         "add": {
-          ".filenesting.json": [ "App.xaml.cs" ],
-          "app.manifest": [ "App.xaml.cs" ],
-          "Package.appxmanifest": [ "App.xaml" ],
-          "Package.StoreAssociation.xml": [ "App.xaml" ],
-          ".editorconfig": [ "Program.cs" ],
-          "GlobalUsing.cs": [ "Program.cs" ]
+          ".filenesting.json": [
+            "App.xaml.cs"
+          ],
+          "app.manifest": [
+            "App.xaml.cs"
+          ],
+          "Package.appxmanifest": [
+            "App.xaml"
+          ],
+          "Package.StoreAssociation.xml": [
+            "App.xaml"
+          ],
+          ".editorconfig": [
+            "Program.cs"
+          ],
+          "GlobalUsing.cs": [
+            "Program.cs"
+          ]
         }
       }
     }

src/Snap.Hutao/Snap.Hutao/App.xaml

@@ -10,6 +10,7 @@
                 <ResourceDictionary Source="ms-appx:///Control/Image/CachedImage.xaml"/>
                 <ResourceDictionary Source="ms-appx:///Control/Theme/Card.xaml"/>
                 <ResourceDictionary Source="ms-appx:///Control/Theme/Color.xaml"/>
+                <ResourceDictionary Source="ms-appx:///Control/Theme/ComboBox.xaml"/>
                 <ResourceDictionary Source="ms-appx:///Control/Theme/Converter.xaml"/>
                 <ResourceDictionary Source="ms-appx:///Control/Theme/CornerRadius.xaml"/>
                 <ResourceDictionary Source="ms-appx:///Control/Theme/FlyoutStyle.xaml"/>

src/Snap.Hutao/Snap.Hutao/App.xaml.cs

@@ -20,7 +20,24 @@ namespace Snap.Hutao;
 [SuppressMessage("", "SH001")]
 public sealed partial class App : Application
 {
+    private const string ConsoleBanner = """
+        ----------------------------------------------------------------
+          _____                         _    _         _                
+         / ____|                       | |  | |       | |               
+        | (___   _ __    __ _  _ __    | |__| | _   _ | |_  __ _   ___  
+         \___ \ | '_ \  / _` || '_ \   |  __  || | | || __|/ _` | / _ \ 
+         ____) || | | || (_| || |_) |_ | |  | || |_| || |_| (_| || (_) |
+        |_____/ |_| |_| \__,_|| .__/(_)|_|  |_| \__,_| \__|\__,_| \___/ 
+                              | |                                       
+                              |_| 
+                              
+        Snap.Hutao is a open source software developed by DGP Studio.
+        Copyright (C) 2022 - 2024 DGP Studio, All Rights Reserved.
+        ----------------------------------------------------------------
+        """;
+
     private const string AppInstanceKey = "main";
+
     private readonly IServiceProvider serviceProvider;
     private readonly IActivation activation;
     private readonly ILogger<App> logger;
@@ -51,11 +68,13 @@ public sealed partial class App : Application
 
             if (firstInstance.IsCurrent)
             {
+                logger.LogInformation(ConsoleBanner);
+                LogDiagnosticInformation();
+
                 // manually invoke
                 activation.NonRedirectToActivate(firstInstance, activatedEventArgs);
                 activation.InitializeWith(firstInstance);
 
-                LogDiagnosticInformation();
                 serviceProvider.GetRequiredService<IJumpListInterop>().ConfigureAsync().SafeForget();
             }
             else

src/Snap.Hutao/Snap.Hutao/Control/BoxedValues.cs

@@ -1,21 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Control;
-
-/// <summary>
-/// 封装的值
-/// </summary>
-[HighQuality]
-internal static class BoxedValues
-{
-    /// <summary>
-    /// <see cref="true"/>
-    /// </summary>
-    public static readonly object True = true;
-
-    /// <summary>
-    /// <see cref="false"/>
-    /// </summary>
-    public static readonly object False = false;
-}

src/Snap.Hutao/Snap.Hutao/Control/DependencyValueConverter.cs

@@ -16,22 +16,7 @@ internal abstract class DependencyValueConverter<TFrom, TTo> : DependencyObject,
     /// <inheritdoc/>
     public object? Convert(object value, Type targetType, object parameter, string language)
     {
-#if DEBUG
-        try
-        {
-            return Convert((TFrom)value);
-        }
-        catch (Exception ex)
-        {
-            Ioc.Default
-                .GetRequiredService<ILogger<ValueConverter<TFrom, TTo>>>()
-                .LogError(ex, "值转换器异常");
-        }
-
-        return null;
-#else
         return Convert((TFrom)value);
-#endif
     }
 
     /// <inheritdoc/>

src/Snap.Hutao/Snap.Hutao/Control/Extension/ContentDialogHideToken.cs

@@ -24,7 +24,7 @@ internal struct ContentDialogHideToken : IDisposable, IAsyncDisposable
         if (!disposed && !disposing)
         {
             disposing = true;
-            taskContext.InvokeOnMainThread(contentDialog.Hide); // Hide() must be called on main thread.
+            taskContext.InvokeOnMainThread(contentDialog.Hide);
             disposing = false;
             disposed = true;
         }

src/Snap.Hutao/Snap.Hutao/Control/IScopedPageScopeReferenceTracker.cs

@@ -3,7 +3,7 @@
 
 namespace Snap.Hutao.Control;
 
-internal interface IScopedPageScopeReferenceTracker
+internal interface IScopedPageScopeReferenceTracker : IDisposable
 {
     IServiceScope CreateScope();
 }

src/Snap.Hutao/Snap.Hutao/Control/Image/CachedImage.cs

@@ -20,7 +20,7 @@ internal sealed class CachedImage : Implementation.ImageEx
     public CachedImage()
     {
         IsCacheEnabled = true;
-        EnableLazyLoading = true;
+        EnableLazyLoading = false;
     }
 
     /// <inheritdoc/>
@@ -40,12 +40,7 @@ internal sealed class CachedImage : Implementation.ImageEx
         {
             // The image is corrupted, remove it.
             imageCache.Remove(imageUri);
-            return null;
-        }
-        catch (OperationCanceledException)
-        {
-            // task was explicitly canceled
-            return null;
+            return default;
         }
     }
 }

src/Snap.Hutao/Snap.Hutao/Control/Image/CachedImage.xaml

@@ -17,9 +17,9 @@
                         CornerRadius="{TemplateBinding CornerRadius}">
                         <Image
                             Name="PlaceholderImage"
+                            Margin="{TemplateBinding PlaceholderMargin}"
                             HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
                             VerticalAlignment="{TemplateBinding VerticalAlignment}"
-                            Opacity="1.0"
                             Source="{TemplateBinding PlaceholderSource}"
                             Stretch="{TemplateBinding PlaceholderStretch}"/>
                         <Image
@@ -27,7 +27,6 @@
                             HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
                             VerticalAlignment="{TemplateBinding VerticalAlignment}"
                             NineGrid="{TemplateBinding NineGrid}"
-                            Opacity="0.0"
                             Stretch="{TemplateBinding Stretch}"/>
                         <VisualStateManager.VisualStateGroups>
                             <VisualStateGroup x:Name="CommonStates">

src/Snap.Hutao/Snap.Hutao/Control/Image/CompositionImage.cs

@@ -30,7 +30,6 @@ internal abstract partial class CompositionImage : Microsoft.UI.Xaml.Controls.Co
 
     private readonly IServiceProvider serviceProvider;
 
-    private readonly RoutedEventHandler unloadEventHandler;
     private readonly SizeChangedEventHandler sizeChangedEventHandler;
     private readonly TypedEventHandler<LoadedImageSurface, LoadedImageSourceLoadCompletedEventArgs> loadedImageSourceLoadCompletedEventHandler;
 
@@ -46,9 +45,6 @@ internal abstract partial class CompositionImage : Microsoft.UI.Xaml.Controls.Co
         serviceProvider = this.ServiceProvider();
         this.DisableInteraction();
 
-        unloadEventHandler = OnUnload;
-        Unloaded += unloadEventHandler;
-
         sizeChangedEventHandler = OnSizeChanged;
         SizeChanged += sizeChangedEventHandler;
 
@@ -67,10 +63,6 @@ internal abstract partial class CompositionImage : Microsoft.UI.Xaml.Controls.Co
     {
     }
 
-    protected virtual void Unloading()
-    {
-    }
-
     /// <summary>
     /// 更新视觉对象
     /// </summary>
@@ -88,19 +80,22 @@ internal abstract partial class CompositionImage : Microsoft.UI.Xaml.Controls.Co
         ILogger<CompositionImage> logger = serviceProvider.GetRequiredService<ILogger<CompositionImage>>();
 
         // source is valid
-        if (arg.NewValue is Uri inner && !string.IsNullOrEmpty(inner.OriginalString))
+        if (arg.NewValue is Uri inner)
         {
-            // value is different from old one
-            if (inner != (arg.OldValue as Uri))
+            if (!string.IsNullOrEmpty(inner.OriginalString))
             {
-                image
-                    .ApplyImageAsync(inner, token)
-                    .SafeForget(logger, ex => OnApplyImageFailed(serviceProvider, inner, ex));
+                // value is different from old one
+                if (inner != (arg.OldValue as Uri))
+                {
+                    image
+                        .ApplyImageAsync(inner, token)
+                        .SafeForget(logger, ex => OnApplyImageFailed(serviceProvider, inner, ex));
+                }
+            }
+            else
+            {
+                image.HideAsync(token).SafeForget(logger);
             }
-        }
-        else
-        {
-            image.HideAsync(token).SafeForget(logger);
         }
     }
 
@@ -138,8 +133,9 @@ internal abstract partial class CompositionImage : Microsoft.UI.Xaml.Controls.Co
             {
                 imageSurface = await LoadImageSurfaceAsync(file, token).ConfigureAwait(true);
             }
-            catch (COMException)
+            catch (COMException ex)
             {
+                _ = ex;
                 imageCache.Remove(uri);
             }
             catch (IOException)
@@ -171,7 +167,7 @@ internal abstract partial class CompositionImage : Microsoft.UI.Xaml.Controls.Co
             surface.LoadCompleted += loadedImageSourceLoadCompletedEventHandler;
             if (surface.DecodedPhysicalSize.Size() <= 0D)
             {
-                await surfaceLoadTaskCompletionSource.Task.ConfigureAwait(true);
+                await Task.WhenAny(surfaceLoadTaskCompletionSource.Task, Task.Delay(5000, token)).ConfigureAwait(true);
             }
 
             LoadImageSurfaceCompleted(surface);
@@ -240,14 +236,4 @@ internal abstract partial class CompositionImage : Microsoft.UI.Xaml.Controls.Co
             UpdateVisual(spriteVisual);
         }
     }
-
-    private void OnUnload(object sender, RoutedEventArgs e)
-    {
-        Unloading();
-        spriteVisual?.Dispose();
-        spriteVisual = null;
-
-        SizeChanged -= sizeChangedEventHandler;
-        Unloaded -= unloadEventHandler;
-    }
 }

src/Snap.Hutao/Snap.Hutao/Control/Image/Implementation/ImageExBase.cs

@@ -11,10 +11,6 @@ using Windows.Foundation;
 
 namespace Snap.Hutao.Control.Image.Implementation;
 
-internal delegate void ImageExFailedEventHandler(object sender, ImageExFailedEventArgs e);
-
-internal delegate void ImageExOpenedEventHandler(object sender, ImageExOpenedEventArgs e);
-
 [SuppressMessage("", "CA1001")]
 [SuppressMessage("", "SH003")]
 [TemplateVisualState(Name = LoadingState, GroupName = CommonGroup)]
@@ -22,98 +18,34 @@ internal delegate void ImageExOpenedEventHandler(object sender, ImageExOpenedEve
 [TemplateVisualState(Name = UnloadedState, GroupName = CommonGroup)]
 [TemplateVisualState(Name = FailedState, GroupName = CommonGroup)]
 [TemplatePart(Name = PartImage, Type = typeof(object))]
-internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlphaMaskProvider
+[TemplatePart(Name = PartPlaceholderImage, Type = typeof(object))]
+[DependencyProperty("Stretch", typeof(Stretch), Stretch.Uniform)]
+[DependencyProperty("DecodePixelHeight", typeof(int), 0)]
+[DependencyProperty("DecodePixelWidth", typeof(int), 0)]
+[DependencyProperty("DecodePixelType", typeof(DecodePixelType), DecodePixelType.Physical)]
+[DependencyProperty("IsCacheEnabled", typeof(bool), false)]
+[DependencyProperty("EnableLazyLoading", typeof(bool), false, nameof(EnableLazyLoadingChanged))]
+[DependencyProperty("LazyLoadingThreshold", typeof(double), default(double), nameof(LazyLoadingThresholdChanged))]
+[DependencyProperty("PlaceholderSource", typeof(object), default(object))]
+[DependencyProperty("PlaceholderStretch", typeof(Stretch), Stretch.Uniform)]
+[DependencyProperty("PlaceholderMargin", typeof(Thickness))]
+[DependencyProperty("Source", typeof(object), default(object), nameof(SourceChanged))]
+internal abstract partial class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlphaMaskProvider
 {
     protected const string PartImage = "Image";
+    protected const string PartPlaceholderImage = "PlaceholderImage";
     protected const string CommonGroup = "CommonStates";
     protected const string LoadingState = "Loading";
     protected const string LoadedState = "Loaded";
     protected const string UnloadedState = "Unloaded";
     protected const string FailedState = "Failed";
 
-    private static readonly DependencyProperty StretchProperty = DependencyProperty.Register(nameof(Stretch), typeof(Stretch), typeof(ImageExBase), new PropertyMetadata(Stretch.Uniform));
-    private static readonly DependencyProperty DecodePixelHeightProperty = DependencyProperty.Register(nameof(DecodePixelHeight), typeof(int), typeof(ImageExBase), new PropertyMetadata(0));
-    private static readonly DependencyProperty DecodePixelTypeProperty = DependencyProperty.Register(nameof(DecodePixelType), typeof(int), typeof(ImageExBase), new PropertyMetadata(DecodePixelType.Physical));
-    private static readonly DependencyProperty DecodePixelWidthProperty = DependencyProperty.Register(nameof(DecodePixelWidth), typeof(int), typeof(ImageExBase), new PropertyMetadata(0));
-    private static readonly DependencyProperty IsCacheEnabledProperty = DependencyProperty.Register(nameof(IsCacheEnabled), typeof(bool), typeof(ImageExBase), new PropertyMetadata(false));
-    private static readonly DependencyProperty EnableLazyLoadingProperty = DependencyProperty.Register(nameof(EnableLazyLoading), typeof(bool), typeof(ImageExBase), new PropertyMetadata(false, EnableLazyLoadingChanged));
-    private static readonly DependencyProperty LazyLoadingThresholdProperty = DependencyProperty.Register(nameof(LazyLoadingThreshold), typeof(double), typeof(ImageExBase), new PropertyMetadata(default(double), LazyLoadingThresholdChanged));
-    private static readonly DependencyProperty PlaceholderSourceProperty = DependencyProperty.Register(nameof(PlaceholderSource), typeof(ImageSource), typeof(ImageExBase), new PropertyMetadata(default(ImageSource), PlaceholderSourceChanged));
-    private static readonly DependencyProperty PlaceholderStretchProperty = DependencyProperty.Register(nameof(PlaceholderStretch), typeof(Stretch), typeof(ImageExBase), new PropertyMetadata(default(Stretch)));
-    private static readonly DependencyProperty SourceProperty = DependencyProperty.Register(nameof(Source), typeof(object), typeof(ImageExBase), new PropertyMetadata(null, SourceChanged));
-
     private CancellationTokenSource? tokenSource;
     private object? lazyLoadingSource;
     private bool isInViewport;
 
-    public event ImageExFailedEventHandler? ImageExFailed;
-
-    public event ImageExOpenedEventHandler? ImageExOpened;
-
-    public event EventHandler? ImageExInitialized;
-
     public bool IsInitialized { get; private set; }
 
-    public int DecodePixelHeight
-    {
-        get => (int)GetValue(DecodePixelHeightProperty);
-        set => SetValue(DecodePixelHeightProperty, value);
-    }
-
-    public DecodePixelType DecodePixelType
-    {
-        get => (DecodePixelType)GetValue(DecodePixelTypeProperty);
-        set => SetValue(DecodePixelTypeProperty, value);
-    }
-
-    public int DecodePixelWidth
-    {
-        get => (int)GetValue(DecodePixelWidthProperty);
-        set => SetValue(DecodePixelWidthProperty, value);
-    }
-
-    public Stretch Stretch
-    {
-        get => (Stretch)GetValue(StretchProperty);
-        set => SetValue(StretchProperty, value);
-    }
-
-    public bool IsCacheEnabled
-    {
-        get => (bool)GetValue(IsCacheEnabledProperty);
-        set => SetValue(IsCacheEnabledProperty, value);
-    }
-
-    public bool EnableLazyLoading
-    {
-        get => (bool)GetValue(EnableLazyLoadingProperty);
-        set => SetValue(EnableLazyLoadingProperty, value);
-    }
-
-    public double LazyLoadingThreshold
-    {
-        get => (double)GetValue(LazyLoadingThresholdProperty);
-        set => SetValue(LazyLoadingThresholdProperty, value);
-    }
-
-    public ImageSource PlaceholderSource
-    {
-        get => (ImageSource)GetValue(PlaceholderSourceProperty);
-        set => SetValue(PlaceholderSourceProperty, value);
-    }
-
-    public Stretch PlaceholderStretch
-    {
-        get => (Stretch)GetValue(PlaceholderStretchProperty);
-        set => SetValue(PlaceholderStretchProperty, value);
-    }
-
-    public object Source
-    {
-        get => GetValue(SourceProperty);
-        set => SetValue(SourceProperty, value);
-    }
-
     public bool WaitUntilLoaded
     {
         get => true;
@@ -121,11 +53,9 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
 
     protected object? Image { get; private set; }
 
-    public abstract CompositionBrush GetAlphaMask();
+    protected object? PlaceholderImage { get; private set; }
 
-    protected virtual void OnPlaceholderSourceChanged(DependencyPropertyChangedEventArgs e)
-    {
-    }
+    public abstract CompositionBrush GetAlphaMask();
 
     protected virtual Task<ImageSource?> ProvideCachedResourceAsync(Uri imageUri, CancellationToken token)
     {
@@ -136,61 +66,11 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
     protected virtual void OnImageOpened(object sender, RoutedEventArgs e)
     {
         VisualStateManager.GoToState(this, LoadedState, true);
-        ImageExOpened?.Invoke(this, new ImageExOpenedEventArgs());
     }
 
     protected virtual void OnImageFailed(object sender, ExceptionRoutedEventArgs e)
     {
         VisualStateManager.GoToState(this, FailedState, true);
-        ImageExFailed?.Invoke(this, new ImageExFailedEventArgs(new FileNotFoundException(e.ErrorMessage)));
-    }
-
-    protected void AttachImageOpened(RoutedEventHandler handler)
-    {
-        if (Image is Microsoft.UI.Xaml.Controls.Image image)
-        {
-            image.ImageOpened += handler;
-        }
-        else if (Image is ImageBrush brush)
-        {
-            brush.ImageOpened += handler;
-        }
-    }
-
-    protected void RemoveImageOpened(RoutedEventHandler handler)
-    {
-        if (Image is Microsoft.UI.Xaml.Controls.Image image)
-        {
-            image.ImageOpened -= handler;
-        }
-        else if (Image is ImageBrush brush)
-        {
-            brush.ImageOpened -= handler;
-        }
-    }
-
-    protected void AttachImageFailed(ExceptionRoutedEventHandler handler)
-    {
-        if (Image is Microsoft.UI.Xaml.Controls.Image image)
-        {
-            image.ImageFailed += handler;
-        }
-        else if (Image is ImageBrush brush)
-        {
-            brush.ImageFailed += handler;
-        }
-    }
-
-    protected void RemoveImageFailed(ExceptionRoutedEventHandler handler)
-    {
-        if (Image is Microsoft.UI.Xaml.Controls.Image image)
-        {
-            image.ImageFailed -= handler;
-        }
-        else if (Image is ImageBrush brush)
-        {
-            brush.ImageFailed -= handler;
-        }
     }
 
     protected override void OnApplyTemplate()
@@ -199,11 +79,10 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
         RemoveImageFailed(OnImageFailed);
 
         Image = GetTemplateChild(PartImage);
+        PlaceholderImage = GetTemplateChild(PartPlaceholderImage);
 
         IsInitialized = true;
 
-        ImageExInitialized?.Invoke(this, EventArgs.Empty);
-
         if (Source is null || !EnableLazyLoading || isInViewport)
         {
             lazyLoadingSource = null;
@@ -218,23 +97,73 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
         AttachImageFailed(OnImageFailed);
 
         base.OnApplyTemplate();
+
+        void AttachImageOpened(RoutedEventHandler handler)
+        {
+            if (Image is Microsoft.UI.Xaml.Controls.Image image)
+            {
+                image.ImageOpened += handler;
+            }
+            else if (Image is ImageBrush brush)
+            {
+                brush.ImageOpened += handler;
+            }
+        }
+
+        void AttachImageFailed(ExceptionRoutedEventHandler handler)
+        {
+            if (Image is Microsoft.UI.Xaml.Controls.Image image)
+            {
+                image.ImageFailed += handler;
+            }
+            else if (Image is ImageBrush brush)
+            {
+                brush.ImageFailed += handler;
+            }
+        }
+
+        void RemoveImageOpened(RoutedEventHandler handler)
+        {
+            if (Image is Microsoft.UI.Xaml.Controls.Image image)
+            {
+                image.ImageOpened -= handler;
+            }
+            else if (Image is ImageBrush brush)
+            {
+                brush.ImageOpened -= handler;
+            }
+        }
+
+        void RemoveImageFailed(ExceptionRoutedEventHandler handler)
+        {
+            if (Image is Microsoft.UI.Xaml.Controls.Image image)
+            {
+                image.ImageFailed -= handler;
+            }
+            else if (Image is ImageBrush brush)
+            {
+                brush.ImageFailed -= handler;
+            }
+        }
     }
 
     private static void EnableLazyLoadingChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
     {
-        if (d is ImageExBase control)
+        if (d is not ImageExBase control)
         {
-            bool value = (bool)e.NewValue;
-            if (value)
-            {
-                control.LayoutUpdated += control.ImageExBase_LayoutUpdated;
+            return;
+        }
 
-                control.InvalidateLazyLoading();
-            }
-            else
-            {
-                control.LayoutUpdated -= control.ImageExBase_LayoutUpdated;
-            }
+        bool value = (bool)e.NewValue;
+        if (value)
+        {
+            control.LayoutUpdated += control.OnImageExBaseLayoutUpdated;
+
+            control.InvalidateLazyLoading();
+        }
+        else
+        {
+            control.LayoutUpdated -= control.OnImageExBaseLayoutUpdated;
         }
     }
 
@@ -246,14 +175,6 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
         }
     }
 
-    private static void PlaceholderSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        if (d is ImageExBase control)
-        {
-            control.OnPlaceholderSourceChanged(e);
-        }
-    }
-
     private static void SourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
     {
         if (d is not ImageExBase control)
@@ -261,17 +182,19 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
             return;
         }
 
-        if (e.OldValue is null || e.NewValue is null || !e.OldValue.Equals(e.NewValue))
+        if (e.OldValue is not null && e.NewValue is not null && e.OldValue.Equals(e.NewValue))
         {
-            if (e.NewValue is null || !control.EnableLazyLoading || control.isInViewport)
-            {
-                control.lazyLoadingSource = null;
-                control.SetSource(e.NewValue);
-            }
-            else
-            {
-                control.lazyLoadingSource = e.NewValue;
-            }
+            return;
+        }
+
+        if (e.NewValue is null || !control.EnableLazyLoading || control.isInViewport)
+        {
+            control.lazyLoadingSource = null;
+            control.SetSource(e.NewValue);
+        }
+        else
+        {
+            control.lazyLoadingSource = e.NewValue;
         }
     }
 
@@ -301,11 +224,24 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
         else if (source is BitmapSource { PixelHeight: > 0, PixelWidth: > 0 })
         {
             VisualStateManager.GoToState(this, LoadedState, true);
-            ImageExOpened?.Invoke(this, new ImageExOpenedEventArgs());
         }
     }
 
-    [SuppressMessage("", "IDE0019")]
+    private void AttachPlaceholderSource(ImageSource? source)
+    {
+        // Setting the source at this point should call ImageExOpened/VisualStateManager.GoToState
+        // as we register to both the ImageOpened/ImageFailed events of the underlying control.
+        // We only need to call those methods if we fail in other cases before we get here.
+        if (PlaceholderImage is Microsoft.UI.Xaml.Controls.Image image)
+        {
+            image.Source = source;
+        }
+        else if (PlaceholderImage is ImageBrush brush)
+        {
+            brush.ImageSource = source;
+        }
+    }
+
     private async void SetSource(object? source)
     {
         if (!IsInitialized)
@@ -326,22 +262,19 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
 
         VisualStateManager.GoToState(this, LoadingState, true);
 
-        ImageSource? imageSource = source as ImageSource;
-        if (imageSource is not null)
+        if (source as ImageSource is { } imageSource)
         {
             AttachSource(imageSource);
 
             return;
         }
 
-        Uri? uri = source as Uri;
-        if (uri is null)
+        if (source as Uri is not { } uri)
         {
             string? url = source as string ?? source.ToString();
             if (!Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out uri))
             {
                 VisualStateManager.GoToState(this, FailedState, true);
-                ImageExFailed?.Invoke(this, new ImageExFailedEventArgs(new UriFormatException("Invalid uri specified.")));
                 return;
             }
         }
@@ -355,61 +288,131 @@ internal abstract class ImageExBase : Microsoft.UI.Xaml.Controls.Control, IAlpha
         {
             await LoadImageAsync(uri, tokenSource.Token).ConfigureAwait(true);
         }
+        catch (Exception ex)
+        {
+            SetPlaceholderSource(PlaceholderSource);
+
+            if (ex is OperationCanceledException)
+            {
+                // nothing to do as cancellation has been requested.
+            }
+            else
+            {
+                VisualStateManager.GoToState(this, FailedState, true);
+            }
+        }
+    }
+
+    private async void SetPlaceholderSource(object? source)
+    {
+        if (!IsInitialized)
+        {
+            return;
+        }
+
+        tokenSource?.Cancel();
+
+        tokenSource = new CancellationTokenSource();
+
+        AttachPlaceholderSource(null);
+
+        if (source is null)
+        {
+            return;
+        }
+
+        if (source as ImageSource is { } imageSource)
+        {
+            AttachPlaceholderSource(imageSource);
+
+            return;
+        }
+
+        if (source as Uri is not { } uri)
+        {
+            string? url = source as string ?? source.ToString();
+            if (!Uri.TryCreate(url, UriKind.RelativeOrAbsolute, out uri))
+            {
+                return;
+            }
+        }
+
+        if (!IsHttpUri(uri) && !uri.IsAbsoluteUri)
+        {
+            uri = new Uri("ms-appx:///" + uri.OriginalString.TrimStart('/'));
+        }
+
+        try
+        {
+            if (uri is null)
+            {
+                return;
+            }
+
+            ImageSource? img = await ProvideCachedResourceAsync(uri, tokenSource.Token).ConfigureAwait(true);
+
+            ArgumentNullException.ThrowIfNull(tokenSource);
+            if (!tokenSource.IsCancellationRequested)
+            {
+                // Only attach our image if we still have a valid request.
+                AttachPlaceholderSource(img);
+            }
+        }
         catch (OperationCanceledException)
         {
             // nothing to do as cancellation has been requested.
         }
-        catch (Exception e)
+        catch
         {
-            VisualStateManager.GoToState(this, FailedState, true);
-            ImageExFailed?.Invoke(this, new ImageExFailedEventArgs(e));
         }
     }
 
     private async Task LoadImageAsync(Uri imageUri, CancellationToken token)
     {
-        if (imageUri is not null)
+        if (imageUri is null)
         {
-            if (IsCacheEnabled)
+            return;
+        }
+
+        if (IsCacheEnabled)
+        {
+            ImageSource? img = await ProvideCachedResourceAsync(imageUri, token).ConfigureAwait(true);
+
+            ArgumentNullException.ThrowIfNull(tokenSource);
+            if (!tokenSource.IsCancellationRequested)
             {
-                ImageSource? img = await ProvideCachedResourceAsync(imageUri, token).ConfigureAwait(true);
+                // Only attach our image if we still have a valid request.
+                AttachSource(img);
+            }
+        }
+        else if (string.Equals(imageUri.Scheme, "data", StringComparison.OrdinalIgnoreCase))
+        {
+            string source = imageUri.OriginalString;
+            const string base64Head = "base64,";
+            int index = source.IndexOf(base64Head, StringComparison.Ordinal);
+            if (index >= 0)
+            {
+                byte[] bytes = Convert.FromBase64String(source[(index + base64Head.Length)..]);
+                BitmapImage bitmap = new();
+                await bitmap.SetSourceAsync(new MemoryStream(bytes).AsRandomAccessStream());
 
                 ArgumentNullException.ThrowIfNull(tokenSource);
                 if (!tokenSource.IsCancellationRequested)
                 {
-                    // Only attach our image if we still have a valid request.
-                    AttachSource(img);
+                    AttachSource(bitmap);
                 }
             }
-            else if (string.Equals(imageUri.Scheme, "data", StringComparison.OrdinalIgnoreCase))
+        }
+        else
+        {
+            AttachSource(new BitmapImage(imageUri)
             {
-                string source = imageUri.OriginalString;
-                const string base64Head = "base64,";
-                int index = source.IndexOf(base64Head, StringComparison.Ordinal);
-                if (index >= 0)
-                {
-                    byte[] bytes = Convert.FromBase64String(source[(index + base64Head.Length)..]);
-                    BitmapImage bitmap = new();
-                    await bitmap.SetSourceAsync(new MemoryStream(bytes).AsRandomAccessStream());
-
-                    ArgumentNullException.ThrowIfNull(tokenSource);
-                    if (!tokenSource.IsCancellationRequested)
-                    {
-                        AttachSource(bitmap);
-                    }
-                }
-            }
-            else
-            {
-                AttachSource(new BitmapImage(imageUri)
-                {
-                    CreateOptions = BitmapCreateOptions.IgnoreImageCache,
-                });
-            }
+                CreateOptions = BitmapCreateOptions.IgnoreImageCache,
+            });
         }
     }
 
-    private void ImageExBase_LayoutUpdated(object? sender, object e)
+    private void OnImageExBaseLayoutUpdated(object? sender, object e)
     {
         InvalidateLazyLoading();
     }

src/Snap.Hutao/Snap.Hutao/Control/Image/Implementation/ImageExFailedEventArgs.cs

@@ -1,17 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Control.Image.Implementation;
-
-internal sealed class ImageExFailedEventArgs : EventArgs
-{
-    public ImageExFailedEventArgs(Exception errorException)
-    {
-        ErrorMessage = ErrorException?.Message;
-        ErrorException = errorException;
-    }
-
-    public Exception? ErrorException { get; private set; }
-
-    public string? ErrorMessage { get; private set; }
-}

src/Snap.Hutao/Snap.Hutao/Control/Image/Implementation/ImageExOpenedEventArgs.cs

@@ -1,8 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Control.Image.Implementation;
-
-internal sealed class ImageExOpenedEventArgs : EventArgs
-{
-}

src/Snap.Hutao/Snap.Hutao/Control/Image/MonoChrome.cs

@@ -45,16 +45,6 @@ internal sealed class MonoChrome : CompositionImage
         return compositor.CompositeSpriteVisual(alphaMaskEffectBrush);
     }
 
-    protected override void Unloading()
-    {
-        ActualThemeChanged -= actualThemeChangedEventHandler;
-
-        backgroundBrush?.Dispose();
-        backgroundBrush = null;
-
-        base.Unloading();
-    }
-
     private void OnActualThemeChanged(FrameworkElement sender, object args)
     {
         if (backgroundBrush is not null)

src/Snap.Hutao/Snap.Hutao/Control/Layout/UniformStaggeredLayout.cs

@@ -128,15 +128,8 @@ internal sealed partial class UniformStaggeredLayout : VirtualizingLayout
             UniformStaggeredItem item = state.GetItemAt(i);
             if (item.Height == 0)
             {
-                // https://github.com/DGP-Studio/Snap.Hutao/issues/1079
-                // The first element must be force refreshed otherwise
-                // it will use the old one realized
-                // https://github.com/DGP-Studio/Snap.Hutao/issues/1099
-                // Now we need to refresh the first element of each column
-                ElementRealizationOptions options = i < numberOfColumns ? ElementRealizationOptions.ForceCreate : ElementRealizationOptions.None;
-
                 // Item has not been measured yet. Get the element and store the values
-                UIElement element = context.GetOrCreateElementAt(i, options);
+                UIElement element = context.GetOrCreateElementAt(i);
                 element.Measure(new Size(state.ColumnWidth, availableHeight));
                 item.Height = element.DesiredSize.Height;
                 item.Element = element;
@@ -209,11 +202,8 @@ internal sealed partial class UniformStaggeredLayout : VirtualizingLayout
         for (int columnIndex = 0; columnIndex < state.NumberOfColumns; columnIndex++)
         {
             UniformStaggeredColumnLayout layout = state.GetColumnLayout(columnIndex);
-            Span<UniformStaggeredItem> layoutSpan = CollectionsMarshal.AsSpan(layout);
-            for (int i = 0; i < layoutSpan.Length; i++)
+            foreach (ref readonly UniformStaggeredItem item in CollectionsMarshal.AsSpan(layout))
             {
-                ref readonly UniformStaggeredItem item = ref layoutSpan[i];
-
                 double bottom = item.Top + item.Height;
                 if (bottom < context.RealizationRect.Top)
                 {

src/Snap.Hutao/Snap.Hutao/Control/Layout/UniformStaggeredLayoutState.cs

@@ -62,11 +62,9 @@ internal sealed class UniformStaggeredLayoutState
         }
     }
 
-    [SuppressMessage("", "SH007")]
     internal UniformStaggeredColumnLayout GetColumnLayout(int columnIndex)
     {
-        this.columnLayout.TryGetValue(columnIndex, out UniformStaggeredColumnLayout? columnLayout);
-        return columnLayout!;
+        return columnLayout[columnIndex];
     }
 
     /// <summary>
@@ -74,6 +72,21 @@ internal sealed class UniformStaggeredLayoutState
     /// </summary>
     internal void Clear()
     {
+        // https://github.com/DGP-Studio/Snap.Hutao/issues/1079
+        // The first element must be force refreshed otherwise
+        // it will use the old one realized
+        // https://github.com/DGP-Studio/Snap.Hutao/issues/1099
+        // Now we need to refresh the first element of each column
+        // https://github.com/DGP-Studio/Snap.Hutao/issues/1099
+        // Finally we need to refresh the whole layout when we reset
+        if (context.ItemCount > 0)
+        {
+            for (int i = 0; i < context.ItemCount; i++)
+            {
+                RecycleElementAt(i);
+            }
+        }
+
         columnLayout.Clear();
         items.Clear();
     }

src/Snap.Hutao/Snap.Hutao/Control/ScopedPage.cs

@@ -9,10 +9,6 @@ using Snap.Hutao.ViewModel.Abstraction;
 
 namespace Snap.Hutao.Control;
 
-/// <summary>
-/// 表示支持取消加载的异步页面
-/// 在被导航到其他页面前触发取消异步通知
-/// </summary>
 [HighQuality]
 [SuppressMessage("", "CA1001")]
 internal class ScopedPage : Page
@@ -21,9 +17,8 @@ internal class ScopedPage : Page
     private readonly CancellationTokenSource viewCancellationTokenSource = new();
     private readonly IServiceScope currentScope;
 
-    /// <summary>
-    /// 构造一个新的页面
-    /// </summary>
+    private bool inFrame = true;
+
     protected ScopedPage()
     {
         unloadEventHandler = OnUnloaded;
@@ -31,11 +26,6 @@ internal class ScopedPage : Page
         currentScope = Ioc.Default.GetRequiredService<IScopedPageScopeReferenceTracker>().CreateScope();
     }
 
-    /// <summary>
-    /// 异步通知接收器
-    /// </summary>
-    /// <param name="extra">额外内容</param>
-    /// <returns>任务</returns>
     public async ValueTask NotifyRecipientAsync(INavigationData extra)
     {
         if (extra.Data is not null && DataContext is INavigationRecipient recipient)
@@ -61,6 +51,32 @@ internal class ScopedPage : Page
 
     /// <inheritdoc/>
     protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
+    {
+        DisposeViewModel();
+        inFrame = false;
+    }
+
+    /// <inheritdoc/>
+    protected override void OnNavigatedTo(NavigationEventArgs e)
+    {
+        if (e.Parameter is INavigationData extra)
+        {
+            NotifyRecipientAsync(extra).SafeForget();
+        }
+    }
+
+    private void OnUnloaded(object sender, RoutedEventArgs e)
+    {
+        if (inFrame)
+        {
+            DisposeViewModel();
+        }
+
+        DataContext = null;
+        Unloaded -= unloadEventHandler;
+    }
+
+    private void DisposeViewModel()
     {
         using (viewCancellationTokenSource)
         {
@@ -79,19 +95,4 @@ internal class ScopedPage : Page
             }
         }
     }
-
-    /// <inheritdoc/>
-    protected override void OnNavigatedTo(NavigationEventArgs e)
-    {
-        if (e.Parameter is INavigationData extra)
-        {
-            NotifyRecipientAsync(extra).SafeForget();
-        }
-    }
-
-    private void OnUnloaded(object sender, RoutedEventArgs e)
-    {
-        DataContext = null;
-        Unloaded -= unloadEventHandler;
-    }
 }

src/Snap.Hutao/Snap.Hutao/Control/ScopedPageScopeReferenceTracker.cs

@@ -22,6 +22,7 @@ internal sealed partial class ScopedPageScopeReferenceTracker : IScopedPageScope
 
     public IServiceScope CreateScope()
     {
+        GC.Collect(GC.MaxGeneration, GCCollectionMode.Aggressive, true);
         IServiceScope currentScope = serviceProvider.CreateScope();
 
         // In case previous one is not disposed.

src/Snap.Hutao/Snap.Hutao/Control/SizeRestrictedContentControl.cs

@@ -0,0 +1,50 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Windows.Foundation;
+
+namespace Snap.Hutao.Control;
+
+[DependencyProperty("IsWidthRestricted", typeof(bool), true)]
+[DependencyProperty("IsHeightRestricted", typeof(bool), true)]
+internal sealed partial class SizeRestrictedContentControl : ContentControl
+{
+    private double minContentWidth;
+    private double minContentHeight;
+
+    protected override Size MeasureOverride(Size availableSize)
+    {
+        if (Content is FrameworkElement element)
+        {
+            element.Measure(availableSize);
+            Size contentDesiredSize = element.DesiredSize;
+            Size contentActualOrDesiredSize = new(
+                Math.Max(element.ActualWidth, contentDesiredSize.Width),
+                Math.Max(element.ActualHeight, contentDesiredSize.Height));
+
+            if (IsWidthRestricted)
+            {
+                if (contentActualOrDesiredSize.Width > minContentWidth)
+                {
+                    minContentWidth = contentActualOrDesiredSize.Width;
+                }
+
+                element.MinWidth = minContentWidth;
+            }
+
+            if (IsHeightRestricted)
+            {
+                if (contentActualOrDesiredSize.Height > minContentHeight)
+                {
+                    minContentHeight = contentActualOrDesiredSize.Height;
+                }
+
+                element.MinHeight = minContentHeight;
+            }
+        }
+
+        return base.MeasureOverride(availableSize);
+    }
+}

src/Snap.Hutao/Snap.Hutao/Control/Theme/Card.xaml

@@ -2,6 +2,22 @@
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:cwm="using:CommunityToolkit.WinUI.Media">
+    <ResourceDictionary.ThemeDictionaries>
+        <ResourceDictionary x:Key="Light">
+            <cwm:AttachedCardShadow
+                x:Key="CompatCardShadow"
+                BlurRadius="8"
+                Opacity="0.14"
+                Offset="0,4,0"/>
+        </ResourceDictionary>
+        <ResourceDictionary x:Key="Dark">
+            <cwm:AttachedCardShadow
+                x:Key="CompatCardShadow"
+                BlurRadius="8"
+                Opacity="0.28"
+                Offset="0,4,0"/>
+        </ResourceDictionary>
+    </ResourceDictionary.ThemeDictionaries>
     <Style x:Key="BorderCardStyle" TargetType="Border">
         <Setter Property="Background" Value="{ThemeResource CardBackgroundFillColorDefaultBrush}"/>
         <Setter Property="BorderBrush" Value="{ThemeResource CardStrokeColorDefaultBrush}"/>
@@ -14,8 +30,4 @@
         <Setter Property="BorderThickness" Value="1"/>
         <Setter Property="CornerRadius" Value="{ThemeResource ControlCornerRadius}"/>
     </Style>
-    <cwm:AttachedCardShadow
-        x:Key="CompatCardShadow"
-        Opacity="0.1"
-        Offset="0,4,0"/>
 </ResourceDictionary>

src/Snap.Hutao/Snap.Hutao/Control/Theme/Color.xaml

@@ -23,7 +23,7 @@
     <SolidColorBrush x:Key="PurpleColorBrush" Color="{ThemeResource PurpleColor}"/>
     <SolidColorBrush x:Key="OrangeColorBrush" Color="{ThemeResource OrangeColor}"/>
 
-    <SolidColorBrush x:Key="GuaranteePullCoolorBrush" Color="{ThemeResource GuaranteePullColor}"/>
+    <SolidColorBrush x:Key="GuaranteePullColorBrush" Color="{ThemeResource GuaranteePullColor}"/>
     <SolidColorBrush x:Key="UpPullColorBrush" Color="{ThemeResource UpPullColor}"/>
 
     <SolidColorBrush x:Key="DarkOnlyOverlayMaskColorBrush" Color="{ThemeResource DarkOnlyOverlayMaskColor}"/>

src/Snap.Hutao/Snap.Hutao/Control/Theme/ComboBox.xaml

@@ -0,0 +1,11 @@
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <Style
+        x:Key="CommandBarComboBoxStyle"
+        BasedOn="{StaticResource DefaultComboBoxStyle}"
+        TargetType="ComboBox">
+        <Setter Property="Padding" Value="12,7,0,7"/>
+        <Setter Property="Height" Value="36"/>
+    </Style>
+    <!--  https://github.com/microsoft/microsoft-ui-xaml/issues/4811  -->
+    <x:Int32 x:Key="__DiscardPageOverride">0</x:Int32>
+</ResourceDictionary>

src/Snap.Hutao/Snap.Hutao/Control/Theme/FlyoutStyle.xaml

@@ -18,4 +18,10 @@
         TargetType="FlyoutPresenter">
         <Setter Property="Padding" Value="6"/>
     </Style>
+    <Style
+        x:Key="FlyoutPresenterPadding16And10Style"
+        BasedOn="{StaticResource DefaultFlyoutPresenterStyle}"
+        TargetType="FlyoutPresenter">
+        <Setter Property="Padding" Value="16,10"/>
+    </Style>
 </ResourceDictionary>

src/Snap.Hutao/Snap.Hutao/Control/Theme/FontStyle.xaml

@@ -93,4 +93,19 @@
     <Style BasedOn="{StaticResource DefaultScrollViewerStyle}" TargetType="ScrollViewer">
         <Setter Property="FontFamily" Value="{StaticResource MiSans}"/>
     </Style>
+
+    <SolidColorBrush x:Key="TextControlTextForeground" Color="{ThemeResource TextFillColorPrimary}"/>
+    <Thickness x:Key="TextControlTextMargin">1,0</Thickness>
+    <Style
+        x:Key="TextControlTextBlockStyle"
+        BasedOn="{StaticResource BodyTextBlockStyle}"
+        TargetType="TextBlock">
+        <Setter Property="Foreground" Value="{StaticResource TextControlTextForeground}"/>
+        <Setter Property="Margin" Value="{StaticResource TextControlTextMargin}"/>
+        <Setter Property="HorizontalAlignment" Value="Stretch"/>
+        <Setter Property="VerticalAlignment" Value="Center"/>
+        <Setter Property="HorizontalTextAlignment" Value="Center"/>
+        <Setter Property="TextTrimming" Value="CharacterEllipsis"/>
+        <Setter Property="TextWrapping" Value="NoWrap"/>
+    </Style>
 </ResourceDictionary>

src/Snap.Hutao/Snap.Hutao/Control/Theme/Glyph.xaml

@@ -1,4 +1,5 @@
 <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <!--  https://learn.microsoft.com/en-us/windows/apps/design/style/segoe-fluent-icons-font  -->
     <x:String x:Key="FontIconContentAdd">&#xE710;</x:String>
     <x:String x:Key="FontIconContentSetting">&#xE713;</x:String>
     <x:String x:Key="FontIconContentRefresh">&#xE72C;</x:String>
@@ -12,6 +13,7 @@
     <x:String x:Key="FontIconContentBulletedList">&#xE8FD;</x:String>
     <x:String x:Key="FontIconContentCheckList">&#xE9D5;</x:String>
     <x:String x:Key="FontIconContentWebsite">&#xEB41;</x:String>
+    <x:String x:Key="FontIconContentQRCode">&#xED14;</x:String>
     <x:String x:Key="FontIconContentHomeGroup">&#xEC26;</x:String>
     <x:String x:Key="FontIconContentAsteriskBadge12">&#xEDAD;</x:String>
     <x:String x:Key="FontIconContentZipFolder">&#xF012;</x:String>

src/Snap.Hutao/Snap.Hutao/Control/Theme/ItemsPanelTemplate.xaml

@@ -17,6 +17,9 @@
     <ItemsPanelTemplate x:Key="HorizontalStackPanelSpacing2Template">
         <StackPanel Orientation="Horizontal" Spacing="2"/>
     </ItemsPanelTemplate>
+    <ItemsPanelTemplate x:Key="StackPanelSpacing4Template">
+        <StackPanel Spacing="4"/>
+    </ItemsPanelTemplate>
     <ItemsPanelTemplate x:Key="UniformGridColumns2Spacing2Template">
         <cwcont:UniformGrid
             ColumnSpacing="2"

src/Snap.Hutao/Snap.Hutao/Control/Theme/Uri.xaml

@@ -10,25 +10,27 @@
     <x:String x:Key="Sponsor_Afadian">https://afdian.net/a/DismissedLight</x:String>
 
     <!--  AvatarCard  -->
-    <x:String x:Key="UI_AvatarIcon_Costume_Card">https://static.snapgenshin.com/AvatarCard/UI_AvatarIcon_Costume_Card.png</x:String>
+    <x:String x:Key="UI_AvatarIcon_Costume_Card">https://api.snapgenshin.com/static/raw/AvatarCard/UI_AvatarIcon_Costume_Card.png</x:String>
 
     <!--  Bg  -->
-    <x:String x:Key="UI_Icon_Intee_Explore_1">https://static.snapgenshin.com/Bg/UI_Icon_Intee_Explore_1.png</x:String>
-    <x:String x:Key="UI_ImgSign_ItemIcon">https://static.snapgenshin.com/Bg/UI_ImgSign_ItemIcon.png</x:String>
-    <x:String x:Key="UI_ItemIcon_None">https://static.snapgenshin.com/Bg/UI_ItemIcon_None.png</x:String>
-    <x:String x:Key="UI_MarkQuest_Events_Proce">https://static.snapgenshin.com/Bg/UI_MarkQuest_Events_Proce.png</x:String>
-    <x:String x:Key="UI_MarkTower">https://static.snapgenshin.com/Bg/UI_MarkTower.png</x:String>
+    <x:String x:Key="UI_Icon_Intee_Explore_1">https://api.snapgenshin.com/static/raw/Bg/UI_Icon_Intee_Explore_1.png</x:String>
+    <x:String x:Key="UI_ImgSign_ItemIcon">https://api.snapgenshin.com/static/raw/Bg/UI_ImgSign_ItemIcon.png</x:String>
+    <x:String x:Key="UI_ItemIcon_None">https://api.snapgenshin.com/static/raw/Bg/UI_ItemIcon_None.png</x:String>
+    <x:String x:Key="UI_MarkQuest_Events_Proce">https://api.snapgenshin.com/static/raw/Bg/UI_MarkQuest_Events_Proce.png</x:String>
+    <x:String x:Key="UI_MarkTower">https://api.snapgenshin.com/static/raw/Bg/UI_MarkTower.png</x:String>
 
     <!--  ItemIcon  -->
-    <x:String x:Key="UI_ItemIcon_201">https://static.snapgenshin.com/ItemIcon/UI_ItemIcon_201.png</x:String>
-    <x:String x:Key="UI_ItemIcon_204">https://static.snapgenshin.com/ItemIcon/UI_ItemIcon_204.png</x:String>
-    <x:String x:Key="UI_ItemIcon_210">https://static.snapgenshin.com/ItemIcon/UI_ItemIcon_210.png</x:String>
-    <x:String x:Key="UI_ItemIcon_220021">https://static.snapgenshin.com/ItemIcon/UI_ItemIcon_220021.png</x:String>
+    <x:String x:Key="UI_ItemIcon_201">https://api.snapgenshin.com/static/raw/ItemIcon/UI_ItemIcon_201.png</x:String>
+    <x:String x:Key="UI_ItemIcon_204">https://api.snapgenshin.com/static/raw/ItemIcon/UI_ItemIcon_204.png</x:String>
+    <x:String x:Key="UI_ItemIcon_210">https://api.snapgenshin.com/static/raw/ItemIcon/UI_ItemIcon_210.png</x:String>
+    <x:String x:Key="UI_ItemIcon_220021">https://api.snapgenshin.com/static/raw/ItemIcon/UI_ItemIcon_220021.png</x:String>
 
     <!--  EmotionIcon  -->
-    <x:String x:Key="UI_EmotionIcon25">https://static.snapgenshin.com/EmotionIcon/UI_EmotionIcon25.png</x:String>
-    <x:String x:Key="UI_EmotionIcon71">https://static.snapgenshin.com/EmotionIcon/UI_EmotionIcon71.png</x:String>
-    <x:String x:Key="UI_EmotionIcon250">https://static.snapgenshin.com/EmotionIcon/UI_EmotionIcon250.png</x:String>
-    <x:String x:Key="UI_EmotionIcon272">https://static.snapgenshin.com/EmotionIcon/UI_EmotionIcon272.png</x:String>
-    <x:String x:Key="UI_EmotionIcon293">https://static.snapgenshin.com/EmotionIcon/UI_EmotionIcon293.png</x:String>
+    <x:String x:Key="UI_EmotionIcon25">https://api.snapgenshin.com/static/raw/EmotionIcon/UI_EmotionIcon25.png</x:String>
+    <x:String x:Key="UI_EmotionIcon71">https://api.snapgenshin.com/static/raw/EmotionIcon/UI_EmotionIcon71.png</x:String>
+    <x:String x:Key="UI_EmotionIcon250">https://api.snapgenshin.com/static/raw/EmotionIcon/UI_EmotionIcon250.png</x:String>
+    <x:String x:Key="UI_EmotionIcon271">https://api.snapgenshin.com/static/raw/EmotionIcon/UI_EmotionIcon271.png</x:String>
+    <x:String x:Key="UI_EmotionIcon272">https://api.snapgenshin.com/static/raw/EmotionIcon/UI_EmotionIcon272.png</x:String>
+    <x:String x:Key="UI_EmotionIcon293">https://api.snapgenshin.com/static/raw/EmotionIcon/UI_EmotionIcon293.png</x:String>
+    <x:String x:Key="UI_EmotionIcon445">https://api.snapgenshin.com/static/raw/EmotionIcon/UI_EmotionIcon445.png</x:String>
 </ResourceDictionary>

src/Snap.Hutao/Snap.Hutao/Core/Abstraction/IDeconstruct.cs

@@ -3,18 +3,12 @@
 
 namespace Snap.Hutao.Core.Abstraction;
 
-/// <summary>
-/// 指示该类可以解构为元组
-/// </summary>
-/// <typeparam name="T1">元组的第一个类型</typeparam>
-/// <typeparam name="T2">元组的第二个类型</typeparam>
-[HighQuality]
 internal interface IDeconstruct<T1, T2>
 {
-    /// <summary>
-    /// 解构
-    /// </summary>
-    /// <param name="t1">第一个元素</param>
-    /// <param name="t2">第二个元素</param>
     void Deconstruct(out T1 t1, out T2 t2);
+}
+
+internal interface IDeconstruct<T1, T2, T3>
+{
+    void Deconstruct(out T1 t1, out T2 t2, out T3 t3);
 }

src/Snap.Hutao/Snap.Hutao/Core/Abstraction/IPinnable.cs

@@ -0,0 +1,9 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.Abstraction;
+
+internal interface IPinnable<TData>
+{
+    ref readonly TData GetPinnableReference();
+}

src/Snap.Hutao/Snap.Hutao/Core/Caching/ImageCache.cs

@@ -18,41 +18,30 @@ namespace Snap.Hutao.Core.Caching;
 /// The class's name will become the cache folder's name
 /// </summary>
 [HighQuality]
+[ConstructorGenerated]
 [Injection(InjectAs.Singleton, typeof(IImageCache))]
 [HttpClient(HttpClientConfiguration.Default)]
 [PrimaryHttpMessageHandler(MaxConnectionsPerServer = 8)]
-internal sealed class ImageCache : IImageCache, IImageCacheFilePathOperation
+internal sealed partial class ImageCache : IImageCache, IImageCacheFilePathOperation
 {
     private const string CacheFolderName = nameof(ImageCache);
 
-    private static readonly FrozenDictionary<int, TimeSpan> RetryCountToDelay = new Dictionary<int, TimeSpan>()
+    private readonly FrozenDictionary<int, TimeSpan> retryCountToDelay = new Dictionary<int, TimeSpan>()
     {
         [0] = TimeSpan.FromSeconds(4),
         [1] = TimeSpan.FromSeconds(16),
         [2] = TimeSpan.FromSeconds(64),
     }.ToFrozenDictionary();
 
+    private readonly ConcurrentDictionary<string, Task> concurrentTasks = new();
+
     private readonly IHttpClientFactory httpClientFactory;
     private readonly IServiceProvider serviceProvider;
     private readonly ILogger<ImageCache> logger;
 
-    private readonly ConcurrentDictionary<string, Task> concurrentTasks = new();
-
     private string? baseFolder;
     private string? cacheFolder;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="ImageCache"/> class.
-    /// </summary>
-    /// <param name="serviceProvider">服务提供器</param>
-    public ImageCache(IServiceProvider serviceProvider)
-    {
-        logger = serviceProvider.GetRequiredService<ILogger<ImageCache>>();
-        httpClientFactory = serviceProvider.GetRequiredService<IHttpClientFactory>();
-
-        this.serviceProvider = serviceProvider;
-    }
-
     /// <inheritdoc/>
     public void RemoveInvalid()
     {
@@ -62,7 +51,7 @@ internal sealed class ImageCache : IImageCache, IImageCacheFilePathOperation
     /// <inheritdoc/>
     public void Remove(Uri uriForCachedItem)
     {
-        Remove(new ReadOnlySpan<Uri>(ref uriForCachedItem));
+        Remove([uriForCachedItem]);
     }
 
     /// <inheritdoc/>
@@ -191,7 +180,7 @@ internal sealed class ImageCache : IImageCache, IImageCacheFilePathOperation
                     case HttpStatusCode.TooManyRequests:
                         {
                             retryCount++;
-                            TimeSpan delay = message.Headers.RetryAfter?.Delta ?? RetryCountToDelay[retryCount];
+                            TimeSpan delay = message.Headers.RetryAfter?.Delta ?? retryCountToDelay[retryCount];
                             logger.LogInformation("Retry {Uri} after {Delay}.", uri, delay);
                             await Task.Delay(delay).ConfigureAwait(false);
                             break;

src/Snap.Hutao/Snap.Hutao/Core/CommandLineBuilder.cs

@@ -18,11 +18,11 @@ internal sealed class CommandLineBuilder
     /// <summary>
     /// 当符合条件时添加参数
     /// </summary>
-    /// <param name="name">参数名称</param>
     /// <param name="condition">条件</param>
+    /// <param name="name">参数名称</param>
     /// <param name="value">值</param>
     /// <returns>命令行建造器</returns>
-    public CommandLineBuilder AppendIf(string name, bool condition, object? value = null)
+    public CommandLineBuilder AppendIf(bool condition, string name, object? value = null)
     {
         return condition ? Append(name, value) : this;
     }
@@ -35,7 +35,7 @@ internal sealed class CommandLineBuilder
     /// <returns>命令行建造器</returns>
     public CommandLineBuilder AppendIfNotNull(string name, object? value = null)
     {
-        return AppendIf(name, value is not null, value);
+        return AppendIf(value is not null, name, value);
     }
 
     /// <summary>

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/DependencyInjection.cs

@@ -24,7 +24,7 @@ internal static class DependencyInjection
         ServiceProvider serviceProvider = new ServiceCollection()
 
             // Microsoft extension
-            .AddLogging(builder => builder.AddUnconditionalDebug())
+            .AddLogging(builder => builder.AddDebug().AddConsoleWindow())
             .AddMemoryCache()
 
             // Hutao extensions
@@ -39,6 +39,7 @@ internal static class DependencyInjection
 
         Ioc.Default.ConfigureServices(serviceProvider);
 
+        serviceProvider.InitializeConsoleWindow();
         serviceProvider.InitializeCulture();
 
         return serviceProvider;
@@ -52,6 +53,8 @@ internal static class DependencyInjection
 
         CultureInfo cultureInfo = appOptions.CurrentCulture;
 
+        CultureInfo.DefaultThreadCurrentCulture = cultureInfo;
+        CultureInfo.DefaultThreadCurrentUICulture = cultureInfo;
         CultureInfo.CurrentCulture = cultureInfo;
         CultureInfo.CurrentUICulture = cultureInfo;
 
@@ -59,4 +62,9 @@ internal static class DependencyInjection
 
         SH.Culture = cultureInfo;
     }
+
+    private static void InitializeConsoleWindow(this IServiceProvider serviceProvider)
+    {
+        _ = serviceProvider.GetRequiredService<ConsoleWindowLifeTime>();
+    }
 }

src/Snap.Hutao/Snap.Hutao/Core/DependencyInjection/IocHttpClientConfiguration.cs

@@ -46,7 +46,7 @@ internal static partial class IocHttpClientConfiguration
         client.DefaultRequestHeaders.Accept.ParseAdd(ApplicationJson);
         client.DefaultRequestHeaders.Add("x-rpc-app_version", SaltConstants.CNVersion);
         client.DefaultRequestHeaders.Add("x-rpc-client_type", "5");
-        client.DefaultRequestHeaders.Add("x-rpc-device_id", HoyolabOptions.DeviceId);
+        client.DefaultRequestHeaders.Add("x-rpc-device_id", HoyolabOptions.DeviceId36);
     }
 
     /// <summary>
@@ -62,7 +62,8 @@ internal static partial class IocHttpClientConfiguration
         client.DefaultRequestHeaders.Add("x-rpc-app_id", "bll8iq97cem8");
         client.DefaultRequestHeaders.Add("x-rpc-app_version", SaltConstants.CNVersion);
         client.DefaultRequestHeaders.Add("x-rpc-client_type", "2");
-        client.DefaultRequestHeaders.Add("x-rpc-device_id", HoyolabOptions.DeviceId);
+        client.DefaultRequestHeaders.Add("x-rpc-device_id", HoyolabOptions.DeviceId36);
+        client.DefaultRequestHeaders.Add("x-rpc-device_name", string.Empty);
         client.DefaultRequestHeaders.Add("x-rpc-game_biz", "bbs_cn");
         client.DefaultRequestHeaders.Add("x-rpc-sdk_version", "2.16.0");
     }
@@ -80,7 +81,7 @@ internal static partial class IocHttpClientConfiguration
         client.DefaultRequestHeaders.Add("x-rpc-app_version", SaltConstants.OSVersion);
         client.DefaultRequestHeaders.Add("x-rpc-client_type", "5");
         client.DefaultRequestHeaders.Add("x-rpc-language", "zh-cn");
-        client.DefaultRequestHeaders.Add("x-rpc-device_id", HoyolabOptions.DeviceId);
+        client.DefaultRequestHeaders.Add("x-rpc-device_id", HoyolabOptions.DeviceId36);
     }
 
     /// <summary>

src/Snap.Hutao/Snap.Hutao/Core/Diagnostics/CodeAnalysis/AlsoAsyncSetsAttribute.cs

@@ -0,0 +1,23 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// 指示此特性附加的属性会在属性改变后会异步地设置的其他属性
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, Inherited = false)]
+internal sealed class AlsoAsyncSetsAttribute : Attribute
+{
+    public AlsoAsyncSetsAttribute(string propertyName)
+    {
+    }
+
+    public AlsoAsyncSetsAttribute(string propertyName1, string propertyName2)
+    {
+    }
+
+    public AlsoAsyncSetsAttribute(params string[] propertyNames)
+    {
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/Diagnostics/CodeAnalysis/AlsoSetsAttribute.cs

@@ -0,0 +1,23 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.Diagnostics.CodeAnalysis;
+
+/// <summary>
+/// 指示此特性附加的属性会在属性改变后会设置的其他属性
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, Inherited = false)]
+internal sealed class AlsoSetsAttribute : Attribute
+{
+    public AlsoSetsAttribute(string propertyName)
+    {
+    }
+
+    public AlsoSetsAttribute(string propertyName1, string propertyName2)
+    {
+    }
+
+    public AlsoSetsAttribute(params string[] propertyNames)
+    {
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/Diagnostics/ValueStopwatch.cs

@@ -11,8 +11,6 @@ namespace Snap.Hutao.Core.Diagnostics;
 /// </summary>
 internal readonly struct ValueStopwatch
 {
-    private static readonly double TimestampToTicks = TimeSpan.TicksPerSecond / (double)Stopwatch.Frequency;
-
     private readonly long startTimestamp;
 
     private ValueStopwatch(long startTimestamp)
@@ -49,30 +47,12 @@ internal readonly struct ValueStopwatch
         return new MeasureExecutionToken(stopwatch, logger, callerName);
     }
 
-    /// <summary>
-    /// 获取经过的时间
-    /// </summary>
-    /// <returns>经过的时间</returns>
-    public long GetElapsedTimestamp()
-    {
-        // Start timestamp can't be zero in an initialized ValueStopwatch.
-        // It would have to be literally the first thing executed when the machine boots to be 0.
-        // So it being 0 is a clear indication of default(ValueStopwatch)
-        Verify.Operation(IsActive, $"An uninitialized, or 'default', {nameof(ValueStopwatch)} cannot be used to get elapsed time.");
-
-        long end = Stopwatch.GetTimestamp();
-        long timestampDelta = end - startTimestamp;
-        long ticks = (long)(TimestampToTicks * timestampDelta);
-
-        return ticks;
-    }
-
     /// <summary>
     /// 获取经过的时间
     /// </summary>
     /// <returns>经过的时间</returns>
     public TimeSpan GetElapsedTime()
     {
-        return new TimeSpan(GetElapsedTimestamp());
+        return Stopwatch.GetElapsedTime(startTimestamp);
     }
 }

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/ExceptionRecorder.cs

@@ -31,7 +31,7 @@ internal sealed partial class ExceptionRecorder
     private void OnAppUnhandledException(object? sender, Microsoft.UI.Xaml.UnhandledExceptionEventArgs e)
     {
         ValueTask<string?> task = serviceProvider
-            .GetRequiredService<Web.Hutao.Log.HomaLogUploadClient>()
+            .GetRequiredService<Web.Hutao.Log.HutaoLogUploadClient>()
             .UploadLogAsync(e.Exception);
 
         if (!task.IsCompleted)

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/HutaoException.cs

@@ -0,0 +1,20 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.ExceptionService;
+
+internal sealed class HutaoException : Exception
+{
+    public HutaoException(HutaoExceptionKind kind, string message, Exception? innerException)
+        : this(message, innerException)
+    {
+        Kind = kind;
+    }
+
+    public HutaoException(string message, Exception? innerException)
+        : base($"{message}\n{innerException?.Message}", innerException)
+    {
+    }
+
+    public HutaoExceptionKind Kind { get; private set; }
+}

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/HutaoExceptionKind.cs

@@ -0,0 +1,9 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao.Core.ExceptionService;
+
+internal enum HutaoExceptionKind
+{
+    None,
+}

src/Snap.Hutao/Snap.Hutao/Core/ExceptionService/ThrowHelper.cs

@@ -49,6 +49,13 @@ internal static class ThrowHelper
         throw new NotSupportedException();
     }
 
+    [DoesNotReturn]
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static NotSupportedException NotSupported(string message)
+    {
+        throw new NotSupportedException(message);
+    }
+
     [DoesNotReturn]
     [MethodImpl(MethodImplOptions.NoInlining)]
     public static OperationCanceledException OperationCanceled(string message, Exception? inner = default)
@@ -58,7 +65,7 @@ internal static class ThrowHelper
 
     [DoesNotReturn]
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public static PackageConvertException PackageConvert(string message, Exception? inner)
+    public static PackageConvertException PackageConvert(string message, Exception? inner = default)
     {
         throw new PackageConvertException(message, inner);
     }

src/Snap.Hutao/Snap.Hutao/Core/IO/Hashing/SHA256.cs

@@ -0,0 +1,23 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using System.IO;
+
+namespace Snap.Hutao.Core.IO.Hashing;
+
+internal static class SHA256
+{
+    public static async ValueTask<string> HashFileAsync(string filePath, CancellationToken token = default)
+    {
+        using (FileStream stream = File.OpenRead(filePath))
+        {
+            return await HashAsync(stream, token).ConfigureAwait(false);
+        }
+    }
+
+    public static async ValueTask<string> HashAsync(Stream stream, CancellationToken token = default)
+    {
+        byte[] bytes = await System.Security.Cryptography.SHA256.HashDataAsync(stream, token).ConfigureAwait(false);
+        return System.Convert.ToHexString(bytes);
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/IO/Http/Sharding/HttpShardCopyWorker.cs

@@ -0,0 +1,168 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Win32.SafeHandles;
+using Snap.Hutao.Core.Diagnostics;
+using System.IO;
+using System.Net.Http;
+
+namespace Snap.Hutao.Core.IO.Http.Sharding;
+
+internal sealed class HttpShardCopyWorker<TStatus> : IDisposable
+{
+    private const int ShardSize = 4 * 1024 * 1024;
+
+    private readonly HttpClient httpClient;
+    private readonly string sourceUrl;
+    private readonly Func<long, long, TStatus> statusFactory;
+    private readonly long contentLength;
+    private readonly int bufferSize;
+    private readonly SafeFileHandle destFileHandle;
+    private readonly List<Shard> shards;
+
+    private HttpShardCopyWorker(HttpShardCopyWorkerOptions<TStatus> options)
+    {
+        httpClient = options.HttpClient;
+        sourceUrl = options.SourceUrl;
+        statusFactory = options.StatusFactory;
+        contentLength = options.ContentLength;
+        bufferSize = options.BufferSize;
+        destFileHandle = options.GetFileHandle();
+        shards = CalculateShards(contentLength);
+
+        static List<Shard> CalculateShards(long contentLength)
+        {
+            List<Shard> shards = [];
+            long currentOffset = 0;
+
+            while (currentOffset < contentLength)
+            {
+                long end = Math.Min(currentOffset + ShardSize, contentLength) - 1;
+                shards.Add(new Shard(currentOffset, end));
+                currentOffset = end + 1;
+            }
+
+            return shards;
+        }
+    }
+
+    public static async ValueTask<HttpShardCopyWorker<TStatus>> CreateAsync(HttpShardCopyWorkerOptions<TStatus> options)
+    {
+        await options.DetectContentLengthAsync().ConfigureAwait(false);
+        return new(options);
+    }
+
+    [SuppressMessage("", "SH003")]
+    public Task CopyAsync(IProgress<TStatus> progress, CancellationToken token = default)
+    {
+        ShardProgress shardProgress = new(progress, statusFactory, contentLength);
+        return Parallel.ForEachAsync(shards, token, (shard, token) => CopyShardAsync(shard, shardProgress, token));
+
+        async ValueTask CopyShardAsync(Shard shard, IProgress<ShardStatus> progress, CancellationToken token)
+        {
+            ValueStopwatch stopwatch = ValueStopwatch.StartNew();
+            HttpRequestMessage request = new(HttpMethod.Get, sourceUrl)
+            {
+                Headers = { Range = new(shard.StartOffset, shard.EndOffset), },
+            };
+
+            using (request)
+            {
+                using (HttpResponseMessage response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token).ConfigureAwait(false))
+                {
+                    response.EnsureSuccessStatusCode();
+
+                    Memory<byte> buffer = new byte[bufferSize];
+                    using (Stream stream = await response.Content.ReadAsStreamAsync(token).ConfigureAwait(false))
+                    {
+                        int totalBytesRead = 0;
+                        int bytesReadAfterPreviousReport = 0;
+                        do
+                        {
+                            int bytesRead = await stream.ReadAsync(buffer, token).ConfigureAwait(false);
+                            if (bytesRead <= 0)
+                            {
+                                progress.Report(new(bytesReadAfterPreviousReport));
+                                bytesReadAfterPreviousReport = 0;
+                                break;
+                            }
+
+                            await RandomAccess.WriteAsync(destFileHandle, buffer[..bytesRead], shard.StartOffset + totalBytesRead, token).ConfigureAwait(false);
+
+                            totalBytesRead += bytesRead;
+                            bytesReadAfterPreviousReport += bytesRead;
+                            if (stopwatch.GetElapsedTime().TotalMilliseconds > 500)
+                            {
+                                progress.Report(new(bytesReadAfterPreviousReport));
+                                bytesReadAfterPreviousReport = 0;
+                                stopwatch = ValueStopwatch.StartNew();
+                            }
+                        }
+                        while (true);
+                    }
+                }
+            }
+        }
+    }
+
+    public void Dispose()
+    {
+        destFileHandle.Dispose();
+    }
+
+    private sealed class Shard
+    {
+        public Shard(long startOffset, long endOffset)
+        {
+            StartOffset = startOffset;
+            EndOffset = endOffset;
+        }
+
+        public long StartOffset { get; }
+
+        public long EndOffset { get; }
+    }
+
+    private sealed class ShardStatus
+    {
+        public ShardStatus(int bytesRead)
+        {
+            BytesRead = bytesRead;
+        }
+
+        public int BytesRead { get; }
+    }
+
+    private sealed class ShardProgress : IProgress<ShardStatus>
+    {
+        private readonly IProgress<TStatus> workerProgress;
+        private readonly Func<long, long, TStatus> statusFactory;
+        private readonly long contentLength;
+        private readonly object syncRoot = new();
+        private ValueStopwatch stopwatch = ValueStopwatch.StartNew();
+        private long totalBytesRead;
+
+        public ShardProgress(IProgress<TStatus> workerProgress, Func<long, long, TStatus> statusFactory, long contentLength)
+        {
+            this.workerProgress = workerProgress;
+            this.statusFactory = statusFactory;
+            this.contentLength = contentLength;
+        }
+
+        public void Report(ShardStatus value)
+        {
+            Interlocked.Add(ref totalBytesRead, value.BytesRead);
+            if (stopwatch.GetElapsedTime().TotalMilliseconds > 1000 || totalBytesRead == contentLength)
+            {
+                lock (syncRoot)
+                {
+                    if (stopwatch.GetElapsedTime().TotalMilliseconds > 1000 || totalBytesRead == contentLength)
+                    {
+                        workerProgress.Report(statusFactory(totalBytesRead, contentLength));
+                        stopwatch = ValueStopwatch.StartNew();
+                    }
+                }
+            }
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/IO/Http/Sharding/HttpShardCopyWorkerOptions.cs

@@ -0,0 +1,44 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.Win32.SafeHandles;
+using Snap.Hutao.Web.Request.Builder;
+using System.IO;
+using System.Net.Http;
+
+namespace Snap.Hutao.Core.IO.Http.Sharding;
+
+internal sealed class HttpShardCopyWorkerOptions<TStatus>
+{
+    public HttpClient HttpClient { get; set; } = default!;
+
+    public string SourceUrl { get; set; } = default!;
+
+    public string DestinationFilePath { get; set; } = default!;
+
+    public long ContentLength { get; private set; }
+
+    public Func<long, long, TStatus> StatusFactory { get; set; } = default!;
+
+    public int BufferSize { get; set; } = 80 * 1024;
+
+    public SafeFileHandle GetFileHandle()
+    {
+        return File.OpenHandle(DestinationFilePath, FileMode.Create, FileAccess.Write, FileShare.None, FileOptions.RandomAccess | FileOptions.Asynchronous, ContentLength);
+    }
+
+    public async ValueTask DetectContentLengthAsync()
+    {
+        if (ContentLength > 0)
+        {
+            return;
+        }
+
+        HttpResponseMessage response = await HttpClient.HeadAsync(SourceUrl, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
+        response.EnsureSuccessStatusCode();
+
+        long contentLength = response.Content.Headers.ContentLength ?? 0;
+        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(contentLength);
+        ContentLength = contentLength;
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/IO/StreamCopyWorker.cs

@@ -1,67 +1,21 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
+using Snap.Hutao.Core.Diagnostics;
 using System.IO;
 
 namespace Snap.Hutao.Core.IO;
 
-/// <summary>
-/// 流复制器
-/// </summary>
-internal sealed class StreamCopyWorker
+internal sealed class StreamCopyWorker : StreamCopyWorker<StreamCopyStatus>
 {
-    private readonly Stream source;
-    private readonly Stream destination;
-    private readonly long totalBytes;
-    private readonly int bufferSize;
-
-    /// <summary>
-    /// 创建一个新的流复制器
-    /// </summary>
-    /// <param name="source">源</param>
-    /// <param name="destination">目标</param>
-    /// <param name="totalBytes">总字节</param>
-    /// <param name="bufferSize">字节尺寸</param>
     public StreamCopyWorker(Stream source, Stream destination, long totalBytes, int bufferSize = 81920)
+        : base(source, destination, bytes => new StreamCopyStatus(bytes, totalBytes), bufferSize)
     {
-        Verify.Operation(source.CanRead, "Source Stream can't read");
-        Verify.Operation(destination.CanWrite, "Destination Stream can't write");
-
-        this.source = source;
-        this.destination = destination;
-        this.totalBytes = totalBytes;
-        this.bufferSize = bufferSize;
-    }
-
-    /// <summary>
-    /// 异步复制
-    /// </summary>
-    /// <param name="progress">进度</param>
-    /// <returns>任务</returns>
-    public async ValueTask CopyAsync(IProgress<StreamCopyStatus> progress)
-    {
-        long totalBytesRead = 0;
-        int bytesRead;
-        Memory<byte> buffer = new byte[bufferSize];
-
-        do
-        {
-            bytesRead = await source.ReadAsync(buffer).ConfigureAwait(false);
-            await destination.WriteAsync(buffer[..bytesRead]).ConfigureAwait(false);
-
-            totalBytesRead += bytesRead;
-            progress.Report(new(totalBytesRead, totalBytes));
-        }
-        while (bytesRead > 0);
     }
 }
 
-/// <summary>
-/// 针对特定类型的流复制器
-/// </summary>
-/// <typeparam name="TStatus">进度类型</typeparam>
 [SuppressMessage("", "SA1402")]
-internal sealed class StreamCopyWorker<TStatus>
+internal class StreamCopyWorker<TStatus>
 {
     private readonly Stream source;
     private readonly Stream destination;
@@ -93,6 +47,8 @@ internal sealed class StreamCopyWorker<TStatus>
     /// <returns>任务</returns>
     public async ValueTask CopyAsync(IProgress<TStatus> progress)
     {
+        ValueStopwatch stopwatch = ValueStopwatch.StartNew();
+
         long totalBytesRead = 0;
         int bytesRead;
         Memory<byte> buffer = new byte[bufferSize];
@@ -100,10 +56,20 @@ internal sealed class StreamCopyWorker<TStatus>
         do
         {
             bytesRead = await source.ReadAsync(buffer).ConfigureAwait(false);
+            if (bytesRead == 0)
+            {
+                progress.Report(statusFactory(totalBytesRead));
+                break;
+            }
+
             await destination.WriteAsync(buffer[..bytesRead]).ConfigureAwait(false);
 
             totalBytesRead += bytesRead;
-            progress.Report(statusFactory(totalBytesRead));
+            if (stopwatch.GetElapsedTime().TotalMilliseconds > 1000)
+            {
+                progress.Report(statusFactory(totalBytesRead));
+                stopwatch = ValueStopwatch.StartNew();
+            }
         }
         while (bytesRead > 0);
     }

src/Snap.Hutao/Snap.Hutao/Core/LifeCycle/Activation.cs

@@ -6,6 +6,7 @@ using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Windows.AppLifecycle;
 using Snap.Hutao.Core.Setting;
 using Snap.Hutao.Service.DailyNote;
+using Snap.Hutao.Service.Discord;
 using Snap.Hutao.Service.Hutao;
 using Snap.Hutao.Service.Metadata;
 using Snap.Hutao.Service.Navigation;
@@ -139,14 +140,19 @@ internal sealed partial class Activation : IActivation
     private async ValueTask HandleNormalLaunchActionAsync()
     {
         // Increase launch times
-        LocalSetting.Set(SettingKeys.LaunchTimes, LocalSetting.Get(SettingKeys.LaunchTimes, 0) + 1);
+        LocalSetting.Update(SettingKeys.LaunchTimes, 0, x => x + 1);
 
-        if (StaticResource.IsAnyUnfulfilledCategoryPresent())
+        // If it's the first time launch, we show the guide window anyway.
+        // Otherwise, we check if there's any unfulfilled resource category present.
+        if (UnsafeLocalSetting.Get(SettingKeys.Major1Minor7Revision0GuideState, GuideState.Language) >= GuideState.StaticResourceBegin)
         {
-            LocalSetting.Set(SettingKeys.Major1Minor7Revision0GuideState, (uint)GuideState.StaticResourceBegin);
+            if (StaticResource.IsAnyUnfulfilledCategoryPresent())
+            {
+                UnsafeLocalSetting.Set(SettingKeys.Major1Minor7Revision0GuideState, GuideState.StaticResourceBegin);
+            }
         }
 
-        if (LocalSetting.Get(SettingKeys.Major1Minor7Revision0GuideState, (uint)GuideState.Language) < (uint)GuideState.Completed)
+        if (UnsafeLocalSetting.Get(SettingKeys.Major1Minor7Revision0GuideState, GuideState.Language) < GuideState.Completed)
         {
             await taskContext.SwitchToMainThreadAsync();
             serviceProvider.GetRequiredService<GuideWindow>();
@@ -159,24 +165,33 @@ internal sealed partial class Activation : IActivation
 
     private async ValueTask WaitMainWindowAsync()
     {
-        if (currentWindowReference.Window is null)
+        if (currentWindowReference.Window is not null)
         {
-            await taskContext.SwitchToMainThreadAsync();
-
-            serviceProvider.GetRequiredService<MainWindow>();
-
-            serviceProvider
-                .GetRequiredService<IMetadataService>()
-                .As<IMetadataServiceInitialization>()?
-                .InitializeInternalAsync()
-                .SafeForget();
-
-            serviceProvider
-                .GetRequiredService<IHutaoUserService>()
-                .As<IHutaoUserServiceInitialization>()?
-                .InitializeInternalAsync()
-                .SafeForget();
+            return;
         }
+
+        await taskContext.SwitchToMainThreadAsync();
+
+        serviceProvider.GetRequiredService<MainWindow>();
+
+        await taskContext.SwitchToBackgroundAsync();
+
+        serviceProvider
+            .GetRequiredService<IMetadataService>()
+            .As<IMetadataServiceInitialization>()?
+            .InitializeInternalAsync()
+            .SafeForget();
+
+        serviceProvider
+            .GetRequiredService<IHutaoUserService>()
+            .As<IHutaoUserServiceInitialization>()?
+            .InitializeInternalAsync()
+            .SafeForget();
+
+        serviceProvider
+            .GetRequiredService<IDiscordService>()
+            .SetNormalActivity()
+            .SafeForget();
     }
 
     private async ValueTask HandleUrlActivationAsync(Uri uri, bool isRedirected)
@@ -271,21 +286,22 @@ internal sealed partial class Activation : IActivation
         if (currentWindowReference.Window is null)
         {
             serviceProvider.GetRequiredService<LaunchGameWindow>();
+            return;
+        }
+
+        if (currentWindowReference.Window is MainWindow)
+        {
+            await serviceProvider
+                .GetRequiredService<INavigationService>()
+                .NavigateAsync<View.Page.LaunchGamePage>(INavigationAwaiter.Default, true)
+                .ConfigureAwait(false);
+
+            return;
         }
         else
         {
-            if (currentWindowReference.Window is MainWindow)
-            {
-                await serviceProvider
-                    .GetRequiredService<INavigationService>()
-                    .NavigateAsync<View.Page.LaunchGamePage>(INavigationAwaiter.Default, true)
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                // We have a non-Main Window, just exit current process anyway
-                Process.GetCurrentProcess().Kill();
-            }
+            // We have a non-Main Window, just exit current process anyway
+            Process.GetCurrentProcess().Kill();
         }
     }
 }

src/Snap.Hutao/Snap.Hutao/Core/Logging/ConsoleWindowLifeTime.cs

@@ -0,0 +1,41 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Snap.Hutao.Core.Setting;
+using Windows.Win32.Foundation;
+using Windows.Win32.System.Console;
+using static Windows.Win32.PInvoke;
+
+namespace Snap.Hutao.Core.Logging;
+
+internal sealed class ConsoleWindowLifeTime : IDisposable
+{
+    private readonly bool consoleWindowAllocated;
+
+    public ConsoleWindowLifeTime()
+    {
+        if (LocalSetting.Get(SettingKeys.IsAllocConsoleDebugModeEnabled, false))
+        {
+            consoleWindowAllocated = AllocConsole();
+            if (consoleWindowAllocated)
+            {
+                HANDLE inputHandle = GetStdHandle(STD_HANDLE.STD_INPUT_HANDLE);
+                if (GetConsoleMode(inputHandle, out CONSOLE_MODE mode))
+                {
+                    mode &= ~CONSOLE_MODE.ENABLE_QUICK_EDIT_MODE;
+                    SetConsoleMode(inputHandle, mode);
+                }
+
+                SetConsoleTitle("Snap Hutao Debug Console");
+            }
+        }
+    }
+
+    public void Dispose()
+    {
+        if (consoleWindowAllocated)
+        {
+            FreeConsole();
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao/Core/Logging/DebugLogger.cs

@@ -1,70 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using System.Diagnostics;
-
-namespace Snap.Hutao.Core.Logging;
-
-/// <summary>
-/// A logger that writes messages in the debug output window only when a debugger is attached.
-/// </summary>
-internal sealed class DebugLogger : ILogger
-{
-    private readonly string name;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="DebugLogger"/> class.
-    /// </summary>
-    /// <param name="name">The name of the logger.</param>
-    public DebugLogger(string name)
-    {
-        this.name = name;
-    }
-
-    /// <inheritdoc />
-    public IDisposable BeginScope<TState>(TState state)
-        where TState : notnull
-    {
-        return NullScope.Instance;
-    }
-
-    /// <inheritdoc />
-    public bool IsEnabled(LogLevel logLevel)
-    {
-        // If the filter is null, everything is enabled
-        return logLevel != LogLevel.None;
-    }
-
-    /// <inheritdoc />
-    [SuppressMessage("", "SH002")]
-    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
-    {
-        if (!IsEnabled(logLevel))
-        {
-            return;
-        }
-
-        ArgumentNullException.ThrowIfNull(formatter);
-
-        string message = formatter(state, exception);
-
-        if (string.IsNullOrEmpty(message))
-        {
-            return;
-        }
-
-        message = $"{logLevel}: {message}";
-
-        if (exception is not null)
-        {
-            message += Environment.NewLine + Environment.NewLine + exception;
-        }
-
-        DebugWriteLine(message, name);
-    }
-
-    private static void DebugWriteLine(string message, string name)
-    {
-        Debug.WriteLine(message, category: name);
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/Logging/DebugLoggerFactoryExtensions.cs

@@ -1,24 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-using Microsoft.Extensions.DependencyInjection.Extensions;
-
-namespace Snap.Hutao.Core.Logging;
-
-/// <summary>
-/// Extension methods for the <see cref="ILoggerFactory"/> class.
-/// </summary>
-internal static class DebugLoggerFactoryExtensions
-{
-    /// <summary>
-    /// Adds a debug logger named 'Debug' to the factory.
-    /// </summary>
-    /// <param name="builder">The extension method argument.</param>
-    /// <returns>builder</returns>
-    public static ILoggingBuilder AddUnconditionalDebug(this ILoggingBuilder builder)
-    {
-        builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, DebugLoggerProvider>());
-
-        return builder;
-    }
-}

src/Snap.Hutao/Snap.Hutao/Core/Logging/DebugLoggerProvider.cs

@@ -1,22 +0,0 @@
-// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-namespace Snap.Hutao.Core.Logging;
-
-/// <summary>
-/// The provider for the <see cref="DebugLogger"/>.
-/// </summary>
-[ProviderAlias("Debug")]
-internal sealed class DebugLoggerProvider : ILoggerProvider
-{
-    /// <inheritdoc />
-    public ILogger CreateLogger(string name)
-    {
-        return new DebugLogger(name);
-    }
-
-    /// <inheritdoc />
-    public void Dispose()
-    {
-    }
-}