Wie cache-Bilder mit URLSession in Swift

Ich würde gerne verbessern Sie den code unten, um die cache-Bilder nur herunterladen, wenn Sie noch nicht zwischengespeichert wurde, zuvor. Ich kann nicht scheinen zu finden, eine gute Beispiele, wie URLSession Objekt, dies zu tun. 

extension UIImageView {
    func loadImageWithURL(_ url: URL) -> URLSessionDownloadTask {
        let session = URLSession.shared

        let downloadTask = session.downloadTask(with: url, completionHandler: { [weak self] url, response, error in

            if error == nil, let url = url,
                let data = try? Data(contentsOf: url), let image = UIImage(data: data) {

                    DispatchQueue.main.async {
                        if let strongSelf = self {
                            strongSelf.image = image
                        }
                    }
            }
        })
        downloadTask.resume()
        return downloadTask
    }
}
  • nshipster.com/nsurlcache
  • Nicht verwandt, Ihre if let strongSelf = self { strongSelf.image = image } kann vereinfacht werden zu self?.image = image.
  • FWIW, NSURLCache wird der cache nach dem, was geliefert wird, in die Header der server-Antwort. Es ist auch einschränken cache entsprechend schlecht dokumentiert Regeln, vor allem, wenn ein download mehr als 5% des Gesamt-cache, es wird nicht zwischengespeichert werden, unabhängig davon, was der server die Header sagen (dies ist ein Grund für die Beule, die cache-Größe als die in dem link von Leo zur Verfügung gestellt).
InformationsquelleAutor Martin Muldoon | 2016-11-29
  1. 11

    Aktualisiert Swift 4

    import UIKit

let imageCache = NSCache<AnyObject, AnyObject>()

class ImageLoader: UIImageView {

    var imageURL: URL?

    let activityIndicator = UIActivityIndicatorView()

    func loadImageWithUrl(_ url: URL) {

        //setup activityIndicator...
        activityIndicator.color = .darkGray

        addSubview(activityIndicator)
        activityIndicator.translatesAutoresizingMaskIntoConstraints = false
        activityIndicator.centerXAnchor.constraint(equalTo: centerXAnchor).isActive = true
        activityIndicator.centerYAnchor.constraint(equalTo: centerYAnchor).isActive = true

        imageURL = url

        image = nil
        activityIndicator.startAnimating()

        //retrieves image if already available in cache
        if let imageFromCache = imageCache.object(forKey: url as AnyObject) as? UIImage {

            self.image = imageFromCache
            activityIndicator.stopAnimating()
            return
        }

        //image does not available in cache.. so retrieving it from url...
        URLSession.shared.dataTask(with: url, completionHandler: { (data, response, error) in

            if error != nil {
                print(error as Any)
                DispatchQueue.main.async(execute: {
                    self.activityIndicator.stopAnimating()
                })
                return
            }

            DispatchQueue.main.async(execute: {

                if let unwrappedData = data, let imageToCache = UIImage(data: unwrappedData) {

                    if self.imageURL == url {
                        self.image = imageToCache
                    }

                    imageCache.setObject(imageToCache, forKey: url as AnyObject)
                }
                self.activityIndicator.stopAnimating()
            })
        }).resume()
    }
}

    Verwendung:

    //assign ImageLoader class to your imageView class
let yourImageView: ImageLoader = {

    let iv = ImageLoader()
    iv.frame = CGRect(x: 10, y: 100, width: 300, height: 300)
    iv.backgroundColor = UIColor(red: 0.94, green: 0.94, blue: 0.96, alpha: 1.0)
    iv.contentMode = .scaleAspectFill
    iv.clipsToBounds = true
    return iv
}()


//unwrapped url safely...
   if let strUrl = "https://picsum.photos/300/300".addingPercentEncoding(withAllowedCharacters: .urlFragmentAllowed),
      let imgUrl = URL(string: strUrl) {

      yourImageView.loadImageWithUrl(imgUrl) //call this line for getting image to yourImageView
}
    InformationsquelleAutor iAj
  2. 4

    Eine mögliche Lösung wäre, zu nutzen NSCache zu kümmern Zwischenspeichern. Im wesentlichen, was Sie tun würde, ist zu überprüfen, wenn Sie bereits das Bild lokal laden, anstatt das abrufen jedes mal, bevor Sie tatsächlich einen Antrag stellen.

    Hier ist einer meiner Implementierungen, jedoch - es ist eine Unterklasse eher als eine Erweiterung:

    class CustomImageView: UIImageView {

    //MARK: - Constants

    let imageCache = NSCache<NSString, AnyObject>()

    //MARK: - Properties

    var imageURLString: String?

    func downloadImageFrom(urlString: String, imageMode: UIViewContentMode) {
        guard let url = URL(string: urlString) else { return }
        downloadImageFrom(url: url, imageMode: imageMode)
    }

    func downloadImageFrom(url: URL, imageMode: UIViewContentMode) {
        contentMode = imageMode
        if let cachedImage = imageCache.object(forKey: url.absoluteString as NSString) as? UIImage {
            self.image = cachedImage
        } else {
            URLSession.shared.dataTask(with: url) { data, response, error in
                guard let data = data, error == nil else { return }
                DispatchQueue.main.async {
                    let imageToCache = UIImage(data: data)
                    self.imageCache.setObject(imageToCache!, forKey: url.absoluteString as NSString)
                    self.image = imageToCache
                }
            }.resume()
        }
    }
}

    Außerdem, hier ist eine nützliche Ressource:
    https://www.hackingwithswift.com/example-code/system/how-to-cache-data-using-nscache

    InformationsquelleAutor Brandon Lee
Schreibe einen Kommentar