Creating data objects dynamically at runtime from an interface

Sometimes when I write objects for holding data (not real DTOs, no serialization involved) I also create an interface for it. The class that implements it can also perform some null checks. I don't always like to use the Validator because you need to remember to call it. Such implementations may look like this:

public interface IPerson
{
  [NotNull]
  string FirstName { get; set; }

  [NotNull]
  string LastName { get; set; }

  string NickName { get; set; }
}

public class Person : IPerson
{
  private string _firstName;
  private string _lastName;

  public string FirstName
  {
      get => _firstName ?? throw new InvalidOperationException($"{nameof(FirstName)} isn' set.");
      set => _firstName = value ?? throw new ArgumentNullException(nameof(FirstName));
  }
  public string LastName
  {
      get => _lastName ?? throw new InvalidOperationException($"{nameof(LastName)} isn' set.");
      set => _lastName = value ?? throw new ArgumentNullException(nameof(LastName));
  }

  public string NickName { get; set; }
}

But these checks are another boilerplate code that I'd rather generate then write myself each time. So I experimented with the ILGenerator and wrote this ObjectFactory helper. It creates a new type that implements properties of the specified interface and adds null checks if a property is decorated with the NotNullAttribute (this is used by ReSharper). Derived types are cached.

public static class ObjectFactory
{
    private static readonly ConcurrentDictionary<Type, Type> TypeCache = new ConcurrentDictionary<Type, Type>();

    public static T CreateInstance<T>()
    {
        if (!typeof(T).IsInterface) throw new ArgumentException($"Type {typeof(T).Name} must be an interface.");
        var newType = TypeCache.GetOrAdd(typeof(T), t => BuildType(typeof(T)));
        return (T)Activator.CreateInstance(newType);
    }

    private static Type BuildType(Type interfaceType)
    {
        var assemblyName = new AssemblyName($"DynamicAssembly_{Guid.NewGuid():N}");
        var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
        var moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicModule");
        var typeName = $"{RemoveInterfacePrefix(interfaceType.Name)}_{Guid.NewGuid():N}";
        var typeBuilder = moduleBuilder.DefineType(typeName, TypeAttributes.Public);

        typeBuilder.AddInterfaceImplementation(interfaceType);

        var properties = interfaceType.GetProperties(BindingFlags.Instance | BindingFlags.Public);

        BuildProperties(typeBuilder, properties);

        return typeBuilder.CreateType();

        string RemoveInterfacePrefix(string name) => Regex.Replace(name, "^I", string.Empty);
    }

    private static void BuildProperties(TypeBuilder typeBuilder, IEnumerable<PropertyInfo> properties)
    {
        foreach (var property in properties)
        {
            BuildProperty(typeBuilder, property);
        }
    }

    private static PropertyBuilder BuildProperty(TypeBuilder typeBuilder, PropertyInfo property)
    {
        var fieldName = $"<{property.Name}>k__BackingField";

        var propertyBuilder = typeBuilder.DefineProperty(property.Name, System.Reflection.PropertyAttributes.None, property.PropertyType, Type.EmptyTypes);

        // Build backing-field.
        var fieldBuilder = typeBuilder.DefineField(fieldName, property.PropertyType, FieldAttributes.Private);

        var getSetAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual;

        var getterBuilder = BuildGetter(typeBuilder, property, fieldBuilder, getSetAttributes);
        var setterBuilder = BuildSetter(typeBuilder, property, fieldBuilder, getSetAttributes);

        propertyBuilder.SetGetMethod(getterBuilder);
        propertyBuilder.SetSetMethod(setterBuilder);

        return propertyBuilder;
    }

    private static MethodBuilder BuildGetter(TypeBuilder typeBuilder, PropertyInfo property, FieldBuilder fieldBuilder, MethodAttributes attributes)
    {
        var getterBuilder = typeBuilder.DefineMethod($"get_{property.Name}", attributes, property.PropertyType, Type.EmptyTypes);
        var ilGenerator = getterBuilder.GetILGenerator();

        ilGenerator.Emit(OpCodes.Ldarg_0);
        ilGenerator.Emit(OpCodes.Ldfld, fieldBuilder);

        if (property.GetCustomAttribute<NotNullAttribute>() != null)
        {
            // Build null check
            ilGenerator.Emit(OpCodes.Dup);

            var isFieldNull = ilGenerator.DefineLabel();
            ilGenerator.Emit(OpCodes.Brtrue_S, isFieldNull);
            ilGenerator.Emit(OpCodes.Pop);
            ilGenerator.Emit(OpCodes.Ldstr, $"{property.Name} isn't set.");

            var invalidOperationExceptionConstructor = typeof(InvalidOperationException).GetConstructor(new Type[] { typeof(string) });
            ilGenerator.Emit(OpCodes.Newobj, invalidOperationExceptionConstructor);
            ilGenerator.Emit(OpCodes.Throw);

            ilGenerator.MarkLabel(isFieldNull);
        }
        ilGenerator.Emit(OpCodes.Ret);

        return getterBuilder;
    }

    private static MethodBuilder BuildSetter(TypeBuilder typeBuilder, PropertyInfo property, FieldBuilder fieldBuilder, MethodAttributes attributes)
    {
        var setterBuilder = typeBuilder.DefineMethod($"set_{property.Name}", attributes, null, new Type[] { property.PropertyType });
        var ilGenerator = setterBuilder.GetILGenerator();

        ilGenerator.Emit(OpCodes.Ldarg_0);
        ilGenerator.Emit(OpCodes.Ldarg_1);

        // Build null check

        if (property.GetCustomAttribute<NotNullAttribute>() != null)
        {
            var isValueNull = ilGenerator.DefineLabel();

            ilGenerator.Emit(OpCodes.Dup);
            ilGenerator.Emit(OpCodes.Brtrue_S, isValueNull);
            ilGenerator.Emit(OpCodes.Pop);
            ilGenerator.Emit(OpCodes.Ldstr, property.Name);

            var argumentNullExceptionConstructor = typeof(ArgumentNullException).GetConstructor(new Type[] { typeof(string) });
            ilGenerator.Emit(OpCodes.Newobj, argumentNullExceptionConstructor);
            ilGenerator.Emit(OpCodes.Throw);

            ilGenerator.MarkLabel(isValueNull);
        }
        ilGenerator.Emit(OpCodes.Stfld, fieldBuilder);
        ilGenerator.Emit(OpCodes.Ret);

        return setterBuilder;
    }
}

Example

var person = ObjectFactory.CreateInstance<IPerson>();
//person.FirstName = null; // this throws ArgumentNullException
person.LastName = "Doe";
person.NickName = "JD";
person.Dump(); // InvalidOperationException appears in the dump