Summary
The article provides an overview about approaches for interprocess communication.
When you need to realize the communication between applications, usually you consider the following approaches.
File Transfer
Applications communicate via files. Producing applications write data to files and consuming applications read files to get data.
The advantage is that applications are loosely coupled. They do not have to know about internal implementations of each other. They just need to know the file format and a location of files.
On the other hand, writing and reading files is not so fast. Therefore, files cannot be updated very frequently (e.g. many times per second) but usually they are updated in intervals, e.g. hourly. However, this causes delays and applications reading the file must often deal with the fact that data is not up to date -> synchronization issues.
Database Storage
Applications communicate via shared data in a database. Shared data is written into the database from where it can be read by other applications.
The advantage is that the database provides a unified access to all data (e.g. via SQL). So applications do not have to deal with different file formats. In addition, the transaction mechanism helps to keep data consistent.
The drawback is that applications using the database depend on the data schema. Therefore, the change in the data structure (data schema) can cause changes in applications using the database.
Also the performance can be problematic - especially, if multiple applications frequently read and update the same data or the database is distributed across different locations.
Remote Procedure Call
Applications communicate via exposed functionality. Application providing the functionality uses a middleware (e.g. WCF) to hide the interprocess communication. The intention is that remote calls look like local calls. The communication is usually synchronous.
The advantage of this approach is that the application provides a specified functionality and encapsulates (hides) data.
The disadvantage is that the communicating applications are coupled. Example: The calling application assumes that the other side implements the particular interface. If you add a new method to the interface, then all client applications are affected and must be updated and recompiled.
Read more: Codeproject