Iterate through Nested Classes and Transform Property, Multiple Int by 2

Question

The goal of this code is to iterate through multiple nested classes, and multiple any integer by 2. Provided simple example, however, example will be more complicated in future.

How do I change a Object to its underlying class? When I iterate through this function, it reads the type for OuterProduct correctly, but fails for InnerProduct reading as type System.RuntimeType, giving an error below

How can I resolve this code to multiply all nested integers by 2?

An unhandled exception of type 'System.StackOverflowException' occurred in Unknown Module.

class Program
{
    static void Main(string[] args)
    {
        var test = new OuterProduct();
        test.AmountSold = 5;
        test.ProductName = "BookOuter";

        test.InnerProduct = new InnerProduct();
        test.InnerProduct.ProductNameInner = "BookInner";
        test.InnerProduct.AmountSoldInner = 7;

        ReadPropertiesTest.ReadPropertiesRecursive(test);
    }
}

public class OuterProduct
{
    public string ProductName { get; set; }
    public int AmountSold { get; set; }
    public InnerProduct InnerProduct { get; set; }
}

public class InnerProduct
{
    public string ProductNameInner { get; set; }
    public int AmountSoldInner { get; set; }
}

public static class ReadPropertiesTest
{
    public static void ReadPropertiesRecursive(object test)
    {
        var type = test.GetType();

        foreach (PropertyInfo property in type.GetProperties())
        {
            if (property.PropertyType == typeof(int) || property.PropertyType == typeof(int?))
            {
                property.SetValue(test, (int)(property.GetValue(test)) * 2);
            }
            if (property.PropertyType.IsClass && !(property.PropertyType == typeof(string)))
            {
                ReadPropertiesRecursive(property.PropertyType);
            }
        }
    }
}

Resources:

C#: How to get all public (both get and set) string properties of a type

How to iterate through nested properties of an object

If your int? Property is null, the cast to int will throw an exception. You should handle this case seperately. Also you will want a general null check against `test` in case your nested objects do not have values (assuming you make the change in the answer below) — pinkfloydx33, Jun 11 '20 at 20:46
hi @pinkfloydx33 thanks for the input, feel free to write in answer, and I can send points,! — , Jun 11 '20 at 20:47

pinkfloydx33 · Accepted Answer · 2020-06-11T21:15:41.030

System.RuntimeType is the implementation of the class that represents typeof(X) or something.GetType(). When you pass PropertyType to your function you are not passing the property value, but it's type.

You will need to pass the next object in the hierarchy into the recursive function by using GetValue.

Note though that this is dangerous and error prone. For example, if you have a List<> property you obviously cannot increase its Count (it is readonly!). You should check to make sure that the property can be written to using the CanWrite property.

You also need to check for null objects. On top of that we need to handle int differently from int? (otherwise casting null to int will throw). The latter we can clean up a bit with c#7 pattern matching:

public static void ReadPropertiesRecursive(object test)
{
    if (test is null) // base case 
       return;

    var type = test.GetType();

    foreach (PropertyInfo property in type.GetProperties())
    {
        // check if we can even read the property
        if(!property.CanRead)
           continue;

        // use pattern matching on the value 
        // nulls will be ignored
        // we *could* cache GetValue but then it means we will invoke it for uninteresting types/properties 
        // it's also why I don't call GetValue until we've inspected PropertyType 
        if (property.CanWrite && 
           (property.PropertyType == typeof(int) || property.PropertyType == typeof(int?)) && 
            property.GetValue(test) is int i)
        {
            property.SetValue(test, i * 2);
        }
        else if (property.PropertyType.IsClass && property.PropertyType != typeof(string))
        {
            ReadPropertiesRecursive(property.GetValue(test));
        }
    }
}

An alternative version that omits some of the checks against PropertyType can also be used. It's a bit cleaner looking but it could potentially perform the GetValue reflection in cases where we don't need/want it (like on a double or a struct):

public static void ReadPropertiesRecursive(object test)
{
    if (test is null) // base case 
       return;

    var type = test.GetType();

    foreach (PropertyInfo property in type.GetProperties())
    {
        // check if we can even read the property
        if(!property.CanRead)
           continue;
        // possibly unnecessary if not int or class
        var val = property.GetValue(test);
        if (property.CanWrite && val is int i)
        {
            property.SetValue(test, i * 2);
        }
        else if (property.PropertyType.IsClass && property.PropertyType != typeof(string))
        {
            ReadPropertiesRecursive(val);
        }
    }
}

Note that you may want to have a whitelist or blacklist of types. Recursing into a Type object for example isn't going to get you much.

you can also replace `property.PropertyType.IsClass && property.PropertyType != typeof(string)` by `property.PropertyType.IsNested` — Mohammed Sajid, Jun 11 '20 at 21:05
He doesn't have nested types though. OP used incorrect wording to describe a simple property hierarchy — pinkfloydx33, Jun 11 '20 at 21:09
the `InnerProduct` is a nested type. if not nested why the OP call `ReadPropertiesRecursive` recursively? — Mohammed Sajid, Jun 11 '20 at 21:15
Not in the OP it's not. It's at the same namespace level nesting as `OuterProduct` — pinkfloydx33, Jun 11 '20 at 21:16
He's trying to recurse into nested *objects* /an object graph not into nested *types* — pinkfloydx33, Jun 11 '20 at 21:23
check this `property.PropertyType.IsNested` in debug mode, equal true if the property is `InnerProduct` that's all — Mohammed Sajid, Jun 11 '20 at 21:26
Sorry friend, but you are [wrong](https://dotnetfiddle.net/YZEGTW) — pinkfloydx33, Jun 11 '20 at 21:33
the same code gives me true, in VS 2019, but in dotnetfiddle false :) — Mohammed Sajid, Jun 11 '20 at 21:41
sorry freind i have declared classes insides program class. +1 — Mohammed Sajid, Jun 11 '20 at 21:53
[This](https://dotnetfiddle.net/cNBUVp) should help explain it better. I don't know how you could possibly be getting `true` in Visual Studio. A type is only nested if it's defined *inside* an other type. In the OP's example, none of the types are actually nested. Look at the link I pasted in this comment which shows an actual nested type — pinkfloydx33, Jun 11 '20 at 22:00

score 1 · Answer 2 · answered Jun 11 '20 at 22:04

Alternative would be to go with more object-oriented approach. Make it responsibility of every class which need to be "updated".

For every type with properties which need to be updated introduce a method to do it.

public class OuterProduct
{
    public string ProductName { get; set; }
    public int AmountSold { get; set; }
    public InnerProduct InnerProduct { get; set; }

    public void Update()
    {
        AmountSold *= 2;
        InnerProduct.Update();
    }
}

public class InnerProduct
{
    public string ProductNameInner { get; set; }
    public int AmountSoldInner { get; set; }

    public void Update()
    {
        AmountSoldInner *= 2;
    }
}    

// Usage is simple
var test = new OuterProduct
{
    AmountSold = 5,
    ProductName = "BookOuter",
    InnerProduct = new InnerProduct
    {
        ProductNameInner = "BookInner",
        AmountSoldInner = 7
    }
};

test.Update();
// test.AmountSold == 10 is true
// test.InnerProduct.AmountSoldInner == 14 is true

This approach will simplify code maintenance. For example adding/removing properties or worse case scenario adding some other logic to Update method will be isolated in one class.

score 0 · Answer 3 · answered Jun 11 '20 at 20:42

0

In your recursive call you are passing the type, not the actual property value:

if (property.PropertyType.IsClass && !(property.PropertyType == typeof(string)))
{
    ReadPropertiesRecursive(property.PropertyType);
}

should be:

if (property.PropertyType.IsClass && !(property.PropertyType == typeof(string)))
{
    ReadPropertiesRecursive(property.GetValue(test));
}

answered Jun 11 '20 at 20:42

Xerillio

4,855
1
17
28

1

Yes, this. However you will likely want to add tests for null to ensure the nested objects have values. – pinkfloydx33 Jun 11 '20 at 20:44

Iterate through Nested Classes and Transform Property, Multiple Int by 2

3 Answers3