Refactor: Rename

NatTypeTester-Console/Program.cs

@@ -27,7 +27,7 @@ var dnsClient = new DefaultDnsClient();
 var ip = await dnsClient.QueryAsync(server);
 using var client = new StunClient5389UDP(ip, port, local);
 await client.QueryAsync();
-var res = client.Status;
+var res = client.State;
 
 Console.WriteLine($@"Other address is {res.OtherEndPoint}");
 Console.WriteLine($@"Binding test: {res.BindingTestResult}");

NatTypeTester.ViewModels/RFC3489ViewModel.cs

@@ -69,7 +69,7 @@ namespace NatTypeTester.ViewModels
 			var ip = await DnsClient.QueryAsync(server.Hostname, token);
 			using var client = new StunClient3489(ip, server.Port, Result3489.LocalEndPoint, proxy);
 
-			Result3489 = client.Status;
+			Result3489 = client.State;
 			using (Observable.Interval(TimeSpan.FromSeconds(0.1))
 					.ObserveOn(RxApp.MainThreadScheduler)
 					.Subscribe(_ => this.RaisePropertyChanged(nameof(Result3489))))
@@ -87,7 +87,7 @@ namespace NatTypeTester.ViewModels
 			}
 
 			Result3489 = new ClassicStunResult();
-			Result3489.Clone(client.Status);
+			Result3489.Clone(client.State);
 
 			this.RaisePropertyChanged(nameof(Result3489));
 		}

NatTypeTester.ViewModels/RFC5780ViewModel.cs

@@ -66,7 +66,7 @@ namespace NatTypeTester.ViewModels
 			var ip = await DnsClient.QueryAsync(server.Hostname, token);
 			using var client = new StunClient5389UDP(ip, server.Port, Result5389.LocalEndPoint, proxy);
 
-			Result5389 = client.Status;
+			Result5389 = client.State;
 			using (Observable.Interval(TimeSpan.FromSeconds(0.1))
 					.ObserveOn(RxApp.MainThreadScheduler)
 					.Subscribe(_ => this.RaisePropertyChanged(nameof(Result5389))))
@@ -84,7 +84,7 @@ namespace NatTypeTester.ViewModels
 			}
 
 			Result5389 = new StunResult5389();
-			Result5389.Clone(client.Status);
+			Result5389.Clone(client.State);
 
 			this.RaisePropertyChanged(nameof(Result5389));
 		}

STUN/Client/StunClient3489.cs

@@ -28,7 +28,7 @@ namespace STUN.Client
 
 		private readonly IUdpProxy _proxy;
 
-		public ClassicStunResult Status { get; } = new();
+		public ClassicStunResult State { get; } = new();
 
 		public StunClient3489(IPAddress server, ushort port, IPEndPoint local, IUdpProxy? proxy = null)
 		{
@@ -39,7 +39,7 @@ namespace STUN.Client
 
 			_remoteEndPoint = new IPEndPoint(server, port);
 
-			Status.LocalEndPoint = local;
+			State.LocalEndPoint = local;
 		}
 
 		public virtual async ValueTask ConnectProxyAsync(CancellationToken cancellationToken = default)
@@ -57,29 +57,29 @@ namespace STUN.Client
 
 		public async ValueTask QueryAsync(CancellationToken cancellationToken = default)
 		{
-			Status.Reset();
+			State.Reset();
 
 			// test I
 			var response1 = await Test1Async(cancellationToken);
 			if (response1 is null)
 			{
-				Status.NatType = NatType.UdpBlocked;
+				State.NatType = NatType.UdpBlocked;
 				return;
 			}
 
-			Status.LocalEndPoint = new IPEndPoint(response1.LocalAddress, LocalEndPoint.Port);
+			State.LocalEndPoint = new IPEndPoint(response1.LocalAddress, LocalEndPoint.Port);
 
 			var mappedAddress1 = response1.Message.GetMappedAddressAttribute();
 			var changedAddress = response1.Message.GetChangedAddressAttribute();
 
-			Status.PublicEndPoint = mappedAddress1; // 显示 test I 得到的映射地址
+			State.PublicEndPoint = mappedAddress1; // 显示 test I 得到的映射地址
 
 			// 某些单 IP 服务器的迷惑操作
 			if (mappedAddress1 is null || changedAddress is null
 				|| Equals(changedAddress.Address, response1.Remote.Address)
 				|| changedAddress.Port == response1.Remote.Port)
 			{
-				Status.NatType = NatType.UnsupportedServer;
+				State.NatType = NatType.UnsupportedServer;
 				return;
 			}
 
@@ -93,13 +93,13 @@ namespace STUN.Client
 				// No NAT
 				if (response2 is null)
 				{
-					Status.NatType = NatType.SymmetricUdpFirewall;
-					Status.PublicEndPoint = mappedAddress1;
+					State.NatType = NatType.SymmetricUdpFirewall;
+					State.PublicEndPoint = mappedAddress1;
 				}
 				else
 				{
-					Status.NatType = NatType.OpenInternet;
-					Status.PublicEndPoint = mappedAddress2;
+					State.NatType = NatType.OpenInternet;
+					State.PublicEndPoint = mappedAddress2;
 				}
 				return;
 			}
@@ -109,8 +109,8 @@ namespace STUN.Client
 			{
 				// 有些单 IP 服务器并不能测 NAT 类型，比如 Google 的
 				var type = Equals(response1.Remote.Address, response2.Remote.Address) || response1.Remote.Port == response2.Remote.Port ? NatType.UnsupportedServer : NatType.FullCone;
-				Status.NatType = type;
-				Status.PublicEndPoint = mappedAddress2;
+				State.NatType = type;
+				State.PublicEndPoint = mappedAddress2;
 				return;
 			}
 
@@ -120,14 +120,14 @@ namespace STUN.Client
 
 			if (mappedAddress12 is null)
 			{
-				Status.NatType = NatType.Unknown;
+				State.NatType = NatType.Unknown;
 				return;
 			}
 
 			if (!Equals(mappedAddress12, mappedAddress1))
 			{
-				Status.NatType = NatType.Symmetric;
-				Status.PublicEndPoint = mappedAddress12;
+				State.NatType = NatType.Symmetric;
+				State.PublicEndPoint = mappedAddress12;
 				return;
 			}
 
@@ -140,14 +140,14 @@ namespace STUN.Client
 					&& Equals(response3.Remote.Address, response1.Remote.Address)
 					&& response3.Remote.Port != response1.Remote.Port)
 				{
-					Status.NatType = NatType.RestrictedCone;
-					Status.PublicEndPoint = mappedAddress3;
+					State.NatType = NatType.RestrictedCone;
+					State.PublicEndPoint = mappedAddress3;
 					return;
 				}
 			}
 
-			Status.NatType = NatType.PortRestrictedCone;
-			Status.PublicEndPoint = mappedAddress12;
+			State.NatType = NatType.PortRestrictedCone;
+			State.PublicEndPoint = mappedAddress12;
 		}
 
 		private async ValueTask<StunResponse?> RequestAsync(StunMessage5389 sendMessage, IPEndPoint remote, IPEndPoint receive, CancellationToken cancellationToken)

STUN/Client/StunClient5389UDP.cs

@@ -28,7 +28,7 @@ namespace STUN.Client
 
 		private readonly IUdpProxy _proxy;
 
-		public StunResult5389 Status { get; } = new();
+		public StunResult5389 State { get; } = new();
 
 		public StunClient5389UDP(IPAddress server, ushort port, IPEndPoint local, IUdpProxy? proxy = null)
 		{
@@ -39,7 +39,7 @@ namespace STUN.Client
 
 			_remoteEndPoint = new IPEndPoint(server, port);
 
-			Status.LocalEndPoint = local;
+			State.LocalEndPoint = local;
 		}
 
 		public virtual async ValueTask ConnectProxyAsync(CancellationToken cancellationToken = default)
@@ -57,19 +57,19 @@ namespace STUN.Client
 
 		public async ValueTask QueryAsync(CancellationToken cancellationToken = default)
 		{
-			Status.Reset();
+			State.Reset();
 
 			await FilteringBehaviorTestBaseAsync(cancellationToken);
-			if (Status.BindingTestResult != BindingTestResult.Success
-				|| Status.FilteringBehavior == FilteringBehavior.UnsupportedServer
+			if (State.BindingTestResult != BindingTestResult.Success
+				|| State.FilteringBehavior == FilteringBehavior.UnsupportedServer
 			)
 			{
 				return;
 			}
 
-			if (Equals(Status.PublicEndPoint, Status.LocalEndPoint))
+			if (Equals(State.PublicEndPoint, State.LocalEndPoint))
 			{
-				Status.MappingBehavior = MappingBehavior.Direct;
+				State.MappingBehavior = MappingBehavior.Direct;
 				return;
 			}
 
@@ -88,7 +88,7 @@ namespace STUN.Client
 		{
 			try
 			{
-				Status.Reset();
+				State.Reset();
 				using var cts = new CancellationTokenSource(ReceiveTimeout);
 				await _proxy.ConnectAsync(cts.Token);
 				await BindingTestInternalAsync(cts.Token);
@@ -101,7 +101,7 @@ namespace STUN.Client
 
 		private async Task BindingTestInternalAsync(CancellationToken token)
 		{
-			Status.Clone(await BindingTestBaseAsync(_remoteEndPoint, token));
+			State.Clone(await BindingTestBaseAsync(_remoteEndPoint, token));
 		}
 
 		private async Task<StunResult5389> BindingTestBaseAsync(IPEndPoint remote, CancellationToken token)
@@ -137,28 +137,28 @@ namespace STUN.Client
 		{
 			try
 			{
-				Status.Reset();
+				State.Reset();
 				using var cts = new CancellationTokenSource(ReceiveTimeout);
 				await _proxy.ConnectAsync(cts.Token);
 
 				// test I
 				await BindingTestInternalAsync(cts.Token);
-				if (Status.BindingTestResult != BindingTestResult.Success)
+				if (State.BindingTestResult != BindingTestResult.Success)
 				{
 					return;
 				}
 
-				if (Status.OtherEndPoint is null
-					|| Equals(Status.OtherEndPoint.Address, _remoteEndPoint.Address)
-					|| Status.OtherEndPoint.Port == _remoteEndPoint.Port)
+				if (State.OtherEndPoint is null
+					|| Equals(State.OtherEndPoint.Address, _remoteEndPoint.Address)
+					|| State.OtherEndPoint.Port == _remoteEndPoint.Port)
 				{
-					Status.MappingBehavior = MappingBehavior.UnsupportedServer;
+					State.MappingBehavior = MappingBehavior.UnsupportedServer;
 					return;
 				}
 
-				if (Equals(Status.PublicEndPoint, Status.LocalEndPoint))
+				if (Equals(State.PublicEndPoint, State.LocalEndPoint))
 				{
-					Status.MappingBehavior = MappingBehavior.Direct;
+					State.MappingBehavior = MappingBehavior.Direct;
 					return;
 				}
 
@@ -180,16 +180,16 @@ namespace STUN.Client
 
 		private async Task<(bool, StunResult5389)> MappingBehaviorTestBase2Async(CancellationToken token)
 		{
-			var result2 = await BindingTestBaseAsync(new IPEndPoint(Status.OtherEndPoint!.Address, _remoteEndPoint.Port), token);
+			var result2 = await BindingTestBaseAsync(new IPEndPoint(State.OtherEndPoint!.Address, _remoteEndPoint.Port), token);
 			if (result2.BindingTestResult != BindingTestResult.Success)
 			{
-				Status.MappingBehavior = MappingBehavior.Fail;
+				State.MappingBehavior = MappingBehavior.Fail;
 				return (false, result2);
 			}
 
-			if (Equals(result2.PublicEndPoint, Status.PublicEndPoint))
+			if (Equals(result2.PublicEndPoint, State.PublicEndPoint))
 			{
-				Status.MappingBehavior = MappingBehavior.EndpointIndependent;
+				State.MappingBehavior = MappingBehavior.EndpointIndependent;
 				return (false, result2);
 			}
 
@@ -198,30 +198,30 @@ namespace STUN.Client
 
 		private async Task MappingBehaviorTestBase3Async(StunResult5389 result2, CancellationToken token)
 		{
-			var result3 = await BindingTestBaseAsync(Status.OtherEndPoint!, token);
+			var result3 = await BindingTestBaseAsync(State.OtherEndPoint!, token);
 			if (result3.BindingTestResult != BindingTestResult.Success)
 			{
-				Status.MappingBehavior = MappingBehavior.Fail;
+				State.MappingBehavior = MappingBehavior.Fail;
 				return;
 			}
 
-			Status.MappingBehavior = Equals(result3.PublicEndPoint, result2.PublicEndPoint) ? MappingBehavior.AddressDependent : MappingBehavior.AddressAndPortDependent;
+			State.MappingBehavior = Equals(result3.PublicEndPoint, result2.PublicEndPoint) ? MappingBehavior.AddressDependent : MappingBehavior.AddressAndPortDependent;
 		}
 
 		private async Task FilteringBehaviorTestBaseAsync(CancellationToken token)
 		{
 			// test I
 			await BindingTestInternalAsync(token);
-			if (Status.BindingTestResult != BindingTestResult.Success)
+			if (State.BindingTestResult != BindingTestResult.Success)
 			{
 				return;
 			}
 
-			if (Status.OtherEndPoint is null
-				|| Equals(Status.OtherEndPoint.Address, _remoteEndPoint.Address)
-				|| Status.OtherEndPoint.Port == _remoteEndPoint.Port)
+			if (State.OtherEndPoint is null
+				|| Equals(State.OtherEndPoint.Address, _remoteEndPoint.Address)
+				|| State.OtherEndPoint.Port == _remoteEndPoint.Port)
 			{
-				Status.FilteringBehavior = FilteringBehavior.UnsupportedServer;
+				State.FilteringBehavior = FilteringBehavior.UnsupportedServer;
 				return;
 			}
 
@@ -231,11 +231,11 @@ namespace STUN.Client
 				StunMessageType = StunMessageType.BindingRequest,
 				Attributes = new[] { AttributeExtensions.BuildChangeRequest(true, true) }
 			};
-			var (response2, _, _) = await TestAsync(test2, _remoteEndPoint, Status.OtherEndPoint, token);
+			var (response2, _, _) = await TestAsync(test2, _remoteEndPoint, State.OtherEndPoint, token);
 
 			if (response2 is not null)
 			{
-				Status.FilteringBehavior = FilteringBehavior.EndpointIndependent;
+				State.FilteringBehavior = FilteringBehavior.EndpointIndependent;
 				return;
 			}
 
@@ -249,17 +249,17 @@ namespace STUN.Client
 
 			if (response3 is null || remote3 is null)
 			{
-				Status.FilteringBehavior = FilteringBehavior.AddressAndPortDependent;
+				State.FilteringBehavior = FilteringBehavior.AddressAndPortDependent;
 				return;
 			}
 
 			if (Equals(remote3.Address, _remoteEndPoint.Address) && remote3.Port != _remoteEndPoint.Port)
 			{
-				Status.FilteringBehavior = FilteringBehavior.AddressAndPortDependent;
+				State.FilteringBehavior = FilteringBehavior.AddressAndPortDependent;
 			}
 			else
 			{
-				Status.FilteringBehavior = FilteringBehavior.UnsupportedServer;
+				State.FilteringBehavior = FilteringBehavior.UnsupportedServer;
 			}
 		}
 
@@ -267,7 +267,7 @@ namespace STUN.Client
 		{
 			try
 			{
-				Status.Reset();
+				State.Reset();
 				using var cts = new CancellationTokenSource(ReceiveTimeout);
 				await _proxy.ConnectAsync(cts.Token);
 				await FilteringBehaviorTestBaseAsync(cts.Token);

UnitTest/StunClient3489Test.cs

@@ -41,9 +41,9 @@ namespace UnitTest
 
 			mock.Setup(x => x.Test1Async(It.IsAny<CancellationToken>())).ReturnsAsync((StunResponse?)null);
 
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.UdpBlocked, client.Status.NatType);
+			Assert.AreEqual(NatType.UdpBlocked, client.State.NatType);
 		}
 
 		[TestMethod]
@@ -101,10 +101,10 @@ namespace UnitTest
 
 			async Task TestAsync()
 			{
-				Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+				Assert.AreEqual(NatType.Unknown, client.State.NatType);
 				await client.QueryAsync();
-				Assert.AreEqual(NatType.UnsupportedServer, client.Status.NatType);
-				client.Status.Reset();
+				Assert.AreEqual(NatType.UnsupportedServer, client.State.NatType);
+				client.State.Reset();
 			}
 		}
 
@@ -142,17 +142,17 @@ namespace UnitTest
 			mock.Setup(x => x.LocalEndPoint).Returns(MappedAddress1);
 			mock.Setup(x => x.Test2Async(It.IsAny<IPEndPoint>(), It.IsAny<CancellationToken>())).ReturnsAsync(test2Response);
 
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.OpenInternet, client.Status.NatType);
-			client.Status.Reset();
+			Assert.AreEqual(NatType.OpenInternet, client.State.NatType);
+			client.State.Reset();
 
 			mock.Setup(x => x.Test2Async(It.IsAny<IPEndPoint>(), It.IsAny<CancellationToken>())).ReturnsAsync((StunResponse?)null);
 
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.SymmetricUdpFirewall, client.Status.NatType);
-			client.Status.Reset();
+			Assert.AreEqual(NatType.SymmetricUdpFirewall, client.State.NatType);
+			client.State.Reset();
 		}
 
 		[TestMethod]
@@ -222,10 +222,10 @@ namespace UnitTest
 			mock.Setup(x => x.LocalEndPoint).Returns(LocalAddress1);
 			mock.Setup(x => x.Test2Async(It.IsAny<IPEndPoint>(), It.IsAny<CancellationToken>())).ReturnsAsync(fullConeResponse);
 
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.FullCone, client.Status.NatType);
-			client.Status.Reset();
+			Assert.AreEqual(NatType.FullCone, client.State.NatType);
+			client.State.Reset();
 
 			mock.Setup(x => x.Test2Async(It.IsAny<IPEndPoint>(), It.IsAny<CancellationToken>())).ReturnsAsync(unsupportedResponse1);
 			await TestUnsupportedServerAsync();
@@ -238,10 +238,10 @@ namespace UnitTest
 
 			async Task TestUnsupportedServerAsync()
 			{
-				Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+				Assert.AreEqual(NatType.Unknown, client.State.NatType);
 				await client.QueryAsync();
-				Assert.AreEqual(NatType.UnsupportedServer, client.Status.NatType);
-				client.Status.Reset();
+				Assert.AreEqual(NatType.UnsupportedServer, client.State.NatType);
+				client.State.Reset();
 			}
 		}
 
@@ -280,16 +280,16 @@ namespace UnitTest
 			mock.Setup(x => x.Test2Async(It.IsAny<IPEndPoint>(), It.IsAny<CancellationToken>())).ReturnsAsync((StunResponse?)null);
 			mock.Setup(x => x.Test1_2Async(It.IsAny<IPEndPoint>(), It.IsAny<CancellationToken>())).ReturnsAsync((StunResponse?)null);
 
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
-			client.Status.Reset();
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
+			client.State.Reset();
 
 			mock.Setup(x => x.Test1_2Async(It.IsAny<IPEndPoint>(), It.IsAny<CancellationToken>())).ReturnsAsync(test12Response);
 
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.Symmetric, client.Status.NatType);
+			Assert.AreEqual(NatType.Symmetric, client.State.NatType);
 		}
 
 		[TestMethod]
@@ -340,21 +340,21 @@ namespace UnitTest
 			mock.Setup(x => x.Test1_2Async(It.IsAny<IPEndPoint>(), It.IsAny<CancellationToken>())).ReturnsAsync(test1Response);
 
 			mock.Setup(x => x.Test3Async(It.IsAny<CancellationToken>())).ReturnsAsync(test3Response);
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.RestrictedCone, client.Status.NatType);
-			client.Status.Reset();
+			Assert.AreEqual(NatType.RestrictedCone, client.State.NatType);
+			client.State.Reset();
 
 			mock.Setup(x => x.Test3Async(It.IsAny<CancellationToken>())).ReturnsAsync(test3ErrorResponse);
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.PortRestrictedCone, client.Status.NatType);
-			client.Status.Reset();
+			Assert.AreEqual(NatType.PortRestrictedCone, client.State.NatType);
+			client.State.Reset();
 
 			mock.Setup(x => x.Test3Async(It.IsAny<CancellationToken>())).ReturnsAsync((StunResponse?)null);
-			Assert.AreEqual(NatType.Unknown, client.Status.NatType);
+			Assert.AreEqual(NatType.Unknown, client.State.NatType);
 			await client.QueryAsync();
-			Assert.AreEqual(NatType.PortRestrictedCone, client.Status.NatType);
+			Assert.AreEqual(NatType.PortRestrictedCone, client.State.NatType);
 		}
 
 		[TestMethod]