Ensuring anonymous objects in C# all have certain common properties

Question

I have a problem regarding anonymous objects in C#. The situation is as follows:

I have a C# web app which does NOT use the traditional ASP.NET Razor engine, but instead uses the RazorEngine open source project (https://github.com/Antaris/RazorEngine). I'm not sure if this is relevant, but it could be.

I'm passing a model object to each page I'm displaying. Each model object is different, there are many pages and therefore many different model objects, but I would rather not have to declare separate classes for each model, which is why I've been using anonymous classes:

// In method which displays page A:
var model = new {
  Lang  = _lang,
  PropX = "foo",
  PropY = "bar"
};
RazorEngine.Run("templateA", model);

// In a different method which displays page B:
var model = new {
  Lang = _lang,
  PropZ = "smu"
};
RazorEngine.Run("templateB", model);

You may notice that botn (and in fact, all) those models have a common property (the "Lang" property), a few common properties actually (Lang is the only one displayed in the example above to simplify matters).

My main problem is that I'm trying to ensure that those properties are added to all the models in a way which guarantees that they are included to all pages, and if I later decide to add a new common property, then I can do that in a single place.

One way would of course be to drop the anonymous classes, and use typed classes which all inherit from a single base class, which would declare the common properties. But this would be a lot of boilerplate code, and if there is another solution then I would prefer that.

Another solution would be to either declare the common properties in a sub-property of the model object, or declare the individual page properties in a sub object:

// Either like this:
var model = new {
    Common = GetCommonModelProperties(),
    PropX  = "foo",
    PropY  = "bar"
};
public object GetCommonModelProperties()
{
  return new {
    Lang = _lang
  };
}
// etc.

// or like this:

var pageModel = new {
  PropX = "foo",
  PropY = "bar
};
var model = CreateModel(pageModel);
RazorEngine.Run("templateA", model);

// where CreateModel could be implemented like this:

public object CreateModel(object pageModel)
{
  return new 
  {
    Lang = _lang,
    // etc., whatever common properties there exist
    Data = pageModel
  };
}

The problem with this approach is that I would have to modify all my templates, either all instances where those pages refer to the common property (I would have to rename all Model.Lang instances to Model.Common.Lang), or to the individual page data (modify Model.AnyProperty to Model.Data.AnyProperty). Of course there is a great risk of errors when such a rewrite takes place.

So: is there a way to create an anonymous object, where a number of its properties are always the same, but the rest can be specified dynamically?

I've tried to create two separate objects, and then combine them into one, using code from this question: Merging anonymous types

var commonModel = new {
  Lang = _lang
};
var pageModel = new {
  PropX = "foo",
  PropY = "bar"
};
var model = Merge(commonModel, pageModel);

and yes, this works. Until I have to use the Lang object, which is of a class type (which I have full control over), and this class overloads operator[]. If I use this workaround, the overload stops working, and I get the error:

Cannot apply indexing with [] to an expression of type 'object'

N.b. the indexing works perfectly fine if I just include the Lang property in a regular anonymous object.

I've also tried to create a separate base class for all the models, declare all the common properties in that class, but also derive it from System.Dynamic.DynamicObject, and override the TryGetMember method which would dynamically look up the page properties from a dictionary (which would work, since those properties are usually simple objects, i.e. they don't override the indexing operator, so I can add those properties dynamically at runtime:

var pageModel = new {
  PropX = "foo",
  PropY = "bar"
};

var model = CreateMainModel(pageModel);

public object CreateMainModel(object pageModel)
{
   var mainModel = new BaseModel()
   mainModel.Lang = _lang;

    foreach (System.Reflection.PropertyInfo fi in pageModel.GetType().GetProperties())
    {
      mainModel.PageProperties[fi.Name] = fi.GetValue(pageModel, null);
    }

    return mainModel;
}

class BaseModel : DynamicObject
{
  public LanguageMap Lang { get; set; }
  public Dictionary<string, object> PageProperties { get; set; }
  
  public override bool TryGetMember(GetMemberBinder binder, out object result)
  {
    if (PageProperties.ContainsKey(binder.Name))
    {
      result = PageProperties[binder.Name];
      return true;
    }
    return false;
  }
}

The problem with this is that properties declared inside a class which derives from DynamicObject will NOT be visible inside the page templates, it seems that only properties returned from TryGetMember are. And if I make the members visible the explicity checking for their names inside TryGetMember, then the indexing stops working just like in the case above.

Now if this was C++, I could create a preprocessor macro:

#define COMMON_MODEL_PROPERTIES \
    Lang = _lang
    More = _otherProperty

// Where models are declared:

var model = new 
{
  COMMON_MODEL_PROPERTIES,
  PropX = "foo",
  PropY = "bar"
}

but this isn't C++... It's C#.

Any ideas?

I think your instinct to use composition is probably right, following question because I'm very curious what will be suggested — DCAggie, Dec 21 '21 at 21:05
Wow what a mess. Kinda looks like the sort of thing that would happen if a javascript dev decided to work with C#. I think my first course of action would be to hand in my notice and run — App Pack, Dec 21 '21 at 21:06
How about.. `record`s? Easy declare and instantiate, semantically quite similar to ATs (mutability, equatability), can participate in an inheritance hierarchy, find/replace could perhaps do a lot of the donkey work... — Caius Jard, Dec 21 '21 at 21:20
Bunch of boilerplate code or getting your foot blown off during runtime using some hacky reflection job, tough one — JohanP, Dec 21 '21 at 21:23

App Pack · Answer 1 · 2021-12-21T22:17:40.760

Ok, so as per my initial comment... just wow. I would highly recommend that you bite the bullet and refactor to use static typing. To anyone else reading this, please do not do this.

However if you really really really really really really really really want to achieve this with minimal changes, I think this will work for you.

Add an extension method to your codebase:

internal static class DynamicCommonPropertyExtensions
{
    public static object AddCommonProperties(this object obj)
    {
        dynamic expando = new ExpandoObject();
        foreach (var prop in obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public))
        {
            if (expando is IDictionary<string, object?> dict)
            {
                dict[prop.Name] = prop.GetValue(obj, null);
            }
        }
        //Add common properties here
        expando.CommonProp1 = "CommonPropValue1";
        expando.CommonProp2 = "CommonPropValue2";
        return expando;
    }
}

This can then be used as follows (with your example)

var model = new
{
    Lang = _lang,
    PropX = "foo",
    PropY = "bar"
};
var addedCommonProperties = model.AddCommonProperties();
RazorEngine.Run("templateA", addedCommonProperties);

Or even "better" without using another variable

var model = new
{
    Lang = "Test",
    PropX = "foo",
    PropY = "bar"
}.AddCommonProperties();
RazorEngine.Run("templateA", model);

If you need to access the properties before passing through you can declare it as dynamic

dynamic model = new
{
    Lang = "Test",
    PropX = "foo",
    PropY = "bar"
}.AddCommonProperties();

var a = model.CommonProp1;

I now feel really dirty having written this

That's clever in both the good and evil senses at the same time. Bravo. — Tech Inquisitor, Dec 21 '21 at 22:24

Ensuring anonymous objects in C# all have certain common properties

1 Answers1