The Right Way to Manage Multiple Delegates in Swift View Controllers

Описание: Discover how to set up multiple delegates effectively in your Swift view controllers to ensure smooth data handling and persistence.
---
This video is based on the question https://stackoverflow.com/q/70377147/ asked by the user 'Kets' ( https://stackoverflow.com/u/2719688/ ) and on the answer https://stackoverflow.com/a/70380735/ provided by the user 'matt' ( https://stackoverflow.com/u/341994/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Setting multiple delegates for passing multiple view controllers right way?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Challenge of Multiple Delegates in Swift

When you're developing applications using Swift, you may come across a situation where you need to handle multiple delegates to pass data across various view controllers. This is especially common if you want to maintain a central object for data persistence—ensuring that any updates to your data remain intact, even when the user navigates between different parts of the app or closes it altogether.

In this post, we are going to delve into the best practices for implementing multiple delegates effectively within Swift view controllers, explore potential pitfalls, and discuss modern alternatives to the delegation pattern.

The Initial Setup

In your current scenario, you have three view controllers (VC1, VC2, and VC3), structured as follows:

VC1: This is your main object responsible for holding all necessary data.

It acts as a delegate for VC2.

VC2: This view controller provides an overview of specific objects from VC1.

It has a delegate for VC3.

The delegate function is triggered to pass data back to VC1 when edits are made.

VC3: This controller handles the editing of data from VC2.

It calls its delegate function to send edited data back to VC2.

This setup seems functional, but let's take a closer look at whether it's the best architecture for your needs.

Why Your Current Approach Works

Centralized Data Saving:

By designating VC1 as the sole source of truth for data storage, you've ensured that all changes are propagated back to one place. This guarantees data integrity and easier management.

Delegation Pattern:

Using the protocol-and-delegate pattern helps in communicating between your view controllers, allowing for a clear contract on how data should be passed back.

Areas for Improvement

While your architecture works, there are a few considerations to optimize your implementation:

1. Delegation: Is It the Best Choice?

Modern Alternatives:

In contemporary Swift applications, there are more streamlined approaches for handling data flow. One prevalent model is using a reactive programming paradigm where view controllers subscribe to a data store. This way, any updates to the data automatically inform all subscribers, reducing the need for protocols and delegate methods.

2. View Controller Responsibilities

Avoiding Tight Coupling:

View controllers should ideally not manage data storage or persistency directly. Instead, consider implementing a separate data store object, which can be orchestrated by your app delegate or another persistent object. This change will not only simplify your view controllers but make them more testable and maintainable.

Moving Forward: Enhanced Architecture

To evolve your approach, consider implementing the following:

Implement a Central Data Store

Create a dedicated data store object that handles all data-related operations. This could operate using a reactive framework like Combine or RxSwift to notify relevant view controllers of data changes.

Use Dependency Injection

Pass the instance of the data store to each view controller via dependency injection. This design pattern allows you to easily swap implementations and makes your code cleaner and more testable.

Embrace Reactive Programming

By letting your view controllers subscribe to changes in your data store, you can create a cleaner architecture where each component focuses on its core function without needing to know about others.

Conclusion

While your current use of multiple delegates effectively allows you to manage data between your view controllers, exploring alternatives can simplify your code and enhance your app's architecture. Transitioning to a more modern approach with a standalone data store and reac