How to Dynamically Access Property Types in C# Using Custom Classes Without Direct Reflection

Discover an efficient method for dynamically accessing property values in C# classes, utilizing custom classes for various types without resorting to reflection.
---

Visit these links for original content and any more details, such as alternate solutions, comments, revision history etc. For example, the original title of the Question was: C# get property value type T from a class by name, do I need reflection?

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Accessing Property Values Dynamically in C#

In C#, it can become challenging to access properties of specific types dynamically, especially when dealing with custom types. Specifically, if you have a class with properties defined as generic types and you need to retrieve these values without using reflection, it requires a thoughtful approach.

The Problem

Imagine you have a class with multiple properties defined using your custom generic type, myOwnType<T>. Your objective is to create a method to retrieve these properties based on their names while maintaining their specific types.

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

You want to access these properties dynamically, similar to how you might with an array or a dictionary, but you want the values to maintain their specific types.

The Solution

While reflection is a common approach to dynamically access property values, there is a more structured way to achieve this by leveraging indexed properties. Here's a breakdown of how you can implement this without utilizing reflection.

Step 1: Create the Class with Indexed Properties

You need to create the main class that will hold the properties with their respective types. In this example, the class is called TestClass.

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

Step 2: Define the Custom Generic Class

Next, you will create the generic class myOwnType<T>. This class should implement a base interface to allow for typed operations while using a nullable reference for simplicity.

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

Step 3: Accessing Properties

Now that you have set up your classes, you can create an instance of TestClass and access properties using their names.

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

Conclusion

By using indexed properties and a well-defined custom class system, you can access different property types without needing to rely on reflection. This method keeps the typing intact and ensures you can utilize the specific functionality of each property type.

Key Takeaway

To dynamically access property values by name in C# while preserving their types, leverage indexed properties and custom generic classes. This minimizes performance overhead, is cleaner, and avoids the complexities that come with using reflection.

Make sure to explore and refine your classes based on your specific requirements, and have fun coding!