Cocoa Touch kitaplıklarını kullanan iOS'ta veya Cocoa kitaplıklarını kullanan macOS'ta bir İnternet bağlantım olup olmadığını kontrol etmek istiyorum .

Bunu kullanarak bir yol buldum NSURL. Yaptığım yol biraz güvenilmez görünüyor (çünkü Google bile bir gün kapalı olabilir ve üçüncü bir tarafa güveniyor gibi görünüyor) ve Google yanıt vermediyse diğer bazı web sitelerinden bir yanıt görmek için kontrol edebilirken, savurgan ve benim uygulama gereksiz bir yük gibi görünüyor.

- (BOOL) connectedToInternet
{
    NSString *URLString = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];
    return ( URLString != NULL ) ? YES : NO;
}

Yaptığım şey kötü mü ( stringWithContentsOfURLiOS 3.0 ve macOS 10.4'te bahsedilmiyor ) ve öyleyse bunu başarmanın daha iyi bir yolu nedir?

Önemli : Bu kontrol daima eşzamansız olarak yapılmalıdır. Aşağıdaki cevapların çoğu eşzamanlıdır, bu nedenle dikkatli olun aksi takdirde uygulamanızı dondurursunuz.

hızlı

1) CocoaPods veya Carthage ile yükleyin: https://github.com/ashleymills/Reachability.swift

2) Kapanışlarla test erişilebilirliği

let reachability = Reachability()!

reachability.whenReachable = { reachability in
    if reachability.connection == .wifi {
        print("Reachable via WiFi")
    } else {
        print("Reachable via Cellular")
    }
}

reachability.whenUnreachable = { _ in
    print("Not reachable")
}

do {
    try reachability.startNotifier()
} catch {
    print("Unable to start notifier")
}

Objective-C

1) SystemConfigurationProjeye çerçeve ekleyin ancak herhangi bir yere dahil etme konusunda endişelenmeyin

2) Tony Milyon sürümünü ekleyin Reachability.hve Reachability.mprojeye (burada bulunabilir: https://github.com/tonymillion/Reachability )

3) Arayüz bölümünü güncelleyin

#import "Reachability.h"

// Add this to the interface in the .m file of your view controller
@interface MyViewController ()
{
    Reachability *internetReachableFoo;
}
@end

4) Ardından, bu yöntemi arayabileceğiniz görünüm denetleyicinizin .m dosyasına uygulayın

// Checks if we have an internet connection or not
- (void)testInternetConnection
{   
    internetReachableFoo = [Reachability reachabilityWithHostname:@"www.google.com"];

    // Internet is reachable
    internetReachableFoo.reachableBlock = ^(Reachability*reach)
    {
        // Update the UI on the main thread
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"Yayyy, we have the interwebs!");
        });
    };

    // Internet is not reachable
    internetReachableFoo.unreachableBlock = ^(Reachability*reach)
    {
        // Update the UI on the main thread
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"Someone broke the internet :(");
        });
    };

    [internetReachableFoo startNotifier];
}

Önemli Not:Reachability Eğer diğer projeler adlandırma çakışmaları içine çalışabilir böylece sınıf projelerinde en çok kullanılan sınıfların biridir. Bu durumda, sorunu çözmek için dosyalarından Reachability.hve Reachability.mdosyalarından birini yeniden adlandırmanız gerekir .

Not: Kullandığınız alanın önemi yoktur. Sadece herhangi bir alan için ağ geçidi test ediyor.

Ben işleri basit tutmayı severim. Bunu yapmanın yolu:

//Class.h
#import "Reachability.h"
#import <SystemConfiguration/SystemConfiguration.h>

- (BOOL)connected;

//Class.m
- (BOOL)connected
{
    Reachability *reachability = [Reachability reachabilityForInternetConnection];
    NetworkStatus networkStatus = [reachability currentReachabilityStatus];
    return networkStatus != NotReachable;
}

Sonra, bir bağlantım olup olmadığını görmek istediğimde bunu kullanıyorum:

if (![self connected]) {
    // Not connected
} else {
    // Connected. Do some Internet stuff
}

Bu yöntem, şeyler yapmak için değiştirilmiş ağ durumlarını beklemez. Sadece istendiğinde durumu test eder.

Apple'ın Okunabilirlik kodunu kullanarak, herhangi bir sınıf eklemenize gerek kalmadan bunu doğru bir şekilde kontrol edecek bir işlev oluşturdum.

Projenize SystemConfiguration.framework ekleyin.

Bazı ithalatlar yapın:

#import <sys/socket.h>
#import <netinet/in.h>
#import <SystemConfiguration/SystemConfiguration.h>

Şimdi sadece bu işlevi çağırın:

/*
Connectivity testing code pulled from Apple's Reachability Example: https://developer.apple.com/library/content/samplecode/Reachability
 */
+(BOOL)hasConnectivity {
    struct sockaddr_in zeroAddress;
    bzero(&zeroAddress, sizeof(zeroAddress));
    zeroAddress.sin_len = sizeof(zeroAddress);
    zeroAddress.sin_family = AF_INET;

    SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)&zeroAddress);
    if (reachability != NULL) {
        //NetworkStatus retVal = NotReachable;
        SCNetworkReachabilityFlags flags;
        if (SCNetworkReachabilityGetFlags(reachability, &flags)) {
            if ((flags & kSCNetworkReachabilityFlagsReachable) == 0)
            {
                // If target host is not reachable
                return NO;
            }

            if ((flags & kSCNetworkReachabilityFlagsConnectionRequired) == 0)
            {
                // If target host is reachable and no connection is required
                //  then we'll assume (for now) that your on Wi-Fi
                return YES;
            }


            if ((((flags & kSCNetworkReachabilityFlagsConnectionOnDemand ) != 0) ||
                 (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic) != 0))
            {
                // ... and the connection is on-demand (or on-traffic) if the
                //     calling application is using the CFSocketStream or higher APIs.

                if ((flags & kSCNetworkReachabilityFlagsInterventionRequired) == 0)
                {
                    // ... and no [user] intervention is needed
                    return YES;
                }
            }

            if ((flags & kSCNetworkReachabilityFlagsIsWWAN) == kSCNetworkReachabilityFlagsIsWWAN)
            {
                // ... but WWAN connections are OK if the calling application
                //     is using the CFNetwork (CFSocketStream?) APIs.
                return YES;
            }
        }
    }

    return NO;
}

Ve iOS 5 sizin için test edildi.

Bu eskiden doğru cevaptı, ancak artık erişilebilirlik bildirimlerine abone olmanız gerektiği için güncelliğini yitirdi. Bu yöntem senkronize olarak kontrol eder:

Apple'ın Okunabilirlik sınıfını kullanabilirsiniz. Ayrıca, Kablosuz'un etkin olup olmadığını kontrol etmenizi sağlar:

Reachability* reachability = [Reachability sharedReachability];
[reachability setHostName:@"www.example.com"];    // Set your host name here
NetworkStatus remoteHostStatus = [reachability remoteHostStatus];

if (remoteHostStatus == NotReachable) { }
else if (remoteHostStatus == ReachableViaWiFiNetwork) { }
else if (remoteHostStatus == ReachableViaCarrierDataNetwork) { }

Reachability sınıfı SDK ile değil, bu Apple örnek uygulamasının bir parçasıyla birlikte gönderilir . Sadece indirin ve Reachability.h / m'yi projenize kopyalayın. Ayrıca, projenize SystemConfiguration çerçevesini eklemeniz gerekir.

İşte çok basit bir cevap:

NSURL *scriptUrl = [NSURL URLWithString:@"http://www.google.com/m"];
NSData *data = [NSData dataWithContentsOfURL:scriptUrl];
if (data)
    NSLog(@"Device is connected to the Internet");
else
    NSLog(@"Device is not connected to the Internet");

URL çok küçük bir web sitesine işaret etmelidir. Google'ın mobil web sitesini burada kullanıyorum, ancak güvenilir bir web sunucum olsaydı , maksimum hız için sadece bir karakter içeren küçük bir dosya yüklerdim.

Cihazın bir şekilde İnternet'e bağlı olup olmadığını kontrol etmek istiyorsanız, yapmak istediğiniz her şeyse, kesinlikle bu basit çözümü kullanmanızı tavsiye ederim. Kullanıcının nasıl bağlandığını bilmeniz gerekiyorsa, Okunabilirlik özelliğini kullanmak en uygun yoldur.

Dikkat: Bu, web sitesini yüklerken iş parçacığınızı kısaca engeller. Benim durumumda, bu bir problem değildi, ama bunu düşünmelisin (Brad bunu işaret ettiği için kredi).

Uygulamalarımda şu şekilde yapıyorum: 200 durum yanıt kodu hiçbir şeyi garanti etmese de, benim için yeterince kararlı. Bu, burada yayınlanan NSData cevapları kadar yükleme gerektirmez, çünkü benimki HEAD yanıtını kontrol eder.

Swift kodu

func checkInternet(flag:Bool, completionHandler:(internet:Bool) -> Void)
{
    UIApplication.sharedApplication().networkActivityIndicatorVisible = true

    let url = NSURL(string: "http://www.google.com/")
    let request = NSMutableURLRequest(URL: url!)

    request.HTTPMethod = "HEAD"
    request.cachePolicy = NSURLRequestCachePolicy.ReloadIgnoringLocalAndRemoteCacheData
    request.timeoutInterval = 10.0

    NSURLConnection.sendAsynchronousRequest(request, queue:NSOperationQueue.mainQueue(), completionHandler:
    {(response: NSURLResponse!, data: NSData!, error: NSError!) -> Void in

        UIApplication.sharedApplication().networkActivityIndicatorVisible = false

        let rsp = response as! NSHTTPURLResponse?

        completionHandler(internet:rsp?.statusCode == 200)
    })
}

func yourMethod()
{
    self.checkInternet(false, completionHandler:
    {(internet:Bool) -> Void in

        if (internet)
        {
            // "Internet" aka Google URL reachable
        }
        else
        {
            // No "Internet" aka Google URL un-reachable
        }
    })
}

Amaç-C Kodu

typedef void(^connection)(BOOL);

- (void)checkInternet:(connection)block
{
    NSURL *url = [NSURL URLWithString:@"http://www.google.com/"];
    NSMutableURLRequest *headRequest = [NSMutableURLRequest requestWithURL:url];
    headRequest.HTTPMethod = @"HEAD";

    NSURLSessionConfiguration *defaultConfigObject = [NSURLSessionConfiguration ephemeralSessionConfiguration];
    defaultConfigObject.timeoutIntervalForResource = 10.0;
    defaultConfigObject.requestCachePolicy = NSURLRequestReloadIgnoringLocalAndRemoteCacheData;

    NSURLSession *defaultSession = [NSURLSession sessionWithConfiguration:defaultConfigObject delegate:self delegateQueue: [NSOperationQueue mainQueue]];

    NSURLSessionDataTask *dataTask = [defaultSession dataTaskWithRequest:headRequest
        completionHandler:^(NSData *data, NSURLResponse *response, NSError *error)
    {
        if (!error && response)
        {
            block([(NSHTTPURLResponse *)response statusCode] == 200);
        }
    }];
    [dataTask resume];
}

- (void)yourMethod
{
    [self checkInternet:^(BOOL internet)
    {
         if (internet)
         {
             // "Internet" aka Google URL reachable
         }
         else
         {
             // No "Internet" aka Google URL un-reachable
         }
    }];
}

Apple örnek kod sağlar , farklı ağ kullanılabilirliği türlerini kontrol etmek için sağlar. Alternatif olarak, iPhone geliştiricileri yemek kitabında bir örnek var .

Not: Lütfen Apple'ın erişilebilirlik kodunun kullanımına ilişkin bu cevap hakkındaki @ KHG'nin yorumuna bakın.

Reachability ile kullanabilirsiniz ( burada bulunabilir ).

#import "Reachability.h"

- (BOOL)networkConnection {
    return [[Reachability reachabilityWithHostName:@"www.google.com"] currentReachabilityStatus];
}

if ([self networkConnection] == NotReachable) { /* No Network */ } else { /* Network */ } //Use ReachableViaWiFi / ReachableViaWWAN to get the type of connection.

Apple tam olarak bunu yapan örnek bir uygulama sunar:

Erişilebilirlik

Yalnızca Okunabilirlik sınıfı güncellendi. Artık şunları kullanabilirsiniz:

Reachability* reachability = [Reachability reachabilityWithHostName:@"www.apple.com"];
NetworkStatus remoteHostStatus = [reachability currentReachabilityStatus];

if (remoteHostStatus == NotReachable) { NSLog(@"not reachable");}
else if (remoteHostStatus == ReachableViaWWAN) { NSLog(@"reachable via wwan");}
else if (remoteHostStatus == ReachableViaWiFi) { NSLog(@"reachable via wifi");}

İOS 5 için Okunabilirlik hakkındaki bir sürüm karanlık tohum / Okunabilirlik.h . Benim değil! =)

Burada güzel görünümlü, ARC ve GCD kullanan bir Erişilebilirlik modernizasyonu var:

Erişilebilirlik

Kullanıyorsanız AFNetworking internet erişilebilirlik durumu kendi uygulamasını kullanabilirsiniz.

Kullanmanın en iyi yolu AFNetworking,AFHTTPClient sınıfı sınıflara ayırmak ve ağ bağlantılarınızı yapmak için bu sınıfı kullanmaktır.

Bu yaklaşımı kullanmanın avantajlarından biri blocks, erişilebilirlik durumu değiştiğinde istenen davranışı ayarlamak için kullanabilmenizdir . Tek bir alt sınıf oluşturduğumu varsayarak AFHTTPClient( AFNetworking belgelerindeki "Alt sınıf notları" da söylendiği gibi ) adlı bir BKHTTPClientşey yaptım:

BKHTTPClient *httpClient = [BKHTTPClient sharedClient];
[httpClient setReachabilityStatusChangeBlock:^(AFNetworkReachabilityStatus status)
{
    if (status == AFNetworkReachabilityStatusNotReachable) 
    {
    // Not reachable
    }
    else
    {
        // Reachable
    }
}];

Ayrıca AFNetworkReachabilityStatusReachableViaWWANve AFNetworkReachabilityStatusReachableViaWiFinumaralarını kullanarak Wi-Fi veya WLAN bağlantılarını da kontrol edebilirsiniz ( daha fazla bilgi ).

Bu tartışmada kodu kullandım ve iyi çalışıyor gibi görünüyor ( tamamını oku konu !).

Akla gelebilecek her tür bağlantıyla (ad hoc Wi-Fi gibi) kapsamlı bir şekilde test etmedim.

Çok basit .... Şu adımları deneyin:

1 Adım: Ekle SystemConfigurationprojenize çerçeve.

Adım 2: Aşağıdaki kodu headerdosyanıza aktarın.

#import <SystemConfiguration/SystemConfiguration.h>

3. Adım: Aşağıdaki yöntemi kullanın

• Tip 1:

  - (BOOL) currentNetworkStatus {
      [UIApplication sharedApplication].networkActivityIndicatorVisible = NO;
      BOOL connected;
      BOOL isConnected;
      const char *host = "www.apple.com";
      SCNetworkReachabilityRef reachability = SCNetworkReachabilityCreateWithName(NULL, host);
      SCNetworkReachabilityFlags flags;
      connected = SCNetworkReachabilityGetFlags(reachability, &flags);
      isConnected = NO;
      isConnected = connected && (flags & kSCNetworkFlagsReachable) && !(flags & kSCNetworkFlagsConnectionRequired);
      CFRelease(reachability);
      return isConnected;
  }

• Tip 2:

  İçe aktarma başlığı :#import "Reachability.h"

  - (BOOL)currentNetworkStatus
  {
      Reachability *reachability = [Reachability reachabilityForInternetConnection];
      NetworkStatus networkStatus = [reachability currentReachabilityStatus];
      return networkStatus != NotReachable;
  }

4. Adım: Nasıl kullanılır:

- (void)CheckInternet
{
    BOOL network = [self currentNetworkStatus];
    if (network)
    {
        NSLog(@"Network Available");
    }
    else
    {
        NSLog(@"No Network Available");
    }
}

-(void)newtworkType {

 NSArray *subviews = [[[[UIApplication sharedApplication] valueForKey:@"statusBar"] valueForKey:@"foregroundView"]subviews];
NSNumber *dataNetworkItemView = nil;

for (id subview in subviews) {
    if([subview isKindOfClass:[NSClassFromString(@"UIStatusBarDataNetworkItemView") class]]) {
        dataNetworkItemView = subview;
        break;
    }
}


switch ([[dataNetworkItemView valueForKey:@"dataNetworkType"]integerValue]) {
    case 0:
        NSLog(@"No wifi or cellular");
        break;

    case 1:
        NSLog(@"2G");
        break;

    case 2:
        NSLog(@"3G");
        break;

    case 3:
        NSLog(@"4G");
        break;

    case 4:
        NSLog(@"LTE");
        break;

    case 5:
        NSLog(@"Wifi");
        break;


    default:
        break;
}
}

- (void)viewWillAppear:(BOOL)animated
{
    NSString *URL = [NSString stringWithContentsOfURL:[NSURL URLWithString:@"http://www.google.com"]];

    return (URL != NULL ) ? YES : NO;
}

Veya Reachability sınıfını kullanın .

İPhone SDK'yı kullanarak İnternet kullanılabilirliğini kontrol etmenin iki yolu vardır:

1. Google sayfasının açık olup olmadığını kontrol edin.

2. Ulaşılabilirlik Sınıfı

Daha fazla bilgi için lütfen Ulaşılabilirlik'e (Apple Developer) bakın.

Http://huytd.github.io/datatify/ adresini kullanın . Kitaplık eklemek ve kendi kendinize kod yazmaktan daha kolaydır.

İlk olarak : CFNetwork.frameworkÇerçeve ekle

Kod :ViewController.m

#import "Reachability.h"

- (void)viewWillAppear:(BOOL)animated
{
    Reachability *r = [Reachability reachabilityWithHostName:@"www.google.com"];
    NetworkStatus internetStatus = [r currentReachabilityStatus];

    if ((internetStatus != ReachableViaWiFi) && (internetStatus != ReachableViaWWAN))
    {
        /// Create an alert if connection doesn't work
        UIAlertView *myAlert = [[UIAlertView alloc]initWithTitle:@"No Internet Connection"   message:NSLocalizedString(@"InternetMessage", nil)delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil];
        [myAlert show];
        [myAlert release];
    }
    else
    {
         NSLog(@"INTERNET IS CONNECT");
    }
}

Önce reachability sınıfını indirin ve reachability.h ve reachabilty.m dosyasını Xcode'unuza yerleştirin .

En iyi yol, herhangi bir sınıfı kullanabilmeniz için ortak bir Functions sınıfı (NSObject) yapmaktır. Ağ bağlantısı erişilebilirlik denetimi için iki yöntem şunlardır:

+(BOOL) reachabiltyCheck
{
    NSLog(@"reachabiltyCheck");
    BOOL status =YES;
    [[NSNotificationCenter defaultCenter] addObserver:self
                                          selector:@selector(reachabilityChanged:)
                                          name:kReachabilityChangedNotification
                                          object:nil];
    Reachability * reach = [Reachability reachabilityForInternetConnection];
    NSLog(@"status : %d",[reach currentReachabilityStatus]);
    if([reach currentReachabilityStatus]==0)
    {
        status = NO;
        NSLog(@"network not connected");
    }
    reach.reachableBlock = ^(Reachability * reachability)
    {
        dispatch_async(dispatch_get_main_queue(), ^{
        });
    };
    reach.unreachableBlock = ^(Reachability * reachability)
    {
        dispatch_async(dispatch_get_main_queue(), ^{
        });
    };
    [reach startNotifier];
    return status;
}

+(BOOL)reachabilityChanged:(NSNotification*)note
{
    BOOL status =YES;
    NSLog(@"reachabilityChanged");
    Reachability * reach = [note object];
    NetworkStatus netStatus = [reach currentReachabilityStatus];
    switch (netStatus)
    {
        case NotReachable:
            {
                status = NO;
                NSLog(@"Not Reachable");
            }
            break;

        default:
            {
                if (!isSyncingReportPulseFlag)
                {
                    status = YES;
                    isSyncingReportPulseFlag = TRUE;
                    [DatabaseHandler checkForFailedReportStatusAndReSync];
                }
            }
            break;
    }
    return status;
}

+ (BOOL) connectedToNetwork
{
    // Create zero addy
    struct sockaddr_in zeroAddress;
    bzero(&zeroAddress, sizeof(zeroAddress));
    zeroAddress.sin_len = sizeof(zeroAddress);
    zeroAddress.sin_family = AF_INET;

    // Recover reachability flags
    SCNetworkReachabilityRef defaultRouteReachability = SCNetworkReachabilityCreateWithAddress(NULL, (struct sockaddr *)&zeroAddress);
    SCNetworkReachabilityFlags flags;
    BOOL didRetrieveFlags = SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags);
    CFRelease(defaultRouteReachability);
    if (!didRetrieveFlags)
    {
        NSLog(@"Error. Could not recover network reachability flags");
        return NO;
    }
    BOOL isReachable = flags & kSCNetworkFlagsReachable;
    BOOL needsConnection = flags & kSCNetworkFlagsConnectionRequired;
    BOOL nonWiFi = flags & kSCNetworkReachabilityFlagsTransientConnection;
    NSURL *testURL = [NSURL URLWithString:@"http://www.apple.com/"];
    NSURLRequest *testRequest = [NSURLRequest requestWithURL:testURL  cachePolicy:NSURLRequestReloadIgnoringLocalCacheData timeoutInterval:20.0];
    NSURLConnection *testConnection = [[NSURLConnection alloc] initWithRequest:testRequest delegate:self];
    return ((isReachable && !needsConnection) || nonWiFi) ? (testConnection ? YES : NO) : NO;
}

Artık bu sınıf yöntemini çağırarak herhangi bir sınıftaki ağ bağlantısını kontrol edebilirsiniz.

İPhone SDK'sını kullanarak İnternet bağlantısını kontrol etmenin başka bir yöntemi daha var.

Ağ bağlantısı için aşağıdaki kodu uygulamaya çalışın.

#import <SystemConfiguration/SystemConfiguration.h>
#include <netdb.h>

/**
     Checking for network availability. It returns
     YES if the network is available.
*/
+ (BOOL) connectedToNetwork
{

    // Create zero addy
    struct sockaddr_in zeroAddress;
    bzero(&zeroAddress, sizeof(zeroAddress));
    zeroAddress.sin_len = sizeof(zeroAddress);
    zeroAddress.sin_family = AF_INET;

    // Recover reachability flags
    SCNetworkReachabilityRef defaultRouteReachability =
        SCNetworkReachabilityCreateWithAddress(NULL, (struct sockaddr *)&zeroAddress);
    SCNetworkReachabilityFlags flags;

    BOOL didRetrieveFlags = SCNetworkReachabilityGetFlags(defaultRouteReachability, &flags);
    CFRelease(defaultRouteReachability);

    if (!didRetrieveFlags)
    {
        printf("Error. Could not recover network reachability flags\n");
        return NO;
    }

    BOOL isReachable = ((flags & kSCNetworkFlagsReachable) != 0);
    BOOL needsConnection = ((flags & kSCNetworkFlagsConnectionRequired) != 0);

    return (isReachable && !needsConnection) ? YES : NO;
}

SimplePingHelper kütüphanesini basit ve kullanımı kolay buldum .

Örnek kod: chrishulbert / SimplePingHelper ( GitHub )

1. Okunabilirlik dosyasını indirin, https://gist.github.com/darkseed/1182373

2. Ve CFNetwork.frameworkçerçeve içine 'SystemConfiguration.framework' ekleyin ve

3. #İmport "Reachability.h" yapın

İlk olarak : CFNetwork.frameworkÇerçeve ekle

Kod :ViewController.m

- (void)viewWillAppear:(BOOL)animated
{
    Reachability *r = [Reachability reachabilityWithHostName:@"www.google.com"];
    NetworkStatus internetStatus = [r currentReachabilityStatus];

    if ((internetStatus != ReachableViaWiFi) && (internetStatus != ReachableViaWWAN))
    {
        /// Create an alert if connection doesn't work
        UIAlertView *myAlert = [[UIAlertView alloc]initWithTitle:@"No Internet Connection"   message:NSLocalizedString(@"InternetMessage", nil)delegate:nil cancelButtonTitle:@"Ok" otherButtonTitles:nil];
        [myAlert show];
        [myAlert release];
    }
    else
    {
         NSLog(@"INTERNET IS CONNECT");
    }
}

Hızlı 3 / Hızlı 4

Önce içe aktarmalısınız

import SystemConfiguration

İnternet bağlantısını aşağıdaki yöntemle kontrol edebilirsiniz

func isConnectedToNetwork() -> Bool {

    var zeroAddress = sockaddr_in()
    zeroAddress.sin_len = UInt8(MemoryLayout.size(ofValue: zeroAddress))
    zeroAddress.sin_family = sa_family_t(AF_INET)

    let defaultRouteReachability = withUnsafePointer(to: &zeroAddress) {
        $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {zeroSockAddress in
            SCNetworkReachabilityCreateWithAddress(nil, zeroSockAddress)
        }
    }

    var flags = SCNetworkReachabilityFlags()
    if !SCNetworkReachabilityGetFlags(defaultRouteReachability!, &flags) {
        return false
    }
    let isReachable = (flags.rawValue & UInt32(kSCNetworkFlagsReachable)) != 0
    let needsConnection = (flags.rawValue & UInt32(kSCNetworkFlagsConnectionRequired)) != 0
    return (isReachable && !needsConnection)

}

Ulaşılabilirlik sınıf Internet bağlantısı bir cihaz ile veya mevcut olup olmadığını öğrenmek için sorun yok ...

Ancak bir intranet kaynağına erişilmesi durumunda :

İntranet sunucusuna ulaşılabilirlik sınıfıyla ping atmak her zaman true değerini döndürür.

Bu senaryoda hızlı bir çözüm pingme, hizmetteki diğer web yöntemleriyle birlikte çağrılan bir web yöntemi oluşturmak olacaktır . Bir pingmeşey döndürmelidir.

Bu yüzden ortak fonksiyonlar üzerine aşağıdaki yöntemi yazdım

-(BOOL)PingServiceServer
{
    NSURL *url=[NSURL URLWithString:@"http://www.serveraddress/service.asmx/Ping"];

    NSMutableURLRequest *urlReq=[NSMutableURLRequest requestWithURL:url];

    [urlReq setTimeoutInterval:10];

    NSURLResponse *response;

    NSError *error = nil;

    NSData *receivedData = [NSURLConnection sendSynchronousRequest:urlReq
                                                 returningResponse:&response
                                                             error:&error];
    NSLog(@"receivedData:%@",receivedData);

    if (receivedData !=nil)
    {
        return YES;
    }
    else
    {
        NSLog(@"Data is null");
        return NO;
    }
}

Yukarıdaki yöntem benim için çok yararlı oldu, bu yüzden sunucuya bazı veri göndermeye çalıştığımda, her zaman bu düşük zaman aşımı URLRequest kullanarak intranet kaynağımın erişilebilirliğini kontrol ediyorum.

Bunu kendiniz yapmak son derece basittir. Aşağıdaki yöntem çalışacaktır. HTTP, HTTPS vb. Gibi bir ana bilgisayar adı protokolünün adla iletilmesine izin vermediğinizden emin olun.

-(BOOL)hasInternetConnection:(NSString*)urlAddress
{
    SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithName(kCFAllocatorDefault, [urlAddress UTF8String]);
    SCNetworkReachabilityFlags flags;
    if (!SCNetworkReachabilityGetFlags(ref, &flags))
    {
        return NO;
    }
    return flags & kSCNetworkReachabilityFlagsReachable;
}

Hızlı basit ve ağrısızdır.

Ulaşılabilirlik dışında, Basit Ping yardımcı kitaplığını da kullanabilirsiniz . Gerçekten güzel çalışıyor ve entegrasyonu basit.

Bence bu en iyi cevap.

"Evet" bağlı anlamına gelir. "Hayır" bağlantısı kesilmiş anlamına gelir.

#import "Reachability.h"

 - (BOOL)canAccessInternet
{
    Reachability *IsReachable = [Reachability reachabilityForInternetConnection];
    NetworkStatus internetStats = [IsReachable currentReachabilityStatus];

    if (internetStats == NotReachable)
    {
        return NO;
    }
    else
    {
        return YES;
    }
}

Reachable.hSınıfı bilgisayarınıza içe aktarın ViewControllerve bağlantıyı kontrol etmek için aşağıdaki kodu kullanın :

     #define hasInternetConnection [[Reachability reachabilityForInternetConnection] isReachable]
     if (hasInternetConnection){
           // To-do block
     }

• Adım 1: Projenize Reachability sınıfını ekleyin.
• 2. Adım: Ulaşılabilirlik sınıfını içe aktarın

• 3. Adım: Aşağıdaki işlevi oluşturun

  - (BOOL)checkNetConnection {
      self.internetReachability = [Reachability reachabilityForInternetConnection];
      [self.internetReachability startNotifier];
      NetworkStatus netStatus = [self.internetReachability currentReachabilityStatus];
      switch (netStatus) {
          case NotReachable:
          {
              return NO;
          }
  
          case ReachableViaWWAN:
          {
               return YES;
          }
  
          case ReachableViaWiFi:
          {
               return YES;
          }
      }
  }

• Adım 4: Aşağıdaki gibi fonksiyonu çağırın:

  if (![self checkNetConnection]) {
      [GlobalFunctions showAlert:@""
                       message:@"Please connect to the Internet!"
                       canBtntitle:nil
                       otherBtnTitle:@"Ok"];
      return;
  }
  else
  {
      Log.v("internet is connected","ok");
  }