Скачать или смотреть Understanding Inter-Project Communication in .NET: No Protocols Needed!

Explore how .NET handles communication between class libraries and web applications, clarifying protocols like TCP/IP versus in-process operations.
---
This video is based on the question https://stackoverflow.com/q/67223975/ asked by the user 'Yogi' ( https://stackoverflow.com/u/4984854/ ) and on the answer https://stackoverflow.com/a/67236977/ provided by the user 'T.S.' ( https://stackoverflow.com/u/1704458/ ) 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: Inter project (class library) communication in .Net

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 Inter-Project Communication in .NET: No Protocols Needed!

In the world of software development, particularly when using Microsoft’s .NET framework, developers often encounter various types of communications between different project components. A common dilemma arises when trying to understand how a web application communicates with a class library. Specifically, many ask: What protocol does .NET use for inter-project communication, and which port does it utilize?

The Problem Explained

Let's say you have a basic web application developed with the Visual Studio MVC template, and alongside it, you have a class library project that is referenced by the web application. When the web application calls a method in the class library, it’s essential to understand how this communication works under the hood. Are protocols like TCP/IP or Named Pipes at play, or is it something else altogether?

This question is significant because the understanding of how these interactions occur can influence the design and performance of your application.

The Solution: How .NET Handles This Communication

In-Process Operations

When you reference a class library within a .NET application, you are dealing with in-process communication. Here’s how it works:

Compilation & Public API

Your class library (let’s call it Library A) is compiled, and it exposes a public API consisting of public methods and properties.

Your MVC project, which is also a type of library, gets compiled against Library A. During this compilation, the signatures of all methods being called are resolved.

AppDomain and Runtime

At runtime, both the web application and the class library are loaded into the same AppDomain.

This means they reside within a single process. All method signatures have already been resolved as part of the compilation process. This process of resolving method signatures during compilation is known as Early Binding.

Early Binding vs. Late Binding

Early Binding: As described, this involves resolving method signatures at compile time, allowing for faster execution and compile-time type checks.

Late Binding: This occurs when method invocation is not resolved until the program is running. For example:

[[See Video to Reveal this Text or Code Snippet]]

In this scenario, SomeMethod will be sought and resolved at runtime, enabling greater flexibility but sacrificing some performance benefits inherent in early binding.

No Protocols Needed

Since both the web application and the class library are operating within the same process, no external communication protocols like TCP/IP or Named Pipes are used. Thus, there aren’t any ports involved in this communication. Because of this, in-process communication in .NET is efficient and straightforward, as it does not require the additional overhead of inter-process communication protocols.

When Protocols Come into Play

However, if you move beyond in-process operations and need to communicate across multiple processes, the scenario changes:

You would then consider using:

A database for data persistence.

File mechanisms for sharing data.

Specific communication protocols such as TCP/IP, REST APIs, or others.

Memory Mapped Files for high-performance inter-process communication.

Conclusion

Understanding inter-project (class library) communication in .NET simplifies the development process and improves performance. By recognizing that references between libraries are managed within the same process, you can design your applications effectively without worrying about protocols like TCP/IP or Named Pipes for most use cases. This knowledge allows developers to focus on more critical aspects of application functionality and user experience.

For detailed communica