如何使我的网络 class 在 Swift 中通用？

Question

Here i am extracting data as DataModel . But i want to make this class generic and pass the model myself so that i can use it to parse data from multiple API's. Can Anyone Help?

import Foundation

struct NetworkManager {
    func fetchData(url : String, completion : @escaping (DataModel?) -> ()) {
        print("Neeraj here")
        let sessionURL = URL(string: url)
        let session = URLSession(configuration: .default)
        let dataTask = session.dataTask(with: sessionURL!) { (data, response, error) in
            if error == nil {
                if let safeData = data {
                    if let parsedData = self.parseData(data : safeData) {
                        print("got data")
                        completion(parsedData)
                    }
                    else {
                        debugPrint("failed to fetch data")
                        completion(nil)
                    }
                }
            }
            else {
                print("error in data task is \(String(describing: error))")
                completion(nil)
            }
        }
        dataTask.resume()
        
    }
    
    func parseData(data : Data) -> DataModel? {
        let decoder = JSONDecoder()
        do {
            let decodedData = try decoder.decode(DataModel.self, from: data)
            return decodedData
        } catch {
            print("error while parsing data \(error)")
            return nil
        }
    }
}

Answer 1

With the convenient Result type you can write a quite tiny generic method, it returns the decoded type on success and any error on failure

func fetchData<T: Decodable>(urlString: String, completion: @escaping (Result<T,Error>) -> Void) {
    guard let url = URL(string: urlString) else { return } // or throw an error
    URLSession.shared.dataTask(with: url) { (data, _, error) in
        if let error = error { completion(.failure(error)); return }
        completion( Result{ try JSONDecoder().decode(T.self, from: data!) })
    }.resume()
}

Note: Force unwrapping data! is 100% safe if no error occurs

---

Be aware that you have to specify the concrete type when you are going to call the method

fetchData(urlString: "https://example.com/api") { (result : Result<MyModel,Error>) in
    switch result {
        case .success(let model): print(model)
        case .failure(let error): print(error)
    }
}

Answer 2

You can add a generic type constraint (called Model ) which conforms Decodable like below:

struct NetworkManager {

    func fetchData<Model: Decodable>(url : String, completion : @escaping (Model?) -> ()) {
        let sessionURL = URL(string: url)
        let session = URLSession(configuration: .default)
        let dataTask = session.dataTask(with: sessionURL!) { (data, response, error) in
            if error == nil {
                if let safeData = data {
                    do {
                        let decodedData = try JSONDecoder().decode(Model.self, from: safeData)
                        completion(decodedData)
                    } catch {
                        print("error while parsing data \(error)")
                    }
                } else {
                    debugPrint("failed to fetch data")
                    completion(nil)
                }
            }
            else {
                print("error in data task is \(String(describing: error))")
                completion(nil)
            }
        }
        dataTask.resume()
    }
}

Usage

struct SampleModel: Decodable {
    let name: String
}

NetworkManager().fetchData(url: "") { (data: SampleModel?) in
    print(data)
}

Answer 3

You can write a generic function to fetch data like this one:

    func fetchGenericData<T: Decodable>(urlString: String, completion: @escaping (T) -> ()) {
        let url = URL(string: urlString)
        URLSession.shared.dataTask(with: url!) { (data, resp, err) in
            if let err = err {
                print("Failed to fetch data:", err)
                return
            }
            
            guard let data = data else { return }
            
            do {
                let obj = try JSONDecoder().decode(T.self, from: data)
                completion(obj)
            } catch let jsonErr {
                print("Failed to decode json:", jsonErr)
            }
            }.resume()
    }
}

I suppose that you have a data model, if you have not, you should create for your every object. Also by using a dummy URL i will make a request and fetch the JSON includes some users name and ids with JSON format. Let`s define a data model for this:

struct StackUser: Decodable {
      let id: Int
      let name: String
  }

fetchGenericData(urlString: "https://api.stackoverexample.com/stackusers") { (stackUsers: [StackUser]) in
     stackUsers.forEach({print($0.name)})
}
        

Finally you will be parse the data and prints like this:

Rob
Matt
Vadian