static void Main(string[] args)
{
var t = DynamicTypeFactory.Class()
.Interface <ASDTEST>() // new class implements this interface
.Constructor()
.Constructor <string>((ctx, s) => ctx.Field("_TEST2", s))
.Field <string>("_TEST") // has a field named _TEST
.Field <string>("_TEST2") // has a field named _TEST
.Property <string>("i2", (ctx) => (string)ctx.Field("_TEST"), (ctx, s) => ctx.Field("_TEST", ctx.Field("_TEST2") + s)) // has a property using _TEST as a backing field
.Property <string>("i3", (ctx) => (string)ctx.Field("_TEST2"), (ctx, s) => ctx.Field("_TEST2", s)) // has an auto property
.Method <string, string, string>("Combine", (ctx, s1, s2) => ctx.Field("_TEST2") + s1 + s2)
.Method <string>("GetProps", (ctx) =>
{
var ret = ctx.Field("_TEST2") + (string)ctx.Property("i2");
ctx.Property("i2", ret);
return(ret);
})
.Build();
var obj = (ASDTEST)Activator.CreateInstance(t);
//obj.i3 = "pre_";
obj.i2 = "test";
var asa = obj.i2;
var as2 = obj.Combine(" HI ", "BYE");
var as3 = obj.GetProps();
var as4 = obj.i2;
Console.WriteLine( );
}
public override void Initialize()
{
base.Initialize();
var controllerType = ReflectionManager.LooseGetType(InventoryInstance.InterfaceControllerTypeName);
var args = new object[] { this };
InterfaceController = DynamicTypeFactory.CreateInstance <InventoryInterfaceController>(controllerType, args);
InterfaceController.Initialize();
if (Owner.TryGetComponent(out _sprite))
{
foreach (var mask in InventoryInstance.SlotMasks.OrderBy(s => InventoryInstance.SlotDrawingOrder(s)))
{
if (mask == Slots.NONE)
{
continue;
}
_sprite.LayerMapReserveBlank(mask);
}
}
// Component state already came in but we couldn't set anything visually because, well, we didn't initialize yet.
foreach (var(slot, entity) in _slots)
{
_setSlot(slot, entity);
}
}
public Type Build()
{
return(DynamicTypeFactory
.AsContext()
.Ensures(builder)
.Entities(service)
.GetOrCreate());
}
/// <summary>
/// Create a dynamic service type to specified service type (<typeparamref name="TService"/>)
/// and target context <typeparamref name="TContext"/>.
/// Then, invoke callback to register it in service collection.
/// </summary>
/// <typeparam name="TContext">database context type</typeparam>
/// <typeparam name="TService">service contract type</typeparam>
/// <param name="addServiceCallback">service collection callback operation</param>
/// <param name="implementedType">implemented type generated to target context and service contract type</param>
/// <returns>current service collection</returns>
private static IServiceCollection CreateAndAddServiceDynamicType <TContext, TService>([NotNull] Func <Type, Type, IServiceCollection> addServiceCallback, ref Type implementedType)
where TContext : ContextBase
where TService : IService
{
implementedType ??= DynamicTypeFactory.AsService().GetOrCreateType <TContext, TService>();
var sType = typeof(TService);
return(addServiceCallback.Invoke(sType, implementedType));
}
/// <summary>
/// The main entry point for the application.
/// </summary>
/// <param name="args">The command-line arguments passed to the program</param>
static void Main(string[] args)
{
// Read the todos, dynamic property definitions and values from the JSON content files.
var todos = JsonSerializer.Deserialize <IList <Todo> >(File.ReadAllText(@"Content\todos.json"));
var dynamicProperties = JsonSerializer.Deserialize <IList <DynamicProperty> >(File.ReadAllText(@"Content\dynamic-properties.json"));
var dynamicTodoValues = JsonSerializer.Deserialize <IList <TodoDynamicValue> >(File.ReadAllText(@"Content\todo-dynamic-values.json"));
// Create a new Type based on a 'Todo' with additional dynamic properties.
var factory = new DynamicTypeFactory();
var extendedType = factory.CreateNewTypeWithDynamicProperties(typeof(Todo), dynamicProperties);
// Get all read/write properties for the extended Type.
var properties = extendedType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.CanRead && p.CanWrite);
// Populate a list of objects of the extended Type and display the property names and values.
object extendedObject = null;
for (int i = 0; i < todos.Count(); i++)
{
extendedObject = Activator.CreateInstance(extendedType);
string todoHeading = $"Todo {i + 1}";
Console.WriteLine(todoHeading);
Console.WriteLine("".PadLeft(todoHeading.Length, '='));
Console.WriteLine();
extendedType.GetProperty($"{nameof(Todo.Id)}")
.SetValue(extendedObject, todos[i].Id, null);
extendedType.GetProperty($"{nameof(Todo.UserId)}")
.SetValue(extendedObject, todos[i].UserId, null);
extendedType.GetProperty($"{nameof(Todo.Title)}")
.SetValue(extendedObject, todos[i].Title, null);
extendedType.GetProperty($"{nameof(Todo.Completed)}")
.SetValue(extendedObject, todos[i].Completed, null);
// NOTE: The dynamic property names are prefixed to mitigate against name collision.
extendedType.GetProperty($"{nameof(DynamicProperty)}_{nameof(TodoDynamicValue.Important)}")
.SetValue(extendedObject, dynamicTodoValues[i].Important, null);
extendedType.GetProperty($"{nameof(DynamicProperty)}_{nameof(TodoDynamicValue.Notes)}")
.SetValue(extendedObject, dynamicTodoValues[i].Notes, null);
foreach (PropertyInfo property in properties)
{
Console.WriteLine($"{property.Name}: {property.GetValue(extendedObject, null)}");
}
Console.WriteLine();
}
Console.ReadKey();
}
public UsersController(IUnitOfWork unitOfWork,
IJwtProvider jwtProvider,
DynamicTypeFactory dynamicTypeFactory,
SignInManager <User> signInManager)
{
_unitOfWork = unitOfWork;
_jwtProvider = jwtProvider;
_dynamicTypeFactory = dynamicTypeFactory;
_signInManager = signInManager;
}
/// <summary>
/// Creates a new type of error model depending on the errors in the the model state.
/// </summary>
/// <param name="modelState">A model state dictionary where each key (property name) has a list of error messages related to that key</param>
/// <param name="dynamicFactory">A dynamic factory for creating new types</param>
/// <returns>A instance of the new created type</returns>
public static object GetErrors(this ModelStateDictionary modelState, DynamicTypeFactory dynamicFactory)
{
List <DynamicProperty> dynamicProperties = new List <DynamicProperty>();
foreach (var key in modelState.Keys)
{
dynamicProperties.Add(new DynamicProperty
{
DisplayName = key.ToCamelCase(),
PropertyName = key.ToCamelCase(),
SystemTypeName = modelState[key].Errors.Count > 1 ? typeof(List <string>).ToString() : typeof(string).ToString()
});
}
var errorType = dynamicFactory.CreateNewTypeWithDynamicProperties(typeof(ErrorModel), dynamicProperties);
var errorObject = Activator.CreateInstance(errorType);
foreach (var key in modelState.Keys)
{
List <string> errors = new List <string>();
foreach (var error in modelState[key].Errors)
{
errors.Add(error.ErrorMessage);
}
dynamic value;
if (errors.Count > 1)
{
value = errors;
}
else
{
value = errors[0];
}
errorType.GetProperty($"{key.ToCamelCase()}")
.SetValue(errorObject, value);
}
return(errorObject);
}
/// <summary>
/// Creates a new type of error model depending on the errors in the the dictionary.
/// </summary>
/// <param name="dict">A dictionary where each key (property name) has a list of error messages related to that key</param>
/// <param name="dynamicFactory">A dynamic factory for creating new types</param>
/// <returns>A instance of the new created type</returns>
public static object GetModelError(this Dictionary <string, List <string> > dict, DynamicTypeFactory dynamicFactory)
{
List <DynamicProperty> dynamicProperties = new List <DynamicProperty>();
foreach (var key in dict.Keys)
{
dynamicProperties.Add(new DynamicProperty
{
DisplayName = key.ToCamelCase(),
PropertyName = key.ToCamelCase(),
SystemTypeName = dict[key].Count > 1 ? typeof(List <string>).ToString() : typeof(string).ToString()
});
}
var errorType = dynamicFactory.CreateNewTypeWithDynamicProperties(typeof(ErrorModel), dynamicProperties);
var errorObject = Activator.CreateInstance(errorType);
foreach (var key in dict.Keys)
{
dynamic value;
if (dict[key].Count > 1)
{
value = dict[key];
}
else
{
value = dict[key][0];
}
errorType.GetProperty($"{key.ToCamelCase()}")
.SetValue(errorObject, value);
}
return(errorObject);
}
