1.7.0 package

1.7.0 Stable

.github/FUNDING.yml

@@ -0,0 +1,13 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+custom: https://afdian.net/a/DismissedLight

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -15,17 +15,15 @@ body:
       description: |-
         请确保你已完整执行检查清单，否则你的 Issue 可能会被忽略
       options:
-        - label: 我已完整阅读[胡桃工具箱文档](https://hut.ao/FAQ/most-frequent-questions.html)，并认为我的问题没有在文档中得到解答
-          required: true
+        - label: 我并未完整阅读[胡桃工具箱文档](https://hut.ao/advanced/FAQ.html)
+          
+        - label: 我不知道文档站的导航栏中有**搜索功能**，也没有搜索过相关关键词
 
-        - label: 我使用的操作系统是[受支持的版本](https://hut.ao/quick-start.html#%E6%9C%80%E4%BD%8E%E7%B3%BB%E7%BB%9F%E8%A6%81%E6%B1%82)
-          required: true
+        - label: 我使用的操作系统是不[受支持的版本](https://hut.ao/quick-start.html#%E6%9C%80%E4%BD%8E%E7%B3%BB%E7%BB%9F%E8%A6%81%E6%B1%82)
 
-        - label: 我确认没有其他人已经提出了相同或类似的问题
-          required: true
-
-        - label: 我会在下方的表单中附上充足的信息以帮助开发人员确定问题
-          required: true
+        - label: 我没有**通过搜索功能**确认其他人提出过相同或类似的问题
+         
+        - label: 我不明白上述的勾选项是**一个有助于快速排查问题的检查清单**，而是随手确认的选项
 
   - type: input
     id: winver
@@ -33,7 +31,7 @@ body:
       label: Windows 版本
       description: | 
         `Win+R` 输入 `winver` 回车后在打开的窗口第二行可以找到
-      placeholder: 例：22000.556
+      placeholder: 例：22621.1105
     validations:
       required: true
    
@@ -42,7 +40,7 @@ body:
     attributes:
       label: Snap Hutao 版本
       description: 在应用标题，应用程序的设置界面中靠下的位置可以找到
-      placeholder: 例：1.1.0
+      placeholder: 例：1.4.15.0
     validations:
       required: true
 
@@ -96,14 +94,4 @@ body:
       description: 详细的描述你期望发生的行为，突出与目前（可能不正确的）行为的不同
     validations:
       required: false
-
-  - type: textarea
-    id: logs
-    attributes:
-      label: 相关的崩溃日志
-      description: |
-                   在资源管理器中直接输入`%userprofile%/Documents/Hutao`即可进入文件夹
-                   如果应用程序崩溃了，请将`log.db` 文件上传，文件包含了敏感信息，谨慎上传
-                   如果这个表单是关于导入祈愿记录的问题，请包含你导入的`Json`文件
-                   > **务必不要上传`user.db`文件，该文件包含你的帐号敏感信息**
-        
+      

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -14,7 +14,7 @@ body:
     id: back
     attributes:
       label: 背景与动机
-      description: 添加此功能的理由
+      description: 添加此功能的理由，如果你想要实现多个功能，请分别发起多个单独的 Issue
     validations:
       required: true
 

.github/ISSUE_TEMPLATE/network-issue.yml

@@ -21,7 +21,7 @@ body:
         **在填写下面的问题之前请先使用我们的网络诊断工具**
         **这个工具将会生成一份报告，请将这份报告拖入下面的框中，让其与你的工单一起被上传提交**
         - 你可以点击下面的链接以下载网络诊断工具：
-          - [胡桃资源站](https://d.hut.ao/d/tools/network-diagnosis-tool.exe)
+          - [胡桃资源站](https://d.hut.ao/d/tools/network-diagnosis-hutao.exe)
           - [GitHub](https://github.com/Masterain98/network-diagnosis-tool/releases/latest/download/network-diagnosis-hutao.exe)
     validations:
       required: true

.github/dependabot.yml

@@ -0,0 +1,16 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "nuget"
+    directory: "/src/Snap.Hutao" # Snap.Hutao.csproj
+    target-branch: "develop"
+    schedule:
+      interval: "weekly"
+    groups:
+      packages:
+        patterns:
+          - "*"

.github/workflows/PublishDistribution.yml

@@ -23,7 +23,7 @@ jobs:
         with: 
           repository: "DGP-Studio/Snap.Hutao"
           latest: true
-          fileName: "*.zip"
+          fileName: "*.msix"
           out-file-path: ./release-download
           
       # Upload to Drive

.gitignore

@@ -1,8 +1,12 @@
+desktop.ini
 
 *.csproj.user
 *.pubxml
+*.DotSettings.user
 
 .vs/
+.idea/
+src/Snap.Hutao/_ReSharper.Caches
 
 src/Snap.Hutao/Snap.Hutao/bin/
 src/Snap.Hutao/Snap.Hutao/obj/
@@ -15,5 +19,5 @@ src/Snap.Hutao/Snap.Hutao.Installer/Properties/PublishProfiles/FolderProfile.pub
 src/Snap.Hutao/Snap.Hutao.SourceGeneration/bin/
 src/Snap.Hutao/Snap.Hutao.SourceGeneration/obj/
 
-src/Snap.Hutao/Snap.Hutao.Win32/bin/
-src/Snap.Hutao/Snap.Hutao.Win32/obj/
+src/Snap.Hutao/Snap.Hutao.Test/bin/
+src/Snap.Hutao/Snap.Hutao.Test/obj/

CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Code of Conduct
+
+>  Snap Hutao is adapting the following rules to keep the community safety.
+
+When participating in our open source community, we want all members to respect and support each other. To ensure the comfort and safety of our community members, we have established the following code of conduct:
+
+1. Respect diversity and inclusivity. We welcome people from different countries, regions, genders, sexual orientations, abilities, religions, and cultural backgrounds to participate in our community, and we encourage respect for all differences.
+2. Prohibit discrimination and harassment. We do not tolerate any form of discrimination, harassment, personal attacks, or insults. This includes but is not limited to race, gender, sexual orientation, age, religion, nationality, cultural background, physical and mental health status.
+3. Respect privacy and personal information. We protect the privacy and personal information of community members and prohibit the public disclosure of any private information. If you need to disclose certain information, please make sure you have obtained the relevant person's permission.
+4. Keep honesty and transparency. We expect community members to maintain honesty and transparency and not intentionally mislead or deceive others.
+5. Respect community rules and other members. We encourage community members to follow community rules and guidelines and maintain a polite and respectful attitude towards other members. If you find that other members are violating community rules, please report it to community administrators or organizers in a timely manner.
+
+The above is our community's code of conduct, and we expect all community members to abide by these rules. We will actively address behaviors that violate these rules. We believe that through mutual respect and support, we can build a friendly, inclusive, and beneficial open source community.

NuGet.Config

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" />
+    <add key="Microsoft CsWin32" value="https://pkgs.dev.azure.com/azure-public/winsdk/_packaging/CI/nuget/v3/index.json" />
+    <add key="CommunityToolkit-MainLatest" value="https://pkgs.dev.azure.com/dotnet/CommunityToolkit/_packaging/CommunityToolkit-MainLatest/nuget/v3/index.json" />
+    <add key="CommunityToolkit-Labs" value="https://pkgs.dev.azure.com/dotnet/CommunityToolkit/_packaging/CommunityToolkit-Labs/nuget/v3/index.json" />
+  </packageSources>
+  <packageRestore>
+    <add key="enabled" value="True" />
+    <add key="automatic" value="True" />
+  </packageRestore>
+  <bindingRedirects>
+    <add key="skip" value="False" />
+  </bindingRedirects>
+  <packageManagement>
+    <add key="format" value="1" />
+    <add key="disabled" value="False" />
+  </packageManagement>
+</configuration>

README.md

@@ -1,33 +1,50 @@
-# [Snap.Hutao](https://hut.ao)
+![](https://repository-images.githubusercontent.com/482734649/c47a0a8e-868d-4d07-a66f-6d4473abfe46)
 
-![](https://repository-images.githubusercontent.com/482734649/5f8cf574-2ef0-43e9-aa8d-6cf094b54dd9)
+胡桃工具箱是一个 Windows 平台的开源的原神工具箱，旨在帮助玩家获得更好的游戏体验； 它是对官方移动端工具的一种非破坏性功能扩展，为不习惯在移动端进行原神游戏的 PC 玩家提供一个在 Windows 平台下获得接近移动端功能权利的途径
 
-> 唷，找本堂主有何贵干呀？
+Snap Hutao is an open-source Genshin Impact toolbox on Windows platform, aim to provide a better gaming experience for players. It's an nondestructive feature extension from Genshin Impact's official mobile application, to provide similar feature on desktop, to allow PC gamers gain deserved benefits from mobile platforms.
 
-![Snap.Hutao](https://repobeats.axiom.co/api/embed/f029553fbe0c60689b1710476ec8512452163fc9.svg)
+## 下载使用 / 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)
+
+## 贡献 / Contribute
+
+* [向我们提交 PR / Make Pull Requests](https://github.com/DGP-Studio/Snap.Hutao/pulls)
+* [在 Crowdin 上进行本地化 / Translate project on Crowdin](https://translate.hut.ao/)
+* [为我们更新文档 / Enhance our Document ](https://github.com/DGP-Studio/Snap.Hutao.Docs)
+
+## 特别感谢 / Special Thanks
 
 * [HolographicHat](https://github.com/HolographicHat)
 * [UIGF organization](https://uigf.org)
 
-### 特定的原神项目
+### 特定的原神项目 / Specific Genshin-related Project
 
 * [biuuu/genshin-wish-export](https://github.com/biuuu/genshin-wish-export)
 * [xunkong/xunkong](https://github.com/xunkong/xunkong)
 * [YuehaiTeam/cocogoat](https://github.com/YuehaiTeam/cocogoat)
 
-### 使用的技术栈
+### 使用的技术栈 / Tech Stack
 
 * [CommunityToolkit/dotnet](https://github.com/CommunityToolkit/dotnet)
-* [CommunityToolkit/WindowsCommunityToolkit](https://github.com/CommunityToolkit/WindowsCommunityToolkit)
+* [CommunityToolkit/Labs-Windows](https://github.com/CommunityToolkit/Labs-Windows)
+* [CommunityToolkit/Windows](https://github.com/CommunityToolkit/Windows)
 * [dahall/taskscheduler](https://github.com/dahall/taskscheduler)
 * [dotnet/efcore](https://github.com/dotnet/efcore)
 * [dotnet/runtime](https://github.com/dotnet/runtime)
 * [DotNetAnalyzers/StyleCopAnalyzers](https://github.com/DotNetAnalyzers/StyleCopAnalyzers)
 * [microsoft/CsWin32](https://github.com/microsoft/CsWin32)
-* [microsoft/vs-threading](https://github.com/microsoft/vs-threading)
 * [microsoft/vs-validation](https://github.com/microsoft/vs-validation)
 * [microsoft/WindowsAppSDK](https://github.com/microsoft/WindowsAppSDK)
 * [microsoft/microsoft-ui-xaml](https://github.com/microsoft/microsoft-ui-xaml)
-* [WinUICommunity/SettingsUI](https://github.com/WinUICommunity/SettingsUI)
+
+### 支撑项目 / Supporter Project
+
+* [Snap.Hutao.Server](https://github.com/DGP-Studio/Snap.Hutao.Server)
+* [Snap.Metadata](https://github.com/DGP-Studio/Snap.Metadata)
+
+## 开发 / Development
+![Snap.Hutao](https://repobeats.axiom.co/api/embed/f029553fbe0c60689b1710476ec8512452163fc9.svg)
+
+![Branch Rule](res/branch.png)

SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| >=1.6.0   | :white_check_mark: |
+| <1.6.0   | :x:                |
+
+## Reporting a Vulnerability
+
+Please [open an issue](https://github.com/DGP-Studio/Snap.Hutao/issues/new/choose)

azure-pipelines.yml

@@ -11,12 +11,14 @@ 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:
@@ -27,10 +29,12 @@ pr:
      - azure-pipelines.yml
      - .github/ISSUE_TEMPLATE/*.yml
      - .github/workflows/*.yml
+     - src/Snap.Hutao/Snap.Hutao/Resource/Localization/*.resx
     
 
 pool:
-  vmImage: 'windows-2022'
+  name: Default
+  demands: agent.name -equals Hutao-Server
 
 variables:
   DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
@@ -63,7 +67,8 @@ steps:
   inputs:
     command: 'restore'
     restoreSolution: '$(solution)'
-    feedsToUse: 'select'
+    feedsToUse: 'config'
+    nugetConfigPath: '$(Build.SourcesDirectory)/NuGet.Config'
 
 - task: MsixPackaging@1
   displayName: Build binary package
@@ -81,7 +86,7 @@ steps:
 
 - task: MagicChunks@2
   inputs:
-    sourcePath: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net7.0-windows10.0.18362.0\win10-x64\AppxManifest.xml'
+    sourcePath: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net7.0-windows10.0.19041.0\win10-x64\AppxManifest.xml'
     fileType: 'Xml'
     targetPathType: 'source'
     transformationType: 'json'
@@ -102,7 +107,7 @@ steps:
       mkdir Assets
       
       mkdir Resource
-    workingDirectory: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net7.0-windows10.0.18362.0\win10-x64'
+    workingDirectory: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net7.0-windows10.0.19041.0\win10-x64'
       
 
 - task: CopyFiles@2
@@ -110,33 +115,36 @@ steps:
   inputs:
     SourceFolder: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\Assets'
     Contents: '**'
-    TargetFolder: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net7.0-windows10.0.18362.0\win10-x64\Assets'
+    TargetFolder: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net7.0-windows10.0.19041.0\win10-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\net7.0-windows10.0.18362.0\win10-x64\Resource'
+    TargetFolder: '$(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net7.0-windows10.0.19041.0\win10-x64\Resource'
 
 - task: CmdLine@2
   displayName: Build MSIX
   inputs:
-    script: '"C:\Program Files (x86)\Windows Kits\10\bin\10.0.22000.0\x64\makeappx.exe" pack /d $(Build.SourcesDirectory)\src\Snap.Hutao\Snap.Hutao\bin\x64\Release\net7.0-windows10.0.18362.0\win10-x64 /p $(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(build_date).$(rev_number).msix'
+    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\net7.0-windows10.0.19041.0\win10-x64 /p $(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(build_date).$(rev_number).msix'
 
 - task: MsixSigning@1
+  name: signMsix
   displayName: Sign MSIX package
   inputs:
     package: '$(Build.ArtifactStagingDirectory)/Snap.Hutao.Alpha-$(build_date).$(rev_number).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: PublishPipelineArtifact@1
+#  displayName: 'Upload Output'
+#  inputs:
+#    targetPath: '$(Build.ArtifactStagingDirectory)/'
+#    artifact: 'Output'
+#    publishLocation: 'pipeline'
 
 - task: DownloadSecureFile@1
   name: cerFile
@@ -145,7 +153,6 @@ steps:
     secureFile: 'Snap.Hutao.CI.cer'
 
 - task: GitHubRelease@1
-  condition: or(eq(variables['Build.Reason'], 'Manual'), eq(variables['Build.Reason'], 'IndividualCI'), eq(variables['Build.Reason'], 'BatchedCI'))
   inputs:
     gitHubConnection: 'github.com_Masterain'
     repositoryName: 'DGP-Studio/Snap.Hutao'
@@ -168,14 +175,17 @@ steps:
     changeLogCompareToRelease: 'lastFullRelease'
     changeLogType: 'commitBased'
 
-- task: DownloadSecureFile@1
-  name: RcloneConfigFile
-  displayName: Download Rclone Config
-  inputs:
-    secureFile: 'rclone.conf'
 
 - 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/'
-    configPath: '$(RcloneConfigFile.secureFilePath)'
+    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/'
+    configPath: 'C:\agent\_work\_tasks\rclone.conf'

crowdin.yml

@@ -0,0 +1,3 @@
+files:
+  - source: /src/Snap.Hutao/Snap.Hutao/Resource/Localization/SH.resx
+    translation: /src/Snap.Hutao/Snap.Hutao/Resource/Localization/SH.%osx_locale%.resx

desktop.ini

@@ -1,6 +0,0 @@
-[.ShellClassInfo]
-IconResource=D:\Develop\Projects\Snap.Hutao\src\Snap.Hutao\Snap.Hutao\Assets\Logo.ico,0
-[ViewState]
-Mode=
-Vid=
-FolderType=Generic

res/README.md

@@ -0,0 +1,3 @@
+本文件夹中的所有图片，均由 [DGP Studio](https://github.com/DGP-Studio) 委托 [Bilibili 画画的芦苇](https://space.bilibili.com/274422134) 绘制
+
+Copyright © 2023 DGP Studio, All Rights Reserved.

src/Snap.Hutao/.editorconfig

@@ -10,7 +10,7 @@ csharp_style_expression_bodied_constructors = false:silent
 csharp_style_expression_bodied_operators = false:silent
 csharp_style_expression_bodied_properties = false:silent
 csharp_style_expression_bodied_indexers = false:silent
-csharp_style_expression_bodied_accessors = when_on_single_line:silent
+csharp_style_expression_bodied_accessors = when_on_single_line:suggestion
 csharp_style_expression_bodied_lambdas = when_on_single_line:silent
 csharp_style_expression_bodied_local_functions = false:silent
 csharp_style_conditional_delegate_call = true:suggestion
@@ -57,6 +57,7 @@ dotnet_style_prefer_simplified_interpolation = true:suggestion
 dotnet_style_namespace_match_folder = true:suggestion
 dotnet_style_predefined_type_for_locals_parameters_members = true:silent
 dotnet_style_predefined_type_for_member_access = true:silent
+dotnet_diagnostic.CA1000.severity = suggestion
 [*.cs]
 #### 命名样式 ####
 
@@ -162,11 +163,166 @@ dotnet_diagnostic.CA1309.severity = suggestion
 dotnet_diagnostic.CA1805.severity = suggestion
 
 # VSTHRD111: Use ConfigureAwait(bool)
-dotnet_diagnostic.VSTHRD111.severity = suggestion
+dotnet_diagnostic.VSTHRD111.severity = silent
 csharp_style_prefer_top_level_statements = true:silent
 csharp_style_prefer_readonly_struct = true:suggestion
 csharp_style_prefer_utf8_string_literals = true:suggestion
 
+# SA1600: Elements should be documented
+dotnet_diagnostic.SA1600.severity = none
+dotnet_diagnostic.SA1601.severity = silent
+dotnet_diagnostic.SA1602.severity = silent
+
+# CA1008: 枚举应具有零值
+dotnet_diagnostic.CA1008.severity = suggestion
+
+# CA1010: 还应实现泛型接口
+dotnet_diagnostic.CA1010.severity = suggestion
+
+# CA1012: 抽象类型不应具有公共构造函数
+dotnet_diagnostic.CA1012.severity = suggestion
+
+# CA1024: 在适用处使用属性
+dotnet_diagnostic.CA1024.severity = suggestion
+
+# CA1034: 嵌套类型应不可见
+dotnet_diagnostic.CA1034.severity = suggestion
+
+# CA1036: 重写可比较类型中的方法
+dotnet_diagnostic.CA1036.severity = suggestion
+
+# CA1040: 避免使用空接口
+dotnet_diagnostic.CA1040.severity = suggestion
+
+# CA1044: 属性不应是只写的
+dotnet_diagnostic.CA1044.severity = suggestion
+
+# CA1043: 将整型或字符串参数用于索引器
+dotnet_diagnostic.CA1043.severity = suggestion
+
+# CA1046: 不要对引用类型重载相等运算符
+dotnet_diagnostic.CA1046.severity = suggestion
+
+# CA1051: 不要声明可见实例字段
+dotnet_diagnostic.CA1051.severity = suggestion
+
+# CA1052: 静态容器类型应为 Static 或 NotInheritable
+dotnet_diagnostic.CA1052.severity = suggestion
+
+# CA1058: 类型不应扩展某些基类型
+dotnet_diagnostic.CA1058.severity = suggestion
+
+# CA1063: 正确实现 IDisposable
+dotnet_diagnostic.CA1063.severity = suggestion
+
+# CA1065: 不要在意外的位置引发异常
+dotnet_diagnostic.CA1065.severity = suggestion
+
+# CA1066: 重写 Object.Equals 时实现 IEquatable
+dotnet_diagnostic.CA1066.severity = suggestion
+
+# CA1304: 指定 CultureInfo
+dotnet_diagnostic.CA1304.severity = suggestion
+
+# CA1305: 指定 IFormatProvider
+dotnet_diagnostic.CA1305.severity = suggestion
+
+# CA1307: 为了清晰起见，请指定 StringComparison
+dotnet_diagnostic.CA1307.severity = suggestion
+
+# CA1310: 为了确保正确，请指定 StringComparison
+dotnet_diagnostic.CA1310.severity = suggestion
+
+# CA1308: 将字符串规范化为大写
+dotnet_diagnostic.CA1308.severity = suggestion
+
+# CA1501: 避免过度继承
+dotnet_diagnostic.CA1501.severity = suggestion
+
+# CA1502: 避免过度复杂性
+dotnet_diagnostic.CA1502.severity = suggestion
+
+# CA1505: 避免使用无法维护的代码
+dotnet_diagnostic.CA1505.severity = suggestion
+
+# CA1506: 避免过度的类耦合
+dotnet_diagnostic.CA1506.severity = suggestion
+
+# CA1508: 避免死条件代码
+dotnet_diagnostic.CA1508.severity = suggestion
+
+# CA1810: 以内联方式初始化引用类型的静态字段
+dotnet_diagnostic.CA1810.severity = suggestion
+
+# CA1813: 避免使用非密封特性
+dotnet_diagnostic.CA1813.severity = suggestion
+
+# CA1814: 与多维数组相比，首选使用交错数组
+dotnet_diagnostic.CA1814.severity = suggestion
+
+# CA1819: 属性不应返回数组
+dotnet_diagnostic.CA1819.severity = suggestion
+
+# CA1820: 使用字符串长度测试是否有空字符串
+dotnet_diagnostic.CA1820.severity = suggestion
+
+# CA1823: 避免未使用的私有字段
+dotnet_diagnostic.CA1823.severity = suggestion
+
+# CA1849: 当在异步方法中时，调用异步方法
+dotnet_diagnostic.CA1849.severity = suggestion
+
+# CA1852: 密封内部类型
+dotnet_diagnostic.CA1852.severity = suggestion
+
+# CA2000: 丢失范围之前释放对象
+dotnet_diagnostic.CA2000.severity = suggestion
+
+# CA2002: 不要锁定具有弱标识的对象
+dotnet_diagnostic.CA2002.severity = suggestion
+
+# CA2007: 考虑对等待的任务调用 ConfigureAwait
+dotnet_diagnostic.CA2007.severity = suggestion
+
+# CA2008: 不要在未传递 TaskScheduler 的情况下创建任务
+dotnet_diagnostic.CA2008.severity = suggestion
+
+# CA2100: 检查 SQL 查询是否存在安全漏洞
+dotnet_diagnostic.CA2100.severity = suggestion
+
+# CA2109: 检查可见的事件处理程序
+dotnet_diagnostic.CA2109.severity = suggestion
+
+# CA2119: 密封满足私有接口的方法
+dotnet_diagnostic.CA2119.severity = suggestion
+
+# CA2153: 不要捕获损坏状态异常
+dotnet_diagnostic.CA2153.severity = suggestion
+
+# CA2201: 不要引发保留的异常类型
+dotnet_diagnostic.CA2201.severity = suggestion
+
+# CA2207: 以内联方式初始化值类型的静态字段
+dotnet_diagnostic.CA2207.severity = suggestion
+
+# CA2213: 应释放可释放的字段
+dotnet_diagnostic.CA2213.severity = suggestion
+
+# CA2214: 不要在构造函数中调用可重写的方法
+dotnet_diagnostic.CA2214.severity = suggestion
+
+# CA2215: Dispose 方法应调用基类释放
+dotnet_diagnostic.CA2215.severity = suggestion
+
+# CA2216: 可释放类型应声明终结器
+dotnet_diagnostic.CA2216.severity = suggestion
+
+# CA2227: 集合属性应为只读
+dotnet_diagnostic.CA2227.severity = suggestion
+
+# CA2251: 使用 “string.Equals”
+dotnet_diagnostic.CA2251.severity = suggestion
+
 [*.vb]
 #### 命名样式 ####
 

src/Snap.Hutao/Snap.Hutao.Installer/Program.cs

@@ -1,73 +0,0 @@
-using Microsoft.Win32;
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Threading.Tasks;
-
-namespace Snap.Hutao.Installer;
-
-internal class Program
-{
-    private const string AppxKey = @"HKEY_LOCAL_MACHINE\SOFTWARE\Policies\Microsoft\Windows\Appx";
-    private const string ValueName = "AllowDevelopmentWithoutDevLicense";
-
-    public static async Task Main(string[] args)
-    {
-        _ = args;
-        string ps1File = Path.Combine(AppContext.BaseDirectory, "Install.ps1");
-
-        if (!File.Exists(ps1File))
-        {
-            Console.WriteLine("未检测到 Install.ps1 文件");
-            Console.WriteLine("请勿移动该安装程序，按下任意键退出...");
-            Console.ReadKey();
-            return;
-        }
-
-        try
-        {
-            //以管理策略打开开发者模式
-            Registry.SetValue(AppxKey, ValueName, 1, RegistryValueKind.DWord);
-        }
-        catch (Exception)
-        {
-            Console.WriteLine("开发者模式未开启，请手动开启，参阅下方链接");
-            Console.WriteLine("https://learn.microsoft.com/zh-CN/windows/apps/get-started/developer-mode-features-and-debugging");
-        }
-
-        await InstallAsync(ps1File).ConfigureAwait(false);
-
-        Console.WriteLine();
-        Console.WriteLine("官方文档与使用教程");
-        Console.WriteLine("https://hut.ao");
-        Console.WriteLine();
-        Console.WriteLine("在开始菜单中启动 Snap.Hutao ，按下任意键退出...");
-        Console.ReadKey();
-    }
-
-    private static async Task InstallAsync(string ps1File)
-    {
-        Console.WriteLine("请注意 PowerShell 中的提示");
-        Process ps = new()
-        {
-            StartInfo = new ProcessStartInfo()
-            {
-                FileName = "powershell.exe",
-                Arguments = $"-ExecutionPolicy Unrestricted \"{ps1File}\"",
-                UseShellExecute = true,
-            }
-        };
-
-        try
-        {
-            ps.Start();
-            await ps.WaitForExitAsync();
-            Console.WriteLine("安装脚本运行完成");
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine(ex);
-        }
-
-    }
-}

src/Snap.Hutao/Snap.Hutao.Installer/Snap.Hutao.Installer.csproj

@@ -1,14 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0-windows</TargetFramework>
-    <ImplicitUsings>disable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <PublishTrimmed>true</PublishTrimmed>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
-    <DebugType>embedded</DebugType>
-    <Platforms>AnyCPU;x64</Platforms>
-  </PropertyGroup>
-
-</Project>

src/Snap.Hutao/Snap.Hutao.Installer/app.manifest

@@ -1,79 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
-  <assemblyIdentity version="1.0.0.0" name="MyApplication.app"/>
-  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
-    <security>
-      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
-        <!-- UAC 清单选项
-             如果想要更改 Windows 用户帐户控制级别，请使用
-             以下节点之一替换 requestedExecutionLevel 节点。
-
-        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
-        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
-        <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
-
-            指定 requestedExecutionLevel 元素将禁用文件和注册表虚拟化。
-            如果你的应用程序需要此虚拟化来实现向后兼容性，则移除此
-            元素。
-        -->
-        <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
-      </requestedPrivileges>
-    </security>
-  </trustInfo>
-
-  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
-    <application>
-      <!-- 设计此应用程序与其一起工作且已针对此应用程序进行测试的
-           Windows 版本的列表。取消评论适当的元素，
-           Windows 将自动选择最兼容的环境。 -->
-
-      <!-- Windows Vista -->
-      <!--<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />-->
-
-      <!-- Windows 7 -->
-      <!--<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />-->
-
-      <!-- Windows 8 -->
-      <!--<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />-->
-
-      <!-- Windows 8.1 -->
-      <!--<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />-->
-
-      <!-- Windows 10 -->
-      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
-
-    </application>
-  </compatibility>
-
-  <!-- 指示该应用程序可感知 DPI 且 Windows 在 DPI 较高时将不会对其进行
-       自动缩放。Windows Presentation Foundation (WPF)应用程序自动感知 DPI，无需
-       选择加入。选择加入此设置的 Windows 窗体应用程序(面向 .NET Framework 4.6)还应
-       在其 app.config 中将 "EnableWindowsFormsHighDpiAutoResizing" 设置设置为 "true"。
-       
-       将应用程序设为感知长路径。请参阅 https://docs.microsoft.com/windows/win32/fileio/maximum-file-path-limitation -->
-  <!--
-  <application xmlns="urn:schemas-microsoft-com:asm.v3">
-    <windowsSettings>
-      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
-      <longPathAware xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">true</longPathAware>
-    </windowsSettings>
-  </application>
-  -->
-
-  <!-- 启用 Windows 公共控件和对话框的主题(Windows XP 和更高版本) -->
-  <!--
-  <dependency>
-    <dependentAssembly>
-      <assemblyIdentity
-          type="win32"
-          name="Microsoft.Windows.Common-Controls"
-          version="6.0.0.0"
-          processorArchitecture="*"
-          publicKeyToken="6595b64144ccf1df"
-          language="*"
-        />
-    </dependentAssembly>
-  </dependency>
-  -->
-
-</assembly>

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

@@ -0,0 +1,98 @@
+// 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

@@ -0,0 +1,193 @@
+// 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

@@ -0,0 +1,149 @@
+// 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.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 = GetLiteralString(arguments.ElementAtOrDefault(2)) ?? "default";
+            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);
+        }
+    }
+
+    private static string? GetLiteralString(TypedConstant typedConstant)
+    {
+        if (typedConstant.IsNull)
+        {
+            return default;
+        }
+
+        if (typedConstant.Value is bool boolValue)
+        {
+            return boolValue ? "true" : "false";
+        }
+
+        string result = typedConstant.Value!.ToString();
+        if (string.IsNullOrEmpty(result))
+        {
+            return default;
+        }
+
+        return result;
+    }
+}

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

@@ -0,0 +1,15 @@
+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/DedendencyInjection/HttpClientGenerator.cs

@@ -1,178 +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 Microsoft.CodeAnalysis.Text;
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-
-namespace Snap.Hutao.SourceGeneration.DedendencyInjection;
-
-/// <summary>
-/// 注入HttpClient代码生成器
-/// 旨在使用源生成器提高注入效率
-/// 防止在运行时动态查找注入类型
-/// </summary>
-[Generator]
-public class HttpClientGenerator : ISourceGenerator
-{
-    private const string DefaultName = "Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.HttpClientConfigration.Default";
-    private const string XRpcName = "Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.HttpClientConfigration.XRpc";
-    private const string XRpc2Name = "Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.HttpClientConfigration.XRpc2";
-
-    private const string PrimaryHttpMessageHandlerAttributeName = "Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.PrimaryHttpMessageHandlerAttribute";
-    private const string DynamicSecretAttributeName = "Snap.Hutao.Web.Hoyolab.DynamicSecret.UseDynamicSecretAttribute";
-
-    /// <inheritdoc/>
-    public void Initialize(GeneratorInitializationContext context)
-    {
-        // Register a syntax receiver that will be created for each generation pass
-        context.RegisterForSyntaxNotifications(() => new HttpClientSyntaxContextReceiver());
-    }
-
-    /// <inheritdoc/>
-    public void Execute(GeneratorExecutionContext context)
-    {
-        // retrieve the populated receiver
-        if (context.SyntaxContextReceiver is not HttpClientSyntaxContextReceiver receiver)
-        {
-            return;
-        }
-
-        string toolName = this.GetGeneratorType().FullName;
-
-        StringBuilder sourceCodeBuilder = new();
-
-        sourceCodeBuilder.Append($@"// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-// This class is generated by Snap.Hutao.SourceGeneration
-
-using Microsoft.Extensions.DependencyInjection;
-using Snap.Hutao.Web.Hoyolab.DynamicSecret;
-using System.Net.Http;
-
-namespace Snap.Hutao.Core.DependencyInjection;
-
-internal static partial class IocHttpClientConfiguration
-{{
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute(""{toolName}"",""1.0.0.0"")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    public static partial IServiceCollection AddHttpClients(this IServiceCollection services)
-    {{");
-
-        FillWithInjectionServices(receiver, sourceCodeBuilder);
-        sourceCodeBuilder.Append(@"
-        return services;
-    }
-}");
-
-        context.AddSource("IocHttpClientConfiguration.g.cs", SourceText.From(sourceCodeBuilder.ToString(), Encoding.UTF8));
-    }
-
-    private static void FillWithInjectionServices(HttpClientSyntaxContextReceiver receiver, StringBuilder sourceCodeBuilder)
-    {
-        List<string> lines = new();
-        StringBuilder lineBuilder = new();
-
-        foreach (INamedTypeSymbol classSymbol in receiver.Classes)
-        {
-            lineBuilder.Clear().Append("\r\n");
-            lineBuilder.Append(@"        services.AddHttpClient<");
-            lineBuilder.Append($"{classSymbol.ToDisplayString()}>(");
-
-            AttributeData httpClientInfo = classSymbol
-                .GetAttributes()
-                .Single(attr => attr.AttributeClass!.ToDisplayString() == HttpClientSyntaxContextReceiver.AttributeName);
-            ImmutableArray<TypedConstant> arguments = httpClientInfo.ConstructorArguments;
-
-            TypedConstant injectAs = arguments[0];
-
-            string injectAsName = injectAs.ToCSharpString();
-            switch (injectAsName)
-            {
-                case DefaultName:
-                    lineBuilder.Append(@"DefaultConfiguration)");
-                    break;
-                case XRpcName:
-                    lineBuilder.Append(@"XRpcConfiguration)");
-                    break;
-                case XRpc2Name:
-                    lineBuilder.Append(@"XRpc2Configuration)");
-                    break;
-                default:
-                    throw new InvalidOperationException($"非法的HttpClientConfigration值: [{injectAsName}]");
-            }
-
-            AttributeData? handlerInfo = classSymbol
-                .GetAttributes()
-                .SingleOrDefault(attr => attr.AttributeClass!.ToDisplayString() == PrimaryHttpMessageHandlerAttributeName);
-
-            if (handlerInfo != null)
-            {
-                ImmutableArray<KeyValuePair<string, TypedConstant>> properties = handlerInfo.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(" })");
-            }
-
-            if (classSymbol.GetAttributes().Any(attr => attr.AttributeClass!.ToDisplayString() == DynamicSecretAttributeName))
-            {
-                lineBuilder.Append(".AddHttpMessageHandler<DynamicSecretHandler>()");
-            }
-
-            lineBuilder.Append(";");
-
-            lines.Add(lineBuilder.ToString());
-        }
-
-        foreach (string line in lines.OrderBy(x => x))
-        {
-            sourceCodeBuilder.Append(line);
-        }
-    }
-
-    private class HttpClientSyntaxContextReceiver : ISyntaxContextReceiver
-    {
-        /// <summary>
-        /// 注入特性的名称
-        /// </summary>
-        public const string AttributeName = "Snap.Hutao.Core.DependencyInjection.Annotation.HttpClient.HttpClientAttribute";
-
-        /// <summary>
-        /// 所有需要注入的类型符号
-        /// </summary>
-        public List<INamedTypeSymbol> Classes { get; } = new();
-
-        /// <inheritdoc/>
-        public void OnVisitSyntaxNode(GeneratorSyntaxContext context)
-        {
-            // any class with at least one attribute is a candidate for injection generation
-            if (context.Node is ClassDeclarationSyntax classDeclarationSyntax && classDeclarationSyntax.AttributeLists.Count > 0)
-            {
-                // get as named type symbol
-                if (context.SemanticModel.GetDeclaredSymbol(classDeclarationSyntax) is INamedTypeSymbol classSymbol)
-                {
-                    if (classSymbol.GetAttributes().Any(ad => ad.AttributeClass!.ToDisplayString() == AttributeName))
-                    {
-                        Classes.Add(classSymbol);
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -1,156 +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 Microsoft.CodeAnalysis.Text;
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using System.Text;
-
-namespace Snap.Hutao.SourceGeneration.DedendencyInjection;
-
-/// <summary>
-/// 注入代码生成器
-/// 旨在使用源生成器提高注入效率
-/// 防止在运行时动态查找注入类型
-/// </summary>
-[Generator]
-public class InjectionGenerator : ISourceGenerator
-{
-    private const string InjectAsSingletonName = "Snap.Hutao.Core.DependencyInjection.Annotation.InjectAs.Singleton";
-    private const string InjectAsTransientName = "Snap.Hutao.Core.DependencyInjection.Annotation.InjectAs.Transient";
-    private const string InjectAsScopedName = "Snap.Hutao.Core.DependencyInjection.Annotation.InjectAs.Scoped";
-
-    /// <inheritdoc/>
-    public void Initialize(GeneratorInitializationContext context)
-    {
-        // Register a syntax receiver that will be created for each generation pass
-        context.RegisterForSyntaxNotifications(() => new InjectionSyntaxContextReceiver());
-    }
-
-    /// <inheritdoc/>
-    public void Execute(GeneratorExecutionContext context)
-    {
-        // retrieve the populated receiver
-        if (context.SyntaxContextReceiver is not InjectionSyntaxContextReceiver receiver)
-        {
-            return;
-        }
-
-        string toolName = this.GetGeneratorType().FullName;
-
-        StringBuilder sourceCodeBuilder = new();
-        sourceCodeBuilder.Append($@"// Copyright (c) DGP Studio. All rights reserved.
-// Licensed under the MIT license.
-
-// This class is generated by Snap.Hutao.SourceGeneration
-
-using Microsoft.Extensions.DependencyInjection;
-
-namespace Snap.Hutao.Core.DependencyInjection;
-
-internal static partial class ServiceCollectionExtension
-{{
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute(""{toolName}"",""1.0.0.0"")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    public static partial IServiceCollection AddInjections(this IServiceCollection services)
-    {{");
-
-        FillWithInjectionServices(receiver, sourceCodeBuilder);
-        sourceCodeBuilder.Append(@"
-        return services;
-    }
-}");
-
-        context.AddSource("ServiceCollectionExtension.g.cs", SourceText.From(sourceCodeBuilder.ToString(), Encoding.UTF8));
-    }
-
-    private static void FillWithInjectionServices(InjectionSyntaxContextReceiver receiver, StringBuilder sourceCodeBuilder)
-    {
-        List<string> lines = new();
-        StringBuilder lineBuilder = new();
-
-        foreach (INamedTypeSymbol classSymbol in receiver.Classes)
-        {
-            IEnumerable<AttributeData> datas = classSymbol
-                .GetAttributes()
-                .Where(attr => attr.AttributeClass!.ToDisplayString() == InjectionSyntaxContextReceiver.AttributeName);
-
-            foreach (AttributeData injectionInfo in datas)
-            {
-                lineBuilder
-                    .Clear()
-                    .Append("\r\n");
-
-                ImmutableArray<TypedConstant> arguments = injectionInfo.ConstructorArguments;
-
-                TypedConstant injectAs = arguments[0];
-
-                string injectAsName = injectAs.ToCSharpString();
-                switch (injectAsName)
-                {
-                    case InjectAsSingletonName:
-                        lineBuilder.Append(@"        services.AddSingleton(");
-                        break;
-                    case InjectAsTransientName:
-                        lineBuilder.Append(@"        services.AddTransient(");
-                        break;
-                    case InjectAsScopedName:
-                        lineBuilder.Append(@"        services.AddScoped(");
-                        break;
-                    default:
-                        throw new InvalidOperationException($"非法的 InjectAs 值: [{injectAsName}]");
-                }
-
-                if (arguments.Length == 2)
-                {
-                    TypedConstant interfaceType = arguments[1];
-                    lineBuilder.Append($"{interfaceType.ToCSharpString()}, ");
-                }
-
-                lineBuilder.Append($"typeof({classSymbol.ToDisplayString()}));");
-
-                lines.Add(lineBuilder.ToString());
-            }
-        }
-
-        foreach (string line in lines.OrderBy(x => x))
-        {
-            sourceCodeBuilder.Append(line);
-        }
-    }
-
-    private class InjectionSyntaxContextReceiver : ISyntaxContextReceiver
-    {
-        /// <summary>
-        /// 注入特性的名称
-        /// </summary>
-        public const string AttributeName = "Snap.Hutao.Core.DependencyInjection.Annotation.InjectionAttribute";
-
-        /// <summary>
-        /// 所有需要注入的类型符号
-        /// </summary>
-        public List<INamedTypeSymbol> Classes { get; } = new();
-
-        /// <inheritdoc/>
-        public void OnVisitSyntaxNode(GeneratorSyntaxContext context)
-        {
-            // any class with at least one attribute is a candidate for injection generation
-            if (context.Node is ClassDeclarationSyntax classDeclarationSyntax && classDeclarationSyntax.AttributeLists.Count > 0)
-            {
-                // get as named type symbol
-                if (context.SemanticModel.GetDeclaredSymbol(classDeclarationSyntax) is INamedTypeSymbol classSymbol)
-                {
-                    if (classSymbol.GetAttributes().Any(ad => ad.AttributeClass!.ToDisplayString() == AttributeName))
-                    {
-                        Classes.Add(classSymbol);
-                    }
-                }
-            }
-        }
-    }
-}

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

@@ -0,0 +1,152 @@
+// 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 UseDynamicSecretAttributeName = "Snap.Hutao.Web.Hoyolab.DynamicSecret.UseDynamicSecretAttribute";
+    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 Snap.Hutao.Web.Hoyolab.DynamicSecret;
+            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 = new();
+        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(" })");
+            }
+
+            if (context.HasAttributeWithName(UseDynamicSecretAttributeName))
+            {
+                lineBuilder.Append(".AddHttpMessageHandler<DynamicSecretHandler>()");
+            }
+
+            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

@@ -0,0 +1,126 @@
+// 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 = new();
+        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();
+            switch (injectAsName)
+            {
+                case InjectAsSingletonName:
+                    lineBuilder.Append("        services.AddSingleton<");
+                    break;
+                case InjectAsTransientName:
+                    lineBuilder.Append("        services.AddTransient<");
+                    break;
+                case InjectAsScopedName:
+                    lineBuilder.Append("        services.AddScoped<");
+                    break;
+                default:
+                    production.ReportDiagnostic(Diagnostic.Create(invalidInjectionDescriptor, context.Context.Node.GetLocation(), injectAsName));
+                    break;
+            }
+
+            if (arguments.Length == 2)
+            {
+                lineBuilder.Append($"{arguments[1].Value}, ");
+            }
+
+            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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,134 @@
+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.
+            
+            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);
+                    }
+                }
+
+                /// <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);
+                }
+            }
+            """);
+
+        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

@@ -0,0 +1,8 @@
+// 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

@@ -0,0 +1,196 @@
+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();
+                }
+            }
+            """);
+
+        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

@@ -0,0 +1,439 @@
+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 ??= new Dictionary<Type, Dictionary<string, PropertyInfo>>();
+        fieldInfoCache ??= new Dictionary<Type, Dictionary<string, FieldInfo>>();
+        stringBuilder ??= new StringBuilder();
+        splitArrayPool ??= new Stack<List<string>>();
+
+        // 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() : new List<string>();
+        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

@@ -0,0 +1,16 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.CodeAnalysis;
+using System;
+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!));
+    }
+}

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

@@ -0,0 +1,41 @@
+// 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 = new();
+
+            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

@@ -0,0 +1,77 @@
+// 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

@@ -0,0 +1,18 @@
+// 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

@@ -0,0 +1,21 @@
+// 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

@@ -0,0 +1,20 @@
+// 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

@@ -0,0 +1,28 @@
+// 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/Snap.Hutao.SourceGeneration.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
@@ -7,6 +7,7 @@
     <Nullable>enable</Nullable>
     <Platforms>x64</Platforms>
     <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
+    <Configurations>Debug;Release;Debug As Fake Elevated</Configurations>
   </PropertyGroup>
 
   <ItemGroup>
@@ -18,11 +19,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4-beta1.22518.1">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" PrivateAssets="all" Version="3.3.4" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.7.0" />
   </ItemGroup>
 
-</Project>
+</Project>

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

@@ -0,0 +1,312 @@
+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.Test/DependencyInjectionTest.cs

@@ -0,0 +1,89 @@
+using Microsoft.Extensions.DependencyInjection;
+using System;
+
+namespace Snap.Hutao.Test;
+
+[TestClass]
+public sealed class DependencyInjectionTest
+{
+    private readonly IServiceProvider services = new ServiceCollection()
+        .AddSingleton<IService, ServiceA>()
+        .AddSingleton<IService, ServiceB>()
+        .AddScoped<IScopedService, ServiceA>()
+        .AddTransient(typeof(IGenericService<>), typeof(GenericService<>))
+        .BuildServiceProvider();
+
+    [TestMethod]
+    public void OriginalTypeCannotResolved()
+    {
+        Assert.IsNull(services.GetService<ServiceA>());
+        Assert.IsNull(services.GetService<ServiceB>());
+    }
+
+    [TestMethod]
+    public void GenericServicesCanBeResolved()
+    {
+        IServiceProvider services = new ServiceCollection()
+            .AddTransient(typeof(IGenericService<>), typeof(GenericService<>))
+            .BuildServiceProvider();
+
+        Assert.IsNotNull(services.GetService<IGenericService<int>>());
+    }
+
+    [TestMethod]
+    public void ScopedServiceInitializeMultipleTimesInScope()
+    {
+        using (IServiceScope scope = services.CreateScope())
+        {
+            IScopedService service1 = scope.ServiceProvider.GetRequiredService<IScopedService>();
+            IScopedService service2 = scope.ServiceProvider.GetRequiredService<IScopedService>();
+            Assert.AreNotEqual(service1.Id, service2.Id);
+        }
+    }
+
+    private interface IService
+    {
+        Guid Id { get; }
+    }
+
+    private interface IScopedService
+    {
+        Guid Id { get; }
+    }
+
+    private sealed class ServiceA : IService, IScopedService
+    {
+        public Guid Id
+        {
+            get => Guid.NewGuid();
+        }
+    }
+
+    private sealed class ServiceB : IService
+    {
+        public Guid Id
+        {
+            get => throw new NotImplementedException();
+        }
+    }
+
+    private interface IGenericService<T>
+    {
+    }
+
+    private sealed class GenericService<T> : IGenericService<T>
+    {
+    }
+
+    private sealed class NonInjectedServiceA
+    {
+    }
+
+    private sealed class NonInjectedServiceB
+    {
+        [ActivatorUtilitiesConstructor]
+        public NonInjectedServiceB(NonInjectedServiceA? serviceA)
+        {
+        }
+    }
+}

src/Snap.Hutao/Snap.Hutao.Test/GlobalUsings.cs

@@ -0,0 +1 @@
+global using Microsoft.VisualStudio.TestTools.UnitTesting;

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

@@ -0,0 +1,67 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Snap.Hutao.Test;
+
+[TestClass]
+public class JsonSerializeTest
+{
+    private const string SmapleObjectJson = """
+        {
+            "A" :1
+        }
+        """;
+
+    private const string SmapleEmptyStringObjectJson = """
+        {
+            "A" : ""
+        }
+        """;
+
+    private const string SmapleNumberKeyDictionaryJson = """
+        {
+            "111" : "12",
+            "222" : "34"
+        }
+        """;
+
+    [TestMethod]
+    public void DelegatePropertyCanSerialize()
+    {
+        Sample sample = JsonSerializer.Deserialize<Sample>(SmapleObjectJson)!;
+        Assert.AreEqual(sample.B, 1);
+    }
+
+    [TestMethod]
+    [ExpectedException(typeof(JsonException))]
+    public void EmptyStringCannotSerializeAsNumber()
+    {
+        StringNumberSample sample = JsonSerializer.Deserialize<StringNumberSample>(SmapleEmptyStringObjectJson)!;
+        Assert.AreEqual(sample.A, 0);
+    }
+
+    [TestMethod]
+    public void NumberStringKeyCanSerializeAsKey()
+    {
+        JsonSerializerOptions options = new()
+        {
+            NumberHandling = JsonNumberHandling.AllowReadingFromString,
+        };
+
+        Dictionary<int,string> sample = JsonSerializer.Deserialize<Dictionary<int, string>>(SmapleNumberKeyDictionaryJson, options)!;
+        Assert.AreEqual(sample[111], "12");
+    }
+
+    private sealed class Sample
+    {
+        public int A { get => B; set => B = value; }
+        public int B { get; set; }
+    }
+
+    private sealed class StringNumberSample
+    {
+        [JsonNumberHandling(JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString)]
+        public int A { get; set; }
+    }
+}

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

@@ -0,0 +1,35 @@
+using System;
+
+namespace Snap.Hutao.Test.RuntimeBehavior;
+
+[TestClass]
+public sealed class EnumRuntimeBehaviorTest
+{
+    [TestMethod]
+    [ExpectedException(typeof(ArgumentException))]
+    public void EnumParseCanNotHandleEmptyString()
+    {
+        Enum.Parse<EnumA>(string.Empty);
+    }
+
+    [TestMethod]
+    public void EnumParseCanHandleNumberString()
+    {
+        EnumA a = Enum.Parse<EnumA>("2");
+        Assert.AreEqual(a, EnumA.ValueB);
+    }
+
+    [TestMethod]
+    public void EnumToStringDecimal()
+    {
+        Assert.AreEqual("2", EnumA.ValueB.ToString("D"));
+    }
+
+    private enum EnumA
+    {
+        None = 0,
+        ValueA = 1,
+        ValueB = 2,
+        ValueC = 3,
+    }
+}

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

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+
+namespace Snap.Hutao.Test.RuntimeBehavior;
+
+[TestClass]
+public sealed class ForEachRuntimeBehaviorTest
+{
+    [TestMethod]
+    public void ListOfStringCanEnumerateAsReadOnlySpanOfChar()
+    {
+        List<string> strings = new()
+        {
+            "a", "b", "c"
+        };
+
+        int count = 0;
+        foreach (ReadOnlySpan<char> chars in strings)
+        {
+            Assert.IsTrue(chars.Length == 1);
+            ++count;
+        }
+
+        Assert.AreEqual(3, count);
+    }
+}

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

@@ -0,0 +1,15 @@
+using System;
+
+namespace Snap.Hutao.Test.RuntimeBehavior;
+
+[TestClass]
+public sealed class PropertyRuntimeBehaviorTest
+{
+    [TestMethod]
+    public void GetTwiceOnPropertyResultsNotSame()
+    {
+        Assert.AreNotEqual(UUID, UUID);
+    }
+
+    public static Guid UUID { get => Guid.NewGuid(); }
+}

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

@@ -0,0 +1,17 @@
+using System;
+
+namespace Snap.Hutao.Test.RuntimeBehavior;
+
+[TestClass]
+public sealed class RangeRuntimeBehaviorTest
+{
+    [TestMethod]
+    public void RangeTrimLastOne()
+    {
+        int[] array = { 1, 2, 3, 4 };
+        int[] test = { 1, 2, 3 };
+        int[] result = array[..^1];
+        Assert.AreEqual(3, result.Length);
+        Assert.IsTrue(MemoryExtensions.SequenceEqual<int>(test, result));
+    }
+}

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

@@ -0,0 +1,35 @@
+using System;
+
+namespace Snap.Hutao.Test.RuntimeBehavior;
+
+[TestClass]
+public sealed class StringRuntimeBehaviorTest
+{
+    [TestMethod]
+    public unsafe void NullStringFixedIsNullPointer()
+    {
+        string testStr = null!;
+        fixed (char* pStr = testStr)
+        {
+            Assert.IsTrue(pStr == null);
+        }
+    }
+
+    [TestMethod]
+    public unsafe void EmptyStringFixedIsNullTerminator()
+    {
+        string testStr = string.Empty;
+        fixed (char* pStr = testStr)
+        {
+            Assert.IsTrue(*pStr == '\0');
+        }
+    }
+
+    [TestMethod]
+    public unsafe void EmptyStringAsSpanIsZeroLength()
+    {
+        string testStr = string.Empty;
+        ReadOnlySpan<char> testSpan = testStr;
+        Assert.IsTrue(testSpan.Length == 0);
+    }
+}

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

@@ -0,0 +1,16 @@
+namespace Snap.Hutao.Test.RuntimeBehavior;
+
+[TestClass]
+public sealed class UnsafeRuntimeBehaviorTest
+{
+    [TestMethod]
+    public unsafe void UInt32AllSetIs()
+    {
+        byte[] bytes = { 0xFF, 0xFF, 0xFF, 0xFF, };
+
+        fixed (byte* pBytes = bytes)
+        {
+            Assert.AreEqual(uint.MaxValue, *(uint*)pBytes);
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <Configurations>Debug;Release;Debug As Fake Elevated</Configurations>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.1" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
+    <PackageReference Include="coverlet.collector" Version="6.0.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+</Project>

src/Snap.Hutao/Snap.Hutao.sln

@@ -12,10 +12,14 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 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.Installer", "Snap.Hutao.Installer\Snap.Hutao.Installer.csproj", "{CEC01691-F65E-4874-9AE2-F571369A7631}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Snap.Hutao.Test", "Snap.Hutao.Test\Snap.Hutao.Test.csproj", "{D691BA9F-904C-4229-87A5-E14F2EFF2F64}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug As Fake Elevated|Any CPU = Debug As Fake Elevated|Any CPU
+		Debug As Fake Elevated|arm64 = Debug As Fake Elevated|arm64
+		Debug As Fake Elevated|x64 = Debug As Fake Elevated|x64
+		Debug As Fake Elevated|x86 = Debug As Fake Elevated|x86
 		Debug|Any CPU = Debug|Any CPU
 		Debug|arm64 = Debug|arm64
 		Debug|x64 = Debug|x64
@@ -26,6 +30,18 @@ Global
 		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|Any CPU.ActiveCfg = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|Any CPU.Build.0 = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|Any CPU.Deploy.0 = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|arm64.ActiveCfg = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|arm64.Build.0 = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|arm64.Deploy.0 = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|x64.ActiveCfg = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|x64.Build.0 = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|x64.Deploy.0 = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|x86.ActiveCfg = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|x86.Build.0 = Debug As Fake Elevated|x64
+		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug As Fake Elevated|x86.Deploy.0 = Debug As Fake Elevated|x64
 		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug|Any CPU.ActiveCfg = Debug|x64
 		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug|Any CPU.Build.0 = Debug|x64
 		{AAAB7CF0-F299-49B8-BDB4-4C320B3EC2C7}.Debug|Any CPU.Deploy.0 = Debug|x64
@@ -50,8 +66,16 @@ 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|Any CPU
-		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug As Fake Elevated|Any CPU.ActiveCfg = Debug As Fake Elevated|x64
+		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug As Fake Elevated|Any CPU.Build.0 = Debug As Fake Elevated|x64
+		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug As Fake Elevated|arm64.ActiveCfg = Debug As Fake Elevated|x64
+		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug As Fake Elevated|arm64.Build.0 = Debug As Fake Elevated|x64
+		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug As Fake Elevated|x64.ActiveCfg = Debug As Fake Elevated|x64
+		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug As Fake Elevated|x64.Build.0 = Debug As Fake Elevated|x64
+		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug As Fake Elevated|x86.ActiveCfg = Debug As Fake Elevated|x64
+		{8B96721E-5604-47D2-9B72-06FEBAD0CE00}.Debug As Fake Elevated|x86.Build.0 = Debug As Fake Elevated|x64
+		{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
@@ -66,27 +90,40 @@ Global
 		{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
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Debug|arm64.ActiveCfg = Debug|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Debug|arm64.Build.0 = Debug|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Debug|x64.ActiveCfg = Debug|x64
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Debug|x64.Build.0 = Debug|x64
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Debug|x86.Build.0 = Debug|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Release|Any CPU.Build.0 = Release|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Release|arm64.ActiveCfg = Release|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Release|arm64.Build.0 = Release|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Release|x64.ActiveCfg = Release|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Release|x64.Build.0 = Release|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Release|x86.ActiveCfg = Release|Any CPU
-		{CEC01691-F65E-4874-9AE2-F571369A7631}.Release|x86.Build.0 = Release|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug As Fake Elevated|Any CPU.ActiveCfg = Debug As Fake Elevated|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug As Fake Elevated|Any CPU.Build.0 = Debug As Fake Elevated|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug As Fake Elevated|arm64.ActiveCfg = Debug As Fake Elevated|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug As Fake Elevated|arm64.Build.0 = Debug As Fake Elevated|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug As Fake Elevated|x64.ActiveCfg = Debug As Fake Elevated|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug As Fake Elevated|x64.Build.0 = Debug As Fake Elevated|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug As Fake Elevated|x86.ActiveCfg = Debug As Fake Elevated|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug As Fake Elevated|x86.Build.0 = Debug As Fake Elevated|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
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug|arm64.Build.0 = Debug|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug|x64.Build.0 = Debug|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Debug|x86.Build.0 = Debug|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Release|arm64.ActiveCfg = Release|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Release|arm64.Build.0 = Release|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Release|x64.ActiveCfg = Release|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Release|x64.Build.0 = Release|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Release|x86.ActiveCfg = Release|Any CPU
+		{D691BA9F-904C-4229-87A5-E14F2EFF2F64}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
+		RESX_Rules = {"EnabledRules":["StringFormat","WhiteSpaceLead","WhiteSpaceTail","PunctuationLead"]}
+		RESX_ShowErrorsInErrorList = False
+		RESX_SortFileContentOnSave = True
 		SolutionGuid = {E4449B1C-0E6A-4D19-955E-1CA491656ABA}
+		RESX_NeutralResourcesLanguage = zh-CN
+		RESX_AutoApplyExistingTranslations = False
 	EndGlobalSection
 EndGlobal

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

@@ -9,7 +9,7 @@
       },
       "pathSegment": {
         "add": {
-          ".*": [ ".cs" ]
+          ".*": [ ".cs", ".resx" ]
         }
       },
       "fileSuffixToExtension": {
@@ -19,11 +19,12 @@
       },
       "fileToFile": {
         "add": {
+          ".filenesting.json": [ "App.xaml.cs" ],
           "app.manifest": [ "App.xaml.cs" ],
-          "Package.appxmanifest": [ "App.xaml.cs" ],
-          "GlobalUsing.cs": [ "Program.cs" ],
-          ".filenesting.json": [ "Program.cs" ],
-          ".editorconfig": [ "Program.cs" ]
+          "Package.appxmanifest": [ "App.xaml" ],
+          "Package.StoreAssociation.xml": [ "App.xaml" ],
+          ".editorconfig": [ "Program.cs" ],
+          "GlobalUsing.cs": [ "Program.cs" ]
         }
       }
     }

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

@@ -2,15 +2,16 @@
     x:Class="Snap.Hutao.App"
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:cwcw="using:CommunityToolkit.WinUI.Controls"
     xmlns:cwuc="using:CommunityToolkit.WinUI.UI.Converters"
     xmlns:muxc="using:Microsoft.UI.Xaml.Controls"
+    xmlns:shci="using:Snap.Hutao.Control.Image"
     xmlns:shmmc="using:Snap.Hutao.Model.Metadata.Converter"
     xmlns:shvc="using:Snap.Hutao.View.Converter">
     <Application.Resources>
         <ResourceDictionary>
             <ResourceDictionary.MergedDictionaries>
                 <muxc:XamlControlsResources/>
-                <ResourceDictionary Source="ms-appx:///SettingsUI/Themes/Generic.xaml"/>
                 <ResourceDictionary Source="Control/Theme/FontStyle.xaml"/>
             </ResourceDictionary.MergedDictionaries>
 
@@ -30,8 +31,9 @@
             <!--  Page Transparent Background  -->
             <StaticResource x:Key="ApplicationPageBackgroundThemeBrush" ResourceKey="ControlFillColorTransparentBrush"/>
             <!--  InfoBar Resource  -->
-            <Thickness x:Key="InfoBarIconMargin">6,16,16,16</Thickness>
-            <Thickness x:Key="InfoBarContentRootPadding">16,0,0,0</Thickness>
+            <Thickness x:Key="InfoBarIconMargin">19,16,19,16</Thickness>
+            <Thickness x:Key="InfoBarContentRootPadding">0,0,0,0</Thickness>
+            <x:Double x:Key="InfoBarIconFontSize">20</x:Double>
             <!--  Pivot Resource  -->
             <x:Double x:Key="PivotHeaderItemFontSize">16</x:Double>
             <Thickness x:Key="PivotHeaderItemMargin">16,0,0,0</Thickness>
@@ -42,18 +44,60 @@
             <CornerRadius x:Key="CompatCornerRadiusRight">0,6,6,0</CornerRadius>
             <CornerRadius x:Key="CompatCornerRadiusBottom">0,0,6,6</CornerRadius>
             <CornerRadius x:Key="CompatCornerRadiusSmall">2</CornerRadius>
-            <!--  OpenPaneLength  -->
+            <!--  Length  -->
+            <GridLength x:Key="CompatGridLength2">288</GridLength>
             <x:Double x:Key="CompatSplitViewOpenPaneLength">212</x:Double>
-            <x:Double x:Key="CompatSplitViewOpenPaneLength2">268</x:Double>
-            <GridLength x:Key="CompatGridLength2">268</GridLength>
+            <x:Double x:Key="CompatSplitViewOpenPaneLength2">304</x:Double>
+            <x:Double x:Key="CompatSplitViewOpenPaneLength3">320</x:Double>
+            <x:Double x:Key="HomeAdaptiveCardHeight">180</x:Double>
+            <x:Double x:Key="ContentDialogMinHeight">64</x:Double>
+            <x:Double x:Key="LargeAppBarButtonWidth">100</x:Double>
+            <!--  ProgressBar  -->
+            <x:Double x:Key="LargeBackgroundProgressBarOpacity">0.2</x:Double>
+
             <!--  Brushes  -->
             <SolidColorBrush x:Key="AvatarPropertyAddValueBrush" Color="{ThemeResource AvatarPropertyAddValueColor}"/>
+            <SolidColorBrush x:Key="BlueBrush" Color="#FF5180CB"/>
+            <SolidColorBrush x:Key="PurpleBrush" Color="#FFA156E0"/>
+            <SolidColorBrush x:Key="OrangeBrush" Color="#FFBC6932"/>
+            <SolidColorBrush x:Key="GuaranteePullBrush" Color="#FF0063FF"/>
+            <SolidColorBrush x:Key="UpPullBrush" Color="#FFFFA400"/>
+            <!--  Settings  -->
+            <x:Double x:Key="SettingsCardSpacing">3</x:Double>
+            <x:Double x:Key="SettingsCardMinHeight">0</x:Double>
+            <x:Double x:Key="SettingsCardWrapThreshold">0</x:Double>
+            <x:Double x:Key="SettingsCardWrapNoIconThreshold">0</x:Double>
+            <Style
+                x:Key="SettingsSectionHeaderTextBlockStyle"
+                BasedOn="{StaticResource BodyStrongTextBlockStyle}"
+                TargetType="TextBlock">
+                <Style.Setters>
+                    <Setter Property="Margin" Value="1,29,0,5"/>
+                </Style.Setters>
+            </Style>
+            <Style
+                x:Key="SettingsContentComboBoxStyle"
+                BasedOn="{StaticResource DefaultComboBoxStyle}"
+                TargetType="ComboBox">
+                <Setter Property="MinWidth" Value="120"/>
+            </Style>
             <!--  Uris  -->
-            <x:String x:Key="DocumentLink_MhyAccountSwitch">https://hut.ao/features/mhy-account-switch.html#%E5%A6%82%E4%BD%95%E8%8E%B7%E5%8F%96-cookie</x:String>
+            <x:String x:Key="DocumentLink_MhyAccountSwitch">https://hut.ao/features/mhy-account-switch.html</x:String>
             <x:String x:Key="DocumentLink_BugReport">https://hut.ao/statements/bug-report.html</x:String>
+            <x:String x:Key="DocumentLink_Translate">https://translate.hut.ao</x:String>
+            <x:String x:Key="DocumentLink_Home">https://hut.ao</x:String>
             <x:String x:Key="HolographicHat_GetToken_Release">https://github.com/HolographicHat/GetToken/releases/latest</x:String>
+            <x:String x:Key="Sponsor_Afadian">https://afdian.net/a/DismissedLight</x:String>
 
+            <!--  Images  -->
             <x:String x:Key="UI_ItemIcon_None">https://static.snapgenshin.com/Bg/UI_ItemIcon_None.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://static.snapgenshin.com/Bg/UI_Icon_Intee_Explore_1.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_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_ImgSign_ItemIcon">https://static.snapgenshin.com/Bg/UI_ImgSign_ItemIcon.png</x:String>
             <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_EmotionIcon25">https://static.snapgenshin.com/EmotionIcon/UI_EmotionIcon25.png</x:String>
@@ -61,15 +105,26 @@
             <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>
+
+            <!--  FontIcon Content  -->
+            <x:String x:Key="FontIconContentAdd">&#xE710;</x:String>
+            <x:String x:Key="FontIconContentSetting">&#xE713;</x:String>
+            <x:String x:Key="FontIconContentRefresh">&#xE72C;</x:String>
+            <x:String x:Key="FontIconContentDelete">&#xE74D;</x:String>
+            <x:String x:Key="FontIconContentFolder">&#xE8B7;</x:String>
+            <x:String x:Key="FontIconContentCheckList">&#xE9D5;</x:String>
+            <x:String x:Key="FontIconContentAsteriskBadge12">&#xEDAD;</x:String>
+            <x:String x:Key="FontIconContentZipFolder">&#xF012;</x:String>
             <!--  Converters  -->
             <cwuc:BoolNegationConverter x:Key="BoolNegationConverter"/>
             <cwuc:BoolToVisibilityConverter x:Key="BoolToVisibilityConverter"/>
+            <cwuc:FileSizeToFriendlyStringConverter x:Key="FileSizeToFriendlyStringConverter"/>
             <shmmc:AchievementIconConverter x:Key="AchievementIconConverter"/>
             <shmmc:AvatarCardConverter x:Key="AvatarCardConverter"/>
             <shmmc:AvatarIconConverter x:Key="AvatarIconConverter"/>
             <shmmc:AvatarNameCardPicConverter x:Key="AvatarNameCardPicConverter"/>
             <shmmc:AvatarSideIconConverter x:Key="AvatarSideIconConverter"/>
-            <shmmc:DescParamDescriptor x:Key="DescParamDescriptor"/>
+            <shmmc:DescriptionsParametersDescriptor x:Key="DescParamDescriptor"/>
             <shmmc:ElementNameIconConverter x:Key="ElementNameIconConverter"/>
             <shmmc:EmotionIconConverter x:Key="EmotionIconConverter"/>
             <shmmc:EquipIconConverter x:Key="EquipIconConverter"/>
@@ -77,7 +132,8 @@
             <shmmc:GachaAvatarIconConverter x:Key="GachaAvatarIconConverter"/>
             <shmmc:GachaEquipIconConverter x:Key="GachaEquipIconConverter"/>
             <shmmc:ItemIconConverter x:Key="ItemIconConverter"/>
-            <shmmc:PropertyInfoDescriptor x:Key="PropertyDescriptor"/>
+            <shmmc:MonsterIconConverter x:Key="MonsterIconConverter"/>
+            <shmmc:PropertiesParametersDescriptor x:Key="PropertyDescriptor"/>
             <shmmc:QualityColorConverter x:Key="QualityColorConverter"/>
             <shmmc:WeaponTypeIconConverter x:Key="WeaponTypeIconConverter"/>
             <shvc:BoolToVisibilityRevertConverter x:Key="BoolToVisibilityRevertConverter"/>
@@ -87,8 +143,9 @@
             <shvc:EmptyObjectToVisibilityRevertConverter x:Key="EmptyObjectToVisibilityRevertConverter"/>
             <shvc:Int32ToVisibilityConverter x:Key="Int32ToVisibilityConverter"/>
             <shvc:Int32ToVisibilityRevertConverter x:Key="Int32ToVisibilityRevertConverter"/>
-            <!--  Styles  -->
+            <shvc:StringBoolConverter x:Key="StringBoolConverter"/>
 
+            <!--  Styles  -->
             <Style
                 x:Key="LargeGridViewItemStyle"
                 BasedOn="{StaticResource DefaultGridViewItemStyle}"
@@ -111,13 +168,103 @@
                 <Setter Property="BorderThickness" Value="1"/>
                 <Setter Property="CornerRadius" Value="{StaticResource CompatCornerRadius}"/>
             </Style>
+            <Style x:Key="BorderGridStyle" TargetType="Grid">
+                <Setter Property="Background" Value="{ThemeResource CardBackgroundFillColorDefaultBrush}"/>
+                <Setter Property="BorderBrush" Value="{ThemeResource CardStrokeColorDefaultBrush}"/>
+                <Setter Property="BorderThickness" Value="1"/>
+                <Setter Property="CornerRadius" Value="{StaticResource CompatCornerRadius}"/>
+            </Style>
+            <Style TargetType="shci:CachedImage">
+                <Setter Property="Background" Value="Transparent"/>
+                <Setter Property="Foreground" Value="{ThemeResource ApplicationForegroundThemeBrush}"/>
+                <Setter Property="IsTabStop" Value="False"/>
+                <Setter Property="LazyLoadingThreshold" Value="300"/>
+                <Setter Property="Template">
+                    <Setter.Value>
+                        <ControlTemplate TargetType="shci:CachedImage">
+                            <Grid
+                                Background="{TemplateBinding Background}"
+                                BorderBrush="{TemplateBinding BorderBrush}"
+                                BorderThickness="{TemplateBinding BorderThickness}"
+                                CornerRadius="{TemplateBinding CornerRadius}">
+                                <Image
+                                    Name="PlaceholderImage"
+                                    HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
+                                    VerticalAlignment="{TemplateBinding VerticalAlignment}"
+                                    Opacity="1.0"
+                                    Source="{TemplateBinding PlaceholderSource}"
+                                    Stretch="{TemplateBinding PlaceholderStretch}"/>
+                                <Image
+                                    Name="Image"
+                                    HorizontalAlignment="{TemplateBinding HorizontalAlignment}"
+                                    VerticalAlignment="{TemplateBinding VerticalAlignment}"
+                                    NineGrid="{TemplateBinding NineGrid}"
+                                    Opacity="0.0"
+                                    Stretch="{TemplateBinding Stretch}"/>
+                                <VisualStateManager.VisualStateGroups>
+                                    <VisualStateGroup x:Name="CommonStates">
+                                        <VisualState x:Name="Failed">
+                                            <Storyboard>
+                                                <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Image" Storyboard.TargetProperty="Opacity">
+                                                    <DiscreteObjectKeyFrame KeyTime="0" Value="0"/>
+                                                </ObjectAnimationUsingKeyFrames>
+                                                <ObjectAnimationUsingKeyFrames Storyboard.TargetName="PlaceholderImage" Storyboard.TargetProperty="Opacity">
+                                                    <DiscreteObjectKeyFrame KeyTime="0" Value="1"/>
+                                                </ObjectAnimationUsingKeyFrames>
+                                            </Storyboard>
+                                        </VisualState>
+                                        <VisualState x:Name="Loading">
+                                            <Storyboard>
+                                                <ObjectAnimationUsingKeyFrames Storyboard.TargetName="Image" Storyboard.TargetProperty="Opacity">
+                                                    <DiscreteObjectKeyFrame KeyTime="0" Value="0"/>
+                                                </ObjectAnimationUsingKeyFrames>
+                                                <ObjectAnimationUsingKeyFrames Storyboard.TargetName="PlaceholderImage" Storyboard.TargetProperty="Opacity">
+                                                    <DiscreteObjectKeyFrame KeyTime="0" Value="1"/>
+                                                </ObjectAnimationUsingKeyFrames>
+                                            </Storyboard>
+                                        </VisualState>
+                                        <VisualState x:Name="Loaded">
+                                            <Storyboard>
+                                                <DoubleAnimation
+                                                    AutoReverse="False"
+                                                    BeginTime="0"
+                                                    Storyboard.TargetName="Image"
+                                                    Storyboard.TargetProperty="Opacity"
+                                                    From="0"
+                                                    To="1"
+                                                    Duration="0:0:0.5"/>
+                                                <DoubleAnimation
+                                                    AutoReverse="False"
+                                                    BeginTime="0"
+                                                    Storyboard.TargetName="PlaceholderImage"
+                                                    Storyboard.TargetProperty="Opacity"
+                                                    From="1"
+                                                    To="0"
+                                                    Duration="0:0:0.5"/>
+                                            </Storyboard>
+                                        </VisualState>
+                                        <VisualState x:Name="Unloaded"/>
+                                    </VisualStateGroup>
+                                </VisualStateManager.VisualStateGroups>
+                            </Grid>
+                        </ControlTemplate>
+                    </Setter.Value>
+                </Setter>
+            </Style>
             <!--  ItemsPanelTemplate  -->
             <ItemsPanelTemplate x:Key="ItemsStackPanelTemplate">
                 <ItemsStackPanel/>
             </ItemsPanelTemplate>
+            <ItemsPanelTemplate x:Key="WrapPanelTemplate">
+                <cwcw:WrapPanel/>
+            </ItemsPanelTemplate>
             <ItemsPanelTemplate x:Key="HorizontalStackPanelTemplate">
                 <StackPanel Orientation="Horizontal"/>
             </ItemsPanelTemplate>
+            <!--  Transitions  -->
+            <TransitionCollection x:Key="ReorderThemeTransitions">
+                <ReorderThemeTransition/>
+            </TransitionCollection>
         </ResourceDictionary>
     </Application.Resources>
-</Application>
+</Application>

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

@@ -1,38 +1,44 @@
 // Copyright (c) DGP Studio. All rights reserved.
 // Licensed under the MIT license.
 
-using CommunityToolkit.WinUI.Notifications;
 using Microsoft.UI.Xaml;
 using Microsoft.Windows.AppLifecycle;
 using Snap.Hutao.Core;
 using Snap.Hutao.Core.ExceptionService;
 using Snap.Hutao.Core.LifeCycle;
-using Snap.Hutao.Core.Logging;
+using Snap.Hutao.Core.Shell;
 using System.Diagnostics;
-using Windows.Storage;
 
 namespace Snap.Hutao;
 
 /// <summary>
 /// Provides application-specific behavior to supplement the default Application class.
+/// This class must be public
 /// </summary>
+[HighQuality]
 [Injection(InjectAs.Singleton)]
-public partial class App : Application
+[SuppressMessage("", "SH001")]
+public sealed partial class App : Application
 {
+    private const string AppInstanceKey = "main";
+    private readonly IServiceProvider serviceProvider;
+    private readonly IActivation activation;
     private readonly ILogger<App> logger;
 
     /// <summary>
     /// Initializes the singleton application object.
     /// </summary>
-    /// <param name="logger">日志器</param>
-    /// <param name="appCenter">App Center</param>
-    public App(ILogger<App> logger)
+    /// <param name="serviceProvider">服务提供器</param>
+    public App(IServiceProvider serviceProvider)
     {
-        // load app resource
+        // Load app resource
         InitializeComponent();
-        this.logger = logger;
 
-        _ = new ExceptionRecorder(this, logger);
+        activation = serviceProvider.GetRequiredService<IActivation>();
+        logger = serviceProvider.GetRequiredService<ILogger<App>>();
+        serviceProvider.GetRequiredService<ExceptionRecorder>().Record(this);
+
+        this.serviceProvider = serviceProvider;
     }
 
     /// <inheritdoc/>
@@ -41,19 +47,16 @@ public partial class App : Application
         try
         {
             AppActivationArguments activatedEventArgs = AppInstance.GetCurrent().GetActivatedEventArgs();
-            AppInstance firstInstance = AppInstance.FindOrRegisterForKey("main");
+            AppInstance firstInstance = AppInstance.FindOrRegisterForKey(AppInstanceKey);
 
             if (firstInstance.IsCurrent)
             {
                 // manually invoke
-                Activation.NonRedirectToActivate(firstInstance, activatedEventArgs);
-                firstInstance.Activated += Activation.Activate;
-                ToastNotificationManagerCompat.OnActivated += Activation.NotificationActivate;
+                activation.NonRedirectToActivate(firstInstance, activatedEventArgs);
+                activation.InitializeWith(firstInstance);
 
-                logger.LogInformation(EventIds.CommonLog, "Snap Hutao | {name} : {version}", CoreEnvironment.FamilyName, CoreEnvironment.Version);
-                logger.LogInformation(EventIds.CommonLog, "Cache folder : {folder}", ApplicationData.Current.LocalCacheFolder.Path);
-
-                JumpListHelper.ConfigureAsync().SafeForget(logger);
+                LogDiagnosticInformation();
+                serviceProvider.GetRequiredService<IJumpListInterop>().ConfigureAsync().SafeForget();
             }
             else
             {
@@ -62,10 +65,19 @@ public partial class App : Application
                 Process.GetCurrentProcess().Kill();
             }
         }
-        catch (Exception)
+        catch
         {
             // AppInstance.GetCurrent() calls failed
             Process.GetCurrentProcess().Kill();
         }
     }
+
+    private void LogDiagnosticInformation()
+    {
+        RuntimeOptions hutaoOptions = serviceProvider.GetRequiredService<RuntimeOptions>();
+
+        logger.LogInformation("FamilyName: {name}", hutaoOptions.FamilyName);
+        logger.LogInformation("Version: {version}", hutaoOptions.Version);
+        logger.LogInformation("LocalCache: {folder}", hutaoOptions.LocalCache);
+    }
 }

src/Snap.Hutao/Snap.Hutao/AppResourceProvider.cs

@@ -0,0 +1,28 @@
+// Copyright (c) DGP Studio. All rights reserved.
+// Licensed under the MIT license.
+
+namespace Snap.Hutao;
+
+/// <summary>
+/// 应用程序资源提供器
+/// </summary>
+[Injection(InjectAs.Transient, typeof(IAppResourceProvider))]
+internal sealed class AppResourceProvider : IAppResourceProvider
+{
+    private readonly App app;
+
+    /// <summary>
+    /// 构造一个新的应用程序资源提供器
+    /// </summary>
+    /// <param name="app">应用</param>
+    public AppResourceProvider(App app)
+    {
+        this.app = app;
+    }
+
+    /// <inheritdoc/>
+    public T GetResource<T>(string name)
+    {
+        return (T)app.Resources[name];
+    }
+}