What's the advantages of using NSOutputstream?

Question

I need to download large files from the Internet , and save it to local disk.

At first, i save the data like this:

- (void)saveToLocalFile:(NSData *)data withOffset:(unsigned long long)offset{

    NSString* localFile = [self tempLocalFile];
    dispatch_async(mFileOperationQueue_, ^{

        NSFileHandle* fileHandle = [NSFileHandle fileHandleForWritingAtPath:localFile];
        if (fileHandle == nil) {
            [data writeToFile:localFile atomically:YES];
            return;
        }
        else {
            [fileHandle seekToFileOffset:offset];
            [fileHandle writeData:data];
            [fileHandle closeFile];
        }
    });
}

As AFNetworking use NSOutputstream to save data to local like this:

NSUInteger length = [data length];
    while (YES) {
        NSInteger totalNumberOfBytesWritten = 0;
        if ([self.outputStream hasSpaceAvailable]) {
            const uint8_t *dataBuffer = (uint8_t *)[data bytes];

            NSInteger numberOfBytesWritten = 0;
            while (totalNumberOfBytesWritten < (NSInteger)length) {
                numberOfBytesWritten = [self.outputStream write:&dataBuffer[(NSUInteger)totalNumberOfBytesWritten] maxLength:(length - (NSUInteger)totalNumberOfBytesWritten)];
                if (numberOfBytesWritten == -1) {
                    break;
                }

                totalNumberOfBytesWritten += numberOfBytesWritten;
            }

            break;
        }

        if (self.outputStream.streamError) {
            [self.connection cancel];
            [self performSelector:@selector(connection:didFailWithError:) withObject:self.connection withObject:self.outputStream.streamError];
            return;
        }
    }

What are the advantages to use NSOutputstream than NSFileHandle when writing a file ?

What are the advantages in terms of performance ?

Answer 1

There are several different technologies for reading and writing the contents of files, nearly all of which are supported by both iOS and OS X. All of them do essentially the same thing but in slightly different ways. Some technologies require you to read and write file data sequentially, while others may allow you to jump around and operate on only part of a file. Some technologies provide automatic support for reading and writing asynchronously, while others execute synchronously so that you have more control over their execution.

Choosing from the available technologies is a matter of deciding how much control you want over the reading and writing process and how much effort you want to spend writing your file management code. Higher-level technologies like Cocoa streams limit your flexibility but provide an easy-to-use interface. Lower-level technologies like POSIX and Grand Central Dispatch (GCD) give you maximum flexibility and power but require you to write a little more code.

Reading and Writing Files Asynchronously

Because file operations involve accessing a disk (possibly one on a network server), performing those operations asynchronously is almost always preferred. Technologies such as Cocoa streams and Grand Central Dispatch (GCD) are designed to execute asynchronously at all times, which allows you to focus on reading and writing file data rather than worrying about where your code executes.

Processing an Entire File Linearly Using Streams

If you always read or write a file’s contents from start to finish, streams provide a simple interface for doing so asynchronously. Streams are typically used for managing sockets and other types of sources where data may become available over time. However, you can also use streams to read or write an entire file in one or more bursts. There are two types of streams available:

• Use an NSOutputStream to write data sequentially to disk.
• Use an NSInputStream object to read data sequentially from disk.

Please go through the Apple Documentaion for code explanation.