using System;
using System.Collections.Generic;
using System.IO;
using System.Linq.Expressions;
using System.Net.Security;
using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using Nerdle.AutoConfig;
using NUnit.Framework;
namespace TestName
{
[TestFixture]
class Program
{
static void Main(string[] args)
{
}
private class TestMessage2
{
public DateTime DateTimeData { get; set; }
public string StringData { get; set; }
public int IntData { get; set; }
}
[Test]
public void TestNotWorking()
{
RegisterMessageType<List<TestMessage2>>();
}
private void RegisterMessageType<T>()
{
var messageType = typeof(T);
try
{
Build(messageType);
return;
}
catch (Exception ex)
{
throw new Exception($"Error registering message type {messageType.Name} with type.", ex);
}
}
private void Build(Type classType)
{
if (classType == null) throw new ArgumentNullException(nameof(classType));
// It is important that the schema stores the properties in a predictable order:
// a) as xml comparison tools used in unit tests are sensitive to field order.
// b) it makes log inspection etc much easier.
// For that reason they are sorted alphabetically regardless of definition order on the classes.
var propertyInfos = classType.GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var p in propertyInfos)
{
var weakGetter = CreateWeakGetter(p);
}
return;
}
/// <summary>
/// Create a weakly typed getter, i.e. one that takes an instance of type object as the argument and returns the boxed
/// result as an object.
/// </summary>
/// <param name="propertyInfo">PropertyInfo of the property to create a getter for.</param>
/// <returns>A compiled weakly typed property getter delegate.</returns>
private Func<object, object> CreateWeakGetter(PropertyInfo propertyInfo)
{
try
{
// We want to handle the class instance as an object so that we can work with a consistent delegate type across
// all mapping.
var parameter = Expression.Parameter(typeof(object));
// Convert the class instance argument from object into the declaring type.
// ReSharper disable once AssignNullToNotNullAttribute
var converted = Expression.Convert(parameter, propertyInfo.DeclaringType);
// Invoke the getter on the typed instance.
var property = Expression.Property(converted, propertyInfo);
// Box the result (convert to object).
var boxedResult = Expression.Convert(property, typeof(object));
// Build the delegate.
return Expression.Lambda<Func<object, object>>(boxedResult, parameter).Compile();
}
catch (Exception ex)
{
throw new Exception(
$"Error creating WeakGetter for property {propertyInfo.Name} on type {propertyInfo.ReflectedType}. ",
ex);
}
}
}
}
