Does Uiimageview Cache Images

Does UIImageView cache images?

The method
[UIImage imageNamed:@""]
caches the image. The UIImageView doesn't. I had a problem in an app with a lot of images that was crashing due to low memory.
To fix if I changed to [UIImage imageWithContentsOfFile:@""] that does not caches the image.

To pre-cache the image you can simply call [UIImage imageNamed:@""] for all images you want in the init method. But if you receive a memory warning the images gonna be deallocated.

Does the UIImage Cache image?

• The -initWithContentsOfFile: creates a new image without caching, it's an ordinary initialization method.

• The +imageNamed: method uses cache. Here's a documentation from UIImage Reference:

  This method looks in the system caches for an image object with the specified name and returns that object if it exists. If a matching image object is not already in the cache, this method loads the image data from the specified file, caches it, and then returns the resulting object.

  UIImage will retain loaded image, keeping it alive until low memory condition will cause the cache to be purged.

Update for Swift:
In Swift the UIImage(named: "...") function is the one that caches the image.

How do I release cached images when using UIImage(data:)?

I was under the impression that Firestore auto-caching applied to cloud Storage, but it only applies to cloud Database. Once I implemented local caching with NSCache, my problem was solved.

How do I get cached image stored by AFNetworking's UIImageView category?

I assume you import UIImageView+AFNetworking.h header.

If you want to access to the cached image. You should have a NSURLRequest object. Then it is like this:

UIImage *image = [[UIImageView sharedImageCache] cachedImageForRequest:request];

Done!

How to cache images when using imageWithData to make a UIImage

I've seen more then a few discussions of this online over the years with various solutions and rationales. Arguably the simplest solution is here.

In short with large numbers of images, UIImage imageNamed is rough on memory and it suggests using a simple dictionary with imageWithContentsOfFile to store cached images where you can easily have more control over memory usage.

Pre-cache Images for AFNetworking's UIImageView category

Please, please don't do this.

Trust me when I say that this almost certainly unnecessary.

In fact, it will likely have the opposite of the desired effect, due to the increased pressure of downloading images that will probably never be viewed.

The cache is private for a very good reason--it's just there to speed up subsequent requests on scroll views. Just have the table view download the images as requested, and you should be just fine. If anything, you can optimize the size of the images that you are downloading (ensure correct image dimensions; compress intelligently).

How to Flush Cache to Free up Memory when using UIImage - Swift 3.0

It's pretty simple. UIImage(named:) caches images, and UIImage(contentsOfFile:) does not.

If you don't want your images to be cached, use UIImage(contentsOfFile:) instead. If you can't get that to work then post your code and we'll help you debug it.

Be aware that UIImage(contentsOfFile:) does not look for files in your app bundle. It expects a full path to the image file. You will need to use Bundle methods to find the path to the file and then pass that path to UIImage(contentsOfFile:):

if let imagePath = Bundle.mainBundle.path(forResource: "ImageSet1" ofType: "png"),
  let image = UIImage(contentsOfFile: imagePath) {
     //Your image has been loaded 
}

Your code is loading all the images for all 3 animations into an array of images and never releasing them, so the fact that the system caches those images seems pretty irrelevant. In a low memory condition the system should flush the cached copies of the images, but your code will still hold all those images in your arrays so the memory won't get freed. It looks to me like it's your code that's causing the memory problem, not the system's images caching.

Your code might look like this:

func createImageArray(total: Int, imagePrefix: String) -> [UIImage]{
    var imageArray: [UIImage] = []
    for imageCount in 0..<total {
        let imageName = "\(imagePrefix)-\(imageCount)"
        if let imagePath = Bundle.main.path(forResource: imageName,
            ofType: "png"),
          let image = UIImage(contentsOfFile: imagePath) {
              imageArray.append(image)
        }
    }
    return imageArray 
}

When is it worthwhile to cache UIImage resources?

In the latest performance sessions at WWDC (2011), Apple didn't recommend caching images for most cases. They recommend that you only cache images when you know for a fact, after a performance analysis, that you need to cache images ahead of time because you can't afford the time to load them off disk and decode them. In most cases you probably can afford it.

They specifically noted, as @Till does, that +[UIImage imageNamed:] caches images for the lifetime of your process, and so they recommend using a non-caching loading method, such as +[UIImage imageWithContentsOfFile:]

The reason is that memory is a constrained resource on iOS devices, so if you cache your images, you are likely to cause memory pressure on the system, and apps to get jetsammed. And since iOS 5 jetsams apps using more memory first, if you're caching a bunch of UIImages you're going to make it more likely for your app to get jetsammed.

---

Related Topics