Why Can't .NET Object Property Values Be Set Via Dictionary Keys and Object References?

Question

I've created a data class that I plan to use to send data to be persisted in the database and to return data from the database in a strongly typed way. In addition to its properties, the class contains a Dictionary that I populate in the constructor with the name of and reference to each property. This makes the properties enumerable and enables me to iterate through them using 'foreach'.

This works great when setting property values and sending the object to be persisted in the database. I can iterate through the Dictionary keys, get the value of each property, and add a SqlParameter for each property using the key as the parameter name and the property value as the parameter value.

However, going the other way doesn't work. I can iterate through the Dictionary keys and get the value of each column in each row of the SqlDataReader, but when I try to assign these values to my data object using the Dictionary's reference to the corresponding object property, a curious thing occurs. The assignments succeed, BUT the data object properties all retain their initial, default values. I can view the data object properties and see these initial, default values. I can also view the Dictionary entry values and see the updated values that were read and assigned from the SqlDataReader.

This makes no sense. The Dictionary is supposed to provide access to each property (the 'object' generic type) via its key (the 'string' generic type), but its acting like its maintaining a separate copy of each Dictionary 'KeyValuePair'.

What gives?

I'm doing all this in C# in the context of an ASP.NET Core 2.1.1 project running on macOS 10.13.6 High Sierra.

I've searched StackOverflow extensively, and I see lots of recommendations for using reflection to do this type of thing. I'll refactor my code to use reflection if necessary, but I'd really like to understand where and how my mental model for what's happening is off.

An explanation of what's happening and why would be MOST appreciated.

Example Data Class with Property Dictionary

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Runtime.Serialization;
using Newtonsoft.Json;

namespace MyOrg.MyProj.Data
{
    [DataContract]
    public class DataObj
    {
        #region Attributes

        [Required]
        [DataMember(Name = "dataObjectId")]
        public Int64 DataObjectId { get; set; }

        [Required]
        [DataMember(Name = "guid")]
        public Guid Guid { get; set; }

        public virtual Dictionary<string, object> DataMembers { get; set; }     //NOTE: Implements the IEnumerable interface in order to support 'foreach' operations, etc on 'DataObj' class attributes

        #endregion Attributes

        #region Constructors

        public DataObj(Int64 dataObjectId, Guid guid)
        {
            try
            {
                DataObjectId = dataObjectId;
                Guid = guid;

                DataMembers = new Dictionary<string, object>
                {
                    { "DataObjectId", DataObjectId },
                    { "Guid", Guid }
                };
            }
            catch (Exception e)
            {
                Console.WriteLine($"RUNTIME EXCEPTION while INSTANTIATEing DataObj, " + e.Message + ", " + e.StackTrace);
            }
        }

        #endregion Constructors

        #region Methods

        /// <summary>
        /// Implements the IEnumerable interface in order to support 'foreach' operations, etc on 'DataObj' class attributes
        /// </summary>
        /// <returns>Enumerator</returns>
        public Dictionary<string, object>.Enumerator Enumerator()
        {
            return DataMembers.GetEnumerator();     //NOTE: Return the Dictionary object's IEnumerator rather than implementing IEnumerable for the 'DataObj' class itself
        }

        #endregion Methods

Example Data Access Class (excerpt)

                reader = command.ExecuteReader();

                dataObjList = new List<DataObj>();

                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        tempDataObj = new DataObj(-1, new Guid("00000000-0000-0000-0000-000000000000"));

                        keys = new List<String>(tempDataObj.DataMembers.Keys);       //NOTE: Can't modify a Dictionary while iterating through it.  See the 'Why This Error?' section of https://stackoverflow.com/questions/604831/collection-was-modified-enumeration-operation-may-not-execute

                        foreach (String key in keys)
                        {
                            tempDataObj.DataMembers[key] = reader[key];
                        }

                        dataObjList.Add(tempDataObj);

For 'key' = 'DataObjectId', 'Guid', etc, I expect the value of tempDataObj.DataObjectId, tempDataObj.Guid, etc to be set to the value returned from the database in 'reader[key]'.

Instead, it retains its initial, default value as set in the constructor, i.e. '-1'. This is true for both value and reference data types.

However, when I inspect tempDataObj.DataMembers["DataObjectId"], it has been set to the value returned from the database in 'reader[key]'.

Inspecting the Object Property and Dictionary Values

tempDataObj.DataMembers["DataObjectId"] should be referencing the tempDataObj.DataObjectId property, etc, but the Dictionary appears to be maintaining its own value rather than providing an object reference to the 'DataObjectId' property.

What's going on here? Thank you!

Answer 1

I see two (main) routes to do what you want. In both cases you should implement a custom indexer.

1. In the indexer explicitly check the name given to it and get or set the field or property accordingly.

2. Use reflection, i.e. GetField() or GetProperty(), to get the field or property and GetValue() or SetValue() to get or set the values.

Below is a demonstration where ExposeByExplicitIndexer0 and its descendants use way 1 and ExposeByIndexerUsingReflection0 and its descendants use way 2.

public class ExposeByExplicitIndexer0
{
    public int Int0 = 1;
    public string String0 = "A";

    public virtual object this[string name]
    {
        get
        {
            switch (name)
            {
                case "Int0":
                    return this.Int0;
                case "String0":
                    return this.String0;
                default:
                    throw new IndexOutOfRangeException();
            }
        }
        set
        {
            switch (name)
            {
                case "Int0":
                    this.Int0 = (int)value;
                    break;
                case "String0":
                    this.String0 = (string)value;
                    break;
                default:
                    throw new IndexOutOfRangeException();
            }
        }
    }
}

public class ExposeByExplicitIndexer1 : ExposeByExplicitIndexer0
{
    protected Guid _Guid1 = Guid.Empty;
    public Guid Guid1
    {
        get
        {
            return this._Guid1;
        }
        set
        {
            this._Guid1 = value;
        }
    }

    public override object this[string name]
    {
        get
        {
            switch (name)
            {
                case "Guid1":
                    return this.Guid1;
                default:
                    return base[name];
            }
        }
        set
        {
            switch (name)
            {
                case "Guid1":
                    this.Guid1 = (Guid)value;
                    break;
                default:
                    base[name] = value;
                    break;
            }
        }
    }
}

public class ExposeByIndexerUsingReflection0
{
    public object this[string name]
    {
        get
        {
            FieldInfo fieldInfo;
            if ((fieldInfo = this.GetType().GetField(name)) != null)
            {
                return fieldInfo.GetValue(this);
            }
            PropertyInfo propertyInfo;
            if ((propertyInfo = this.GetType().GetProperty(name)) != null)
            {
                return propertyInfo.GetValue(this);
            }
            throw new IndexOutOfRangeException();
        }
        set
        {
            FieldInfo fieldInfo;
            if ((fieldInfo = this.GetType().GetField(name)) != null)
            {
                fieldInfo.SetValue(this, value);
                return;
            }
            PropertyInfo propertyInfo;
            if ((propertyInfo = this.GetType().GetProperty(name)) != null)
            {
                propertyInfo.SetValue(this, value);
                return;
            }
            throw new IndexOutOfRangeException();
        }
    }
}

public class ExposeByIndexerUsingReflection1 : ExposeByIndexerUsingReflection0
{
    public int Int1 = 1;
    public string String1 = "A";
}

public class ExposeByIndexerUsingReflection2 : ExposeByIndexerUsingReflection1
{
    protected Guid _Guid2 = Guid.Empty;
    public Guid Guid2
    {
        get
        {
            return this._Guid2;
        }
        set
        {
            this._Guid2 = value;
        }
    }
}

public class Program
{
    static void Main(string[] args)
    {
        Guid newGuid = Guid.NewGuid();

        Console.WriteLine("Expose by explicit indexer:");
        ExposeByExplicitIndexer1 exposeByExplicitIndexer1 = new ExposeByExplicitIndexer1();
        exposeByExplicitIndexer1["Int0"] = 10;
        exposeByExplicitIndexer1["String0"] = "AAA";
        exposeByExplicitIndexer1["Guid1"] = newGuid;
        Console.WriteLine("output via indexer:");
        Console.WriteLine(exposeByExplicitIndexer1["Int0"]);
        Console.WriteLine(exposeByExplicitIndexer1["String0"]);
        Console.WriteLine(exposeByExplicitIndexer1["Guid1"]);
        Console.WriteLine("output via fields or properties:");
        Console.WriteLine(exposeByExplicitIndexer1.Int0);
        Console.WriteLine(exposeByExplicitIndexer1.String0);
        Console.WriteLine(exposeByExplicitIndexer1.Guid1);

        Console.WriteLine("Expose by indexer using reflection:");
        ExposeByIndexerUsingReflection2 exposeByIndexerUsingReflection2 = new ExposeByIndexerUsingReflection2();
        exposeByIndexerUsingReflection2["Int1"] = 10;
        exposeByIndexerUsingReflection2["String1"] = "AAA";
        exposeByIndexerUsingReflection2["Guid2"] = newGuid;
        Console.WriteLine("output via indexer:");
        Console.WriteLine(exposeByIndexerUsingReflection2["Int1"]);
        Console.WriteLine(exposeByIndexerUsingReflection2["String1"]);
        Console.WriteLine(exposeByIndexerUsingReflection2["Guid2"]);
        Console.WriteLine("output via fields or properties:");
        Console.WriteLine(exposeByIndexerUsingReflection2.Int1);
        Console.WriteLine(exposeByIndexerUsingReflection2.String1);
        Console.WriteLine(exposeByIndexerUsingReflection2.Guid2);

        Console.Read();
    }
}

In way 1 every descendant that adds new fields or properties has to extend the indexer. That's more work in general but also offers an easy way of flexibility i.e. for adding some casts or expose some field or property via an alias, etc.

Way 2 needs less effort in the descendants. But being as flexible as in way 1 may become more difficult in turn. Maybe some mixed solution is also possible overriding the indexer in some descendant to inject special logic.

Answer 2

You're storing the data twice - once in a Dictionary, and a second time in a field. There's no need to store it twice. Just do this:

[DataContract]
public class DataObj
{
    [Required]
    [DataMember(Name = "dataObjectId")]
    public Int64 DataObjectId
    {
        get => (long)DataMembers[nameof(DataObjectId)];
        set => DataMembers[nameof(DataObjectId)] = value;
    }

    [Required]
    [DataMember(Name = "guid")]
    public Guid Guid
    {
        get => (Guid)DataMembers[nameof(Guid)];
        set => DataMembers[nameof(Guid)] = value;
    }

    public Dictionary<string, object> DataMembers { get; } = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

    public DataObj(Int64 dataObjectId, Guid guid)
    {
        DataObjectId = dataObjectId;
        Guid = guid;
    }

    public Dictionary<string, object>.Enumerator Enumerator()
    {
        return DataMembers.GetEnumerator();
    }
}

FYI, you can also look at using an ExpandoObject, which lets you access something in a way that looks like a class, but is really just a Dictionary. https://learn.microsoft.com/en-us/dotnet/api/system.dynamic.expandoobject?view=netframework-4.7.2

_{I have never used an ExpandoObject and I think the whole idea is as perverse as VBA's default of option explicit being off and On Error Resume Next. On the other hand, I don't deal with databases much.}