Cocoa Touchライブラリを使用するiOS またはCocoaライブラリを使用するmacOSにインターネット接続があるかどうかを確認したいと思います。

私はこれを使用してこれを行う方法を思いつきましたNSURL。私がやった方法は少し信頼性が低いようです（Googleでさえもダウンしてサードパーティに依存しているように見えるので悪いかもしれません）。私のアプリケーションでは無駄で不要なオーバーヘッドに見えます。

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

私が行ったことは悪いことです（言うまでもなくstringWithContentsOfURL、iOS 3.0とmacOS 10.4で非推奨になっています）。

重要：このチェックは常に非同期で実行する必要があります。以下の答えの大部分は同期しているため、そうしないとアプリがフリーズすることに注意してください。

迅速

1）CocoaPodsまたはCarthage経由でインストール：https : //github.com/ashleymills/Reachability.swift

2）クロージャーによる到達可能性のテスト

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）SystemConfigurationフレームワークをプロジェクトに追加しますが、どこに含めてもかまいません。

2）のトニー・ミリオンのバージョンを追加Reachability.hし、Reachability.mプロジェクトに（ここで見つける：https://github.com/tonymillion/Reachability）

3）インターフェースセクションを更新します

#import "Reachability.h"

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

4）次に、このメソッドを、呼び出すことができるビューコントローラの.mファイルに実装します。

// 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];
}

重要な注意：Reachabilityあなたが他のプロジェクトとの競合に名前を付けるに遭遇するかもしれないので、クラスがプロジェクトに最も使用されるクラスの1つです。これが発生した場合は、Reachability.hとReachability.mファイルのペアの1つを別の名前に変更して、問題を解決する必要があります。

注：使用するドメインは重要ではありません。これは、任意のドメインへのゲートウェイをテストするだけです。

私は物事をシンプルに保つのが好きです。これを行う方法は次のとおりです。

//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;
}

次に、接続があるかどうかを確認したいときにこれを使用します。

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

このメソッドは、何かを行うためにネットワークステータスの変更を待機しません。要求したときにステータスをテストするだけです。

Appleの到達可能性コードを使用して、クラスを含めることなくこれを正しくチェックする関数を作成しました。

プロジェクトにSystemConfiguration.frameworkを含めます。

インポートします。

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

次に、この関数を呼び出すだけです。

/*
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;
}

そして、それはあなたのためにテストされたiOS 5です。

以前は正しい答えでしたが、代わりに到達可能性の通知をサブスクライブする必要があるため、現在は古くなっています。このメソッドは同期的にチェックします：

AppleのReachabilityクラスを使用できます。また、Wi-Fiが有効になっているかどうかも確認できます。

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クラスはSDKには付属していませんが、このAppleサンプルアプリケーションの一部です。ダウンロードして、Reachability.h / mをプロジェクトにコピーします。また、SystemConfigurationフレームワークをプロジェクトに追加する必要があります。

ここに非常に簡単な答えがあります：

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は非常に小さなWebサイトを指す必要があります。ここではGoogleのモバイルWebサイトを使用していますが、信頼性の高いWebサーバーがある場合は、最大の速度で1文字だけの小さなファイルをアップロードします。

デバイスがなんらかの方法でインターネットに接続されているかどうかを確認することだけが目的の場合は、この簡単なソリューションを使用することをお勧めします。ユーザーの接続方法を知る必要がある場合は、到達可能性を使用する方法があります。

注意：これにより、ウェブサイトの読み込み中にスレッドが一時的にブロックされます。私の場合、これは問題ではありませんでしたが、これを考慮する必要があります（これを指摘してくれたBradへのクレジット）。

アプリでの方法は次のとおりです。200ステータスレスポンスコードは何も保証しませんが、十分に安定しています。私がHEADレスポンスをチェックするだけなので、これはここに投稿されたNSDataの回答ほど多くのロードを必要としません。

スウィフトコード

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
        }
    })
}

Objective-Cコード

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は、さまざまな種類のネットワークの可用性を確認するためのサンプルコードを提供しています。あるいは、iPhone開発者のクックブックに例があります。

注： Appleの到達可能性コードの使用については、この回答に関する@KHGのコメントを参照してください。

Reachabilitybyで使用できます（ここから入手できます）。

#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はこれを正確に行うサンプルアプリを提供しています。

到達可能性

Reachabilityクラスのみが更新されました。あなたは今使うことができます：

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");}

Reachability for iOS 5のバージョンはdarkseed / Reachability.hです。私のものではありません！=）

見栄えがよく、ARCおよびGCDを使用した到達可能性の最新化があります。

到達可能性

使用しているAFNetworking場合は、インターネットの到達可能性ステータスに独自の実装を使用できます。

使用する最良の方法AFNetworkingは、AFHTTPClientクラスをサブクラス化し、このクラスを使用してネットワーク接続を行うことです。

このアプローチを使用する利点の1つは、blocks到達可能性のステータスが変化したときに、を使用して目的の動作を設定できることです。という名前のシングルトンサブクラスAFHTTPClient（AFNetworkingのドキュメントの「サブクラス化に関するメモ」で述べたBKHTTPClientように）を作成したとすると、次のようになります。

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

また、具体的使用のWi-FiまたはWLAN接続のためにチェックすることができAFNetworkReachabilityStatusReachableViaWWAN、およびAFNetworkReachabilityStatusReachableViaWiFi（列挙型よりここに）。

このディスカッションではコードを使用しましたが、正常に動作するようです（スレッド全体を読んでください）。

私は、考えられるすべての種類の接続（アドホックWi-Fiなど）を使って徹底的にテストしていません。

非常に簡単です。次の手順を試してください。

ステップ1：SystemConfigurationフレームワークをプロジェクトに追加します。

ステップ2：次のコードをheaderファイルにインポートします。

#import <SystemConfiguration/SystemConfiguration.h>

手順3：次の方法を使用する

• タイプ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;
  }

• タイプ2：

  インポートヘッダー：#import "Reachability.h"

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

ステップ4：使用方法：

- (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;
}

または、到達可能性クラスを使用します。

iPhone SDKを使用してインターネットの可用性を確認するには、2つの方法があります。

1. Googleページが開いているかどうかを確認します。

2.到達可能性クラス

詳細については、到達可能性（Apple Developer）を参照してください。

http://huytd.github.io/datatify/を使用します。ライブラリを追加して自分でコードを書くよりも簡単です。

最初：CFNetwork.frameworkフレームワークに追加

コード：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");
    }
}

まず、到達可能性クラスをダウンロードし、Xcodeに reachability.hファイルとreachabilty.mファイルを配置します。

最善の方法は、共通の関数クラス（NSObject）を作成して、どのクラスでも使用できるようにすることです。これらは、ネットワーク接続の到達可能性チェックの2つの方法です。

+(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;
}

これで、このクラスメソッドを呼び出して、任意のクラスのネットワーク接続を確認できます。

iPhone SDKを使用してインターネット接続を確認する別の方法もあります。

ネットワーク接続用に次のコードを実装してみてください。

#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を見つけました。

サンプルコード：chrishulbert / SimplePingHelper（GitHub）

1. 到達可能性ファイルhttps://gist.github.com/darkseed/1182373をダウンロードします

2. CFNetwork.frameworkフレームワークに「SystemConfiguration.framework」を追加します

3. #import "Reachability.h"を実行します

最初：CFNetwork.frameworkフレームワークに追加

コード：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");
    }
}

Swift 3 / Swift 4

最初にインポートする必要があります

import SystemConfiguration

以下の方法でインターネット接続を確認できます

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)

}

到達可能性クラスには、インターネット接続がデバイスに利用可能であるかどうかを調べるためにOKです...

ただし、イントラネットリソースにアクセスする場合：

到達可能性クラスでイントラネットサーバーにpingすると、常にtrueが返されます。

したがって、このシナリオでの簡単な解決策はpingme、サービスの他のWebメソッドと一緒に呼び出されるWebメソッドを作成することです。pingme何かを返す必要があります。

だから私は一般的な機能について次のメソッドを書きました

-(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;
    }
}

上記の方法は私にとってとても便利だったので、サーバーにデータを送信しようとするときはいつでも、この低タイムアウトURLRequestを使用してイントラネットリソースの到達可能性を常にチェックします。

これを自分で行うのは非常に簡単です。次の方法が機能します。HTTP、HTTPSなどのホスト名プロトコルが名前で渡されないようにしてください。

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

それは迅速でシンプルで無痛です。

到達可能性とは別に、Simple Pingヘルパーライブラリを使用することもできます。それは本当にうまく動作し、統合するのは簡単です。

これが一番の答えだと思います。

「はい」は接続されていることを意味します。「いいえ」は切断されていることを意味します。

#import "Reachability.h"

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

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

にReachable.hクラスをインポートしViewController、次のコードを使用して接続を確認します。

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

• ステップ1：プロジェクトにReachabilityクラスを追加します。
• ステップ2：到達可能性クラスをインポートする

• ステップ3：以下の関数を作成する

  - (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;
          }
      }
  }

• ステップ4：以下のように関数を呼び出します。

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