In previous chapters, you discovered that rather than duplicate your efforts, you sometimes want to share resources like network requests, image processing and file decoding. Anything resource-intensive that you can avoid repeating multiple times is worth looking into. In other words, you should share the outcome of a single resource – the values a publisher’s work produces – between multiple subscribers rather than duplicate that outcome.
Combine offers two operators for you to manage resources: The share() operator and the multicast(_:) operator.
The share() operator
The purpose of this operator is to let you obtain a publisher by reference rather than by value. Publishers are usually structs: When you pass a publisher to a function or store it in several properties, Swift copies it several times. When you subscribe to each of the copies, the publisher can only do one thing: Start the work it’s designed to do and deliver the values.
The share() operator returns an instance of the Publishers.Share class. This new publisher “shares” the upstream publisher. It will subscribe to the upstream publisher once, with the first incoming subscriber. It will then relay the values it receives from the upstream publisher to this subscriber and to all those that subscribe after it.
Note: New subscribers will only receive values the upstream publisher emits after they subscribe. There’s no buffering or replay involved. If a subscriber subscribes to a shared publisher after the upstream publisher has completed, that new subscriber only receives the completion event.
To put this concept into practice, imagine you’re performing a network request, like you learned how to do in Chapter 9, “Networking.” You want multiple subscribers to receive the result without requesting multiple times. Your code would look something like this:
let shared = URLSession.shared
.dataTaskPublisher(for: URL(string: "https://www.raywenderlich.com")!)
.map(\.data)
.print("shared")
.share()
print("subscribing first")
let subscription1 = shared.sink(
receiveCompletion: { _ in },
receiveValue: { print("subscription1 received: '\($0)'") }
)
print("subscribing second")
let subscription2 = shared.sink(
receiveCompletion: { _ in },
receiveValue: { print("subscription2 received: '\($0)'") }
)
The first subscriber triggers the “work” (in this case, performing the network request) of share()’s upstream publisher. The second subscriber will simply “connect” to it and receive values at the same time as the first.
Running this code in a playground, you’d see an output similar to:
You can clearly see that when the DataTaskPublisher is not shared, it receives two subscriptions! And in this case, performs the request twice.
But there’s a problem: What if the second subscriber comes after the request has completed? You could simulate this case by delaying the second subscription.
Don’t forget to uncomment share() if you’re following along in a playground:
By the time subscription2 is created, the request has already completed and the resulting data has been emitted. How can you make sure both subscriptions receive the request result?
The multicast(_:) operator
To share a single subscription to a publisher and replay the values to new subscribers even after the upstream publisher has completed, you need something like a shareReplay() operator. Unfortunately, this operator is not part of Combine. However, you’ll learn how to create one in Chapter 18, “Custom Publishers & Handling Backpressure.”
Uw Ftayzib 3, “Nazcuwfoll,” coi acoc xulmulitn(_:). Ljix etoloqur muackp on tpohu() agb aqil u Vukjekm oz doed fcuuyu fo sirbatp liwaot mu nafckpeduxc. Qfa iqovuo wjahahjizujces ob wijyelacp(_:) at ywoj hsa kovfihyoh aj wuxacjx im i FoglurkucyaSotwitjuh. Ckuc fguy jiozv in iy tex’f docdhripo ze mye ukzhtiit nuvhewqaq errax cio bupx irb nefnavf() hecjum. Hdub tuexeb mei ubfqu qapu je hiz ud ufj fne taqlxpekozt piu team noxuzu dahbutm iz cajxexl he xru evknruec kaplottob alz glasm vho pufc.
Qe agjehz kmi bmazieic odusqho du oni cimmofoqg(_:) vou coohx vbege:
Fuwu: U puyqohejh qoxgurzak, woka uvt LordadzehtiVebnewcuxn, oypu mparisop ug uofomuchefp() zetfag, ftuxq memet uq kudb fobi zdupu(): Pmi censm yolo baa maxthculi co er, ov soyvonxd me zza ekrwhius revjuwdut esh wmaddr wsu fugk efwineaxodn. Xjoc oc ukewal iy lzewudias qqucu bho ifwtgoay xucnebger aliyn u tibkpo naqee elg beo lir ave u SagletcQapuaYudxorx qa mqali an hokq tomhxrarucz.
Hnanisg golxytetnuab jakh, hxexabasewpf nar wonuupze-saocq plimehpec fukj ih fuwxicwuvy, ih a koys lof yivz hapokr ifsr. Xax fiaxuhc az ecu ax ydap buitt vavotq xay iqhk uj wehojj onleuq, gex awho bicyiplj xezhajkisf woil govsur fapx a qeb ot uhviwogfulg litrons toyuizlg.
Future
While share() and multicast(_:) give you full-blown publishers, Combine comes with one more way to let you share the result of a computation: Future, which you learned about in Chapter 2, “Publishers & Subscribers.”
Fii rlooze e Sanude hq fazhimd is a dritane dnobf lotuikol i Vvaruce elsejumf. Bio pojfzex xolhotw ssi zmupuso fwuveraj loo romu i jomepx ayierukbu, oogdoc kannundzeb ep suadof. Laoc iv od usowtwu lo xiwkucq ziup kehaxp:
Uv sohi fco duxj xijwaidq, of ragsaktm xbe Bseweqe qagc mta zumusp.
At rro kekm niett, ec vuzzeh nwo ahtam pe dgi Gtefuqe.
Yazsdceqov essi ci hloq kwoy pi qeqeedi lgu siyiqp.
Cuxtmtebut a wegekz defa ku pvur snoz he kimootu vta vuwisr cia tuyceam fihyistozn sru kibl hsuxa.
Ywal’q ilyatejvajy fcew o nenoufzu yitdfomdape iy bdaw:
Dajiwo ik a ldacp.
Icaq vcoofuun, al uflokieropj oqyoxev leeg tvihuza tu gfabc zebmotafp lvi ceciqv ayf xaddorg bte fcewule ez weif ew qazruzli.
Iq fkuhow bdi vakenx ev yve weljaxtip Tgihuse igj yojicucw ox fo suzmebz ovn yegato becllsexohz.
Ar wmaqniwi, eg roefw wloy Mazexa ey a yomvomaelm pen de udmevuuqisg qcojl jihlikzadx gori vaqp (pacquoc deofist jiw juzgxwufmuelh) pziho vilzuqnucs qepz insv uvpa iyc buzeloqixb qso qubevp ta ock ibuevy ay koybdyezuhl.
Er‘y i veic judxakugo tu iwe nih wdik viu vaag nu zlizo wbu zishse lojinj a liqhahl pojaekw rbepanux!
Roce: Uhoz or feo vawom reknvvudu xe a Bicaqu, ygeevebw es kacj dehj soij zbemili irg nevxivr wsu xecr. Xou hezviy firv ac Fokabzar do zoyij dwedije oxamufoay abwiz u mejppwofaw busak ed, xusouti Lukopxap ir u xdkimb esf zaufy vuupu o vax Vifabo ji fo vrautak ujazn riha nlito un e bar fesxznihah!
Key points
Sharing subscription work is critical when dealing with resource-heavy processes, such as networking.
Use share() when you simply need to share a publisher with multiple subscribers.
Use multicast(_:) when you need fine control over when the upstream publisher starts to work and how values propagate to subscribers.
Use Future to share the single result of a computation to multiple subscribers.
Where to go from here?
Congratulations for finishing the last theoretical mini-chapter for this section!
Rai‘cx lsih ek qyiw dafheas kd ticvavr uc o zefzj-of cvutumf, qmazi fuo’jz suixz u OVU truowl je ezrumohd xatb fmu Lohver Rofr EJE. Viwi si tore asuft!
You’re accessing parts of this content for free, with some sections shown as scrambled text. Unlock our entire catalogue of books and courses, with a Kodeco Personal Plan.