wake-up-neo.net

Laden/Herunterladen eines Bildes von einer URL auf Swift

Ich möchte ein Bild von einer URL in meine Anwendung laden, also habe ich es zuerst mit Objective-C versucht und es funktionierte jedoch mit Swift. Ich habe einen Kompilierungsfehler: 

'imageWithData' ist nicht verfügbar: Objektkonstruktion verwenden 'UIImage (data :)'

Meine Funktion: 

@IBOutlet var imageView : UIImageView

override func viewDidLoad() {
    super.viewDidLoad()

    var url:NSURL = NSURL.URLWithString("http://myURL/ios8.png")
    var data:NSData = NSData.dataWithContentsOfURL(url, options: nil, error: nil)

    imageView.image = UIImage.imageWithData(data)// Error here
}

In Ziel-C: 

- (void)viewDidLoad {
    [super viewDidLoad];

    NSURL *url = [NSURL URLWithString:(@"http://myURL/ios8.png")];
    NSData *data = [NSData dataWithContentsOfURL:url];

    _imageView.image = [UIImage imageWithData: data];
    _labelURL.text = @"http://www.quentinroussat.fr/assets/img/iOS%20icon's%20Style/ios8.png";
 }

Kann mir bitte jemand erklären, warum der imageWithData: mit Swift nicht funktioniert und wie ich das Problem lösen kann. 

iosswiftuiimagensurl
324
QuentR

Xcode 8 oder höher • Swift 3 oder höher

Synchron:  

if let filePath = Bundle.main.path(forResource: "imageName", ofType: "jpg"), let image = UIImage(contentsOfFile: filePath) {
    imageView.contentMode = .scaleAspectFit
    imageView.image = image
}

Asynchron:  

Erstellen Sie eine Methode mit einem Completion-Handler, um die Bilddaten von Ihrer URL zu erhalten. 

func getData(from url: URL, completion: @escaping (Data?, URLResponse?, Error?) -> ()) {
    URLSession.shared.dataTask(with: url, completionHandler: completion).resume()
}

Eine Methode zum Herunterladen des Bildes erstellen (Task starten) 

func downloadImage(from url: URL) {
    print("Download Started")
    getData(from: url) { data, response, error in
        guard let data = data, error == nil else { return }
        print(response?.suggestedFilename ?? url.lastPathComponent)
        print("Download Finished")
        DispatchQueue.main.async() {
            self.imageView.image = UIImage(data: data)
        }
    }
}

Verwendungszweck: 

override func viewDidLoad() {
    super.viewDidLoad()
    // Do any additional setup after loading the view, typically from a nib.
    print("Begin of code")
    let url = URL(string: "http://www.Apple.com/euro/ios/ios8/a/generic/images/og.png")! 
    downloadImage(from: url)
    print("End of code. The image will continue downloading in the background and it will be loaded when it ends.")
}

Erweiterung :

extension UIImageView {
    func downloaded(from url: URL, contentMode mode: UIViewContentMode = .scaleAspectFit) {  // for Swift 4.2 syntax just use ===> mode: UIView.ContentMode
        contentMode = mode
        URLSession.shared.dataTask(with: url) { data, response, error in
            guard
                let httpURLResponse = response as? HTTPURLResponse, httpURLResponse.statusCode == 200,
                let mimeType = response?.mimeType, mimeType.hasPrefix("image"),
                let data = data, error == nil,
                let image = UIImage(data: data)
                else { return }
            DispatchQueue.main.async() {
                self.image = image
            }
        }.resume()
    }
    func downloaded(from link: String, contentMode mode: UIViewContentMode = .scaleAspectFit) {  // for Swift 4.2 syntax just use ===> mode: UIView.ContentMode
        guard let url = URL(string: link) else { return }
        downloaded(from: url, contentMode: mode)
    }
}

Verwendungszweck: 

imageView.downloaded(from: "http://www.Apple.com/euro/ios/ios8/a/generic/images/og.png")
656
Leo Dabus

(Swift 4-Update) Um die ursprüngliche Frage direkt zu beantworten, folgt hier das Swift-Äquivalent des veröffentlichten Objective-C-Snippets.

let url = URL(string: image.url)
let data = try? Data(contentsOf: url!) //make sure your image in this url does exist, otherwise unwrap in a if let check / try-catch
imageView.image = UIImage(data: data!)

HAFTUNGSAUSSCHLUSS:

Es ist wichtig zu wissen, dass die Data(contentsOf:)-Methode den Inhalt der URL synchron im selben Thread lädt, in dem der Code ausgeführt wird, sodass nicht dies im Haupt-Thread Ihrer Anwendung aufruft.

Eine einfache Möglichkeit, um den gleichen Code asynchron auszuführen, die Benutzeroberfläche nicht zu blockieren, ist die Verwendung von GCD:

let url = URL(string: image.url)

DispatchQueue.global().async {
    let data = try? Data(contentsOf: url!) //make sure your image in this url does exist, otherwise unwrap in a if let check / try-catch
    DispatchQueue.main.async {
        imageView.image = UIImage(data: data!)
    }
}

Wenn Sie in realen Anwendungen die beste Benutzererfahrung haben und mehrere Downloads desselben Bildes vermeiden möchten, möchten Sie möglicherweise, dass diese nicht nur heruntergeladen, sondern auch zwischengespeichert werden. Es gibt bereits einige Bibliotheken, die das sehr nahtlos machen, und alle sind sehr einfach zu bedienen. Ich persönlich empfehle Eisvogel :

import Kingfisher

let url = URL(string: "url_of_your_image")
// this downloads the image asynchronously if it's not cached yet
imageView.kf.setImage(with: url)

Und das ist es

289
Lucas Eduardo

Wenn Sie nur image (asynchron!) - laden möchten, fügen Sie Ihrem Swift-Code diese kleine Erweiterung hinzu:

extension UIImageView {
    public func imageFromUrl(urlString: String) {
        if let url = NSURL(string: urlString) {
            let request = NSURLRequest(URL: url)
            NSURLConnection.sendAsynchronousRequest(request, queue: NSOperationQueue.mainQueue()) {
                (response: NSURLResponse?, data: NSData?, error: NSError?) -> Void in
                if let imageData = data as NSData? {
                    self.image = UIImage(data: imageData)
                }
            }
        }
    }
}

Und benutze es so:

myImageView.imageFromUrl("https://robohash.org/123.png")
63
skywinder

Swift 2.2 || Xcode 7.3

Ich habe Amazing results !! mit AlamofireImage Swift-Bibliothek

Es bietet mehrere Funktionen wie:

  • Asynchron download
  • Automatisches Löschen des Bild-Caches, wenn Speicherwarnungen für die App auftreten
  • Bild-URL-Caching
  • Bild-Caching
  • Doppelte Downloads vermeiden

und sehr einfach für Ihre App zu implementieren

Schritt.1 Installieren Sie die Pods

Alamofire 3.3.x

schote 'Alamofire'

AlamofireImage 2.4.x

pod 'AlamofireImage'

Schritt 2 importieren und verwenden

import Alamofire
import AlamofireImage

let downloadURL = NSURL(string: "http://cdn.sstatic.net/Sites/stackoverflow/company/Img/photos/big/6.jpg?v=f4b7c5fee820")!
imageView.af_setImageWithURL(downloadURL)

das ist es!! es wird alles aufpassen

Vielen Dank an Alamofire-Jungs , für die Erleichterung von iDevelopers;)

40
swiftBoy

Xcode 8 • Swift 3

Die Antwort von Leo Dabus ist großartig! Ich wollte nur eine All-in-One-Funktionslösung bieten:

let url = URL(string: 
    "http://www.Apple.com/euro/ios/ios8/a/generic/images/og.png")

let task = URLSession.shared.dataTask(with: url!) { data, response, error in
    guard let data = data, error == nil else { return }

    DispatchQueue.main.async() {    // execute on main thread
        self.imageView.image = UIImage(data: data)
    }
}

task.resume()
25
Mark Moeykens

Ich habe den Code der besten Antworten auf die Frage in eine einzige wiederverwendbare UIImageView-Klasse zusammengefasst, sodass Sie das asynchrone Laden von UIImageViews direkt in Ihrem Storyboard verwenden können (oder sie aus Code erstellen können).

Hier ist meine Klasse:

import Foundation
import UIKit

class UIImageViewAsync :UIImageView
{

    override init()
    {
        super.init(frame: CGRect())
    }

    override init(frame:CGRect)
    {
        super.init(frame:frame)
    }

    required init(coder aDecoder: NSCoder) {
        super.init(coder: aDecoder)
    }

    func getDataFromUrl(url:String, completion: ((data: NSData?) -> Void)) {
        NSURLSession.sharedSession().dataTaskWithURL(NSURL(string: url)!) { (data, response, error) in
            completion(data: NSData(data: data))
        }.resume()
    }

    func downloadImage(url:String){
        getDataFromUrl(url) { data in
            dispatch_async(dispatch_get_main_queue()) {
                self.contentMode = UIViewContentMode.ScaleAspectFill
                self.image = UIImage(data: data!)
            }
        }
    }
}

und hier ist, wie man es benutzt:

imageView.downloadImage("http://www.image-server.com/myImage.jpg")
16
datayeah
let url = NSURL.URLWithString("http://live-wallpaper.net/iphone/img/app/i/p/iphone-4s-wallpapers-mobile-backgrounds-dark_2466f886de3472ef1fa968033f1da3e1_raw_1087fae1932cec8837695934b7eb1250_raw.jpg");
var err: NSError?
var imageData :NSData = NSData.dataWithContentsOfURL(url,options: NSDataReadingOptions.DataReadingMappedIfSafe, error: &err)
var bgImage = UIImage(data:imageData)
13
user3763002

Zu Ihrer Information: Für Swift-2.0 Xcode7.0 beta2

extension UIImageView {
    public func imageFromUrl(urlString: String) {
        if let url = NSURL(string: urlString) {
            let request = NSURLRequest(URL: url)
            NSURLConnection.sendAsynchronousRequest(request, queue: NSOperationQueue.mainQueue()) {
            (response: NSURLResponse?, data: NSData?, error: NSError?) -> Void in
                self.image = UIImage(data: data!)
            }
        }
    }
}
13
katopz

Swift 3 mit Fehlerbehandlung

let url = URL(string: arr[indexPath.row] as! String)
if url != nil {
    DispatchQueue.global().async {
        let data = try? Data(contentsOf: url!) //make sure your image in this url does exist, otherwise unwrap in a if let check / try-catch
        DispatchQueue.main.async {
            if data != nil {
                cell.imgView.image = UIImage(data:data!)
            }else{
                cell.imgView.image = UIImage(named: "default.png")
            }
        }
    }
}

Mit Erweiterung

extension UIImageView {

    func setCustomImage(_ imgURLString: String?) {
        guard let imageURLString = imgURLString else {
            self.image = UIImage(named: "default.png")
            return
        }
        DispatchQueue.global().async {
            let data = try? Data(contentsOf: URL(string: imageURLString)!)
            DispatchQueue.main.async {
                self.image = data != nil ? UIImage(data: data!) : UIImage(named: "default.png")
            }
        }
    }
}

Erweiterungsnutzung

myImageView. setCustomImage ("url")

8
Manee ios

Swift 2 mit Fehlerhandle und benutzerdefiniertem Anforderungskopf

Fügen Sie einfach die Erweiterung zu UIImageView hinzu: 

extension UIImageView {
    public func imageFromUrl(urlString: String) {
        if let url = NSURL(string: urlString) {
            let request = NSMutableURLRequest(URL: url)
            request.setValue("<YOUR_HEADER_VALUE>", forHTTPHeaderField: "<YOUR_HEADER_KEY>")
            NSURLSession.sharedSession().dataTaskWithRequest(request) {
                (data, response, error) in
                guard let data = data where error == nil else{
                    NSLog("Image download error: \(error)")
                    return
                }

                if let httpResponse = response as? NSHTTPURLResponse{
                    if httpResponse.statusCode > 400 {
                        let errorMsg = NSString(data: data, encoding: NSUTF8StringEncoding)
                        NSLog("Image download error, statusCode: \(httpResponse.statusCode), error: \(errorMsg!)")
                        return
                    }
                }

            dispatch_async(dispatch_get_main_queue(), {
                NSLog("Image download success")
                self.image = UIImage(data: data)
            })
            }.resume()
        }
    }
}

Verwenden Sie dann die neue imageFromUrl(urlString: String), um das Image herunterzuladen

Verwendungszweck: 

imageView.imageFromUrl("https://i.imgur.com/ONaprQV.png")
7
Cody

Sie möchten Folgendes tun:

UIImage(data: data)

In Swift haben sie die meisten Objective C-Fabrikmethoden durch reguläre Konstruktoren ersetzt.

Sehen:

https://developer.Apple.com/library/prerelease/ios/documentation/Swift/Conceptual/BuildingCocoaAls/InteractingWithObjective-CAPIs.html#//Apple_ref/doc/uid/TP40014216-CH4_XID_26

7
joshstaiger

Swift 4: Ein einfacher Loader für kleine Bilder (zB: Miniaturbilder), der NSCache verwendet und immer im Haupt-Thread ausgeführt wird:

class ImageLoader {

  private static let cache = NSCache<NSString, NSData>()

  class func image(for url: URL, completionHandler: @escaping(_ image: UIImage?) -> ()) {

    DispatchQueue.global(qos: DispatchQoS.QoSClass.background).async {

      if let data = self.cache.object(forKey: url.absoluteString as NSString) {
        DispatchQueue.main.async { completionHandler(UIImage(data: data as Data)) }
        return
      }

      guard let data = NSData(contentsOf: url) else {
        DispatchQueue.main.async { completionHandler(nil) }
        return
      }

      self.cache.setObject(data, forKey: url.absoluteString as NSString)
      DispatchQueue.main.async { completionHandler(UIImage(data: data as Data)) }
    }
  }

}

Verwendungszweck: 

ImageLoader.image(for: imageURL) { image in
  self.imageView.image = image
}
6
fethica

Schnell 4

Diese Methode lädt ein Bild asynchron von einer Website herunter und speichert es im Cache:

    func getImageFromWeb(_ urlString: String, closure: @escaping (UIImage?) -> ()) {
        guard let url = URL(string: urlString) else {
return closure(nil)
        }
        let task = URLSession(configuration: .default).dataTask(with: url) { (data, response, error) in
            guard error == nil else {
                print("error: \(String(describing: error))")
                return closure(nil)
            }
            guard response != nil else {
                print("no response")
                return closure(nil)
            }
            guard data != nil else {
                print("no data")
                return closure(nil)
            }
            DispatchQueue.main.async {
                closure(UIImage(data: data!))
            }
        }; task.resume()
    }

In Benutzung:

    getImageFromWeb("http://www.Apple.com/euro/ios/ios8/a/generic/images/og.png") { (image) in
        if let image = image {
            let imageView = UIImageView(frame: CGRect(x: 0, y: 0, width: 200, height: 200))
            imageView.image = image
            self.view.addSubview(imageView)
        } // if you use an Else statement, it will be in background
    }
6
Bobby

Swift 2.0:  

1)

if let url = NSURL(string: "http://etc...") {
    if let data = NSData(contentsOfURL: url) {
        imageURL.image = UIImage(data: data)
    }        
}

ODER 

imageURL.image =
    NSURL(string: "http:// image name...")
    .flatMap { NSData(contentsOfURL: $0) }
    .flatMap { UIImage(data: $0) }

2) Fügen Sie diese Methode zu VC oder Extension hinzu.

func load_image(urlString:String)
{   let imgURL: NSURL = NSURL(string: urlString)!
    let request: NSURLRequest = NSURLRequest(URL: imgURL)

    NSURLConnection.sendAsynchronousRequest(request, queue: NSOperationQueue.mainQueue()) { (response: NSURLResponse?, data: NSData?, error: NSError?) in

        if error == nil {
            self.image_element.image = UIImage(data: data)
        }
    }
}

Verwendungszweck : 

self.load_image(" url strig here")
5
A.G

Kingfisher ist eine der besten Bibliotheken zum Laden von Bildern in URL.

Github-URL - https://github.com/onevcat/Kingfisher

// If you want to use Activity Indicator.
imageview_pic.kf.indicatorType = .activity
imageview_pic.kf.setImage(with: URL(string: "Give your url string"))

// If you want to use custom placeholder image.
imageview_pic.kf.setImage(with: URL(string: "Give your url string"), placeholder: UIImage(named: "placeholder image name"), options: nil, progressBlock: nil, completionHandler: nil)
4
Kamani Jasmin

Ich empfehle die Verwendung der Kingfisher-Bibliothek, um Bilder asynchron herunterzuladen. Das Beste an Kingfisher ist, dass alle heruntergeladenen Bilder standardmäßig mit der Bild-URL als ID zwischengespeichert werden. Wenn Sie das nächste Mal anfordern, ein Bild mit dieser bestimmten URL herunterzuladen, wird es aus dem Cache geladen.

Verwendungszweck: 

newsImage.kf.setImage(with: imageUrl!, placeholder: nil, options: nil, progressBlock: nil, completionHandler: { (image, error, cacheType, imageUrl) in
                if error == nil{
                    self.activityIndicator.stopAnimating()
                }else if error != nil{
                    self.activityIndicator.stopAnimating()
                }
            })
3
Raj Salla

Wenn Sie eine sehr einfache Implementierung suchen. (Dies hat in Swift 2 für mich funktioniert)

 let imageURL = NSURL(string: "https://farm2.staticflickr.com/1591/26078338233_d1466b7da2_m.jpg")
 let imagedData = NSData(contentsOfURL: imageURL!)!
 imageView?.image = UIImage(data: imagedData)

Ich habe eine Tabellenansicht mit einer benutzerdefinierten Zelle implementiert, die nur ein Bild enthält

func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell{

        let cell = tableView.dequeueReusableCellWithIdentifier("theCell", forIndexPath: indexPath) as! customTableViewCell

        let imageURL = NSURL(string: "https://farm2.staticflickr.com/1591/26078338233_d1466b7da2_m.jpg")

        let imagedData = NSData(contentsOfURL: imageURL!)!

        cell.imageView?.image = UIImage(data: imagedData)

        return cell

    }
3
Naishta

Eine Methode, um ein Bild zu erhalten, das sicher ist und mit Swift 2.0 und X-Code 7.1 funktioniert:

static func imageForImageURLString(imageURLString: String, completion: (image: UIImage?, success: Bool) -> Void) {
    guard let url = NSURL(string: imageURLString),
        let data = NSData(contentsOfURL: url),
        let image = UIImage(data: data)
        else { 
            completion(image: nil, success: false); 
            return 
       }

    completion(image: image, success: true)
}

Sie würden diese Methode dann so aufrufen: 

imageForImageURLString(imageString) { (image, success) -> Void in
        if success {
            guard let image = image 
                 else { return } // Error handling here 
            // You now have the image. 
         } else {
            // Error handling here.
        }
    }

Wenn Sie die Ansicht mit dem Bild aktualisieren, müssen Sie dies nach dem "if success" verwenden:

    dispatch_async(dispatch_get_main_queue()) { () -> Void in
         guard let image = image 
              else { return } // Error handling here 
         // You now have the image. Use the image to update the view or anything UI related here
         // Reload the view, so the image appears
    }

Wenn Sie das Image in der Benutzeroberfläche verwenden, ist der letzte Teil erforderlich, weil Netzwerkanrufe Zeit benötigen. Wenn Sie versuchen, die Benutzeroberfläche mit dem Image zu aktualisieren, ohne dispatch_async wie oben aufzurufen, sucht der Computer nach dem Image, während das Image noch abgerufen wird, stellt fest, dass noch kein Image vorhanden ist, und fährt fort, als wäre kein Image vorhanden gefunden Wenn Sie Ihren Code in eine dispatch_async-Beendigungsschließung einfügen, sagt der Computer: "Los, holen Sie sich dieses Image und wenn Sie fertig sind, vervollständigen Sie diesen Code." Auf diese Weise erhalten Sie das Bild, wenn der Code aufgerufen wird, und die Dinge funktionieren gut. 

3
Ben Patch

Swift 4::

Dies zeigt den Loader an, während das Image geladen wird. Sie können NSCache verwenden, um das Image vorübergehend zu speichern 

let imageCache = NSCache<NSString, UIImage>()
extension UIImageView {
    func loadImageUsingCache(withUrl urlString : String) {
        let url = URL(string: urlString)
        if url == nil {return}
        self.image = nil

        // check cached image
        if let cachedImage = imageCache.object(forKey: urlString as NSString)  {
            self.image = cachedImage
            return
        }

        let activityIndicator: UIActivityIndicatorView = UIActivityIndicatorView.init(activityIndicatorStyle: .gray)
        addSubview(activityIndicator)
        activityIndicator.startAnimating()
        activityIndicator.center = self.center

        // if not, download image from url
        URLSession.shared.dataTask(with: url!, completionHandler: { (data, response, error) in
            if error != nil {
                print(error!)
                return
            }

            DispatchQueue.main.async {
                if let image = UIImage(data: data!) {
                    imageCache.setObject(image, forKey: urlString as NSString)
                    self.image = image
                    activityIndicator.removeFromSuperview()
                }
            }

        }).resume()
    }
}

Verwendungszweck:-

truckImageView.loadImageUsingCache(withUrl: currentTruck.logoString)
2
Jack

Sie können pod SDWebImage verwenden, um dasselbe zu erreichen. Es ist einfach zu bedienen. Sie können hier Dokumentationen erhalten SDWebImage

Hier ist der Beispielcode

self.yourImage.sd_setImage(with: NSURL(string: StrUrl as String ) as URL!, placeholderImage: placeholderImage, options: SDWebImageOptions(rawValue: 0), completed: { (image, error, cacheType, imageURL) in
                if( error != nil)
                {
                    print("Error while displaying image" , (error?.localizedDescription)! as String)
                }
            })
2
Shruti Thombre

Swift 2.x-Antwort zum Herunterladen von Bildern in eine Datei (im Gegensatz zu Leo Dabus 'Antwort, bei der das Bild im Speicher gespeichert wird). Basierend auf der Antwort von Leo Dabus und Robs Antwort von Holen Sie die Daten von NSURLSession DownloadTaskWithRequest von Completion Handler :

    // Set download vars
    let downloadURL = NSURL() // URL to download from
    let localFilename = "foobar.png" // Filename for storing locally 

    // Create download request
    let task = NSURLSession.sharedSession().downloadTaskWithURL(downloadURL) { location, response, error in
        guard location != nil && error == nil else {
            print("Error downloading message: \(error)")
            return
        }

        // If here, no errors so save message to permanent location
        let fileManager = NSFileManager.defaultManager()
        do {
            let documents = try fileManager.URLForDirectory(.DocumentDirectory, inDomain: .UserDomainMask, appropriateForURL: nil, create: false)
            let fileURL = documents.URLByAppendingPathComponent(localFilename)
            try fileManager.moveItemAtURL(location!, toURL: fileURL)
            self.doFileDownloaded(fileURL, localFilename: localFilename)
            print("Downloaded message @ \(localFilename)")
        } catch {
            print("Error downloading message: \(error)")
        }
    }

    // Start download
    print("Starting download @ \(downloadURL)")
    task.resume()


// Helper function called after file successfully downloaded
private func doFileDownloaded(fileURL: NSURL, localFilename: String) {

    // Do stuff with downloaded image

}
1
Crashalot

Swift 4.1 Ich habe eine Funktion erstellt, die Image-URL nur übergeben, der Cacheschlüssel, nachdem das Image generiert wurde, auf "Completion" gesetzt.

   class NetworkManager: NSObject {

  private var imageQueue = OperationQueue()
  private var imageCache = NSCache<AnyObject, AnyObject>()

  func downloadImageWithUrl(imageUrl: String, cacheKey: String, completionBlock: @escaping (_ image: UIImage?)-> Void) {

    let downloadedImage = imageCache.object(forKey: cacheKey as AnyObject)
    if let  _ = downloadedImage as? UIImage {
      completionBlock(downloadedImage as? UIImage)
    } else {
      let blockOperation = BlockOperation()
      blockOperation.addExecutionBlock({
        let url = URL(string: imageUrl)
        do {
          let data = try Data(contentsOf: url!)
          let newImage = UIImage(data: data)
          if newImage != nil {
            self.imageCache.setObject(newImage!, forKey: cacheKey as AnyObject)
            self.runOnMainThread {
              completionBlock(newImage)
            }
          } else {
            completionBlock(nil)
          }
        } catch {
          completionBlock(nil)
        }
      })
      self.imageQueue.addOperation(blockOperation)
      blockOperation.completionBlock = {
        print("Image downloaded \(cacheKey)")
      }
    }
  }
}
extension NetworkManager {
  fileprivate func runOnMainThread(block:@escaping ()->Void) {
    if Thread.isMainThread {
      block()
    } else {
      let mainQueue = OperationQueue.main
      mainQueue.addOperation({
        block()
      })
    }
  }
}
1
GSK

Das einzige, was dort fehlt, ist ein!

let url = NSURL.URLWithString("http://live-wallpaper.net/iphone/img/app/i/p/iphone-4s-wallpapers-mobile-backgrounds-dark_2466f886de3472ef1fa968033f1da3e1_raw_1087fae1932cec8837695934b7eb1250_raw.jpg");
var err: NSError?
var imageData :NSData = NSData.dataWithContentsOfURL(url!,options: NSDataReadingOptions.DataReadingMappedIfSafe, error: &err)
var bgImage = UIImage(data:imageData!)
1
Simon Jensen
class func downloadImageFromUrl(with urlStr: String, andCompletionHandler:@escaping (_ result:Bool) -> Void) {
        guard let url = URL(string: urlStr) else {
            andCompletionHandler(false)
            return
        }
        DispatchQueue.global(qos: .background).async {
            URLSession.shared.dataTask(with: url, completionHandler: { (data, response, error) -> Void in
                if error == nil {
                    let httpURLResponse = response as? HTTPURLResponse
                    Utils.print( "status code ID : \(String(describing: httpURLResponse?.statusCode))")
                    if httpURLResponse?.statusCode == 200 {
                        if let data = data {
                            if let image = UIImage(data: data) {
                                ImageCaching.sharedInterface().setImage(image, withID: url.absoluteString as NSString)
                                DispatchQueue.main.async {
                                    andCompletionHandler(true)
                                }
                            }else {
                                andCompletionHandler(false)
                            }
                        }else {
                            andCompletionHandler(false)
                        }
                    }else {
                        andCompletionHandler(false)
                    }
                }else {
                    andCompletionHandler(false)
                }
            }).resume()
        }
    }

Ich habe in meiner Klasse Utils.Swift eine einfache Klassenfunktion zum Aufrufen dieser Methode erstellt, auf die Sie einfach mit classname.methodname zugreifen können. Ihre Bilder werden im NSCache mit der Klasse ImageCaching.Swift gespeichert

Utils.downloadImageFromUrl(with: URL, andCompletionHandler: { (isDownloaded) in
                            if isDownloaded {
                                if  let image = ImageCaching.sharedInterface().getImage(URL as NSString) {
                                    self.btnTeam.setBackgroundImage(image, for: .normal)
                                }
                            }else {
                                DispatchQueue.main.async {
                                    self.btnTeam.setBackgroundImage(#imageLiteral(resourceName: "com"), for: .normal)
                                }
                            }
                        })

Happy Codding. Prost:)

1
Vishal16

Hier ist der Arbeitscode zum Laden/Herunterladen eines Bildes von einer URL. NSCache automatisch und Platzhalterbild vor dem Download anzeigen und Aktuelles Bild laden (Swift 4-Code). 

func NKPlaceholderImage(image:UIImage?, imageView:UIImageView?,imgUrl:String,compate:@escaping (UIImage?) -> Void){

    if image != nil && imageView != nil {
        imageView!.image = image!
    }

    var urlcatch = imgUrl.replacingOccurrences(of: "/", with: "#")
    let documentpath = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)[0]
    urlcatch = documentpath + "/" + "\(urlcatch)"

    let image = UIImage(contentsOfFile:urlcatch)
    if image != nil && imageView != nil
    {
        imageView!.image = image!
        compate(image)

    }else{

        if let url = URL(string: imgUrl){

            DispatchQueue.global(qos: .background).async {
                () -> Void in
                let imgdata = NSData(contentsOf: url)
                DispatchQueue.main.async {
                    () -> Void in
                    imgdata?.write(toFile: urlcatch, atomically: true)
                    let image = UIImage(contentsOfFile:urlcatch)
                    compate(image)
                    if image != nil  {
                        if imageView != nil  {
                            imageView!.image = image!
                        }
                    }
                }
            }
        }
    }
}

Verwendung wie folgt: 

// Here imgPicture = your imageView
// UIImage(named: "placeholder") is Display image brfore download and load actual image. 

NKPlaceholderImage(image: UIImage(named: "placeholder"), imageView: imgPicture, imgUrl: "Put Here your server image Url Sting") { (image) in }
1
Nikunj Kumbhani

Diesen Code in Swift verwenden 

imageView.image=UIImage(data: NSData(contentsOfURL: NSURL(string: "http://myURL/ios8.png")!)!
0
Bibin Joseph

Swift 4.2 und AlamofireImage

Wenn die Verwendung einer Bibliothek kein Problem darstellt, können Sie dies mit Hilfe von AlamofireImage..__ tun. Meine Beispiele stammen von Github

Platzhalterbilder Beispiel:

let imageView = UIImageView(frame: frame)
let url = URL(string: "https://httpbin.org/image/png")!
let placeholderImage = UIImage(named: "placeholder")!
imageView.af_setImage(withURL: url, placeholderImage: placeholderImage)

es hat viele praktische Funktionen und Erweiterungen, um mit Bildern zu arbeiten. vom Zwischenspeichern bis zur Skalierung und Größenänderung oder sogar zum Anwenden von Filtern auf das Bild. Wenn Bilder in Ihrer App wichtig sind, schlage ich vor, dieses Framework zu verwenden und Zeit zu sparen.

0
Hamid Shahsavari

Mit Ascyimageview können Sie einfach imageurl in imageview laden.

let image1Url: URL = URL (Zeichenfolge: "(imageurl)" als Zeichenfolge)!

0
saurabh rathod

Bild wird vom Server geladen: - 

func downloadImage(from url: URL , success:@escaping((_ image:UIImage)->()),failure:@escaping ((_ msg:String)->())){
    print("Download Started")
    getData(from: url) { data, response, error in
        guard let data = data, error == nil else {
            failure("Image cant download from G+ or fb server")
            return
        }

        print(response?.suggestedFilename ?? url.lastPathComponent)
        print("Download Finished")
        DispatchQueue.main.async() {
             if let _img = UIImage(data: data){
                  success(_img)
            }
        }
    }
}
func getData(from url: URL, completion: @escaping (Data?, URLResponse?, Error?) -> ()) {
    URLSession.shared.dataTask(with: url, completionHandler: completion).resume()
}

Verwendungszweck :- 

  if let url = URL(string: "http://www.Apple.com/euro/ios/ios8/a/generic/images/og.png") {
                        self.downloadImage(from:url , success: { (image) in
                            print(image)

                        }, failure: { (failureReason) in
                            print(failureReason)
                        })
                    }
0
Abhimanyu Rathore