Ios SwiftUI@ObservedObject在异步获取映像时未得到更新

我有一个应用程序，它从远程API获取一个带有图像URL的项目列表，然后它必须从该项目位置内的给定URL获取每个项目的图像。 问题是，当上下滚动从而从视图中删除列表项并将其移回视图时，它们确实会显示出来。然而，在初始加载时，它们始终处于“加载”状态，直到移出和移入。 我的代码：

import SwiftUI

struct ContentView: View {

    @EnvironmentObject var artObjectStore: ArtObjectStore
    @State private var pageCount = 1
    @State private var tappedLink: String? = nil
    @Environment(\.imageCache) var cache: ImageCache

    var body: some View {
        NavigationView {
            Form {

                Section(header: Text("Art")) {

                    List {
                        ForEach(artObjectStore.artObjects, id: \.self) { artObject in
                            self.link(for: artObject)

                        }
                        Button(action: loadMore) {
                            Text("")
                        }
                        .onAppear {
                            DispatchQueue.global(qos: .background).asyncAfter(deadline: DispatchTime(uptimeNanoseconds: 10)) {
                                self.loadMore()
                            }
                        }
                    }
                }
            }
            .navigationBarTitle("Art objects")
        }
        .onAppear(perform: loadMore)

    }

    func loadMore() {
        pageCount += 1
        artObjectStore.loadMore(pageCount)
    }

    private func link(for artObject: ArtObject) -> some View {
        let selection = Binding(get: { self.tappedLink },
            set: {
                UIApplication.shared.endEditing()
                self.tappedLink = $0
        })

        return NavigationLink(destination: DetailView(artObject: artObject, cache: self.cache),
                              tag: artObject.id,
                              selection: selection) {
            HStack(alignment: .center) {
                VStack(alignment: .leading){
                    Text("\(artObject.title)").font(.system(size: 12))
                    Text("\(artObject.principalOrFirstMaker)").font(.system(size: 9)).foregroundColor(.gray)
                }
                Spacer()
                AsyncImage(
                    url: URL(string: artObject.headerImage.url)!,
                    cache: self.cache,
                    width: 200,
                    height: 50
                )
            }
        }
    }
}


extension UIApplication {
    func endEditing() {
        sendAction(#selector(UIResponder.resignFirstResponder), to: nil, from: nil, for: nil)
    }
}

struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

图像容器：

import SwiftUI
import Combine
import Foundation

class ImageLoader: ObservableObject {

    let objectWillChange = ObservableObjectPublisher()

    private var cancellable: AnyCancellable?
    @Published var image: UIImage? {
        willSet {
            objectWillChange.send()
        }
    }


    private let url: URL

    private var cache: ImageCache?

    init(url: URL, cache: ImageCache? = nil) {
        self.url = url
        self.cache = cache
    }

    deinit {
        cancellable?.cancel()
    }

    private func cache(_ image: UIImage?) {
        image.map { cache?[url] = $0 }
    }

    func load() {
        if let image = cache?[url] {
            self.image = image
            return
        }

        cancellable = URLSession.shared.dataTaskPublisher(for: url)
            .map { UIImage(data: $0.data) }
            .replaceError(with: nil)
            .handleEvents(receiveOutput: { [weak self] in self?.cache($0) })
            .receive(on: DispatchQueue.main)
            .assign(to: \.image, on: self)


    }

    func cancel() {
        cancellable?.cancel()
    }
}


struct AsyncImage: View {
    @ObservedObject private var loader: ImageLoader
    private let width: CGFloat?
    private let height: CGFloat?
    @State var spin = false

    init(url: URL, cache: ImageCache? = nil, width: CGFloat? = nil, height: CGFloat? = nil) {
        loader = ImageLoader(url: url, cache: cache)
        self.width = width
        self.height = height
    }

    var body: some View {
        image
            .onAppear(perform: loader.load)
            .onDisappear(perform: loader.cancel)
    }

    private var image: some View {
        Group {
            if loader.image != nil {
                Image(uiImage: loader.image!)
                    .resizable()
                    .aspectRatio(contentMode: .fit)
                    .frame(width: width, height: height)
            } else {
                Image("loadingCircle")
                    .resizable()
                    .frame(width: 20, height: 20)
                    .rotationEffect(.degrees(spin ? 360 : 0))
                    .animation(Animation.linear(duration: 0.8).repeatForever(autoreverses: false))
                    .onAppear() {
                        self.spin.toggle()
                }
            }
        }
    }
}

protocol ImageCache {
    subscript(_ url: URL) -> UIImage? { get set }
}

struct TemporaryImageCache: ImageCache {
    private let cache = NSCache<NSURL, UIImage>()

    subscript(_ key: URL) -> UIImage? {
        get { cache.object(forKey: key as NSURL) }
        set { newValue == nil ? cache.removeObject(forKey: key as NSURL) : cache.setObject(newValue!, forKey: key as NSURL) }
    }
}


struct ImageCacheKey: EnvironmentKey {
    static let defaultValue: ImageCache = TemporaryImageCache()
}

extension EnvironmentValues {
    var imageCache: ImageCache {
        get { self[ImageCacheKey.self] }
        set { self[ImageCacheKey.self] = newValue }
    }
}

导入快捷界面
进口联合收割机
进口基金会
类ImageLoader:ObservableObject{
let objectWillChange=observeObjectPublisher（）
私有var可取消：任何可取消？
@已发布的var图像：UIImage{
意志{
objectWillChange.send（）
}
}
私有let url:url
私有变量缓存：ImageCache？
初始化（url:url，缓存：ImageCache？=nil）{
self.url=url
self.cache=cache
}
脱硝{
可取消？.cancel（）
}
专用func缓存（image:UIImage？）{
image.map{cache？[url]=$0}
}
func load（）{
如果让image=cache？[url]{
self.image=image
返回
}
Cancelable=URLSession.shared.dataTaskPublisher（for:url）
.map{UIImage（数据：$0.data）}
.replaceError（带：nil）
.handleEvents（receiveOutput:{[weak self]在self？.cache（$0）中）
.receive（在：DispatchQueue.main上）
.assign（到：\.image，在：self上）
}
func cancel（）{
可取消？.cancel（）
}
}
结构异步映像：视图{
@ObservedObject私有变量加载程序：ImageLoader
私人出租宽度：CGFloat？
私人出租高度：CGFloat？
@状态变量spin=false
init（url:url，cache:ImageCache？=nil，宽度：CGFloat？=nil，高度：CGFloat？=nil）{
loader=ImageLoader（url:url，缓存：缓存）
self.width=宽度
自我高度=高度
}
var body：一些观点{
形象
.onAppear（执行：loader.load）
.onDisappear（执行：loader.cancel）
}
私有var映像：一些视图{
团体{
如果loader.image！=nil{
图像（uiImage:loader.Image！）
.可调整大小（）
.aspectRatio（内容模式：.fit）
.框架（宽度：宽度，高度：高度）
}否则{
图像（“加载循环”）
.可调整大小（）
.框架（宽度：20，高度：20）
.旋转效果（.度（旋转360:0））
.animation（animation.linear（持续时间：0.8）。repeatForever（自动反转：false））
.onAppear（）{
self.spin.toggle（）
}
}
}
}
}
协议映像缓存{
下标（url:url）->UIImage？{get set}
}
结构临时ImageCache:ImageCache{
private let cache=NSCache（）
下标（ukey:URL）->UIImage{
获取{cache.object（forKey:key作为NSURL）}
set{newValue==nil？cache.removeObject（forKey:key作为NSURL）：cache.setObject（newValue！，forKey:key作为NSURL）}
}
}
结构ImageCacheKey:EnvironmentKey{
静态let defaultValue:ImageCache=TemporaryImageCache（）
}
扩展环境值{
var-imageCache:imageCache{
获取{self[ImageCacheKey.self]}
设置{self[ImageCacheKey.self]=newValue}
}
}

---

我确实尝试在图像上添加willSet，但似乎不起作用。你能帮我吗？

下面所有内容都是用Xcode 11.4/iOS 13.4测试的

修改后的图像

AsyncImage

我将

Group

更改为

VStack

，它开始更新

    private var image: some View {
        VStack {                        // << here !!
            if loader.image != nil {

---

cache（）函数没有被触发，我在那里添加了一个断点。很抱歉，我没有正确检查它，它不工作：（我确实得到了很多HTTP加载失败，0/0字节（错误代码：-999[1:89]）我当时使用的是iOS 13.2，现在正在更新，也许是这个helps@Async-，只是想问一下您的URL是否有效，因为我测试了google image中的found，它确实存在。感觉像是一个非主线程更新。如果您在ContentView中调用loadMore而没有DispatchAsync，会发生什么情况。loadMore不必做任何事情，因为它如果只加载其他单元格，则问题在于ImageLoader.load（）

class ImageLoader: ObservableObject {

    @Published var image: UIImage?

    private var cancellable: AnyCancellable?
    private let url: URL
    private var cache: ImageCache?

    init(url: URL, cache: ImageCache? = nil) {
        self.url = url
        self.cache = cache
    }

    deinit {
        cancellable?.cancel()
    }

    private func cache(_ image: UIImage?) {
        self.image = image
        image.map { cache?[url] = $0 }
    }

    func load() {
        if let image = cache?[url] {
            self.image = image
            return
        }

        cancellable = URLSession.shared.dataTaskPublisher(for: url)
            .map { UIImage(data: $0.data) }
            .receive(on: DispatchQueue.main)
            .replaceError(with: nil)
            .sink(receiveValue: { [weak self] in self?.cache($0) })
    }

    func cancel() {
        cancellable?.cancel()
    }
}