SDWebImage Pobierz obraz i zapisz do pamięci podręcznej dla klucza

In Swift użyj poniższego kodu, aby pobrać obraz i zapisać go w pamięci podręcznej:

//SDWebImageManager download image with High Priority 

    SDWebImageManager.sharedManager().downloadImageWithURL(NSURL(string: imageUrl), options: SDWebImageOptions.HighPriority, progress: { (receivedSize :Int, ExpectedSize :Int) in
            SVProgressHUD.show()
            }, completed: { (image :UIImage!, error:NSError!, cacheType :SDImageCacheType, finished :Bool,imageUrl: NSURL!) in
                if(finished) {
                    SVProgressHUD.dismiss()
                    if((image) != nil) {
                        //image downloaded do your stuff
                    }
                }
        })

Wersja Swift 3 :

SDWebImageManager.shared().downloadImage(with: NSURL(string: "...") as URL!, options: .continueInBackground, progress: { 
(receivedSize :Int, ExpectedSize :Int) in

}, completed: { 
(image : UIImage?, error : Error?, cacheType : SDImageCacheType, finished : Bool, url : URL?) in

})

Objective-C Wersja:

[[SDWebImageDownloader sharedDownloader] downloadImageWithURL:[NSURL URLWithString:imageUrl] options:SDWebImageDownloaderUseNSURLCache progress:nil completed:^(UIImage *image, NSData *data, NSError *error, BOOL finished) {

                    if (image && finished) {
                        // Cache image to disk or memory
                        [[SDImageCache sharedImageCache] storeImage:image forKey:CUSTOM_KEY toDisk:YES];     
                    }
                }]; 

Swift 4:

SDWebImageManager.shared().loadImage(
        with: URL(string: imageUrl),
        options: .highPriority,
        progress: nil) { (image, data, error, cacheType, isFinished, imageUrl) in
          print(isFinished)
      }

SWIFT 5 & najnowszy SDWebImage 5.2.3

SDWebImageManager.shared.loadImage(
    with: album.artUrlFor(imageShape: .square),
    options: .continueInBackground, // or .highPriority
    progress: nil,
    completed: { [weak self] (image, data, error, cacheType, finished, url) in
        guard let sself = self else { return }

        if let err = error {
            // Do something with the error
            return
        }

        guard let img = image else {
            // No image handle this error
            return
        }

        // Do something with image
    }
)

SDWebImage buforuje obraz zarówno na dysk, jak i pamięć. Przejdźmy przez to:

1. pobierasz obraz z nowego adresu url.
2. jest buforowany na pamięć i dysk.
3. Jeśli wywołasz obraz w tej samej sesji, zostanie on pobrany z pamięci.
4. Załóżmy, że ponownie uruchomisz aplikację, a następnie uzyskasz dostęp do adresu url, sprawdzi pamięć, gdzie nie będzie obrazu, a następnie sprawdzi dysk i stamtąd pobierze. Jeśli nie, pobierze go.
5. The obraz pozostaje na dysku przez tydzień według standardowego ustawienia.

Więc nie musisz się martwić o buforowanie. SDWebImage dba o to cholernie dobrze.

Możesz wykonać niestandardową implementację buforowania, a także odświeżyć obraz z pamięci podręcznej w przypadku, gdy chcesz, aby ustawienia były zgodne z nagłówkiem buforowania HTTP.

Możesz znaleźć pełne szczegóły na ich stronie github tutaj .

Spróbuj tego dla Swift 4.0 .

let url = URL(string: imageUrl!)

SDWebImageManager.shared().imageDownloader?.downloadImage(with: url, options: .continueInBackground, progress: nil, completed: {(image:UIImage?, data:Data?, error:Error?, finished:Bool) in
     if image != nil {. 

     }
})

Wypróbuj APSmartStorage ( https://github.com/Alterplay/APSmartStorage ) zamiast SDWebImage.

APSmartStorage pobiera dane z sieci i automatycznie buforuje dane na dysku lub w pamięci w inteligentny, konfigurowalny sposób. Powinno wystarczyć na twoje zadanie.

Tak można pobrać obraz za pomocą SDWebImage i zapisać go w pamięci lokalnej ręcznie .

Pobrany obraz przechowuje się w pamięci lokalnej używając SDWebImage

func saveImage(url: URL, toCache: UIImage?, complation: @escaping SDWebImageNoParamsBlock) {
    guard let toCache = toCache else { return }

    let manager = SDWebImageManager.shared()
    if let key = manager.cacheKey(for: url) {
        manager.imageCache?.store(toCache, forKey: key, completion: complation)
    }
}

Załaduj obraz z pamięci za pomocą adresu URL obrazu

static func imageFromMemory(for url: String) -> UIImage? {
    if let encoded = url.addingPercentEncoding(withAllowedCharacters: .urlFragmentAllowed),
        let url = URL(string: encoded) {
        let manager = SDWebImageManager.shared()
        if let key: String = manager.cacheKey(for: url),
            let image = manager.imageCache?.imageFromMemoryCache(forKey: key) {
            return image
        }
    }
    return nil
}

//UTWÓRZ CUSTOME IMAGEVIEW I PRZEKAŻ ADRES URL OBRAZU ZA POMOCĄ TABLICY (INDEXPATH.Wiersz)

(void) loadImage:(NSString *)imageLink{

    imageLink = [imageLink stringByReplacingOccurrencesOfString:@" " withString:@"%20"];

    SDWebImageManager *manager = [SDWebImageManager sharedManager];

    [manager loadImageWithURL:[NSURL URLWithString:imageLink] options:SDWebImageDelayPlaceholder progress:^(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL) {

    } completed:^(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, SDImageCacheType cacheType, BOOL finished, NSURL * _Nullable imageURL) {

        imageFrame.image = image;

    }];
}

Swift 5.1

import UIKit
import SDWebImage

extension UIImageView{
    func downloadImage(url:String){
      //remove space if a url contains.
        let stringWithoutWhitespace = url.replacingOccurrences(of: " ", with: "%20", options: .regularExpression)
        self.sd_imageIndicator = SDWebImageActivityIndicator.gray
        self.sd_setImage(with: URL(string: stringWithoutWhitespace), placeholderImage: UIImage())
    }
}

Jak stosować

let myUrl = "https://www.example.com"
myImageView.downloadImage(url: myUrl)

SDWebImageManager *manager = [SDWebImageManager sharedManager];

[manager downloadImageWithURL:ImageUrl options:0 progress:^(NSInteger receivedSize, NSInteger expectedSize)

{


} completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {

    if(image){


        NSLog(@"image=====%@",image);
    }
}];