C# IPAddress.ThrowIfNull方法代码示例

		/// <summary>
		/// Determines whether the IP address is in the same subnet as the
		/// specified IP address.
		/// </summary>
		/// <param name="address">The IPAddress instance this is being called
		/// for.</param>
		/// <param name="other">The IP address to determine whether it is in the same
		/// subnet.</param>
		/// <param name="netmask">The subnetmask to apply.</param>
		/// <returns>true if both IP address are located in the same subnet; Otherwise
		/// false.</returns>
		/// <exception cref="ArgumentNullException">The other parameter or the netmask
		/// parameter is null.</exception>
		/// <exception cref="ArgumentException">The netmask and IP address must be
		/// of the same address family.</exception>
		/// <remarks>This is an extension method for the IPAddress class.</remarks>
		public static bool InSameSubnet(this IPAddress address, IPAddress other,
			IPAddress netmask) {
			other.ThrowIfNull("other");
			netmask.ThrowIfNull("netmask");

			return address.And(netmask).Equals(other.And(netmask));
		}

		public async Task<ValidateResponseResult> ValidateResponseAsync(IPAddress ipAddress, string challenge, string response)
		{
			ipAddress.ThrowIfNull("ipAddress");
			challenge.ThrowIfNull("challenge");
			response.ThrowIfNull("response");

			if (!_configuration.Enabled)
			{
				return ValidateResponseResult.ServiceDisabled;
			}

			var requestMessage =
				new HttpRequestMessage(HttpMethod.Post, _configuration.Url)
				{
					Content = new FormUrlEncodedContent(
						new[]
						{
							new KeyValuePair<string, string>("privatekey", _configuration.PrivateKey),
							new KeyValuePair<string, string>("remoteip", ipAddress.ToString()),
							new KeyValuePair<string, string>("challenge", challenge),
							new KeyValuePair<string, string>("response", response)
						})
				};

			requestMessage.Headers.Add("User-Agent", _configuration.UserAgent);

			HttpResponseMessage responseMessage = await HttpClientSingleton.Instance.SendAsync(requestMessage);
			string responseContent = await responseMessage.Content.ReadAsStringAsync();
			string[] lines = responseContent.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);

			return lines.Length > 0 && lines[0] == "true" ? ValidateResponseResult.Valid : ValidateResponseResult.Invalid;
		}

		/// <summary>
		/// Bitwise ANDs the IP address with the specified netmask.
		/// </summary>
		/// <param name="address">The IPAddress instance to AND with the specified
		/// netmask.</param>
		/// <param name="netmask">The netmask to bitwise AND with the IP
		/// address.</param>
		/// <returns>The result of the bitwise AND.</returns>
		/// <exception cref="ArgumentNullException">The netmask parameter is
		/// null.</exception>
		/// <exception cref="ArgumentException">The netmask and IP address must be
		/// of the same address family.</exception>
		/// <remarks>This is an extension method for the IPAddress class.</remarks>
		static IPAddress And(this IPAddress address, IPAddress netmask) {
			netmask.ThrowIfNull("netmask");
			if (address.AddressFamily != netmask.AddressFamily)
				throw new ArgumentException("The address family of the specified netmask " +
					"is different from the address family of the IP address.");
			byte[] buffer = address.GetAddressBytes();
			byte[] other = netmask.GetAddressBytes();
			for (int i = 0; i < buffer.Length; i++)
				buffer[i] = (byte) (buffer[i] & other[i]);
			return new IPAddress(buffer);
		}

		/// <summary>
		/// Initializes a new instance of the SocksReply class.
		/// </summary>
		/// <param name="status">The status of the response.</param>
		/// <param name="address">The server bound IP address.</param>
		/// <param name="port">The server bound port.</param>
		/// <exception cref="ArgumentNullException">The address parameter
		/// is null.</exception>
		public SocksReply(ReplyStatus status, IPAddress address, ushort port) {
			address.ThrowIfNull("address");
			Status = status;
			ATyp = address.AddressFamily == AddressFamily.InterNetworkV6 ?
				ATyp.IPv6 : ATyp.IPv4;
			Address = address;
			Port = port;
		}

 /// <summary>
 /// Initializes a new instance of the Socks5Client class and connects to the
 /// specified port on the specified host.
 /// </summary>
 /// <param name="address">The IP address of the remote host to which you intend
 /// to connect.</param>
 /// <param name="port">The port number of the remote host to which you intend
 /// to connect.</param>
 /// <param name="username">The username with which to authenticate if the
 /// server requires authentication.</param>
 /// <param name="password">The password with which to authenticate if the
 /// server requires authentication.</param>
 /// <exception cref="ArgumentNullException">The address parameter is
 /// null.</exception>
 /// <exception cref="ArgumentOutOfRangeException">The port parameter is not
 /// between 0 and 65535.</exception>
 /// <exception cref="SocketException">An error occurred when accessing the
 /// socket.</exception>
 /// <exception cref="Socks5Exception">The server returned invalid data, or
 /// authentication with the SOCKS5 server failed.</exception>
 public Socks5Client(IPAddress address, int port, string username = null,
     string password = null)
 {
     address.ThrowIfNull("address");
     port.ThrowIfOutOfRange("port", 0, 65535);
     Username = username;
     Password = password;
     client = new TcpClient();
     client.Connect(address, port);
     InitializeConnection();
 }

		/// <summary>
		/// Initializes a new instance of the BindingResponse class.
		/// </summary>
		/// <param name="id">The transaction id of the binding response.</param>
		/// <param name="address">The IP address containd in the binding
		/// response message.</param>
		/// <exception cref="ArgumentNullException">The id parameter or the
		/// address parameter is null.</exception>
		internal BindingResponse(byte[] id, IPAddress address) {
			id.ThrowIfNull("id");
			address.ThrowIfNull("address");
			Id = id;
			Address = address;
		}

 /// <summary>
 /// Queries the STUN server with the specified IP address for the public IP
 /// address of the requesting host.
 /// </summary>
 /// <param name="address">The IP address of the STUN server to query.</param>
 /// <param name="port">The port on which the STUN service is running at
 /// the specified host.</param>
 /// <param name="timeout">The maximum number of milliseconds to wait for
 /// a server response before returning to the caller.</param>
 /// <returns>The public IP address of the requesting host.</returns>
 /// <exception cref="ArgumentNullException">The address parameter is
 /// null.</exception>
 /// <exception cref="ArgumentOutOfRangeException">The port is not between
 /// 0 and 65535.</exception>
 /// <exception cref="ProtocolViolationException">The specified STUN
 /// server returned an erroneous response.</exception>
 /// <exception cref="SocketException">The specified hostname could not be
 /// resolved, or an error occurred while sending the request or while
 /// retrieving the response, or the specified STUN server could not be
 /// reached.</exception>
 /// <exception cref="TimeoutException">The specified timeout has
 /// expired.</exception>
 public static IPAddress Query(IPAddress address, int port = 3478,
     int timeout = Int32.MaxValue)
 {
     address.ThrowIfNull("address");
     port.ThrowIfOutOfRange("port", 0, 65535);
     IPEndPoint IpEp = new IPEndPoint(address, port);
     var request = new BindingRequest().Serialize();
     int rto = initialRto;
     using (UdpClient udp = new UdpClient())
     {
         // The timeout mechanism is similar to TCP. For details,
         // refer to RFC 5389, Section 7.2.1. Sending over UDP.
         for (int tries = 0; tries < rc; tries++)
         {
             // Transmit the datagram.
             udp.Send(request, request.Length, IpEp);
             // Set the timeout value on the socket.
             udp.Client.ReceiveTimeout = rto;
             try
             {
                 byte[] datagram = udp.Receive(ref IpEp);
                 return BindingResponse.Deserialize(datagram).Address;
             }
             catch (SocketException e)
             {
                 if (e.ErrorCode != connectionTimeout)
                     throw;
                 timeout = timeout - rto;
                 if (timeout <= 0)
                     throw new TimeoutException("The timeout has expired.");
             }
             catch (SerializationException)
             {
                 throw new ProtocolViolationException("The STUN " +
                     "Binding Response is invalid.");
             }
             // Increase the timeout value.
             if (tries < (rc - 1))
                 rto = rto * 2;
             else
                 rto = initialRto * rm;
             if (timeout < rto)
                 rto = timeout;
         }
         // Give up.
         throw new SocketException(connectionTimeout);
     }
 }

		/// <summary>
		/// Initializes a new instance of the SocksRequest class.
		/// </summary>
		/// <param name="command">The command of the request.</param>
		/// <param name="destination">The IP address of the destination host.</param>
		/// <param name="port">The port of the destination host.</param>
		/// <exception cref="ArgumentNullException">The destination parameter
		/// is null.</exception>
		public SocksRequest(SocksCommand command, IPAddress destination,
			ushort port) {
			destination.ThrowIfNull("destination");
			Command = command;
			ATyp = destination.AddressFamily == AddressFamily.InterNetworkV6 ?
				ATyp.IPv6 : ATyp.IPv4;
			Destination = destination;
			Port = port;
		}