XFE Git
XFE Studio Git
Git 首页 全局搜索
XFE 主站 文档 NuGet

XFEExtension

【DLL】XFE各类拓展是一个C#的DLL库，旨在优化C#代码中常用语句的使用，并提供更简洁的访问方式，同时提供Xunit测试框架，快速搭建服务器/客户端，免费ChatGPTAPI接口，免费通讯服务器，XFE下载器，新增格式等

公开
关注 0 Fork 0 Star 0
返回提交历史

XFEstudio/XFEExtension

fix-修复CyberComm中的部分问题 change-优化网址匹配正则

78ba483
XFE工作室室长 <mail@xfegzs.com>
提交于
父提交 7b96e76

代码差异

17 个文件 +244 -775
Modified XFEExtension.NetCore.Analyzer.Test/Program.cs +3 -75
@@ -1,84 +1,12 @@
1 using System.Diagnostics;
2 using System.IO.Pipes;
3
4 namespace XFEExtension.NetCore.Analyzer.Test;
1 namespace XFEExtension.NetCore.Analyzer.Test;
5 2
6 3 internal class Program
7 4 {
8 5 [SMTest]
9 public static async Task TestNamedPipeAsync()
6 public static void TestNamedPipeAsync()
10 7 {
11 try
12 {
13 if (Console.ReadLine() == "s")
14 {
15 using var pipeServer = new NamedPipeServerStream("testpipe", PipeDirection.InOut, 100);
16 using var pipeServer2 = new NamedPipeServerStream("testpipe2", PipeDirection.InOut, 100);
17 Console.WriteLine("Named Pipe Server waiting for connection...");
18 while (true)
19 {
20 await pipeServer.WaitForConnectionAsync();
21 Console.WriteLine("Client 1 Connected!");
22 await pipeServer2.WaitForConnectionAsync();
23 Console.WriteLine("Client 2 Connected!");
24 _ = Task.Run(async () =>
25 {
26 using var reader = new StreamReader(pipeServer);
27 using var writer = new StreamWriter(pipeServer);
28 var message = await reader.ReadLineAsync();
29 Console.WriteLine("Received from client: " + message);
30 string response = "Hello from server!";
31 await writer.WriteLineAsync(response);
32 writer.Flush();
33 await Task.Delay(1000);
34 await writer.WriteLineAsync(response);
35 writer.Flush();
36 await Task.Delay(1000);
37 await writer.WriteLineAsync(response);
38 writer.Flush();
39 await Task.Delay(1000);
40 await writer.WriteLineAsync(response);
41 writer.Flush();
42 await Task.Delay(1000);
43 await writer.WriteLineAsync(response);
44 writer.Flush();
45 await Task.Delay(1000);
46 await writer.WriteLineAsync(response);
47 writer.Flush();
48 await Task.Delay(1000);
49 await writer.WriteLineAsync(response);
50 writer.Flush();
51 });
52 }
53 }
54 else
55 {
56 using var pipeClient = new NamedPipeClientStream(".", "testpipe", PipeDirection.InOut);
57 using var pipeClient2 = new NamedPipeClientStream(".", "testpipe2", PipeDirection.InOut);
58 Console.WriteLine("Named Pipe Client connecting to server...");
59 await pipeClient.ConnectAsync();
60 Console.WriteLine("Server 1 Connected!");
61 await Task.Delay(3000);
62 await pipeClient2.ConnectAsync();
63 Console.WriteLine("Server 2 Connected!");
64 using var reader = new StreamReader(pipeClient);
65 using var writer = new StreamWriter(pipeClient);
66 string message = "Hello from client!";
67 await writer.WriteLineAsync(message);
68 writer.Flush();
69 while (true)
70 {
71 var response = await reader.ReadLineAsync();
72 Console.WriteLine("Received from server: " + response);
73 }
74 }
75 }
76 catch (Exception ex)
77 {
78 Console.WriteLine(ex);
79 }
8 Console.WriteLine("Hello World!");
80 9 Console.WriteLine("Program End");
81 Console.ReadLine();
82 10 }
83 11 }
84 12 enum MyEnum
Added XFEExtension.NetCore.Test/Program.cs +9 -0
@@ -0,0 +1,9 @@
1 using XFEExtension.NetCore.Test;
2
3 var testClass = new TestClass("测试类", "测试描述：我上早八", 56)
4 {
5 Tags = [["标签11", "标签12"], ["标签21", "标签22"]]
6 };
7 Console.WriteLine(testClass);
8 Console.WriteLine("Program End");
9 Console.ReadLine();
Added XFEExtension.NetCore.Test/TestClass.cs +25 -0
@@ -0,0 +1,25 @@
1 using System;
2
3 namespace XFEExtension.NetCore.Test;
4
5 internal class TestClass(string name, string description, int age)
6 {
7 public int id;
8 private int data;
9 public EmptyClass EPClass { get; } = new();
10 public ushort OS { get; set; }
11 public string Name { get; set; } = name;
12 public List<List<string>> Tags { get; set; }
13 public bool MyProperty { get; set; }
14 public MyEnum Enum { get; set; }
15 public string Description { get; set; } = description;
16 public int Age { get; set; } = age;
17 }
18
19 internal class EmptyClass { }
20 enum MyEnum
21 {
22 Test1 = 3,
23 Test2 = 12,
24 Test3 = 1
25 }
Added XFEExtension.NetCore.Test/XFEExtension.NetCore.Test.csproj +14 -0
@@ -0,0 +1,14 @@
1 <Project Sdk="Microsoft.NET.Sdk">
2
3 <PropertyGroup>
4 <OutputType>Exe</OutputType>
5 <TargetFramework>net8.0</TargetFramework>
6 <ImplicitUsings>enable</ImplicitUsings>
7 <Nullable>enable</Nullable>
8 </PropertyGroup>
9
10 <ItemGroup>
11 <ProjectReference Include="..\XFEExtension.NetCore\XFEExtension.NetCore.csproj" />
12 </ItemGroup>
13
14 </Project>
Deleted XFEExtension.NetCore/Console/XFEConsole.cs +0 -148
@@ -1,148 +0,0 @@
1 using System.Diagnostics;
2 using XFEExtension.NetCore.XFETransform.ObjectInfoAnalyzer;
3 using XFEExtension.NetCore.XFETransform;
4 using XFEExtension.NetCore.XFETransform.StringConverter;
5
6 namespace XFEExtension.NetCore.XFEConsole;
7
8 /// <summary>
9 /// XFE控制台
10 /// </summary>
11 public class XFEConsole
12 {
13 /// <summary>
14 /// 是否在本地调试的Debug中展示
15 /// </summary>
16 /// <remarks>
17 /// 默认为 true
18 /// </remarks>
19 public static bool ShowInDebug { get; set; } = true;
20 /// <summary>
21 /// 是否在本地控制台中显示
22 /// </summary>
23 /// <remarks>
24 /// 默认为 false
25 /// </remarks>
26 public static bool ShowInLocalConsole { get; set; } = false;
27 /// <summary>
28 /// 是否自动解析对象，而非直接输出对象的.ToString()方法
29 /// </summary>
30 /// <remarks>
31 /// 默认为 true
32 /// </remarks>
33 public static bool AutoAnalyzeObject { get; set; } = true;
34 /// <summary>
35 /// 客户端列表
36 /// </summary>
37 public static List<XFEConsoleProgramClient> ClientList { get; set; } = [];
38 /// <summary>
39 /// 使用XFE控制台
40 /// </summary>
41 /// <param name="ipAddress">IP地址</param>
42 /// <param name="name">客户端名称</param>
43 /// <param name="id">客户端ID</param>
44 /// <param name="password">密码</param>
45 /// <returns>是否连接成功</returns>
46 public static async Task<bool> UseXFEConsole(string ipAddress, string name, string id, string password)
47 {
48 SetConsoleOutput();
49 return await ConnectConsole(ipAddress, name, id, password);
50 }
51 /// <summary>
52 /// 使用XFE控制台
53 /// </summary>
54 /// <param name="port">端口</param>
55 /// <param name="password">密码</param>
56 /// <returns>是否连接成功</returns>
57 public static async Task<bool> UseXFEConsole(string port, string password = "") => await UseXFEConsole($"ws://*:{port}", AppDomain.CurrentDomain.FriendlyName, Guid.NewGuid().ToString(), password);
58 /// <summary>
59 /// 设置XFE控制台
60 /// </summary>
61 /// <returns></returns>
62 public static void SetConsoleOutput()
63 {
64 Console.SetOut(new XFEConsoleTextWriter());
65 }
66 /// <summary>
67 /// 连接XFE控制台
68 /// </summary>
69 /// <param name="ipAddress">IP地址</param>
70 /// <param name="name">客户端名称</param>
71 /// <param name="id">客户端ID</param>
72 /// <param name="password">密码</param>
73 /// <returns>是否连接成功</returns>
74 public static async Task<bool> ConnectConsole(string ipAddress, string name, string id, string password)
75 {
76 var client = new XFEConsoleProgramClient(ipAddress, name, id, password);
77 if (await client.Connect())
78 {
79 ClientList.Add(client);
80 return true;
81 }
82 else
83 {
84 return false;
85 }
86 }
87 /// <summary>
88 /// 输出对象信息
89 /// </summary>
90 /// <param name="obj">对象</param>
91 /// <param name="remarkName">对象注释</param>
92 /// <param name="onlyProperty">仅解析属性</param>
93 /// <param name="onlyPublic">仅解析公共属性或字段</param>
94 /// <returns></returns>
95 public static async Task WriteObject(object? obj, string remarkName = "分析对象", bool onlyProperty = true, bool onlyPublic = true)
96 {
97 var objectInfo = "无法分析对象：";
98 try
99 {
100 objectInfo = XFEConverter.GetObjectInfo(StringConverter.ObjectAnalyzer, remarkName, ObjectPlace.Main, 0, obj?.GetType(), obj, onlyProperty, onlyPublic).OutPutObject();
101 }
102 catch (Exception ex)
103 {
104 Debug.WriteLine(ex);
105 objectInfo += ex.StackTrace;
106 }
107 if (ShowInDebug)
108 Debug.WriteLine(objectInfo);
109 if (ShowInLocalConsole)
110 Console.WriteLine(objectInfo);
111 foreach (var client in ClientList)
112 await client.OutputMessage(objectInfo, true);
113 }
114 /// <summary>
115 /// 向已连接的XFE控制台输出一条消息
116 /// </summary>
117 /// <param name="text">文本</param>
118 /// <returns></returns>
119 public static async Task WriteLine(string? text)
120 {
121 if (text is not null)
122 {
123 if (ShowInDebug)
124 Debug.WriteLine(text);
125 if (ShowInLocalConsole)
126 Console.WriteLine(text);
127 foreach (var client in ClientList)
128 await client.OutputMessage(text, true);
129 }
130 }
131 /// <summary>
132 /// 向已连接的XFE控制台输出一条消息
133 /// </summary>
134 /// <param name="text">文本</param>
135 /// <returns></returns>
136 public static async Task Write(string? text)
137 {
138 if (text is not null)
139 {
140 if (ShowInDebug)
141 Debug.WriteLine(text);
142 if (ShowInLocalConsole)
143 Console.WriteLine(text);
144 foreach (var client in ClientList)
145 await client.OutputMessage(text, false);
146 }
147 }
148 }
Deleted XFEExtension.NetCore/Console/XFEConsoleClientInfo.cs +0 -30
@@ -1,30 +0,0 @@
1 using XFEExtension.NetCore.CyberComm;
2
3 namespace XFEExtension.NetCore.XFEConsole;
4
5 /// <summary>
6 /// XFE控制台客户端信息
7 /// </summary>
8 /// <param name="clientName">客户端名称</param>
9 /// <param name="clientUUID">客户端唯一标识符</param>
10 /// <param name="password">客户端连接时密码</param>
11 /// <param name="eventArgs">事件参数</param>
12 public class XFEConsoleClientInfo(string clientName, string clientUUID, string password, CyberCommServerEventArgs eventArgs)
13 {
14 /// <summary>
15 /// 客户端名称
16 /// </summary>
17 public string ClientName { get; set; } = clientName;
18 /// <summary>
19 /// 客户端唯一标识符
20 /// </summary>
21 public string ClientUUID { get; set; } = clientUUID;
22 /// <summary>
23 /// 客户端密码
24 /// </summary>
25 public string Password { get; set; } = password;
26 /// <summary>
27 /// 事件参数
28 /// </summary>
29 public CyberCommServerEventArgs EventArgs { get; set; } = eventArgs;
30 }
Deleted XFEExtension.NetCore/Console/XFEConsoleProgramClient.cs +0 -66
@@ -1,66 +0,0 @@
1 using XFEExtension.NetCore.CyberComm;
2 using XFEExtension.NetCore.FormatExtension;
3 using XFEExtension.NetCore.TaskExtension;
4
5 namespace XFEExtension.NetCore.XFEConsole;
6
7 /// <summary>
8 /// XFE控制台程序客户端
9 /// </summary>
10 /// <remarks>
11 /// 默认构造函数
12 /// </remarks>
13 /// <param name="ipAddress">控制台输出端IP地址</param>
14 /// <param name="clientName">客户端名称</param>
15 /// <param name="password">密码</param>
16 /// <param name="clientID">客户端ID</param>
17 public class XFEConsoleProgramClient(string ipAddress, string clientName, string password, string clientID)
18 {
19 private event EndTaskTrigger<bool>? ConnectTrigger;
20 /// <summary>
21 /// 客户端
22 /// </summary>
23 public CyberCommClient Client { get; set; } = new CyberCommClient(ipAddress);
24 /// <summary>
25 /// 客户端名称
26 /// </summary>
27 public string ClientName { get; set; } = clientName;
28 /// <summary>
29 /// 连接时密码
30 /// </summary>
31 public string Password { get; set; } = password;
32 /// <summary>
33 /// 客户端ID
34 /// </summary>
35 public string ClientID { get; set; } = clientID;
36 /// <summary>
37 /// 连接服务器
38 /// </summary>
39 /// <returns></returns>
40 public async Task<bool> Connect()
41 {
42 Client.Connected += Client_Connected;
43 _ = Client.StartCyberCommClient();
44 Client.ClientWebSocket!.Options.SetRequestHeader(nameof(ClientName), ClientName);
45 Client.ClientWebSocket!.Options.SetRequestHeader(nameof(Password), Password);
46 Client.ClientWebSocket!.Options.SetRequestHeader(nameof(ClientID), ClientID);
47 if (Client.IsConnected)
48 return true;
49 else
50 return await new XFEWaitTask<bool>(ref ConnectTrigger!);
51 }
52
53 private void Client_Connected(object? sender, EventArgs e) => ConnectTrigger?.Invoke(true);
54
55 /// <summary>
56 /// 输出控制台消息
57 /// </summary>
58 /// <param name="message">消息文本</param>
59 /// <param name="isLine">是否是一整行</param>
60 /// <returns></returns>
61 public async Task OutputMessage(string message, bool isLine)
62 {
63 if (Client.IsConnected)
64 await Client.SendTextMessage(new XFEDictionary("IsLine", isLine ? "true" : "false", "Text", message));
65 }
66 }
Deleted XFEExtension.NetCore/Console/XFEConsoleProgramServer.cs +0 -8
@@ -1,8 +0,0 @@
1 namespace XFEExtension.NetCore.XFEConsole;
2
3 /// <summary>
4 /// XFE控制台进程服务器
5 /// </summary>
6 public class XFEConsoleProgramServer
7 {
8 }
Deleted XFEExtension.NetCore/Console/XFEConsoleTerminalClient.cs +0 -8
@@ -1,8 +0,0 @@
1 namespace XFEExtension.NetCore.XFEConsole;
2
3 /// <summary>
4 /// XFE控制台终端客户端
5 /// </summary>
6 public class XFEConsoleTerminalClient
7 {
8 }
Deleted XFEExtension.NetCore/Console/XFEConsoleTerminalServer.cs +0 -127
@@ -1,127 +0,0 @@
1 using System.Net.WebSockets;
2 using XFEExtension.NetCore.CyberComm;
3 using XFEExtension.NetCore.DelegateExtension;
4
5 namespace XFEExtension.NetCore.XFEConsole;
6
7 /// <summary>
8 /// XFE控制台终端服务器
9 /// </summary>
10 public class XFEConsoleTerminalServer
11 {
12 /// <summary>
13 /// 服务器
14 /// </summary>
15 public CyberCommServer Server { get; set; }
16 /// <summary>
17 /// 密码
18 /// </summary>
19 public string Password { get; set; }
20 /// <summary>
21 /// Socket客户端-客户端信息字典
22 /// </summary>
23 public Dictionary<WebSocket, XFEConsoleClientInfo> ClientInfoDictionary { get; set; } = [];
24 /// <summary>
25 /// 客户端连接事件
26 /// </summary>
27 public event XFEEventHandler<XFEConsoleTerminalServer, XFEConsoleClientInfo>? Connected;
28 /// <summary>
29 /// 客户端断开连接事件
30 /// </summary>
31 public event XFEEventHandler<XFEConsoleTerminalServer, XFEConsoleClientInfo>? Disconnected;
32 /// <summary>
33 /// 接收到客户端消息触发
34 /// </summary>
35 public event XFEEventHandler<XFEConsoleClientInfo, string>? MessageReceived;
36 /// <summary>
37 /// 发生错误
38 /// </summary>
39 public event XFEEventHandler<XFEConsoleClientInfo, Exception>? ErrorOccurred;
40 /// <summary>
41 /// 服务器启动事件
42 /// </summary>
43 public event XFEEventHandler<XFEConsoleTerminalServer>? ServerStarted;
44 /// <summary>
45 /// XFE控制台终端服务器
46 /// </summary>
47 /// <param name="port">端口号</param>
48 /// <param name="password">密码（默认为空）</param>
49 public XFEConsoleTerminalServer(int port, string password = "")
50 {
51 Password = password;
52 Server = new CyberCommServer(port);
53 Server.ServerStarted += Server_ServerStarted;
54 Server.ClientConnected += Server_ClientConnected;
55 Server.ConnectionClosed += Server_ConnectionClosed;
56 Server.MessageReceived += Server_MessageReceived;
57 }
58
59 private void Server_MessageReceived(object? sender, CyberCommServerEventArgs e)
60 {
61 switch (e.MessageType)
62 {
63 case BackMessageType.Text:
64 break;
65 case BackMessageType.Binary:
66 break;
67 case BackMessageType.Error:
68 break;
69 default:
70 break;
71 }
72 }
73
74 private void Server_ConnectionClosed(object? sender, CyberCommServerEventArgs e)
75 {
76 if (ClientInfoDictionary.TryGetValue(e.CurrentWebSocket, out XFEConsoleClientInfo? clientInfo))
77 {
78 ClientInfoDictionary.Remove(e.CurrentWebSocket);
79 Disconnected?.Invoke(this, clientInfo);
80 }
81 }
82
83 private async void Server_ClientConnected(object? sender, CyberCommServerEventArgs e)
84 {
85 try
86 {
87 if (e.WSHeader["ClientName"] is not null && e.WSHeader["ClientID"] is not null && e.WSHeader["Password"] is not null)
88 {
89 var password = e.WSHeader["Password"]!;
90 var clientName = e.WSHeader["ClientName"]!;
91 var clientUUID = e.WSHeader["ClientID"]!;
92 if (password == Password)
93 {
94 var clientInfo = new XFEConsoleClientInfo(clientName, clientUUID, password, e);
95 ClientInfoDictionary.Add(e.CurrentWebSocket, clientInfo);
96 Connected?.Invoke(this, clientInfo);
97 }
98 }
99 }
100 catch { }
101 try
102 {
103 await e.Close();
104 }
105 catch
106 {
107 try
108 {
109 e.ForceClose();
110 }
111 catch { }
112 }
113 }
114
115 private void Server_ServerStarted(object? sender, EventArgs e)
116 {
117 ClientInfoDictionary = [];
118 }
119 /// <summary>
120 /// 启动服务器
121 /// </summary>
122 /// <returns></returns>
123 public async Task StartServer()
124 {
125 await Server.StartCyberCommServer();
126 }
127 }
Deleted XFEExtension.NetCore/Console/XFEConsoleTextWriter.cs +0 -304
@@ -1,304 +0,0 @@
1 using System.Diagnostics.CodeAnalysis;
2 using System.Text;
3
4 namespace XFEExtension.NetCore.XFEConsole;
5
6 /// <summary>
7 /// XFE控制台文本写入器
8 /// </summary>
9 public class XFEConsoleTextWriter : TextWriter
10 {
11 /// <inheritdoc/>
12 public override Encoding Encoding => Encoding.UTF8;
13
14 /// <inheritdoc/>
15 public override async void Write(bool value)
16 {
17 base.Write(value);
18 await XFEConsole.Write(value.ToString());
19 }
20
21 /// <inheritdoc/>
22 public override async void Write(char value)
23 {
24 base.Write(value);
25 await XFEConsole.Write(value.ToString());
26 }
27
28 /// <inheritdoc/>
29 public override async void Write(char[]? buffer)
30 {
31 base.Write(buffer);
32 if(buffer is not null)
33 {
34 var stringBuilder = new StringBuilder();
35 foreach (var sigChar in buffer)
36 {
37 stringBuilder.Append(sigChar);
38 }
39 await XFEConsole.Write(stringBuilder.ToString());
40 }
41 }
42
43 /// <inheritdoc/>
44 public override async void Write(char[] buffer, int index, int count)
45 {
46 base.Write(buffer, index, count);
47 for (int i = index; i < count; i++)
48 {
49 var stringBuilder = new StringBuilder();
50 stringBuilder.Append(buffer[i]);
51 await XFEConsole.Write(stringBuilder.ToString());
52 }
53 }
54
55 /// <inheritdoc/>
56 public override async void Write(decimal value)
57 {
58 base.Write(value);
59 await XFEConsole.Write(value.ToString());
60 }
61
62 /// <inheritdoc/>
63 public override async void Write(double value)
64 {
65 base.Write(value);
66 await XFEConsole.Write(value.ToString());
67 }
68
69 /// <inheritdoc/>
70 public override async void Write(int value)
71 {
72 base.Write(value);
73 await XFEConsole.Write(value.ToString());
74 }
75
76 /// <inheritdoc/>
77 public override async void Write(long value)
78 {
79 base.Write(value);
80 await XFEConsole.Write(value.ToString());
81 }
82
83 /// <inheritdoc/>
84 public override async void Write(object? value)
85 {
86 base.Write(value);
87 await XFEConsole.Write(value?.ToString());
88 }
89
90 /// <inheritdoc/>
91 public override async void Write(float value)
92 {
93 base.Write(value);
94 await XFEConsole.Write(value.ToString());
95 }
96
97 /// <inheritdoc/>
98 public override async void Write(string? value)
99 {
100 base.Write(value);
101 await XFEConsole.Write(value);
102 }
103
104 /// <inheritdoc/>
105 public override async void Write(StringBuilder? value)
106 {
107 base.Write(value);
108 await XFEConsole.Write(value?.ToString());
109 }
110
111 /// <inheritdoc/>
112 public override async void Write(uint value)
113 {
114 base.Write(value);
115 await XFEConsole.Write(value.ToString());
116 }
117
118 /// <inheritdoc/>
119 public override async void Write(ulong value)
120 {
121 base.Write(value);
122 await XFEConsole.Write(value.ToString());
123 }
124
125 /// <inheritdoc/>
126 public override async Task WriteAsync(char value)
127 {
128 await base.WriteAsync(value);
129 await XFEConsole.Write(value.ToString());
130 }
131
132 /// <inheritdoc/>
133 public override async Task WriteAsync(char[] buffer, int index, int count)
134 {
135 await base.WriteAsync(buffer, index, count);
136 for (int i = index; i < count; i++)
137 {
138 var stringBuilder = new StringBuilder();
139 stringBuilder.Append(buffer[i]);
140 await XFEConsole.Write(stringBuilder.ToString());
141 }
142 }
143
144 /// <inheritdoc/>
145 public override async Task WriteAsync(string? value)
146 {
147 await base.WriteAsync(value);
148 await XFEConsole.Write(value);
149 }
150
151 /// <inheritdoc/>
152 public override async void WriteLine()
153 {
154 base.WriteLine();
155 await XFEConsole.WriteLine("");
156 }
157
158 /// <inheritdoc/>
159 public override async void WriteLine(bool value)
160 {
161 base.WriteLine(value);
162 await XFEConsole.WriteLine(value.ToString());
163 }
164
165 /// <inheritdoc/>
166 public override async void WriteLine(char value)
167 {
168 base.WriteLine(value);
169 await XFEConsole.WriteLine(value.ToString());
170 }
171
172 /// <inheritdoc/>
173 public override async void WriteLine(char[]? buffer)
174 {
175 base.WriteLine(buffer);
176 if (buffer is not null)
177 {
178 var stringBuilder = new StringBuilder();
179 foreach (var sigChar in buffer)
180 {
181 stringBuilder.Append(sigChar);
182 }
183 await XFEConsole.WriteLine(stringBuilder.ToString());
184 }
185 }
186
187 /// <inheritdoc/>
188 public override async void WriteLine(char[] buffer, int index, int count)
189 {
190 base.WriteLine(buffer, index, count);
191 for (int i = index; i < count; i++)
192 {
193 var stringBuilder = new StringBuilder();
194 stringBuilder.Append(buffer[i]);
195 await XFEConsole.WriteLine(stringBuilder.ToString());
196 }
197 }
198
199 /// <inheritdoc/>
200 public override async void WriteLine(decimal value)
201 {
202 base.WriteLine(value);
203 await XFEConsole.WriteLine(value.ToString());
204 }
205
206 /// <inheritdoc/>
207 public override async void WriteLine(double value)
208 {
209 base.WriteLine(value);
210 await XFEConsole.WriteLine(value.ToString());
211 }
212
213 /// <inheritdoc/>
214 public override async void WriteLine(int value)
215 {
216 base.WriteLine(value);
217 await XFEConsole.WriteLine(value.ToString());
218 }
219
220 /// <inheritdoc/>
221 public override async void WriteLine(long value)
222 {
223 base.WriteLine(value);
224 await XFEConsole.WriteLine(value.ToString());
225 }
226
227 /// <inheritdoc/>
228 public override async void WriteLine(object? value)
229 {
230 base.WriteLine(value);
231 if(XFEConsole.AutoAnalyzeObject)
232 await XFEConsole.WriteObject(value);
233 else
234 await XFEConsole.WriteLine(value?.ToString());
235 }
236
237 /// <inheritdoc/>
238 public override async void WriteLine(float value)
239 {
240 base.WriteLine(value);
241 await XFEConsole.WriteLine(value.ToString());
242 }
243
244 /// <inheritdoc/>
245 public override async void WriteLine(string? value)
246 {
247 base.WriteLine(value);
248 await XFEConsole.WriteLine(value);
249 }
250
251 /// <inheritdoc/>
252 public override async void WriteLine(StringBuilder? value)
253 {
254 base.WriteLine(value);
255 await XFEConsole.WriteLine(value?.ToString());
256 }
257
258 /// <inheritdoc/>
259 public override async void WriteLine(uint value)
260 {
261 base.WriteLine(value);
262 await XFEConsole.WriteLine(value.ToString());
263 }
264
265 /// <inheritdoc/>
266 public override async void WriteLine(ulong value)
267 {
268 base.WriteLine(value);
269 await XFEConsole.WriteLine(value.ToString());
270 }
271
272 /// <inheritdoc/>
273 public override async Task WriteLineAsync()
274 {
275 await base.WriteLineAsync();
276 await XFEConsole.WriteLine("");
277 }
278
279 /// <inheritdoc/>
280 public override async Task WriteLineAsync(char value)
281 {
282 await base.WriteLineAsync(value);
283 await XFEConsole.WriteLine(value.ToString());
284 }
285
286 /// <inheritdoc/>
287 public override async Task WriteLineAsync(char[] buffer, int index, int count)
288 {
289 await base.WriteLineAsync(buffer, index, count);
290 for (int i = index; i < count; i++)
291 {
292 var stringBuilder = new StringBuilder();
293 stringBuilder.Append(buffer[i]);
294 await XFEConsole.WriteLine(stringBuilder.ToString());
295 }
296 }
297
298 /// <inheritdoc/>
299 public override async Task WriteLineAsync(string? value)
300 {
301 await base.WriteLineAsync(value);
302 await XFEConsole.WriteLine(value);
303 }
304 }
Modified XFEExtension.NetCore/CyberComm/CyberCommClient.cs +2 -2
@@ -49,7 +49,7 @@ public class CyberCommClient
49 49 /// <summary>
50 50 /// WebSocket客户端
51 51 /// </summary>
52 public ClientWebSocket? ClientWebSocket { get; private set; }
52 public ClientWebSocket ClientWebSocket { get; set; } = new ClientWebSocket();
53 53 #endregion
54 54 #region 公有方法
55 55 /// <summary>
@@ -59,7 +59,6 @@ public class CyberCommClient
59 59 public async Task StartCyberCommClient()
60 60 {
61 61 StartConnect:
62 ClientWebSocket = new ClientWebSocket();
63 62 reconnectTimes++;
64 63 try
65 64 {
@@ -87,6 +86,7 @@ public class CyberCommClient
87 86 return;
88 87 }
89 88 }
89 IsConnected = true;
90 90 Connected?.Invoke(this, EventArgs.Empty);
91 91 reconnectTimes = 0;
92 92 while (ClientWebSocket.State == WebSocketState.Open)
Modified XFEExtension.NetCore/StringExtension/StringExtension.cs +1 -1
Modified XFEExtension.NetCore/XFEExtension.NetCore.csproj +4 -6
Added XFEExtension.NetCore/XFETransform/StringConverter/ColoredObjectAnalyzer.cs +173 -0
Modified XFEExtension.NetCore/XFETransform/StringConverter/StringConverter.cs +4 -0
Modified XFEExtension.sln +9 -0