下面是一个工作版本：

class LinkViewModel : ObservableObject {
    let metadataProvider = LPMetadataProvider()
    
    @Published var metadata: LPLinkMetadata?
    @Published var image: UIImage?
    
    init(link : String) {
        guard let url = URL(string: link) else {
            return
        }
        metadataProvider.startFetchingMetadata(for: url) { (metadata, error) in
            guard error == nil else {
                assertionFailure("Error")
                return
            }
            DispatchQueue.main.async {
                self.metadata = metadata
            }
            guard let imageProvider = metadata?.imageProvider else { return }
            imageProvider.loadObject(ofClass: UIImage.self) { (image, error) in
                guard error == nil else {
                    // handle error
                    return
                }
                if let image = image as? UIImage {
                    // do something with image
                    DispatchQueue.main.async {
                        self.image = image
                    }
                } else {
                    print("no image available")
                }
            }
        }
    }
}

struct MetadataView : View {
    @StateObject var vm : LinkViewModel
    
    var body: some View {
        VStack {
            if let metadata = vm.metadata {
                Text(metadata.title ?? "")
            }
            if let uiImage = vm.image {
                Image(uiImage: uiImage)
                    .resizable()
                    .frame(width: 100, height: 100)
            }
        }
    }
}

struct ContentView: View {
    var links = [ "https://www.google.com", "https://www.hotmail.com"]
    let metadataProvider = LPMetadataProvider()
    
    var body: some View {
        List(links, id:\.self) { item in
            HStack {
                Text(item)
                Image(systemName: "heart.fill")
                MetadataView(vm: LinkViewModel(link: item))
            }
        }
    }
}

如果您尝试将LPMetadataProvider用于多个调用，它会发出抱怨，因此我将它移到了视图模型中。
该图像由NSImageProvider出售--您可以看到loadObject调用是从中获取UIImage的。
请注意，如果您想使用Apple提供的开箱即用的演示文稿，则可以使用LPLinkView。因为它是一个UIView，要在SwiftUI中使用它，你必须用UIViewRepresentable Package 它：

struct LPLinkViewRepresented: UIViewRepresentable {
    var metadata: LPLinkMetadata
    
    func makeUIView(context: Context) -> LPLinkView {
        return LPLinkView(metadata: metadata)
    }
    
    func updateUIView(_ uiView: LPLinkView, context: Context) {
        
    }
}

struct MetadataView : View {
    @StateObject var vm : LinkViewModel
    
    var body: some View {
        if let metadata = vm.metadata {
            LPLinkViewRepresented(metadata: metadata)
        } else {
            EmptyView()
        }
    }
}

class LinkViewModel : ObservableObject {
    let metadataProvider = LPMetadataProvider()
    
    @Published var metadata: LPLinkMetadata?
    
    init(link : String) {
        guard let url = URL(string: link) else {
            return
        }
        metadataProvider.startFetchingMetadata(for: url) { (metadata, error) in
            guard error == nil else {
                assertionFailure("Error")
                return
            }
            DispatchQueue.main.async {
                self.metadata = metadata
            }
        }
    }
}

接受的答案做的工作。这是一个改进的版本，具有缓存和Swift并发性。

import LinkPresentation
import SwiftUI

struct URLPreview<Content: View>: View {
  let url: URL
  let fallback: () -> Content

  @State var metadata: LPLinkMetadata? = nil

  var body: some View {
    if let metadata = metadata {
      LinkPresentationView(metadata: metadata)
    } else {
      fallback()
        .onAppear(perform: updateMetadata)
    }
  }

  func updateMetadata() {
    Task {
      metadata = await URLPreviewCache.metadata(for: url)
    }
  }
}

private enum URLPreviewCache {
  private static var cache: Cache<URL, LPLinkMetadata> = .init(totalCountLimit: 500)

  static func metadata(for url: URL) async -> LPLinkMetadata? {
    if let metadata = cache[url] {
      return metadata
    } else {
      return await fetch(for: url)
    }
  }

  static func preHeat(_ urls: [URL]) {
    for url in urls {
      Task {
        await fetch(for: url)
      }
    }
  }

  private static func fetch(for url: URL) async -> LPLinkMetadata? {
    do {
      let provider = LPMetadataProvider()
      let metadata = try await provider.startFetchingMetadata(for: url)
      cache[url] = metadata
      return metadata
    } catch {
      log(error)
      return nil
    }
  }
}

private struct LinkPresentationView: NSViewRepresentable {
  let metadata: LPLinkMetadata

  func makeNSView(context: Context) -> LPLinkView {
    LPLinkView(metadata: metadata)
  }

  func updateNSView(_ nsView: LPLinkView, context: Context) {}
}

如果您的目标不是macOS，请将NS替换为UI。