Скачать или смотреть Understanding Late Binding in VB.NET: Why No Error Occurs with Option Strict ON

Discover the concept of `late binding` in VB.NET and why using Option Strict ON doesn't always produce errors as expected.
---
This video is based on the question https://stackoverflow.com/q/67765589/ asked by the user 'Sougata' ( https://stackoverflow.com/u/12508654/ ) and on the answer https://stackoverflow.com/a/67766728/ provided by the user 'jmcilhinney' ( https://stackoverflow.com/u/584183/ ) 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: Late Binding: Expecting error but not getting it

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 Late Binding in VB.NET

In the realm of programming, especially in object-oriented languages like VB.NET, understanding the concept of late binding is crucial. A peculiar situation often arises when developers expect errors due to the violation of rules set by Option Strict ON, particularly when the term "late binding" is mentioned. If you find yourself scratching your head, wondering why you aren't encountering any errors with late binding, you're not alone. In this guide, we will break down this concept clearly and provide insight into why your code behaves the way it does.

The Problem: Misunderstanding Late Binding and Option Strict

You might have written code like this, expecting an error when attempting to instantiate a derived object as a base type with Option Strict ON:

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

Here, you expect a compile-time error due to late binding. However, you ultimately do not see any such error, leaving you puzzled. Let's dive deeper into why this happens.

The Solution: Understanding the Mechanics

What is Late Binding?

Late Binding refers to the process where the decision to bind to a particular member (like properties or methods) is deferred until run time.

This is in contrast to Early Binding, where this decision is made at compile time.

Why No Error?

Polymorphism: There's nothing inappropriate about assigning an object of a derived type (in this case, Car) to a variable of a base type (Object). This behavior is exactly what allows polymorphism to function in OOP (Object-Oriented Programming).

Type Knowledge: When you declare Dim o As Object, the compiler only identifies the variable o as an Object. It doesn't know its specific underlying type until the program executes. Therefore, it does not check member validity at compile time.

Accessing Members: Early vs Late Binding

Early Binding Example:

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

Here, Make property access is resolved at compile time, thus it is early bound.

Late Binding Example:

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

In this snippet, o.Price is considered late binding because at the time of compile, the compiler cannot confirm that Price exists on the Object type. Only at run time does the actual type of o get evaluated to see if it has that member.

Conclusion: The Key Takeaway

In essence, as long as you don't attempt to access any members through your base type, the compiler remains unaware of the specific derived members present. Therefore, it does not detect any late binding errors during compilation. Remember, for late binding to occur, an attempt to access a member that is not defined in the object's declared type is necessary.

Understanding late binding and its intricacies can help you better navigate the complexities of VB.NET and improve your coding practices, ensuring that you utilize object-oriented principles effectively.

By clarifying these concepts, we hope this guide assists you in becoming more proficient in using Option Strict and comprehending the underlying operations of your code.