diff --git a/29WxOrder.sln b/29WxOrder.sln
index cbb0fa1..2b5b26e 100644
--- a/29WxOrder.sln
+++ b/29WxOrder.sln
@@ -17,6 +17,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_SolutionItems", "_Solution
 	ProjectSection(SolutionItems) = preProject
 		.editorconfig = .editorconfig
 		.gitignore = .gitignore
+		Directory.Build.props = Directory.Build.props
 	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WxOrder.Framework", "WxOrder.Framework\WxOrder.Framework.csproj", "{3123963C-A0EC-4AD5-9916-DC063F73490B}"
@@ -25,6 +26,16 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".test", ".test", "{14261B9B
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WXOrder.Test", "test\WXOrder.Test\WXOrder.Test.csproj", "{3790EC79-EA1D-4660-AB0D-EA0DE4FF77B7}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Trade.Client", "Source\Trade.Client\Trade.Client.csproj", "{BCABF48D-183D-A66F-33B6-B865CC0AD623}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MAX.Core", "Source\MAX.Core\MAX.Core.csproj", "{313C8137-00DA-4116-B3B4-68FC45CC0CE7}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Trade.Framework", "Source\Trade.Framework\Trade.Framework.csproj", "{0180FDFA-6984-462D-B406-65B460CDB47A}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Main.Test", "Main.Test\Main.Test.csproj", "{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MAX.Framework", "Source\MAX.Framework\MAX.Framework.csproj", "{EABFACFE-C74D-4111-9683-C6E7714F432D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -117,6 +128,86 @@ Global
 		{3790EC79-EA1D-4660-AB0D-EA0DE4FF77B7}.Release|x64.Build.0 = Release|Any CPU
 		{3790EC79-EA1D-4660-AB0D-EA0DE4FF77B7}.Release|x86.ActiveCfg = Release|Any CPU
 		{3790EC79-EA1D-4660-AB0D-EA0DE4FF77B7}.Release|x86.Build.0 = Release|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Debug|x64.Build.0 = Debug|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Debug|x86.Build.0 = Debug|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Release|x64.ActiveCfg = Release|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Release|x64.Build.0 = Release|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Release|x86.ActiveCfg = Release|Any CPU
+		{BCABF48D-183D-A66F-33B6-B865CC0AD623}.Release|x86.Build.0 = Release|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Debug|x64.Build.0 = Debug|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Debug|x86.Build.0 = Debug|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Release|x64.ActiveCfg = Release|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Release|x64.Build.0 = Release|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Release|x86.ActiveCfg = Release|Any CPU
+		{313C8137-00DA-4116-B3B4-68FC45CC0CE7}.Release|x86.Build.0 = Release|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Debug|x64.Build.0 = Debug|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Debug|x86.Build.0 = Debug|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Release|x64.ActiveCfg = Release|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Release|x64.Build.0 = Release|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Release|x86.ActiveCfg = Release|Any CPU
+		{0180FDFA-6984-462D-B406-65B460CDB47A}.Release|x86.Build.0 = Release|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Debug|x64.Build.0 = Debug|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Debug|x86.Build.0 = Debug|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Release|x64.ActiveCfg = Release|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Release|x64.Build.0 = Release|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Release|x86.ActiveCfg = Release|Any CPU
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF}.Release|x86.Build.0 = Release|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Debug|x64.Build.0 = Debug|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Debug|x86.Build.0 = Debug|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Release|x64.ActiveCfg = Release|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Release|x64.Build.0 = Release|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Release|x86.ActiveCfg = Release|Any CPU
+		{EABFACFE-C74D-4111-9683-C6E7714F432D}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -126,6 +217,7 @@ Global
 		{1AD45D66-6872-4522-ACF0-04E2C0514048} = {4A54DC2A-B47C-4ED1-A482-EE60161DB2C3}
 		{5A410EB5-06AD-97BB-2314-9D7A808E12F7} = {1A7830FA-AC8F-40FB-A232-F0626812B8BE}
 		{3790EC79-EA1D-4660-AB0D-EA0DE4FF77B7} = {14261B9B-E3EA-4BC0-B08D-4B3591AC13E5}
+		{890E871A-F6E7-42DA-85D5-3BF2F8ECAEDF} = {14261B9B-E3EA-4BC0-B08D-4B3591AC13E5}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {38687A61-0347-49AC-98C7-E7F7148C0234}
diff --git a/Directory.Build.props b/Directory.Build.props
new file mode 100644
index 0000000..b60289c
--- /dev/null
+++ b/Directory.Build.props
@@ -0,0 +1,24 @@
+<Project>
+
+	<!-- See https://aka.ms/dotnet/msbuild/customize for more details on customizing your build -->
+	<PropertyGroup>
+		<DefaultTargetFramework>net8.0</DefaultTargetFramework>
+		<TargetFramework>$(DefaultTargetFramework)</TargetFramework>
+		<LangVersion>12.0</LangVersion>
+		<SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+		<CheckEolTargetFramework>false</CheckEolTargetFramework>
+		<SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
+		<Nullable>annotations</Nullable>
+		<NoWarn>CS1591</NoWarn>
+		<ImplicitUsings>enable</ImplicitUsings>
+	</PropertyGroup>
+
+
+	<ItemGroup>
+		<PackageReference Include="PolySharp" Version="1.16.0">
+			<PrivateAssets>all</PrivateAssets>
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+		</PackageReference>
+	</ItemGroup>
+
+</Project>
diff --git a/Main.Test/App.xaml b/Main.Test/App.xaml
new file mode 100644
index 0000000..543a120
--- /dev/null
+++ b/Main.Test/App.xaml
@@ -0,0 +1,8 @@
+<tf:FrameworkApplication
+	x:Class="Main.Test.App"
+	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+	xmlns:local="clr-namespace:Main.Test"
+	xmlns:tf="Trade.Framework">
+	<Application.Resources />
+</tf:FrameworkApplication>
\ No newline at end of file
diff --git a/Main.Test/App.xaml.cs b/Main.Test/App.xaml.cs
new file mode 100644
index 0000000..91ae68a
--- /dev/null
+++ b/Main.Test/App.xaml.cs
@@ -0,0 +1,57 @@
+using Main.Test.ViewModels;
+using Main.Test.Views;
+using MAX.Core.DependencyInjection;
+using MAX.Core.Logger;
+using Prism.Ioc;
+using Prism.Modularity;
+using Prism.Mvvm;
+using System.Configuration;
+using System.Data;
+using System.Windows;
+using Trade.Framework;
+using Trade.Framework.Extensions;
+using Trade.Framework.Services;
+
+namespace Main.Test;
+/// <summary>
+/// Interaction logic for App.xaml
+/// </summary>
+public partial class App : FrameworkApplication
+{
+	public IScopedProvider CurrentScope => throw new NotImplementedException();
+
+	protected override void OnStartup(StartupEventArgs e)
+	{
+		base.OnStartup(e);
+
+	}
+	protected override Window CreateShell()
+	{
+		return Container.Resolve<MainWindow>();
+	}
+
+	protected override void RegisterTypes(IContainerRegistry containerRegistry)
+	{
+		// 严格模式：FrameworkApplication 已关闭 DryIoc 按需动态注册（WithConcreteTypeDynamicRegistrations），
+		// 所有被解析的类型必须显式注册，否则抛 ContainerException。
+
+		// 启动 Shell
+		containerRegistry.Register<MainWindow>();
+
+		// 窗口/控件 ViewModel（DISource 从容器解析）
+		containerRegistry.Register<MainViewModel>();
+		containerRegistry.Register<HeaderViewModel>();
+
+		// 对话框：RegisterDialog 只注册 View 本身，VM 由 ViewModelLocator 从容器解析，需单独注册
+		containerRegistry.RegisterDialog<bbbDialogView, bbbDialogViewModel>(nameof(bbbDialogView));
+		containerRegistry.Register<bbbDialogViewModel>();
+
+		// 服务：原先靠 DryIoc 动态注册（Transient），显式注册保持同样行为
+		//containerRegistry.Register<UserManager>();
+		// 若希望 UserManager 全局只实例化一次：
+		// containerRegistry.RegisterSingleton<UserManager>();
+
+		//containerRegistry.RegisterSingleton<ILoggerFacade, ConsoleLogger>();
+	}
+
+}
diff --git a/Main.Test/AssemblyInfo.cs b/Main.Test/AssemblyInfo.cs
new file mode 100644
index 0000000..d9a1bde
--- /dev/null
+++ b/Main.Test/AssemblyInfo.cs
@@ -0,0 +1,10 @@
+using System.Windows;
+
+[assembly: ThemeInfo(
+	ResourceDictionaryLocation.None,            //where theme specific resource dictionaries are located
+												//(used if a resource is not found in the page,
+												// or application resource dictionaries)
+	ResourceDictionaryLocation.SourceAssembly   //where the generic resource dictionary is located
+												//(used if a resource is not found in the page,
+												// app, or any theme specific resource dictionaries)
+)]
diff --git a/Main.Test/Main.Test.csproj b/Main.Test/Main.Test.csproj
new file mode 100644
index 0000000..a6124fb
--- /dev/null
+++ b/Main.Test/Main.Test.csproj
@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<OutputType>WinExe</OutputType>
+		<TargetFramework>$(DefaultTargetFramework)-windows</TargetFramework>
+		<Nullable>enable</Nullable>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<UseWPF>true</UseWPF>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\Source\Trade.Framework\Trade.Framework.csproj" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<None Update="Views\bbbDialogView.xaml">
+			<Generator>MSBuild:Compile</Generator>
+		</None>
+		<None Update="Views\HeaderView.xaml">
+			<Generator>MSBuild:Compile</Generator>
+		</None>
+	</ItemGroup>
+
+</Project>
diff --git a/Main.Test/MainWindow.xaml b/Main.Test/MainWindow.xaml
new file mode 100644
index 0000000..54af584
--- /dev/null
+++ b/Main.Test/MainWindow.xaml
@@ -0,0 +1,19 @@
+<Window
+	x:Class="Main.Test.MainWindow"
+	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+	xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+	xmlns:local="clr-namespace:Main.Test"
+	xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+	xmlns:views="clr-namespace:Main.Test.Views"
+	Title="MainWindow"
+	xmlns:tf="Trade.Framework"
+	xmlns:vm="clr-namespace:Main.Test.ViewModels"
+	Width="800"
+	Height="450"
+	DataContext="{tf:DISource Type=vm:MainViewModel}"
+	mc:Ignorable="d">
+	<Grid>
+		<views:HeaderView />
+	</Grid>
+</Window>
diff --git a/Main.Test/MainWindow.xaml.cs b/Main.Test/MainWindow.xaml.cs
new file mode 100644
index 0000000..7e781b9
--- /dev/null
+++ b/Main.Test/MainWindow.xaml.cs
@@ -0,0 +1,22 @@
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace Main.Test;
+/// <summary>
+/// Interaction logic for MainWindow.xaml
+/// </summary>
+public partial class MainWindow : Window
+{
+	public MainWindow()
+	{
+		InitializeComponent();
+	}
+}
\ No newline at end of file
diff --git a/Main.Test/ViewModels/HeaderViewModel.cs b/Main.Test/ViewModels/HeaderViewModel.cs
new file mode 100644
index 0000000..5e66fd0
--- /dev/null
+++ b/Main.Test/ViewModels/HeaderViewModel.cs
@@ -0,0 +1,30 @@
+using CommunityToolkit.Mvvm.Input;
+using Main.Test.Views;
+using Prism.Commands;
+using Prism.Services.Dialogs;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace Main.Test.ViewModels;
+
+internal class HeaderViewModel
+{
+	private readonly IDialogService _dialogService;
+
+	public HeaderViewModel(IDialogService dialogService)
+	{
+		_dialogService = dialogService;
+	}
+	//public ICommand ccCommand => new AsyncDelegateCommand(cc);
+
+
+	[RelayCommand]
+	private async Task cc()
+	{
+		_dialogService.ShowDialog(nameof(bbbDialogView));
+	}
+}
diff --git a/Main.Test/ViewModels/MainViewModel.cs b/Main.Test/ViewModels/MainViewModel.cs
new file mode 100644
index 0000000..eacab68
--- /dev/null
+++ b/Main.Test/ViewModels/MainViewModel.cs
@@ -0,0 +1,20 @@
+using MAX.Core.Logger;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Trade.Framework.Services;
+
+namespace Main.Test.ViewModels;
+
+internal class MainViewModel
+{
+	private readonly ILoggerFacade _logger;
+
+	public MainViewModel(ILoggerFacade logger, UserManager userManager)
+	{
+		_logger = logger;
+		_logger.Info("123123");
+	}
+}
diff --git a/Main.Test/Views/HeaderView.xaml b/Main.Test/Views/HeaderView.xaml
new file mode 100644
index 0000000..43d13e7
--- /dev/null
+++ b/Main.Test/Views/HeaderView.xaml
@@ -0,0 +1,16 @@
+<UserControl
+	x:Class="Main.Test.Views.HeaderView"
+	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+	xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+	xmlns:local="clr-namespace:Main.Test.Views"
+	xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+	xmlns:tf="Trade.Framework"
+	xmlns:vm="clr-namespace:Main.Test.ViewModels"
+	d:DesignHeight="450"
+	d:DesignWidth="800" DataContext="{tf:DISource Type=vm:HeaderViewModel}"
+	mc:Ignorable="d"> 
+	<Grid>
+		<Button Command="{Binding ccCommand}" Content="abc" />
+	</Grid>
+</UserControl>
diff --git a/Main.Test/Views/HeaderView.xaml.cs b/Main.Test/Views/HeaderView.xaml.cs
new file mode 100644
index 0000000..37565d7
--- /dev/null
+++ b/Main.Test/Views/HeaderView.xaml.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace Main.Test.Views;
+
+/// <summary>
+/// HeaderView.xaml 的交互逻辑
+/// </summary>
+public partial class HeaderView : UserControl
+{
+	public HeaderView()
+	{
+		InitializeComponent();
+	}
+}
diff --git a/Main.Test/Views/bbbDialogView.xaml b/Main.Test/Views/bbbDialogView.xaml
new file mode 100644
index 0000000..bd2b35e
--- /dev/null
+++ b/Main.Test/Views/bbbDialogView.xaml
@@ -0,0 +1,12 @@
+<UserControl x:Class="Main.Test.Views.bbbDialogView"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:local="clr-namespace:Main.Test.Views"
+             mc:Ignorable="d" 
+             d:DesignHeight="450" d:DesignWidth="800">
+    <Grid>
+            
+    </Grid>
+</UserControl>
diff --git a/Main.Test/Views/bbbDialogView.xaml.cs b/Main.Test/Views/bbbDialogView.xaml.cs
new file mode 100644
index 0000000..bf5d5b6
--- /dev/null
+++ b/Main.Test/Views/bbbDialogView.xaml.cs
@@ -0,0 +1,57 @@
+using Prism.Services.Dialogs;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using Trade.Framework.Services;
+
+namespace Main.Test.Views;
+
+/// <summary>
+/// bbbDialogView.xaml 的交互逻辑
+/// </summary>
+public partial class bbbDialogView : UserControl
+{
+	public bbbDialogView()
+	{
+		InitializeComponent();
+	}
+}
+public class bbbDialogViewModel : IDialogAware
+{
+	private readonly IUserManager _user;
+
+	public bbbDialogViewModel(IUserManager user)
+	{
+		_user = user;
+	}
+	public string Title => "ttt";
+
+	public event Action<IDialogResult> RequestClose;
+
+	public bool CanCloseDialog()
+	{
+
+		return true;
+	}
+
+	public void OnDialogClosed()
+	{
+		return;
+	}
+
+	public void OnDialogOpened(IDialogParameters parameters)
+	{
+		return;
+	}
+}
\ No newline at end of file
diff --git a/Source/MAX.Core/Autofac/AutowiredAttribute.cs b/Source/MAX.Core/Autofac/AutowiredAttribute.cs
new file mode 100644
index 0000000..f82ae6a
--- /dev/null
+++ b/Source/MAX.Core/Autofac/AutowiredAttribute.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace MAX.Core.Autofac
+{
+	/// <summary>
+	/// 自动填充属性特性
+	/// </summary>
+	[AttributeUsage(AttributeTargets.Property)]
+	public class AutowiredAttribute : Attribute
+	{
+	}
+}
diff --git a/Source/MAX.Core/Autofac/CustomPropertySelector.cs b/Source/MAX.Core/Autofac/CustomPropertySelector.cs
new file mode 100644
index 0000000..452d089
--- /dev/null
+++ b/Source/MAX.Core/Autofac/CustomPropertySelector.cs
@@ -0,0 +1,23 @@
+using Autofac.Core;
+using System.Linq;
+using System.Reflection;
+
+namespace MAX.Core.Autofac
+{
+	/// <summary>
+	/// autofac  找出所有属性上是否摸个特性
+	/// </summary>
+	public class CustomPropertySelector : IPropertySelector
+	{
+		public bool InjectProperty(PropertyInfo propertyInfo, object instance)
+		{
+			if (propertyInfo.CustomAttributes.Any(iterator => iterator.AttributeType == typeof(AutowiredAttribute)))
+			{
+
+			}
+			//需要一个判断
+			//;如果标记的有CustomPropertyAttribute特性返回True:返回true;就构造实例
+			return propertyInfo.CustomAttributes.Any(iterator => iterator.AttributeType == typeof(AutowiredAttribute));
+		}
+	}
+}
diff --git a/Source/MAX.Core/Autofac/IDependencyRegistrar.cs b/Source/MAX.Core/Autofac/IDependencyRegistrar.cs
new file mode 100644
index 0000000..e3f7478
--- /dev/null
+++ b/Source/MAX.Core/Autofac/IDependencyRegistrar.cs
@@ -0,0 +1,9 @@
+using Autofac;
+
+namespace MAX.Core.Autofac
+{
+	public interface IDependencyRegistrar
+	{
+		void Register(ContainerBuilder builder);
+	}
+}
diff --git a/Source/MAX.Core/Autofac/IocManager.cs b/Source/MAX.Core/Autofac/IocManager.cs
new file mode 100644
index 0000000..f604681
--- /dev/null
+++ b/Source/MAX.Core/Autofac/IocManager.cs
@@ -0,0 +1,107 @@
+using Autofac;
+using Autofac.Core;
+using System;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MAX.Core.DependencyInjection;
+
+/// <summary>
+/// 容器
+/// </summary>
+public static partial class IocManager
+{
+	/// <summary>
+	/// 默认容器
+	/// </summary>
+	public static IContainer Container { get; internal set; }
+	public static void SetContainer(IContainer container)
+	{
+		Container = container;
+	}
+
+	/// <summary>
+	/// 确定指定的服务在上下文中是否可用。
+	/// </summary>
+	/// <typeparam name="TService"></typeparam>
+	/// <returns></returns>
+	public static bool IsRegistered<TService>()
+	{
+		return Container.IsRegistered<TService>();
+	}
+	/// <summary>
+	/// 确定指定的服务在上下文中是否可用。
+	/// </summary>
+	/// <param name="type"></param>
+	/// <returns></returns>
+	public static bool IsRegistered(Type serverType)
+	{
+		return Container.IsRegistered(serverType);
+	}
+
+	public static TService Resolve<TService>()
+	{
+		if (Container.IsRegistered<TService>())
+		{
+			return Container.Resolve<TService>();
+		}
+		return default;
+	}
+	public static object Resolve(Type serviceType)
+	{
+		if (Container.IsRegistered(serviceType))
+		{
+			return Container.Resolve(serviceType);
+		}
+		return default;
+	}
+	public static TService Resolve<TService>(params Parameter[] parameters)
+	{
+		if (Container.IsRegistered<TService>())
+		{
+			return Container.Resolve<TService>(parameters);
+		}
+		return default;
+	}
+	/// <summary>
+	/// 获取所有注册 
+	/// </summary>
+	/// <typeparam name="TService"></typeparam>
+	/// <returns></returns>
+	public static TService[] ResolveAll<TService>()
+	{
+		return ResolveAll(typeof(TService)) as TService[];
+	}
+	/// <summary>
+	/// 获取所有注册 
+	/// </summary>
+	/// <typeparam name="TService"></typeparam>
+	/// <returns></returns>
+	public static object[] ResolveAll(Type type)
+	{
+		Type enumerableOfType = typeof(IEnumerable<>).MakeGenericType(type);
+		return (object[])Container.ResolveService(new TypedService(enumerableOfType));
+	}
+
+	public static Type GetRegistrationType(string key)
+	{
+		foreach (IComponentRegistration registration in Container.ComponentRegistry.Registrations)
+		{
+			foreach (Service service in registration.Services)
+			{
+				if (service is KeyedService ks)
+				{
+					if (key.Equals(ks.ServiceKey.ToString(), StringComparison.Ordinal))
+					{
+						if (Container.ComponentRegistry.TryGetServiceRegistration(service, out ServiceRegistration serviceRegistration))
+						{
+							return serviceRegistration.Registration.Target.Activator.LimitType;
+						}
+					}
+				}
+			}
+		}
+		return null;
+	}
+}
diff --git a/Source/MAX.Core/Caches/ICache.cs b/Source/MAX.Core/Caches/ICache.cs
new file mode 100644
index 0000000..9407565
--- /dev/null
+++ b/Source/MAX.Core/Caches/ICache.cs
@@ -0,0 +1,99 @@
+using System;
+
+namespace MAX.Core.Caches;
+
+/// <summary>
+/// 缓存
+/// </summary>
+public interface ICache
+{
+	/// <summary>
+	/// 是否存在指定键的缓存
+	/// </summary>
+	/// <param name="key">缓存键</param>
+	bool Exists(string key);
+	/// <summary>
+	/// 从缓存中获取数据
+	/// </summary>
+	/// <param name="key"></param>
+	/// <returns></returns>
+	T Get<T>(string key);
+	/// <summary>
+	/// 从缓存中获取数据，如果不存在，则执行获取数据操作并添加到缓存中
+	/// </summary>
+	/// <typeparam name="T">缓存数据类型</typeparam>
+	/// <param name="key">缓存键</param>
+	/// <param name="func">获取数据操作</param>
+	T Get<T>(string key, Func<T> func);
+	/// <summary>
+	/// 当缓存数据不存在则添加，已存在不会添加，添加成功返回true
+	/// </summary>
+	/// <typeparam name="T">缓存数据类型</typeparam>
+	/// <param name="key">缓存键</param>
+	/// <param name="value">值</param>
+	bool TryAdd<T>(string key, T value);
+	/// <summary>
+	/// 覆盖添加
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="key"></param>
+	/// <param name="value"></param>
+	/// <returns></returns>
+	bool OverlayAdd<T>(string key, T value);
+	/// <summary>
+	/// 移除缓存
+	/// </summary>
+	/// <param name="key">缓存键</param>
+	void Remove(string key);
+	/// <summary>
+	/// 清空缓存
+	/// </summary>
+	void Clear();
+}
+
+public interface ICache<T>
+{
+	/// <summary>
+	/// 是否存在指定键的缓存
+	/// </summary>
+	/// <param name="key">缓存键</param>
+	bool Exists(string key);
+
+	/// <summary>
+	/// 从缓存中获取数据，如果不存在，则执行获取数据操作并添加到缓存中
+	/// </summary>
+	/// <typeparam name="T">缓存数据类型</typeparam>
+	/// <param name="key">缓存键</param>
+	T Get(string key);
+	/// <summary>
+	/// 从缓存中获取数据，如果不存在，则执行获取数据操作并添加到缓存中
+	/// </summary>
+	/// <typeparam name="T">缓存数据类型</typeparam>
+	/// <param name="key">缓存键</param>
+	/// <param name="func">获取数据操作</param>
+	T Get(string key, Func<T> func);
+	/// <summary>
+	/// 当缓存数据不存在则添加，已存在不会添加，添加成功返回true
+	/// </summary>
+	/// <typeparam name="T">缓存数据类型</typeparam>
+	/// <param name="key">缓存键</param>
+	/// <param name="value">值</param>
+	bool TryAdd(string key, T value);
+	/// <summary>
+	/// 覆盖添加
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="key"></param>
+	/// <param name="value"></param>
+	/// <returns></returns>
+	bool OverlayAdd(string key, T value);
+	/// <summary>
+	/// 移除缓存
+	/// </summary>
+	/// <param name="key">缓存键</param>
+	void Remove(string key);
+	/// <summary>
+	/// 清空缓存
+	/// </summary>
+	void Clear();
+}
diff --git a/Source/MAX.Core/Caches/MemoryCache.cs b/Source/MAX.Core/Caches/MemoryCache.cs
new file mode 100644
index 0000000..b2bc36a
--- /dev/null
+++ b/Source/MAX.Core/Caches/MemoryCache.cs
@@ -0,0 +1,168 @@
+
+using MAX.Core.DependencyInjection;
+using MAX.Core.Infrastructure;
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+
+namespace MAX.Core.Caches;
+
+/// <summary>
+/// 内存缓存
+/// </summary>
+public class MemoryCache : ICache, ISingletonDependency
+{
+	//private static readonly Object _locker = new object();
+	private readonly ConcurrentDictionary<string, object> _cache = new();
+
+	public virtual void Clear()
+	{
+		_cache.Clear();
+	}
+
+	public virtual bool Exists(string key)
+	{
+		return _cache.ContainsKey(key);
+	}
+	public virtual T Get<T>(string key)
+	{
+		if (Exists(key))
+		{
+			return (T)_cache[key];
+		}
+		return default;
+	}
+	public virtual TResult Get<TResult>(string key, Func<TResult> func)
+	{
+		if (Exists(key))
+		{
+			return (TResult)_cache[key];
+		}
+		else
+		{
+			if (func != null)
+			{
+				TResult t = func();
+				TryAdd(key, t);
+				return t;
+			}
+		}
+		return default;
+	}
+
+	public virtual bool OverlayAdd<T>(string key, T value)
+	{
+		if (Exists(key))
+		{
+			_cache[key] = value;
+		}
+		else
+		{
+			_cache.TryAdd(key, value);
+		}
+		return true;
+	}
+
+	public virtual void Remove(string key)
+	{
+		_cache.TryRemove(key, out _);
+	}
+
+	public virtual bool TryAdd<T>(string key, T value)
+	{
+		_cache.AddOrUpdate(key, value, (oldkey, oldvalue) => value);
+		return true;
+	}
+	/// <summary>
+	/// 获取所有Key
+	/// </summary>
+	/// <returns></returns>
+	public string[] AllKeys()
+	{
+		return _cache.Keys.ToArray();
+	}
+}
+/// <summary>
+/// 单例缓存抽象类
+/// </summary>
+/// <typeparam name="TModel">单例对象</typeparam>
+/// <typeparam name="TValue">缓存类型</typeparam>
+public abstract class SingleInstanceLittleCache<TModel, TValue> : SingleInstance<TModel>, ICache<TValue> where TModel : class
+{
+	private readonly ConcurrentDictionary<string, TValue> _cache = new();
+	/// <summary>
+	/// 自定义前缀
+	/// </summary>
+	//public abstract string KeyPrefix { get; }
+	//private string FormatKey(string key)
+	//{
+	//    return KeyPrefix + key;
+	//}
+
+	public virtual void Clear()
+	{
+		_cache.Clear();
+	}
+
+	public virtual bool Exists(string key)
+	{
+		return _cache.ContainsKey(key);
+	}
+	public virtual TValue Get(string key)
+	{
+		if (Exists(key))
+		{
+			return _cache[key];
+		}
+		return default;
+	}
+	public virtual TValue Get(string key, Func<TValue> func)
+	{
+		if (Exists(key))
+		{
+			return _cache[key];
+		}
+		else
+		{
+			if (func != null)
+			{
+				TValue t = func();
+				TryAdd(key, t);
+				return t;
+			}
+		}
+		return default;
+	}
+
+	public virtual bool OverlayAdd(string key, TValue value)
+	{
+		if (Exists(key))
+		{
+			_cache[key] = value;
+		}
+		else
+		{
+			_cache.TryAdd(key, value);
+		}
+		return true;
+	}
+
+	public virtual void Remove(string key)
+	{
+		_cache.TryRemove(key, out _);
+	}
+
+	public virtual bool TryAdd(string key, TValue value)
+	{
+		_cache.AddOrUpdate(key, value, (oldkey, oldvalue) => value);
+		return true;
+	}
+	/// <summary>
+	/// 获取所有Key
+	/// </summary>
+	/// <returns></returns>
+	public string[] AllKeys()
+	{
+		return _cache.Keys.ToArray();
+	}
+}
diff --git a/Source/MAX.Core/Commons/CommonValue.cs b/Source/MAX.Core/Commons/CommonValue.cs
new file mode 100644
index 0000000..ddcd731
--- /dev/null
+++ b/Source/MAX.Core/Commons/CommonValue.cs
@@ -0,0 +1,37 @@
+namespace MAX.Core.Commons;
+
+/// <summary>
+/// 公共Value
+/// </summary>
+/// <typeparam name="TValue"></typeparam>
+public class CommonValue<TValue>
+{
+	public CommonValue() { }
+	public CommonValue(TValue value)
+	{
+		Value = value;
+	}
+	public TValue Value { get; set; }
+}
+/// <summary>
+/// 公共TextValue
+/// </summary>
+/// <typeparam name="TValue"></typeparam>
+public class CommonTextValue<TValue> : CommonValue<TValue>
+{
+	public string Text { get; set; }
+}
+/// <summary>
+/// 公共TextValue
+/// </summary>
+public class CommonTextValue : CommonTextValue<string>
+{
+
+}
+/// <summary>
+/// 默认公共键值对 Key Value 
+/// </summary>
+public class CommonKeyValue : CommonValue<string>
+{
+	public string Key { get; set; }
+}
diff --git a/Source/MAX.Core/Commons/Result.cs b/Source/MAX.Core/Commons/Result.cs
new file mode 100644
index 0000000..5d71941
--- /dev/null
+++ b/Source/MAX.Core/Commons/Result.cs
@@ -0,0 +1,55 @@
+using System;
+
+namespace MAX.Core.Commons;
+
+/// <summary>
+/// 通用返回
+/// </summary>
+public class Result
+{
+	/// <summary>
+	/// 返回结果是否成功
+	/// </summary>
+	public bool Success { get; set; } = false;
+	/// <summary>
+	/// 返回消息
+	/// </summary>
+	public string Msg { get; set; } = "";
+	/// <summary>
+	/// 返回内容
+	/// </summary>
+	public object Data { get; set; } = null;
+
+	/// <summary>
+	/// 返回状态码
+	/// </summary>
+	public int Code { get; set; }
+
+}
+/// <summary>
+/// 通用返回 指定Data类型
+/// </summary>
+/// <typeparam name="TData">数据类型</typeparam>
+public class Result<TData> : Result
+{
+	/// <summary>
+	/// 返回内容
+	/// </summary>
+	public new TData Data { get; set; }
+}
+/// <summary>
+/// 通用返回 
+/// </summary>
+/// <typeparam name="TStatus">状态类型枚举</typeparam>
+/// <typeparam name="TData">数据类型</typeparam>
+public class Result<TStatus, TData> : Result where TStatus : Enum
+{
+	/// <summary>
+	/// 状态
+	/// </summary>
+	public TStatus Status { get; set; }
+	/// <summary>
+	/// 返回内容
+	/// </summary>
+	public new TData Data { get; set; }
+}
diff --git a/Source/MAX.Core/Cryptography/Base64Helper.cs b/Source/MAX.Core/Cryptography/Base64Helper.cs
new file mode 100644
index 0000000..768c732
--- /dev/null
+++ b/Source/MAX.Core/Cryptography/Base64Helper.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Text;
+
+namespace MAX.Core.Cryptography;
+
+public class Base64Helper
+{
+	/// <summary>
+	/// Base64加密
+	/// </summary>
+	/// <param name="codeName">加密采用的编码方式</param>
+	/// <param name="source">待加密的明文</param>
+	/// <returns></returns>
+	public static string Encode(string source, Encoding encode)
+	{
+		string encodeValue = "";
+		byte[] bytes = encode.GetBytes(source);
+		try
+		{
+			encodeValue = Convert.ToBase64String(bytes);
+		}
+		catch
+		{
+			encodeValue = source;
+		}
+		return encodeValue;
+	}
+
+	/// <summary>
+	/// Base64加密，采用utf8编码方式加密
+	/// </summary>
+	/// <param name="source">待加密的明文</param>
+	/// <returns>加密后的字符串</returns>
+	public static string Encode(string source)
+	{
+		return Encode(source, Encoding.UTF8);
+	}
+
+	/// <summary>
+	/// Base64解密
+	/// </summary>
+	/// <param name="codeName">解密采用的编码方式，注意和加密时采用的方式一致</param>
+	/// <param name="result">待解密的密文</param>
+	/// <returns>解密后的字符串</returns>
+	public static string Decode(string result, Encoding encode)
+	{
+		string decode = "";
+		byte[] bytes = Convert.FromBase64String(result);
+		try
+		{
+			decode = encode.GetString(bytes);
+		}
+		catch
+		{
+			decode = result;
+		}
+		return decode;
+	}
+
+	/// <summary>
+	/// Base64解密，采用utf8编码方式解密
+	/// </summary>
+	/// <param name="result">待解密的密文</param>
+	/// <returns>解密后的字符串</returns>
+	public static string Decode(string result)
+	{
+		return Decode(result, Encoding.UTF8);
+	}
+}
diff --git a/Source/MAX.Core/Cryptography/DESHelper.cs b/Source/MAX.Core/Cryptography/DESHelper.cs
new file mode 100644
index 0000000..67e37f0
--- /dev/null
+++ b/Source/MAX.Core/Cryptography/DESHelper.cs
@@ -0,0 +1,215 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace MAX.Core.Cryptography;
+
+public sealed class DESHelper
+{
+
+	//默认密钥向量
+	private static readonly byte[] IVKey = { 36, 109, 97, 120, 111, 110, 120, 36 };
+	/// <summary>
+	/// DES加密字符串
+	/// </summary>
+	/// <param name="encryptString">待加密的字符串</param>
+	/// <param name="encryptKey">加密密钥,要求为8位</param>
+	/// <returns>加密成功返回加密后的字符串,失败返回源串</returns>
+	public static string Encrypt(string encryptString, string encryptKey)
+	{
+		try
+		{
+			encryptKey = GetSubString(encryptKey, 8, "");
+			encryptKey = encryptKey.PadRight(8, ' ');
+			byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));
+			byte[] rgbIV = IVKey;
+			byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
+			DES dCSP = DES.Create();
+			MemoryStream mStream = new();
+			CryptoStream cStream = new(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
+			cStream.Write(inputByteArray, 0, inputByteArray.Length);
+			cStream.FlushFinalBlock();
+			return Convert.ToBase64String(mStream.ToArray());
+		}
+		catch
+		{
+			return encryptString;
+		}
+	}
+
+	/// <summary>
+	/// DES解密字符串
+	/// </summary>
+	/// <param name="decryptString">待解密的字符串</param>
+	/// <param name="decryptKey">解密密钥,要求为8位,和加密密钥相同</param>
+	/// <returns>解密成功返回解密后的字符串,失败返源串</returns>
+	public static string Decrypt(string decryptString, string decryptKey)
+	{
+		try
+		{
+			decryptKey = GetSubString(decryptKey, 0, 8, "");
+			decryptKey = decryptKey.PadRight(8, ' ');
+			byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
+			byte[] rgbIV = IVKey;
+			byte[] inputByteArray = Convert.FromBase64String(decryptString);
+			DES DCSP = DES.Create();
+
+			MemoryStream mStream = new();
+			CryptoStream cStream = new(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
+			cStream.Write(inputByteArray, 0, inputByteArray.Length);
+			cStream.FlushFinalBlock();
+			return Encoding.UTF8.GetString(mStream.ToArray());
+		}
+		catch
+		{
+			return string.Empty;
+		}
+
+	}
+
+	#region 截取字符串函数
+
+	/// <summary>
+	/// 截取字符串函数
+	/// </summary>
+	/// <param name="Str">所要截取的字符串</param>
+	/// <param name="Num">截取字符串的长度</param>
+	/// <returns></returns>
+	public static string GetSubString(string Str, int Num)
+	{
+		if (Str is null or "")
+		{
+			return "";
+		}
+		string outstr = string.Empty;
+		int n = 0;
+		foreach (char ch in Str)
+		{
+			n += Encoding.Default.GetByteCount(ch.ToString());
+
+			if (n > Num)
+			{
+				break;
+			}
+			else
+			{
+				outstr += ch;
+			}
+		}
+
+		return outstr;
+	}
+	/// <summary>
+	/// 截取字符串函数,如果超过指定长度则将超出的部分用指定字符串代替
+	/// </summary>
+	/// <param name="Str">所要截取的字符串</param>
+	/// <param name="Num">截取字符串的长度</param>
+	/// <param name="LastStr">截取字符串后省略部分的字符串</param>
+	/// <returns></returns>
+	public static string GetSubString(string Str, int Num, string LastStr)
+	{
+		return GetSubString(Str, 0, Num, LastStr);
+	}
+
+	#endregion
+
+	#region 截取字符串，超过部分用指定字符串替换
+
+	/* 宗波于 2010-6-12 日添加， 来源于DiscuzNt */
+	/// <summary>
+	/// 取指定长度的字符串
+	/// </summary>
+	/// <param name="p_SrcString">要检查的字符串</param>
+	/// <param name="p_StartIndex">起始位置</param>
+	/// <param name="p_Length">指定长度</param>
+	/// <param name="p_TailString">用于替换的字符串</param>
+	/// <returns>截取后的字符串</returns>
+	public static string GetSubString(string p_SrcString, int p_StartIndex, int p_Length, string p_TailString)
+	{
+		string myResult = p_SrcString;
+
+		byte[] bComments = Encoding.UTF8.GetBytes(p_SrcString);
+		foreach (char c in Encoding.UTF8.GetChars(bComments))
+		{    //当是日文或韩文时(注:中文的范围:\u4e00 - \u9fa5, 日文在\u0800 - \u4e00, 韩文为\xAC00-\xD7A3)
+			if (c is (> '\u0800' and < '\u4e00') or (> '\xAC00' and < '\xD7A3'))
+			{
+				//if (System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\u0800-\u4e00]+") || System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\xAC00-\xD7A3]+"))
+				//当截取的起始位置超出字段串长度时
+				if (p_StartIndex >= p_SrcString.Length)
+				{
+					return "";
+				}
+				else
+				{
+					return p_SrcString.Substring(p_StartIndex,
+												   p_Length + p_StartIndex > p_SrcString.Length ? p_SrcString.Length - p_StartIndex : p_Length);
+				}
+			}
+		}
+
+		if (p_Length >= 0)
+		{
+			byte[] bsSrcString = Encoding.Default.GetBytes(p_SrcString);
+
+			//当字符串长度大于起始位置
+			if (bsSrcString.Length > p_StartIndex)
+			{
+				int p_EndIndex = bsSrcString.Length;
+
+				//当要截取的长度在字符串的有效长度范围内
+				if (bsSrcString.Length > p_StartIndex + p_Length)
+				{
+					p_EndIndex = p_Length + p_StartIndex;
+				}
+				else
+				{   //当不在有效范围内时,只取到字符串的结尾
+
+					p_Length = bsSrcString.Length - p_StartIndex;
+					p_TailString = "";
+				}
+
+				int nRealLength = p_Length;
+				int[] anResultFlag = new int[p_Length];
+				byte[] bsResult = null;
+
+				int nFlag = 0;
+				for (int i = p_StartIndex; i < p_EndIndex; i++)
+				{
+					if (bsSrcString[i] > 127)
+					{
+						nFlag++;
+						if (nFlag == 3)
+						{
+							nFlag = 1;
+						}
+					}
+					else
+					{
+						nFlag = 0;
+					}
+
+					anResultFlag[i] = nFlag;
+				}
+
+				if (bsSrcString[p_EndIndex - 1] > 127 && anResultFlag[p_Length - 1] == 1)
+				{
+					nRealLength = p_Length + 1;
+				}
+
+				bsResult = new byte[nRealLength];
+
+				Array.Copy(bsSrcString, p_StartIndex, bsResult, 0, nRealLength);
+
+				myResult = Encoding.Default.GetString(bsResult);
+				myResult += p_TailString;
+			}
+		}
+
+		return myResult;
+	}
+
+
+	#endregion
+
+}
diff --git a/Source/MAX.Core/Cryptography/MD5Helper.cs b/Source/MAX.Core/Cryptography/MD5Helper.cs
new file mode 100644
index 0000000..8397396
--- /dev/null
+++ b/Source/MAX.Core/Cryptography/MD5Helper.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace MAX.Core.Cryptography;
+
+public class MD5Helper
+{
+	/// <summary>
+	/// MD5加密
+	/// </summary>
+	/// <param name="instring"></param>
+	/// <returns></returns>
+	public static string Md5_32(string instring)
+	{
+		return _Md532(instring);
+	}
+	public static string Md5_Lower32(string instring)
+	{
+		return _Md532(instring, true);
+	}
+	public static string _Md532(string instring, bool IsLower = false)
+	{
+		byte[] result = Encoding.UTF8.GetBytes(string.IsNullOrEmpty(instring) ? "" : instring.Trim());
+		MD5 md5 = MD5.Create();
+		byte[] output = md5.ComputeHash(result);
+		string value = BitConverter.ToString(output).Replace("-", "");
+		if (IsLower)
+		{
+			return value.ToLower();
+		}
+		return value;
+	}
+
+
+	/// <summary>
+	/// MD5加密
+	/// </summary>
+	/// <returns></returns>
+	public static long GetLong(byte[] result)
+	{
+		return
+			Convert.ToInt64(
+				BitConverter.ToString(MD5.Create().ComputeHash(result), 4,
+					8).Replace("-", ""), 16);
+	}
+
+	/// <summary>
+	/// MD5 16位加密转long
+	/// </summary>
+	/// <param name="url"></param>
+	/// <returns></returns>
+	public static long GetLong(string url)
+	{
+		if (string.IsNullOrEmpty(url))
+		{
+			return 0;
+		}
+
+		return Convert.ToInt64(BitConverter.ToString(MD5.Create().ComputeHash(Encoding.Default.GetBytes(url)), 4, 8).Replace("-", ""), 16);
+	}
+}
diff --git a/Source/MAX.Core/Cryptography/UrlHelper.cs b/Source/MAX.Core/Cryptography/UrlHelper.cs
new file mode 100644
index 0000000..35f2521
--- /dev/null
+++ b/Source/MAX.Core/Cryptography/UrlHelper.cs
@@ -0,0 +1,51 @@
+using System.Text;
+
+namespace MAX.Core.Cryptography;
+
+/// <summary>
+/// Url 加密 解密
+/// </summary>
+public class UrlHelper
+{
+	/// <summary>
+	/// Url加密
+	/// </summary>
+	/// <param name="codeName">加密采用的编码方式</param>
+	/// <param name="source">待加密的明文</param>
+	/// <returns></returns>
+	public static string Encode(string source, Encoding encode)
+	{
+		return System.Web.HttpUtility.UrlEncode(source, encode);
+	}
+
+	/// <summary>
+	/// Url加密，采用utf8编码方式加密
+	/// </summary>
+	/// <param name="source">待加密的明文</param>
+	/// <returns>加密后的字符串</returns>
+	public static string Encode(string source)
+	{
+		return Encode(source, Encoding.UTF8);
+	}
+
+	/// <summary>
+	/// Url解密
+	/// </summary>
+	/// <param name="codeName">解密采用的编码方式，注意和加密时采用的方式一致</param>
+	/// <param name="result">待解密的密文</param>
+	/// <returns>解密后的字符串</returns>
+	public static string Decode(string result, Encoding encode)
+	{
+		return System.Web.HttpUtility.UrlDecode(result, Encoding.UTF8);
+	}
+
+	/// <summary>
+	/// Url解密，采用utf8编码方式解密
+	/// </summary>
+	/// <param name="result">待解密的密文</param>
+	/// <returns>解密后的字符串</returns>
+	public static string Decode(string result)
+	{
+		return Decode(result, Encoding.UTF8);
+	}
+}
diff --git a/Source/MAX.Core/DependencyInjection/IScopedDependency.cs b/Source/MAX.Core/DependencyInjection/IScopedDependency.cs
new file mode 100644
index 0000000..eb004ed
--- /dev/null
+++ b/Source/MAX.Core/DependencyInjection/IScopedDependency.cs
@@ -0,0 +1,8 @@
+namespace MAX.Core.DependencyInjection;
+
+/// <summary>
+/// 作用域（每个 Scope/请求一个实例）
+/// </summary>
+public interface IScopedDependency
+{
+}
diff --git a/Source/MAX.Core/DependencyInjection/IServiceRegistrar.cs b/Source/MAX.Core/DependencyInjection/IServiceRegistrar.cs
new file mode 100644
index 0000000..b2f5755
--- /dev/null
+++ b/Source/MAX.Core/DependencyInjection/IServiceRegistrar.cs
@@ -0,0 +1,81 @@
+//using System;
+
+//namespace MAX.Core.DependencyInjection;
+
+///// <summary>
+///// 依赖注册抽象（由 MAX.Core 自己定义，不依赖任何第三方 DI 容器）。
+///// 具体实现由宿主项目提供，内部适配外部容器（Autofac、Microsoft.Extensions.DependencyInjection 等）。
+///// </summary>
+//public interface IServiceRegistrar
+//{
+//	/// <summary>
+//	/// 注册单例：<typeparamref name="TImplementation"/> 实现 <typeparamref name="TService"/>
+//	/// </summary>
+//	void RegisterSingleton<TService, TImplementation>() where TService : class where TImplementation : class, TService;
+
+//	/// <summary>
+//	/// 注册单例实例
+//	/// </summary>
+//	void RegisterSingleton<TService>(TService instance) where TService : class;
+
+//	/// <summary>
+//	/// 注册单例（匿名工厂）
+//	/// </summary>
+//	void RegisterSingleton<TService>(Func<IServiceProvider, TService> factory) where TService : class;
+
+//	/// <summary>
+//	/// 注册单例（key）：<typeparamref name="TImplementation"/> 实现 <typeparamref name="TService"/>
+//	/// </summary>
+//	void RegisterSingleton<TService, TImplementation>(object? serviceKey) where TService : class where TImplementation : class, TService;
+
+//	/// <summary>
+//	/// 注册单例实例（key）
+//	/// </summary>
+//	void RegisterSingleton<TService>(object? serviceKey, TService instance) where TService : class;
+
+//	/// <summary>
+//	/// 注册单例（key + 匿名工厂）
+//	/// </summary>
+//	void RegisterSingleton<TService>(object? serviceKey, Func<IServiceProvider, object?, TService> factory) where TService : class;
+
+//	/// <summary>
+//	/// 注册作用域生命周期
+//	/// </summary>
+//	void RegisterScoped<TService, TImplementation>() where TService : class where TImplementation : class, TService;
+
+//	/// <summary>
+//	/// 注册作用域生命周期（匿名工厂）
+//	/// </summary>
+//	void RegisterScoped<TService>(Func<IServiceProvider, TService> factory) where TService : class;
+
+//	/// <summary>
+//	/// 注册作用域生命周期（key）：<typeparamref name="TImplementation"/> 实现 <typeparamref name="TService"/>
+//	/// </summary>
+//	void RegisterScoped<TService, TImplementation>(object? serviceKey) where TService : class where TImplementation : class, TService;
+
+//	/// <summary>
+//	/// 注册作用域生命周期（key + 匿名工厂）
+//	/// </summary>
+//	void RegisterScoped<TService>(object? serviceKey, Func<IServiceProvider, object?, TService> factory) where TService : class;
+
+//	/// <summary>
+//	/// 注册瞬时生命周期
+//	/// </summary>
+//	void RegisterTransient<TService, TImplementation>() where TService : class where TImplementation : class, TService;
+
+//	/// <summary>
+//	/// 注册瞬时生命周期（匿名工厂）
+//	/// </summary>
+//	void RegisterTransient<TService>(Func<IServiceProvider, TService> factory) where TService : class;
+
+//	/// <summary>
+//	/// 注册瞬时生命周期（key）：<typeparamref name="TImplementation"/> 实现 <typeparamref name="TService"/>
+//	/// </summary>
+//	void RegisterTransient<TService, TImplementation>(object? serviceKey) where TService : class where TImplementation : class, TService;
+
+//	/// <summary>
+//	/// 注册瞬时生命周期（key + 匿名工厂）
+//	/// </summary>
+//	void RegisterTransient<TService>(object? serviceKey, Func<IServiceProvider, object?, TService> factory) where TService : class;
+
+//}
diff --git a/Source/MAX.Core/DependencyInjection/ISingletonDependency.cs b/Source/MAX.Core/DependencyInjection/ISingletonDependency.cs
new file mode 100644
index 0000000..bcacfcb
--- /dev/null
+++ b/Source/MAX.Core/DependencyInjection/ISingletonDependency.cs
@@ -0,0 +1,8 @@
+namespace MAX.Core.DependencyInjection;
+
+/// <summary>
+/// 单例
+/// </summary>
+public interface ISingletonDependency
+{
+}
diff --git a/Source/MAX.Core/DependencyInjection/ITransientDependency.cs b/Source/MAX.Core/DependencyInjection/ITransientDependency.cs
new file mode 100644
index 0000000..3da15a0
--- /dev/null
+++ b/Source/MAX.Core/DependencyInjection/ITransientDependency.cs
@@ -0,0 +1,8 @@
+namespace MAX.Core.DependencyInjection;
+
+/// <summary>
+/// 每次实例化
+/// </summary>
+public interface ITransientDependency
+{
+}
diff --git a/Source/MAX.Core/DependencyInjection/LazyServiceProvider.cs b/Source/MAX.Core/DependencyInjection/LazyServiceProvider.cs
new file mode 100644
index 0000000..2429709
--- /dev/null
+++ b/Source/MAX.Core/DependencyInjection/LazyServiceProvider.cs
@@ -0,0 +1,36 @@
+using MAX.Core.Infrastructure;
+using System;
+using System.Collections.Concurrent;
+
+namespace MAX.Core.DependencyInjection;
+
+public interface ILazyServiceProvider
+{
+	object LazyGetService(Type serviceType);
+	T LazyGetService<T>();
+}
+
+public class LazyServiceProvider : SingleInstance<LazyServiceProvider>, ILazyServiceProvider
+{
+	protected ConcurrentDictionary<Type, Lazy<object>> CachedServices { get; }
+	private LazyServiceProvider()
+	{
+		CachedServices = new ConcurrentDictionary<Type, Lazy<object>>();
+	}
+	public virtual T LazyGetService<T>()
+	{
+		return (T)LazyGetService(typeof(T));
+	}
+
+	public virtual object LazyGetService(Type serviceType)
+	{
+		return GetService(serviceType);
+	}
+	public virtual object GetService(Type serviceType)
+	{
+		return CachedServices.GetOrAdd(
+			serviceType,
+			_ => new Lazy<object>(() => IocManager.Resolve(serviceType))
+		).Value;
+	}
+}
diff --git a/Source/MAX.Core/Extensions/Convert.cs b/Source/MAX.Core/Extensions/Convert.cs
new file mode 100644
index 0000000..382d8b2
--- /dev/null
+++ b/Source/MAX.Core/Extensions/Convert.cs
@@ -0,0 +1,218 @@
+using MAX.Core.Helpers;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MAX.Core.Extensions;
+
+/// <summary>
+/// 系统扩展 - 类型转换
+/// </summary>
+public static partial class Extensions
+{
+	/// <summary>
+	/// IsNullOrEmpty
+	/// </summary>
+	/// <param name="input"></param>
+	/// <returns></returns>
+	public static bool IsNullOrEmpty(this string input)
+	{
+		return string.IsNullOrEmpty(input);
+	}
+	/// <summary>
+	/// 安全转换为字符串，去除两端空格，当值为null时返回""
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static string SafeString(this object input)
+	{
+		return input?.ToString().Trim() ?? string.Empty;
+	}
+
+	/// <summary>
+	/// 转换为bool
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static bool ToBool(this string obj, bool defvalue = false)
+	{
+		return Helpers.Convert.ToBool(obj, defvalue);
+	}
+
+	/// <summary>
+	/// 转换为可空bool
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static bool? ToBoolOrNull(this string obj)
+	{
+		return Helpers.Convert.ToBoolOrNull(obj);
+	}
+
+	/// <summary>
+	/// 转换为int
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static int ToInt(this string obj, int defvalue = 0)
+	{
+		return Helpers.Convert.ToInt(obj, defvalue);
+	}
+
+	/// <summary>
+	/// 转换为可空int
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static int? ToIntOrNull(this string obj)
+	{
+		return Helpers.Convert.ToIntOrNull(obj);
+	}
+
+	/// <summary>
+	/// 转换为long
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static long ToLong(this string obj, long defvalue = 0)
+	{
+		return Helpers.Convert.ToLong(obj, defvalue);
+	}
+
+	/// <summary>
+	/// 转换为可空long
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static long? ToLongOrNull(this string obj)
+	{
+		return Helpers.Convert.ToLongOrNull(obj);
+	}
+
+	/// <summary>
+	/// 转换为double
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static double ToDouble(this string obj, double defvalue = 0)
+	{
+		return Helpers.Convert.ToDouble(obj, defvalue: defvalue);
+	}
+
+	/// <summary>
+	/// 转换为可空double
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static double? ToDoubleOrNull(this string obj)
+	{
+		return Helpers.Convert.ToDoubleOrNull(obj);
+	}
+
+	/// <summary>
+	/// 转换为decimal
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static decimal ToDecimal(this string obj, decimal defvalue = 0)
+	{
+		return Helpers.Convert.ToDecimal(obj, defvalue: defvalue);
+	}
+
+	/// <summary>
+	/// 转换为可空decimal
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static decimal? ToDecimalOrNull(this string obj)
+	{
+		return Helpers.Convert.ToDecimalOrNull(obj);
+	}
+
+	/// <summary>
+	/// 转换为日期
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static DateTime ToDate(this string obj)
+	{
+		return Helpers.Convert.ToDate(obj);
+	}
+
+	/// <summary>
+	/// 转换为可空日期
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static DateTime? ToDateOrNull(this string obj)
+	{
+		return Helpers.Convert.ToDateOrNull(obj);
+	}
+
+	/// <summary>
+	/// 转换为Guid
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static Guid ToGuid(this string obj)
+	{
+		return Helpers.Convert.ToGuid(obj);
+	}
+
+	/// <summary>
+	/// 转换为可空Guid
+	/// </summary>
+	/// <param name="obj">数据</param>
+	public static Guid? ToGuidOrNull(this string obj)
+	{
+		return Helpers.Convert.ToGuidOrNull(obj);
+	}
+
+	/// <summary>
+	/// 转换为Guid集合
+	/// </summary>
+	/// <param name="obj">数据,范例: "83B0233C-A24F-49FD-8083-1337209EBC9A,EAB523C6-2FE7-47BE-89D5-C6D440C3033A"</param>
+	public static List<Guid> ToGuidList(this string obj)
+	{
+		return Helpers.Convert.ToGuidList(obj);
+	}
+
+	/// <summary>
+	/// 转换为Guid集合
+	/// </summary>
+	/// <param name="obj">字符串集合</param>
+	public static List<Guid> ToGuidList(this IList<string> obj)
+	{
+		if (obj == null)
+		{
+			return [];
+		}
+
+		return obj.Select(t => t.ToGuid()).ToList();
+	}
+	/// <summary>
+	/// 转换枚举描述
+	/// </summary>
+	/// <param name="obj"></param>
+	/// <returns></returns>
+	public static string ToDescription(this Enum obj)
+	{
+		return EnumHelper.GetDescription(obj.GetType(), obj);
+	}
+
+	/// <summary>
+	/// 枚举值 → 单个 EnumItem
+	/// </summary>
+	/// <typeparam name="TEnum"></typeparam>
+	/// <param name="value"></param>
+	/// <returns></returns>
+	public static EnumItem<TEnum> ToItem<TEnum>(this TEnum value) where TEnum : struct, Enum
+	{
+		return new EnumItem<TEnum>(value);
+	}
+	/// <summary>
+	/// 是否单一标记
+	/// </summary>
+	/// <param name="obj"></param>
+	/// <returns></returns>
+	public static bool IsSingleFlag(Enum obj)
+	{
+		return EnumHelper.IsSingleFlag(obj);
+	}
+	/// <summary>
+	/// 获取第一个标记
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="obj"></param>
+	/// <returns></returns>
+	public static Enum GetFirstFlag(this Enum obj)
+	{
+		return EnumHelper.GetFirstFlag(obj);
+	}
+}
diff --git a/Source/MAX.Core/Extensions/DictionaryExtension.cs b/Source/MAX.Core/Extensions/DictionaryExtension.cs
new file mode 100644
index 0000000..d71917e
--- /dev/null
+++ b/Source/MAX.Core/Extensions/DictionaryExtension.cs
@@ -0,0 +1,33 @@
+using MAX.Core.Cryptography;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MAX.Core.Extensions;
+
+public static class DictionaryExtension
+{
+	/// <summary>
+	/// 字典转url Get 参数
+	/// </summary>
+	/// <param name="parameters"></param>
+	/// <returns></returns>
+	public static string ToUrlParams(this IDictionary<string, string> parameters, bool IsUrlEncode = true)
+	{
+		IDictionary<string, string> sortedParams = new SortedDictionary<string, string>(parameters);
+		IEnumerator<KeyValuePair<string, string>> dem = sortedParams.GetEnumerator();
+		StringBuilder sb = new("");
+		while (dem.MoveNext())
+		{
+			string key = dem.Current.Key;
+			string value = dem.Current.Value;
+			if (!string.IsNullOrEmpty(key))
+			{
+				sb.Append(key).Append("=").Append(IsUrlEncode ? UrlHelper.Encode(value) : value).Append("&");
+
+			}
+		}
+		string content = sb.ToString().Substring(0, sb.Length - 1);
+
+		return content;
+	}
+}
diff --git a/Source/MAX.Core/Helpers/Common.cs b/Source/MAX.Core/Helpers/Common.cs
new file mode 100644
index 0000000..172d10d
--- /dev/null
+++ b/Source/MAX.Core/Helpers/Common.cs
@@ -0,0 +1,55 @@
+using System;
+
+namespace MAX.Core.Helpers;
+
+/// <summary>
+/// 常用公共操作
+/// </summary>
+public static partial class Common
+{
+	/// <summary>
+	/// 获取类型
+	/// </summary>
+	/// <typeparam name="T">类型</typeparam>
+	public static Type GetType<T>()
+	{
+		return GetType(typeof(T));
+	}
+
+	/// <summary>
+	/// 获取类型
+	/// </summary>
+	/// <param name="type">类型</param>
+	public static Type GetType(Type type)
+	{
+		return Nullable.GetUnderlyingType(type) ?? type;
+	}
+
+	/// <summary>
+	/// 换行符
+	/// </summary>
+	public static string Line => Environment.NewLine;
+
+
+#if NET5_0
+        /// <summary>
+        /// 是否Linux操作系统
+        /// </summary>
+        public static bool IsLinux => RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
+
+        /// <summary>
+        /// 是否Windows操作系统
+        /// </summary>
+        public static bool IsWindows => RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+
+        /// <summary>
+        /// 是否苹果操作系统
+        /// </summary>
+        public static bool IsOsx => RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+
+        /// <summary>
+        /// 当前操作系统
+        /// </summary>
+        public static string System => IsWindows ? "Windows" : IsLinux ? "Linux" : IsOsx ? "OSX" : string.Empty;
+#endif
+}
diff --git a/Source/MAX.Core/Helpers/CommonItem.cs b/Source/MAX.Core/Helpers/CommonItem.cs
new file mode 100644
index 0000000..7d83ee4
--- /dev/null
+++ b/Source/MAX.Core/Helpers/CommonItem.cs
@@ -0,0 +1,78 @@
+using System;
+
+namespace MAX.Core.Helpers;
+
+public class CommonItem : IComparable<CommonItem>
+{
+	/// <summary>
+	/// 初始化
+	/// </summary>
+	/// <param name="text">文本</param>
+	/// <param name="value">值</param>
+	/// <param name="sortId">排序号</param>
+	/// <param name="group">组</param>
+	/// <param name="disabled">禁用</param>
+	public CommonItem(string text, object value, string des = "", int? sortId = null, string group = null, bool? disabled = null)
+	{
+		Text = text;
+		Value = value;
+		Description = des;
+		SortId = sortId;
+		Group = group;
+		Disabled = disabled;
+	}
+
+	/// <summary>
+	/// 文本
+	/// </summary>
+	public string Text { get; }
+
+	/// <summary>
+	/// 值
+	/// </summary>
+	public object Value { get; protected set; }
+	/// <summary>
+	/// 描述
+	/// </summary>
+	public string Description { get; set; }
+	/// <summary>
+	/// 排序号
+	/// </summary>
+	public int? SortId { get; set; }
+
+	/// <summary>
+	/// 组
+	/// </summary>
+	public string Group { get; }
+	/// <summary>
+	/// 是否选中
+	/// </summary>
+	public bool IsSelected { get; set; }
+	/// <summary>
+	/// 禁用
+	/// </summary>
+	public bool? Disabled { get; }
+
+	/// <summary>
+	/// 比较
+	/// </summary>
+	/// <param name="other">其它列表项</param>
+	public int CompareTo(CommonItem other)
+	{
+		return string.Compare(Text, other.Text, StringComparison.CurrentCulture);
+	}
+}
+
+public class CommonItem<T> : CommonItem
+{
+	public new T Value
+	{
+		get { return (T)base.Value; }
+		set { base.Value = value; }
+	}
+	public CommonItem(string text, T value, string des = "", int? sortId = null, string group = null, bool? disabled = null) : base(text, value, des, sortId, group, disabled)
+	{
+	}
+
+
+}
diff --git a/Source/MAX.Core/Helpers/Convert.cs b/Source/MAX.Core/Helpers/Convert.cs
new file mode 100644
index 0000000..03dc271
--- /dev/null
+++ b/Source/MAX.Core/Helpers/Convert.cs
@@ -0,0 +1,385 @@
+using MAX.Core.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MAX.Core.Helpers;
+
+[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field)]
+public class ConvertAttribute : Attribute
+{
+	public Type ConverterType { get; set; }
+	public ConvertAttribute(Type type)
+	{
+		ConverterType = type;
+	}
+}
+public interface IConverter
+{
+	object Converter(object input);
+}
+/// <summary>
+/// 类型转换
+/// </summary>
+public static partial class Convert
+{
+	/// <summary>
+	/// 转换为32位整型
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static int ToInt(object input, int defvalue = 0)
+	{
+		return ToIntOrNull(input) ?? defvalue;
+	}
+
+	/// <summary>
+	/// 转换为32位可空整型
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static int? ToIntOrNull(object input)
+	{
+		bool success = int.TryParse(input.SafeString(), out int result);
+		if (success)
+		{
+			return result;
+		}
+
+		try
+		{
+			double? temp = ToDoubleOrNull(input, 0);
+			if (temp == null)
+			{
+				return null;
+			}
+
+			return System.Convert.ToInt32(temp);
+		}
+		catch
+		{
+			return null;
+		}
+	}
+
+	/// <summary>
+	/// 转换为64位整型
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static long ToLong(object input, long defvalue = 0)
+	{
+		return ToLongOrNull(input) ?? defvalue;
+	}
+
+	/// <summary>
+	/// 转换为64位可空整型
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static long? ToLongOrNull(object input)
+	{
+		bool success = long.TryParse(input.SafeString(), out long result);
+		if (success)
+		{
+			return result;
+		}
+
+		try
+		{
+			decimal? temp = ToDecimalOrNull(input, 0);
+			if (temp == null)
+			{
+				return null;
+			}
+
+			return System.Convert.ToInt64(temp);
+		}
+		catch
+		{
+			return null;
+		}
+	}
+
+	/// <summary>
+	/// 转换为32位浮点型,并按指定小数位舍入
+	/// </summary>
+	/// <param name="input">输入值</param>
+	/// <param name="digits">小数位数</param>
+	public static float ToFloat(object input, int? digits = null)
+	{
+		return ToFloatOrNull(input, digits) ?? 0;
+	}
+
+	/// <summary>
+	/// 转换为32位可空浮点型,并按指定小数位舍入
+	/// </summary>
+	/// <param name="input">输入值</param>
+	/// <param name="digits">小数位数</param>
+	public static float? ToFloatOrNull(object input, int? digits = null)
+	{
+		bool success = float.TryParse(input.SafeString(), out float result);
+		if (!success)
+		{
+			return null;
+		}
+
+		if (digits == null)
+		{
+			return result;
+		}
+
+		return (float)Math.Round(result, digits.Value);
+	}
+
+	/// <summary>
+	/// 转换为64位浮点型,并按指定小数位舍入
+	/// </summary>
+	/// <param name="input">输入值</param>
+	/// <param name="digits">小数位数</param>
+	public static double ToDouble(object input, int? digits = null, double defvalue = 0)
+	{
+		return ToDoubleOrNull(input, digits) ?? defvalue;
+	}
+
+	/// <summary>
+	/// 转换为64位可空浮点型,并按指定小数位舍入
+	/// </summary>
+	/// <param name="input">输入值</param>
+	/// <param name="digits">小数位数</param>
+	public static double? ToDoubleOrNull(object input, int? digits = null)
+	{
+		if (input is bool b)
+		{
+			return b ? 1 : 0;
+		}
+		bool success = double.TryParse(input.SafeString(), out double result);
+		if (!success)
+		{
+			return null;
+		}
+
+		if (digits == null)
+		{
+			return result;
+		}
+
+		return Math.Round(result, digits.Value);
+	}
+
+	/// <summary>
+	/// 转换为128位浮点型,并按指定小数位舍入
+	/// </summary>
+	/// <param name="input">输入值</param>
+	/// <param name="digits">小数位数</param>
+	public static decimal ToDecimal(object input, int? digits = null, decimal defvalue = 0)
+	{
+		return ToDecimalOrNull(input, digits) ?? defvalue;
+	}
+
+	/// <summary>
+	/// 转换为128位可空浮点型,并按指定小数位舍入
+	/// </summary>
+	/// <param name="input">输入值</param>
+	/// <param name="digits">小数位数</param>
+	public static decimal? ToDecimalOrNull(object input, int? digits = null)
+	{
+		bool success = decimal.TryParse(input.SafeString(), out decimal result);
+		if (!success)
+		{
+			return null;
+		}
+
+		if (digits == null)
+		{
+			return result;
+		}
+
+		return Math.Round(result, digits.Value);
+	}
+
+	/// <summary>
+	/// 转换为布尔值
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static bool ToBool(object input, bool defvalue = false)
+	{
+		return ToBoolOrNull(input) ?? defvalue;
+	}
+
+	/// <summary>
+	/// 转换为可空布尔值
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static bool? ToBoolOrNull(object input)
+	{
+		bool? value = GetBool(input);
+		if (value != null)
+		{
+			return value.Value;
+		}
+
+		return bool.TryParse(input.SafeString(), out bool result) ? result : null;
+	}
+
+	/// <summary>
+	/// 获取布尔值
+	/// </summary>
+	private static bool? GetBool(object input)
+	{
+		return input.SafeString().ToLower() switch
+		{
+			"0" => false,
+			"否" => false,
+			"不" => false,
+			"no" => false,
+			"fail" => false,
+			"1" => true,
+			"是" => true,
+			"ok" => true,
+			"yes" => true,
+			_ => null,
+		};
+	}
+
+	/// <summary>
+	/// 转换为日期
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static DateTime ToDate(object input)
+	{
+		return ToDateOrNull(input) ?? DateTime.MinValue;
+	}
+
+	/// <summary>
+	/// 转换为可空日期
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static DateTime? ToDateOrNull(object input)
+	{
+		return DateTime.TryParse(input.SafeString(), out DateTime result) ? result : null;
+	}
+
+	/// <summary>
+	/// 转换为Guid
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static Guid ToGuid(object input)
+	{
+		return ToGuidOrNull(input) ?? Guid.Empty;
+	}
+
+	/// <summary>
+	/// 转换为可空Guid
+	/// </summary>
+	/// <param name="input">输入值</param>
+	public static Guid? ToGuidOrNull(object input)
+	{
+		return Guid.TryParse(input.SafeString(), out Guid result) ? result : null;
+	}
+
+	/// <summary>
+	/// 转换为Guid集合
+	/// </summary>
+	/// <param name="input">以逗号分隔的Guid集合字符串，范例:83B0233C-A24F-49FD-8083-1337209EBC9A,EAB523C6-2FE7-47BE-89D5-C6D440C3033A</param>
+	public static List<Guid> ToGuidList(string input)
+	{
+		return ToList<Guid>(input);
+	}
+
+	/// <summary>
+	/// 泛型集合转换
+	/// </summary>
+	/// <typeparam name="T">目标元素类型</typeparam>
+	/// <param name="input">以逗号分隔的元素集合字符串，范例:83B0233C-A24F-49FD-8083-1337209EBC9A,EAB523C6-2FE7-47BE-89D5-C6D440C3033A</param>
+	public static List<T> ToList<T>(string input)
+	{
+		List<T> result = [];
+		if (string.IsNullOrWhiteSpace(input))
+		{
+			return result;
+		}
+
+		string[] array = input.Split(',');
+		result.AddRange(from each in array where !string.IsNullOrWhiteSpace(each) select To<T>(each));
+		return result;
+	}
+
+	/// <summary>
+	/// 通用泛型转换
+	/// </summary>
+	/// <typeparam name="T">目标类型</typeparam>
+	/// <param name="input">输入值</param>
+	public static T To<T>(object input)
+	{
+		Type type = Common.GetType<T>();
+		return (T)To(type, input);
+	}
+	public static object To(Type type, object input)
+	{
+		object defValue = null;
+		if (type != null)
+		{
+			defValue = type.IsValueType ? Activator.CreateInstance(type) : null;
+		}
+		if (input == null)
+		{
+			return defValue;
+		}
+
+		if (input is string && string.IsNullOrWhiteSpace(input.ToString()))
+		{
+			return defValue;
+		}
+
+		string typeName = type.Name.ToLower();
+		try
+		{
+			if (typeName == "string")
+			{
+				return input.ToString();
+			}
+
+			if (typeName == "guid")
+			{
+				return new Guid(input.ToString());
+			}
+
+			if (type.IsEnum)
+			{
+				return EnumHelper.Parse(type, input);
+			}
+
+			if (typeof(IConverter).IsAssignableFrom(type))
+			{
+				object instance = Activator.CreateInstance(type);
+				return ((IConverter)instance).Converter(input);
+			}
+			if (input is IConvertible)
+			{
+				return System.Convert.ChangeType(input, type);
+			}
+
+			return input;
+		}
+		catch
+		{
+			return defValue;
+		}
+	}
+	/// <summary>
+	/// 转换为字节数组
+	/// </summary>
+	/// <param name="input">输入值</param>        
+	public static byte[] ToBytes(string input)
+	{
+		return ToBytes(input, Encoding.UTF8);
+	}
+
+	/// <summary>
+	/// 转换为字节数组
+	/// </summary>
+	/// <param name="input">输入值</param>
+	/// <param name="encoding">字符编码</param>
+	public static byte[] ToBytes(string input, Encoding encoding)
+	{
+		return string.IsNullOrWhiteSpace(input) ? new byte[] { } : encoding.GetBytes(input);
+	}
+}
diff --git a/Source/MAX.Core/Helpers/CopyHelper.cs b/Source/MAX.Core/Helpers/CopyHelper.cs
new file mode 100644
index 0000000..dfb4e5f
--- /dev/null
+++ b/Source/MAX.Core/Helpers/CopyHelper.cs
@@ -0,0 +1,1151 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace MAX.Core.Helpers;
+
+public class CopyIgnoreAttribute : Attribute { }
+
+/// <summary>
+/// 拷贝帮助
+/// </summary>
+public class CopyHelper
+{
+	/// <summary>
+	/// 反射深拷贝
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="obj"></param>
+	/// <returns></returns>
+	public static T DeepCopy<T>(T obj)
+	{
+		return (T)DeepCopy((Object)obj, null);
+	}
+
+	public static T DeepCopy<T>(T obj, Func<FieldInfo, bool> filter = null)
+	{
+		return (T)DeepCopy((Object)obj, filter);
+	}
+
+	public static Object DeepCopy(Object originalObject, Func<FieldInfo, bool> filter = null)
+	{
+		return InternalCopy(
+			originalObject,
+			new Dictionary<Object, Object>(new ReferenceEqualityComparer()),
+			filter
+		);
+	}
+
+	private static readonly MethodInfo CloneMethod = typeof(Object).GetMethod(
+		"MemberwiseClone",
+		BindingFlags.NonPublic | BindingFlags.Instance
+	);
+
+	public static bool IsPrimitive(Type type)
+	{
+		if (type == typeof(String))
+		{
+			return true;
+		}
+
+		return type.IsValueType & type.IsPrimitive;
+	}
+
+	private static Object InternalCopy(
+		Object originalObject,
+		IDictionary<Object, Object> visited,
+		Func<FieldInfo, bool> filter = null
+	)
+	{
+		if (originalObject == null)
+		{
+			return null;
+		}
+
+		Type typeToReflect = originalObject.GetType();
+		if (IsPrimitive(typeToReflect))
+		{
+			return originalObject;
+		}
+
+		if (visited.ContainsKey(originalObject))
+		{
+			return visited[originalObject];
+		}
+
+		if (typeof(Delegate).IsAssignableFrom(typeToReflect))
+		{
+			return null;
+		}
+
+		object cloneObject = CloneMethod.Invoke(originalObject, null);
+		if (typeToReflect.IsArray)
+		{
+			Type arrayType = typeToReflect.GetElementType();
+			if (IsPrimitive(arrayType) == false)
+			{
+				Array clonedArray = (Array)cloneObject;
+				clonedArray.ForEach(
+					(array, indices) =>
+						array.SetValue(
+							InternalCopy(clonedArray.GetValue(indices), visited, filter),
+							indices
+						)
+				);
+			}
+		}
+		visited.Add(originalObject, cloneObject);
+		CopyFields(originalObject, visited, cloneObject, typeToReflect, filter: filter);
+		RecursiveCopyBaseTypePrivateFields(
+			originalObject,
+			visited,
+			cloneObject,
+			typeToReflect,
+			filter
+		);
+		return cloneObject;
+	}
+
+	private static void RecursiveCopyBaseTypePrivateFields(
+		object originalObject,
+		IDictionary<object, object> visited,
+		object cloneObject,
+		Type typeToReflect,
+		Func<FieldInfo, bool> filter = null
+	)
+	{
+		if (typeToReflect.BaseType != null)
+		{
+			RecursiveCopyBaseTypePrivateFields(
+				originalObject,
+				visited,
+				cloneObject,
+				typeToReflect.BaseType
+			);
+			CopyFields(
+				originalObject,
+				visited,
+				cloneObject,
+				typeToReflect.BaseType,
+				BindingFlags.Instance | BindingFlags.NonPublic,
+				info => info.IsPrivate
+			);
+		}
+	}
+
+	private static void CopyFields(
+		object originalObject,
+		IDictionary<object, object> visited,
+		object cloneObject,
+		Type typeToReflect,
+		BindingFlags bindingFlags =
+			BindingFlags.Instance
+			| BindingFlags.NonPublic
+			| BindingFlags.Public
+			| BindingFlags.FlattenHierarchy,
+		Func<FieldInfo, bool> filter = null
+	)
+	{
+		foreach (FieldInfo fieldInfo in typeToReflect.GetFields(bindingFlags))
+		{
+			if (filter != null && filter(fieldInfo) == false)
+			{
+				continue;
+			}
+
+			if (IsPrimitive(fieldInfo.FieldType))
+			{
+				continue;
+			}
+
+			object originalFieldValue = fieldInfo.GetValue(originalObject);
+			object clonedFieldValue = InternalCopy(originalFieldValue, visited, filter: filter);
+			fieldInfo.SetValue(cloneObject, clonedFieldValue);
+		}
+	}
+}
+
+/// <summary>
+/// Superfast deep copier class, which uses Expression trees.
+/// </summary>
+public static class DeepCopyByExpressionTrees
+{
+	private static readonly object IsStructTypeToDeepCopyDictionaryLocker = new();
+	private static Dictionary<Type, bool> IsStructTypeToDeepCopyDictionary =
+		[];
+
+	private static readonly object CompiledCopyFunctionsDictionaryLocker = new();
+	private static Dictionary<
+		Type,
+		Func<object, Dictionary<object, object>, object>
+	> CompiledCopyFunctionsDictionary =
+		[];
+
+	private static readonly Type ObjectType = typeof(Object);
+	private static readonly Type ObjectDictionaryType = typeof(Dictionary<object, object>);
+
+	/// <summary>
+	/// Creates a deep copy of an object.
+	/// </summary>
+	/// <typeparam name="T">Object type.</typeparam>
+	/// <param name="original">Object to copy.</param>
+	/// <param name="copiedReferencesDict">Dictionary of already copied objects (Keys: original objects, Values: their copies).</param>
+	/// <returns></returns>
+	public static T DeepCopyByExpressionTree<T>(
+		this T original,
+		Dictionary<object, object> copiedReferencesDict = null
+	)
+	{
+		return (T)DeepCopyByExpressionTreeObj(
+			original,
+			false,
+			copiedReferencesDict
+				?? new Dictionary<object, object>(new ReferenceEqualityComparer())
+		);
+	}
+
+	private static object DeepCopyByExpressionTreeObj(
+		object original,
+		bool forceDeepCopy,
+		Dictionary<object, object> copiedReferencesDict
+	)
+	{
+		if (original == null)
+		{
+			return null;
+		}
+
+		Type type = original.GetType();
+
+		if (IsDelegate(type))
+		{
+			return null;
+		}
+
+		if (!forceDeepCopy && !IsTypeToDeepCopy(type))
+		{
+			return original;
+		}
+
+
+		if (copiedReferencesDict.TryGetValue(original, out object alreadyCopiedObject))
+		{
+			return alreadyCopiedObject;
+		}
+
+		if (type == ObjectType)
+		{
+			return new object();
+		}
+
+		Func<object, Dictionary<object, object>, object> compiledCopyFunction = GetOrCreateCompiledLambdaCopyFunction(type);
+
+		object copy = compiledCopyFunction(original, copiedReferencesDict);
+
+		return copy;
+	}
+
+	private static Func<
+		object,
+		Dictionary<object, object>,
+		object
+	> GetOrCreateCompiledLambdaCopyFunction(Type type)
+	{
+		// The following structure ensures that multiple threads can use the dictionary
+		// even while dictionary is locked and being updated by other thread.
+		// That is why we do not modify the old dictionary instance but
+		// we replace it with a new instance everytime.
+
+
+		if (!CompiledCopyFunctionsDictionary.TryGetValue(type, out Func<object, Dictionary<object, object>, object> compiledCopyFunction))
+		{
+			lock (CompiledCopyFunctionsDictionaryLocker)
+			{
+				if (
+					!CompiledCopyFunctionsDictionary.TryGetValue(type, out compiledCopyFunction)
+				)
+				{
+					Expression<Func<object, Dictionary<object, object>, object>> uncompiledCopyFunction = CreateCompiledLambdaCopyFunctionForType(type);
+
+					compiledCopyFunction = uncompiledCopyFunction.Compile();
+
+					Dictionary<Type, Func<object, Dictionary<object, object>, object>> dictionaryCopy = CompiledCopyFunctionsDictionary.ToDictionary(
+						pair => pair.Key,
+						pair => pair.Value
+					);
+
+					dictionaryCopy.Add(type, compiledCopyFunction);
+
+					CompiledCopyFunctionsDictionary = dictionaryCopy;
+				}
+			}
+		}
+
+		return compiledCopyFunction;
+	}
+
+	private static Expression<
+		Func<object, Dictionary<object, object>, object>
+	> CreateCompiledLambdaCopyFunctionForType(Type type)
+	{
+
+		///// INITIALIZATION OF EXPRESSIONS AND VARIABLES
+
+		InitializeExpressions(
+			type,
+			out ParameterExpression inputParameter,
+			out ParameterExpression inputDictionary,
+			out ParameterExpression outputVariable,
+			out ParameterExpression boxingVariable,
+			out LabelTarget endLabel,
+			out List<ParameterExpression> variables,
+			out List<Expression> expressions
+		);
+
+		///// RETURN NULL IF ORIGINAL IS NULL
+
+		IfNullThenReturnNullExpression(inputParameter, endLabel, expressions);
+
+		///// MEMBERWISE CLONE ORIGINAL OBJECT
+
+		MemberwiseCloneInputToOutputExpression(
+			type,
+			inputParameter,
+			outputVariable,
+			expressions
+		);
+
+		///// STORE COPIED OBJECT TO REFERENCES DICTIONARY
+
+		if (IsClassOtherThanString(type))
+		{
+			StoreReferencesIntoDictionaryExpression(
+				inputParameter,
+				inputDictionary,
+				outputVariable,
+				expressions
+			);
+		}
+
+		///// COPY ALL NONVALUE OR NONPRIMITIVE FIELDS
+
+		FieldsCopyExpressions(
+			type,
+			inputParameter,
+			inputDictionary,
+			outputVariable,
+			boxingVariable,
+			expressions
+		);
+
+		///// COPY ELEMENTS OF ARRAY
+
+		if (IsArray(type) && IsTypeToDeepCopy(type.GetElementType()))
+		{
+			CreateArrayCopyLoopExpression(
+				type,
+				inputParameter,
+				inputDictionary,
+				outputVariable,
+				variables,
+				expressions
+			);
+		}
+
+		///// COMBINE ALL EXPRESSIONS INTO LAMBDA FUNCTION
+
+		Expression<Func<object, Dictionary<object, object>, object>> lambda = CombineAllIntoLambdaFunctionExpression(
+			inputParameter,
+			inputDictionary,
+			outputVariable,
+			endLabel,
+			variables,
+			expressions
+		);
+
+		return lambda;
+	}
+
+	private static void InitializeExpressions(
+		Type type,
+		out ParameterExpression inputParameter,
+		out ParameterExpression inputDictionary,
+		out ParameterExpression outputVariable,
+		out ParameterExpression boxingVariable,
+		out LabelTarget endLabel,
+		out List<ParameterExpression> variables,
+		out List<Expression> expressions
+	)
+	{
+		inputParameter = Expression.Parameter(ObjectType);
+
+		inputDictionary = Expression.Parameter(ObjectDictionaryType);
+
+		outputVariable = Expression.Variable(type);
+
+		boxingVariable = Expression.Variable(ObjectType);
+
+		endLabel = Expression.Label();
+
+		variables = [];
+
+		expressions = [];
+
+		variables.Add(outputVariable);
+		variables.Add(boxingVariable);
+	}
+
+	private static void IfNullThenReturnNullExpression(
+		ParameterExpression inputParameter,
+		LabelTarget endLabel,
+		List<Expression> expressions
+	)
+	{
+		///// Intended code:
+		/////
+		///// if (input == null)
+		///// {
+		/////     return null;
+		///// }
+
+		ConditionalExpression ifNullThenReturnNullExpression = Expression.IfThen(
+			Expression.Equal(inputParameter, Expression.Constant(null, ObjectType)),
+			Expression.Return(endLabel)
+		);
+
+		expressions.Add(ifNullThenReturnNullExpression);
+	}
+
+	private static void MemberwiseCloneInputToOutputExpression(
+		Type type,
+		ParameterExpression inputParameter,
+		ParameterExpression outputVariable,
+		List<Expression> expressions
+	)
+	{
+		///// Intended code:
+		/////
+		///// var output = (<type>)input.MemberwiseClone();
+
+		MethodInfo memberwiseCloneMethod = ObjectType.GetMethod(
+			"MemberwiseClone",
+			BindingFlags.NonPublic | BindingFlags.Instance
+		);
+
+		BinaryExpression memberwiseCloneInputExpression = Expression.Assign(
+			outputVariable,
+			Expression.Convert(Expression.Call(inputParameter, memberwiseCloneMethod), type)
+		);
+
+		expressions.Add(memberwiseCloneInputExpression);
+	}
+
+	private static void StoreReferencesIntoDictionaryExpression(
+		ParameterExpression inputParameter,
+		ParameterExpression inputDictionary,
+		ParameterExpression outputVariable,
+		List<Expression> expressions
+	)
+	{
+		///// Intended code:
+		/////
+		///// inputDictionary[(Object)input] = (Object)output;
+
+		BinaryExpression storeReferencesExpression = Expression.Assign(
+			Expression.Property(
+				inputDictionary,
+				ObjectDictionaryType.GetProperty("Item"),
+				inputParameter
+			),
+			Expression.Convert(outputVariable, ObjectType)
+		);
+
+		expressions.Add(storeReferencesExpression);
+	}
+
+	private static Expression<
+		Func<object, Dictionary<object, object>, object>
+	> CombineAllIntoLambdaFunctionExpression(
+		ParameterExpression inputParameter,
+		ParameterExpression inputDictionary,
+		ParameterExpression outputVariable,
+		LabelTarget endLabel,
+		List<ParameterExpression> variables,
+		List<Expression> expressions
+	)
+	{
+		expressions.Add(Expression.Label(endLabel));
+
+		expressions.Add(Expression.Convert(outputVariable, ObjectType));
+
+		BlockExpression finalBody = Expression.Block(variables, expressions);
+
+		Expression<Func<object, Dictionary<object, object>, object>> lambda = Expression.Lambda<Func<object, Dictionary<object, object>, object>>(
+			finalBody,
+			inputParameter,
+			inputDictionary
+		);
+
+		return lambda;
+	}
+
+	private static void CreateArrayCopyLoopExpression(
+		Type type,
+		ParameterExpression inputParameter,
+		ParameterExpression inputDictionary,
+		ParameterExpression outputVariable,
+		List<ParameterExpression> variables,
+		List<Expression> expressions
+	)
+	{
+		///// Intended code:
+		/////
+		///// int i1, i2, ..., in;
+		/////
+		///// int length1 = inputarray.GetLength(0);
+		///// i1 = 0;
+		///// while (true)
+		///// {
+		/////     if (i1 >= length1)
+		/////     {
+		/////         goto ENDLABELFORLOOP1;
+		/////     }
+		/////     int length2 = inputarray.GetLength(1);
+		/////     i2 = 0;
+		/////     while (true)
+		/////     {
+		/////         if (i2 >= length2)
+		/////         {
+		/////             goto ENDLABELFORLOOP2;
+		/////         }
+		/////         ...
+		/////         ...
+		/////         ...
+		/////         int lengthn = inputarray.GetLength(n);
+		/////         in = 0;
+		/////         while (true)
+		/////         {
+		/////             if (in >= lengthn)
+		/////             {
+		/////                 goto ENDLABELFORLOOPn;
+		/////             }
+		/////             outputarray[i1, i2, ..., in]
+		/////                 = (<elementType>)DeepCopyByExpressionTreeObj(
+		/////                        (Object)inputarray[i1, i2, ..., in])
+		/////             in++;
+		/////         }
+		/////         ENDLABELFORLOOPn:
+		/////         ...
+		/////         ...
+		/////         ...
+		/////         i2++;
+		/////     }
+		/////     ENDLABELFORLOOP2:
+		/////     i1++;
+		///// }
+		///// ENDLABELFORLOOP1:
+
+		int rank = type.GetArrayRank();
+
+		List<ParameterExpression> indices = GenerateIndices(rank);
+
+		variables.AddRange(indices);
+
+		Type elementType = type.GetElementType();
+
+		BinaryExpression assignExpression = ArrayFieldToArrayFieldAssignExpression(
+			inputParameter,
+			inputDictionary,
+			outputVariable,
+			elementType,
+			type,
+			indices
+		);
+
+		Expression forExpression = assignExpression;
+
+		for (int dimension = 0; dimension < rank; dimension++)
+		{
+			ParameterExpression indexVariable = indices[dimension];
+
+			forExpression = LoopIntoLoopExpression(
+				inputParameter,
+				indexVariable,
+				forExpression,
+				dimension
+			);
+		}
+
+		expressions.Add(forExpression);
+	}
+
+	private static List<ParameterExpression> GenerateIndices(int arrayRank)
+	{
+		///// Intended code:
+		/////
+		///// int i1, i2, ..., in;
+
+		List<ParameterExpression> indices = [];
+
+		for (int i = 0; i < arrayRank; i++)
+		{
+			ParameterExpression indexVariable = Expression.Variable(typeof(Int32));
+
+			indices.Add(indexVariable);
+		}
+
+		return indices;
+	}
+
+	private static BinaryExpression ArrayFieldToArrayFieldAssignExpression(
+		ParameterExpression inputParameter,
+		ParameterExpression inputDictionary,
+		ParameterExpression outputVariable,
+		Type elementType,
+		Type arrayType,
+		List<ParameterExpression> indices
+	)
+	{
+		///// Intended code:
+		/////
+		///// outputarray[i1, i2, ..., in]
+		/////     = (<elementType>)DeepCopyByExpressionTreeObj(
+		/////            (Object)inputarray[i1, i2, ..., in]);
+
+		IndexExpression indexTo = Expression.ArrayAccess(outputVariable, indices);
+
+		MethodCallExpression indexFrom = Expression.ArrayIndex(
+			Expression.Convert(inputParameter, arrayType),
+			indices
+		);
+
+		bool forceDeepCopy = elementType != ObjectType;
+
+		UnaryExpression rightSide = Expression.Convert(
+			Expression.Call(
+				DeepCopyByExpressionTreeObjMethod,
+				Expression.Convert(indexFrom, ObjectType),
+				Expression.Constant(forceDeepCopy, typeof(Boolean)),
+				inputDictionary
+			),
+			elementType
+		);
+
+		BinaryExpression assignExpression = Expression.Assign(indexTo, rightSide);
+
+		return assignExpression;
+	}
+
+	private static BlockExpression LoopIntoLoopExpression(
+		ParameterExpression inputParameter,
+		ParameterExpression indexVariable,
+		Expression loopToEncapsulate,
+		int dimension
+	)
+	{
+		///// Intended code:
+		/////
+		///// int length = inputarray.GetLength(dimension);
+		///// i = 0;
+		///// while (true)
+		///// {
+		/////     if (i >= length)
+		/////     {
+		/////         goto ENDLABELFORLOOP;
+		/////     }
+		/////     loopToEncapsulate;
+		/////     i++;
+		///// }
+		///// ENDLABELFORLOOP:
+
+		ParameterExpression lengthVariable = Expression.Variable(typeof(Int32));
+
+		LabelTarget endLabelForThisLoop = Expression.Label();
+
+		LoopExpression newLoop = Expression.Loop(
+			Expression.Block(
+				new ParameterExpression[0],
+				Expression.IfThen(
+					Expression.GreaterThanOrEqual(indexVariable, lengthVariable),
+					Expression.Break(endLabelForThisLoop)
+				),
+				loopToEncapsulate,
+				Expression.PostIncrementAssign(indexVariable)
+			),
+			endLabelForThisLoop
+		);
+
+		BinaryExpression lengthAssignment = GetLengthForDimensionExpression(
+			lengthVariable,
+			inputParameter,
+			dimension
+		);
+
+		BinaryExpression indexAssignment = Expression.Assign(indexVariable, Expression.Constant(0));
+
+		return Expression.Block(
+			new[] { lengthVariable },
+			lengthAssignment,
+			indexAssignment,
+			newLoop
+		);
+	}
+
+	private static BinaryExpression GetLengthForDimensionExpression(
+		ParameterExpression lengthVariable,
+		ParameterExpression inputParameter,
+		int i
+	)
+	{
+		///// Intended code:
+		/////
+		///// length = ((Array)input).GetLength(i);
+
+		MethodInfo getLengthMethod = typeof(Array).GetMethod(
+			"GetLength",
+			BindingFlags.Public | BindingFlags.Instance
+		);
+
+		ConstantExpression dimensionConstant = Expression.Constant(i);
+
+		return Expression.Assign(
+			lengthVariable,
+			Expression.Call(
+				Expression.Convert(inputParameter, typeof(Array)),
+				getLengthMethod,
+				new[] { dimensionConstant }
+			)
+		);
+	}
+
+	private static void FieldsCopyExpressions(
+		Type type,
+		ParameterExpression inputParameter,
+		ParameterExpression inputDictionary,
+		ParameterExpression outputVariable,
+		ParameterExpression boxingVariable,
+		List<Expression> expressions
+	)
+	{
+		FieldInfo[] fields = GetAllRelevantFields(type);
+
+		List<FieldInfo> readonlyFields = fields.Where(f => f.IsInitOnly).ToList();
+		List<FieldInfo> writableFields = fields.Where(f => !f.IsInitOnly).ToList();
+
+		///// READONLY FIELDS COPY (with boxing)
+
+		bool shouldUseBoxing = readonlyFields.Any();
+
+		if (shouldUseBoxing)
+		{
+			BinaryExpression boxingExpression = Expression.Assign(
+				boxingVariable,
+				Expression.Convert(outputVariable, ObjectType)
+			);
+
+			expressions.Add(boxingExpression);
+		}
+
+		foreach (FieldInfo field in readonlyFields)
+		{
+			if (IsDelegate(field.FieldType))
+			{
+				ReadonlyFieldToNullExpression(field, boxingVariable, expressions);
+			}
+			else
+			{
+				ReadonlyFieldCopyExpression(
+					type,
+					field,
+					inputParameter,
+					inputDictionary,
+					boxingVariable,
+					expressions
+				);
+			}
+		}
+
+		if (shouldUseBoxing)
+		{
+			BinaryExpression unboxingExpression = Expression.Assign(
+				outputVariable,
+				Expression.Convert(boxingVariable, type)
+			);
+
+			expressions.Add(unboxingExpression);
+		}
+
+		///// NOT-READONLY FIELDS COPY
+
+		foreach (FieldInfo field in writableFields)
+		{
+			if (IsDelegate(field.FieldType))
+			{
+				WritableFieldToNullExpression(field, outputVariable, expressions);
+			}
+			else
+			{
+				WritableFieldCopyExpression(
+					type,
+					field,
+					inputParameter,
+					inputDictionary,
+					outputVariable,
+					expressions
+				);
+			}
+		}
+	}
+
+	private static FieldInfo[] GetAllRelevantFields(Type type, bool forceAllFields = false)
+	{
+		List<FieldInfo> fieldsList = [];
+
+		Type typeCache = type;
+
+		while (typeCache != null)
+		{
+			fieldsList.AddRange(
+				typeCache
+					.GetFields(
+						BindingFlags.Instance
+							| BindingFlags.Public
+							| BindingFlags.NonPublic
+							| BindingFlags.FlattenHierarchy
+					)
+					.Where(field => forceAllFields || IsTypeToDeepCopy(field.FieldType))
+			);
+
+			typeCache = typeCache.BaseType;
+		}
+
+		return fieldsList.ToArray();
+	}
+
+	private static FieldInfo[] GetAllFields(Type type)
+	{
+		return GetAllRelevantFields(type, forceAllFields: true);
+	}
+
+	private static readonly Type FieldInfoType = typeof(FieldInfo);
+	private static readonly MethodInfo SetValueMethod = FieldInfoType.GetMethod(
+		"SetValue",
+		new[] { ObjectType, ObjectType }
+	);
+
+	private static void ReadonlyFieldToNullExpression(
+		FieldInfo field,
+		ParameterExpression boxingVariable,
+		List<Expression> expressions
+	)
+	{
+		// This option must be implemented by Reflection because of the following:
+		// https://visualstudio.uservoice.com/forums/121579-visual-studio-2015/suggestions/2727812-allow-expression-assign-to-set-readonly-struct-f
+
+		///// Intended code:
+		/////
+		///// fieldInfo.SetValue(boxing, <fieldtype>null);
+
+		MethodCallExpression fieldToNullExpression = Expression.Call(
+			Expression.Constant(field),
+			SetValueMethod,
+			boxingVariable,
+			Expression.Constant(null, field.FieldType)
+		);
+
+		expressions.Add(fieldToNullExpression);
+	}
+
+	private static readonly Type ThisType = typeof(DeepCopyByExpressionTrees);
+	private static readonly MethodInfo DeepCopyByExpressionTreeObjMethod = ThisType.GetMethod(
+		"DeepCopyByExpressionTreeObj",
+		BindingFlags.NonPublic | BindingFlags.Static
+	);
+
+	private static void ReadonlyFieldCopyExpression(
+		Type type,
+		FieldInfo field,
+		ParameterExpression inputParameter,
+		ParameterExpression inputDictionary,
+		ParameterExpression boxingVariable,
+		List<Expression> expressions
+	)
+	{
+		// This option must be implemented by Reflection (SetValueMethod) because of the following:
+		// https://visualstudio.uservoice.com/forums/121579-visual-studio-2015/suggestions/2727812-allow-expression-assign-to-set-readonly-struct-f
+
+		///// Intended code:
+		/////
+		///// fieldInfo.SetValue(boxing, DeepCopyByExpressionTreeObj((Object)((<type>)input).<field>))
+
+		MemberExpression fieldFrom = Expression.Field(Expression.Convert(inputParameter, type), field);
+
+		bool forceDeepCopy = field.FieldType != ObjectType;
+
+		MethodCallExpression fieldDeepCopyExpression = Expression.Call(
+			Expression.Constant(field, FieldInfoType),
+			SetValueMethod,
+			boxingVariable,
+			Expression.Call(
+				DeepCopyByExpressionTreeObjMethod,
+				Expression.Convert(fieldFrom, ObjectType),
+				Expression.Constant(forceDeepCopy, typeof(Boolean)),
+				inputDictionary
+			)
+		);
+
+		expressions.Add(fieldDeepCopyExpression);
+	}
+
+	private static void WritableFieldToNullExpression(
+		FieldInfo field,
+		ParameterExpression outputVariable,
+		List<Expression> expressions
+	)
+	{
+		///// Intended code:
+		/////
+		///// output.<field> = (<type>)null;
+
+		MemberExpression fieldTo = Expression.Field(outputVariable, field);
+
+		BinaryExpression fieldToNullExpression = Expression.Assign(
+			fieldTo,
+			Expression.Constant(null, field.FieldType)
+		);
+
+		expressions.Add(fieldToNullExpression);
+	}
+
+	private static void WritableFieldCopyExpression(
+		Type type,
+		FieldInfo field,
+		ParameterExpression inputParameter,
+		ParameterExpression inputDictionary,
+		ParameterExpression outputVariable,
+		List<Expression> expressions
+	)
+	{
+		///// Intended code:
+		/////
+		///// output.<field> = (<fieldType>)DeepCopyByExpressionTreeObj((Object)((<type>)input).<field>);
+
+		MemberExpression fieldFrom = Expression.Field(Expression.Convert(inputParameter, type), field);
+
+		Type fieldType = field.FieldType;
+
+		MemberExpression fieldTo = Expression.Field(outputVariable, field);
+
+		bool forceDeepCopy = field.FieldType != ObjectType;
+
+		BinaryExpression fieldDeepCopyExpression = Expression.Assign(
+			fieldTo,
+			Expression.Convert(
+				Expression.Call(
+					DeepCopyByExpressionTreeObjMethod,
+					Expression.Convert(fieldFrom, ObjectType),
+					Expression.Constant(forceDeepCopy, typeof(Boolean)),
+					inputDictionary
+				),
+				fieldType
+			)
+		);
+
+		expressions.Add(fieldDeepCopyExpression);
+	}
+
+	private static bool IsArray(Type type)
+	{
+		return type.IsArray;
+	}
+
+	private static bool IsDelegate(Type type)
+	{
+		return typeof(Delegate).IsAssignableFrom(type);
+	}
+
+	private static bool IsTypeToDeepCopy(Type type)
+	{
+		return IsClassOtherThanString(type) || IsStructWhichNeedsDeepCopy(type);
+	}
+
+	private static bool IsClassOtherThanString(Type type)
+	{
+		return !type.IsValueType && type != typeof(String);
+	}
+
+	private static bool IsStructWhichNeedsDeepCopy(Type type)
+	{
+		// The following structure ensures that multiple threads can use the dictionary
+		// even while dictionary is locked and being updated by other thread.
+		// That is why we do not modify the old dictionary instance but
+		// we replace it with a new instance everytime.
+
+
+		if (!IsStructTypeToDeepCopyDictionary.TryGetValue(type, out bool isStructTypeToDeepCopy))
+		{
+			lock (IsStructTypeToDeepCopyDictionaryLocker)
+			{
+				if (
+					!IsStructTypeToDeepCopyDictionary.TryGetValue(
+						type,
+						out isStructTypeToDeepCopy
+					)
+				)
+				{
+					isStructTypeToDeepCopy = IsStructWhichNeedsDeepCopy_NoDictionaryUsed(type);
+
+					Dictionary<Type, bool> newDictionary = IsStructTypeToDeepCopyDictionary.ToDictionary(
+						pair => pair.Key,
+						pair => pair.Value
+					);
+
+					newDictionary[type] = isStructTypeToDeepCopy;
+
+					IsStructTypeToDeepCopyDictionary = newDictionary;
+				}
+			}
+		}
+
+		return isStructTypeToDeepCopy;
+	}
+
+	private static bool IsStructWhichNeedsDeepCopy_NoDictionaryUsed(Type type)
+	{
+		return IsStructOtherThanBasicValueTypes(type)
+			&& HasInItsHierarchyFieldsWithClasses(type);
+	}
+
+	private static bool IsStructOtherThanBasicValueTypes(Type type)
+	{
+		return type.IsValueType && !type.IsPrimitive && !type.IsEnum && type != typeof(Decimal);
+	}
+
+	private static bool HasInItsHierarchyFieldsWithClasses(
+		Type type,
+		HashSet<Type> alreadyCheckedTypes = null
+	)
+	{
+		alreadyCheckedTypes ??= [];
+
+		alreadyCheckedTypes.Add(type);
+
+		FieldInfo[] allFields = GetAllFields(type);
+
+		List<Type> allFieldTypes = allFields.Select(f => f.FieldType).Distinct().ToList();
+
+		bool hasFieldsWithClasses = allFieldTypes.Any(IsClassOtherThanString);
+
+		if (hasFieldsWithClasses)
+		{
+			return true;
+		}
+
+		List<Type> notBasicStructsTypes = allFieldTypes
+			.Where(IsStructOtherThanBasicValueTypes)
+			.ToList();
+
+		List<Type> typesToCheck = notBasicStructsTypes
+			.Where(t => !alreadyCheckedTypes.Contains(t))
+			.ToList();
+
+		foreach (Type typeToCheck in typesToCheck)
+		{
+			if (HasInItsHierarchyFieldsWithClasses(typeToCheck, alreadyCheckedTypes))
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	public class ReferenceEqualityComparer : EqualityComparer<Object>
+	{
+		public override bool Equals(object x, object y)
+		{
+			return ReferenceEquals(x, y);
+		}
+
+		public override int GetHashCode(object obj)
+		{
+			if (obj == null)
+			{
+				return 0;
+			}
+
+			return obj.GetHashCode();
+		}
+	}
+}
+
+public class ReferenceEqualityComparer : EqualityComparer<Object>
+{
+	public override bool Equals(object x, object y)
+	{
+		return ReferenceEquals(x, y);
+	}
+
+	public override int GetHashCode(object obj)
+	{
+		if (obj == null)
+		{
+			return 0;
+		}
+
+		return obj.GetHashCode();
+	}
+}
+
+public static class ArrayExtensions
+{
+	public static void ForEach(this Array array, Action<Array, int[]> action)
+	{
+		if (array.LongLength == 0)
+		{
+			return;
+		}
+
+		ArrayTraverse walker = new(array);
+		do
+		{
+			action(array, walker.Position);
+		}
+		while (walker.Step());
+	}
+}
+
+internal class ArrayTraverse
+{
+	public int[] Position;
+	private readonly int[] maxLengths;
+
+	public ArrayTraverse(Array array)
+	{
+		maxLengths = new int[array.Rank];
+		for (int i = 0; i < array.Rank; ++i)
+		{
+			maxLengths[i] = array.GetLength(i) - 1;
+		}
+		Position = new int[array.Rank];
+	}
+
+	public bool Step()
+	{
+		for (int i = 0; i < Position.Length; ++i)
+		{
+			if (Position[i] < maxLengths[i])
+			{
+				Position[i]++;
+				for (int j = 0; j < i; j++)
+				{
+					Position[j] = 0;
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+}
diff --git a/Source/MAX.Core/Helpers/DateHelper.cs b/Source/MAX.Core/Helpers/DateHelper.cs
new file mode 100644
index 0000000..d9eb110
--- /dev/null
+++ b/Source/MAX.Core/Helpers/DateHelper.cs
@@ -0,0 +1,110 @@
+using System;
+
+namespace MAX.Core.Helpers;
+
+public class DateHelper
+{
+	/// <summary>
+	/// Unix纪元时间
+	/// </summary>
+	private static readonly DateTime UnixEpoch = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+	/// <summary>
+	/// 将时间转换为秒级时间戳
+	/// </summary>
+	/// <param name="dateTime"></param>
+	/// <returns></returns>
+	public static long GetUnixTimestampInSeconds(DateTime dateTime)
+	{
+		TimeSpan timeSpan = dateTime.ToUniversalTime() - UnixEpoch;
+		return (long)timeSpan.TotalSeconds;
+	}
+
+	/// <summary>
+	/// 将时间转换为毫秒级时间戳
+	/// </summary>
+	/// <param name="dateTime"></param>
+	/// <returns></returns>
+	public static long GetUnixTimestampInMilliseconds(DateTime dateTime)
+	{
+		TimeSpan timeSpan = dateTime.ToUniversalTime() - UnixEpoch;
+		return (long)timeSpan.TotalMilliseconds;
+	}
+
+	/// <summary>
+	/// 将时间转换为微秒时间戳
+	/// </summary>
+	/// <param name="dateTime"></param>
+	/// <returns></returns>
+	public static long GetUnixTimestampInMicroseconds(DateTime dateTime)
+	{
+		long us = dateTime.ToUniversalTime().Ticks - UnixEpoch.Ticks;
+		return us;
+	}
+	/// <summary>
+	/// 将时间Ticks转换为毫微秒时间戳
+	/// </summary>
+	/// <param name="dateTime"></param>
+	/// <returns></returns>
+	public static long GetUnixTimestampInMicroseconds(long ticks)
+	{
+		long us = ticks - UnixEpoch.Ticks;
+		return us;
+	}
+
+	/// <summary>
+	/// 将秒级时间戳转换为时间
+	/// </summary>
+	/// <param name="timestamp"></param>
+	/// <returns></returns>
+	public static DateTime ConvertFromUnixTimestampInSeconds(long timestamp)
+	{
+		return UnixEpoch.AddSeconds(timestamp).ToLocalTime();
+	}
+
+	/// <summary>
+	/// 将毫秒级时间戳转换为时间
+	/// </summary>
+	/// <param name="timestamp"></param>
+	/// <returns></returns>
+	public static DateTime ConvertFromUnixTimestampInMilliseconds(long timestamp)
+	{
+		return UnixEpoch.AddMilliseconds(timestamp).ToLocalTime();
+	}
+	/// <summary>
+	/// 将微秒级时间戳转换为时间
+	/// </summary>
+	/// <param name="timestamp"></param>
+	/// <returns></returns>
+	public static DateTime ConvertFromUnixTimestampInMicroseconds(long timestamp)
+	{
+		long us = timestamp + UnixEpoch.Ticks;
+		return new DateTime(us);
+	}
+	/// <summary>
+	/// 获取当前时间的秒级时间戳
+	/// </summary>
+	/// <returns></returns>
+	public static long GetCurrentUnixTimestampInSeconds()
+	{
+		return GetUnixTimestampInSeconds(DateTime.UtcNow);
+	}
+
+	/// <summary>
+	/// 获取当前时间的毫秒级时间戳
+	/// </summary>
+	/// <returns></returns>
+	public static long GetCurrentUnixTimestampInMilliseconds()
+	{
+		return GetUnixTimestampInMilliseconds(DateTime.UtcNow);
+	}
+
+	/// <summary>
+	/// 获取当前时间的微秒级时间戳
+	/// </summary>
+	/// <returns></returns>
+	public static long GetCurrentUnixTimestampInMicroseconds()
+	{
+		return GetUnixTimestampInMicroseconds(DateTime.UtcNow);
+	}
+}
diff --git a/Source/MAX.Core/Helpers/EnumHelper.cs b/Source/MAX.Core/Helpers/EnumHelper.cs
new file mode 100644
index 0000000..439042d
--- /dev/null
+++ b/Source/MAX.Core/Helpers/EnumHelper.cs
@@ -0,0 +1,341 @@
+using MAX.Core.Extensions;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Reflection;
+
+namespace MAX.Core.Helpers;
+
+/// <summary>
+/// 枚举操作
+/// </summary>
+public static partial class EnumHelper
+{
+	/// <summary>
+	/// 获取实例
+	/// </summary>
+	/// <typeparam name="TEnum">枚举类型</typeparam>
+	/// <param name="member">成员名或值,范例:Enum1枚举有成员A=0,则传入"A"或"0"获取 Enum1.A</param>
+	public static TEnum Parse<TEnum>(object member)
+	{
+		string value = member.SafeString();
+		if (string.IsNullOrWhiteSpace(value))
+		{
+			if (typeof(TEnum).IsGenericType)
+			{
+				return default;
+			}
+
+			throw new ArgumentNullException(nameof(member));
+		}
+		return (TEnum)Enum.Parse(Common.GetType<TEnum>(), value, true);
+	}
+	public static object Parse(Type enumObj, object member)
+	{
+		string value = member.SafeString();
+		if (string.IsNullOrWhiteSpace(value))
+		{
+			if (enumObj.IsGenericType)
+			{
+				return null;
+			}
+
+			throw new ArgumentNullException(nameof(member));
+		}
+		return Enum.Parse(enumObj, value, true);
+	}
+	public static TEnum ParseByDescription<TEnum>(string description)
+	{
+		return (TEnum)ParseByDescription(Common.GetType<TEnum>(), description);
+	}
+	public static object ParseByDescription(Type enumObj, string description)
+	{
+		List<EnumItem> listitem = GetItems(enumObj);
+		foreach (EnumItem item in listitem)
+		{
+			if (item.Description == description)
+			{
+				return Enum.Parse(enumObj, item.Numeric.ToString(), true);
+			}
+		}
+		return null;
+	}
+	/// <summary>
+	/// 获取成员名
+	/// </summary>
+	/// <typeparam name="TEnum">枚举类型</typeparam>
+	/// <param name="member">成员名、值、实例均可,范例:Enum1枚举有成员A=0,则传入Enum1.A或0,获取成员名"A"</param>
+	public static string GetName<TEnum>(object member)
+	{
+		return GetName(Common.GetType<TEnum>(), member);
+	}
+
+	/// <summary>
+	/// 获取成员名
+	/// </summary>
+	/// <param name="type">枚举类型</param>
+	/// <param name="member">成员名、值、实例均可</param>
+	public static string GetName(Type type, object member)
+	{
+		if (type == null)
+		{
+			return string.Empty;
+		}
+
+		if (member == null)
+		{
+			return string.Empty;
+		}
+
+		if (member is string)
+		{
+			return member.ToString();
+		}
+
+		if (type.GetTypeInfo().IsEnum == false)
+		{
+			return string.Empty;
+		}
+
+		return Enum.GetName(type, member);
+	}
+
+	/// <summary>
+	/// 获取成员值
+	/// </summary>
+	/// <typeparam name="TEnum">枚举类型</typeparam>
+	/// <param name="member">成员名、值、实例均可，范例:Enum1枚举有成员A=0,可传入"A"、0、Enum1.A，获取值0</param>
+	public static int GetValue<TEnum>(object member)
+	{
+		return GetValue(Common.GetType<TEnum>(), member);
+	}
+
+	/// <summary>
+	/// 获取成员值
+	/// </summary>
+	/// <param name="type">枚举类型</param>
+	/// <param name="member">成员名、值、实例均可</param>
+	public static int GetValue(Type type, object member)
+	{
+		string value = member.SafeString();
+		if (string.IsNullOrWhiteSpace(value))
+		{
+			throw new ArgumentNullException(nameof(member));
+		}
+
+		return (int)Enum.Parse(type, member.ToString(), true);
+	}
+	/// <summary>
+	/// 获取描述,使用System.ComponentModel.Description特性设置描述
+	/// </summary>
+	/// <typeparam name="TEnum">枚举类型</typeparam>
+	/// <param name="member">成员名、值、实例均可</param>
+	public static string GetDescription<TEnum>(object member)
+	{
+		return ReflectionHelper.GetDescription<TEnum>(GetName<TEnum>(member));
+	}
+
+	/// <summary>
+	/// 获取描述,使用System.ComponentModel.Description特性设置描述
+	/// </summary>
+	/// <param name="type">枚举类型</param>
+	/// <param name="member">成员名、值、实例均可</param>
+	public static string GetDescription(Type type, object member)
+	{
+		return ReflectionHelper.GetDescription(type, GetName(type, member));
+	}
+
+
+	/// <summary>
+	/// 获取项集合,文本设置为Description，值为Value
+	/// </summary>
+	/// <typeparam name="TEnum">枚举类型</typeparam>
+	public static List<EnumItem> GetItems<TEnum>()
+	{
+		return GetItems(typeof(TEnum));
+	}
+
+	/// <summary>
+	/// 获取项集合,文本设置为Description，值为Value
+	/// </summary>
+	/// <param name="type">枚举类型</param>
+	public static List<EnumItem> GetItems(Type type)
+	{
+		type = Common.GetType(type);
+		if (type.IsEnum == false)
+		{
+			throw new InvalidOperationException($"类型 {type} 不是枚举");
+		}
+
+		List<EnumItem> result = [];
+		foreach (FieldInfo field in type.GetFields())
+		{
+			AddItem(type, result, field);
+		}
+
+		return result.OrderBy(t => t.Numeric).ToList();
+	}
+
+	public static CommonItem GetItem(object obj)
+	{
+		CommonItem item = null;
+		if (obj is Enum em)
+		{
+			//item.Text = em.get
+			string text = em.ToString();
+			int value = GetValue(obj.GetType(), obj);
+			string description = em.ToDescription();
+			item = new CommonItem(text, value, des: description);
+		}
+		return item;
+	}
+
+	/// <summary>
+	/// 添加描述项
+	/// </summary>
+	private static void AddItem(Type type, ICollection<EnumItem> result, FieldInfo field)
+	{
+		if (!field.FieldType.IsEnum)
+		{
+			return;
+		}
+
+		string text = field.Name;
+		int value = GetValue(type, field.Name);
+		string description = ReflectionHelper.GetDescription(field);
+		result.Add(new EnumItem(text, value, description));
+	}
+
+	/// <summary>
+	/// 获取名称集合
+	/// </summary>
+	/// <typeparam name="TEnum">枚举类型</typeparam>
+	public static List<string> GetNames<TEnum>()
+	{
+		return GetNames(typeof(TEnum));
+	}
+
+	/// <summary>
+	/// 获取名称集合
+	/// </summary>
+	/// <param name="type">枚举类型</param>
+	public static List<string> GetNames(Type type)
+	{
+		type = Common.GetType(type);
+		if (type.IsEnum == false)
+		{
+			throw new InvalidOperationException($"类型 {type} 不是枚举");
+		}
+
+		List<string> result = [];
+		foreach (FieldInfo field in type.GetFields())
+		{
+			if (!field.FieldType.IsEnum)
+			{
+				continue;
+			}
+
+			result.Add(field.Name);
+		}
+		return result;
+	}
+
+
+	/// <summary>
+	/// 获取名称集合
+	/// </summary>
+	/// <typeparam name="TEnum">枚举类型</typeparam>
+	public static List<string> GetDescriptions<TEnum>()
+	{
+		return GetDescriptions(typeof(TEnum));
+	}
+
+	/// <summary>
+	/// 获取名称集合
+	/// </summary>
+	/// <param name="type">枚举类型</param>
+	public static List<string> GetDescriptions(Type type)
+	{
+		type = Common.GetType(type);
+		if (type.IsEnum == false)
+		{
+			throw new InvalidOperationException($"类型 {type} 不是枚举");
+		}
+
+		List<string> result = [];
+		foreach (FieldInfo field in type.GetFields())
+		{
+			if (!field.FieldType.IsEnum)
+			{
+				continue;
+			}
+
+			string description = ReflectionHelper.GetDescription(field);
+			result.Add(description);
+		}
+		return result;
+	}
+	/// <summary>
+	/// 是否单一标记
+	/// </summary>
+	/// <param name="obj"></param>
+	/// <returns></returns>
+	public static bool IsSingleFlag(Enum obj)
+	{
+		int intValue = GetValue(obj.GetType(), obj);
+		return (intValue > 0) && ((intValue & (intValue - 1)) == 0);
+	}
+	/// <summary>
+	/// 获取第一个标记
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="value"></param>
+	/// <returns></returns>
+	public static T GetFirstFlag<T>(T value) where T : Enum
+	{
+		long v = System.Convert.ToInt64(value);
+		long first = v & -v;
+		return Enum.GetValues(typeof(T)).Cast<T>().First(flag => System.Convert.ToInt64(flag) == first);
+	}
+}
+/// <summary>
+/// Enum展示类型
+/// </summary>
+public enum EnumDisplayType
+{
+	Text,
+	Value,
+	Description,
+	CommonItem
+}
+public class EnumItem
+{
+	public string Name { get; init; }
+	public int Numeric { get; init; }
+	public string Description { get; init; }
+
+	public EnumItem(string name, int numeric, string description)
+	{
+		Name = name;
+		Numeric = numeric;
+		Description = description;
+	}
+}
+public class EnumItem<TEnum> : EnumItem where TEnum : struct, Enum
+{
+	public TEnum Value { get; }
+
+	public EnumItem(TEnum value)
+		: base(value.ToString(), System.Convert.ToInt32(value), GetDescription(value))
+	{
+		Value = value;
+	}
+	private static string GetDescription(TEnum value)
+	{
+		var field = typeof(TEnum).GetField(value.ToString())!;
+		var attr = field.GetCustomAttribute<DescriptionAttribute>();
+		return attr?.Description ?? string.Empty;
+	}
+
+}
\ No newline at end of file
diff --git a/Source/MAX.Core/Helpers/EnvironmentHelper.cs b/Source/MAX.Core/Helpers/EnvironmentHelper.cs
new file mode 100644
index 0000000..1bd0d39
--- /dev/null
+++ b/Source/MAX.Core/Helpers/EnvironmentHelper.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MAX.Core.Helpers;
+
+public class EnvironmentHelper
+{
+	private static string? _currentEnvironment;
+
+	// 获取当前环境
+	public static string CurrentEnvironment
+	{
+		get
+		{
+			if (_currentEnvironment == null)
+			{
+				_currentEnvironment = DetermineEnvironment();
+			}
+			return _currentEnvironment;
+		}
+	}
+	public static bool IsTest => CurrentEnvironment.Equals("Test", StringComparison.OrdinalIgnoreCase);
+	public static bool IsDevelopment => CurrentEnvironment.Equals("Development", StringComparison.OrdinalIgnoreCase);
+
+	public static bool IsProduction => CurrentEnvironment.Equals("Production", StringComparison.OrdinalIgnoreCase);
+
+	private static string DetermineEnvironment()
+	{
+#if RELEASE
+		// Release 构建：只允许生产环境，不允许其他环境
+		return "Production";
+#else
+		// 1. 检查环境变量
+		var envVar = Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT") ??
+					Environment.GetEnvironmentVariable("ENVIRONMENT");
+
+		if (!string.IsNullOrEmpty(envVar))
+		{
+			return envVar;
+		}
+
+
+		// 检查当前机器名
+		string machineName = Environment.MachineName.ToLower();
+		if (machineName.Contains("dev") ||
+			machineName.Contains("test"))
+		{
+			return machineName.Contains("TEST") ? "Test" : "Development";
+		}
+
+		// 4. 默认返回 Production
+		return "Production";
+#endif
+	}
+
+	// 获取环境描述
+	public static string EnvironmentDescription
+	{
+		get
+		{
+			if (IsTest) return "测试环境";
+			if (IsDevelopment) return "开发环境";
+			if (IsProduction) return "生产环境";
+			return $"未知环境 ({CurrentEnvironment})";
+		}
+	}
+}
diff --git a/Source/MAX.Core/Helpers/FileHelper.cs b/Source/MAX.Core/Helpers/FileHelper.cs
new file mode 100644
index 0000000..e03a4d6
--- /dev/null
+++ b/Source/MAX.Core/Helpers/FileHelper.cs
@@ -0,0 +1,188 @@
+using System.IO;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MAX.Core.Helpers;
+
+/// <summary>
+/// 文件和流操作
+/// </summary>
+public static partial class FileHelper
+{
+	/// <summary>
+	/// 流转换为字节流
+	/// </summary>
+	/// <param name="stream">流</param>
+	public static async Task<byte[]> ToBytesAsync(Stream stream)
+	{
+		stream.Seek(0, SeekOrigin.Begin);
+		byte[] buffer = new byte[stream.Length];
+		await stream.ReadAsync(buffer, 0, buffer.Length);
+		return buffer;
+	}
+
+	/// <summary>
+	/// 流转换为字节流
+	/// </summary>
+	/// <param name="stream">流</param>
+	public static byte[] ToBytes(Stream stream)
+	{
+		stream.Seek(0, SeekOrigin.Begin);
+		byte[] buffer = new byte[stream.Length];
+		stream.Read(buffer, 0, buffer.Length);
+		return buffer;
+	}
+
+	/// <summary>
+	/// 字符串转换成字节数组
+	/// </summary>
+	/// <param name="data">数据,默认字符编码utf-8</param>        
+	public static byte[] ToBytes(string data)
+	{
+		return ToBytes(data, Encoding.UTF8);
+	}
+
+	/// <summary>
+	/// 字符串转换成字节数组
+	/// </summary>
+	/// <param name="data">数据</param>
+	/// <param name="encoding">字符编码</param>
+	public static byte[] ToBytes(string data, Encoding encoding)
+	{
+		if (string.IsNullOrWhiteSpace(data))
+		{
+			return new byte[] { };
+		}
+
+		return encoding.GetBytes(data);
+	}
+
+	/// <summary>
+	/// 将文件读取到字节流中
+	/// </summary>
+	/// <param name="filePath">文件的绝对路径</param>
+	public static byte[] Read(string filePath)
+	{
+		if (!File.Exists(filePath))
+		{
+			return null;
+		}
+
+		FileInfo fileInfo = new(filePath);
+		using BinaryReader reader = new(fileInfo.Open(FileMode.Open));
+		return reader.ReadBytes((int)fileInfo.Length);
+	}
+
+	/// <summary>
+	/// 流转换成字符串
+	/// </summary>
+	/// <param name="stream">流</param>
+	/// <param name="encoding">字符编码</param>
+	/// <param name="bufferSize">缓冲区大小</param>
+	/// <param name="isCloseStream">读取完成是否释放流，默认为true</param>
+	public static string ToString(Stream stream, Encoding encoding = null, int bufferSize = 1024 * 2, bool isCloseStream = true)
+	{
+		if (stream == null)
+		{
+			return string.Empty;
+		}
+
+		encoding ??= Encoding.UTF8;
+
+		if (stream.CanRead == false)
+		{
+			return string.Empty;
+		}
+
+		using StreamReader reader = new(stream, encoding, true, bufferSize, !isCloseStream);
+		if (stream.CanSeek)
+		{
+			stream.Seek(0, SeekOrigin.Begin);
+		}
+
+		string result = reader.ReadToEnd();
+		if (stream.CanSeek)
+		{
+			stream.Seek(0, SeekOrigin.Begin);
+		}
+
+		return result;
+	}
+
+	/// <summary>
+	/// 流转换成字符串
+	/// </summary>
+	/// <param name="stream">流</param>
+	/// <param name="encoding">字符编码</param>
+	/// <param name="bufferSize">缓冲区大小</param>
+	/// <param name="isCloseStream">读取完成是否释放流，默认为true</param>
+	public static async Task<string> ToStringAsync(Stream stream, Encoding encoding = null, int bufferSize = 1024 * 2, bool isCloseStream = true)
+	{
+		if (stream == null)
+		{
+			return string.Empty;
+		}
+
+		encoding ??= Encoding.UTF8;
+
+		if (stream.CanRead == false)
+		{
+			return string.Empty;
+		}
+
+		using StreamReader reader = new(stream, encoding, true, bufferSize, !isCloseStream);
+		if (stream.CanSeek)
+		{
+			stream.Seek(0, SeekOrigin.Begin);
+		}
+
+		string result = await reader.ReadToEndAsync();
+		if (stream.CanSeek)
+		{
+			stream.Seek(0, SeekOrigin.Begin);
+		}
+
+		return result;
+	}
+
+	/// <summary>
+	/// 复制流并转换成字符串
+	/// </summary>
+	/// <param name="stream">流</param>
+	/// <param name="encoding">字符编码</param>
+	public static async Task<string> CopyToStringAsync(Stream stream, Encoding encoding = null)
+	{
+		if (stream == null)
+		{
+			return string.Empty;
+		}
+
+		encoding ??= Encoding.UTF8;
+
+		if (stream.CanRead == false)
+		{
+			return string.Empty;
+		}
+
+		using MemoryStream memoryStream = new();
+		using StreamReader reader = new(memoryStream, encoding);
+		if (stream.CanSeek)
+		{
+			stream.Seek(0, SeekOrigin.Begin);
+		}
+
+		stream.CopyTo(memoryStream);
+		if (memoryStream.CanSeek)
+		{
+			memoryStream.Seek(0, SeekOrigin.Begin);
+		}
+
+		string result = await reader.ReadToEndAsync();
+		if (stream.CanSeek)
+		{
+			stream.Seek(0, SeekOrigin.Begin);
+		}
+
+		return result;
+	}
+}
diff --git a/Source/MAX.Core/Helpers/HttpHelper.cs b/Source/MAX.Core/Helpers/HttpHelper.cs
new file mode 100644
index 0000000..f85098f
--- /dev/null
+++ b/Source/MAX.Core/Helpers/HttpHelper.cs
@@ -0,0 +1,1047 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Net;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace MAX.Core.Helpers;
+
+
+/// <summary>
+/// Http连接操作帮助类
+/// </summary>
+public class HttpHelper
+{
+	public static HttpResult Get(string Url)
+	{
+		return new HttpHelper().GetHtml(new HttpItem
+		{
+			URL = Url,
+			Method = MethodType.Get,
+		});
+	}
+
+	public static HttpResult Post(string Url, string PostData)
+	{
+		return new HttpHelper().GetHtml(new HttpItem
+		{
+			URL = Url,
+			Method = MethodType.Get,
+			Postdata = PostData,
+			PostDataType = PostDataType.String
+		});
+	}
+	public static HttpResult Request(HttpItem item)
+	{
+		return new HttpHelper().GetHtml(item);
+	}
+	/// <summary>
+	/// 下载文件
+	/// </summary>
+	/// <param name="address"></param>
+	/// <param name="fileName"></param>
+	public static byte[] DownloadFile(string address)
+	{
+		HttpItem item = new()
+		{
+			URL = address,
+			Timeout = 3000,
+			ResultType = ResultType.Byte
+		};
+		HttpHelper http = new();
+		HttpResult result = http.GetHtml(item);
+		if (result.StatusCode == HttpStatusCode.OK)
+		{
+			return result.ResultByte;
+		}
+		else
+		{
+			throw new HttpListenerException((int)result.StatusCode, result.StatusDescription);
+		}
+	}
+
+	/// <summary>
+	/// 下载文件
+	/// </summary>
+	/// <param name="address"></param>
+	/// <param name="fileName"></param>
+	public static bool DownloadFile(string address, string fileName)
+	{
+		HttpItem item = new()
+		{
+			URL = address,
+			Timeout = 3000,
+			ResultType = ResultType.Byte
+		};
+		HttpHelper http = new();
+		HttpResult result = http.GetHtml(item);
+		if (result.StatusCode == HttpStatusCode.OK)
+		{
+			FileStream fs = new(fileName, FileMode.CreateNew);
+			BinaryWriter bw = new(fs);
+			bw.Write(result.ResultByte);
+			fs.Close();
+			bw.Close();
+		}
+		else
+		{
+			throw new HttpListenerException((int)result.StatusCode, result.StatusDescription);
+		}
+
+		return true;
+	}
+
+	#region 预定义方法或者变更
+	//默认的编码
+	private Encoding encoding = Encoding.Default;
+	//Post数据编码
+	private Encoding postencoding = Encoding.Default;
+	//HttpWebRequest对象用来发起请求
+	private HttpWebRequest request = null;
+	//获取影响流的数据对象
+	private HttpWebResponse response = null;
+	/// <summary>
+	/// 根据相传入的数据，得到相应页面数据
+	/// </summary>
+	/// <param name="item">参数类对象</param>
+	/// <returns>返回HttpResult类型</returns>
+	public HttpResult GetHtml(HttpItem item)
+	{
+		//返回参数
+		HttpResult result = new()
+		{
+			item = item
+		};
+		try
+		{
+			//准备参数
+			SetRequest(item);
+		}
+		catch (Exception ex)
+		{
+			result = new HttpResult
+			{
+				Cookie = string.Empty,
+				Header = null,
+				Html = ex.Message,
+				StatusDescription = "配置参数时出错：" + ex.Message
+			};
+			return result;
+		}
+		try
+		{
+			//请求数据
+			using (response = (HttpWebResponse)request.GetResponse())
+			{
+				GetData(item, result);
+			}
+			//#region 得到请求的response
+			//using (response = (HttpWebResponse)request.GetResponse())
+			//{
+			//    result.StatusCode = response.StatusCode;
+			//    result.StatusDescription = response.StatusDescription;
+			//    result.Header = response.Headers;
+			//    if (response.Cookies != null) result.CookieCollection = response.Cookies;
+			//    if (response.Headers["set-cookie"] != null) result.Cookie = response.Headers["set-cookie"];
+			//    MemoryStream _stream = new MemoryStream();
+			//    //GZIIP处理
+			//    if (response.ContentEncoding != null && response.ContentEncoding.Equals("gzip", StringComparison.InvariantCultureIgnoreCase))
+			//    {
+			//        //开始读取流并设置编码方式
+			//        //new GZipStream(response.GetResponseStream(), CompressionMode.Decompress).CopyTo(_stream, 10240);
+			//        //.net4.0以下写法
+			//        _stream = GetMemoryStream(new GZipStream(response.GetResponseStream(), CompressionMode.Decompress));
+
+			//    }
+			//    else
+			//    {
+			//        //开始读取流并设置编码方式
+			//        //response.GetResponseStream().CopyTo(_stream, 10240);
+			//        //.net4.0以下写法
+			//        _stream = GetMemoryStream(response.GetResponseStream());
+			//    }
+			//    //获取Byte
+			//    byte[] ResponseByte = _stream.ToArray();
+			//    _stream.Close();
+			//    if (ResponseByte != null & ResponseByte.Length > 0)
+			//    {
+			//        //是否返回Byte类型数据
+			//        if (item.ResultType == ResultType.Byte) result.ResultByte = ResponseByte;
+			//        //从这里开始我们要无视编码了
+			//        if (encoding == null)
+			//        {
+			//            Match meta = Regex.Match(Encoding.Default.GetString(ResponseByte), "<meta([^<]*)charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
+			//            string c = (meta.Groups.Count > 1) ? meta.Groups[2].Value.ToLower().Trim() : string.Empty;
+			//            if (c.Length > 2)
+			//            {
+			//                try
+			//                {
+			//                    if (c.IndexOf(" ") > 0) c = c.Substring(0, c.IndexOf(" "));
+			//                    encoding = Encoding.GetEncoding(c.Replace("\"", "").Replace("'", "").Replace(";", "").Replace("iso-8859-1", "gbk").Trim());
+			//                }
+			//                catch
+			//                {
+			//                    if (string.IsNullOrEmpty(response.CharacterSet)) encoding = Encoding.UTF8;
+			//                    else encoding = Encoding.GetEncoding(response.CharacterSet);
+			//                }
+			//            }
+			//            else
+			//            {
+			//                if (string.IsNullOrEmpty(response.CharacterSet)) encoding = Encoding.UTF8;
+			//                else encoding = Encoding.GetEncoding(response.CharacterSet);
+			//            }
+			//        }
+			//        //得到返回的HTML
+			//        result.Html = encoding.GetString(ResponseByte);
+			//    }
+			//    else
+			//    {
+			//        //得到返回的HTML
+			//        result.Html = "本次请求并未返回任何数据";
+			//    }
+			//}
+			//#endregion
+		}
+		catch (WebException ex)
+		{
+			if (ex.Response != null)
+			{
+				using (response = (HttpWebResponse)ex.Response)
+				{
+					GetData(item, result);
+				}
+			}
+			else
+			{
+				result.Html = ex.Message;
+			}
+
+		}
+		catch (Exception ex)
+		{
+			result.Html = ex.Message;
+		}
+		if (item.IsToLower)
+		{
+			result.Html = result.Html.ToLower();
+		}
+
+		return result;
+	}
+
+	#region GetData
+	/// <summary>
+	/// 获取数据的并解析的方法
+	/// </summary>
+	/// <param name="item"></param>
+	/// <param name="result"></param>
+	private void GetData(HttpItem item, HttpResult result)
+	{
+		if (response == null)
+		{
+			return;
+		}
+		#region base
+		//获取StatusCode
+		result.StatusCode = response.StatusCode;
+		//获取最后访问的URl
+		//获取StatusDescription
+		result.StatusDescription = response.StatusDescription;
+		//获取Headers
+		result.Header = response.Headers;
+		//获取CookieCollection
+		if (response.Cookies != null)
+		{
+			result.CookieCollection = response.Cookies;
+		}
+		//获取set-cookie
+		if (response.Headers["set-cookie"] != null)
+		{
+			result.Cookie = response.Headers["set-cookie"];
+		}
+
+		#endregion
+		#region 用户设置用编码
+		//处理网页Byte
+		byte[] ResponseByte = GetByte(item);
+
+		if (ResponseByte != null && ResponseByte.Length > 0)
+		{
+			//设置编码
+			SetEncoding(item, result, ResponseByte);
+
+			//设置返回的Byte
+			SetResultByte(item, result, ResponseByte);
+		}
+		else
+		{
+			//没有返回任何Html代码
+			result.Html = string.Empty;
+		}
+
+		#endregion
+	}
+	/// <summary>
+	/// 设置返回的Byte
+	/// </summary>
+	/// <param name="item">HttpItem</param>
+	/// <param name="result">result</param>
+	/// <param name="enByte">byte</param>
+	private void SetResultByte(HttpItem item, HttpResult result, byte[] enByte)
+	{
+		//是否返回Byte类型数据
+		if (item.ResultType == ResultType.Byte)
+		{
+			//Byte数据
+			result.ResultByte = enByte;
+		}
+		else if (item.ResultType == ResultType.String)
+		{
+			//得到返回的HTML
+			result.Html = encoding.GetString(enByte);
+		}
+
+	}
+	/// <summary>
+	/// 设置编码
+	/// </summary>
+	/// <param name="item">HttpItem</param>
+	/// <param name="result">HttpResult</param>
+	/// <param name="ResponseByte">byte[]</param>
+	private void SetEncoding(HttpItem item, HttpResult result, byte[] ResponseByte)
+	{
+		//从这里开始我们要无视编码了
+		if (encoding == null)
+		{
+			Match meta = Regex.Match(Encoding.Default.GetString(ResponseByte), "<meta[^<]*charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
+			string c = string.Empty;
+			if (meta != null && meta.Groups.Count > 0)
+			{
+				c = meta.Groups[1].Value.ToLower().Trim();
+			}
+			string cs = string.Empty;
+			if (!string.IsNullOrWhiteSpace(response.CharacterSet))
+			{
+				cs = response.CharacterSet.Trim().Replace("\"", "").Replace("\'", "");
+			}
+
+			if (c.Length > 2)
+			{
+				try
+				{
+					encoding = Encoding.GetEncoding(c.Replace("\"", string.Empty).Replace("'", "").Replace(";", "").Replace("iso-8859-1", "gbk").Trim());
+				}
+				catch
+				{
+					if (string.IsNullOrEmpty(cs))
+					{
+						encoding = Encoding.UTF8;
+					}
+					else
+					{
+						encoding = Encoding.GetEncoding(cs);
+					}
+				}
+			}
+			else
+			{
+				if (string.IsNullOrEmpty(cs))
+				{
+					encoding = Encoding.UTF8;
+				}
+				else
+				{
+					encoding = Encoding.GetEncoding(cs);
+				}
+			}
+		}
+	}
+	/// <summary>
+	/// 提取网页Byte
+	/// </summary>
+	/// <returns></returns>
+	private byte[] GetByte(HttpItem item)
+	{
+		byte[] ResponseByte = null;
+		using (MemoryStream _stream = new())
+		{
+
+			//GZIIP处理
+			if (response.ContentEncoding != null && response.ContentEncoding.Equals("gzip", StringComparison.InvariantCultureIgnoreCase))
+			{
+				//开始读取流并设置编码方式
+				new GZipStream(response.GetResponseStream(), CompressionMode.Decompress).CopyTo(_stream, 10240);
+			}
+			else
+			{
+				//开始读取流并设置编码方式
+				response.GetResponseStream().CopyTo(_stream, 10240);
+			}
+
+			//获取Byte
+			ResponseByte = _stream.ToArray();
+		}
+		return ResponseByte;
+	}
+	#endregion
+
+
+	/// <summary>
+	/// 4.0以下.net版本取数据使用
+	/// </summary>
+	/// <param name="streamResponse">流</param>
+	private MemoryStream GetMemoryStream(Stream streamResponse)
+	{
+		MemoryStream _stream = new();
+		int Length = 256;
+		Byte[] buffer = new Byte[Length];
+		int bytesRead = streamResponse.Read(buffer, 0, Length);
+		while (bytesRead > 0)
+		{
+			_stream.Write(buffer, 0, bytesRead);
+			bytesRead = streamResponse.Read(buffer, 0, Length);
+		}
+		return _stream;
+	}
+	/// <summary>
+	/// 为请求准备参数
+	/// </summary>
+	///<param name="item">参数列表</param>
+	private void SetRequest(HttpItem item)
+
+	{
+		// 验证证书
+		SetCer(item);
+		//设置Header参数
+		if (item.Header != null && item.Header.Count > 0)
+		{
+			foreach (string key in item.Header.AllKeys)
+			{
+				request.Headers.Add(key, item.Header[key]);
+			}
+		}
+		// 设置代理
+		SetProxy(item);
+		if (item.ProtocolVersion != null)
+		{
+			request.ProtocolVersion = item.ProtocolVersion;
+		}
+
+		request.ServicePoint.Expect100Continue = item.Expect100Continue;
+		//请求方式Get或者Post
+		request.Method = item.Method.ToString();
+		request.Timeout = item.Timeout;
+		request.KeepAlive = item.KeepAlive;
+		request.ReadWriteTimeout = item.ReadWriteTimeout;
+		//Accept
+		request.Accept = item.Accept;
+		//ContentType返回类型
+		request.ContentType = item.ContentType;
+		//UserAgent客户端的访问类型，包括浏览器版本和操作系统信息
+		request.UserAgent = item.UserAgent;
+		// 编码
+		encoding = item.Encoding;
+		//设置安全凭证
+		request.Credentials = item.ICredentials;
+		//设置Cookie
+		SetCookie(item);
+		//来源地址
+		request.Referer = item.Referer;
+		//是否执行跳转功能
+		request.AllowAutoRedirect = item.Allowautoredirect;
+		//设置Post数据
+		SetPostData(item);
+		//设置最大连接
+		if (item.Connectionlimit > 0)
+		{
+			request.ServicePoint.ConnectionLimit = item.Connectionlimit;
+		}
+	}
+	/// <summary>
+	/// 设置证书
+	/// </summary>
+	/// <param name="item"></param>
+#pragma warning disable SYSLIB0014 // Type or member is obsolete
+	private void SetCer(HttpItem item)
+	{
+		if (!string.IsNullOrEmpty(item.CerPath))
+		{
+			//这一句一定要写在创建连接的前面。使用回调的方法进行证书验证。
+			ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
+			//初始化对像，并设置请求的URL地址
+			request = (HttpWebRequest)WebRequest.Create(item.URL);
+			SetCerList(item);
+			//将证书添加到请求里
+			request.ClientCertificates.Add(new X509Certificate(item.CerPath));
+		}
+		else
+		{
+			//初始化对像，并设置请求的URL地址
+			request = (HttpWebRequest)WebRequest.Create(item.URL);
+			SetCerList(item);
+		}
+	}
+#pragma warning restore SYSLIB0014 // Type or member is obsolete
+	/// <summary>
+	/// 设置多个证书
+	/// </summary>
+	/// <param name="item"></param>
+	private void SetCerList(HttpItem item)
+	{
+		if (item.ClentCertificates != null && item.ClentCertificates.Count > 0)
+		{
+			foreach (X509Certificate c in item.ClentCertificates)
+			{
+				request.ClientCertificates.Add(c);
+			}
+		}
+	}
+	/// <summary>
+	/// 设置Cookie
+	/// </summary>
+	/// <param name="item">Http参数</param>
+	private void SetCookie(HttpItem item)
+	{
+		if (!string.IsNullOrEmpty(item.Cookie))
+		{
+			request.Headers[HttpRequestHeader.Cookie] = item.Cookie;
+		}
+		//设置CookieCollection
+		if (item.ResultCookieType == ResultCookieType.CookieCollection)
+		{
+			request.CookieContainer = new CookieContainer();
+			if (item.CookieCollection != null && item.CookieCollection.Count > 0)
+			{
+				request.CookieContainer.Add(item.CookieCollection);
+			}
+		}
+	}
+	/// <summary>
+	/// 设置Post数据
+	/// </summary>
+	/// <param name="item">Http参数</param>
+	private void SetPostData(HttpItem item)
+	{
+		//验证在得到结果时是否有传入数据
+		if (request.Method.Trim().ToLower().Contains("post"))
+		{
+			if (item.PostEncoding != null)
+			{
+				postencoding = item.PostEncoding;
+			}
+			byte[] buffer = null;
+			//写入Byte类型
+			if (item.PostDataType == PostDataType.Byte && item.PostdataByte != null && item.PostdataByte.Length > 0)
+			{
+				//验证在得到结果时是否有传入数据
+				buffer = item.PostdataByte;
+			}//写入文件
+			else if (item.PostDataType == PostDataType.FilePath && !string.IsNullOrEmpty(item.Postdata))
+			{
+				StreamReader r = new(item.Postdata, postencoding);
+				buffer = postencoding.GetBytes(r.ReadToEnd());
+				r.Close();
+			} //写入字符串
+			else if (!string.IsNullOrEmpty(item.Postdata))
+			{
+				buffer = postencoding.GetBytes(item.Postdata);
+			}
+			if (buffer != null)
+			{
+				request.ContentLength = buffer.Length;
+				request.GetRequestStream().Write(buffer, 0, buffer.Length);
+			}
+		}
+	}
+	/// <summary>
+	/// 设置代理
+	/// </summary>
+	/// <param name="item">参数对象</param>
+	private void SetProxy(HttpItem item)
+	{
+		bool isIeProxy = item.ProxyIp.ToLower().Contains("ieproxy");
+		if (!string.IsNullOrEmpty(item.ProxyIp) && !isIeProxy)
+		{
+			//设置代理服务器
+			if (item.ProxyIp.Contains(":"))
+			{
+				string[] plist = item.ProxyIp.Split(':');
+				WebProxy myProxy = new(plist[0].Trim(), Convert.ToInt(plist[1].Trim()))
+				{
+					//建议连接
+					Credentials = new NetworkCredential(item.ProxyUserName, item.ProxyPwd)
+				};
+				//给当前请求对象
+				request.Proxy = myProxy;
+			}
+			else
+			{
+				WebProxy myProxy = new(item.ProxyIp, false)
+				{
+					//建议连接
+					Credentials = new NetworkCredential(item.ProxyUserName, item.ProxyPwd)
+				};
+				//给当前请求对象
+				request.Proxy = myProxy;
+			}
+		}
+		else if (isIeProxy)
+		{
+			//设置为IE代理
+		}
+		else
+		{
+			request.Proxy = item.WebProxy;
+		}
+	}
+	/// <summary>
+	/// 回调验证证书问题
+	/// </summary>
+	/// <param name="sender">流对象</param>
+	/// <param name="certificate">证书</param>
+	/// <param name="chain">X509Chain</param>
+	/// <param name="errors">SslPolicyErrors</param>
+	/// <returns>bool</returns>
+	public bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) { return true; }
+	#endregion
+}
+/// <summary>
+/// Http请求参考类
+/// </summary>
+public class HttpItem
+{
+	private string _URL = string.Empty;
+	/// <summary>
+	/// 请求URL必须填写
+	/// </summary>
+	public string URL
+	{
+		get { return _URL; }
+		set { _URL = value; }
+	}
+
+	private MethodType _Method = MethodType.Get;
+	/// <summary>
+	/// 请求方式默认为GET方式,当为POST方式时必须设置Postdata的值
+	/// </summary>
+	public MethodType Method
+	{
+		get { return _Method; }
+		set
+		{
+			_Method = value;
+			if (_Method == MethodType.Post)
+			{
+				_ContentType = "application/x-www-form-urlencoded";
+			}
+		}
+	}
+
+	private int _Timeout = 100000;
+	/// <summary>
+	/// 默认请求超时时间
+	/// </summary>
+	public int Timeout
+	{
+		get { return _Timeout; }
+		set { _Timeout = value; }
+	}
+
+	private int _ReadWriteTimeout = 30000;
+	/// <summary>
+	/// 默认写入Post数据超时间
+	/// </summary>
+	public int ReadWriteTimeout
+	{
+		get { return _ReadWriteTimeout; }
+		set { _ReadWriteTimeout = value; }
+	}
+
+	private Boolean _KeepAlive = true;
+	/// <summary>
+	///  获取或设置一个值，该值指示是否与 Internet 资源建立持久性连接默认为true。
+	/// </summary>
+	public Boolean KeepAlive
+	{
+		get { return _KeepAlive; }
+		set { _KeepAlive = value; }
+	}
+
+	private string _Accept = "text/html, application/xhtml+xml, */*";
+	/// <summary>
+	/// 请求标头值 默认为text/html, application/xhtml+xml, */*
+	/// </summary>
+	public string Accept
+	{
+		get { return _Accept; }
+		set { _Accept = value; }
+	}
+
+	private string _ContentType = "text/html";
+	/// <summary>
+	/// 请求返回类型默认 text/html
+	/// </summary>
+	public string ContentType
+	{
+		get { return _ContentType; }
+		set { _ContentType = value; }
+	}
+
+	private string _UserAgent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)";
+	/// <summary>
+	/// 客户端访问信息默认Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)
+	/// </summary>
+	public string UserAgent
+	{
+		get { return _UserAgent; }
+		set { _UserAgent = value; }
+	}
+
+	private Encoding _Encoding = null;
+	/// <summary>
+	/// 返回数据编码默认为NUll,可以自动识别,一般为utf-8,gbk,gb2312
+	/// </summary>
+	public Encoding Encoding
+	{
+		get { return _Encoding; }
+		set { _Encoding = value; }
+	}
+	private PostDataType _PostDataType = PostDataType.String;
+	/// <summary>
+	/// Post的数据类型
+	/// </summary>
+	public PostDataType PostDataType
+	{
+		get { return _PostDataType; }
+		set { _PostDataType = value; }
+	}
+
+	private string _Postdata = string.Empty;
+	/// <summary>
+	/// Post请求时要发送的字符串Post数据
+	/// </summary>
+	public string Postdata
+	{
+		get { return _Postdata; }
+		set { _Postdata = value; }
+	}
+	private byte[] _PostdataByte = null;
+	/// <summary>
+	/// Post请求时要发送的Byte类型的Post数据
+	/// </summary>
+	public byte[] PostdataByte
+	{
+		get { return _PostdataByte; }
+		set { _PostdataByte = value; }
+	}
+	private WebProxy _WebProxy;
+	/// <summary>
+	/// 设置代理对象，不想使用IE默认配置就设置为Null，而且不要设置ProxyIp
+	/// </summary>
+	public WebProxy WebProxy
+	{
+		get { return _WebProxy; }
+		set { _WebProxy = value; }
+	}
+
+	private CookieCollection cookiecollection = null;
+	/// <summary>
+	/// Cookie对象集合
+	/// </summary>
+	public CookieCollection CookieCollection
+	{
+		get { return cookiecollection; }
+		set { cookiecollection = value; }
+	}
+
+	private string _Cookie = string.Empty;
+	/// <summary>
+	/// 请求时的Cookie
+	/// </summary>
+	public string Cookie
+	{
+		get { return _Cookie; }
+		set { _Cookie = value; }
+	}
+
+	private string _Referer = string.Empty;
+	/// <summary>
+	/// 来源地址，上次访问地址
+	/// </summary>
+	public string Referer
+	{
+		get { return _Referer; }
+		set { _Referer = value; }
+	}
+
+	private string _CerPath = string.Empty;
+	/// <summary>
+	/// 证书绝对路径
+	/// </summary>
+	public string CerPath
+	{
+		get { return _CerPath; }
+		set { _CerPath = value; }
+	}
+	private Boolean isToLower = false;
+	/// <summary>
+	/// 是否设置为全文小写，默认为不转化
+	/// </summary>
+	public Boolean IsToLower
+	{
+		get { return isToLower; }
+		set { isToLower = value; }
+	}
+	private Boolean allowautoredirect = true;
+	/// <summary>
+	/// 支持跳转页面，查询结果将是跳转后的页面
+	/// </summary>
+	public Boolean Allowautoredirect
+	{
+		get { return allowautoredirect; }
+		set { allowautoredirect = value; }
+	}
+	private int connectionlimit = 1024;
+	/// <summary>
+	/// 最大连接数
+	/// </summary>
+	public int Connectionlimit
+	{
+		get { return connectionlimit; }
+		set { connectionlimit = value; }
+	}
+	private string proxyusername = string.Empty;
+	/// <summary>
+	/// 代理Proxy 服务器用户名
+	/// </summary>
+	public string ProxyUserName
+	{
+		get { return proxyusername; }
+		set { proxyusername = value; }
+	}
+	private string proxypwd = string.Empty;
+	/// <summary>
+	/// 代理 服务器密码
+	/// </summary>
+	public string ProxyPwd
+	{
+		get { return proxypwd; }
+		set { proxypwd = value; }
+	}
+	private string proxyip = string.Empty;
+	/// <summary>
+	/// 代理 服务IP ,如果要使用IE代理就设置为ieproxy
+	/// </summary>
+	public string ProxyIp
+	{
+		get { return proxyip; }
+		set { proxyip = value; }
+	}
+	private ResultType resulttype = ResultType.String;
+	/// <summary>
+	/// 设置返回类型String和Byte
+	/// </summary>
+	public ResultType ResultType
+	{
+		get { return resulttype; }
+		set { resulttype = value; }
+	}
+	private WebHeaderCollection header = [];
+	/// <summary>
+	/// header对象
+	/// </summary>
+	public WebHeaderCollection Header
+	{
+		get { return header; }
+		set { header = value; }
+	}
+
+	private Version _ProtocolVersion;
+
+	/// <summary>
+	///     获取或设置用于请求的 HTTP 版本。返回结果:用于请求的 HTTP 版本。默认为 System.Net.HttpVersion.Version11。
+	/// </summary>
+	public Version ProtocolVersion
+	{
+		get { return _ProtocolVersion; }
+		set { _ProtocolVersion = value; }
+	}
+	private Boolean _expect100continue = true;
+	/// <summary>
+	///  获取或设置一个 System.Boolean 值，该值确定是否使用 100-Continue 行为。如果 POST 请求需要 100-Continue 响应，则为 true；否则为 false。默认值为 true。
+	/// </summary>
+	public Boolean Expect100Continue
+	{
+		get { return _expect100continue; }
+		set { _expect100continue = value; }
+	}
+	private X509CertificateCollection _ClentCertificates;
+	/// <summary>
+	/// 设置509证书集合
+	/// </summary>
+	public X509CertificateCollection ClentCertificates
+	{
+		get { return _ClentCertificates; }
+		set { _ClentCertificates = value; }
+	}
+	private Encoding _PostEncoding;
+	/// <summary>
+	/// 设置或获取Post参数编码,默认的为Default编码
+	/// </summary>
+	public Encoding PostEncoding
+	{
+		get { return _PostEncoding; }
+		set { _PostEncoding = value; }
+	}
+	private ResultCookieType _ResultCookieType = ResultCookieType.String;
+	/// <summary>
+	/// Cookie返回类型,默认的是只返回字符串类型
+	/// </summary>
+	public ResultCookieType ResultCookieType
+	{
+		get { return _ResultCookieType; }
+		set { _ResultCookieType = value; }
+	}
+
+	private ICredentials _ICredentials = CredentialCache.DefaultCredentials;
+	/// <summary>
+	/// 获取或设置请求的身份验证信息。
+	/// </summary>
+	public ICredentials ICredentials
+	{
+		get { return _ICredentials; }
+		set { _ICredentials = value; }
+	}
+
+}
+/// <summary>
+/// Http返回参数类
+/// </summary>
+public class HttpResult
+{
+	private string _Cookie;
+	/// <summary>
+	/// Http请求返回的Cookie
+	/// </summary>
+	public string Cookie
+	{
+		get { return _Cookie; }
+		set { _Cookie = value; }
+	}
+
+	private CookieCollection _CookieCollection;
+	/// <summary>
+	/// Cookie对象集合
+	/// </summary>
+	public CookieCollection CookieCollection
+	{
+		get { return _CookieCollection; }
+		set { _CookieCollection = value; }
+	}
+	private string _Html;
+	/// <summary>
+	/// 返回的String类型数据 只有ResultType.String时才返回数据，其它情况为空
+	/// </summary>
+	public string Html
+	{
+		get { return _Html; }
+		set { _Html = value; }
+	}
+	private byte[] _ResultByte;
+	/// <summary>
+	/// 返回的Byte数组 只有ResultType.Byte时才返回数据，其它情况为空
+	/// </summary>
+	public byte[] ResultByte
+	{
+		get { return _ResultByte; }
+		set { _ResultByte = value; }
+	}
+
+	private WebHeaderCollection _Header;
+	/// <summary>
+	/// header对象
+	/// </summary>
+	public WebHeaderCollection Header
+	{
+		get { return _Header; }
+		set { _Header = value; }
+	}
+
+	private string _StatusDescription;
+	/// <summary>
+	/// 返回状态说明
+	/// </summary>
+	public string StatusDescription
+	{
+		get { return _StatusDescription; }
+		set { _StatusDescription = value; }
+	}
+	private HttpStatusCode _StatusCode;
+	/// <summary>
+	/// 返回状态码,默认为OK
+	/// </summary>
+	public HttpStatusCode StatusCode
+	{
+		get { return _StatusCode; }
+		set { _StatusCode = value; }
+	}
+	/// <summary>
+	/// HttpItem类，用于存储实际执行所用到的HttpItem对象
+	/// </summary>
+	public HttpItem item { get; set; }
+}
+/// <summary>
+/// 返回类型
+/// </summary>
+public enum ResultType
+{
+	/// <summary>
+	/// 表示只返回字符串 只有Html有数据
+	/// </summary>
+	String,
+	/// <summary>
+	/// 表示返回字符串和字节流 ResultByte和Html都有数据返回
+	/// </summary>
+	Byte
+}
+/// <summary>
+/// Post的数据格式默认为string
+/// </summary>
+public enum PostDataType
+{
+	/// <summary>
+	/// 字符串类型，这时编码Encoding可不设置
+	/// </summary>
+	String,
+	/// <summary>
+	/// Byte类型，需要设置PostdataByte参数的值编码Encoding可设置为空
+	/// </summary>
+	Byte,
+	/// <summary>
+	/// 传文件，Postdata必须设置为文件的绝对路径，必须设置Encoding的值
+	/// </summary>
+	FilePath
+}
+/// <summary>
+/// Cookie返回类型
+/// </summary>
+public enum ResultCookieType
+{
+	/// <summary>
+	/// 只返回字符串类型的Cookie
+	/// </summary>
+	String,
+	/// <summary>
+	/// CookieCollection格式的Cookie集合同时也返回String类型的cookie
+	/// </summary>
+	CookieCollection
+}
+public enum MethodType
+{
+	Get,
+	Post
+}
+
diff --git a/Source/MAX.Core/Helpers/IdHelper.cs b/Source/MAX.Core/Helpers/IdHelper.cs
new file mode 100644
index 0000000..224a70c
--- /dev/null
+++ b/Source/MAX.Core/Helpers/IdHelper.cs
@@ -0,0 +1,45 @@
+namespace MAX.Core.Helpers;
+
+/// <summary>
+/// 标识生成器
+/// </summary>
+public static partial class IdHelper
+{
+	/// <summary>
+	/// 标识
+	/// </summary>
+	private static string _id;
+
+	/// <summary>
+	/// 设置标识
+	/// </summary>
+	/// <param name="id">Id</param>
+	public static void SetId(string id)
+	{
+		_id = id;
+	}
+
+	/// <summary>
+	/// 重置标识
+	/// </summary>
+	public static void Reset()
+	{
+		_id = null;
+	}
+
+	/// <summary>
+	/// 用Guid创建标识,去掉分隔符
+	/// </summary>
+	public static string Guid()
+	{
+		return string.IsNullOrWhiteSpace(_id) ? System.Guid.NewGuid().ToString("N") : _id;
+	}
+
+	///// <summary>
+	///// 获取Guid
+	///// </summary>
+	//public static Guid GetGuid()
+	//{
+	//    return string.IsNullOrWhiteSpace(_id) ? System.Guid.NewGuid() : _id.ToGuid();
+	//}
+}
diff --git a/Source/MAX.Core/Helpers/ParametersBase.cs b/Source/MAX.Core/Helpers/ParametersBase.cs
new file mode 100644
index 0000000..9cf8d97
--- /dev/null
+++ b/Source/MAX.Core/Helpers/ParametersBase.cs
@@ -0,0 +1,369 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+
+
+namespace MAX.Core.Helpers;
+
+/// <summary>
+/// This is a generic parameters base class used for Dialog Parameters and Navigation Parameters.
+/// </summary>
+public abstract class ParametersBase : IEnumerable<KeyValuePair<string, object>>
+{
+	private readonly List<KeyValuePair<string, object>> _entries = [];
+
+	/// <summary>
+	/// Default constructor.
+	/// </summary>
+	protected ParametersBase()
+	{
+	}
+
+	/// <summary>
+	/// Constructs a list of parameters.
+	/// </summary>
+	/// <param name="query">Query string to be parsed.</param>
+	protected ParametersBase(string query)
+	{
+		if (!string.IsNullOrWhiteSpace(query))
+		{
+			int num = query.Length;
+			for (int i = ((query.Length > 0) && (query[0] == '?')) ? 1 : 0; i < num; i++)
+			{
+				int startIndex = i;
+				int num4 = -1;
+				while (i < num)
+				{
+					char ch = query[i];
+					if (ch == '=')
+					{
+						if (num4 < 0)
+						{
+							num4 = i;
+						}
+					}
+					else if (ch == '&')
+					{
+						break;
+					}
+					i++;
+				}
+				string key = null;
+				string value;
+				if (num4 >= 0)
+				{
+					key = query.Substring(startIndex, num4 - startIndex);
+					value = query.Substring(num4 + 1, i - num4 - 1);
+				}
+				else
+				{
+					value = query.Substring(startIndex, i - startIndex);
+				}
+
+				if (key != null)
+				{
+					Add(Uri.UnescapeDataString(key), Uri.UnescapeDataString(value));
+				}
+			}
+		}
+	}
+
+	/// <summary>
+	/// Searches Parameter collection and returns value if Collection contains key.
+	/// Otherwise returns null.
+	/// </summary>
+	/// <param name="key">The key for the value to be returned.</param>
+	/// <returns>The value of the parameter referenced by the key; otherwise <c>null</c>.</returns>
+	public object this[string key]
+	{
+		get
+		{
+			foreach (KeyValuePair<string, object> entry in _entries)
+			{
+				if (string.Compare(entry.Key, key, StringComparison.Ordinal) == 0)
+				{
+					return entry.Value;
+				}
+			}
+
+			return null;
+		}
+	}
+
+	/// <summary>
+	/// The count, or number, of parameters in collection.
+	/// </summary>
+	public int Count => _entries.Count;
+
+	/// <summary>
+	/// Returns an IEnumerable of the Keys in the collection.
+	/// </summary>
+	public IEnumerable<string> Keys =>
+		_entries.Select(x => x.Key);
+
+	/// <summary>
+	/// Adds the key and value to the parameters collection.
+	/// </summary>
+	/// <param name="key">The key to reference this value in the parameters collection.</param>
+	/// <param name="value">The value of the parameter to store.</param>
+	public void Add(string key, object value) =>
+		_entries.Add(new KeyValuePair<string, object>(key, value));
+
+
+	public void Remove(string key)
+	{
+		_entries.RemoveAll(x => x.Key == key);
+	}
+
+	public void Update(string key, object value)
+	{
+		_entries.RemoveAll(x => x.Key == key);
+		Add(key, value);
+	}
+
+	/// <summary>
+	/// Checks collection for presence of key.
+	/// </summary>
+	/// <param name="key">The key to check in the collection.</param>
+	/// <returns><c>true</c> if key exists; else returns <c>false</c>.</returns>
+	public bool ContainsKey(string key)
+	{
+		return _entries.Any(x => string.Compare(x.Key, key, StringComparison.Ordinal) == 0);
+	}
+
+
+	/// <summary>
+	/// Gets an enumerator for the KeyValuePairs in parameter collection.
+	/// </summary>
+	/// <returns>Enumerator.</returns>
+	public IEnumerator<KeyValuePair<string, object>> GetEnumerator() =>
+		_entries.GetEnumerator();
+
+	/// <summary>
+	/// Returns the value of the member referenced by key.
+	/// </summary>
+	/// <typeparam name="T">The type of object to be returned.</typeparam>
+	/// <param name="key">The key for the value to be returned.</param>
+	/// <returns>Returns a matching parameter of <typeparamref name="T"/> if one exists in the Collection.</returns>
+	public T GetValue<T>(string key) =>
+		_entries.GetValue<T>(key);
+
+	/// <summary>
+	/// Returns an IEnumerable of all parameters.
+	/// </summary>
+	/// <typeparam name="T">The type for the values to be returned.</typeparam>
+	/// <param name="key">The key for the values to be returned.</param>
+	///<returns>Returns a IEnumerable of all the instances of type <typeparamref name="T"/>.</returns>
+	public IEnumerable<T> GetValues<T>(string key) =>
+		_entries.GetValues<T>(key);
+
+	/// <summary>
+	/// Checks to see if the parameter collection contains the value.
+	/// </summary>
+	/// <typeparam name="T">The type for the values to be returned.</typeparam>
+	/// <param name="key">The key for the value to be returned.</param>
+	/// <param name="value">Value of the returned parameter if it exists.</param>
+	public bool TryGetValue<T>(string key, out T value) =>
+		_entries.TryGetValue(key, out value);
+
+	IEnumerator IEnumerable.GetEnumerator() =>
+		GetEnumerator();
+
+	/// <summary>
+	/// Converts parameter collection to a parameter string.
+	/// </summary>
+	/// <returns>A string representation of the parameters.</returns>
+	public override string ToString()
+	{
+		StringBuilder queryBuilder = new();
+
+		if (_entries.Count > 0)
+		{
+			queryBuilder.Append('?');
+			bool first = true;
+
+			foreach (KeyValuePair<string, object> kvp in _entries)
+			{
+				if (!first)
+				{
+					queryBuilder.Append('&');
+				}
+				else
+				{
+					first = false;
+				}
+
+				queryBuilder.Append(Uri.EscapeDataString(kvp.Key));
+				queryBuilder.Append('=');
+				queryBuilder.Append(Uri.EscapeDataString(kvp.Value != null ? kvp.Value.ToString() : ""));
+			}
+		}
+
+		return queryBuilder.ToString();
+	}
+
+	/// <summary>
+	/// Adds a collection of parameters to the local parameter list.
+	/// </summary>
+	/// <param name="parameters">An IEnumerable of KeyValuePairs to add to the current parameter list.</param>
+	public void FromParameters(IEnumerable<KeyValuePair<string, object>> parameters) =>
+		_entries.AddRange(parameters);
+}
+
+
+public static class ParametersExtensions
+{
+	/// <summary>
+	/// Searches <paramref name="parameters"/> for <paramref name="key"/>
+	/// </summary>
+	/// <typeparam name="T">The type of the parameter to return</typeparam>
+	/// <param name="parameters">A collection of parameters to search</param>
+	/// <param name="key">The key of the parameter to find</param>
+	/// <returns>A matching value of <typeparamref name="T"/> if it exists</returns>
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public static T GetValue<T>(this IEnumerable<KeyValuePair<string, object>> parameters, string key) =>
+		(T)GetValue(parameters, key, typeof(T));
+
+	/// <summary>
+	/// Searches <paramref name="parameters"/> for value referenced by <paramref name="key"/>
+	/// </summary>
+	/// <param name="parameters">A collection of parameters to search</param>
+	/// <param name="key">The key of the parameter to find</param>
+	/// <param name="type">The type of the parameter to return</param>
+	/// <returns>A matching value of <paramref name="type"/> if it exists</returns>
+	/// <exception cref="InvalidCastException">Unable to convert the value of Type</exception>
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public static object GetValue(this IEnumerable<KeyValuePair<string, object>> parameters, string key, Type type)
+	{
+		foreach (KeyValuePair<string, object> kvp in parameters)
+		{
+			if (string.Compare(kvp.Key, key, StringComparison.Ordinal) == 0)
+			{
+				if (TryGetValueInternal(kvp, type, out object value))
+				{
+					return value;
+				}
+
+				throw new InvalidCastException($"Unable to convert the value of Type '{kvp.Value.GetType().FullName}' to '{type.FullName}' for the key '{key}' ");
+			}
+		}
+
+		return GetDefault(type);
+	}
+
+	/// <summary>
+	/// Searches <paramref name="parameters"/> for value referenced by <paramref name="key"/>
+	/// </summary>
+	/// <typeparam name="T">The type of the parameter to return</typeparam>
+	/// <param name="parameters">A collection of parameters to search</param>
+	/// <param name="key">The key of the parameter to find</param>
+	/// <param name="value">The value of parameter to return</param>
+	/// <returns>Success if value is found; otherwise returns <c>false</c></returns>
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public static bool TryGetValue<T>(this IEnumerable<KeyValuePair<string, object>> parameters, string key, out T value)
+	{
+		Type type = typeof(T);
+
+		foreach (KeyValuePair<string, object> kvp in parameters)
+		{
+			if (string.Compare(kvp.Key, key, StringComparison.Ordinal) == 0)
+			{
+				bool success = TryGetValueInternal(kvp, typeof(T), out object valueAsObject);
+				value = (T)valueAsObject;
+				return success;
+			}
+		}
+
+		value = default;
+		return false;
+	}
+
+	/// <summary>
+	/// Searches <paramref name="parameters"/> for value referenced by <paramref name="key"/>
+	/// </summary>
+	/// <typeparam name="T">The type of the parameter to return</typeparam>
+	/// <param name="parameters">A collection of parameters to search</param>
+	/// <param name="key">The key of the parameter to find</param>
+	/// <returns>An IEnumerable{T} of all the values referenced by key</returns>
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public static IEnumerable<T> GetValues<T>(this IEnumerable<KeyValuePair<string, object>> parameters, string key)
+	{
+		List<T> values = [];
+		Type type = typeof(T);
+
+		foreach (KeyValuePair<string, object> kvp in parameters)
+		{
+			if (string.Compare(kvp.Key, key, StringComparison.Ordinal) == 0)
+			{
+				TryGetValueInternal(kvp, type, out object value);
+				values.Add((T)value);
+			}
+		}
+
+		return values.AsEnumerable();
+	}
+
+	private static bool TryGetValueInternal(KeyValuePair<string, object> kvp, Type type, out object value)
+	{
+		value = GetDefault(type);
+		bool success = false;
+		if (kvp.Value == null)
+		{
+			success = true;
+		}
+		else if (kvp.Value.GetType() == type)
+		{
+			success = true;
+			value = kvp.Value;
+		}
+		else if (type.IsAssignableFrom(kvp.Value.GetType()))
+		{
+			success = true;
+			value = kvp.Value;
+		}
+		else if (type.IsEnum)
+		{
+			string valueAsString = kvp.Value.ToString();
+			if (Enum.IsDefined(type, valueAsString))
+			{
+				success = true;
+				value = Enum.Parse(type, valueAsString);
+			}
+			else if (int.TryParse(valueAsString, out int numericValue))
+			{
+				success = true;
+				value = Enum.ToObject(type, numericValue);
+			}
+		}
+
+		if (!success && type.GetInterface("System.IConvertible") != null)
+		{
+			success = true;
+			value = System.Convert.ChangeType(kvp.Value, type);
+		}
+
+		return success;
+	}
+
+	/// <summary>
+	/// Checks to see if key exists in parameter collection
+	/// </summary>
+	/// <param name="parameters">IEnumerable to search</param>
+	/// <param name="key">The key to search the <paramref name="parameters"/> for existence</param>
+	/// <returns><c>true</c> if key exists; <c>false</c> otherwise</returns>
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public static bool ContainsKey(this IEnumerable<KeyValuePair<string, object>> parameters, string key) =>
+		parameters.Any(x => string.Compare(x.Key, key, StringComparison.Ordinal) == 0);
+
+	private static object GetDefault(Type type)
+	{
+		if (type.IsValueType)
+		{
+			return Activator.CreateInstance(type);
+		}
+		return null;
+	}
+}
diff --git a/Source/MAX.Core/Helpers/ReflectionHelper.cs b/Source/MAX.Core/Helpers/ReflectionHelper.cs
new file mode 100644
index 0000000..e08efdf
--- /dev/null
+++ b/Source/MAX.Core/Helpers/ReflectionHelper.cs
@@ -0,0 +1,586 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace MAX.Core.Helpers;
+
+/// <summary>
+/// 反射操作
+/// </summary>
+public static class ReflectionHelper
+{
+	/// <summary>
+	/// 获取类型描述，使用DescriptionAttribute设置描述
+	/// </summary>
+	/// <typeparam name="T">类型</typeparam>
+	public static string GetDescription<T>()
+	{
+		return GetDescription(Common.GetType<T>());
+	}
+
+	/// <summary>
+	/// 获取类型成员描述，使用DescriptionAttribute设置描述
+	/// </summary>
+	/// <typeparam name="T">类型</typeparam>
+	/// <param name="memberName">成员名称</param>
+	public static string GetDescription<T>(string memberName)
+	{
+		return GetDescription(Common.GetType<T>(), memberName);
+	}
+
+	/// <summary>
+	/// 获取类型成员描述，使用DescriptionAttribute设置描述
+	/// </summary>
+	/// <param name="type">类型</param>
+	/// <param name="memberName">成员名称</param>
+	public static string GetDescription(Type type, string memberName)
+	{
+		if (type == null)
+		{
+			return string.Empty;
+		}
+
+		if (string.IsNullOrWhiteSpace(memberName))
+		{
+			return string.Empty;
+		}
+
+		return GetDescription(type.GetTypeInfo().GetMember(memberName).FirstOrDefault());
+	}
+
+	/// <summary>
+	/// 获取类型成员描述，使用DescriptionAttribute设置描述
+	/// </summary>
+	/// <param name="member">成员</param>
+	public static string GetDescription(MemberInfo member)
+	{
+		if (member == null)
+		{
+			return string.Empty;
+		}
+
+		return member.GetCustomAttribute<DescriptionAttribute>() is DescriptionAttribute attribute ? attribute.Description : member.Name;
+	}
+
+	
+
+	/// <summary>
+	/// 获取显示名称或描述,使用DisplayNameAttribute设置显示名称,使用DescriptionAttribute设置描述
+	/// </summary>
+	/// <typeparam name="T">类型</typeparam>
+	public static string GetDisplayNameOrDescription<T>()
+	{
+		return GetDisplayNameOrDescription(Common.GetType<T>());
+	}
+
+	/// <summary>
+	/// 获取属性显示名称或描述,使用DisplayAttribute或DisplayNameAttribute设置显示名称,使用DescriptionAttribute设置描述
+	/// </summary>
+	public static string GetDisplayNameOrDescription(MemberInfo member)
+	{
+		return  GetDescription(member);
+	}
+
+	/// <summary>
+	/// 查找类型列表
+	/// </summary>
+	/// <typeparam name="TFind">查找类型</typeparam>
+	/// <param name="assemblies">待查找的程序集列表</param>
+	public static List<Type> FindTypes<TFind>(params Assembly[] assemblies)
+	{
+		Type findType = typeof(TFind);
+		return FindTypes(findType, assemblies);
+	}
+
+	/// <summary>
+	/// 查找类型列表
+	/// </summary>
+	/// <param name="findType">查找类型</param>
+	/// <param name="assemblies">待查找的程序集列表</param>
+	public static List<Type> FindTypes(Type findType, params Assembly[] assemblies)
+	{
+		List<Type> result = [];
+		foreach (Assembly assembly in assemblies)
+		{
+			result.AddRange(GetTypes(findType, assembly));
+		}
+
+		return result.Distinct().ToList();
+	}
+
+	/// <summary>
+	/// 获取类型列表
+	/// </summary>
+	private static List<Type> GetTypes(Type findType, Assembly assembly)
+	{
+		List<Type> result = [];
+		if (assembly == null)
+		{
+			return result;
+		}
+
+		Type[] types;
+		try
+		{
+			types = assembly.GetTypes();
+		}
+		catch (ReflectionTypeLoadException ex)
+		{
+			Debug.WriteLine(ex);
+			return result;
+		}
+		foreach (Type type in types)
+		{
+			AddType(result, findType, type);
+		}
+
+		return result;
+	}
+
+	/// <summary>
+	/// 添加类型
+	/// </summary>
+	private static void AddType(List<Type> result, Type findType, Type type)
+	{
+		if (type.IsInterface || type.IsAbstract)
+		{
+			return;
+		}
+
+		if (findType.IsAssignableFrom(type) == false && MatchGeneric(findType, type) == false)
+		{
+			return;
+		}
+
+		result.Add(type);
+	}
+
+	/// <summary>
+	/// 泛型匹配
+	/// </summary>
+	private static bool MatchGeneric(Type findType, Type type)
+	{
+		if (findType.IsGenericTypeDefinition == false)
+		{
+			return false;
+		}
+
+		Type definition = findType.GetGenericTypeDefinition();
+		foreach (Type implementedInterface in type.FindInterfaces((filter, criteria) => true, null))
+		{
+			if (implementedInterface.IsGenericType == false)
+			{
+				continue;
+			}
+
+			return definition.IsAssignableFrom(implementedInterface.GetGenericTypeDefinition());
+		}
+		return false;
+	}
+
+	/// <summary>
+	/// 获取实现了接口的所有实例
+	/// </summary>
+	/// <typeparam name="TInterface">接口类型</typeparam>
+	/// <param name="assemblies">待查找的程序集列表</param>
+	public static List<TInterface> GetInstancesByInterface<TInterface>(params Assembly[] assemblies)
+	{
+		return FindTypes<TInterface>(assemblies)
+			.Select(t => CreateInstance<TInterface>(t)).ToList();
+	}
+
+	/// <summary>
+	/// 动态创建实例
+	/// </summary>
+	/// <typeparam name="T">目标类型</typeparam>
+	/// <param name="type">类型</param>
+	/// <param name="parameters">传递给构造函数的参数</param>        
+	public static T CreateInstance<T>(Type type, params object[] parameters)
+	{
+		return Convert.To<T>(Activator.CreateInstance(type, parameters));
+	}
+
+	public static Type GetType(string typeName)
+	{
+
+		Type type = null;
+
+		Assembly[] assemblyArray = AppDomain.CurrentDomain.GetAssemblies();
+
+		int assemblyArrayLength = assemblyArray.Length;
+
+		for (int i = 0; i < assemblyArrayLength; ++i)
+		{
+
+			type = assemblyArray[i].GetType(typeName);
+
+			if (type != null)
+			{
+				return type;
+			}
+		}
+
+		for (int i = 0; i < assemblyArrayLength; ++i)
+		{
+			Type[] typeArray = assemblyArray[i].GetTypes();
+			int typeArrayLength = typeArray.Length;
+			for (int j = 0; j < typeArrayLength; ++j)
+			{
+				if (typeArray[j].Name.Equals(typeName))
+				{
+					return typeArray[j];
+				}
+			}
+		}
+
+		return type;
+
+	}
+
+	/// <summary>
+	/// 获取程序集
+	/// </summary>
+	/// <param name="assemblyName">程序集名称</param>
+	public static Assembly GetAssembly(string assemblyName)
+	{
+		return Assembly.Load(new AssemblyName(assemblyName));
+	}
+
+	/// <summary>
+	/// 是否布尔类型
+	/// </summary>
+	/// <param name="member">成员</param>
+	public static bool IsBool(MemberInfo member)
+	{
+		if (member == null)
+		{
+			return false;
+		}
+
+		return member.MemberType switch
+		{
+			MemberTypes.TypeInfo => member.ToString() == "System.Boolean",
+			MemberTypes.Property => IsBool((PropertyInfo)member),
+			_ => false,
+		};
+	}
+
+	/// <summary>
+	/// 是否布尔类型
+	/// </summary>
+	private static bool IsBool(PropertyInfo property)
+	{
+		return property.PropertyType == typeof(bool) || property.PropertyType == typeof(bool?);
+	}
+
+	/// <summary>
+	/// 是否枚举类型
+	/// </summary>
+	/// <param name="member">成员</param>
+	public static bool IsEnum(MemberInfo member)
+	{
+		if (member == null)
+		{
+			return false;
+		}
+
+		return member.MemberType switch
+		{
+			MemberTypes.TypeInfo => ((TypeInfo)member).IsEnum,
+			MemberTypes.Property => IsEnum((PropertyInfo)member),
+			_ => false,
+		};
+	}
+
+	/// <summary>
+	/// 是否枚举类型
+	/// </summary>
+	private static bool IsEnum(PropertyInfo property)
+	{
+		if (property.PropertyType.GetTypeInfo().IsEnum)
+		{
+			return true;
+		}
+
+		Type value = Nullable.GetUnderlyingType(property.PropertyType);
+		if (value == null)
+		{
+			return false;
+		}
+
+		return value.GetTypeInfo().IsEnum;
+	}
+
+	/// <summary>
+	/// 是否日期类型
+	/// </summary>
+	/// <param name="member">成员</param>
+	public static bool IsDate(MemberInfo member)
+	{
+		if (member == null)
+		{
+			return false;
+		}
+
+		return member.MemberType switch
+		{
+			MemberTypes.TypeInfo => member.ToString() == "System.DateTime",
+			MemberTypes.Property => IsDate((PropertyInfo)member),
+			_ => false,
+		};
+	}
+
+	/// <summary>
+	/// 是否日期类型
+	/// </summary>
+	private static bool IsDate(PropertyInfo property)
+	{
+		if (property.PropertyType == typeof(DateTime))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(DateTime?))
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	/// <summary>
+	/// 是否整型
+	/// </summary>
+	/// <param name="member">成员</param>
+	public static bool IsInt(MemberInfo member)
+	{
+		if (member == null)
+		{
+			return false;
+		}
+
+		return member.MemberType switch
+		{
+			MemberTypes.TypeInfo => member.ToString() is "System.Int32" or "System.Int16" or "System.Int64",
+			MemberTypes.Property => IsInt((PropertyInfo)member),
+			_ => false,
+		};
+	}
+
+	/// <summary>
+	/// 是否整型
+	/// </summary>
+	private static bool IsInt(PropertyInfo property)
+	{
+		if (property.PropertyType == typeof(int))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(int?))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(short))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(short?))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(long))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(long?))
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	/// <summary>
+	/// 是否数值类型
+	/// </summary>
+	/// <param name="member">成员</param>
+	public static bool IsNumber(MemberInfo member)
+	{
+		if (member == null)
+		{
+			return false;
+		}
+
+		if (IsInt(member))
+		{
+			return true;
+		}
+
+		return member.MemberType switch
+		{
+			MemberTypes.TypeInfo => member.ToString() is "System.Double" or "System.Decimal" or "System.Single",
+			MemberTypes.Property => IsNumber((PropertyInfo)member),
+			_ => false,
+		};
+	}
+
+	/// <summary>
+	/// 是否数值类型
+	/// </summary>
+	private static bool IsNumber(PropertyInfo property)
+	{
+		if (property.PropertyType == typeof(double))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(double?))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(decimal))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(decimal?))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(float))
+		{
+			return true;
+		}
+
+		if (property.PropertyType == typeof(float?))
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	/// <summary>
+	/// 是否集合
+	/// </summary>
+	/// <param name="type">类型</param>
+	public static bool IsCollection(Type type)
+	{
+		if (type.IsArray)
+		{
+			return true;
+		}
+
+		return IsGenericCollection(type);
+	}
+
+	/// <summary>
+	/// 是否泛型集合
+	/// </summary>
+	/// <param name="type">类型</param>
+	public static bool IsGenericCollection(Type type)
+	{
+		if (!type.IsGenericType)
+		{
+			return false;
+		}
+
+		Type typeDefinition = type.GetGenericTypeDefinition();
+		return typeDefinition == typeof(IEnumerable<>)
+			   || typeDefinition == typeof(IReadOnlyCollection<>)
+			   || typeDefinition == typeof(IReadOnlyList<>)
+			   || typeDefinition == typeof(ICollection<>)
+			   || typeDefinition == typeof(IList<>)
+			   || typeDefinition == typeof(List<>);
+	}
+
+	/// <summary>
+	/// 从目录中获取所有程序集
+	/// </summary>
+	/// <param name="directoryPath">目录绝对路径</param>
+	public static List<Assembly> GetAssemblies(string directoryPath)
+	{
+		return Directory.GetFiles(directoryPath, "*.*", SearchOption.AllDirectories).ToList()
+			.Where(t => t.EndsWith(".exe") || t.EndsWith(".dll"))
+			.Select(path => Assembly.Load(new AssemblyName(path))).ToList();
+	}
+
+	/// <summary>
+	/// 获取公共属性列表
+	/// </summary>
+	/// <param name="instance">实例</param>
+	public static List<CommonItem> GetPublicProperties(object instance)
+	{
+		PropertyInfo[] properties = instance.GetType().GetProperties();
+		return properties.ToList().Select(t => new CommonItem(t.Name, t.GetValue(instance))).ToList();
+	}
+
+	/// <summary>
+	/// 获取顶级基类
+	/// </summary>
+	/// <typeparam name="T">类型</typeparam>
+	public static Type GetTopBaseType<T>()
+	{
+		return GetTopBaseType(typeof(T));
+	}
+
+	/// <summary>
+	/// 获取顶级基类
+	/// </summary>
+	/// <param name="type">类型</param>
+	public static Type GetTopBaseType(Type type)
+	{
+		if (type == null)
+		{
+			return null;
+		}
+
+		if (type.IsInterface)
+		{
+			return type;
+		}
+
+		if (type.BaseType == typeof(object))
+		{
+			return type;
+		}
+
+		return GetTopBaseType(type.BaseType);
+	}
+
+	/// <summary>
+	/// 获取元素类型，如果是集合，返回集合的元素类型
+	/// </summary>
+	/// <param name="type">类型</param>
+	public static Type GetElementType(Type type)
+	{
+		if (IsCollection(type) == false)
+		{
+			return type;
+		}
+
+		if (type.IsArray)
+		{
+			return type.GetElementType();
+		}
+
+		Type[] genericArgumentsTypes = type.GetTypeInfo().GetGenericArguments();
+		if (genericArgumentsTypes == null || genericArgumentsTypes.Length == 0)
+		{
+			throw new ArgumentException("泛型类型参数不能为空");
+		}
+
+		return genericArgumentsTypes[0];
+	}
+}
diff --git a/Source/MAX.Core/Helpers/UriHelper.cs b/Source/MAX.Core/Helpers/UriHelper.cs
new file mode 100644
index 0000000..bfa9f33
--- /dev/null
+++ b/Source/MAX.Core/Helpers/UriHelper.cs
@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace MAX.Core.Helpers;
+
+public class UriHelper
+{
+	#region 对外公开方法
+	/// <summary>
+	/// 带有前缀的域名
+	/// </summary>
+	/// <param name="url"></param>
+	/// <returns></returns>
+	public static string GetSchemeDomain(string url)
+	{
+		Uri uri = new(url);
+		return $"{uri.Scheme}://{uri.Authority}";
+	}
+	/// <summary>
+	/// 获取域名
+	/// </summary>
+	/// <param name="url"></param>
+	/// <returns></returns>
+	public static string GetDomain(string url)
+	{
+		Uri uri = new(url);
+		return uri.Host;
+	}
+	/// <summary>
+	/// 获取 URL
+	/// </summary>
+	/// <param name="url">URL 地址</param>
+	/// <returns></returns>
+	public static string GetUrl(string url)
+	{
+		Uri uri = new(url);
+		return uri.AbsolutePath;
+	}
+	/// <summary>
+	/// URL 解码
+	/// </summary>
+	/// <param name="url">URL 地址</param>
+	/// <returns></returns>
+	public static string UrlDecode(string url)
+	{
+		return System.Web.HttpUtility.UrlDecode(url);
+	}
+	/// <summary>
+	/// URL 解码
+	/// </summary>
+	/// <param name="url">URL 地址</param>
+	/// <param name="encoding">编码格式</param>
+	/// <returns></returns>
+	public static string UrlDecode(string url, Encoding encoding)
+	{
+		return System.Web.HttpUtility.UrlDecode(url, encoding);
+	}
+	/// <summary>
+	/// URL 编码
+	/// </summary>
+	/// <param name="url">URL 地址</param>
+	/// <returns></returns>
+	public static string UrlEncode(string url)
+	{
+		return System.Web.HttpUtility.UrlEncode(url);
+	}
+	/// <summary>
+	/// URL 编码
+	/// </summary>
+	/// <param name="url">URL 地址</param>
+	/// <param name="encoding">编码格式</param>
+	/// <returns></returns>
+	public static string UrlEncode(string url, Encoding encoding)
+	{
+		return System.Web.HttpUtility.UrlEncode(url, encoding);
+	}
+	/// <summary>
+	/// 获取参数列表
+	/// </summary>
+	/// <param name="url">Url 地址</param>
+	/// <returns></returns>
+	public static List<string> GetQueryList(string url)
+	{
+		return GetQueryList(url, Encoding.UTF8);
+	}
+	/// <summary>
+	/// 获取参数列表
+	/// </summary>
+	/// <param name="url">Url 地址</param>
+	/// <param name="encoding">编码格式</param>
+	/// <returns></returns>
+	public static List<string> GetQueryList(string url, Encoding encoding)
+	{
+		Uri uri = new(url);
+		string query = uri.PathAndQuery;
+		if (query.IndexOf(".") > 0)
+		{
+			query = query.Substring(0, query.IndexOf("."));
+		}
+
+		List<string> dataList = [];
+		string[] queryDataList = query.Split(new string[] { "/" }, StringSplitOptions.RemoveEmptyEntries);
+		if (queryDataList != null && queryDataList.Length > 0)
+		{
+			foreach (string queryData in queryDataList)
+			{
+				dataList.Add(System.Web.HttpUtility.UrlDecode(queryData, encoding));
+			}
+		}
+		return dataList;
+	}
+	/// <summary>
+	/// 获取参数字典
+	/// </summary>
+	/// <param name="url">Url 地址</param>
+	/// <returns></returns>
+	public static Dictionary<string, string> GetQueryDict(string url)
+	{
+		return GetQueryDict(url, Encoding.UTF8);
+	}
+	/// <summary>
+	/// 获取参数字典
+	/// </summary>
+	/// <param name="url">Url 地址</param>
+	/// <param name="encoding">编码格式</param>
+	/// <returns></returns>
+	public static Dictionary<string, string> GetQueryDict(string url, Encoding encoding)
+	{
+		Uri uri = new(url);
+		string query = uri.Query.TrimStart(new char[] { '?' });
+
+		Dictionary<string, string> dataDict = [];
+		string[] queryDataList = query.Split(new string[] { "&" }, StringSplitOptions.RemoveEmptyEntries);
+		if (queryDataList != null && queryDataList.Length > 0)
+		{
+			foreach (string queryData in queryDataList)
+			{
+				string[] keyValue = queryData.Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries);
+				if (!dataDict.ContainsKey(keyValue[0]))
+				{
+					dataDict.Add(keyValue[0].ToLower(), System.Web.HttpUtility.UrlDecode(keyValue[1], encoding));
+				}
+			}
+		}
+		return dataDict;
+	}
+	#endregion
+}
diff --git a/Source/MAX.Core/Infrastructure/IStartup.cs b/Source/MAX.Core/Infrastructure/IStartup.cs
new file mode 100644
index 0000000..635cf03
--- /dev/null
+++ b/Source/MAX.Core/Infrastructure/IStartup.cs
@@ -0,0 +1,15 @@
+using MAX.Core.Autofac;
+using MAX.Core.DependencyInjection;
+
+namespace MAX.Core.Infrastructure;
+
+/// <summary>
+/// 启动器：实现 <see cref="IDependencyRegistrar"/>，由宿主项目统一发现并按 <see cref="Priority"/> 排序执行。
+/// </summary>
+public interface IStartup : IDependencyRegistrar, IPriority
+{
+	/// <summary>
+	/// 初始化
+	/// </summary>
+	void Initialize();
+}
diff --git a/Source/MAX.Core/Infrastructure/SingleInstance.cs b/Source/MAX.Core/Infrastructure/SingleInstance.cs
new file mode 100644
index 0000000..b6eb50a
--- /dev/null
+++ b/Source/MAX.Core/Infrastructure/SingleInstance.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Reflection;
+
+namespace MAX.Core.Infrastructure;
+
+/// <summary>
+/// 单例，需要在当前类中定义
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public class SingleInstance<T> where T : class
+{
+	private static readonly object lockObj = new();
+	private static T mySelf;//= default(T);
+	public static T Instance
+	{
+		get
+		{
+			lock (lockObj)
+			{
+				mySelf ??= InstanceCreator.CreateInstance<T>();
+			}
+
+			return mySelf;
+		}
+	}
+}
+
+public static class InstanceCreator
+{
+	public static T CreateInstance<T>()
+	{
+		Type type = typeof(T);
+		try
+		{
+			return (T)type.Assembly.CreateInstance(type.FullName, true, BindingFlags.NonPublic | BindingFlags.Instance, null, null, null, null);
+		}
+		catch (MissingMethodException ex)
+		{
+			throw new Exception($"{ex.Message}\n(单例模式下，构造函数必须为 private)");
+		}
+	}
+}
diff --git a/Source/MAX.Core/IntPriority.cs b/Source/MAX.Core/IntPriority.cs
new file mode 100644
index 0000000..b4fc563
--- /dev/null
+++ b/Source/MAX.Core/IntPriority.cs
@@ -0,0 +1,74 @@
+namespace MAX.Core;
+
+/// <summary>
+/// 优先级（优先级越高越先执行）
+/// </summary>
+public interface IPriority
+{
+	/// <summary>
+	/// 优先级（优先级越高越先执行）
+	/// </summary>
+	int Priority { get; }
+}
+/// <summary>
+/// 优先级
+/// </summary>
+/// <remarks>
+/// </remarks>
+public static class IntPriority
+{
+	/// <summary>
+	/// 最高优先级 (5000)
+	/// </summary>
+	public const int Highest = 5000;
+
+	/// <summary>
+	/// 非常高优先级 (4000)
+	/// </summary>
+	public const int VeryHigh = 4000;
+
+	/// <summary>
+	/// 较高优先级 (3000)
+	/// </summary>
+	public const int Higher = 3000;
+
+	/// <summary>
+	/// 高优先级 (2000)
+	/// </summary>
+	public const int High = 2000;
+
+	/// <summary>
+	/// 高于正常优先级 (1000)
+	/// </summary>
+	public const int AboveNormal = 1000;
+
+	/// <summary>
+	/// 正常优先级 (0)
+	/// </summary>
+	public const int Normal = 0;
+
+	/// <summary>
+	/// 低于正常优先级 (-1000)
+	/// </summary>
+	public const int BelowNormal = -1000;
+
+	/// <summary>
+	/// 低优先级 (-2000)
+	/// </summary>
+	public const int Low = -2000;
+
+	/// <summary>
+	/// 较低优先级 (-3000)
+	/// </summary>
+	public const int Lower = -3000;
+
+	/// <summary>
+	/// 非常低优先级 (-4000)
+	/// </summary>
+	public const int VeryLow = -4000;
+
+	/// <summary>
+	/// 最低优先级 (-5000)
+	/// </summary>
+	public const int Lowest = -5000;
+}
\ No newline at end of file
diff --git a/Source/MAX.Core/Logger/ConsoleLogger.cs b/Source/MAX.Core/Logger/ConsoleLogger.cs
new file mode 100644
index 0000000..2c330dd
--- /dev/null
+++ b/Source/MAX.Core/Logger/ConsoleLogger.cs
@@ -0,0 +1,124 @@
+using System;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+
+namespace MAX.Core.Logger;
+
+/// <summary>
+/// Implementation of <see cref="ILoggerBase"/> that logs into a <see cref="TextWriter"/>.
+/// </summary>
+public class ConsoleLogger : ILoggerFacade
+{
+	private readonly bool _debug;
+	private readonly bool _console;
+
+	public bool IsDebugEnabled => true;
+
+	/// <summary>
+	/// Initializes a new instance of <see cref="ConsoleLogger"/> that writes to
+	/// the console output.
+	/// </summary>
+	public ConsoleLogger(bool debug = true, bool console = true)
+	{
+		_debug = debug;
+		_console = console;
+	}
+
+
+
+
+
+
+	///// <summary>
+	///// Disposes the associated <see cref="TextWriter"/>.
+	///// </summary>
+	///// <param name="disposing">When <see langword="true"/>, disposes the associated <see cref="TextWriter"/>.</param>
+	//protected virtual void Dispose(bool disposing)
+	//{
+	//	if (disposing)
+	//	{
+	//		writer?.Dispose();
+	//	}
+	//}
+
+	///<summary>
+	///Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+	///</summary>
+	/// <remarks>Calls <see cref="Dispose(bool)"/></remarks>.
+	///<filterpriority>2</filterpriority>
+	public void Dispose()
+	{
+		GC.SuppressFinalize(this);
+	}
+
+	public void Debug(Exception ex, string message)
+	{
+		Log(message, LogLevel.Debug);
+	}
+
+	public void Debug(string message)
+	{
+		Log(message, LogLevel.Debug);
+	}
+
+	public void Info(Exception ex, string message)
+	{
+		Log(message, LogLevel.Info);
+	}
+
+	public void Info(string message)
+	{
+		Log(message, LogLevel.Info);
+	}
+
+	public void Warn(Exception ex, string message)
+	{
+		Log(message, LogLevel.Warn);
+	}
+
+	public void Warn(string message)
+	{
+		Log(message, LogLevel.Warn);
+	}
+
+	public void Error(Exception ex, string message)
+	{
+		Log(message, LogLevel.Error);
+	}
+
+	public void Error(string message)
+	{
+		Log(message, LogLevel.Error);
+	}
+
+	public void Fatal(Exception ex, string message)
+	{
+		Log(message, LogLevel.Fatal);
+	}
+
+	public void Fatal(string message)
+	{
+		Log(message, LogLevel.Fatal);
+	}
+
+	public void Error(Exception ex)
+	{
+		Log(ex.Message, LogLevel.Error);
+	}
+
+	public void Log(string message, LogLevel level)
+	{
+		string messageToLog = string.Format(CultureInfo.InvariantCulture, "{1}: {2}. Timestamp:{0:u}.", DateTime.Now,
+			level.ToString().ToUpper(CultureInfo.InvariantCulture), message);
+		//Trace.WriteLine(messageToLog);
+		if (_debug)
+		{
+			System.Diagnostics.Debug.WriteLine(messageToLog);
+		}
+		if (_console)
+		{
+            Console.WriteLine(messageToLog);
+		}
+	}
+}
\ No newline at end of file
diff --git a/Source/MAX.Core/Logger/ICustomLogger.cs b/Source/MAX.Core/Logger/ICustomLogger.cs
new file mode 100644
index 0000000..456a96b
--- /dev/null
+++ b/Source/MAX.Core/Logger/ICustomLogger.cs
@@ -0,0 +1,12 @@
+using MAX.Core.Infrastructure;
+
+namespace MAX.Core.Logger;
+
+/// <summary>自定义日志记录器接口</summary>
+public interface ICustomLogger
+{
+	/// <summary>记录日志信息</summary>
+	/// <param name="group">日志分组</param>
+	/// <param name="message">日志内容</param>
+	void Log(string group, string message);
+}
diff --git a/Source/MAX.Core/Logger/ILoggerFacade.cs b/Source/MAX.Core/Logger/ILoggerFacade.cs
new file mode 100644
index 0000000..02bd991
--- /dev/null
+++ b/Source/MAX.Core/Logger/ILoggerFacade.cs
@@ -0,0 +1,68 @@
+using System;
+
+namespace MAX.Core.Logger;
+
+/// <summary>
+/// 日志操作
+/// </summary>
+public interface ILoggerFacade
+{
+	/// <summary>
+	/// 调试级别是否启用
+	/// </summary>
+	bool IsDebugEnabled { get; }
+
+	/// <summary>
+	/// 调试
+	/// </summary>
+	void Debug(Exception ex, string message);
+	/// <summary>
+	/// 调试
+	/// </summary>
+	/// <param name="message">日志消息</param>
+	void Debug(string message);
+	/// <summary>
+	/// 信息
+	/// </summary>
+	void Info(Exception ex, string message);
+	/// <summary>
+	/// 信息
+	/// </summary>
+	/// <param name="message">日志消息</param>
+	void Info(string message);
+	/// <summary>
+	/// 警告
+	/// </summary>
+	void Warn(Exception ex, string message);
+	/// <summary>
+	/// 警告
+	/// </summary>
+	/// <param name="message">日志消息</param>
+	void Warn(string message);
+	/// <summary>
+	/// 错误
+	/// </summary>
+	void Error(Exception ex, string message);
+	/// <summary>
+	/// 错误
+	/// </summary>
+	/// <param name="message">日志消息</param>
+	void Error(string message);
+	/// <summary>
+	/// 致命错误
+	/// </summary>
+	void Fatal(Exception ex, string message);
+	/// <summary>
+	/// 致命错误
+	/// </summary>
+	/// <param name="message">日志消息</param>
+	void Fatal(string message);
+	void Error(Exception ex);
+
+	/// <summary>
+	/// 写入日志
+	/// </summary>
+	/// <param name="message"></param>
+	/// <param name="level"></param>
+	void Log(string message, LogLevel level);
+}
diff --git a/Source/MAX.Core/Logger/LogLevel.cs b/Source/MAX.Core/Logger/LogLevel.cs
new file mode 100644
index 0000000..941b991
--- /dev/null
+++ b/Source/MAX.Core/Logger/LogLevel.cs
@@ -0,0 +1,15 @@
+namespace MAX.Core.Logger;
+
+/// <summary>
+/// ��־�ȼ�
+/// </summary>
+public enum LogLevel
+{
+	Trace = 0,
+	Debug = 1,
+	Info = 2,
+	Warn = 3,
+	Error = 4,
+	Fatal = 5,
+	None = 6
+}
\ No newline at end of file
diff --git a/Source/MAX.Core/MAX.Core.csproj b/Source/MAX.Core/MAX.Core.csproj
new file mode 100644
index 0000000..594856b
--- /dev/null
+++ b/Source/MAX.Core/MAX.Core.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="MediatR" Version="9.0.0" />
+		<PackageReference Include="Autofac" Version="9.3.2" />
+	</ItemGroup>
+
+</Project>
diff --git a/Source/MAX.Core/Reflections/AppTypeFinder.cs b/Source/MAX.Core/Reflections/AppTypeFinder.cs
new file mode 100644
index 0000000..d712adb
--- /dev/null
+++ b/Source/MAX.Core/Reflections/AppTypeFinder.cs
@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace MAX.Core.Reflections;
+
+public partial class AppTypeFinder : Finder
+{
+	public static AppTypeFinder Instance { get; } = new AppTypeFinder();
+
+	/// <summary>
+	/// 所有程序集
+	/// </summary>
+	public static List<Assembly> Assemblies => Instance.GetAssemblies();
+
+	public static Exception LoadDLL(string dllPath, out Assembly assembly)
+	{
+		return Instance.LoadAssemblyToAppDomain(dllPath, out assembly);
+	}
+
+	/// <summary>
+	/// 程序集是否匹配
+	/// </summary>
+	protected override bool Match(string assemblyName)
+	{
+		if (base.Match(assemblyName))
+		{
+			if (AvailablePrefix().Exists(assemblyName.StartsWith))
+			{
+				return true;
+			}
+			return Regex.IsMatch(assemblyName, "^(MAX\\.)", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+		}
+		return false;
+	}
+
+
+	protected virtual List<string> AvailablePrefix()
+	{
+		return ["MAX."];
+	}
+
+	public static IEnumerable<Type> GetAllTypes()
+	{
+		List<Type> types = [];
+		foreach (Assembly item in Assemblies)
+		{
+			try
+			{
+				types.AddRange(item.GetTypes());
+			}
+			catch
+			{
+
+			}
+		}
+		return types;
+	}
+
+	/// <summary>
+	/// 查找当前程序集中所有继承或实现了指定类型的非抽象类。
+	/// </summary>
+	/// <param name="targetType">
+	/// 要匹配的目标类型，可以是：
+	/// <list type="bullet">
+	/// <item><description>普通接口类型（例如 <c>IMyService</c>）</description></item>
+	/// <item><description>开放泛型接口类型（例如 <c>IRepository&lt;&gt;</c>）</description></item>
+	/// <item><description>普通基类类型（例如 <c>BaseHandler</c>）</description></item>
+	/// <item><description>开放泛型基类类型（例如 <c>BaseHandler&lt;&gt;</c>）</description></item>
+	/// </list>
+	/// </param>
+	/// <returns>
+	/// 所有满足条件的具体类（非抽象类）的 <see cref="Type"/> 数组。
+	/// </returns>
+	/// <exception cref="ArgumentNullException">
+	/// 当 <paramref name="targetType"/> 为 <c>null</c> 时抛出。
+	/// </exception>
+	/// <remarks>
+	/// <para>
+	/// 此方法会遍历 <c>GetAllTypes()</c> 返回的所有类型，并筛选出：
+	/// <list type="bullet">
+	/// <item><description>实现了指定接口的类（包括开放泛型接口的封闭实现）</description></item>
+	/// <item><description>继承了指定基类的类（包括开放泛型基类的封闭实现）</description></item>
+	/// </list>
+	/// </para>
+	/// <para>示例：</para>
+	/// <code>
+	/// // 查找所有实现了 IEnumDisplayHandler&lt;T&gt; 的类
+	/// var handlers = FindAllDerivedTypes(typeof(IEnumDisplayHandler&lt;&gt;));
+	///
+	/// // 查找所有实现了 IMyService 的类
+	/// var services = FindAllDerivedTypes(typeof(IMyService));
+	///
+	/// // 查找所有继承 BaseHandler 的类
+	/// var subclasses = FindAllDerivedTypes(typeof(BaseHandler));
+	///
+	/// // 查找所有继承开放泛型基类 BaseHandler&lt;T&gt; 的类
+	/// var genericSubclasses = FindAllDerivedTypes(typeof(BaseHandler&lt;&gt;));
+	/// </code>
+	/// </remarks>
+	public static Type[] FindAllDerivedTypes(Type targetType)
+	{
+		if (targetType == null)
+		{
+			throw new ArgumentNullException(nameof(targetType));
+		}
+
+		return GetAllTypes().Where(t =>
+		{
+			try
+			{
+				if (!t.IsClass || t.IsAbstract)
+				{
+					return false;
+				}
+
+				// 开放泛型接口
+				if (targetType.IsInterface && targetType.IsGenericTypeDefinition)
+				{
+					return t.GetInterfaces().Any(i =>
+						i.IsGenericType && i.GetGenericTypeDefinition() == targetType);
+				}
+
+				// 普通接口
+				if (targetType.IsInterface)
+				{
+					return targetType.IsAssignableFrom(t);
+				}
+
+				// 开放泛型基类
+				if (targetType.IsGenericTypeDefinition)
+				{
+					return IsSubclassOfRawGeneric(t, targetType);
+				}
+
+				// 普通基类
+				return targetType.IsAssignableFrom(t) && t != targetType;
+			}
+			catch
+			{
+				return false;
+			}
+		})
+		.ToArray();
+	}
+
+	/// <summary>
+	/// 检查指定类型是否继承自某个开放泛型基类。
+	/// </summary>
+	/// <param name="type">要检查的类型。</param>
+	/// <param name="generic">开放泛型基类类型，例如 <c>BaseHandler&lt;&gt;</c>。</param>
+	/// <returns>
+	/// 如果 <paramref name="type"/> 的继承链中存在指定的开放泛型基类，则返回 <c>true</c>；否则返回 <c>false</c>。
+	/// </returns>
+	/// <remarks>
+	/// 此方法会沿着 <paramref name="type"/> 的继承链向上遍历，
+	/// 并在每一级检查是否为指定的开放泛型基类定义。
+	/// </remarks>
+	private static bool IsSubclassOfRawGeneric(Type type, Type generic)
+	{
+		while (type != null && type != typeof(object))
+		{
+			Type cur = type.IsGenericType ? type.GetGenericTypeDefinition() : type;
+			if (generic == cur)
+			{
+				return true;
+			}
+
+			type = type.BaseType;
+		}
+		return false;
+	}
+
+	/// <summary>
+	/// 泛型包装方法，查找所有继承或实现了指定类型 <typeparamref name="T"/> 的非抽象类。
+	/// </summary>
+	/// <typeparam name="T">
+	/// 目标类型，可以是接口、开放泛型接口、基类或开放泛型基类。
+	/// </typeparam>
+	/// <returns>
+	/// 所有满足条件的具体类（非抽象类）的 <see cref="Type"/> 数组。
+	/// </returns>
+	/// <remarks>
+	/// 调用示例：
+	/// <code>
+	/// var handlers = FindAllDerivedTypes&lt;IEnumDisplayHandler&lt;&gt;&gt;();
+	/// var services = FindAllDerivedTypes&lt;IMyService&gt;();
+	/// var subclasses = FindAllDerivedTypes&lt;BaseHandler&gt;();
+	/// var genericSubclasses = FindAllDerivedTypes&lt;BaseHandler&lt;&gt;&gt;();
+	/// </code>
+	/// </remarks>
+	public static Type[] FindAllDerivedTypes<T>() => FindAllDerivedTypes(typeof(T));
+
+
+}
diff --git a/Source/MAX.Core/Reflections/Finder.cs b/Source/MAX.Core/Reflections/Finder.cs
new file mode 100644
index 0000000..a941c95
--- /dev/null
+++ b/Source/MAX.Core/Reflections/Finder.cs
@@ -0,0 +1,129 @@
+using MAX.Core.Helpers;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace MAX.Core.Reflections;
+
+public class Finder
+{
+	/// <summary>
+	/// 跳过的程序集
+	/// </summary>
+	private const string SkipAssemblies = "^System|^Microsoft|^mscorlib|^netstandard|^Autofac|^AutoMapper|^EntityFramework|^Newtonsoft|^Castle|^NLog|^Pomelo|^AspectCore|^Xunit|^Nito|^Npgsql|^Exceptionless|^MySqlConnector|^Anonymously|^libuv|^api-ms|^clrcompression|^clretwrc|^clrjit|^coreclr|^dbgshim|^e_sqlite3|^hostfxr|^hostpolicy|^MessagePack|^mscordaccore|^mscordbi|^mscorrc|^sni|^sos|^SOS\\.NETCore|^sos_amd64|^SQLitePCLRaw|^StackExchange|^Swashbuckle|^WindowsBase|^ucrtbase|^DotNetCore\\.CAP|^MongoDB|^Confluent\\.Kafka|^librdkafka|^EasyCaching|^RabbitMQ|^Consul|^Dapper|^EnyimMemcachedCore|^Pipelines|^DnsClient|^IdentityModel|^zlib|^Runtime\\.|^Google|^Grpc|^Internal\\.|^Azure|^DevExpress\\.|^FreeSql\\.|^PresentationFramework|^PresentationCore|^Prism|^DirectWriteForwarder|^MAX\\.Common|^ReflectionHelperTypesPublicWrappers|^UIAutomation|^WindowsFormsIntegration";
+
+	/// <summary>
+	/// 获取程序集列表
+	/// </summary>
+	public virtual List<Assembly> GetAssemblies()
+	{
+		LoadAssemblies(AppDomain.CurrentDomain.BaseDirectory);
+		return GetAssembliesFromCurrentAppDomain();
+	}
+
+	/// <summary>
+	/// 加载程序集到当前应用程序域
+	/// </summary>
+	/// <param name="path">目录绝对路径</param>
+	protected void LoadAssemblies(string path)
+	{
+		foreach (string file in Directory.GetFiles(path, "*.dll"))
+		{
+			if (Match(Path.GetFileName(file)) == false)
+			{
+				continue;
+			}
+
+			LoadAssemblyToAppDomain(file, out _);
+		}
+	}
+
+	/// <summary>
+	/// 程序集是否匹配
+	/// </summary>
+	protected virtual bool Match(string assemblyName)
+	{
+		return Regex.IsMatch(assemblyName, SkipAssemblies, RegexOptions.IgnoreCase | RegexOptions.Compiled) == false;
+	}
+
+	/// <summary>
+	/// 将程序集添加当前应用程序域
+	/// </summary>
+	protected Exception LoadAssemblyToAppDomain(string file, out Assembly assembly)
+	{
+		try
+		{
+			//Debug.WriteLine($"Load Assembly : {Path.GetFileName(file)}");
+			AssemblyName assemblyName = AssemblyName.GetAssemblyName(file);
+			assembly = AppDomain.CurrentDomain.Load(assemblyName);
+			return null;
+		}
+		catch (FileNotFoundException)
+		{
+			// 如果找不到文件，回退到 LoadFrom 方式
+			try
+			{
+				assembly = Assembly.LoadFrom(file);
+				return null;
+			}
+			catch (Exception ex)
+			{
+				assembly = null;
+				return ex;
+			}
+		}
+		catch (Exception ex)
+		{
+			assembly = null;
+			return ex;
+		}
+	}
+
+	/// <summary>
+	/// 从当前应用程序域获取程序集列表
+	/// </summary>
+	private List<Assembly> GetAssembliesFromCurrentAppDomain()
+	{
+		List<Assembly> result = [];
+		foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
+		{
+			if (Match(assembly))
+			{
+				result.Add(assembly);
+			}
+		}
+		return result.Distinct().ToList();
+	}
+
+	/// <summary>
+	/// 程序集是否匹配
+	/// </summary>
+	private bool Match(Assembly assembly)
+	{
+		return !Regex.IsMatch(assembly.FullName, SkipAssemblies, RegexOptions.IgnoreCase | RegexOptions.Compiled);
+	}
+
+	/// <summary>
+	/// 查找类型列表
+	/// </summary>
+	/// <typeparam name="T">查找类型</typeparam>
+	/// <param name="assemblies">在指定的程序集列表中查找</param>
+	public List<Type> Find<T>(List<Assembly> assemblies = null)
+	{
+		return Find(typeof(T), assemblies);
+	}
+
+	/// <summary>
+	/// 查找类型列表
+	/// </summary>
+	/// <param name="findType">查找类型</param>
+	/// <param name="assemblies">在指定的程序集列表中查找</param>
+	public List<Type> Find(Type findType, List<Assembly> assemblies = null)
+	{
+		assemblies ??= GetAssemblies();
+		return ReflectionHelper.FindTypes(findType, assemblies.ToArray());
+	}
+}
diff --git a/Source/MAX.Core/Startup.cs b/Source/MAX.Core/Startup.cs
new file mode 100644
index 0000000..21e3865
--- /dev/null
+++ b/Source/MAX.Core/Startup.cs
@@ -0,0 +1,46 @@
+/***
+ *                    _ooOoo_
+ *                   o8888888o
+ *                   88" . "88
+ *                   (| -_- |)
+ *                    O\ = /O
+ *                ____/`---'\____
+ *              .   ' \\| |// `.
+ *               / \\||| : |||// \
+ *             / _||||| -:- |||||- \
+ *               | | \\\ - /// | |
+ *             | \_| ''\---/'' | |
+ *              \ .-\__ `-` ___/-. /
+ *           ___`. .' /--.--\ `. . __
+ *        ."" '< `.___\_<|>_/___.' >'"".
+ *       | | : `- \`.;`\ _ /`;.`/ - ` : | |
+ *         \ \ `-. \_ __\ /__ _/ .-` / /
+ * ======`-.____`-.___\_____/___.-`____.-'======
+ *                    `=---='
+ *
+ * .............................................
+ *          佛祖保佑             永无BUG
+ *          快加工资             不改需求 
+ */
+
+using Autofac;
+using MAX.Core.DependencyInjection;
+using MAX.Core.Infrastructure;
+using MAX.Core.Logger;
+
+namespace MAX.Core;
+
+public class Startup : IStartup
+{
+	public int Priority => int.MaxValue;
+
+	public void Initialize()
+	{
+
+	}
+
+	public void Register(ContainerBuilder builder)
+	{
+		builder.RegisterInstance(new ConsoleLogger()).As<ILoggerFacade>().SingleInstance();
+	}
+}
diff --git a/Source/MAX.Framework/Commons/KeyValue.cs b/Source/MAX.Framework/Commons/KeyValue.cs
new file mode 100644
index 0000000..e03b094
--- /dev/null
+++ b/Source/MAX.Framework/Commons/KeyValue.cs
@@ -0,0 +1,35 @@
+using System.Text;
+
+namespace MAX.Framework.Commons
+{
+	public struct KeyValue
+	{
+		public KeyValue(string key, string value)
+		{
+			Key = key;
+			Value = value;
+		}
+
+		public string Key { get; set; }
+		public string Value { get; set; }
+
+		public override string ToString()
+		{
+			StringBuilder stringBuilder = new StringBuilder();
+			stringBuilder.Append('[');
+			if (Key != null)
+			{
+				stringBuilder.Append(Key.ToString());
+			}
+
+			stringBuilder.Append(", ");
+			if (Value != null)
+			{
+				stringBuilder.Append(Value.ToString());
+			}
+
+			stringBuilder.Append(']');
+			return stringBuilder.ToString();
+		}
+	}
+}
diff --git a/Source/MAX.Framework/Configs/ConfigBase.cs b/Source/MAX.Framework/Configs/ConfigBase.cs
new file mode 100644
index 0000000..30fb3b0
--- /dev/null
+++ b/Source/MAX.Framework/Configs/ConfigBase.cs
@@ -0,0 +1,46 @@
+using Newtonsoft.Json;
+using ConfigHelper = MAX.Framework.Helpers.ConfigHelper;
+
+namespace MAX.Framework.Configs
+{
+	public abstract class ConfigBase
+	{
+		[JsonIgnore]
+		public abstract string ConfigName { get; }
+	}
+	/// <summary>
+	/// 设置
+	/// </summary>
+	public abstract class ConfigBase<TConfig> : ConfigBase where TConfig : ConfigBase, new()
+	{
+		private static TConfig mySelf;//= default(T);
+		public static TConfig Instance
+		{
+			get
+			{
+				if (mySelf == null)
+				{
+					mySelf = new TConfig();
+				}
+
+				return mySelf;
+			}
+		}
+
+		public static TConfig LoadConfig()
+		{
+			try
+			{
+				TConfig config = ConfigHelper.LoadConfig<TConfig>();
+				mySelf = config;
+				return mySelf;
+			}
+			catch { }
+			return default;
+		}
+		public void SaveConfig()
+		{
+			ConfigHelper.SaveConfig(ConfigName, this);
+		}
+	}
+}
diff --git a/Source/MAX.Framework/Configs/GlobalConfig.cs b/Source/MAX.Framework/Configs/GlobalConfig.cs
new file mode 100644
index 0000000..294a819
--- /dev/null
+++ b/Source/MAX.Framework/Configs/GlobalConfig.cs
@@ -0,0 +1,28 @@
+using System;
+using System.IO;
+
+namespace MAX.Framework
+{
+	/// <summary>
+	/// 全局配置
+	/// </summary>
+	public class GlobalConfig
+	{
+		/// <summary>
+		/// 数据库名
+		/// </summary>
+		public const string DbName = "db.db";
+
+		/// <summary>
+		/// app启动路径
+		/// </summary>
+		public static string AppDirectory
+		{
+			get
+			{
+				return AppDomain.CurrentDomain.BaseDirectory;
+			}
+		}
+
+	}
+}
diff --git a/Source/MAX.Framework/Helpers/AppConfigHelper.cs b/Source/MAX.Framework/Helpers/AppConfigHelper.cs
new file mode 100644
index 0000000..2b97e09
--- /dev/null
+++ b/Source/MAX.Framework/Helpers/AppConfigHelper.cs
@@ -0,0 +1,156 @@
+using MAX.Framework.Commons;
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Linq;
+using System.Reflection;
+
+namespace MAX.Framework.Helpers
+{
+	/// <summary>
+	/// App 配置
+	/// </summary>
+	public class AppConfigHelper
+	{
+		public static string exeConfigPath = Assembly.GetEntryAssembly()?.Location ?? "";
+
+		public static string GetConnectionString(string name)
+		{
+			Configuration config = ConfigurationManager.OpenExeConfiguration(exeConfigPath);
+			string connection = config.ConnectionStrings.ConnectionStrings[name].ConnectionString ?? "";
+			//string connectionString = ConfigurationManager.ConnectionStrings["MyConnectionString"].ConnectionString;
+			return connection;
+		}
+		///<summary> 
+		///返回*.exe.config文件中appSettings配置节的value项 
+		///</summary> 
+		///<param name="strKey"></param> 
+		///<returns></returns> 
+		public static TValue GetAppConfig<TValue>(string strKey, TValue def = default)
+		{
+			try
+			{
+				string value = GetAppConfig(strKey);
+				return MAX.Core.Helpers.Convert.To<TValue>(value);
+			}
+			catch (Exception ex)
+			{
+				return def;
+			}
+		}
+		///<summary> 
+		///返回*.exe.config文件中appSettings配置节的value项 
+		///</summary> 
+		///<param name="strKey"></param> 
+		///<returns></returns> 
+		public static string GetAppConfig(string strKey)
+		{
+			Configuration config = ConfigurationManager.OpenExeConfiguration(exeConfigPath);
+			foreach (string key in config.AppSettings.Settings.AllKeys)
+			{
+				if (key == strKey)
+				{
+					return config.AppSettings.Settings[strKey].Value.ToString();
+				}
+			}
+			return null;
+		}
+		public static List<KeyValue> GetAppSettings()
+		{
+			Configuration config = ConfigurationManager.OpenExeConfiguration(exeConfigPath);
+			List<KeyValue> settings = new List<KeyValue>();
+			foreach (string key in config.AppSettings.Settings.AllKeys)
+			{
+				settings.Add(new KeyValue(key, config.AppSettings.Settings[key].Value));
+
+			}
+			return settings;
+		}
+
+		///<summary> 
+		///在*.exe.config文件中appSettings配置节增加一对键值对 
+		///</summary> 
+		///<param name="newKey"></param> 
+		///<param name="newValue"></param> 
+		public static void UpdateAppConfig(string newKey, string newValue)
+		{
+			Configuration config = ConfigurationManager.OpenExeConfiguration(exeConfigPath);
+			bool exist = false;
+			foreach (string key in config.AppSettings.Settings.AllKeys)
+			{
+				if (key == newKey)
+				{
+					exist = true;
+				}
+			}
+			if (exist)
+			{
+				config.AppSettings.Settings.Remove(newKey);
+			}
+			config.AppSettings.Settings.Add(newKey, newValue);
+			config.Save(ConfigurationSaveMode.Modified);
+			ConfigurationManager.RefreshSection("appSettings");
+		}
+
+		/// <summary>
+		/// 静态类型写入配置文件信息
+		/// 名称相同
+		/// </summary>
+		/// <param name="appType"></param>
+		public static void SetAppConfig(Type appType)
+		{
+			PropertyInfo[] props = appType.GetProperties(BindingFlags.Static | BindingFlags.Public);
+			List<KeyValue> settings = GetAppSettings();
+			foreach (KeyValue item in settings)
+			{
+				try
+				{
+					PropertyInfo prop = props.FirstOrDefault(a => a.Name.ToLower() == item.Key.ToLower());
+					if (prop != null)
+					{
+						object value = Core.Helpers.Convert.To(prop.PropertyType, item.Value);
+						prop.SetValue(null, value);
+					}
+				}
+				finally
+				{
+
+				}
+
+			}
+		}
+
+		/// <summary>
+		/// 静态配置文件信息写入到配置文件中
+		/// 只写入配置文件中存在的配置项中
+		/// </summary>
+		/// <param name="appType"></param>
+		public static void UpdateAppConfig(Type appType)
+		{
+			PropertyInfo[] props = appType.GetProperties(BindingFlags.Static | BindingFlags.Public);
+			List<KeyValue> settings = GetAppSettings();
+			foreach (KeyValue item in settings)
+			{
+				try
+				{
+					PropertyInfo prop = props.FirstOrDefault(a => a.Name.ToLower() == item.Key.ToLower());
+					if (prop != null)
+					{
+						object value = prop.GetValue(null);
+						if (value?.ToString().ToLower() == item.Value.ToLower())
+						{
+							continue;
+						}
+						UpdateAppConfig(item.Key, value?.ToString());
+					}
+				}
+				finally
+				{
+
+				}
+
+			}
+		}
+
+	}
+}
diff --git a/Source/MAX.Framework/Helpers/ConfigHelper.cs b/Source/MAX.Framework/Helpers/ConfigHelper.cs
new file mode 100644
index 0000000..42825d9
--- /dev/null
+++ b/Source/MAX.Framework/Helpers/ConfigHelper.cs
@@ -0,0 +1,74 @@
+using MAX.Core.DependencyInjection;
+using MAX.Framework.Configs;
+using MAX.Framework.Interfaces;
+using Newtonsoft.Json;
+using System;
+using System.IO;
+using System.Text;
+
+namespace MAX.Framework.Helpers
+{
+	/// <summary>
+	/// 配置
+	/// </summary>
+	public class ConfigHelper
+	{
+		private static IFolderConfig _folderConfig = LazyServiceProvider.Instance.LazyGetService<IFolderConfig>();
+		public static string prvategp = "4Z-zy_VP";//pIuEFX-0-OZm%tP2qtKw
+		public static T LoadConfig<T>() where T : ConfigBase
+		{
+			string filename = Activator.CreateInstance<T>().ConfigName;
+			return LoadConfig<T>(filename);
+		}
+
+		public static T LoadConfig<T>(string fileName) where T : ConfigBase
+		{
+			try
+			{
+				string filePath = GetConfigUserPath(fileName);
+				if (File.Exists(filePath))
+				{
+					string content = File.ReadAllText(filePath, Encoding.UTF8);
+					return JsonConvert.DeserializeObject<T>(content);
+				}
+			}
+			catch { }
+			return default;
+		}
+
+		public static void SaveConfig<T>(T config) where T : ConfigBase
+		{
+			string filename = Activator.CreateInstance<T>().ConfigName;
+			SaveConfig(filename, config);
+		}
+
+		public static void SaveConfig<T>(string fileName, T config) where T : ConfigBase
+		{
+			try
+			{
+				string filePath = GetConfigUserPath(fileName);
+				FileHelper.CreateDirectory(filePath);
+				string content = JsonConvert.SerializeObject(config);
+				File.WriteAllText(filePath, content, Encoding.UTF8);
+			}
+			catch { }
+		}
+
+		public static void SaveConfig(string fileName, string content)
+		{
+			try
+			{
+				string filePath = GetConfigUserPath(fileName);
+				FileHelper.CreateDirectory(filePath);
+				File.WriteAllText(filePath, content, Encoding.UTF8);
+			}
+			catch { }
+		}
+
+		public static string GetConfigUserPath(string fileName)
+		{
+			string filePath = Path.Combine(_folderConfig.LocalAppFolder, "config", fileName);
+			return filePath;
+		}
+	}
+}
diff --git a/Source/MAX.Framework/Helpers/FileHelper.cs b/Source/MAX.Framework/Helpers/FileHelper.cs
new file mode 100644
index 0000000..a554782
--- /dev/null
+++ b/Source/MAX.Framework/Helpers/FileHelper.cs
@@ -0,0 +1,181 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Text;
+
+namespace MAX.Framework.Helpers
+{
+	/// <summary>
+	/// 文件操作帮助类
+	/// </summary>
+	public class FileHelper
+	{
+		/// <summary>
+		/// 获取文件MD5值
+		/// </summary>
+		/// <param name="FilePath"></param>
+		/// <returns></returns>
+		public static string GetFileMd5(string FilePath)
+		{
+			try
+			{
+				FileStream get_file = new FileStream(FilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
+				System.Security.Cryptography.MD5CryptoServiceProvider get_md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
+				byte[] hash_byte = get_md5.ComputeHash(get_file);
+				string resule = BitConverter.ToString(hash_byte);
+				resule = resule.Replace("-", "");
+				get_file.Close();
+				return resule;
+			}
+			catch (Exception e)
+			{
+				return e.ToString();
+			}
+		}
+
+		/// <summary>
+		/// 读取所有内容 相对路径Or绝对路径
+		/// </summary>
+		/// <param name="file"></param>
+		/// <returns></returns>
+		public static string ReadAllText(string file)
+		{
+			if (!Path.IsPathRooted(file))
+			{
+				file = Path.Combine(GlobalConfig.AppDirectory, file);
+			}
+			if (File.Exists(file))
+			{
+				return _ReadAllText(file, Encoding.UTF8);
+			}
+			return string.Empty;
+		}
+		/// <summary>
+		/// 读取所有内容 绝对路径
+		/// </summary>
+		/// <param name="file"></param>
+		/// <returns></returns>
+		public static string ReadAbsAllText(string file)
+		{
+			return _ReadAllText(file, Encoding.UTF8);
+		}
+		/// <summary>
+		/// 读取所有内容 相对路径
+		/// </summary>
+		/// <param name="file"></param>
+		/// <returns></returns>
+		public static string ReadPartialAllText(string file)
+		{
+			string _file = Path.Combine(GlobalConfig.AppDirectory, file);
+			return _ReadAllText(_file, Encoding.UTF8);
+		}
+
+		private static string _ReadAllText(string file, Encoding encoding)
+		{
+			if (File.Exists(file))
+			{
+				return File.ReadAllText(file, encoding);
+			}
+			else
+			{
+				throw new Exception($"缺失文件{file}");
+			}
+		}
+
+		/// <summary>
+		/// 创建目录
+		/// </summary>
+		/// <param name="dir"></param>
+		public static void CreateDirectory(string dir)
+		{
+			if (Path.HasExtension(dir))
+			{
+				dir = Path.GetDirectoryName(dir);
+			}
+			if (!Directory.Exists(dir))
+			{
+				Directory.CreateDirectory(dir);
+			}
+		}
+
+		public static bool DeleteDirectory(string path)
+		{
+			try
+			{
+				Directory.Delete(path, true);
+				return true;
+			}
+			catch (Exception ex)
+			{
+				Debug.WriteLine(ex);
+				return false;
+			}
+		}
+
+		public static void CopyDirectory(string sourceDir, string destinationDir, bool recursive = true)
+		{
+			// Get information about the source directory
+			DirectoryInfo dir = new DirectoryInfo(sourceDir);
+
+			// Check if the source directory exists
+			if (!dir.Exists)
+			{
+				throw new DirectoryNotFoundException($"Source directory not found: {dir.FullName}");
+			}
+
+			// Cache directories before we start copying
+			DirectoryInfo[] dirs = dir.GetDirectories();
+
+			// Create the destination directory
+			Directory.CreateDirectory(destinationDir);
+
+			// Get the files in the source directory and copy to the destination directory
+			foreach (FileInfo file in dir.GetFiles())
+			{
+				string targetFilePath = Path.Combine(destinationDir, file.Name);
+				file.CopyTo(targetFilePath);
+			}
+
+			// If recursive and copying subdirectories, recursively call this method
+			if (recursive)
+			{
+				foreach (DirectoryInfo subDir in dirs)
+				{
+					string newDestinationDir = Path.Combine(destinationDir, subDir.Name);
+					CopyDirectory(subDir.FullName, newDestinationDir, true);
+				}
+			}
+		}
+
+
+		/// <summary>
+		/// 获取文件夹大小
+		/// </summary>
+		/// <param name="path"></param>
+		/// <returns></returns>
+		public static long GetDirectorySize(string path)
+		{
+			long result = 0;
+			try
+			{
+				if (Directory.Exists(path))
+				{
+					dynamic fso = Activator.CreateInstance(Type.GetTypeFromProgID("Scripting.FileSystemObject"));
+					dynamic fldr = fso.GetFolder(path);
+					result = (long)fldr.size;
+				}
+				else
+				{
+					result = 0;
+				}
+			}
+			catch (Exception ex)
+			{
+				result = 0;
+			}
+
+			return result;
+		}
+
+	}
+}
diff --git a/Source/MAX.Framework/Helpers/ImageBuild.cs b/Source/MAX.Framework/Helpers/ImageBuild.cs
new file mode 100644
index 0000000..d43803a
--- /dev/null
+++ b/Source/MAX.Framework/Helpers/ImageBuild.cs
@@ -0,0 +1,1071 @@
+//using MAX.Core.Helpers;
+//using System;
+//using System.Collections.Generic;
+//using System.Drawing;
+//using System.Drawing.Drawing2D;
+//using System.Drawing.Imaging;
+//using System.IO;
+
+//namespace MAX.Framework.Helpers
+//{
+//	public class ImageBuild
+//	{
+//		public byte[] Img;
+//		public int Width = 0, Height = 0;
+//		public Image InitImage = null;
+//		public string format = "";
+//		public int PicQuality = 0;//图片质量
+//		public bool CanUser
+//		{
+//			get { return format == ".jpg" || format == ".png"; }
+//		}
+
+//		public ImageBuild(byte[] image)
+//		{
+//			if (image == null || image.Length == 0)
+//			{
+//				return;
+//			}
+
+//			Img = image;
+//			try
+//			{
+//				if (image.Length > 3145728)
+//				{
+//					return;
+//				}
+//				MemoryStream ms = new MemoryStream(Img);
+//				InitImage = Image.FromStream(ms);
+//				ImageFormat f = GetImageFormat(InitImage, out format);
+//				ms.Close();
+//				ms.Dispose();
+//			}
+//			catch (Exception e)
+//			{
+//				throw;
+//			}
+//			if (InitImage == null)
+//			{
+//				return;
+//			}
+
+//			Width = InitImage.Width;
+//			Height = InitImage.Height;
+//		}
+//		/// <summary>
+//		/// 裁剪为指定大小，不符合则返回null
+//		/// </summary>
+//		/// <param name="width"></param>
+//		/// <param name="height"></param>
+//		/// <returns></returns>
+//		public byte[] CutToSize(int width, int height)
+//		{
+//			if (InitImage == null)
+//			{
+//				return null;
+//			}
+
+//			int w = InitImage.Width;
+//			int h = InitImage.Height;
+//			if (w < width || h < height)
+//			{
+//				return null;
+//			}
+//			int x = 0, y = 0, nw = w, nh = h;
+//			int tx = 0, ty = 0, tw = width, th = height;
+//			double f = w * 1.0 / width;
+//			double t = h * 1.0 / height;
+//			if (f == t)//无需变化
+//			{
+//			}
+//			else if (f > t)//宽度较大
+//			{
+//				x = (int)((f - t) / 2 * width);
+//				nw = w - (x * 2);
+//			}
+//			else//高度较大
+//			{
+//				y = (int)((t - f) / 2 * height);
+//				nh = h - (y * 2);
+//			}
+//			Rectangle fromR = new Rectangle(x, y, nw, nh);
+//			Rectangle toR = new Rectangle(tx, ty, tw, th);
+//			Bitmap pickedImage = new Bitmap(width, height);
+
+//			Graphics pickedG = Graphics.FromImage(pickedImage);
+//			pickedG.InterpolationMode = InterpolationMode.Low;
+//			pickedG.SmoothingMode = SmoothingMode.HighSpeed;
+//			pickedG.DrawImage(InitImage, toR, fromR, GraphicsUnit.Pixel);
+//			//转图片后转二进制数组
+//			Image initImagex = (Image)pickedImage.Clone();
+//			MemoryStream ms = new MemoryStream();
+//			ImageCodecInfo icc = GetCodeInfo("1.jpg");
+//			long quality = 80;
+//			EncoderParameters ep = new EncoderParameters(1);
+//			ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
+//			initImagex.Save(ms, icc, ep);
+//			byte[] bytes = ms.ToArray();
+//			return bytes;
+//		}
+//		/// <summary>
+//		/// 添加线条
+//		/// </summary>
+//		/// <param name="img"></param>
+//		public void AddLineToImage(ref byte[] img)
+//		{
+//			MemoryStream ms = new MemoryStream(img);
+//			Bitmap image = (Bitmap)Image.FromStream(ms);
+//			ms.Close();
+//			int width = image.Width;
+//			int height = image.Height;
+//			if (width < 100 || height < 100)
+//			{
+//				return;
+//			}
+
+//			int r = RandomHelper.GetRandomNumber(100, 256);
+//			int b = RandomHelper.GetRandomNumber(100, 256);
+//			int g = RandomHelper.GetRandomNumber(100, 256);
+//			int h = RandomHelper.GetRandomNumber(1, 10);
+//			Color c = Color.FromArgb(r, g, b);
+//			for (int i = 0; i < h; i++)
+//			{
+//				for (int j = 0; j < height; j++)
+//				{
+//					image.SetPixel(i, j, c);
+//				}
+
+//				for (int j = 0; j < width; j++)
+//				{
+//					image.SetPixel(j, i, c);
+//				}
+//			}
+//			for (int i = height - h; i < height; i++)
+//			{
+//				for (int j = 0; j < width; j++)
+//				{
+//					image.SetPixel(j, i, c);
+//				}
+//			}
+//			for (int i = width - h; i < width; i++)
+//			{
+//				for (int j = 0; j < height; j++)
+//				{
+//					image.SetPixel(i, j, c);
+//				}
+//			}
+//			ImageCodecInfo icc = GetCodeInfo("1.jpg");
+//			long quality = 75;
+//			ms = new MemoryStream();
+//			EncoderParameters ep = new EncoderParameters(1);
+//			ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
+//			image.Save(ms, icc, ep);
+//			img = ms.ToArray();
+//			//FileBase.WriteBytes("1.jpg", bytes);
+//		}
+
+
+//		/// <summary>
+//		/// 在图片四周区域随机选取8*8像素，微调像素值
+//		/// </summary>
+//		/// <param name="img"></param>
+//		public void FineTuningImageToRandomArea(ref byte[] img)
+//		{
+//			try
+//			{
+//				MemoryStream ms = new MemoryStream(img);
+//				Bitmap image = (Bitmap)Image.FromStream(ms);
+//				int iW = image.Width;
+//				int iH = image.Height;
+//				if (iW <= 32 || iH <= 32)
+//				{
+//					return;
+//				}
+
+//				int x = 0;
+//				int y = 0;
+//				Random rand = new Random();
+//				int r = rand.Next(1, 4);
+//				switch (r)
+//				{
+//					case 1:
+//						x = rand.Next(0, (iW / 4) - 8);
+//						y = rand.Next(0, iH - 8);
+//						break;
+//					case 2:
+//						x = rand.Next((iW / 4) - 8, iW - 8);
+//						y = rand.Next(0, (iH / 4) - 8);
+//						break;
+//					case 3:
+//						x = rand.Next((iW / 4) - 8, iW - 8);
+//						y = rand.Next(3 * iH / 4, iH - 8);
+//						break;
+//					case 4:
+//						x = rand.Next(3 * iW / 4, iW - 8);
+//						y = rand.Next((iH / 4) - 8, 3 * iH / 4);
+//						break;
+//				}
+//				List<List<PixPoint>> lstlstPixes = new List<List<PixPoint>>();
+//				int tmpx = x;
+//				int tmpy = y;
+//				for (int jj = 0; jj < 4; jj++)
+//				{
+//					List<PixPoint> lstPixes = new List<PixPoint>
+//					{
+//						new PixPoint { X = tmpx, Y = tmpy }
+//					};
+//					for (int i = 1; i < 8 - (jj * 2); i++)
+//					{
+//						PixPoint ppx = new PixPoint { X = x, Y = ++tmpy };
+//						lstPixes.Add(ppx);
+//						PixPoint ppy = new PixPoint { X = ++tmpx, Y = y };
+//						lstPixes.Add(ppy);
+//					}
+//					lstlstPixes.Add(lstPixes);
+//					if (jj == 3)
+//					{
+//						break;
+//					}
+
+//					tmpx = ++x;
+//					tmpy = ++y;
+//				}
+
+//				for (int jj = 3; jj >= 0; jj--)
+//				{
+
+//					List<PixPoint> lstPixes = new List<PixPoint>();
+//					tmpx = ++x;
+//					tmpy = ++y;
+//					lstPixes.Add(new PixPoint { X = tmpx, Y = tmpy });
+//					for (int i = 1; i < 7 - (jj * 2); i++)
+//					{
+//						PixPoint ppx = new PixPoint { X = x, Y = --tmpy };
+//						lstPixes.Add(ppx);
+//						PixPoint ppy = new PixPoint { X = --tmpx, Y = y };
+//						lstPixes.Add(ppy);
+//					}
+//					lstlstPixes[jj].AddRange(lstPixes);
+//				}
+
+//				int inc = 0;
+//				foreach (List<PixPoint> lstpix in lstlstPixes)
+//				{
+//					inc++;
+//					foreach (PixPoint pix in lstpix)
+//					{
+//						Color color = image.GetPixel(pix.X, pix.Y);
+//						int newR, newG, newB;
+//						newR = color.R + inc > 255 ? 255 : color.R + inc;
+//						newG = color.G + inc > 255 ? 255 : color.G + inc;
+//						newB = color.B + inc > 255 ? 255 : color.B + inc;
+//						Color c = Color.FromArgb(newR, newG, newB);
+//						image.SetPixel(pix.X, pix.Y, c);
+//					}
+//				}
+//				ImageCodecInfo icc = GetCodeInfo("1.jpg");
+//				//long quality = 75;
+//				long quality = PicQuality;//之前固定值  现在改为设置的数值 
+//				ms = new MemoryStream();
+//				EncoderParameters ep = new EncoderParameters(1);
+//				ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
+//				image.Save(ms, icc, ep);
+//				img = ms.ToArray();
+//				//TODO:Need Test
+//				//image.Dispose();
+//				ms.Close();
+//			}
+//			catch (Exception ex)
+//			{
+//				throw;
+//			}
+//		}
+
+//		/// <summary>
+//		/// 输出固定大小图片，背景白色填充，返回JPG格式二进制代码
+//		/// </summary>
+//		/// <param name="width"></param>
+//		/// <param name="height"></param>
+//		/// <param name="maxSize">最大尺寸KB</param>
+//		/// <returns></returns>
+//		public byte[] BuildNewSize(int width, int height, int maxSize, string codePath = "1.jpg")
+//		{
+//			if (InitImage == null)
+//			{
+//				return null;
+//			}
+
+//			int w = InitImage.Width;
+//			int h = InitImage.Height;
+//			int x = 0, y = 0, nw = w, nh = h;
+//			int tx = 0, ty = 0, tw = width, th = height;
+//			//先缩放
+//			if (w <= width && h <= height)//无需缩放
+//			{
+//				tx = (width - w) / 2;
+//				tw = w;
+//				ty = (height - h) / 2;
+//				th = h;
+//			}
+//			else if (w < width && h > height)
+//			{
+//				tx = (width - w) / 2;
+//				tw = w;
+//				y = (h - height) / 2;
+//				nh = height;
+//			}
+//			else if (w > width && h < height)
+//			{
+//				ty = (height - h) / 2;
+//				th = h;
+//				x = (w - width) / 2;
+//				nw = width;
+//			}
+//			else
+//			{
+//				double f = w * 1.0 / width;
+//				double t = h * 1.0 / height;
+//				if (f == t)//无需变化
+//				{
+//				}
+//				else if (f > t)//宽度较大
+//				{
+//					x = (int)((f - t) / 2 * width);
+//					nw = w - (x * 2);
+//				}
+//				else//高度较大
+//				{
+//					y = (int)((t - f) / 2 * height);
+//					nh = h - (y * 2);
+//				}
+//			}
+//			Rectangle fromR = new Rectangle(x, y, nw, nh);
+//			Rectangle toR = new Rectangle(tx, ty, tw, th);
+//			Bitmap pickedImage = new Bitmap(width, height);
+//			for (int i = 0; i < pickedImage.Width; i++)
+//			{
+//				for (int j = 0; j < pickedImage.Height; j++)
+//				{
+//					Color color = Color.FromArgb(255, 255, 255);
+//					pickedImage.SetPixel(i, j, color);
+//				}
+//			}
+//			Graphics pickedG = Graphics.FromImage(pickedImage);
+//			pickedG.InterpolationMode = InterpolationMode.Low;
+//			pickedG.SmoothingMode = SmoothingMode.HighSpeed;
+//			pickedG.DrawImage(InitImage, toR, fromR, GraphicsUnit.Pixel);
+//			//转图片后转二进制数组
+//			Image initImagex = (Image)pickedImage.Clone();
+//			MemoryStream ms = new MemoryStream();
+//			ImageCodecInfo icc = GetCodeInfo(codePath);
+
+//			//long quality = maxSize == 1024 ? 75l : 85;
+//			long quality = PicQuality;//之前固定值  现在改为设置的数值 
+//			EncoderParameters ep = new EncoderParameters(1);
+//			ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
+//			initImagex.Save(ms, icc, ep);
+//			byte[] bytes = ms.ToArray();
+//			if (bytes.Length > maxSize * 1024)
+//			{
+//				ms = new MemoryStream();
+//				ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 75L);
+//				initImagex.Save(ms, icc, ep);
+//				bytes = ms.ToArray();
+//			}
+//			if (bytes.Length > maxSize * 1024)
+//			{
+//				ms = new MemoryStream();
+//				ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 55L);
+//				initImagex.Save(ms, icc, ep);
+//				bytes = ms.ToArray();
+//			}
+//			//TODO:Need Test
+//			//pickedImage.Dispose();
+//			//pickedG.Dispose();
+//			//initImagex.Dispose();
+//			//ms.Close();
+//			if (bytes.Length > maxSize * 1024)
+//			{
+//				return null;
+//			}
+//			//ImageCodecInfo icc = GetCodeInfo("1.jpg");
+//			//initImagex.Save("22.jpg", icc, ep);
+//			return bytes;
+//		}
+//		/// <summary>
+//		/// 根据路劲得出图片编码信息
+//		/// </summary>
+//		/// <param name="path"></param>
+//		/// <returns></returns>
+//		public ImageCodecInfo GetCodeInfo(string path)
+//		{
+//			string exe = path.Split('.')[path.Split('.').Length - 1].ToLower();
+//			ImageCodecInfo[] icis = ImageCodecInfo.GetImageEncoders();
+//			ImageCodecInfo ici = null, defCodecInfo = null;
+//			foreach (ImageCodecInfo i in icis)
+//			{
+//				if (i.MimeType == "image/jpeg")
+//				{
+//					defCodecInfo = i;
+//				}
+
+//				if ((exe == "jpg" || exe == "jpeg") && i.MimeType == "image/jpeg")
+//				{
+//					ici = i;
+//				}
+//				if (exe == "bmp" && i.MimeType == "image/bmp")
+//				{
+//					ici = i;
+//				}
+//				if (exe == "png" && i.MimeType == "image/png")
+//				{
+//					ici = i;
+//				}
+//				if (exe == "gif" && i.MimeType == "image/gif")
+//				{
+//					ici = i;
+//				}
+//			}
+//			if (ici == null)
+//			{
+//				ici = defCodecInfo;
+//			}
+
+//			return ici;
+//		}
+
+//		/// <summary>
+//		/// 获取Image图片格式
+//		/// </summary>
+//		/// <param name="_img"></param>
+//		/// <param name="format"></param>
+//		/// <returns></returns>
+//		private ImageFormat GetImageFormat(Image _img, out string format)
+//		{
+//			if (_img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Jpeg))
+//			{
+//				format = ".jpg";
+//				return System.Drawing.Imaging.ImageFormat.Jpeg;
+//			}
+//			if (_img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Gif))
+//			{
+//				format = ".gif";
+//				return System.Drawing.Imaging.ImageFormat.Gif;
+//			}
+//			if (_img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Png))
+//			{
+//				format = ".png";
+//				return System.Drawing.Imaging.ImageFormat.Png;
+//			}
+//			if (_img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Bmp))
+//			{
+//				format = ".bmp";
+//				return System.Drawing.Imaging.ImageFormat.Bmp;
+//			}
+//			format = string.Empty;
+//			return null;
+//		}
+
+
+//		#region 随机裁四边--10个像素以内
+//		public void CutPicture(ref byte[] file)
+//		{
+//			MemoryStream ms = new MemoryStream(file);
+//			Bitmap image = (Bitmap)Image.FromStream(ms);
+
+//			Random radom = new Random();
+//			int cutPixl = radom.Next(1, 5); //左边切除的像素
+//			int cutPixr = radom.Next(1, 5); //右边切除的像素
+//			int cutPixt = radom.Next(1, 5); //顶部切除的像素
+//			int cutPixb = radom.Next(1, 5); //底部切除的像素
+
+//			Image img = BytesToImage(file);
+//			int iniWidth = img.Width;
+//			int iniHeight = img.Height;
+
+//			try
+//			{
+//				Bitmap bitmap = StartCutImage(file, cutPixl, cutPixr, iniWidth - cutPixl - cutPixt, iniHeight - cutPixr - cutPixb, iniWidth, iniHeight);
+
+//				image = bitmap;
+
+//				ImageCodecInfo icc = GetCodeInfo("1.jpg");
+//				//long quality = 75;
+//				long quality = PicQuality;//之前固定值  现在改为设置的数值 
+//				ms = new MemoryStream();
+//				EncoderParameters ep = new EncoderParameters(1);
+//				ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
+//				image.Save(ms, icc, ep);
+//				//    image.Save(ms,ImageFormat.Jpeg);
+//				file = ms.ToArray();
+//				//TODO:Need Test
+//				//img.Dispose();
+//				//bitmap.Dispose();
+//				//image.Dispose();
+//				ms.Close();
+//			}
+//			catch (Exception)
+//			{
+
+//			}
+
+//		}
+
+//		/// <summary>
+//		/// 剪裁
+//		/// </summary>
+//		/// <param name="b">原始Bitmap</param>
+//		/// <param name="StartX">开始坐标X</param>
+//		/// <param name="StartY">开始坐标Y</param>
+//		/// <param name="iWidth">宽度</param>
+//		/// <param name="iHeight">高度</param>
+//		/// <returns>剪裁后的Bitmap</returns>
+//		public static Bitmap StartCutImage(byte[] bytes, int StartX, int StartY, int iWidth, int iHeight, int iniWidth, int iniHeight)
+//		{
+//			Image image = BytesToImage(bytes);
+//			Bitmap b = new Bitmap(image);
+//			if (bytes == null)
+//			{
+//				return null;
+//			}
+
+//			try
+//			{
+//				Bitmap bmpOut = new Bitmap(iWidth, iHeight, PixelFormat.Format24bppRgb);//裁剪成小一号的图片
+//																						//Bitmap bmpOut = new Bitmap(w, h, PixelFormat.Format24bppRgb);//保持原大小，裁剪部分用指定的颜色填充
+//				Graphics graphics = Graphics.FromImage(bmpOut);
+//				//graphics.Clear(Color.White);//裁剪部分用指定的颜色填充
+//				graphics.DrawImage(b, new Rectangle(0, 0, iWidth, iHeight), new Rectangle(StartX, StartY, iWidth, iHeight), GraphicsUnit.Pixel);
+//				graphics.Dispose();
+//				bmpOut = new Bitmap(bmpOut, iniWidth, iniHeight);//图片保存原始的大小尺寸 
+//				return bmpOut;
+//			}
+//			catch
+//			{
+//				return null;
+//			}
+
+//		}
+
+//		/// <summary>
+//		/// 字节数组转换为图片
+//		/// </summary>
+//		/// <param name="buffer">字节数组</param>
+//		/// <returns>图片</returns>
+//		public static Image BytesToImage(byte[] buffer)
+//		{
+//			MemoryStream ms = new MemoryStream(buffer, 0, buffer.Length);
+//			Image img = Image.FromStream(ms);
+//			ms.Dispose();
+//			return img;
+//		}
+
+//		/// <summary>
+//		/// 图片对象转字节数组
+//		/// </summary>
+//		/// <param name="imagePath">图片路径</param>
+//		/// <returns>图片字节数组</returns>
+//		private byte[] ImageToBytes(string imagePath)
+//		{
+//			FileStream fs = new FileStream(imagePath, FileMode.Open);
+//			byte[] imgBytes = new byte[fs.Length];
+//			fs.Read(imgBytes, 0, imgBytes.Length);
+//			fs.Close();
+//			return imgBytes;
+//			//var bf = new BinaryFormatter();
+//			//bf.Serialize(ms,imagePath);
+//			//ms.Close();
+//			//return ms.ToArray();
+
+//		}
+
+//		#endregion
+
+//		#region 添加文字水印
+//		public void AddWaterMark(ref byte[] file, string shopName = "")
+//		{
+//			MemoryStream ms = new MemoryStream(file);
+//			Bitmap image = (Bitmap)Image.FromStream(ms);
+
+//			try
+//			{
+//				Bitmap bitmap = StartAddWaterMark(file, shopName);
+//				image = bitmap;
+
+//				ImageCodecInfo icc = GetCodeInfo("1.jpg");
+//				//long quality = 75;
+//				long quality = PicQuality;//之前固定值  现在改为设置的数值 
+//				ms = new MemoryStream();
+//				EncoderParameters ep = new EncoderParameters(1);
+//				ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
+//				image.Save(ms, icc, ep);
+//				file = ms.ToArray();
+//				//image.Dispose();
+//				//bitmap.Dispose();
+//				ms.Close();
+//			}
+//			catch (Exception)
+//			{
+//				throw;
+//			}
+
+//		}
+
+//		/// <summary>
+//		/// 检测是否是白底图
+//		/// </summary>
+//		/// <param name="bytesImg">图片byte数组</param>
+//		/// <returns>true-白底图  false-非白底图</returns>
+//		public static bool CheckImageIsWhiteBackground(byte[] bytesImg)
+//		{
+//			MemoryStream ms = new MemoryStream(bytesImg);
+//			Bitmap image = (Bitmap)Image.FromStream(ms);
+//			int iWhitePixNum = 0;
+//			int iTotalPix = 0;
+//			try
+//			{
+//				int iWidth = image.Width;
+//				int iHeight = image.Height;
+//				int iInpectWidth = 20;
+//				//统计三窄边白色像素数量
+//				for (int i = 0; i < iInpectWidth; i++)
+//				{
+//					for (int j = 0; j < iHeight; j++)
+//					{
+//						Color cl = image.GetPixel(i, j);
+//						iTotalPix++;
+//						if (cl.Name.Equals("ffffffff"))
+//						{
+//							iWhitePixNum++;
+//						}
+//					}
+//				}
+//				for (int i = iWidth - iInpectWidth; i < iWidth; i++)
+//				{
+//					for (int j = iInpectWidth; j < iHeight; j++)
+//					{
+//						Color cl = image.GetPixel(i, j);
+//						iTotalPix++;
+//						if (cl.Name.Equals("ffffffff"))
+//						{
+//							iWhitePixNum++;
+//						}
+//					}
+//				}
+//				for (int i = iInpectWidth; i < iWidth; i++)
+//				{
+//					for (int j = 0; j < iInpectWidth; j++)
+//					{
+//						Color cl = image.GetPixel(i, j);
+//						iTotalPix++;
+//						if (cl.Name.Equals("ffffffff"))
+//						{
+//							iWhitePixNum++;
+//						}
+//					}
+//				}
+//			}
+//			catch (Exception ex)
+//			{
+//				throw;
+//			}
+//			finally
+//			{
+//				ms.Close();
+//				image.Dispose();
+//			}
+//			//如果三窄边的白色像素数量占比高于85%，则判定为白底图
+//			return Decimal.Divide(iWhitePixNum, iTotalPix) > (decimal)0.85;
+//		}
+
+//		/// <summary>
+//		/// 添加图片水印
+//		/// </summary>
+//		/// <param name="image"></param>
+//		/// <param name="text"></param>
+//		/// <param name="rectX">水印开始X坐标（自动扣除图片宽度）</param>
+//		/// <param name="rectY">水印开始Y坐标（自动扣除图片高度</param>
+//		/// <param name="opacity">透明度 0-1</param>
+//		/// <param name="externName">文件后缀名</param>
+//		/// <returns></returns>
+//		public void AddLogoWaterMark(ref byte[] file, Image watermark, float opacity, string externName, bool bFill = true)
+//		{
+//			MemoryStream ms = new MemoryStream(file);
+//			Bitmap image = (Bitmap)Image.FromStream(ms);
+//			Bitmap bitmap = new Bitmap(image, image.Width, image.Height); //改为固定
+
+//			Graphics g = Graphics.FromImage(bitmap);
+
+//			//下面定义一个矩形区域      
+//			float rectWidth = watermark.Width + 10;
+//			float rectHeight = watermark.Height + 10;
+//			//声明矩形域
+
+//			RectangleF textArea;
+//			if (bFill)
+//			{
+//				textArea = new RectangleF(0, 0, image.Width, image.Height);
+//			}
+//			else
+//			{
+//				int height = watermark.Height;
+//				int width = watermark.Width;
+//				height = 80;
+//				width = 80;
+//				textArea = new RectangleF(0, 0, width, height);
+//			}
+//			Bitmap w_bitmap = ChangeOpacity(watermark, opacity);
+
+//			g.DrawImage(w_bitmap, 0, 0, 80, 80);
+//			ms = new MemoryStream();
+//			//保存图片
+//			switch (externName)
+//			{
+//				case ".jpg":
+//					bitmap.Save(ms, ImageFormat.Jpeg);
+//					break;
+//				case ".gif":
+//					bitmap.Save(ms, ImageFormat.Gif);
+//					break;
+//				case ".png":
+//					bitmap.Save(ms, ImageFormat.Png);
+//					break;
+//				default:
+//					bitmap.Save(ms, ImageFormat.Jpeg);
+//					break;
+//			}
+
+//			file = ms.ToArray();
+//			ms.Close();
+//			g.Dispose();
+//			bitmap.Dispose();
+//		}
+
+//		/// <summary>
+//		/// 改变图片的透明度
+//		/// </summary>
+//		/// <param name="img">图片</param>
+//		/// <param name="opacityvalue">透明度</param>
+//		/// <returns></returns>
+//		public Bitmap ChangeOpacity(Image img, float opacityvalue)
+//		{
+
+//			float[][] nArray ={ new float[] {1, 0, 0, 0, 0},
+//								new float[] {0, 1, 0, 0, 0},
+//								new float[] {0, 0, 1, 0, 0},
+//								new float[] {0, 0, 0, opacityvalue, 0},
+//								new float[] {0, 0, 0, 0, 1}};
+//			ColorMatrix matrix = new ColorMatrix(nArray);
+//			ImageAttributes attributes = new ImageAttributes();
+//			attributes.SetColorMatrix(matrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
+//			Image srcImage = img;
+//			Bitmap resultImage = new Bitmap(srcImage.Width, srcImage.Height);
+//			Graphics g = Graphics.FromImage(resultImage);
+//			g.DrawImage(srcImage, new Rectangle(0, 0, srcImage.Width, srcImage.Height), 0, 0, srcImage.Width, srcImage.Height, GraphicsUnit.Pixel, attributes);
+//			//g.DrawImage(srcImage, 0, 0, srcImage.Width, srcImage.Height) ;
+//			//g.DrawImage(srcImage, 0, 0, 80,80);
+//			g.Dispose();
+//			attributes.Dispose();
+//			return resultImage;
+//		}
+
+//		//private static Font crFont = new Font("微软雅黑", 30, FontStyle.Bold);
+//		/// <summary>
+//		/// 
+//		/// </summary>
+//		/// <param name="bytes"></param>
+//		/// <param name="text">水印文字</param>
+//		/// <returns></returns>
+//		public static Bitmap StartAddWaterMark(byte[] bytes, string text = "")
+//		{
+//			if (bytes == null)
+//			{
+//				return null;
+//			}
+
+//			Image image = BytesToImage(bytes);
+//			Bitmap bitmap = new Bitmap(image);
+//			try
+//			{
+
+//				int width = bitmap.Width, height = bitmap.Height;
+
+//				Graphics g = Graphics.FromImage(bitmap);
+
+//				g.DrawImage(bitmap, 0, 0);
+
+//				g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;
+
+//				g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+
+//				g.DrawImage(image, new Rectangle(0, 0, width, height), 0, 0, width, height, GraphicsUnit.Pixel);
+
+//				Font crFont = new Font("微软雅黑", 30, FontStyle.Bold);
+//				SizeF crSize = new SizeF();
+//				crSize = g.MeasureString(text, crFont);
+
+//				//背景位置(去掉了. 如果想用可以自己调一调 位置.)
+//				//g.FillRectangle(new SolidBrush(Color.FromArgb(200, 255, 255, 255)), (width - crSize.Width) / 2, (height - crSize.Height) / 2, crSize.Width, crSize.Height);
+
+//				SolidBrush semiTransBrush = new SolidBrush(Color.FromArgb(120, 177, 171, 171));//177, 171, 171
+
+
+//				//文字水印随机加在一遍
+//				Random rdom = new Random();
+//				int rdLocation = rdom.Next(1, 5);//1:左边 2:右边 3：上边 4：下边
+
+//				if (rdLocation == 1)
+//				{
+//					#region 左边
+//					//将原点移动 到图片中点
+//					g.TranslateTransform(0, (height / 2) + crSize.Height);
+//					//以原点为中心 转 -45度
+//					g.RotateTransform(-90);
+
+//					g.DrawString(text, crFont, semiTransBrush, new PointF(0, 0));//文字所加的位置
+//					#endregion
+//				}
+//				else if (rdLocation == 2)
+//				{
+//					#region 右边
+//					//将原点移动 到图片中点
+//					g.TranslateTransform(width - (crSize.Width / 2), (height / 2) + crSize.Height);
+//					//以原点为中心 转 -45度
+//					g.RotateTransform(-90);
+
+//					g.DrawString(text, crFont, semiTransBrush, new PointF(0, 0));//文字所加的位置
+//					#endregion
+//				}
+//				else if (rdLocation == 3)
+//				{
+//					#region 上边
+//					////将原点移动 到图片中点
+//					//g.TranslateTransform(width / 2 - crSize.Width, 0);
+//					////以原点为中心 转 -45度
+//					//g.RotateTransform(-0);
+
+//					g.DrawString(text, crFont, semiTransBrush, new PointF((width / 2) - (crSize.Width / 2), 0));//文字所加的位置
+//					#endregion
+//				}
+//				else if (rdLocation == 4)
+//				{
+//					#region 下边
+//					////将原点移动 到图片中点
+//					//g.TranslateTransform(width / 2 - crSize.Width, height - crSize.Height * 3);
+//					////以原点为中心 转 -0度
+//					////g.RotateTransform(-0);
+
+//					g.DrawString(text, crFont, semiTransBrush, new PointF((width / 2) - (crSize.Width / 2), height - crSize.Height));//文字所加的位置
+//					#endregion
+//				}
+//				else
+//				{
+//					#region 上边
+//					g.DrawString(text, crFont, semiTransBrush, new PointF((width / 2) - (crSize.Width / 2), 0));//文字所加的位置
+//					#endregion
+//				}
+//				//crFont.Dispose();
+//				g.Dispose();
+//				//image.Dispose();
+//				//semiTransBrush.Dispose();
+//				////将原点移动 到图片中点
+//				//g.TranslateTransform(width / 2, height / 2);
+//				////以原点为中心 转 -45度
+//				//g.RotateTransform(-45);
+
+//				//g.DrawString(text, crFont, semiTransBrush, new PointF(width / 2 - crSize.Width / 2, 0));//文字所加的位置
+
+
+//			}
+//			catch (Exception e)
+//			{
+//				throw;
+//			}
+
+//			return bitmap;
+//		}
+//		#endregion
+
+//		/// <summary>
+//		/// 获取两张图片的相似度
+//		/// </summary>
+//		/// <param name="image1">图片1</param>
+//		/// <param name="image2">图片2</param>
+//		/// <returns></returns>
+//		public static string GetSimilarityForTwoImgs(Image image1, Image image2)
+//		{
+//			string sImg1Hash = GetHash(image1);
+//			string sImg2Hash = GetHash(image2);
+//			return (Math.Round(((64.0 * 64.0) - CalcSimularDegree(sImg1Hash, sImg2Hash)) / (64.0 * 64.0), 4) * 100) + "%";
+//		}
+
+//		private static int CalcSimularDegree(string a, string b)
+//		{
+//			if (a.Length != b.Length)
+//			{
+//				throw new ArgumentException();
+//			}
+
+//			int count = 0;
+//			for (int i = 0; i < a.Length; i++)
+//			{
+//				if (a[i] != b[i])
+//				{
+//					count++;
+//				}
+//			}
+//			return count;
+//		}
+
+//		private static string GetHash(Image sourceImage)
+//		{
+//			Image image = ReduceSize(sourceImage);
+//			byte[] grayValues = ReduceColor(image);
+//			byte average = CalcAverage(grayValues);
+//			string sRes = ComputeBits(grayValues, average);
+//			image.Dispose();
+//			image = null;
+//			return sRes;
+//		}
+
+//		private static string ComputeBits(byte[] grayValues, byte average)
+//		{
+//			char[] result = new char[grayValues.Length];
+//			for (int i = 0; i < grayValues.Length; i++)
+//			{
+//				if (grayValues[i] < average)
+//				{
+//					result[i] = '0';
+//				}
+//				else
+//				{
+//					result[i] = '1';
+//				}
+//			}
+//			return new string(result);
+//		}
+
+//		private static byte CalcAverage(byte[] grayValues)
+//		{
+//			int sum = 0;
+//			for (int i = 0; i < grayValues.Length; i++)
+//			{
+//				sum += grayValues[i];
+//			}
+//			return System.Convert.ToByte(sum / grayValues.Length);
+//		}
+
+//		private static byte[] ReduceColor(Image image)
+//		{
+//			Bitmap bitmap = new Bitmap(image);
+//			byte[] grayValues = new byte[image.Width * image.Height];
+
+//			for (int i = 0; i < image.Width; i++)
+//			{
+//				for (int j = 0; j < image.Height; j++)
+//				{
+//					Color color = bitmap.GetPixel(i, j);
+//					byte grayValue = (byte)(((color.R * 30) + (color.G * 59) + (color.B * 11)) / 100);
+//					grayValues[(i * image.Width) + j] = grayValue;
+//				}
+//			}
+//			bitmap.Dispose();
+//			return grayValues;
+//		}
+
+//		private static Image ReduceSize(Image image)
+//		{
+//			Image image1 = image.GetThumbnailImage(64, 64, () =>
+//			{
+//				return false;
+//			}, IntPtr.Zero);
+//			return image1;
+//		}
+
+//		//byte[] 转换 Bitmap
+//		public static Bitmap BytesToBitmap(byte[] Bytes)
+//		{
+//			MemoryStream stream = null;
+//			try
+//			{
+//				stream = new MemoryStream(Bytes);
+//				return new Bitmap(new Bitmap(stream));
+//			}
+//			catch (ArgumentNullException ex)
+//			{
+//				throw ex;
+//			}
+//			catch (ArgumentException ex)
+//			{
+//				throw ex;
+//			}
+//			finally
+//			{
+//				stream.Close();
+//			}
+//		}
+//		//Bitmap转byte[]  
+//		public static byte[] BitmapToBytes(Bitmap Bitmap)
+//		{
+//			MemoryStream ms = null;
+//			try
+//			{
+//				ms = new MemoryStream();
+//				Bitmap.Save(ms, Bitmap.RawFormat);
+//				byte[] byteImage = new Byte[ms.Length];
+//				byteImage = ms.ToArray();
+//				return byteImage;
+//			}
+//			catch (ArgumentNullException ex)
+//			{
+//				throw ex;
+//			}
+//			finally
+//			{
+//				ms.Close();
+//			}
+//		}
+//		public static Image ResizeImage(Image imgToResize, Size size)
+//		{
+//			//获取图片宽度
+//			int sourceWidth = imgToResize.Width;
+//			//获取图片高度
+//			int sourceHeight = imgToResize.Height;
+
+//			float nPercent = 0;
+//			float nPercentW = 0;
+//			float nPercentH = 0;
+//			//计算宽度的缩放比例
+//			nPercentW = size.Width / (float)sourceWidth;
+//			//计算高度的缩放比例
+//			nPercentH = size.Height / (float)sourceHeight;
+
+//			if (nPercentH < nPercentW)
+//			{
+//				nPercent = nPercentH;
+//			}
+//			else
+//			{
+//				nPercent = nPercentW;
+//			}
+//			//期望的宽度
+//			int destWidth = (int)(sourceWidth * nPercent);
+//			//期望的高度
+//			int destHeight = (int)(sourceHeight * nPercent);
+
+//			Bitmap b = new Bitmap(destWidth, destHeight);
+//			Graphics g = Graphics.FromImage(b);
+//			g.InterpolationMode = InterpolationMode.HighQualityBicubic;
+//			//绘制图像
+//			g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
+//			g.Dispose();
+//			return b;
+//		}
+
+//		private class PixPoint
+//		{
+//			public int X { get; set; }
+//			public int Y { get; set; }
+//		}
+//	}
+//}
diff --git a/Source/MAX.Framework/Helpers/ObjectHelper.cs b/Source/MAX.Framework/Helpers/ObjectHelper.cs
new file mode 100644
index 0000000..dac2387
--- /dev/null
+++ b/Source/MAX.Framework/Helpers/ObjectHelper.cs
@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace MAX.Framework.Helpers
+{
+	public static class ObjectHelper
+	{
+		private static readonly ConcurrentDictionary<string, PropertyInfo> CachedObjectProperties =
+			new ConcurrentDictionary<string, PropertyInfo>();
+
+		public static void TrySetProperty<TObject, TValue>(
+			TObject obj,
+			Expression<Func<TObject, TValue>> propertySelector,
+			Func<TValue> valueFactory,
+			params Type[] ignoreAttributeTypes
+		)
+		{
+			TrySetProperty(obj, propertySelector, x => valueFactory(), ignoreAttributeTypes);
+		}
+
+		public static void TrySetProperty<TObject, TValue>(
+			TObject obj,
+			Expression<Func<TObject, TValue>> propertySelector,
+			Func<TObject, TValue> valueFactory,
+			params Type[] ignoreAttributeTypes
+		)
+		{
+			string cacheKey =
+				$"{obj?.GetType().FullName}-"
+				+ $"{propertySelector}-"
+				+ $"{(ignoreAttributeTypes != null ? "-" + string.Join("-", ignoreAttributeTypes.Select(x => x.FullName)) : "")}";
+
+			PropertyInfo property = CachedObjectProperties.GetOrAdd(
+				cacheKey,
+				(name) =>
+				{
+					if (propertySelector.Body.NodeType != ExpressionType.MemberAccess)
+					{
+						return null;
+					}
+
+					MemberExpression memberExpression = (MemberExpression)propertySelector.Body;
+
+					PropertyInfo propertyInfo = obj?.GetType()
+						.GetProperties()
+						.FirstOrDefault(
+							x =>
+								x.Name == memberExpression.Member.Name
+								&& x.GetSetMethod(true) != null
+						);
+
+					if (propertyInfo == null)
+					{
+						return null;
+					}
+
+					if (
+						ignoreAttributeTypes != null
+						&& ignoreAttributeTypes.Any(
+							ignoreAttribute => propertyInfo.IsDefined(ignoreAttribute, true)
+						)
+					)
+					{
+						return null;
+					}
+
+					return propertyInfo;
+				}
+			);
+
+			property?.SetValue(obj, valueFactory(obj));
+		}
+	}
+}
diff --git a/Source/MAX.Framework/Helpers/StringTypeHelper.cs b/Source/MAX.Framework/Helpers/StringTypeHelper.cs
new file mode 100644
index 0000000..a6d617c
--- /dev/null
+++ b/Source/MAX.Framework/Helpers/StringTypeHelper.cs
@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MAX.Framework.Helpers;
+public class StringTypeHelper
+{
+	public static object ConvertToObject(string input, out Type type)
+	{
+		type = typeof(string);
+		object value = input;
+
+		// 1. 检查布尔值（支持多种表示形式）
+		if (IsBoolean(input, out bool boolValue))
+		{
+			type = typeof(bool);
+			value = boolValue;
+			return value;
+		}
+
+		// 2. 检查整数
+		if (int.TryParse(input, NumberStyles.Integer, CultureInfo.InvariantCulture, out int intValue))
+		{
+			type = typeof(int);
+			value = intValue;
+			return value;
+		}
+
+		// 3. 检查无符号整数
+		if (ulong.TryParse(input, NumberStyles.Integer, CultureInfo.InvariantCulture, out ulong ulongValue))
+		{
+			type = typeof(ulong);
+			value = ulongValue;
+			return value;
+		}
+
+		// 4. 检查双精度浮点数
+		if (double.TryParse(input, NumberStyles.Number | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent,
+							CultureInfo.InvariantCulture, out double doubleValue))
+		{
+			type = typeof(double);
+			value = doubleValue;
+			return value;
+		}
+
+		// 5. 检查十进制数
+		if (decimal.TryParse(input, NumberStyles.Number | NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent,
+							  CultureInfo.InvariantCulture, out decimal decimalValue))
+		{
+			type = typeof(decimal);
+			value = decimalValue;
+			return value;
+		}
+
+		// 6. 检查日期时间
+		if (IsDateTime(input, out DateTime dateTimeValue))
+		{
+			type = typeof(DateTime);
+			value = dateTimeValue;
+			return value;
+		}
+
+		// 7. 检查null
+		if (input == null)
+		{
+			type = typeof(string);
+			value = null;
+			return value;
+		}
+
+		// 8. 默认返回字符串类型
+		type = typeof(string);
+		return value;
+	}
+
+
+	private static bool IsBoolean(string input, out bool boolValue)
+	{
+		boolValue = false;
+		// 支持多种布尔值表示形式
+		if (input.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase) ||
+			input.Equals(bool.FalseString, StringComparison.OrdinalIgnoreCase) ||
+			input.Equals("t", StringComparison.OrdinalIgnoreCase) ||
+			input.Equals("f", StringComparison.OrdinalIgnoreCase) ||
+			input.Equals("1", StringComparison.Ordinal) ||
+			input.Equals("0", StringComparison.Ordinal) ||
+			input.Equals("yes", StringComparison.OrdinalIgnoreCase) ||
+			input.Equals("no", StringComparison.OrdinalIgnoreCase) ||
+			input.Equals("真", StringComparison.Ordinal) ||
+			input.Equals("假", StringComparison.Ordinal))
+		{
+			boolValue = input.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase) ||
+						input.Equals("t", StringComparison.OrdinalIgnoreCase) ||
+						input.Equals("1", StringComparison.Ordinal) ||
+						input.Equals("yes", StringComparison.OrdinalIgnoreCase) ||
+						input.Equals("真", StringComparison.Ordinal);
+			return true;
+		}
+
+		return false;
+	}
+
+	private static bool IsDateTime(string input, out DateTime dateTimeValue)
+	{
+		dateTimeValue = default;
+		// 首先尝试使用默认的DateTime.TryParse进行解析
+		if (DateTime.TryParse(input, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTime dateTime))
+		{
+			dateTimeValue = dateTime;
+			return true;
+		}
+
+		// 如果解析失败，尝试使用不同的格式字符串进行解析
+		string[] formats = {
+			"yyyy-MM-dd",
+			"yyyy/MM/dd",
+			"yyyy.MM.dd",
+			"yyyyMMdd",
+			"yyyy-MM-dd HH:mm",
+			"yyyy/MM/dd HH:mm",
+			"yyyy.MM.dd HH:mm",
+			"yyyy-MM-dd HH:mm:ss",
+			"yyyy/MM/dd HH:mm:ss",
+			"yyyy.MM.dd HH:mm:ss",
+			"yyyy-MM-dd HH:mm:ss.fff",
+			"yyyy-MM-ddTHH:mm:ss.fffK"  // 支持ISO 8601格式带时区
+        };
+
+		// 使用TryParseExact尝试解析，提供多种格式字符串
+		foreach (string format in formats)
+		{
+			if (DateTime.TryParseExact(input, format, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime))
+			{
+				dateTimeValue = dateTime;
+				return true;
+			}
+		}
+
+		return false;
+	}
+}
diff --git a/Source/MAX.Framework/Helpers/WinCmdHelper.cs b/Source/MAX.Framework/Helpers/WinCmdHelper.cs
new file mode 100644
index 0000000..f63ce4b
--- /dev/null
+++ b/Source/MAX.Framework/Helpers/WinCmdHelper.cs
@@ -0,0 +1,157 @@
+using MAX.Core.Commons;
+using System;
+using System.Diagnostics;
+using System.Text;
+
+namespace MAX.Framework.Helpers
+{
+	public class WinCmdHelper
+	{
+		#region 执行Dos命令
+
+		/// <summary>
+		/// 执行Dos命令
+		/// </summary>
+		/// <param name="cmd">Dos命令及参数</param>
+		/// <param name="isShowCmdWindow">是否显示cmd窗口</param>
+		/// <param name="isCloseCmdProcess">执行完毕后是否关闭cmd进程</param>
+		/// <returns>成功返回true，失败返回false</returns>
+		public static Result ExcuteDosCommand(string cmd, string workdir, bool isShowCmdWindow = false, bool isWaitForExit = false, bool isCloseCmdProcess = true)
+		{
+			Result result = new Result();
+			try
+			{
+				StringBuilder errString = new StringBuilder();
+				StringBuilder outString = new StringBuilder();
+				Process p = new Process();
+				p.StartInfo.FileName = "cmd";
+				p.StartInfo.WorkingDirectory = workdir;
+				p.StartInfo.Arguments = "/c " + cmd;
+				p.StartInfo.StandardOutputEncoding = Encoding.UTF8;
+				p.StartInfo.StandardErrorEncoding = Encoding.UTF8;
+				p.StartInfo.UseShellExecute = false;
+				p.StartInfo.RedirectStandardOutput = true;
+				p.StartInfo.RedirectStandardError = true;
+				p.StartInfo.CreateNoWindow = !isShowCmdWindow;
+				p.OutputDataReceived += new DataReceivedEventHandler(delegate (object sender, DataReceivedEventArgs e)
+				{
+					if (!string.IsNullOrEmpty(e.Data))
+					{
+						outString.AppendLine(e.Data);
+						Debug.WriteLine(e.Data);
+					}
+				});
+				p.ErrorDataReceived += new DataReceivedEventHandler(delegate (object sender, DataReceivedEventArgs e)
+				{
+					if (!string.IsNullOrEmpty(e.Data))
+					{
+						errString.AppendLine(e.Data);
+					}
+				});
+				p.Start();
+				p.BeginOutputReadLine();
+				p.BeginErrorReadLine();
+				if (isWaitForExit)
+				{
+					p.WaitForExit();
+				}
+
+				if (isCloseCmdProcess)
+				{
+					p.Close();
+				}
+				if (errString.Length <= 0)
+				{
+					result.Success = true;
+					result.Data = outString.ToString();
+				}
+				Console.WriteLine(string.Format("成功执行Dos命令[{0}]!", cmd));
+				return result;
+			}
+			catch (Exception ex)
+			{
+				Console.WriteLine("执行命令失败，请检查输入的命令是否正确:" + ex.Message, ex);
+				result.Msg = ex.Message;
+			}
+
+			return result;
+		}
+
+		private static void P_ErrorDataReceived(object sender, DataReceivedEventArgs e)
+		{
+			throw new NotImplementedException();
+		}
+
+		#endregion
+
+		#region 判断指定的进程是否在运行中
+
+		/// <summary>
+		/// 判断指定的进程是否在运行中
+		/// </summary>
+		/// <param name="processName">要判断的进程名称，不包括扩展名exe</param>
+		/// <param name="processFileName">进程文件的完整路径</param>
+		/// <returns>存在返回true，否则返回false</returns>
+		public static bool CheckProcessExists(string processName, string processFileName)
+		{
+			Process[] processes = Process.GetProcessesByName(processName);
+			foreach (Process p in processes)
+			{
+				if (!string.IsNullOrEmpty(processFileName))
+				{
+					if (processFileName == p?.MainModule?.FileName)
+					{
+						return true;
+					}
+				}
+				else
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+
+		#endregion
+
+		#region 结束指定的windows进程
+
+		/// <summary>
+		/// 结束指定的windows进程，如果进程存在
+		/// </summary>
+		/// <param name="processName">进程名称，不包含扩展名</param>
+		/// <param name="processFileName">进程文件完整路径，如果为空则删除所有进程名为processName参数值的进程</param>
+		public static bool KillProcessExists(string processName, string processFileName)
+		{
+			try
+			{
+				Process[] processes = Process.GetProcessesByName(processName);
+				foreach (Process p in processes)
+				{
+					if (!string.IsNullOrEmpty(processFileName))
+					{
+						if (processFileName == p.MainModule.FileName)
+						{
+							p.Kill();
+							p.Close();
+						}
+					}
+					else
+					{
+						p.Kill();
+						p.Close();
+					}
+				}
+				Console.WriteLine(string.Format("成功结束[{0}]进程!", processes));
+				return true;
+			}
+			catch (Exception ex)
+			{
+				Console.WriteLine("结束指定的Widnows进程异常:" + ex.Message, ex);
+				return false;
+			}
+		}
+
+		#endregion
+	}
+}
diff --git a/Source/MAX.Framework/Helpers/XmlHelper.cs b/Source/MAX.Framework/Helpers/XmlHelper.cs
new file mode 100644
index 0000000..8d3b6d6
--- /dev/null
+++ b/Source/MAX.Framework/Helpers/XmlHelper.cs
@@ -0,0 +1,292 @@
+
+using System.Xml;
+using System.Data;
+using System.IO;
+using System;
+
+namespace MAX.Framework.Helpers
+{
+	/// <summary>
+	/// Xml的操作公共类
+	/// </summary>    
+	public class XmlHelper
+	{
+		#region 字段定义
+		/// <summary>
+		/// /// XML文件的物理路径
+		/// </summary>
+		private string _filePath = string.Empty;
+		/// <summary>
+		/// Xml文档
+		/// </summary>
+		private XmlDocument _xml;
+		/// <summary>
+		/// XML的根节点
+		/// </summary>
+		private XmlElement _element;
+		#endregion
+
+		#region 构造方法
+		/// <summary>
+		/// 实例化XmlHelper对象
+		/// </summary>
+		/// <param name="xmlFilePath">Xml文件的相对路径</param>
+		public XmlHelper(string xmlFilePath)
+		{
+			//获取XML文件的绝对路径
+			_filePath = xmlFilePath;
+			//创建一个XML对象
+			_xml = new XmlDocument();
+			if (File.Exists(xmlFilePath))
+			{
+				//加载XML文件
+				_xml.Load(xmlFilePath);
+			}
+			_element = _xml.DocumentElement;
+		}
+		public XmlHelper(Stream stream)
+		{
+			//创建一个XML对象
+			_xml = new XmlDocument();
+			if (stream != null)
+			{
+				//加载XML
+				_xml.Load(stream);
+			}
+			_element = _xml.DocumentElement;
+		}
+		#endregion
+
+
+
+		#region 获取指定XPath表达式的节点对象
+		/// <summary>
+		/// 获取指定XPath表达式的节点对象
+		/// </summary>        
+		/// <param name="xPath">XPath表达式,
+		/// 范例1: @"Skill/First/SkillItem", 等效于 @"//Skill/First/SkillItem"
+		/// 范例2: @"Table[USERNAME='a']" , []表示筛选,USERNAME是Table下的一个子节点.
+		/// 范例3: @"ApplyPost/Item[@itemName='岗位编号']",@itemName是Item节点的属性.
+		/// </param>
+		public XmlNode GetNode(string xPath)
+		{
+			//返回XPath节点
+			return _element.SelectSingleNode(xPath);
+		}
+
+		/// <summary>
+		/// 获取指定XPath表达式的节点对象
+		/// </summary>        
+		/// <param name="xPath">XPath表达式,
+		/// 范例1: @"Skill/First/SkillItem", 等效于 @"//Skill/First/SkillItem"
+		/// 范例2: @"Table[USERNAME='a']" , []表示筛选,USERNAME是Table下的一个子节点.
+		/// 范例3: @"ApplyPost/Item[@itemName='岗位编号']",@itemName是Item节点的属性.
+		/// </param>
+		public XmlNodeList GetNodes(string xPath)
+		{
+			//返回XPath节点
+			return _element.SelectNodes(xPath);
+		}
+		#endregion
+
+		#region 获取指定XPath表达式节点的值
+		/// <summary>
+		/// 获取指定XPath表达式节点的值
+		/// </summary>
+		/// <param name="xPath">XPath表达式,
+		/// 范例1: @"Skill/First/SkillItem", 等效于 @"//Skill/First/SkillItem"
+		/// 范例2: @"Table[USERNAME='a']" , []表示筛选,USERNAME是Table下的一个子节点.
+		/// 范例3: @"ApplyPost/Item[@itemName='岗位编号']",@itemName是Item节点的属性.
+		/// </param>
+		public string GetValue(string xPath)
+		{
+			//返回XPath节点的值
+			string value = _element.SelectSingleNode(xPath)?.InnerText ?? "";
+			return value;
+		}
+		public T GetValue<T>(string xPath, T? def = default)
+		{
+			string value = GetValue(xPath);
+			if (value == null)
+				return def;
+			else
+				return (T)Convert.ChangeType(value, typeof(T));
+		}
+		#endregion
+
+		#region 获取指定XPath表达式节点的属性值
+		/// <summary>
+		/// 获取指定XPath表达式节点的属性值
+		/// </summary>
+		/// <param name="xPath">XPath表达式,
+		/// 范例1: @"Skill/First/SkillItem", 等效于 @"//Skill/First/SkillItem"
+		/// 范例2: @"Table[USERNAME='a']" , []表示筛选,USERNAME是Table下的一个子节点.
+		/// 范例3: @"ApplyPost/Item[@itemName='岗位编号']",@itemName是Item节点的属性.
+		/// </param>
+		/// <param name="attributeName">属性名</param>
+		public string GetAttributeValue(string xPath, string attributeName)
+		{
+			//返回XPath节点的属性值
+			return _element.SelectSingleNode(xPath).Attributes[attributeName].Value;
+		}
+		#endregion
+
+		#region 新增节点
+		/// <summary>
+		/// 1. 功能：新增节点。
+		/// 2. 使用条件：将任意节点插入到当前Xml文件中。
+		/// </summary>        
+		/// <param name="xmlNode">要插入的Xml节点</param>
+		public void AppendNode(XmlNode xmlNode)
+		{
+			//导入节点
+			XmlNode node = _xml.ImportNode(xmlNode, true);
+
+			//将节点插入到根节点下
+			_element.AppendChild(node);
+		}
+
+		/// <summary>
+		/// 1. 功能：新增节点。
+		/// 2. 使用条件：将DataSet中的第一条记录插入Xml文件中。
+		/// </summary>        
+		/// <param name="ds">DataSet的实例，该DataSet中应该只有一条记录</param>
+		public void AppendNode(DataSet ds)
+		{
+			//创建XmlDataDocument对象
+			XmlDataDocument xmlDataDocument = new XmlDataDocument(ds);
+
+			//导入节点
+			XmlNode node = xmlDataDocument.DocumentElement.FirstChild;
+
+			//将节点插入到根节点下
+			AppendNode(node);
+		}
+		#endregion
+
+		#region 删除节点
+		/// <summary>
+		/// 删除指定XPath表达式的节点
+		/// </summary>        
+		/// <param name="xPath">XPath表达式,
+		/// 范例1: @"Skill/First/SkillItem", 等效于 @"//Skill/First/SkillItem"
+		/// 范例2: @"Table[USERNAME='a']" , []表示筛选,USERNAME是Table下的一个子节点.
+		/// 范例3: @"ApplyPost/Item[@itemName='岗位编号']",@itemName是Item节点的属性.
+		/// </param>
+		public void RemoveNode(string xPath)
+		{
+			//获取要删除的节点
+			XmlNode node = _xml.SelectSingleNode(xPath);
+
+			//删除节点
+			_element.RemoveChild(node);
+		}
+		#endregion //删除节点
+
+		#region 保存XML文件
+		/// <summary>
+		/// 保存XML文件
+		/// </summary>        
+		public void Save()
+		{
+			if (string.IsNullOrEmpty(_filePath))
+			{
+				throw new Exception("Xml文件路径不能为空！");
+			}
+			//保存XML文件
+			_xml.Save(_filePath);
+		}
+		public void Save(string filePath)
+		{
+			//保存XML文件
+			_xml.Save(filePath);
+		}
+		#endregion //保存XML文件
+
+		#region 静态方法
+
+		#region 创建根节点对象
+		/// <summary>
+		/// 创建根节点对象
+		/// </summary>
+		/// <param name="xmlFilePath">Xml文件的相对路径</param>        
+		private static XmlElement CreateRootElement(string xmlFilePath)
+		{
+			//定义变量，表示XML文件的绝对路径
+			string filePath = "";
+
+			//获取XML文件的绝对路径
+			filePath = xmlFilePath;
+
+			//创建XmlDocument对象
+			XmlDocument xmlDocument = new XmlDocument();
+			//加载XML文件
+			xmlDocument.Load(filePath);
+
+			//返回根节点
+			return xmlDocument.DocumentElement;
+		}
+		#endregion
+
+		#region 获取指定XPath表达式节点的值
+		/// <summary>
+		/// 获取指定XPath表达式节点的值
+		/// </summary>
+		/// <param name="xmlFilePath">Xml文件的相对路径</param>
+		/// <param name="xPath">XPath表达式,
+		/// 范例1: @"Skill/First/SkillItem", 等效于 @"//Skill/First/SkillItem"
+		/// 范例2: @"Table[USERNAME='a']" , []表示筛选,USERNAME是Table下的一个子节点.
+		/// 范例3: @"ApplyPost/Item[@itemName='岗位编号']",@itemName是Item节点的属性.
+		/// </param>
+		public static string GetValue(string xmlFilePath, string xPath)
+		{
+			//创建根对象
+			XmlElement rootElement = CreateRootElement(xmlFilePath);
+
+			//返回XPath节点的值
+			return rootElement.SelectSingleNode(xPath).InnerText;
+		}
+		#endregion
+
+		#region 获取指定XPath表达式节点的属性值
+		/// <summary>
+		/// 获取指定XPath表达式节点的属性值
+		/// </summary>
+		/// <param name="xmlFilePath">Xml文件的相对路径</param>
+		/// <param name="xPath">XPath表达式,
+		/// 范例1: @"Skill/First/SkillItem", 等效于 @"//Skill/First/SkillItem"
+		/// 范例2: @"Table[USERNAME='a']" , []表示筛选,USERNAME是Table下的一个子节点.
+		/// 范例3: @"ApplyPost/Item[@itemName='岗位编号']",@itemName是Item节点的属性.
+		/// </param>
+		/// <param name="attributeName">属性名</param>
+		public static string GetAttributeValue(string xmlFilePath, string xPath, string attributeName)
+		{
+			//创建根对象
+			XmlElement rootElement = CreateRootElement(xmlFilePath);
+
+			//返回XPath节点的属性值
+			return rootElement.SelectSingleNode(xPath).Attributes[attributeName].Value;
+		}
+		#endregion
+
+		#endregion
+
+
+	}
+
+	public static class XmlHelExtension
+	{
+		public static string GetAttributeValue(this XmlNode node, string attributeName)
+		{
+			return node.Attributes[attributeName].Value;
+		}
+		public static T GetAttributeValue<T>(this XmlNode node, string attributeName)
+		{
+			var value = node.Attributes[attributeName].Value;
+			if (string.IsNullOrEmpty(value))
+				return default(T);
+			return (T)Convert.ChangeType(value, typeof(T));
+
+		}
+	}
+}
diff --git a/Source/MAX.Framework/Interfaces/IAppConfig.cs b/Source/MAX.Framework/Interfaces/IAppConfig.cs
new file mode 100644
index 0000000..2582f88
--- /dev/null
+++ b/Source/MAX.Framework/Interfaces/IAppConfig.cs
@@ -0,0 +1,17 @@
+using MAX.Core.DependencyInjection;
+
+namespace MAX.Framework.Interfaces
+{
+	public interface IAppConfig : ISingletonDependency
+	{
+		/// <summary>
+		/// 公司名称
+		/// </summary>
+		string CompanyName { get; }
+		/// <summary>
+		/// 软件名称
+		/// </summary>
+		string AppName { get; }
+		T GetValue<T>(string key, T defaultValue = default);
+	}
+}
diff --git a/Source/MAX.Framework/Interfaces/IAppInitialize.cs b/Source/MAX.Framework/Interfaces/IAppInitialize.cs
new file mode 100644
index 0000000..100f94b
--- /dev/null
+++ b/Source/MAX.Framework/Interfaces/IAppInitialize.cs
@@ -0,0 +1,38 @@
+using MAX.Core;
+using MAX.Core.DependencyInjection;
+using System.Threading.Tasks;
+
+namespace MAX.Framework.Interfaces
+{
+	/// <summary>
+	/// 初始化接口
+	/// </summary>
+	public interface IAppInitialize : ISingletonDependency, IPriority
+	{
+		/// <summary>
+		/// 描述
+		/// </summary>
+		string Description { get; }
+
+		/// <summary>
+		/// App 初始化数据
+		/// </summary>
+		void AppInitialize();
+	}
+
+	/// <summary>
+	/// 初始化接口（异步）
+	/// </summary>
+	public interface IAppInitializeAsync : ISingletonDependency, IPriority
+	{
+		/// <summary>
+		/// 描述
+		/// </summary>
+		string Description { get; }
+
+		/// <summary>
+		/// App 初始化数据
+		/// </summary>
+		Task AppInitializeAsync();
+	}
+}
diff --git a/Source/MAX.Framework/Interfaces/IFolderConfig.cs b/Source/MAX.Framework/Interfaces/IFolderConfig.cs
new file mode 100644
index 0000000..26a6a58
--- /dev/null
+++ b/Source/MAX.Framework/Interfaces/IFolderConfig.cs
@@ -0,0 +1,20 @@
+using MAX.Core.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MAX.Framework.Interfaces
+{
+	public interface IFolderConfig: ISingletonDependency
+	{
+		/// <summary>
+		/// 执行目录
+		/// </summary>
+		string LocalFolder { get; }
+		string LocalAppFolder { get; }
+		string TargetFolder { get; }
+		string LoggingFolder { get; }
+	}
+}
diff --git a/Source/MAX.Framework/Logger/NLogger.cs b/Source/MAX.Framework/Logger/NLogger.cs
new file mode 100644
index 0000000..b219141
--- /dev/null
+++ b/Source/MAX.Framework/Logger/NLogger.cs
@@ -0,0 +1,153 @@
+using MAX.Core.DependencyInjection;
+using MAX.Core.Infrastructure;
+using MAX.Core.Logger;
+using MAX.Framework.Interfaces;
+using NLog;
+using NLog.Targets;
+using System;
+using LLogLevel = MAX.Core.Logger.LogLevel;
+using NLogLevel = NLog.LogLevel;
+
+namespace MAX.Framework.Logger
+{
+	public class NLogger : ILoggerFacade, ISingletonDependency
+	{
+		private readonly ILogger _log;
+		public static ILoggerFacade Instance => LazyServiceProvider.Instance.LazyGetService<ILoggerFacade>();
+		public NLogger(IFolderConfig folderConfig = null)
+		{
+			if (folderConfig != null)
+			{
+				Target target = new FileTarget("log1")
+				{
+					FileName = $"{folderConfig.LoggingFolder}\\{DateTime.Now:yyyy-MM-dd}.txt",
+				};
+				var config = new NLog.Config.LoggingConfiguration();
+				config.AddRule(NLogLevel.Debug, NLogLevel.Fatal, target);
+
+				LogManager.Configuration = config;
+			}
+			_log = LogManager.GetLogger("GlobalLogger");
+		}
+
+		public bool IsDebugEnabled { get; private set; } = false;
+
+		public void Debug(Exception ex, string message)
+		{
+			Execute(NLogLevel.Debug, ex, message);
+		}
+
+		public void Debug(string message)
+		{
+			Execute(NLogLevel.Debug, message);
+		}
+		public void Error(Exception ex)
+		{
+			Execute(NLogLevel.Error, ex);
+		}
+		public void Error(Exception ex, string message)
+		{
+			Execute(NLogLevel.Error, ex, message);
+		}
+
+		public void Error(string message)
+		{
+			Execute(NLogLevel.Error, message);
+		}
+
+		public void Fatal(Exception ex, string message)
+		{
+			Execute(NLogLevel.Fatal, ex, message);
+		}
+
+		public void Fatal(string message)
+		{
+			Execute(NLogLevel.Fatal, message);
+		}
+
+		public void Info(Exception ex, string message)
+		{
+			Execute(NLogLevel.Info, ex, message);
+		}
+
+		public void Info(string message)
+		{
+			Execute(NLogLevel.Info, message);
+		}
+
+		public void Warn(Exception ex, string message)
+		{
+			Execute(NLogLevel.Warn, ex, message);
+		}
+
+		public void Warn(string message)
+		{
+			Execute(NLogLevel.Warn, message);
+		}
+		public void Log(string message, LLogLevel level)
+		{
+			NLogLevel lv = NLogLevel.Info;
+			switch (level)
+			{
+				case LLogLevel.Trace:
+					lv = NLogLevel.Trace;
+					break;
+				case LLogLevel.Debug:
+					lv = NLogLevel.Debug;
+					break;
+				case LLogLevel.Info:
+					lv = NLogLevel.Info;
+					break;
+				case LLogLevel.Warn:
+					lv = NLogLevel.Warn;
+					break;
+				case LLogLevel.Error:
+					lv = NLogLevel.Error;
+					break;
+				case LLogLevel.Fatal:
+					lv = NLogLevel.Fatal;
+					break;
+				case LLogLevel.None:
+					lv = NLogLevel.Off;
+					break;
+			}
+			Execute(lv, message);
+		}
+		/// <summary>
+		/// 是否启用
+		/// </summary>
+		private bool Enabled(NLogLevel level)
+		{
+			if (level > NLogLevel.Debug)
+			{
+				return true;
+			}
+
+			return IsDebugEnabled;
+		}
+
+		/// <summary>
+		/// 执行
+		/// </summary>
+		private void Execute(NLogLevel level, Exception ex, string message = "")
+		{
+			if (Enabled(level))
+			{
+				_log.Log(level, ex, message, null);
+			}
+		}
+
+
+		/// <summary>
+		/// 执行
+		/// </summary>
+		private void Execute(NLogLevel level, string message)
+		{
+			if (Enabled(level))
+			{
+				_log.Log(level, message);
+			}
+		}
+
+	}
+}
diff --git a/Source/MAX.Framework/MAX.Framework.csproj b/Source/MAX.Framework/MAX.Framework.csproj
new file mode 100644
index 0000000..87ba535
--- /dev/null
+++ b/Source/MAX.Framework/MAX.Framework.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+	  <TargetFramework>$(DefaultTargetFramework)-windows</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Autofac" Version="9.3.2" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+    <PackageReference Include="NLog" Version="6.2.0" />
+    <PackageReference Include="Prism.Wpf" Version="8.1.97" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MAX.Core\MAX.Core.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Source/MAX.Framework/PrismExtension/Commands/AsyncDelegateCommand.cs b/Source/MAX.Framework/PrismExtension/Commands/AsyncDelegateCommand.cs
new file mode 100644
index 0000000..8a7a4e9
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Commands/AsyncDelegateCommand.cs
@@ -0,0 +1,243 @@
+using System.Linq.Expressions;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using Prism.Properties;
+
+
+namespace Prism.Commands
+{
+
+    /// <summary>
+    /// Provides an implementation of the <see cref="IAsyncCommand"/>
+    /// </summary>
+    public class AsyncDelegateCommand : DelegateCommandBase, IAsyncCommand
+    {
+        private bool _enableParallelExecution = false;
+        private bool _isExecuting = false;
+        private readonly Func<CancellationToken, Task> _executeMethod;
+        private Func<bool> _canExecuteMethod;
+        private Func<CancellationToken> _getCancellationToken = () => CancellationToken.None;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="AsyncDelegateCommand"/> with the <see cref="Func{Task}"/> to invoke on execution.
+        /// </summary>
+        /// <param name="executeMethod">The <see cref="Func{Task}"/> to invoke when <see cref="ICommand.Execute(object)"/> is called.</param>
+        public AsyncDelegateCommand(Func<Task> executeMethod)
+#if NET6_0_OR_GREATER
+            : this (c => executeMethod().WaitAsync(c), () => true)
+#else
+            : this(c => executeMethod(), () => true)
+#endif
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="AsyncDelegateCommand"/> with the <see cref="Func{Task}"/> to invoke on execution.
+        /// </summary>
+        /// <param name="executeMethod">The <see cref="Func{CancellationToken, Task}"/> to invoke when <see cref="ICommand.Execute(object)"/> is called.</param>
+        public AsyncDelegateCommand(Func<CancellationToken, Task> executeMethod)
+            : this(executeMethod, () => true)
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="DelegateCommand"/> with the <see cref="Func{Task}"/> to invoke on execution
+        /// and a <see langword="Func" /> to query for determining if the command can execute.
+        /// </summary>
+        /// <param name="executeMethod">The <see cref="Func{Task}"/> to invoke when <see cref="ICommand.Execute"/> is called.</param>
+        /// <param name="canExecuteMethod">The delegate to invoke when <see cref="ICommand.CanExecute"/> is called</param>
+        public AsyncDelegateCommand(Func<Task> executeMethod, Func<bool> canExecuteMethod)
+#if NET6_0_OR_GREATER
+            : this(c => executeMethod().WaitAsync(c), canExecuteMethod)
+#else
+            : this(c => executeMethod(), canExecuteMethod)
+#endif
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="DelegateCommand"/> with the <see cref="Func{Task}"/> to invoke on execution
+        /// and a <see langword="Func" /> to query for determining if the command can execute.
+        /// </summary>
+        /// <param name="executeMethod">The <see cref="Func{CancellationToken, Task}"/> to invoke when <see cref="ICommand.Execute"/> is called.</param>
+        /// <param name="canExecuteMethod">The delegate to invoke when <see cref="ICommand.CanExecute"/> is called</param>
+        public AsyncDelegateCommand(Func<CancellationToken, Task> executeMethod, Func<bool> canExecuteMethod)
+            : base()
+        {
+            if (executeMethod == null || canExecuteMethod == null)
+                throw new ArgumentNullException(nameof(executeMethod), "Neither the executeMethod nor the canExecuteMethod delegates can be null");
+
+            _executeMethod = executeMethod;
+            _canExecuteMethod = canExecuteMethod;
+        }
+
+        /// <summary>
+        /// Gets the current state of the AsyncDelegateCommand
+        /// </summary>
+        public bool IsExecuting
+        {
+            get => _isExecuting;
+            private set
+            {
+                _isExecuting = value;
+				OnCanExecuteChanged();
+            }
+        }
+
+        ///<summary>
+        /// Executes the command.
+        ///</summary>
+        public async Task Execute(CancellationToken? cancellationToken = null)
+        {
+            var token = cancellationToken ?? _getCancellationToken();
+            try
+            {
+                if (!_enableParallelExecution && IsExecuting)
+                    return;
+
+                IsExecuting = true;
+                await _executeMethod(token)
+                    .ConfigureAwait(false);
+            }
+            catch 
+            {
+                throw;
+
+            }
+            finally
+            {
+                IsExecuting = false;
+            }
+        }
+
+        /// <summary>
+        /// Determines if the command can be executed.
+        /// </summary>
+        /// <returns>Returns <see langword="true"/> if the command can execute,otherwise returns <see langword="false"/>.</returns>
+        public bool CanExecute()
+        {
+            try
+            {
+                if (!_enableParallelExecution && IsExecuting)
+                    return false;
+
+                return _canExecuteMethod?.Invoke() ?? true;
+            }
+            catch (Exception ex)
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Handle the internal invocation of <see cref="ICommand.Execute(object)"/>
+        /// </summary>
+        /// <param name="parameter">Command Parameter</param>
+        protected override async void Execute(object parameter)
+        {
+            // We don't want to wrap this in a try/catch because we already handle
+            // or mean to rethrow the exception in the call with the CancellationToken.
+            var cancellationToken = _getCancellationToken();
+            await Execute(cancellationToken)
+                .ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Handle the internal invocation of <see cref="ICommand.CanExecute(object)"/>
+        /// </summary>
+        /// <param name="parameter"></param>
+        /// <returns><see langword="true"/> if the Command Can Execute, otherwise <see langword="false" /></returns>
+        protected override bool CanExecute(object parameter)
+        {
+            return CanExecute();
+        }
+
+        /// <summary>
+        /// Enables Parallel Execution of Async Tasks
+        /// </summary>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand"/>.</returns>
+        public AsyncDelegateCommand EnableParallelExecution()
+        {
+            _enableParallelExecution = true;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the <see cref="CancellationTokenSourceFactory(Func{CancellationToken})"/> based on the specified timeout.
+        /// </summary>
+        /// <param name="timeout">A specified timeout.</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand{T}"/>.</returns>
+        public AsyncDelegateCommand CancelAfter(TimeSpan timeout) =>
+            CancellationTokenSourceFactory(() => new CancellationTokenSource(timeout).Token);
+
+        /// <summary>
+        /// Provides a delegate callback to provide a default CancellationToken when the Command is invoked.
+        /// </summary>
+        /// <param name="factory">The default <see cref="CancellationToken"/> Factory.</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand"/>.</returns>
+        public AsyncDelegateCommand CancellationTokenSourceFactory(Func<CancellationToken> factory)
+        {
+            _getCancellationToken = factory;
+            return this;
+        }
+
+        /// <summary>
+        /// Observes a property that implements INotifyPropertyChanged, and automatically calls DelegateCommandBase.RaiseCanExecuteChanged on property changed notifications.
+        /// </summary>
+        /// <typeparam name="T">The object type containing the property specified in the expression.</typeparam>
+        /// <param name="propertyExpression">The property expression. Example: ObservesProperty(() => PropertyName).</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand"/>.</returns>
+        public AsyncDelegateCommand ObservesProperty<T>(Expression<Func<T>> propertyExpression)
+        {
+            ObservesPropertyInternal(propertyExpression);
+            return this;
+        }
+
+        /// <summary>
+        /// Observes a property that is used to determine if this command can execute, and if it implements INotifyPropertyChanged it will automatically call DelegateCommandBase.RaiseCanExecuteChanged on property changed notifications.
+        /// </summary>
+        /// <param name="canExecuteExpression">The property expression. Example: ObservesCanExecute(() => PropertyName).</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand"/>.</returns>
+        public AsyncDelegateCommand ObservesCanExecute(Expression<Func<bool>> canExecuteExpression)
+        {
+            _canExecuteMethod = canExecuteExpression.Compile();
+            ObservesPropertyInternal(canExecuteExpression);
+            return this;
+        }
+
+        /// <summary>
+        /// Provides the ability to connect a delegate to catch exceptions encountered by CanExecute or the Execute methods of the DelegateCommand
+        /// </summary>
+        /// <param name="catch">TThe callback when a specific exception is encountered</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand"/>.</returns>
+        public AsyncDelegateCommand Catch<TException>(Action<TException> @catch)
+            where TException : Exception
+        {
+            return this;
+        }
+
+        /// <summary>
+        /// Provides the ability to connect a delegate to catch exceptions encountered by CanExecute or the Execute methods of the DelegateCommand
+        /// </summary>
+        /// <param name="catch">The generic / default callback when an exception is encountered</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand"/>.</returns>
+        public AsyncDelegateCommand Catch(Action<Exception> @catch)
+        {
+            return this;
+        }
+
+        Task IAsyncCommand.ExecuteAsync(object parameter)
+        {
+            return Execute(_getCancellationToken());
+        }
+
+        Task IAsyncCommand.ExecuteAsync(object parameter, CancellationToken cancellationToken)
+        {
+            return Execute(cancellationToken);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Source/MAX.Framework/PrismExtension/Commands/AsyncDelegateCommand{T}.cs b/Source/MAX.Framework/PrismExtension/Commands/AsyncDelegateCommand{T}.cs
new file mode 100644
index 0000000..55d6aec
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Commands/AsyncDelegateCommand{T}.cs
@@ -0,0 +1,284 @@
+using System.Linq.Expressions;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using System.Reflection.Emit;
+using System.Resources;
+
+namespace Prism.Commands
+{
+    /// <summary>
+    /// Provides an implementation of the <see cref="IAsyncCommand"/> with a generic parameter type.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class AsyncDelegateCommand<T> : DelegateCommandBase, IAsyncCommand
+    {
+        private bool _enableParallelExecution = false;
+        private bool _isExecuting = false;
+        private readonly Func<T, CancellationToken, Task> _executeMethod;
+        private Func<T, bool> _canExecuteMethod;
+        private Func<CancellationToken> _getCancellationToken = () => CancellationToken.None;
+
+        /// <summary>
+        /// Creates a new instance of <see cref="AsyncDelegateCommand{T}"/> with the <see cref="Func{Task}"/> to invoke on execution.
+        /// </summary>
+        /// <param name="executeMethod">The <see cref="Func{T, Task}"/> to invoke when <see cref="ICommand.Execute(object)"/> is called.</param>
+        public AsyncDelegateCommand(Func<T, Task> executeMethod)
+#if NET6_0_OR_GREATER
+            : this((p,t) => executeMethod(p).WaitAsync(t), _ => true)
+#else
+            : this((p, t) => executeMethod(p), _ => true)
+#endif
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="AsyncDelegateCommand{T}"/> with the <see cref="Func{Task}"/> to invoke on execution.
+        /// </summary>
+        /// <param name="executeMethod">The <see cref="Func{T, CancellationToken, Task}"/> to invoke when <see cref="ICommand.Execute(object)"/> is called.</param>
+        public AsyncDelegateCommand(Func<T, CancellationToken, Task> executeMethod)
+            : this(executeMethod, _ => true)
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="DelegateCommand"/> with the <see cref="Func{Task}"/> to invoke on execution
+        /// and a <see langword="Func" /> to query for determining if the command can execute.
+        /// </summary>
+        /// <param name="executeMethod">The <see cref="Func{T, Task}"/> to invoke when <see cref="ICommand.Execute"/> is called.</param>
+        /// <param name="canExecuteMethod">The delegate to invoke when <see cref="ICommand.CanExecute"/> is called</param>
+        public AsyncDelegateCommand(Func<T, Task> executeMethod, Func<T, bool> canExecuteMethod)
+#if NET6_0_OR_GREATER
+            : this((p, c) => executeMethod(p).WaitAsync(c), canExecuteMethod)
+#else
+            : this((p, c) => executeMethod(p), canExecuteMethod)
+#endif
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of <see cref="DelegateCommand"/> with the <see cref="Func{Task}"/> to invoke on execution
+        /// and a <see langword="Func" /> to query for determining if the command can execute.
+        /// </summary>
+        /// <param name="executeMethod">The <see cref="Func{T, CancellationToken, Task}"/> to invoke when <see cref="ICommand.Execute"/> is called.</param>
+        /// <param name="canExecuteMethod">The delegate to invoke when <see cref="ICommand.CanExecute"/> is called</param>
+        public AsyncDelegateCommand(Func<T, CancellationToken, Task> executeMethod, Func<T, bool> canExecuteMethod)
+            : base()
+        {
+            if (executeMethod == null || canExecuteMethod == null)
+                throw new ArgumentNullException(nameof(executeMethod), "Neither the executeMethod nor the canExecuteMethod delegates can be null");
+
+
+            _executeMethod = executeMethod;
+            _canExecuteMethod = canExecuteMethod;
+        }
+
+        /// <summary>
+        /// Gets the current state of the AsyncDelegateCommand
+        /// </summary>
+        public bool IsExecuting
+        {
+            get => _isExecuting;
+            private set
+            {
+                _isExecuting = value;
+                OnCanExecuteChanged();
+            }
+        }
+
+        ///<summary>
+        /// Executes the command.
+        ///</summary>
+        public async Task Execute(T parameter, CancellationToken? cancellationToken = null)
+        {
+            var token = cancellationToken ?? _getCancellationToken();
+
+            try
+            {
+                if (!_enableParallelExecution && IsExecuting)
+                    return;
+
+                IsExecuting = true;
+                await _executeMethod(parameter, token)
+                    .ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+            finally
+            {
+                IsExecuting = false;
+            }
+        }
+
+        /// <summary>
+        /// Determines if the command can be executed.
+        /// </summary>
+        /// <returns>Returns <see langword="true"/> if the command can execute,otherwise returns <see langword="false"/>.</returns>
+        public bool CanExecute(T parameter)
+        {
+            try
+            {
+                if (!_enableParallelExecution && IsExecuting)
+                    return false;
+
+                return _canExecuteMethod?.Invoke(parameter) ?? true;
+            }
+            catch (Exception ex)
+            {
+
+                throw;
+
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Handle the internal invocation of <see cref="ICommand.Execute(object)"/>
+        /// </summary>
+        /// <param name="parameter">Command Parameter</param>
+        protected override async void Execute(object parameter)
+        {
+            var cancellationToken = _getCancellationToken();
+            T parameterAsT;
+            try
+            {
+                parameterAsT = (T)parameter;
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+
+            // If we had an exception casting the parameter to T ,
+            // we would have already returned. We want to surface any
+            // exceptions thrown by the Execute method.
+            await Execute(parameterAsT, cancellationToken)
+                .ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Handle the internal invocation of <see cref="ICommand.CanExecute(object)"/>
+        /// </summary>
+        /// <param name="parameter"></param>
+        /// <returns><see langword="true"/> if the Command Can Execute, otherwise <see langword="false" /></returns>
+        protected override bool CanExecute(object parameter)
+        {
+            try
+            {
+                return CanExecute((T)parameter);
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Enables Parallel Execution of Async Tasks
+        /// </summary>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand{T}"/>.</returns>
+        public AsyncDelegateCommand<T> EnableParallelExecution()
+        {
+            _enableParallelExecution = true;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the <see cref="CancellationTokenSourceFactory(Func{CancellationToken})"/> based on the specified timeout.
+        /// </summary>
+        /// <param name="timeout">A specified timeout.</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand{T}"/>.</returns>
+        public AsyncDelegateCommand<T> CancelAfter(TimeSpan timeout) =>
+            CancellationTokenSourceFactory(() => new CancellationTokenSource(timeout).Token);
+
+        /// <summary>
+        /// Provides a delegate callback to provide a default CancellationToken when the Command is invoked.
+        /// </summary>
+        /// <param name="factory">The default <see cref="CancellationToken"/> Factory.</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand{T}"/>.</returns>
+        public AsyncDelegateCommand<T> CancellationTokenSourceFactory(Func<CancellationToken> factory)
+        {
+            _getCancellationToken = factory;
+            return this;
+        }
+
+        /// <summary>
+        /// Observes a property that implements INotifyPropertyChanged, and automatically calls DelegateCommandBase.RaiseCanExecuteChanged on property changed notifications.
+        /// </summary>
+        /// <typeparam name="TType">The type of the return value of the method that this delegate encapsulates</typeparam>
+        /// <param name="propertyExpression">The property expression. Example: ObservesProperty(() => PropertyName).</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand{T}"/>.</returns>
+        public AsyncDelegateCommand<T> ObservesProperty<TType>(Expression<Func<TType>> propertyExpression)
+        {
+            ObservesPropertyInternal(propertyExpression);
+            return this;
+        }
+
+        /// <summary>
+        /// Observes a property that is used to determine if this command can execute, and if it implements INotifyPropertyChanged it will automatically call DelegateCommandBase.RaiseCanExecuteChanged on property changed notifications.
+        /// </summary>
+        /// <param name="canExecuteExpression">The property expression. Example: ObservesCanExecute(() => PropertyName).</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand{T}"/>.</returns>
+        public AsyncDelegateCommand<T> ObservesCanExecute(Expression<Func<bool>> canExecuteExpression)
+        {
+            Expression<Func<T, bool>> expression = Expression.Lambda<Func<T, bool>>(canExecuteExpression.Body, Expression.Parameter(typeof(T), "o"));
+            _canExecuteMethod = expression.Compile();
+            ObservesPropertyInternal(canExecuteExpression);
+            return this;
+        }
+
+        /// <summary>
+        /// Provides the ability to connect a delegate to catch exceptions encountered by CanExecute or the Execute methods of the DelegateCommand
+        /// </summary>
+        /// <param name="catch">TThe callback when a specific exception is encountered</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand{T}"/>.</returns>
+        public AsyncDelegateCommand<T> Catch<TException>(Action<TException> @catch)
+            where TException : Exception
+        {
+            return this;
+        }
+
+        /// <summary>
+        /// Provides the ability to connect a delegate to catch exceptions encountered by CanExecute or the Execute methods of the DelegateCommand
+        /// </summary>
+        /// <param name="catch">The generic / default callback when an exception is encountered</param>
+        /// <returns>The current instance of <see cref="AsyncDelegateCommand{T}"/>.</returns>
+        public AsyncDelegateCommand<T> Catch(Action<Exception> @catch)
+        {
+            return this;
+        }
+
+        async Task IAsyncCommand.ExecuteAsync(object parameter)
+        {
+            try
+            {
+                // If T is not nullable this may throw an exception
+                await Execute((T)parameter, _getCancellationToken());
+            }
+            catch (Exception ex)
+            {
+                throw;
+
+            }
+        }
+
+        async Task IAsyncCommand.ExecuteAsync(object parameter, CancellationToken cancellationToken)
+        {
+            try
+            {
+                // If T is not nullable this may throw an exception
+                await Execute((T)parameter, cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                throw;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Source/MAX.Framework/PrismExtension/Commands/IAsyncCommand.cs b/Source/MAX.Framework/PrismExtension/Commands/IAsyncCommand.cs
new file mode 100644
index 0000000..72a86cd
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Commands/IAsyncCommand.cs
@@ -0,0 +1,28 @@
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace Prism.Commands
+{
+
+    /// <summary>
+    /// Provides an abstraction layer for custom controls which want to make use of Async Commands
+    /// </summary>
+    public interface IAsyncCommand : ICommand
+    {
+        /// <summary>
+        /// Executes the Command with a specified parameter and the Default <see cref="CancellationToken"/>.
+        /// </summary>
+        /// <param name="parameter">The Command Parameter</param>
+        /// <returns>An Asynchronous Task</returns>
+        Task ExecuteAsync(object parameter);
+
+        /// <summary>
+        /// Executes the Command with a specified parameter and using a <see cref="CancellationToken"/>
+        /// </summary>
+        /// <param name="parameter">The Command Parameter</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
+        /// <returns>An Asynchronous Task</returns>
+        Task ExecuteAsync(object parameter, CancellationToken cancellationToken);
+    }
+}
\ No newline at end of file
diff --git a/Source/MAX.Framework/PrismExtension/Prism.Autofac/AutofacContainerExtension.cs b/Source/MAX.Framework/PrismExtension/Prism.Autofac/AutofacContainerExtension.cs
new file mode 100644
index 0000000..7223baa
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Prism.Autofac/AutofacContainerExtension.cs
@@ -0,0 +1,334 @@
+using Autofac;
+using Autofac.Core;
+using Autofac.Features.ResolveAnything;
+using MAX.Core;
+using MAX.Core.Autofac;
+using MAX.Core.DependencyInjection;
+using MAX.Core.Helpers;
+using MAX.Core.Infrastructure;
+using MAX.Core.Reflections;
+using MAX.Framework.Interfaces;
+using MAX.Framework.Prism.Autofac;
+using Prism.Ioc;
+using Prism.Ioc.Internals;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+
+namespace Prism.Autofac
+{
+	public class AutofacContainerExtension : IContainerExtension<IContainer>, IContainerInfo
+	{
+		private AutofacScopedProvider _currentScope;
+		public readonly ContainerBuilder Builder;
+
+		public IContainer Instance { get; private set; }
+
+		public IScopedProvider CurrentScope => _currentScope;
+		public AutofacContainerExtension()
+		{
+			Builder = new ContainerBuilder();
+			string currentContainer = "CurrentContainer";
+			Builder.RegisterInstance(this).Named(currentContainer, typeof(AutofacContainerExtension));
+			Builder.RegisterInstance(this).As<IContainerExtension>();
+			Builder.RegisterInstance(this).As<IContainerProvider>();
+			//设置过滤AOP
+			//IAspectConfiguration configuration = new AspectConfiguration();
+			//foreach (var item in AppTypeFinder.Assemblies)
+			//{
+			//    string _namespace = item.FullName;
+			//    if (!Regex.IsMatch(_namespace, "^MAX", RegexOptions.IgnoreCase | RegexOptions.Compiled))
+			//    {
+			//        configuration.NonAspectPredicates.AddNamespace(_namespace);
+			//    }
+			//}
+			//Builder.RegisterDynamicProxy(configuration);
+		}
+		public AutofacContainerExtension(ContainerBuilder builder)
+		{
+			Builder = builder;
+			string currentContainer = "CurrentContainer";
+			//Builder.RegisterDynamicProxy();
+			Builder.RegisterInstance(this).Named(currentContainer, typeof(AutofacContainerExtension));
+			Builder.RegisterInstance(this).As<IContainerExtension>();
+			Builder.RegisterInstance(this).As<IContainerProvider>();
+		}
+		public IScopedProvider CreateScope()
+		{
+			return CreateScopeInternal();
+		}
+		protected IScopedProvider CreateScopeInternal()
+		{
+			_currentScope = new AutofacScopedProvider(Instance);
+			return _currentScope;
+		}
+		public void FinalizeExtension()
+		{
+			if (Instance != null)
+			{
+				return;
+			}
+
+			Assembly[] assemblies = AppTypeFinder.Assemblies.ToArray();
+
+			// Make sure any not specifically registered concrete type can resolve.
+			IEnumerable<IStartup> startupList = ReflectionHelper.GetInstancesByInterface<IStartup>(assemblies);
+			int index = 1;
+			foreach (IStartup item in startupList.OrderByDescending(a => a.Priority))
+			{
+				Debug.WriteLine($"Startup - {index++} : {item.GetType()}");
+				item.Initialize();
+			}
+
+			// Make sure any not specifically registered concrete type can resolve.
+			IEnumerable<IDependencyRegistrar> ListDependency = ReflectionHelper.GetInstancesByInterface<IDependencyRegistrar>(assemblies);
+			foreach (IDependencyRegistrar item in ListDependency)
+			{
+				item.Register(Builder);
+			}
+
+			IEnumerable<IPreRegisterTypes> PreRegisterTypes = ReflectionHelper.GetInstancesByInterface<IPreRegisterTypes>(assemblies);
+			foreach (IPreRegisterTypes item in PreRegisterTypes)
+			{
+				item.RegisterTypes(this);
+			}
+
+			Builder.RegisterSource(new AnyConcreteTypeNotAlreadyRegisteredSource());
+			Instance = Builder.Build();
+			IocManager.SetContainer(Instance);
+
+		}
+
+		public bool IsRegistered(Type type)
+		{
+			return Instance.IsRegistered(type);
+		}
+
+		public bool IsRegistered(Type type, string name)
+		{
+			return Instance.IsRegisteredWithName(name, type);
+		}
+
+		public IContainerRegistry Register(Type from, Type to)
+		{
+			Builder.RegisterType(to).As(from);
+			return this;
+		}
+
+		public IContainerRegistry Register(Type from, Type to, string name)
+		{
+			Builder.RegisterType(to).Named(name, from);
+			return this;
+		}
+
+
+
+		public IContainerRegistry RegisterInstance(Type type, object instance)
+		{
+			Builder.RegisterInstance(instance).As(type);
+			return this;
+		}
+
+		public IContainerRegistry RegisterInstance(Type type, object instance, string name)
+		{
+			Builder.RegisterInstance(instance).Named(name, type);
+			return this;
+		}
+
+		public IContainerRegistry RegisterSingleton(Type from, Type to)
+		{
+			Builder.RegisterType(to).As(from).SingleInstance();
+			return this;
+		}
+
+		public IContainerRegistry RegisterSingleton(Type from, Type to, string name)
+		{
+			Builder.RegisterType(to).Named(name, from).SingleInstance();
+			return this;
+		}
+
+		public IContainerRegistry RegisterSingleton(Type type, Func<object> factoryMethod)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		public IContainerRegistry RegisterSingleton(Type type, Func<IContainerProvider, object> factoryMethod)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		public object Resolve(Type type)
+		{
+			return Instance.Resolve(type);
+		}
+
+		public object Resolve(Type type, params (Type Type, object Instance)[] parameters)
+		{
+			List<TypedParameter> listps = new List<TypedParameter>();
+			foreach ((Type Type, object Instance) item in parameters)
+			{
+				TypedParameter ps = new TypedParameter(item.Type, item.Instance);
+				listps.Add(ps);
+			}
+			return Instance.Resolve(type, listps);
+		}
+
+		public object Resolve(Type type, string name)
+		{
+			return Instance.ResolveNamed(name, type);
+		}
+
+		public object Resolve(Type type, string name, params (Type Type, object Instance)[] parameters)
+		{
+			List<TypedParameter> listps = new List<TypedParameter>();
+			foreach ((Type Type, object Instance) item in parameters)
+			{
+				TypedParameter ps = new TypedParameter(item.Type, item.Instance);
+				listps.Add(ps);
+			}
+			return Instance.ResolveNamed(name, type, listps);
+		}
+
+		public IContainerRegistry Register(Type type, Func<object> factoryMethod)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		public IContainerRegistry Register(Type type, Func<IContainerProvider, object> factoryMethod)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+		public IContainerRegistry RegisterMany(Type type, params Type[] serviceTypes)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		public IContainerRegistry RegisterManySingleton(Type type, params Type[] serviceTypes)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		public IContainerRegistry RegisterScoped(Type from, Type to)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		public IContainerRegistry RegisterScoped(Type type, Func<object> factoryMethod)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		public IContainerRegistry RegisterScoped(Type type, Func<IContainerProvider, object> factoryMethod)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		public Type GetRegistrationType(string key)
+		{
+			Type retType = null;
+			//First try friendly name registration. If not found, try type registration
+			foreach (IComponentRegistration registration in Instance.ComponentRegistry.Registrations)
+			{
+				//System.Diagnostics.Debug.WriteLine(registration.ToString());
+				foreach (Service service in registration.Services)
+				{
+					//System.Diagnostics.Debug.WriteLine(service.ToString());
+					if (service is KeyedService ks)
+					{
+						if (key.Equals(ks.ServiceKey.ToString(), StringComparison.Ordinal))
+						{
+							if (Instance.ComponentRegistry.TryGetServiceRegistration(service, out ServiceRegistration serviceRegistration))
+							{
+								retType = serviceRegistration.Registration.Target.Activator.LimitType;
+							}
+						}
+					}
+				}
+			}
+
+			//Instance.TryResolveService
+			//retType = Instance.ResolveNamed<object>(key).GetType();
+			if (retType == null)
+			{
+				retType = Instance.ResolveNamed<object>(key).GetType();
+				if (retType == null)
+				{
+					retType = typeof(System.Object);
+				}
+			}
+			return retType;
+		}
+
+		public Type GetRegistrationType(Type serviceType)
+		{
+			Debugger.Break();
+			throw new NotImplementedException();
+		}
+
+		private class AutofacScopedProvider : IScopedProvider
+		{
+			private readonly IContainer _container;
+
+			public bool IsAttached { get; set; }
+
+			public IScopedProvider CurrentScope => this;
+
+			public IScopedProvider CreateScope()
+			{
+				return this;
+			}
+			public AutofacScopedProvider(IContainer container)
+			{
+				_container = container;
+			}
+
+			public void Dispose()
+			{
+				_container.Dispose();
+			}
+
+			public object Resolve(Type type)
+			{
+				return _container.Resolve(type);
+			}
+
+			public object Resolve(Type type, params (Type Type, object Instance)[] parameters)
+			{
+				List<TypedParameter> listps = new List<TypedParameter>();
+				foreach ((Type Type, object Instance) item in parameters)
+				{
+					TypedParameter ps = new TypedParameter(item.Type, item.Instance);
+					listps.Add(ps);
+				}
+				return _container.Resolve(type, listps);
+			}
+
+			public object Resolve(Type type, string name)
+			{
+				return _container.ResolveNamed(name, type);
+			}
+
+			public object Resolve(Type type, string name, params (Type Type, object Instance)[] parameters)
+			{
+				List<TypedParameter> list = new List<TypedParameter>();
+				foreach ((Type Type, object Instance) item in parameters)
+				{
+					TypedParameter ps = new TypedParameter(item.Type, item.Instance);
+					list.Add(ps);
+				}
+				return _container.ResolveNamed(name, type, list);
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/Source/MAX.Framework/PrismExtension/Prism.Autofac/IAutofacContainerExtension.cs b/Source/MAX.Framework/PrismExtension/Prism.Autofac/IAutofacContainerExtension.cs
new file mode 100644
index 0000000..9428a2a
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Prism.Autofac/IAutofacContainerExtension.cs
@@ -0,0 +1,16 @@
+using Autofac;
+using Prism.Ioc;
+
+namespace Prism.Autofac
+{
+	/// <summary>
+	/// Provides customization extensions for Autofac Applications 
+	/// </summary>
+	public interface IAutofacContainerExtension : IContainerExtension<IContainer>
+	{
+		/// <summary>
+		/// Gets the <see cref="ContainerBuilder"/> used to register the services for the application
+		/// </summary>
+		ContainerBuilder Builder { get; }
+	}
+}
diff --git a/Source/MAX.Framework/PrismExtension/Prism.Autofac/IPreRegisterTypes.cs b/Source/MAX.Framework/PrismExtension/Prism.Autofac/IPreRegisterTypes.cs
new file mode 100644
index 0000000..3a0f748
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Prism.Autofac/IPreRegisterTypes.cs
@@ -0,0 +1,9 @@
+using Prism.Ioc;
+
+namespace MAX.Framework.Prism.Autofac
+{
+	public interface IPreRegisterTypes
+	{
+		void RegisterTypes(IContainerRegistry containerRegistry);
+	}
+}
diff --git a/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismApplication.cs b/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismApplication.cs
new file mode 100644
index 0000000..adf50e7
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismApplication.cs
@@ -0,0 +1,44 @@
+using Prism.Ioc;
+using System;
+using System.Windows;
+using AutofacCore = Autofac.Core;
+
+namespace Prism.Autofac
+{
+	/// <summary>
+	/// Base application class that uses <see cref="UnityContainerExtension"/> as it's container.
+	/// </summary>
+	public abstract class PrismApplication : PrismApplicationBase
+	{
+		/// <summary>
+		/// Create a new <see cref="UnityContainerExtension"/> used by Prism.
+		/// </summary>
+		/// <returns>A new <see cref="UnityContainerExtension"/>.</returns>
+		protected override IContainerExtension CreateContainerExtension()
+		{
+			return new AutofacContainerExtension();
+		}
+
+		/// <summary>
+		/// Registers the <see cref="Type"/>s of the Exceptions that are not considered 
+		/// root exceptions by the <see cref="ExceptionExtensions"/>.
+		/// </summary>
+		protected override void RegisterFrameworkExceptionTypes()
+		{
+			ExceptionExtensions.RegisterFrameworkExceptionType(typeof(AutofacCore.DependencyResolutionException));
+			ExceptionExtensions.RegisterFrameworkExceptionType(typeof(AutofacCore.Registration.ComponentNotRegisteredException));
+
+		}
+
+		protected override void Initialize()
+		{
+			base.Initialize();
+		}
+
+
+		protected override Window CreateShell()
+		{
+			return null;
+		}
+	}
+}
diff --git a/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismBootstrapper.cs b/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismBootstrapper.cs
new file mode 100644
index 0000000..b449cd1
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismBootstrapper.cs
@@ -0,0 +1,31 @@
+using Prism.Ioc;
+using System;
+using AutofacCore = Autofac.Core;
+
+namespace Prism.Autofac
+{
+	/// <summary>
+	/// Base bootstrapper class that uses <see cref="UnityContainerExtension"/> as it's container.
+	/// </summary>
+	public abstract class PrismBootstrapper : PrismBootstrapperBase
+	{
+		/// <summary>
+		/// Create a new <see cref="UnityContainerExtension"/> used by Prism.
+		/// </summary>
+		/// <returns>A new <see cref="UnityContainerExtension"/>.</returns>
+		protected override IContainerExtension CreateContainerExtension()
+		{
+			return new AutofacContainerExtension();
+		}
+
+		/// <summary>
+		/// Registers the <see cref="Type"/>s of the Exceptions that are not considered 
+		/// root exceptions by the <see cref="ExceptionExtensions"/>.
+		/// </summary>
+		protected override void RegisterFrameworkExceptionTypes()
+		{
+			ExceptionExtensions.RegisterFrameworkExceptionType(typeof(AutofacCore.DependencyResolutionException));
+			ExceptionExtensions.RegisterFrameworkExceptionType(typeof(AutofacCore.Registration.ComponentNotRegisteredException));
+		}
+	}
+}
diff --git a/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismIocExtensions.cs b/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismIocExtensions.cs
new file mode 100644
index 0000000..a0d99ac
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/Prism.Autofac/PrismIocExtensions.cs
@@ -0,0 +1,40 @@
+using Autofac;
+using Prism.Ioc;
+
+namespace Prism.Autofac
+{
+	/// <summary>
+	/// Extensions help get the underlying <see cref="IUnityContainer" />
+	/// </summary>
+	public static class PrismIocExtensions
+	{
+		/// <summary>
+		/// Gets the <see cref="IUnityContainer" /> from the <see cref="IContainerProvider" />
+		/// </summary>
+		/// <param name="containerProvider">The current <see cref="IContainerProvider" /></param>
+		/// <returns>The underlying <see cref="IUnityContainer" /></returns>
+		public static IContainer GetContainer(this IContainerProvider containerProvider)
+		{
+			return ((IContainerExtension<IContainer>)containerProvider).Instance;
+		}
+
+		/// <summary>
+		/// Gets the <see cref="IUnityContainer" /> from the <see cref="IContainerProvider" />
+		/// </summary>
+		/// <param name="containerRegistry">The current <see cref="IContainerRegistry" /></param>
+		/// <returns>The underlying <see cref="IUnityContainer" /></returns>
+		public static IContainer GetContainer(this IContainerRegistry containerRegistry)
+		{
+			return ((IContainerExtension<IContainer>)containerRegistry).Instance;
+		}
+		/// <summary>
+		/// Gets the <see cref="ContainerBuilder"/> used to register services.
+		/// </summary>
+		/// <param name="registry"></param>
+		/// <returns>The current <see cref="ContainerBuilder"/></returns>
+		public static ContainerBuilder GetBuilder(this IContainerRegistry registry)
+		{
+			return ((IAutofacContainerExtension)registry).Builder;
+		}
+	}
+}
diff --git a/Source/MAX.Framework/PrismExtension/RegionManagerExtension.cs b/Source/MAX.Framework/PrismExtension/RegionManagerExtension.cs
new file mode 100644
index 0000000..65dc602
--- /dev/null
+++ b/Source/MAX.Framework/PrismExtension/RegionManagerExtension.cs
@@ -0,0 +1,35 @@
+using Prism.Regions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using Autofac;
+using Autofac.Core;
+using System.Windows.Input;
+using MAX.Core.DependencyInjection;
+namespace MAX.Framework.PrismExtension;
+public static class RegionManagerExtension
+{
+	public static FrameworkElement GetView(this IRegionManager regionManager, string regionName, string target)
+	{
+		var region = regionManager.Regions[regionName];
+		if (region != null)
+		{
+
+			var viewType = IocManager.GetRegistrationType(target);
+			foreach (var viewItem in region.Views)
+			{
+				if (viewItem.GetType() == viewType)
+				{
+					if (viewItem is FrameworkElement fk)
+					{
+						return fk;
+					}
+				}
+			}			
+		}
+		return null;
+	}
+}
diff --git a/Source/MAX.Framework/Startup.cs b/Source/MAX.Framework/Startup.cs
new file mode 100644
index 0000000..9f62d49
--- /dev/null
+++ b/Source/MAX.Framework/Startup.cs
@@ -0,0 +1,61 @@
+using Autofac;
+using MAX.Core;
+using MAX.Core.Autofac;
+using MAX.Core.DependencyInjection;
+using MAX.Core.Infrastructure;
+using MAX.Core.Logger;
+using MAX.Core.Reflections;
+using MAX.Framework.Logger;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+
+namespace MAX.Framework;
+
+public class Startup : IStartup
+{
+	public int Priority => int.MaxValue - 1;
+
+	public void Initialize()
+	{
+
+	}
+
+	public void Register(ContainerBuilder builder)
+	{
+		#region 注册所有IOC接口
+
+		Assembly[] assemblies = AppTypeFinder.Assemblies.ToArray();
+
+		Type typeSingleton = typeof(ISingletonDependency);
+		builder.RegisterAssemblyTypes(assemblies)
+			.Where(a =>
+				typeSingleton.IsAssignableFrom(a)
+				&& a.IsClass
+				&& !a.IsAbstract
+			)
+			.AsImplementedInterfaces()
+			.AsSelf()
+			.PropertiesAutowired(new CustomPropertySelector())
+			.SingleInstance();
+
+
+		Type typeTransient = typeof(ITransientDependency);
+		builder.RegisterAssemblyTypes(assemblies)
+			.Where(a =>
+				typeTransient.IsAssignableFrom(a)
+				&& a.IsClass
+				&& !a.IsAbstract
+			)
+			.AsImplementedInterfaces()
+			.AsSelf()
+			.PropertiesAutowired(new CustomPropertySelector())
+			.InstancePerDependency();
+
+
+		#endregion
+
+	}
+}
diff --git a/Source/Trade.Client/APIs/CommonApi.cs b/Source/Trade.Client/APIs/CommonApi.cs
new file mode 100644
index 0000000..df59b5e
--- /dev/null
+++ b/Source/Trade.Client/APIs/CommonApi.cs
@@ -0,0 +1,90 @@
+using LittleCow.Core.Helpers;
+using LittleCow.Server.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using Trade.Client.Helpers;
+using Trade.Client.HttpExtension;
+
+namespace Trade.Client.APIs
+{
+	/// <summary>
+	/// 公共基础数据Api
+	/// </summary>
+	internal class CommonApi : ServerReqeustBase
+	{
+		/// <summary>
+		/// 获取服务器时间校准时间
+		/// </summary>
+		public DateTime GetServerTime()
+		{
+			HttpResult result = ServerRequest(new ServerHttpItem { URL = $"{_config.Host}/time.php", IsSign = true });
+			if (result.StatusCode == HttpStatusCode.OK)
+			{
+				if (DateTime.TryParse(result.Html, out DateTime dt))
+				{
+					return dt;
+				}
+				else
+				{
+					throw new Exception("连接服务器失败，将导致无法登录");
+				}
+
+			}
+			return DateTime.Now;
+		}
+
+		/// <summary>
+		/// 获取签名验证配置
+		/// </summary>
+		public string GetAuthConfig()
+		{
+			ServerHttpItem item = new ServerHttpItem();
+			item.URL = $"{_config.Host}?obj=api/config&act=auth_config";
+			HttpResult result = ServerRequest(item);
+			if (result.StatusCode == HttpStatusCode.OK)
+			{
+				return result.Html;
+			}
+			return "";
+		}
+
+		/// <summary>
+		/// 获取服务器图片缓存
+		/// </summary>
+		/// <param name="imgUrl"></param>
+		/// <returns></returns>
+		public HttpResult GetImageCache(string imgUrl)
+		{
+			long id = 123;//BaseClass.GetLong(imgUrl);
+			ServerHttpItem item = new ServerHttpItem();
+			item.Method = MethodType.Post;
+			item.URL = BuildObjString("add_img");
+			item.Postdata = "act=get&table=" + Math.Abs(id % 1024) + "&id=" + id;
+			item.SignUser();
+			return ServerRequest(item);
+		}
+
+
+		/// <summary>
+		/// 获取缓存服务集群负载比例
+		/// </summary>
+		public string GetCacheServerRatio()
+		{
+
+			ServerHttpItem item = new ServerHttpItem();
+			item.URL = BuildObjString("config&act=cache_service_mode");
+			item.Method = MethodType.Post;
+			item.SignUser();
+			HttpResult result = ServerRequest(item);
+			if (result.StatusCode == HttpStatusCode.OK)
+			{
+				return result.Html;
+			}
+			return "";
+		}
+	}
+}
diff --git a/Source/Trade.Client/Helpers/HttpHelper.cs b/Source/Trade.Client/Helpers/HttpHelper.cs
new file mode 100644
index 0000000..0798e21
--- /dev/null
+++ b/Source/Trade.Client/Helpers/HttpHelper.cs
@@ -0,0 +1,1395 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Net;
+using System.Net.Security;
+using System.Security.Cryptography;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace Trade.Client.Helpers
+{
+
+	/// <summary>
+	/// Http连接操作帮助类
+	/// </summary>
+	public class HttpHelper
+	{
+		public static HttpResult Get(string Url)
+		{
+			return new HttpHelper().GetHtml(new HttpItem
+			{
+				URL = Url,
+				Method = MethodType.Get,
+			});
+		}
+
+		public static HttpResult Post(string Url, string PostData)
+		{
+			return new HttpHelper().GetHtml(new HttpItem
+			{
+				URL = Url,
+				Method = MethodType.Get,
+				Postdata = PostData,
+				PostDataType = PostDataType.String
+			});
+		}
+		public static HttpResult Request(HttpItem item)
+		{
+			return new HttpHelper().GetHtml(item);
+		}
+
+		#region 异步方法
+
+		/// <summary>
+		/// 异步Get请求
+		/// </summary>
+		public static Task<HttpResult> GetAsync(string Url)
+		{
+			return new HttpHelper().GetHtmlAsync(new HttpItem
+			{
+				URL = Url,
+				Method = MethodType.Get,
+			});
+		}
+
+		/// <summary>
+		/// 异步Post请求
+		/// </summary>
+		public static Task<HttpResult> PostAsync(string Url, string PostData)
+		{
+			return new HttpHelper().GetHtmlAsync(new HttpItem
+			{
+				URL = Url,
+				Method = MethodType.Post,
+				Postdata = PostData,
+				PostDataType = PostDataType.String
+			});
+		}
+
+		/// <summary>
+		/// 异步执行请求
+		/// </summary>
+		public static Task<HttpResult> RequestAsync(HttpItem item)
+		{
+			return new HttpHelper().GetHtmlAsync(item);
+		}
+
+		/// <summary>
+		/// 异步下载文件
+		/// </summary>
+		/// <param name="address"></param>
+		public static async Task<byte[]> DownloadFileAsync(string address)
+		{
+			HttpItem item = new HttpItem();
+			item.URL = address;
+			item.Timeout = 3000;
+			item.ResultType = ResultType.Byte;
+			HttpHelper http = new HttpHelper();
+			HttpResult result = await http.GetHtmlAsync(item);
+			if (result.StatusCode == HttpStatusCode.OK)
+			{
+				return result.ResultByte;
+			}
+			else
+			{
+				throw new HttpListenerException((int)result.StatusCode, result.StatusDescription);
+			}
+		}
+
+		/// <summary>
+		/// 异步下载文件并保存到本地
+		/// </summary>
+		/// <param name="address"></param>
+		/// <param name="fileName"></param>
+		public static async Task<bool> DownloadFileAsync(string address, string fileName)
+		{
+			HttpItem item = new HttpItem();
+			item.URL = address;
+			item.Timeout = 3000;
+			item.ResultType = ResultType.Byte;
+			HttpHelper http = new HttpHelper();
+			HttpResult result = await http.GetHtmlAsync(item);
+			if (result.StatusCode == HttpStatusCode.OK)
+			{
+				using (FileStream fs = new FileStream(fileName, FileMode.CreateNew))
+				{
+					await fs.WriteAsync(result.ResultByte, 0, result.ResultByte.Length);
+				}
+			}
+			else
+			{
+				throw new HttpListenerException((int)result.StatusCode, result.StatusDescription);
+			}
+
+			return true;
+		}
+
+		#endregion
+
+		/// <summary>
+		/// 下载文件
+		/// </summary>
+		/// <param name="address"></param>
+		/// <param name="fileName"></param>
+		public static byte[] DownloadFile(string address)
+		{
+			HttpItem item = new HttpItem();
+			item.URL = address;
+			item.Timeout = 3000;
+			item.ResultType = ResultType.Byte;
+			HttpHelper http = new HttpHelper();
+			HttpResult result = http.GetHtml(item);
+			if (result.StatusCode == HttpStatusCode.OK)
+			{
+				return result.ResultByte;
+			}
+			else
+			{
+				throw new HttpListenerException((int)result.StatusCode, result.StatusDescription);
+			}
+		}
+
+		/// <summary>
+		/// 下载文件
+		/// </summary>
+		/// <param name="address"></param>
+		/// <param name="fileName"></param>
+		public static bool DownloadFile(string address, string fileName)
+		{
+			HttpItem item = new HttpItem();
+			item.URL = address;
+			item.Timeout = 3000;
+			item.ResultType = ResultType.Byte;
+			HttpHelper http = new HttpHelper();
+			HttpResult result = http.GetHtml(item);
+			if (result.StatusCode == HttpStatusCode.OK)
+			{
+				FileStream fs = new FileStream(fileName, FileMode.CreateNew);
+				BinaryWriter bw = new BinaryWriter(fs);
+				bw.Write(result.ResultByte);
+				fs.Close();
+				bw.Close();
+			}
+			else
+			{
+				throw new HttpListenerException((int)result.StatusCode, result.StatusDescription);
+			}
+
+			return true;
+		}
+
+		#region 预定义方法或者变更
+		//默认的编码
+		private Encoding encoding = Encoding.Default;
+		//Post数据编码
+		private Encoding postencoding = Encoding.Default;
+		//HttpWebRequest对象用来发起请求
+		private HttpWebRequest request = null;
+		//获取影响流的数据对象
+		private HttpWebResponse response = null;
+		/// <summary>
+		/// 根据相传入的数据，得到相应页面数据
+		/// </summary>
+		/// <param name="item">参数类对象</param>
+		/// <returns>返回HttpResult类型</returns>
+		public HttpResult GetHtml(HttpItem item)
+		{
+			//返回参数
+			HttpResult result = new HttpResult();
+			result.item = item;
+			try
+			{
+				//准备参数
+				SetRequest(item);
+			}
+			catch (Exception ex)
+			{
+				result = new HttpResult();
+				result.Cookie = string.Empty;
+				result.Header = null;
+				result.Html = ex.Message;
+				result.StatusDescription = "配置参数时出错：" + ex.Message;
+				return result;
+			}
+			try
+			{
+				#region 得到请求的response
+				using (response = (HttpWebResponse)request.GetResponse())
+				{
+					result.StatusCode = response.StatusCode;
+					result.StatusDescription = response.StatusDescription;
+					result.Header = response.Headers;
+					if (response.Cookies != null) result.CookieCollection = response.Cookies;
+					if (response.Headers["set-cookie"] != null) result.Cookie = response.Headers["set-cookie"];
+					MemoryStream _stream = new MemoryStream();
+					//GZIIP处理
+					if (response.ContentEncoding != null && response.ContentEncoding.Equals("gzip", StringComparison.InvariantCultureIgnoreCase))
+					{
+						//开始读取流并设置编码方式
+						//new GZipStream(response.GetResponseStream(), CompressionMode.Decompress).CopyTo(_stream, 10240);
+						//.net4.0以下写法
+						_stream = GetMemoryStream(new GZipStream(response.GetResponseStream(), CompressionMode.Decompress));
+
+					}
+					else
+					{
+						//开始读取流并设置编码方式
+						//response.GetResponseStream().CopyTo(_stream, 10240);
+						//.net4.0以下写法
+						_stream = GetMemoryStream(response.GetResponseStream());
+					}
+					//获取Byte
+					byte[] ResponseByte = _stream.ToArray();
+					_stream.Close();
+					if (ResponseByte != null & ResponseByte.Length > 0)
+					{
+						//是否返回Byte类型数据
+						if (item.ResultType == ResultType.Byte) result.ResultByte = ResponseByte;
+						//从这里开始我们要无视编码了
+						if (encoding == null)
+						{
+							Match meta = Regex.Match(Encoding.Default.GetString(ResponseByte), "<meta([^<]*)charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
+							string c = (meta.Groups.Count > 1) ? meta.Groups[2].Value.ToLower().Trim() : string.Empty;
+							if (c.Length > 2)
+							{
+								try
+								{
+									if (c.IndexOf(" ") > 0) c = c.Substring(0, c.IndexOf(" "));
+									encoding = Encoding.GetEncoding(c.Replace("\"", "").Replace("'", "").Replace(";", "").Replace("iso-8859-1", "gbk").Trim());
+								}
+								catch
+								{
+									if (string.IsNullOrEmpty(response.CharacterSet)) encoding = Encoding.UTF8;
+									else encoding = Encoding.GetEncoding(response.CharacterSet);
+								}
+							}
+							else
+							{
+								if (string.IsNullOrEmpty(response.CharacterSet)) encoding = Encoding.UTF8;
+								else encoding = Encoding.GetEncoding(response.CharacterSet);
+							}
+						}
+						//得到返回的HTML
+						result.Html = encoding.GetString(ResponseByte);
+					}
+					else
+					{
+						//得到返回的HTML
+						result.Html = "本次请求并未返回任何数据";
+					}
+				}
+				#endregion
+			}
+			catch (WebException ex)
+			{
+				//这里是在发生异常时返回的错误信息
+				response = (HttpWebResponse)ex.Response;
+				result.Html = ex.Message;
+				if (response != null)
+				{
+					result.StatusCode = response.StatusCode;
+					result.StatusDescription = response.StatusDescription;
+				}
+			}
+			catch (Exception ex)
+			{
+				result.Html = ex.Message;
+			}
+			if (item.IsToLower) result.Html = result.Html.ToLower();
+			return result;
+		}
+
+		/// <summary>
+		/// 根据相传入的数据，异步得到相应页面数据
+		/// </summary>
+		/// <param name="item">参数类对象</param>
+		/// <returns>返回HttpResult类型</returns>
+		public async Task<HttpResult> GetHtmlAsync(HttpItem item)
+		{
+			//返回参数
+			HttpResult result = new HttpResult();
+			result.item = item;
+			try
+			{
+				//准备参数（不在此处同步写入Post数据，改为异步写入）
+				SetRequest(item, false);
+				await SetPostDataAsync(item);
+			}
+			catch (Exception ex)
+			{
+				result = new HttpResult();
+				result.Cookie = string.Empty;
+				result.Header = null;
+				result.Html = ex.Message;
+				result.StatusDescription = "配置参数时出错：" + ex.Message;
+				return result;
+			}
+			try
+			{
+				#region 得到请求的response
+				using (response = (HttpWebResponse)await request.GetResponseAsync())
+				{
+					result.StatusCode = response.StatusCode;
+					result.StatusDescription = response.StatusDescription;
+					result.Header = response.Headers;
+					if (response.Cookies != null) result.CookieCollection = response.Cookies;
+					if (response.Headers["set-cookie"] != null) result.Cookie = response.Headers["set-cookie"];
+					MemoryStream _stream;
+					//GZIIP处理
+					if (response.ContentEncoding != null && response.ContentEncoding.Equals("gzip", StringComparison.InvariantCultureIgnoreCase))
+					{
+						_stream = await GetMemoryStreamAsync(new GZipStream(response.GetResponseStream(), CompressionMode.Decompress));
+					}
+					else
+					{
+						_stream = await GetMemoryStreamAsync(response.GetResponseStream());
+					}
+					//获取Byte
+					byte[] ResponseByte = _stream.ToArray();
+					_stream.Close();
+					if (ResponseByte != null & ResponseByte.Length > 0)
+					{
+						//是否返回Byte类型数据
+						if (item.ResultType == ResultType.Byte) result.ResultByte = ResponseByte;
+						//从这里开始我们要无视编码了
+						if (encoding == null)
+						{
+							Match meta = Regex.Match(Encoding.Default.GetString(ResponseByte), "<meta([^<]*)charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
+							string c = (meta.Groups.Count > 1) ? meta.Groups[2].Value.ToLower().Trim() : string.Empty;
+							if (c.Length > 2)
+							{
+								try
+								{
+									if (c.IndexOf(" ") > 0) c = c.Substring(0, c.IndexOf(" "));
+									encoding = Encoding.GetEncoding(c.Replace("\"", "").Replace("'", "").Replace(";", "").Replace("iso-8859-1", "gbk").Trim());
+								}
+								catch
+								{
+									if (string.IsNullOrEmpty(response.CharacterSet)) encoding = Encoding.UTF8;
+									else encoding = Encoding.GetEncoding(response.CharacterSet);
+								}
+							}
+							else
+							{
+								if (string.IsNullOrEmpty(response.CharacterSet)) encoding = Encoding.UTF8;
+								else encoding = Encoding.GetEncoding(response.CharacterSet);
+							}
+						}
+						//得到返回的HTML
+						result.Html = encoding.GetString(ResponseByte);
+					}
+					else
+					{
+						//得到返回的HTML
+						result.Html = "本次请求并未返回任何数据";
+					}
+				}
+				#endregion
+			}
+			catch (WebException ex)
+			{
+				//这里是在发生异常时返回的错误信息
+				response = (HttpWebResponse)ex.Response;
+				result.Html = ex.Message;
+				if (response != null)
+				{
+					result.StatusCode = response.StatusCode;
+					result.StatusDescription = response.StatusDescription;
+				}
+			}
+			catch (Exception ex)
+			{
+				result.Html = ex.Message;
+			}
+			if (item.IsToLower) result.Html = result.Html.ToLower();
+			return result;
+		}
+
+		/// <summary>
+		/// 4.0以下.net版本取数据使用
+		/// </summary>
+		/// <param name="streamResponse">流</param>
+		private MemoryStream GetMemoryStream(Stream streamResponse)
+		{
+			MemoryStream _stream = new MemoryStream();
+			int Length = 256;
+			Byte[] buffer = new Byte[Length];
+			int bytesRead = streamResponse.Read(buffer, 0, Length);
+			while (bytesRead > 0)
+			{
+				_stream.Write(buffer, 0, bytesRead);
+				bytesRead = streamResponse.Read(buffer, 0, Length);
+			}
+			return _stream;
+		}
+
+		/// <summary>
+		/// 异步读取流数据
+		/// </summary>
+		/// <param name="streamResponse">流</param>
+		private async Task<MemoryStream> GetMemoryStreamAsync(Stream streamResponse)
+		{
+			MemoryStream _stream = new MemoryStream();
+			await streamResponse.CopyToAsync(_stream);
+			return _stream;
+		}
+		/// <summary>
+		/// 为请求准备参数
+		/// </summary>
+		///<param name="item">参数列表</param>
+		private void SetRequest(HttpItem item)
+		{
+			SetRequest(item, true);
+		}
+
+		/// <summary>
+		/// 为请求准备参数
+		/// </summary>
+		/// <param name="item">参数列表</param>
+		/// <param name="setPostDataSync">是否在此处同步写入Post数据。异步调用时传入false，改由调用方await SetPostDataAsync写入</param>
+		private void SetRequest(HttpItem item, bool setPostDataSync)
+		{
+			// 验证证书
+			SetCer(item);
+			//设置Header参数
+			if (item.Header != null && item.Header.Count > 0) foreach (string key in item.Header.AllKeys)
+			{
+				request.Headers.Add(key, item.Header[key]);
+			}
+			// 设置代理
+			SetProxy(item);
+			if (item.ProtocolVersion != null) request.ProtocolVersion = item.ProtocolVersion;
+			request.ServicePoint.Expect100Continue = item.Expect100Continue;
+			//请求方式Get或者Post
+			request.Method = item.Method.ToString();
+			request.Timeout = item.Timeout;
+			request.KeepAlive = item.KeepAlive;
+			request.ReadWriteTimeout = item.ReadWriteTimeout;
+			//Accept
+			request.Accept = item.Accept;
+			//ContentType返回类型
+			request.ContentType = item.ContentType;
+			//UserAgent客户端的访问类型，包括浏览器版本和操作系统信息
+			request.UserAgent = item.UserAgent;
+			// 编码
+			encoding = item.Encoding;
+			//设置安全凭证
+			request.Credentials = item.ICredentials;
+			//设置Cookie
+			SetCookie(item);
+			//来源地址
+			request.Referer = item.Referer;
+			//是否执行跳转功能
+			request.AllowAutoRedirect = item.Allowautoredirect;
+			//设置JWT Bearer Token（Authorization: Bearer xxx）
+			SetJwt(item);
+			//设置Post数据
+			if (setPostDataSync) SetPostData(item);
+			//设置最大连接
+			if (item.Connectionlimit > 0) request.ServicePoint.ConnectionLimit = item.Connectionlimit;
+		}
+
+		/// <summary>
+		/// 设置JWT令牌到请求头（Authorization: Bearer {JwtToken}）
+		/// 如果同时设置了AuthorizationHeaderScheme，则使用自定义的方案名代替Bearer
+		/// </summary>
+		/// <param name="item">Http参数</param>
+		private void SetJwt(HttpItem item)
+		{
+			if (!string.IsNullOrEmpty(item.JwtToken))
+			{
+				string scheme = string.IsNullOrEmpty(item.AuthorizationScheme) ? "Bearer" : item.AuthorizationScheme;
+				request.Headers[HttpRequestHeader.Authorization] = $"{scheme} {item.JwtToken}";
+			}
+		}
+		/// <summary>
+		/// 设置证书
+		/// </summary>
+		/// <param name="item"></param>
+		private void SetCer(HttpItem item)
+		{
+			if (!string.IsNullOrEmpty(item.CerPath))
+			{
+				//这一句一定要写在创建连接的前面。使用回调的方法进行证书验证。
+				ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(CheckValidationResult);
+				//初始化对像，并设置请求的URL地址
+				request = (HttpWebRequest)WebRequest.Create(item.URL);
+				SetCerList(item);
+				//将证书添加到请求里
+				request.ClientCertificates.Add(new X509Certificate(item.CerPath));
+			}
+			else
+			{
+				//初始化对像，并设置请求的URL地址
+				request = (HttpWebRequest)WebRequest.Create(item.URL);
+				SetCerList(item);
+			}
+		}
+		/// <summary>
+		/// 设置多个证书
+		/// </summary>
+		/// <param name="item"></param>
+		private void SetCerList(HttpItem item)
+		{
+			if (item.ClentCertificates != null && item.ClentCertificates.Count > 0)
+			{
+				foreach (X509Certificate c in item.ClentCertificates)
+				{
+					request.ClientCertificates.Add(c);
+				}
+			}
+		}
+		/// <summary>
+		/// 设置Cookie
+		/// </summary>
+		/// <param name="item">Http参数</param>
+		private void SetCookie(HttpItem item)
+		{
+			if (!string.IsNullOrEmpty(item.Cookie)) request.Headers[HttpRequestHeader.Cookie] = item.Cookie;
+			//设置CookieCollection
+			if (item.ResultCookieType == ResultCookieType.CookieCollection)
+			{
+				request.CookieContainer = new CookieContainer();
+				if (item.CookieCollection != null && item.CookieCollection.Count > 0)
+					request.CookieContainer.Add(item.CookieCollection);
+			}
+		}
+		/// <summary>
+		/// 设置Post数据
+		/// </summary>
+		/// <param name="item">Http参数</param>
+		private void SetPostData(HttpItem item)
+		{
+			//验证在得到结果时是否有传入数据
+			if (request.Method.Trim().ToLower().Contains("post"))
+			{
+				byte[] buffer = GetPostBuffer(item);
+				if (buffer != null)
+				{
+					request.ContentLength = buffer.Length;
+					request.GetRequestStream().Write(buffer, 0, buffer.Length);
+				}
+			}
+		}
+
+		/// <summary>
+		/// 异步设置Post数据
+		/// </summary>
+		/// <param name="item">Http参数</param>
+		private async Task SetPostDataAsync(HttpItem item)
+		{
+			//验证在得到结果时是否有传入数据
+			if (request.Method.Trim().ToLower().Contains("post"))
+			{
+				byte[] buffer = GetPostBuffer(item);
+				if (buffer != null)
+				{
+					request.ContentLength = buffer.Length;
+					using (Stream stream = await request.GetRequestStreamAsync())
+					{
+						await stream.WriteAsync(buffer, 0, buffer.Length);
+					}
+				}
+			}
+		}
+
+		/// <summary>
+		/// 根据HttpItem的PostDataType构建要发送的Post数据字节数组
+		/// </summary>
+		/// <param name="item">Http参数</param>
+		private byte[] GetPostBuffer(HttpItem item)
+		{
+			if (item.PostEncoding != null)
+			{
+				postencoding = item.PostEncoding;
+			}
+			byte[] buffer = null;
+			//写入Byte类型
+			if (item.PostDataType == PostDataType.Byte && item.PostdataByte != null && item.PostdataByte.Length > 0)
+			{
+				//验证在得到结果时是否有传入数据
+				buffer = item.PostdataByte;
+			}//写入文件
+			else if (item.PostDataType == PostDataType.FilePath && !string.IsNullOrEmpty(item.Postdata))
+			{
+				using (StreamReader r = new StreamReader(item.Postdata, postencoding))
+				{
+					buffer = postencoding.GetBytes(r.ReadToEnd());
+				}
+			} //写入字符串
+			else if (!string.IsNullOrEmpty(item.Postdata))
+			{
+				buffer = postencoding.GetBytes(item.Postdata);
+			}
+			return buffer;
+		}
+		/// <summary>
+		/// 设置代理
+		/// </summary>
+		/// <param name="item">参数对象</param>
+		private void SetProxy(HttpItem item)
+		{
+			bool isIeProxy = item.ProxyIp.ToLower().Contains("ieproxy");
+			if (!string.IsNullOrEmpty(item.ProxyIp) && !isIeProxy)
+			{
+				//设置代理服务器
+				if (item.ProxyIp.Contains(":"))
+				{
+					string[] plist = item.ProxyIp.Split(':');
+					WebProxy myProxy = new WebProxy(plist[0].Trim(), Convert.ToInt32(plist[1].Trim()));
+					//建议连接
+					myProxy.Credentials = new NetworkCredential(item.ProxyUserName, item.ProxyPwd);
+					//给当前请求对象
+					request.Proxy = myProxy;
+				}
+				else
+				{
+					WebProxy myProxy = new WebProxy(item.ProxyIp, false);
+					//建议连接
+					myProxy.Credentials = new NetworkCredential(item.ProxyUserName, item.ProxyPwd);
+					//给当前请求对象
+					request.Proxy = myProxy;
+				}
+			}
+			else if (isIeProxy)
+			{
+				//设置为IE代理
+			}
+			else
+			{
+				request.Proxy = item.WebProxy;
+			}
+		}
+		/// <summary>
+		/// 回调验证证书问题
+		/// </summary>
+		/// <param name="sender">流对象</param>
+		/// <param name="certificate">证书</param>
+		/// <param name="chain">X509Chain</param>
+		/// <param name="errors">SslPolicyErrors</param>
+		/// <returns>bool</returns>
+		public bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) { return true; }
+		#endregion
+	}
+	/// <summary>
+	/// Http请求参考类
+	/// </summary>
+	public class HttpItem
+	{
+		string _URL = string.Empty;
+		/// <summary>
+		/// 请求URL必须填写
+		/// </summary>
+		public string URL
+		{
+			get { return _URL; }
+			set { _URL = value; }
+		}
+		MethodType _Method = MethodType.Get;
+		/// <summary>
+		/// 请求方式默认为GET方式,当为POST方式时必须设置Postdata的值
+		public MethodType Method
+		/// </summary>
+		{
+			get { return _Method; }
+			set
+			{
+				_Method = value;
+				if (_Method == MethodType.Post)
+				{
+					_ContentType = "application/x-www-form-urlencoded";
+				}
+			}
+		}
+		int _Timeout = 100000;
+		/// <summary>
+		/// 默认请求超时时间
+		/// </summary>
+		public int Timeout
+		{
+			get { return _Timeout; }
+			set { _Timeout = value; }
+		}
+		int _ReadWriteTimeout = 30000;
+		/// <summary>
+		/// 默认写入Post数据超时间
+		/// </summary>
+		public int ReadWriteTimeout
+		{
+			get { return _ReadWriteTimeout; }
+			set { _ReadWriteTimeout = value; }
+		}
+		Boolean _KeepAlive = true;
+		/// <summary>
+		///  获取或设置一个值，该值指示是否与 Internet 资源建立持久性连接默认为true。
+		/// </summary>
+		public Boolean KeepAlive
+		{
+			get { return _KeepAlive; }
+			set { _KeepAlive = value; }
+		}
+		string _Accept = "text/html, application/xhtml+xml, */*";
+		/// <summary>
+		/// 请求标头值 默认为text/html, application/xhtml+xml, */*
+		/// </summary>
+		public string Accept
+		{
+			get { return _Accept; }
+			set { _Accept = value; }
+		}
+		string _ContentType = "text/html";
+		/// <summary>
+		/// 请求返回类型默认 text/html
+		/// </summary>
+		public string ContentType
+		{
+			get { return _ContentType; }
+			set { _ContentType = value; }
+		}
+		string _UserAgent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)";
+		/// <summary>
+		/// 客户端访问信息默认Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)
+		/// </summary>
+		public string UserAgent
+		{
+			get { return _UserAgent; }
+			set { _UserAgent = value; }
+		}
+		Encoding _Encoding = null;
+		/// <summary>
+		/// 返回数据编码默认为NUll,可以自动识别,一般为utf-8,gbk,gb2312
+		/// </summary>
+		public Encoding Encoding
+		{
+			get { return _Encoding; }
+			set { _Encoding = value; }
+		}
+		private PostDataType _PostDataType = PostDataType.String;
+		/// <summary>
+		/// Post的数据类型
+		/// </summary>
+		public PostDataType PostDataType
+		{
+			get { return _PostDataType; }
+			set { _PostDataType = value; }
+		}
+		string _Postdata = string.Empty;
+		/// <summary>
+		/// Post请求时要发送的字符串Post数据
+		/// </summary>
+		public string Postdata
+		{
+			get { return _Postdata; }
+			set { _Postdata = value; }
+		}
+		private byte[] _PostdataByte = null;
+		/// <summary>
+		/// Post请求时要发送的Byte类型的Post数据
+		/// </summary>
+		public byte[] PostdataByte
+		{
+			get { return _PostdataByte; }
+			set { _PostdataByte = value; }
+		}
+		private WebProxy _WebProxy;
+		/// <summary>
+		/// 设置代理对象，不想使用IE默认配置就设置为Null，而且不要设置ProxyIp
+		/// </summary>
+		public WebProxy WebProxy
+		{
+			get { return _WebProxy; }
+			set { _WebProxy = value; }
+		}
+
+		CookieCollection cookiecollection = null;
+		/// <summary>
+		/// Cookie对象集合
+		/// </summary>
+		public CookieCollection CookieCollection
+		{
+			get { return cookiecollection; }
+			set { cookiecollection = value; }
+		}
+		string _Cookie = string.Empty;
+		/// <summary>
+		/// 请求时的Cookie
+		/// </summary>
+		public string Cookie
+		{
+			get { return _Cookie; }
+			set { _Cookie = value; }
+		}
+		string _Referer = string.Empty;
+		/// <summary>
+		/// 来源地址，上次访问地址
+		/// </summary>
+		public string Referer
+		{
+			get { return _Referer; }
+			set { _Referer = value; }
+		}
+		string _CerPath = string.Empty;
+		/// <summary>
+		/// 证书绝对路径
+		/// </summary>
+		public string CerPath
+		{
+			get { return _CerPath; }
+			set { _CerPath = value; }
+		}
+		private Boolean isToLower = false;
+		/// <summary>
+		/// 是否设置为全文小写，默认为不转化
+		/// </summary>
+		public Boolean IsToLower
+		{
+			get { return isToLower; }
+			set { isToLower = value; }
+		}
+		private string _JwtToken = string.Empty;
+		/// <summary>
+		/// JWT令牌（不含Bearer前缀），设置后会自动添加到请求头 Authorization: Bearer {JwtToken}
+		/// </summary>
+		public string JwtToken
+		{
+			get { return _JwtToken; }
+			set { _JwtToken = value; }
+		}
+		private string _AuthorizationScheme = "Bearer";
+		/// <summary>
+		/// Authorization请求头的方案名，默认为Bearer，一般无需修改
+		/// </summary>
+		public string AuthorizationScheme
+		{
+			get { return _AuthorizationScheme; }
+			set { _AuthorizationScheme = value; }
+		}
+		private Boolean allowautoredirect = true;
+		/// <summary>
+		/// 支持跳转页面，查询结果将是跳转后的页面
+		/// </summary>
+		public Boolean Allowautoredirect
+		{
+			get { return allowautoredirect; }
+			set { allowautoredirect = value; }
+		}
+		private int connectionlimit = 1024;
+		/// <summary>
+		/// 最大连接数
+		/// </summary>
+		public int Connectionlimit
+		{
+			get { return connectionlimit; }
+			set { connectionlimit = value; }
+		}
+		private string proxyusername = string.Empty;
+		/// <summary>
+		/// 代理Proxy 服务器用户名
+		/// </summary>
+		public string ProxyUserName
+		{
+			get { return proxyusername; }
+			set { proxyusername = value; }
+		}
+		private string proxypwd = string.Empty;
+		/// <summary>
+		/// 代理 服务器密码
+		/// </summary>
+		public string ProxyPwd
+		{
+			get { return proxypwd; }
+			set { proxypwd = value; }
+		}
+		private string proxyip = string.Empty;
+		/// <summary>
+		/// 代理 服务IP ,如果要使用IE代理就设置为ieproxy
+		/// </summary>
+		public string ProxyIp
+		{
+			get { return proxyip; }
+			set { proxyip = value; }
+		}
+		private ResultType resulttype = ResultType.String;
+		/// <summary>
+		/// 设置返回类型String和Byte
+		/// </summary>
+		public ResultType ResultType
+		{
+			get { return resulttype; }
+			set { resulttype = value; }
+		}
+		private WebHeaderCollection header = new WebHeaderCollection();
+		/// <summary>
+		/// header对象
+		/// </summary>
+		public WebHeaderCollection Header
+		{
+			get { return header; }
+			set { header = value; }
+		}
+
+		private Version _ProtocolVersion;
+
+		/// <summary>
+		//     获取或设置用于请求的 HTTP 版本。返回结果:用于请求的 HTTP 版本。默认为 System.Net.HttpVersion.Version11。
+		/// </summary>
+		public Version ProtocolVersion
+		{
+			get { return _ProtocolVersion; }
+			set { _ProtocolVersion = value; }
+		}
+		private Boolean _expect100continue = true;
+		/// <summary>
+		///  获取或设置一个 System.Boolean 值，该值确定是否使用 100-Continue 行为。如果 POST 请求需要 100-Continue 响应，则为 true；否则为 false。默认值为 true。
+		/// </summary>
+		public Boolean Expect100Continue
+		{
+			get { return _expect100continue; }
+			set { _expect100continue = value; }
+		}
+		private X509CertificateCollection _ClentCertificates;
+		/// <summary>
+		/// 设置509证书集合
+		/// </summary>
+		public X509CertificateCollection ClentCertificates
+		{
+			get { return _ClentCertificates; }
+			set { _ClentCertificates = value; }
+		}
+		private Encoding _PostEncoding;
+		/// <summary>
+		/// 设置或获取Post参数编码,默认的为Default编码
+		/// </summary>
+		public Encoding PostEncoding
+		{
+			get { return _PostEncoding; }
+			set { _PostEncoding = value; }
+		}
+		private ResultCookieType _ResultCookieType = ResultCookieType.String;
+		/// <summary>
+		/// Cookie返回类型,默认的是只返回字符串类型
+		/// </summary>
+		public ResultCookieType ResultCookieType
+		{
+			get { return _ResultCookieType; }
+			set { _ResultCookieType = value; }
+		}
+
+		private ICredentials _ICredentials = CredentialCache.DefaultCredentials;
+		/// <summary>
+		/// 获取或设置请求的身份验证信息。
+		/// </summary>
+		public ICredentials ICredentials
+		{
+			get { return _ICredentials; }
+			set { _ICredentials = value; }
+		}
+
+	}
+	/// <summary>
+	/// Http返回参数类
+	/// </summary>
+	public class HttpResult
+	{
+		private string _Cookie;
+		/// <summary>
+		/// Http请求返回的Cookie
+		/// </summary>
+		public string Cookie
+		{
+			get { return _Cookie; }
+			set { _Cookie = value; }
+		}
+
+		private CookieCollection _CookieCollection;
+		/// <summary>
+		/// Cookie对象集合
+		/// </summary>
+		public CookieCollection CookieCollection
+		{
+			get { return _CookieCollection; }
+			set { _CookieCollection = value; }
+		}
+		private string _Html;
+		/// <summary>
+		/// 返回的String类型数据 只有ResultType.String时才返回数据，其它情况为空
+		/// </summary>
+		public string Html
+		{
+			get { return _Html; }
+			set { _Html = value; }
+		}
+		private byte[] _ResultByte;
+		/// <summary>
+		/// 返回的Byte数组 只有ResultType.Byte时才返回数据，其它情况为空
+		/// </summary>
+		public byte[] ResultByte
+		{
+			get { return _ResultByte; }
+			set { _ResultByte = value; }
+		}
+
+		private WebHeaderCollection _Header;
+		/// <summary>
+		/// header对象
+		/// </summary>
+		public WebHeaderCollection Header
+		{
+			get { return _Header; }
+			set { _Header = value; }
+		}
+
+		private string _StatusDescription;
+		/// <summary>
+		/// 返回状态说明
+		/// </summary>
+		public string StatusDescription
+		{
+			get { return _StatusDescription; }
+			set { _StatusDescription = value; }
+		}
+		private HttpStatusCode _StatusCode;
+		/// <summary>
+		/// 返回状态码,默认为OK
+		/// </summary>
+		public HttpStatusCode StatusCode
+		{
+			get { return _StatusCode; }
+			set { _StatusCode = value; }
+		}
+		/// <summary>
+		/// HttpItem类，用于存储实际执行所用到的HttpItem对象
+		/// </summary>
+		public HttpItem item { get; set; }
+	}
+	/// <summary>
+	/// 返回类型
+	/// </summary>
+	public enum ResultType
+	{
+		/// <summary>
+		/// 表示只返回字符串 只有Html有数据
+		/// </summary>
+		String,
+		/// <summary>
+		/// 表示返回字符串和字节流 ResultByte和Html都有数据返回
+		/// </summary>
+		Byte
+	}
+	/// <summary>
+	/// Post的数据格式默认为string
+	/// </summary>
+	public enum PostDataType
+	{
+		/// <summary>
+		/// 字符串类型，这时编码Encoding可不设置
+		/// </summary>
+		String,
+		/// <summary>
+		/// Byte类型，需要设置PostdataByte参数的值编码Encoding可设置为空
+		/// </summary>
+		Byte,
+		/// <summary>
+		/// 传文件，Postdata必须设置为文件的绝对路径，必须设置Encoding的值
+		/// </summary>
+		FilePath
+	}
+	/// <summary>
+	/// Cookie返回类型
+	/// </summary>
+	public enum ResultCookieType
+	{
+		/// <summary>
+		/// 只返回字符串类型的Cookie
+		/// </summary>
+		String,
+		/// <summary>
+		/// CookieCollection格式的Cookie集合同时也返回String类型的cookie
+		/// </summary>
+		CookieCollection
+	}
+	public enum MethodType
+	{
+		Get,
+		Post
+	}
+
+	/// <summary>
+	/// 轻量级JWT帮助类：不依赖第三方NuGet包，支持HS256签名的生成与验证。
+	/// 生成的Token可直接赋值给 HttpItem.JwtToken，HttpHelper会自动添加到Authorization请求头。
+	/// </summary>
+	public static class JwtHelper
+	{
+		/// <summary>
+		/// 生成JWT（HS256签名）
+		/// </summary>
+		/// <param name="claims">自定义payload声明，例如 { "sub", "1001" }, { "name", "cow" }</param>
+		/// <param name="secret">签名密钥</param>
+		/// <param name="expireMinutes">过期时间(分钟)，默认60分钟</param>
+		/// <returns>完整的JWT字符串：header.payload.signature</returns>
+		public static string GenerateToken(Dictionary<string, object> claims, string secret, int expireMinutes = 60)
+		{
+			if (claims == null) claims = new Dictionary<string, object>();
+			if (string.IsNullOrEmpty(secret)) throw new ArgumentException("secret不能为空", nameof(secret));
+
+			var header = new Dictionary<string, object>
+			{
+				{ "alg", "HS256" },
+				{ "typ", "JWT" }
+			};
+
+			var payload = new Dictionary<string, object>(claims);
+			long now = ToUnixTimeSeconds(DateTime.UtcNow);
+			if (!payload.ContainsKey("iat")) payload["iat"] = now;
+			if (!payload.ContainsKey("exp")) payload["exp"] = now + (expireMinutes * 60L);
+
+			string headerEncoded = Base64UrlEncode(Encoding.UTF8.GetBytes(ToJson(header)));
+			string payloadEncoded = Base64UrlEncode(Encoding.UTF8.GetBytes(ToJson(payload)));
+			string signingInput = headerEncoded + "." + payloadEncoded;
+			string signature = Sign(signingInput, secret);
+
+			return signingInput + "." + signature;
+		}
+
+		/// <summary>
+		/// 校验JWT签名和有效期，成功时返回payload中的声明
+		/// </summary>
+		/// <param name="token">JWT字符串</param>
+		/// <param name="secret">签名密钥</param>
+		/// <param name="claims">解析出的payload声明</param>
+		/// <param name="error">失败时的错误信息</param>
+		/// <returns>是否验证通过</returns>
+		public static bool ValidateToken(string token, string secret, out Dictionary<string, object> claims, out string error)
+		{
+			claims = null;
+			error = null;
+			if (string.IsNullOrEmpty(token))
+			{
+				error = "token不能为空";
+				return false;
+			}
+			string[] parts = token.Split('.');
+			if (parts.Length != 3)
+			{
+				error = "token格式不正确";
+				return false;
+			}
+			string signingInput = parts[0] + "." + parts[1];
+			string expectedSignature = Sign(signingInput, secret);
+			if (!SlowEquals(expectedSignature, parts[2]))
+			{
+				error = "签名校验失败";
+				return false;
+			}
+			string payloadJson;
+			try
+			{
+				payloadJson = Encoding.UTF8.GetString(Base64UrlDecode(parts[1]));
+				claims = FromJson(payloadJson);
+			}
+			catch (Exception ex)
+			{
+				error = "payload解析失败：" + ex.Message;
+				return false;
+			}
+			if (claims.TryGetValue("exp", out object expObj))
+			{
+				if (long.TryParse(expObj.ToString(), out long exp))
+				{
+					if (ToUnixTimeSeconds(DateTime.UtcNow) > exp)
+					{
+						error = "token已过期";
+						return false;
+					}
+				}
+			}
+			return true;
+		}
+
+		/// <summary>
+		/// 不校验签名，仅解析出JWT的payload内容（用于调试查看Token内容）
+		/// </summary>
+		public static Dictionary<string, object> DecodeToken(string token)
+		{
+			if (string.IsNullOrEmpty(token)) throw new ArgumentException("token不能为空", nameof(token));
+			string[] parts = token.Split('.');
+			if (parts.Length != 3) throw new FormatException("token格式不正确");
+			string payloadJson = Encoding.UTF8.GetString(Base64UrlDecode(parts[1]));
+			return FromJson(payloadJson);
+		}
+
+		private static string Sign(string input, string secret)
+		{
+			using (var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret ?? string.Empty)))
+			{
+				byte[] hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(input));
+				return Base64UrlEncode(hash);
+			}
+		}
+
+		private static bool SlowEquals(string a, string b)
+		{
+			if (a == null || b == null) return false;
+			if (a.Length != b.Length) return false;
+			int diff = 0;
+			for (int i = 0; i < a.Length; i++)
+			{
+				diff |= a[i] ^ b[i];
+			}
+			return diff == 0;
+		}
+
+		private static long ToUnixTimeSeconds(DateTime utcDateTime)
+		{
+			return (long)(utcDateTime - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)).TotalSeconds;
+		}
+
+		private static string Base64UrlEncode(byte[] input)
+		{
+			return Convert.ToBase64String(input).TrimEnd('=').Replace('+', '-').Replace('/', '_');
+		}
+
+		private static byte[] Base64UrlDecode(string input)
+		{
+			string s = input.Replace('-', '+').Replace('_', '/');
+			switch (s.Length % 4)
+			{
+				case 2: s += "=="; break;
+				case 3: s += "="; break;
+			}
+			return Convert.FromBase64String(s);
+		}
+
+		/// <summary>
+		/// 极简JSON序列化，支持扁平的 Dictionary&lt;string, object&gt;，值类型支持 string/数值/bool/null
+		/// </summary>
+		private static string ToJson(Dictionary<string, object> dict)
+		{
+			var sb = new StringBuilder();
+			sb.Append('{');
+			bool first = true;
+			foreach (var kv in dict)
+			{
+				if (!first) sb.Append(',');
+				first = false;
+				sb.Append('"').Append(EscapeJson(kv.Key)).Append("\":");
+				AppendJsonValue(sb, kv.Value);
+			}
+			sb.Append('}');
+			return sb.ToString();
+		}
+
+		private static void AppendJsonValue(StringBuilder sb, object value)
+		{
+			if (value == null)
+			{
+				sb.Append("null");
+			}
+			else if (value is bool b)
+			{
+				sb.Append(b ? "true" : "false");
+			}
+			else if (value is sbyte || value is byte || value is short || value is ushort ||
+					 value is int || value is uint || value is long || value is ulong ||
+					 value is float || value is double || value is decimal)
+			{
+				sb.Append(Convert.ToString(value, System.Globalization.CultureInfo.InvariantCulture));
+			}
+			else
+			{
+				sb.Append('"').Append(EscapeJson(value.ToString())).Append('"');
+			}
+		}
+
+		private static string EscapeJson(string s)
+		{
+			return s.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\n", "\\n").Replace("\r", "\\r").Replace("\t", "\\t");
+		}
+
+		/// <summary>
+		/// 极简JSON反序列化，仅支持扁平对象（JWT payload通常满足此结构）
+		/// </summary>
+		private static Dictionary<string, object> FromJson(string json)
+		{
+			var result = new Dictionary<string, object>();
+			int i = 0;
+			SkipWhitespace(json, ref i);
+			if (i >= json.Length || json[i] != '{') throw new FormatException("不是合法的JSON对象");
+			i++;
+			SkipWhitespace(json, ref i);
+			if (i < json.Length && json[i] == '}') return result;
+			while (i < json.Length)
+			{
+				SkipWhitespace(json, ref i);
+				string key = ParseJsonString(json, ref i);
+				SkipWhitespace(json, ref i);
+				if (json[i] != ':') throw new FormatException("JSON格式错误，缺少':'");
+				i++;
+				SkipWhitespace(json, ref i);
+				object value = ParseJsonValue(json, ref i);
+				result[key] = value;
+				SkipWhitespace(json, ref i);
+				if (i < json.Length && json[i] == ',') { i++; continue; }
+				if (i < json.Length && json[i] == '}') { i++; break; }
+				break;
+			}
+			return result;
+		}
+
+		private static void SkipWhitespace(string s, ref int i)
+		{
+			while (i < s.Length && char.IsWhiteSpace(s[i])) i++;
+		}
+
+		private static string ParseJsonString(string s, ref int i)
+		{
+			if (s[i] != '"') throw new FormatException("JSON格式错误，期望字符串");
+			i++;
+			var sb = new StringBuilder();
+			while (s[i] != '"')
+			{
+				if (s[i] == '\\')
+				{
+					i++;
+					switch (s[i])
+					{
+						case 'n': sb.Append('\n'); break;
+						case 'r': sb.Append('\r'); break;
+						case 't': sb.Append('\t'); break;
+						case '"': sb.Append('"'); break;
+						case '\\': sb.Append('\\'); break;
+						default: sb.Append(s[i]); break;
+					}
+				}
+				else
+				{
+					sb.Append(s[i]);
+				}
+				i++;
+			}
+			i++; // 跳过结尾的引号
+			return sb.ToString();
+		}
+
+		private static object ParseJsonValue(string s, ref int i)
+		{
+			if (s[i] == '"') return ParseJsonString(s, ref i);
+			if (s[i] == 't' && s.Substring(i, 4) == "true") { i += 4; return true; }
+			if (s[i] == 'f' && s.Substring(i, 5) == "false") { i += 5; return false; }
+			if (s[i] == 'n' && s.Substring(i, 4) == "null") { i += 4; return null; }
+			int start = i;
+			while (i < s.Length && (char.IsDigit(s[i]) || s[i] == '-' || s[i] == '+' || s[i] == '.' || s[i] == 'e' || s[i] == 'E')) i++;
+			string numStr = s.Substring(start, i - start);
+			if (numStr.Contains(".") || numStr.Contains("e") || numStr.Contains("E"))
+			{
+				return double.Parse(numStr, System.Globalization.CultureInfo.InvariantCulture);
+			}
+			return long.Parse(numStr, System.Globalization.CultureInfo.InvariantCulture);
+		}
+	}
+}
\ No newline at end of file
diff --git a/Source/Trade.Client/HttpExtension/ServerReqeustBase.cs b/Source/Trade.Client/HttpExtension/ServerReqeustBase.cs
new file mode 100644
index 0000000..876d267
--- /dev/null
+++ b/Source/Trade.Client/HttpExtension/ServerReqeustBase.cs
@@ -0,0 +1,94 @@
+using LittleCow.Core.Autofac;
+using LittleCow.Core.DependencyInjection;
+using LittleCow.Core.Helpers;
+using LittleCow.Core.Logger;
+using LittleCow.Server.Commons;
+using LittleCow.Server.Extensions;
+using MAX.Core.DependencyInjection;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+using Trade.Client;
+using Trade.Client.Helpers;
+
+namespace Trade.Client.HttpExtension
+{
+	public class ServerReqeustBase : ITransientDependency
+	{
+
+		/// <summary>
+		/// 日志
+		/// </summary>
+		[Autowired]
+		protected ILoggerFacade _log { get; set; }
+
+		/// <summary>
+		/// 服务器配置
+		/// </summary>
+		[Autowired]
+		protected IServerConfig _config { get; set; }
+
+		public ServerReqeustBase()
+		{
+		}
+
+		public string BuildObjString(string urlpath)
+		{
+			return _config.Host + "?" + _config.ObjUrl + urlpath;
+		}
+
+		/// <summary>
+		/// 服务器请求
+		/// </summary>
+		/// <param name="item"></param>
+		/// <returns></returns>
+		public HttpResult ServerRequest(ServerHttpItem item)
+		{
+#if RELEASE
+                item.WebProxy = null;
+#endif
+			if (!item.URL.StartsWith("http"))
+			{
+				item.URL += _config.Host + item.URL;
+			}
+			item.Encoding = Encoding.UTF8;
+			if (item.Method == MethodType.Post)
+			{
+				item.ContentType = "application/x-www-form-urlencoded";
+			}
+			if (!item.IsSign)
+			{
+				if (item.Shop != null)
+					item.SignUser(item.Shop.Id, item.Shop.MainAccount);
+				else
+					item.Sign();
+			}
+			HttpResult result = HttpHelper.Request(item);
+			if (result.StatusCode == HttpStatusCode.OK)
+			{
+				if (!string.IsNullOrEmpty(result.Html))
+				{
+					if (result.Html[0] == 65279)
+					{
+						result.Html = result.Html.Remove(0, 1);
+					}
+				}
+			}
+			else
+			{
+
+			}
+			return result;
+		}
+
+		public async Task<HttpResult> ServerAsyncRequest(ServerHttpItem item)
+		{
+			return await Task.FromResult(ServerRequest(item));
+		}
+	}
+}
diff --git a/Source/Trade.Client/IServerConfig.cs b/Source/Trade.Client/IServerConfig.cs
new file mode 100644
index 0000000..3e1e01e
--- /dev/null
+++ b/Source/Trade.Client/IServerConfig.cs
@@ -0,0 +1,16 @@
+using System;
+
+namespace Trade.Client
+{
+    public interface IServerConfig
+    {
+        /// <summary>
+        /// 服务器地址
+        /// </summary>
+        string Host { get; }
+        /// <summary>
+        /// 项目地址
+        /// </summary>
+        string ObjUrl { get; }
+    }
+}
diff --git a/Source/Trade.Client/ServerConfig.cs b/Source/Trade.Client/ServerConfig.cs
new file mode 100644
index 0000000..601050f
--- /dev/null
+++ b/Source/Trade.Client/ServerConfig.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Trade.Client
+{
+    internal class ServerConfig
+    {
+        /// <summary>
+        /// 服务器时间差
+        /// </summary>
+        public static int TimeDifferent { get; internal set; }
+        /// <summary>
+        /// 是否使用新签名算法
+        /// </summary>
+        public static bool IsNewSignatureAuth { get; internal set; } = true;
+
+    }
+}
diff --git a/Source/Trade.Client/Startup.cs b/Source/Trade.Client/Startup.cs
new file mode 100644
index 0000000..285c48f
--- /dev/null
+++ b/Source/Trade.Client/Startup.cs
@@ -0,0 +1,63 @@
+using MAX.Core;
+using MAX.Core.DependencyInjection;
+using MAX.Core.Infrastructure;
+using RestSharp;
+
+namespace Trade.Client;
+
+public class Startup : IStartup
+{
+	public Startup()
+	{
+
+	}
+
+	public int Priority => IntPriority.Normal;
+
+	public void Initialize()
+	{
+		throw new NotImplementedException();
+	}
+
+	public void Register(IServiceRegistrar registrar)
+	{
+		
+	}
+
+	async Task ss()
+	{
+		// 1. 创建客户端
+		var client = new RestClient("https://api.example.com");
+
+		// 2. 创建请求，并指定资源路径
+		var request = new RestRequest("users/{id}", Method.GET);
+
+		// 3. 添加请求参数
+		// 添加 URL 路径参数，替换 {id}
+		request.AddUrlSegment("id", "123");
+		// 添加 URL 查询参数
+		request.AddQueryParameter("include", "details");
+		// 添加请求头
+		request.AddHeader("Authorization", "Bearer your-token");
+		request.Method = Method.POST;
+
+		// 4. 执行请求，并获取响应
+		// 这里 Execute 是同步方法，如果是异步场景也可以用 ExecuteAsync
+		IRestResponse response = await client.ExecuteAsync(request);
+
+		// 5. 处理响应
+		if (response.IsSuccessful)
+		{
+			// 响应内容可以通过 response.Content 获取
+			var content = response.Content;
+			// 或者通过 RestSharp 自带的序列化器直接反序列化成对象
+			// var user = client.Execute<User>(request).Data;
+			Console.WriteLine(content);
+		}
+		else
+		{
+			Console.WriteLine($"请求失败: {response.StatusCode}, {response.ErrorMessage}");
+		}
+
+	}
+}
diff --git a/Source/Trade.Client/Trade.Client.csproj b/Source/Trade.Client/Trade.Client.csproj
new file mode 100644
index 0000000..52428fe
--- /dev/null
+++ b/Source/Trade.Client/Trade.Client.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="RestSharp" Version="106.15.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MAX.Core\MAX.Core.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Source/Trade.Framework/AssemblyInfo.cs b/Source/Trade.Framework/AssemblyInfo.cs
new file mode 100644
index 0000000..cdf5d8e
--- /dev/null
+++ b/Source/Trade.Framework/AssemblyInfo.cs
@@ -0,0 +1,8 @@
+using System.Windows.Markup;
+
+[assembly: XmlnsDefinition("Trade.Framework", "Trade.Framework")]
+[assembly: XmlnsDefinition("Trade.Framework", "Trade.Framework.Extensions")]
+[assembly: XmlnsDefinition("Trade.Framework", "Trade.Framework.Controls")]
+
+
+[assembly: XmlnsPrefix("Nexus.Framework", "tf")]
\ No newline at end of file
diff --git a/Source/Trade.Framework/Controls/UserControlBase.cs b/Source/Trade.Framework/Controls/UserControlBase.cs
new file mode 100644
index 0000000..e54d2b3
--- /dev/null
+++ b/Source/Trade.Framework/Controls/UserControlBase.cs
@@ -0,0 +1,17 @@
+using Prism.Mvvm;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+
+namespace Trade.Framework.Controls;
+
+public class UserControlBase: UserControl
+{
+	public UserControlBase()
+	{
+		ViewModelLocator.SetAutoWireViewModel(this, true);
+	}
+}
diff --git a/Source/Trade.Framework/Controls/WindowBase.cs b/Source/Trade.Framework/Controls/WindowBase.cs
new file mode 100644
index 0000000..3df51e7
--- /dev/null
+++ b/Source/Trade.Framework/Controls/WindowBase.cs
@@ -0,0 +1,17 @@
+using Prism.Mvvm;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace Trade.Framework.Controls;
+
+public class WindowBase : Window
+{
+	public WindowBase()
+	{
+		ViewModelLocator.SetAutoWireViewModel(this, true);
+	}
+}
diff --git a/Source/Trade.Framework/Extensions/DISource.cs b/Source/Trade.Framework/Extensions/DISource.cs
new file mode 100644
index 0000000..cba5c1e
--- /dev/null
+++ b/Source/Trade.Framework/Extensions/DISource.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Markup;
+
+namespace Trade.Framework.Extensions;
+
+public class DISource : MarkupExtension
+{
+	internal static Func<Type, string, object> Resolver { get; set; }
+
+	public Type Type { get; set; }
+	public string Name { get; set; }
+
+	public override object ProvideValue(IServiceProvider serviceProvider)
+	{
+		return Resolver?.Invoke(Type, Name);
+	}
+}
\ No newline at end of file
diff --git a/Source/Trade.Framework/FrameworkApplication.cs b/Source/Trade.Framework/FrameworkApplication.cs
new file mode 100644
index 0000000..a946aa7
--- /dev/null
+++ b/Source/Trade.Framework/FrameworkApplication.cs
@@ -0,0 +1,49 @@
+using Prism.Autofac;
+using Prism.Ioc;
+using Prism.Mvvm;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using Trade.Framework.Extensions;
+
+namespace Trade.Framework;
+
+public abstract class FrameworkApplication : PrismApplication
+{
+
+	protected FrameworkApplication()
+	{
+
+	}
+
+
+	protected override void OnStartup(StartupEventArgs e)
+	{
+		DISource.Resolver = Resolve;
+		base.OnStartup(e);
+	}
+
+	protected override void OnInitialized()
+	{
+		base.OnInitialized();
+	}
+
+
+	private object Resolve(Type type, string name)
+	{
+		if (type == null || Container is null)
+		{
+			return null;
+		}
+
+		if (name != null)
+		{
+			return Container.Resolve(type, name);
+		}
+
+		return Container.Resolve(type);
+	}
+}
diff --git a/Source/Trade.Framework/Services/UserManager.cs b/Source/Trade.Framework/Services/UserManager.cs
new file mode 100644
index 0000000..fa354b7
--- /dev/null
+++ b/Source/Trade.Framework/Services/UserManager.cs
@@ -0,0 +1,21 @@
+using MAX.Core.DependencyInjection;
+using MAX.Core.Logger;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Trade.Framework.Services;
+
+public interface IUserManager : ISingletonDependency
+{
+
+}
+public class UserManager: IUserManager
+{
+	public UserManager(ILoggerFacade logger)
+	{
+		logger.Info("Stat UserManager");
+	}
+}
diff --git a/Source/Trade.Framework/Startup.cs b/Source/Trade.Framework/Startup.cs
new file mode 100644
index 0000000..a38dd55
--- /dev/null
+++ b/Source/Trade.Framework/Startup.cs
@@ -0,0 +1,25 @@
+using Autofac;
+using MAX.Core;
+using MAX.Core.DependencyInjection;
+using MAX.Core.Infrastructure;
+using MAX.Core.Reflections;
+using Prism.Ioc;
+using Prism.Modularity;
+using System.Reflection;
+
+namespace Trade.Framework;
+
+public class Startup : IStartup
+{
+	public int Priority => IntPriority.Highest;
+
+	public void Initialize()
+	{
+
+	}
+
+	public void Register(ContainerBuilder builder)
+	{
+		
+	}
+}
diff --git a/Source/Trade.Framework/Trade.Framework.csproj b/Source/Trade.Framework/Trade.Framework.csproj
new file mode 100644
index 0000000..afa603a
--- /dev/null
+++ b/Source/Trade.Framework/Trade.Framework.csproj
@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+	  <TargetFramework>$(DefaultTargetFramework)-windows</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.2" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MAX.Core\MAX.Core.csproj" />
+    <ProjectReference Include="..\MAX.Framework\MAX.Framework.csproj" />
+  </ItemGroup>
+
+</Project>