// Is the host reachable with the current network configuration
public static bool IsHostReachable(string host)
{
if (string.IsNullOrEmpty(host))
return false;
using (var r = new NetworkReachability(host)) {
NetworkReachabilityFlags flags;
if (r.TryGetFlags(out flags))
return IsReachableWithoutRequiringConnection(flags);
}
return false;
}
// Is the host reachable with the current network configuration
public static bool IsHostReachable (string host)
{
if (host == null || host.Length == 0)
return false;
using (var r = new NetworkReachability (host)){
NetworkReachabilityFlags flags;
if (r.TryGetFlags (out flags)){
return IsReachableWithoutRequiringConnection (flags);
}
}
return false;
}
void InitializeReachability ()
{
networkReachability = new NetworkReachability (IPAddress.Any);
networkReachability.SetNotification (flags => UpdateReachability (flags, NetworkIcon, NetworkStatusTextField));
networkReachability.Schedule ();
NetworkReachabilityFlags networkReachabilityFlags;
networkReachability.TryGetFlags (out networkReachabilityFlags);
UpdateReachability (networkReachabilityFlags, NetworkIcon, NetworkStatusTextField);
CreateHostReachability ();
HostTextField.Changed += (sender, e) => CreateHostReachability ();
}
// Is the host reachable with the current network configuration
public static bool IsHostReachable(string host)
{
if (string.IsNullOrEmpty(host))
{
return(false);
}
using (var r = new NetworkReachability(host))
{
NetworkReachabilityFlags flags;
if (r.TryGetFlags(out flags))
{
return(IsReachableWithoutRequiringConnection(flags));
}
}
return(false);
}
public static bool StaticIsHostReachable(string host)
{
if (host == null || host.Length == 0)
{
return(false);
}
using (var r = new NetworkReachability(host))
{
NetworkReachabilityFlags flags;
if (r.TryGetFlags(out flags))
{
return(IsReachableWithoutRequiringConnection(flags));
}
}
return(false);
}
public void CtorIPAddress()
{
using (var nr = new NetworkReachability(IPAddress.Loopback))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#1");
// inconsistent results across different iOS versions
// < 9.0 -> Reachable | IsLocalAddress
// 9.x -> Reachable | IsLocalAddress | IsDirect
// 10.0 -> Reachable
// so we're only checking the (most important) Reachable flag
Assert.True((flags & NetworkReachabilityFlags.Reachable) != 0, "Reachable");
}
using (var nr = new NetworkReachability(new IPAddress(new byte[] { 10, 99, 99, 99 })))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#2");
//Assert.That (flags, Is.EqualTo (NetworkReachabilityFlags.Reachable), "#2 Reachable");
}
using (var nr = new NetworkReachability(IPAddress.IPv6Loopback))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#3");
//Assert.That (flags, Is.EqualTo (
// NetworkReachabilityFlags.TransientConnection | NetworkReachabilityFlags.Reachable | NetworkReachabilityFlags.ConnectionRequired), "#3 Reachable");
}
using (var nr = new NetworkReachability(IPAddress.Parse("2001:4860:4860::8844")))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#4");
// TODO: Will probably change when IPv6 is enabled locally
//Assert.That (flags, Is.EqualTo (
// NetworkReachabilityFlags.TransientConnection | NetworkReachabilityFlags.Reachable | NetworkReachabilityFlags.ConnectionRequired), "#4 Reachable");
}
}
// Is the host reachable with the current network configuration
public static bool IsHostReachable()
{
//RemoteHostStatus();
if (string.IsNullOrEmpty(HostName))
{
return(false);
}
using (var r = new NetworkReachability(HostName))
{
NetworkReachabilityFlags flags;
if (r.TryGetFlags(out flags))
{
return(IsReachableWithoutRequiringConnection(flags));
}
}
return(false);
}
/// <summary>
/// Checks ad hoc wifi is available
/// </summary>
/// <param name="flags"></param>
/// <returns></returns>
public static bool IsAdHocWiFiNetworkAvailable(out NetworkReachabilityFlags flags)
{
if (adHocWiFiNetworkReachability == null)
{
//var ip = IPAddress.Parse("::ffff:169.254.0.0");
//var data = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 169, 254, 0, 0 };
var ip = new IPAddress(new byte[] { 169, 254, 0, 0 });
adHocWiFiNetworkReachability = new NetworkReachability(ip);
adHocWiFiNetworkReachability.SetNotification(OnChange);
adHocWiFiNetworkReachability.Schedule(CFRunLoop.Main, CFRunLoop.ModeDefault);
}
if (!adHocWiFiNetworkReachability.TryGetFlags(out flags))
{
return(false);
}
return(IsReachableWithoutRequiringConnection(flags));
}
public static bool IsAdHocWiFiNetworkAvailable(out NetworkReachabilityFlags flags)
{
if (adHocWiFiNetworkReachability == null)
{
adHocWiFiNetworkReachability = new NetworkReachability(new IPAddress(new byte[] { 169, 254, 0, 0 }));
//Changed for SetNotification
//adHocWiFiNetworkReachability.SetCallback(OnChange);
adHocWiFiNetworkReachability.SetNotification(new NetworkReachability.Notification(OnChange));
adHocWiFiNetworkReachability.Schedule(CFRunLoop.Current, CFRunLoop.ModeDefault);
}
if (!adHocWiFiNetworkReachability.TryGetFlags(out flags))
{
return(false);
}
return(IsReachableWithoutRequiringConnection(flags));
}
public void CtorIPAddress()
{
using (var nr = new NetworkReachability(IPAddress.Loopback))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#1");
var expected = NetworkReachabilityFlags.Reachable | NetworkReachabilityFlags.IsLocalAddress;
if (UIDevice.CurrentDevice.CheckSystemVersion(9, 0))
{
expected |= NetworkReachabilityFlags.IsDirect; // make sense
}
Assert.That(flags, Is.EqualTo(expected), "#1 Reachable");
}
using (var nr = new NetworkReachability(new IPAddress(new byte[] { 10, 99, 99, 99 })))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#2");
//Assert.That (flags, Is.EqualTo (NetworkReachabilityFlags.Reachable), "#2 Reachable");
}
using (var nr = new NetworkReachability(IPAddress.IPv6Loopback))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#3");
//Assert.That (flags, Is.EqualTo (
// NetworkReachabilityFlags.TransientConnection | NetworkReachabilityFlags.Reachable | NetworkReachabilityFlags.ConnectionRequired), "#3 Reachable");
}
using (var nr = new NetworkReachability(IPAddress.Parse("2001:4860:4860::8844")))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#4");
// TODO: Will probably change when IPv6 is enabled locally
//Assert.That (flags, Is.EqualTo (
// NetworkReachabilityFlags.TransientConnection | NetworkReachabilityFlags.Reachable | NetworkReachabilityFlags.ConnectionRequired), "#4 Reachable");
}
}
bool IsHostReachable(string host)
{
// Note that I'm not using Apple's Reachability code. This is based on part of
// https://github.com/xamarin/monotouch-samples/blob/master/ReachabilitySample/reachability.cs
// which started as a port of reachability.m but I"m only using what I have to.
if (string.IsNullOrEmpty(host))
{
return(false);
}
using (var r = new NetworkReachability(host)) {
NetworkReachabilityFlags flags;
if (r.TryGetFlags(flags))
{
return(IsReachableWithoutRequiringConnection(flags));
}
}
return(false);
}
/// <summary>
/// Checks if host is reachable
/// </summary>
/// <param name="host"></param>
/// <param name="port"></param>
/// <returns></returns>
public static bool IsHostReachable (string host, int port)
{
if (string.IsNullOrWhiteSpace (host))
return false;
IPAddress address;
if (!IPAddress.TryParse (host + ":" + port, out address)) {
Debug.WriteLine (host + ":" + port + " is not valid");
return false;
}
using (var r = new NetworkReachability (host)) {
NetworkReachabilityFlags flags;
if (r.TryGetFlags (out flags)) {
return IsReachableWithoutRequiringConnection (flags);
}
}
return false;
}
/// <summary>
/// Checks the remote host status
/// </summary>
/// <returns></returns>
public static NetworkStatus RemoteHostStatus()
{
NetworkReachabilityFlags flags;
bool reachable;
if (remoteHostReachability == null)
{
remoteHostReachability = new NetworkReachability(HostName);
// Need to probe before we queue, or we wont get any meaningful values
// this only happens when you create NetworkReachability from a hostname
reachable = remoteHostReachability.TryGetFlags(out flags);
remoteHostReachability.SetNotification(OnChange);
remoteHostReachability.Schedule(CFRunLoop.Main, CFRunLoop.ModeDefault);
}
else
{
reachable = remoteHostReachability.TryGetFlags(out flags);
}
if (!reachable)
{
return(NetworkStatus.NotReachable);
}
if (!IsReachableWithoutRequiringConnection(flags))
{
return(NetworkStatus.NotReachable);
}
#if __IOS__
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
{
return(NetworkStatus.ReachableViaCarrierDataNetwork);
}
#endif
return(NetworkStatus.ReachableViaWiFiNetwork);
}
public static bool IsReachable()
{
NetworkReachabilityFlags flags;
if (defaultRouteReachability == null)
{
defaultRouteReachability = new NetworkReachability(new IPAddress(0));
defaultRouteReachability.Schedule(CFRunLoop.Current, CFRunLoop.ModeDefault);
}
var defaultRouteAvailable = defaultRouteReachability.TryGetFlags(out flags);
var isReachable = (flags & NetworkReachabilityFlags.Reachable) != 0;
var noConnectionRequired = (flags & NetworkReachabilityFlags.ConnectionRequired) == 0 ||
(flags & NetworkReachabilityFlags.IsWWAN) != 0;
var canReachWithoutConnection =
isReachable &&
noConnectionRequired;
var defaultNetworkAvailable =
defaultRouteAvailable &&
canReachWithoutConnection;
if (defaultNetworkAvailable && ((flags & NetworkReachabilityFlags.IsDirect) != 0))
{
return(false);
}
else if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
{
return(true);
}
else if (flags == 0)
{
return(false);
}
return(true);
}
public static MvxReachabilityStatus RemoteHostStatus()
{
NetworkReachabilityFlags flags;
bool reachable;
if (remoteHostReachability == null)
{
remoteHostReachability = new NetworkReachability(DefaultHostName);
// Need to probe before we queue, or we wont get any meaningful values
// this only happens when you create NetworkReachability from a hostname
reachable = remoteHostReachability.TryGetFlags(out flags);
#warning Need to look at SetNotification instead - ios6 change
remoteHostReachability.SetNotification(OnChange);
remoteHostReachability.Schedule(CFRunLoop.Current, CFRunLoop.ModeDefault);
}
else
{
reachable = remoteHostReachability.TryGetFlags(out flags);
}
if (!reachable)
{
return(MvxReachabilityStatus.Not);
}
if (!IsReachableWithoutRequiringConnection(flags))
{
return(MvxReachabilityStatus.Not);
}
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
{
return(MvxReachabilityStatus.ViaCarrierDataNetwork);
}
return(MvxReachabilityStatus.ViaWiFiNetwork);
}
/// <summary>
/// Checks the remote host status
/// </summary>
/// <returns></returns>
public ConnectionType RemoteHostStatus()
{
NetworkReachabilityFlags flags;
bool reachable;
if (_remoteHostReachability == null)
{
_remoteHostReachability = new NetworkReachability(HostName);
// Need to probe before we queue, or we wont get any meaningful values
// this only happens when you create NetworkReachability from a hostname
reachable = _remoteHostReachability.TryGetFlags(out flags);
_remoteHostReachability.SetNotification(OnChange);
_remoteHostReachability.Schedule(CFRunLoop.Main, CFRunLoop.ModeDefault);
}
else
{
reachable = _remoteHostReachability.TryGetFlags(out flags);
}
if (!reachable)
{
return(ConnectionType.None);
}
if (!IsReachableWithoutRequiringConnection(flags))
{
return(ConnectionType.None);
}
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
{
return(ConnectionType.Cellular);
}
return(ConnectionType.WiFi);
}
public ReachabilityService(IConfiguration configuration)
{
_configuration = configuration;
_reachability = new NetworkReachability(_configuration.Host);
_initializeTask = Task.Run(() =>
{
NetworkReachabilityFlags flags;
var resultFlags = _reachability.TryGetFlags(out flags)
? flags
: (NetworkReachabilityFlags)0;
return(resultFlags);
})
.ContinueWithUIThread(previousTask =>
{
OnNotification(previousTask.Result);
_reachability.SetNotification(OnNotification);
_reachability.Schedule();
});
}
public static bool IsNetworkAvaialable(bool sendMessage)
{
using (var r = new NetworkReachability(HostName)){
NetworkReachabilityFlags flags;
if (r.TryGetFlags(out flags))
{
// bool resp =IsReachableWithoutRequiringConnection (flags);
Console.WriteLine("Internet Connection: " + IsReachableWithoutRequiringConnection(flags));
if (!IsReachableWithoutRequiringConnection(flags) && sendMessage)
{
return(false);//Tools.ShowAlert (Language.GetString ("BEM00121"));//No hay conexiﾃ嗜 a Internet no podra realizar ninguna busqueda
}
return(IsReachableWithoutRequiringConnection(flags));
}
}
Console.WriteLine("Internet Connection: False");
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="host">
/// A <see cref="System.String"/>
/// </param>
/// <returns>
/// A <see cref="NetworkType"/>
/// </returns>
private static NetworkType RemoteHostStatus(string host)
{
bool reachable = IsHostReachable(host);;
if (!reachable)
{
return(NetworkType.Unknown);
}
using (var r = new NetworkReachability(host)){
NetworkReachabilityFlags flags;
if (r.TryGetFlags(out flags))
{
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
{
//return NetworkType.Carrier_GSM; // TODO get which type of carrier is being used.
return(NetworkType.Carrier_3G); // HARDCODED.
}
}
}
return(NetworkType.Wifi);
}
void CreateHostReachability()
{
if (hostReachability != null)
{
hostReachability.Unschedule();
hostReachability.Dispose();
}
if (String.IsNullOrEmpty(HostTextField.StringValue))
{
HostIcon.Image = NSImage.ImageNamed("disconnected");
HostStatusTextField.StringValue = "Enter a host name or IP address";
return;
}
hostReachability = new NetworkReachability(HostTextField.StringValue);
hostReachability.SetNotification(flags => UpdateReachability(flags, HostIcon, HostStatusTextField));
hostReachability.Schedule();
NetworkReachabilityFlags networkReachabilityFlags;
networkReachability.TryGetFlags(out networkReachabilityFlags);
UpdateReachability(networkReachabilityFlags, NetworkIcon, NetworkStatusTextField);
}
public static NetworkStatus RemoteHostStatus()
{
NetworkReachabilityFlags flags;
bool reachable;
if (remoteHostReachability == null)
{
remoteHostReachability = new NetworkReachability(HostName);
reachable = remoteHostReachability.TryGetFlags(out flags);
remoteHostReachability.SetNotification(OnChange);
remoteHostReachability.Schedule(CFRunLoop.Current, CFRunLoop.ModeDefault);
}
else
{
reachable = remoteHostReachability.TryGetFlags(out flags);
}
if (!reachable)
{
return(NetworkStatus.NotReachable);
}
if (!IsReachableWithoutRequiringConnection(flags))
{
return(NetworkStatus.NotReachable);
}
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
{
return(NetworkStatus.ReachableViaCarrierDataNetwork);
}
return(NetworkStatus.ReachableViaWiFiNetwork);
}
/// <summary>
/// Checks if host is reachable
/// </summary>
/// <param name="host"></param>
/// <param name="port"></param>
/// <returns></returns>
public static bool IsHostReachable(string host, int port)
{
if (string.IsNullOrWhiteSpace(host))
{
return(false);
}
IPAddress address;
if (!IPAddress.TryParse(host + ":" + port, out address))
{
Debug.WriteLine(host + ":" + port + " is not valid");
return(false);
}
using (var r = new NetworkReachability(host)) {
NetworkReachabilityFlags flags;
if (r.TryGetFlags(out flags))
{
return(IsReachableWithoutRequiringConnection(flags));
}
}
return(false);
}
public static NetworkStatus RemoteHostStatus(string HostName)
{
NetworkReachabilityFlags flags;
bool reachable;
if (remoteHostReachability == null) {
remoteHostReachability = new NetworkReachability (HostName);
// Need to probe before we queue, or we wont get any meaningful values
// this only happens when you create NetworkReachability from a hostname
reachable = remoteHostReachability.TryGetFlags (out flags);
remoteHostReachability.SetCallback (OnChange);
remoteHostReachability.Schedule (CFRunLoop.Current, CFRunLoop.ModeDefault);
} else
reachable = remoteHostReachability.TryGetFlags (out flags);
if (!reachable)
return NetworkStatus.NotReachable;
if (!IsReachableWithoutRequiringConnection (flags))
return NetworkStatus.NotReachable;
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
return NetworkStatus.ReachableViaCarrierDataNetwork;
return NetworkStatus.ReachableViaWiFiNetwork;
}
public static NetworkStatus RemoteHostStatus ()
{
NetworkReachabilityFlags flags;
bool reachable;
if (remoteHostReachability == null){
remoteHostReachability = new NetworkReachability (HostName);
// Need to probe before we queue, or we wont get any meaningful values
// this only happens when you create NetworkReachability from a hostname
reachable = remoteHostReachability.TryGetFlags (out flags);
remoteHostReachability.SetNotification (OnChange);
remoteHostReachability.Schedule (CFRunLoop.Current, CFRunLoop.ModeDefault);
} else
reachable = remoteHostReachability.TryGetFlags (out flags);
if (!reachable)
{
Application._networkstate = DataAccessLayer.NetworkState.Disconnected;
if (Application._user != null)
Application._user.NetworkStatus = DataAccessLayer.NetworkState.Disconnected;
return NetworkStatus.NotReachable;
}
if (!IsReachableWithoutRequiringConnection(flags))
{
Application._networkstate = DataAccessLayer.NetworkState.Disconnected;
if (Application._user != null)
Application._user.NetworkStatus = DataAccessLayer.NetworkState.Disconnected;
return NetworkStatus.NotReachable;
}
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
{
Application._networkstate = DataAccessLayer.NetworkState.ConnectedWifi;
if (Application._user != null)
Application._user.NetworkStatus = DataAccessLayer.NetworkState.ConnectedWifi;
return NetworkStatus.ReachableViaCarrierDataNetwork;
}
Application._networkstate = DataAccessLayer.NetworkState.ConnectedWifi;
if (Application._user != null)
Application._user.NetworkStatus = DataAccessLayer.NetworkState.ConnectedWifi;
return NetworkStatus.ReachableViaWiFiNetwork;
}
// Is the host reachable with the current network configuration
public static bool IsHostReachable(string host)
{
if (host == null || host.Length == 0)
return false;
#if WINDOWS_PHONE
//I know I know, but I'm trying to keep the behavior the same across platforms
bool done = false;
bool reachable = false;
DeviceNetworkInformation.ResolveHostNameAsync(new DnsEndPoint(HostName, 80), (x) => {
done = true;
if (x.NetworkErrorCode == NetworkError.Success)
reachable = true;
else
reachable = false;
}, null);
while (!done) { Thread.Sleep(200); }
return reachable;
#elif IPHONE
using (var r = new NetworkReachability (host)){
NetworkReachabilityFlags flags;
if (r.TryGetFlags (out flags)){
return IsReachableWithoutRequiringConnection (flags);
}
}
return false;
#else
var test = new Ping();
var reply = test.Send(HostName);
if (reply.Status == IPStatus.Success)
return true;
else
return false;
#endif
}
public static NetworkStatus RemoteHostStatus()
{
NetworkReachabilityFlags flags;
bool reachable;
if (remoteHostReachability == null)
{
remoteHostReachability = new NetworkReachability (HostName);
reachable = remoteHostReachability.TryGetFlags (out flags);
remoteHostReachability.SetCallback (OnChange);
remoteHostReachability.Schedule (CFRunLoop.Current, CFRunLoop.ModeDefault);
}
else
reachable = remoteHostReachability.TryGetFlags (out flags);
if (!reachable)
return NetworkStatus.NotReachable;
if (!IsReachableWithoutRequiringConnection (flags))
return NetworkStatus.NotReachable;
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
return NetworkStatus.ReachableViaCarrierDataNetwork;
return NetworkStatus.ReachableViaWiFiNetwork;
}
public void CtorIPAddressPair()
{
var address = Dns.GetHostAddresses("apple.com")[0];
using (var nr = new NetworkReachability(IPAddress.Loopback, address))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#1");
// using Loopback iOS 10 / tvOS 10 returns no flags (0) on devices
#if !MONOMAC
if ((Runtime.Arch == Arch.DEVICE) && TestRuntime.CheckXcodeVersion(8, 0))
{
Assert.That((int)flags, Is.EqualTo(0), "#1 Reachable");
}
else
#endif
Assert.That(flags, Is.EqualTo(NetworkReachabilityFlags.Reachable), "#1 Reachable");
}
using (var nr = new NetworkReachability(null, address))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#2");
Assert.That(flags, Is.EqualTo(NetworkReachabilityFlags.Reachable), "#2 Reachable");
}
using (var nr = new NetworkReachability(IPAddress.Loopback, null))
{
NetworkReachabilityFlags flags;
Assert.IsTrue(nr.TryGetFlags(out flags), "#3");
// using Loopback iOS 10 / tvOS 10 / macOS 10.12 returns no flags (0) on devices
var expected = (NetworkReachabilityFlags)0;
#if MONOMAC
if (!TestRuntime.CheckSystemVersion(PlatformName.MacOSX, 10, 12))
{
expected = NetworkReachabilityFlags.Reachable;
if (!TestRuntime.CheckSystemVersion(PlatformName.MacOSX, 10, 11))
{
expected |= NetworkReachabilityFlags.IsLocalAddress;
}
}
#else
if ((Runtime.Arch == Arch.DEVICE) && TestRuntime.CheckXcodeVersion(8, 0))
{
//
}
else
{
expected = NetworkReachabilityFlags.Reachable;
if (!TestRuntime.CheckXcodeVersion(7, 0))
{
expected |= NetworkReachabilityFlags.IsLocalAddress;
}
}
#endif
Assert.That(flags, Is.EqualTo(expected), "#3 Reachable");
}
}
/// <summary>
///
/// </summary>
/// <param name="host">
/// A <see cref="System.String"/>
/// </param>
/// <returns>
/// A <see cref="NetworkType"/>
/// </returns>
private static NetworkType RemoteHostStatus(string host)
{
bool reachable = IsHostReachable(host);;
if (!reachable)
return NetworkType.Unknown;
using (var r = new NetworkReachability (host)){
NetworkReachabilityFlags flags;
if (r.TryGetFlags (out flags)){
if ((flags & NetworkReachabilityFlags.IsWWAN) != 0)
//return NetworkType.Carrier_GSM; // TODO get which type of carrier is being used.
return NetworkType.Carrier_3G; // HARDCODED.
}
}
return NetworkType.Wifi;
}
/// <summary>
///
/// </summary>
/// <param name="flags">
/// A <see cref="NetworkReachabilityFlags"/>
/// </param>
/// <returns>
/// A <see cref="System.Boolean"/>
/// </returns>
private static bool IsNetworkAvaialable(out NetworkReachabilityFlags flags)
{
NetworkReachability defaultRouteReachability = new NetworkReachability (new IPAddress (0));
if (defaultRouteReachability.TryGetFlags (out flags))
return false;
return IsReachable (flags) && IsNoConnectionRequired(flags); // is reachable without requiring connection.
}
/// <summary>
/// Is the host reachable with the current network configuration
/// </summary>
/// <param name="host">
/// A <see cref="System.String"/>
/// </param>
/// <returns>
/// A <see cref="System.Boolean"/>
/// </returns>
private static bool IsHostReachable(string host)
{
if (host == null || host.Length == 0)
return false;
using (var r = new NetworkReachability (host)){
NetworkReachabilityFlags flags;
if (r.TryGetFlags (out flags)){
return IsReachable (flags) && IsNoConnectionRequired(flags); // is reachable without requiring connection.
}
}
return false;
}
/// <summary>
///
/// </summary>
/// <param name="flags">
/// A <see cref="NetworkReachabilityFlags"/>
/// </param>
/// <returns>
/// A <see cref="System.Boolean"/>
/// </returns>
private static bool IsAdHocWiFiNetworkAvailable(out NetworkReachabilityFlags flags)
{
NetworkReachability adHocWiFiNetworkReachability = new NetworkReachability (new IPAddress (new byte [] {169,254,0,0}));
if (!adHocWiFiNetworkReachability.TryGetFlags (out flags))
return false;
return IsReachable (flags) && IsNoConnectionRequired(flags); // is reachable without requiring connection.
}
