Get a Property Value from a String Using Reflection in C#

By the end of this page, you will understand how to use reflection in C# to look up a property by name and read its value dynamically. You will also learn the difference between getting a property from an object instance versus from a type name string, how to handle nested property paths, and how to avoid common reflection mistakes.

Reflection in C# lets your program inspect types, properties, methods, and fields at runtime.

In this question, the core idea is: instead of writing code like this:

switch (propertyName)
{
    case "FirstName":
        return person.FirstName;
    case "Age":
        return person.Age;
}

you want to do something more dynamic:

return GetPropertyValue(person, "FirstName");

That is exactly the kind of problem reflection can solve.

Why this matters

Reflection is useful when:

• property names are only known at runtime
• you are building mapping or transformation tools
• you are writing generic utilities
• you want to reduce repetitive switch or if logic

The important distinction

There are two related but different problems:

1. Get a property value from an object using a property name string

   • Example: given a Person object and the string "FirstName", return

Think of an object as a cabinet, and its properties as labeled drawers.

Normally, in C#, you open a drawer directly:

person.FirstName

That means you already know the drawer name at compile time.

Reflection is like saying:

“I have the cabinet, and I have the drawer label as text. Please find that drawer and open it.”

If you only have the text "FirstName", reflection can search the cabinet for a drawer with that label.

If you only have "Person.FirstName", that tells you the kind of cabinet and the drawer name, but not which exact cabinet instance you should open. That is why instance properties still require an object.

Basic syntax

To get a property value by name from an object:

using System;
using System.Reflection;

public static object? GetPropertyValue(object source, string propertyName)
{
    if (source == null) throw new ArgumentNullException(nameof(source));
    if (string.IsNullOrWhiteSpace(propertyName)) throw new ArgumentException("Property name is required.", nameof(propertyName));

    PropertyInfo? property = source.GetType().GetProperty(propertyName);

    if (property == null)
        throw new ArgumentException($"Property '{propertyName}' was not found on type '{source.GetType().Name}'.");

    return property.GetValue(source);
}

Example

using System;

public class Person
{
    public string FirstName { get; set; } = ;
      Age { ; ; } = ;
}

  
{
      ? GetPropertyValue( source,  propertyName)
    {
         property = source.GetType().GetProperty(propertyName);
         property?.GetValue(source);
    }

    
    {
        Person person =  Person();

        Console.WriteLine(GetPropertyValue(person, ));
        Console.WriteLine(GetPropertyValue(person, ));
    }
}

Consider this code:

public class Person
{
    public string FirstName { get; set; } = "Alice";
}

Person person = new Person();
object? value = GetPropertyValue(person, "FirstName");
Console.WriteLine(value);

And this method:

public static object? GetPropertyValue(object source, string propertyName)
{
    PropertyInfo? property = source.GetType().GetProperty(propertyName);
    return property?.GetValue(source);
}

What happens step by step

1. person is created as an instance of Person.
2. GetPropertyValue(person, "FirstName") is called.
3. source.GetType() returns the runtime type: Person.
4. .GetProperty("FirstName") searches the Person type for a public property named .

Data transformation and mapping

If you are converting one object into another, reflection can read source properties based on configuration strings.

Example:

• source field: "Customer.Name"
• destination field: "ClientName"

CSV or Excel export tools

A report generator can accept a list of property names and extract values without hard-coded access.

Example:

var columns = new[] { "FirstName", "Age" };

Admin dashboards

Generic UI components often display selected object properties dynamically.

Rule engines and configuration-driven systems

A config file may specify which property to inspect:

• Order.Total
• User.Email
• Product.Price

Logging and auditing

Reflection can help collect certain values from objects for diagnostics or change tracking.

API response shaping

Some systems return only fields requested by the client. Reflection can be used to extract those properties, though this should be done carefully for performance and security.

In real projects, developers often use reflection in controlled utility methods, not scattered everywhere.

Common pattern: reusable helper

public static object? GetPropertyValue(object source, string propertyName)
{
    if (source == null) return null;

    var property = source.GetType().GetProperty(propertyName);
    return property?.GetValue(source);
}

This keeps reflection logic in one place.

Guard clauses

Developers usually validate inputs early:

• null object
• empty property name
• property not found
• wrong casing

Configuration-driven mapping

A common pattern is storing property paths in configuration:

var mappings = new Dictionary<string, string>
{
    ["CustomerName"] = "Customer.Name",
    ["CustomerCity"] = "Customer.Address.City"
};

Then a mapper reads each path dynamically.

Error handling

Reflection code often fails at runtime if the property name is wrong. Real code usually:

1. Forgetting that instance properties need an object

Broken idea:

Type type = Type.GetType("MyApp.Person");
var property = type.GetProperty("FirstName");
var value = property.GetValue(null);

This fails for a normal instance property because null is only valid for static properties.

Fix:

Person person = new Person { FirstName = "Alice" };
var value = person.GetType().GetProperty("FirstName")?.GetValue(person);

2. Assuming Type.GetType always finds your class

Broken code:

Type type = Type.GetType("Person");

This often returns null unless the fully qualified type name is available.

Fix:

• use the full namespace-qualified name
• or use someObject.GetType() when you already have an instance

3. Not checking for missing properties

Reflection vs hard-coded property access

Reflection vs switch statement

Quick reference

Get property from object by name

var property = source.GetType().GetProperty("FirstName");
var value = property?.GetValue(source);

Safe helper

public static object? GetPropertyValue(object source, string propertyName)
{
    if (source == null) throw new ArgumentNullException(nameof(source));

    var property = source.GetType().GetProperty(propertyName);
    if (property == null)
        throw new ArgumentException($"Property '{propertyName}' not found.");

    return property.GetValue(source);
}

Case-insensitive lookup

var property = source.GetType().GetProperty(
    propertyName,
    BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase);

Nested property path

"Address.City"

Can I get a property value from just a string in C#?

Yes, if the string is the property name and you also have the object instance. Reflection can then find and read that property.

Can I pass "ClassName.PropertyName" and get the value directly?

Only if you can also identify the object instance for that class, unless the property is static.

Why does Type.GetType() return null?

Usually because the type name is incomplete. You often need the fully qualified type name, including namespace.

Does reflection work with private properties?

Yes, but you need different binding flags. For most beginner use cases, public properties are simpler and safer.

Is reflection slow?

It is slower than direct property access, but often acceptable for occasional lookups. For heavy repeated use, consider caching.

How do I read nested properties like Address.City?

Split the string by . and resolve each property one step at a time.

What should I return if the property does not exist?

That depends on your design. Common options are returning null, throwing an exception, or logging an error.

Should I replace all switch statements with reflection?

No. Reflection is best when property names are dynamic. If the set of cases is fixed and small, a switch is often clearer.

• C# reflection — the main feature used to inspect types and properties at runtime.
• Properties in C# — reflection reads property metadata and values.
• Type and PropertyInfo — the key classes used for reflection-based property access.
• BindingFlags — useful when you need case-insensitive, static, instance, or non-public lookups.
• Null handling — important when nested properties may contain null.
• Exception handling — reflection often needs clear runtime error messages.
• Object mapping — a common real-world reason to read properties dynamically.
• Delegates and lambda expressions — a safer alternative when property access is known at compile time.