public override void Apply(DynamicTypeBuilder typeBuilder)
{
var properties = from p in typeBuilder.BaseType.GetProperties()
let set = p.GetSetMethod(true)
where set != null && (set.IsPublic || set.IsFamily)
select p;
if (NotifyPropertyChanged)
{
foreach (var item in properties)
{
typeBuilder.AddMember(new DynamicProperty(item.Name, item.PropertyType));
}
}
this.TransactionProxyProperties = new Collection <TransactionProxyProperty>();
foreach (var item in properties)
{
var tpp = new TransactionProxyProperty {
Property = item
};
tpp.HasMultipleValuesProperty = new DynamicProperty(
string.Format("{0}_HasMultipleValues", item.Name),
typeof(bool),
false);
tpp.ValuesProperty = new DynamicProperty(
string.Format("{0}_Values", item.Name),
typeof(Dictionary <,>).MakeGenericType(typeof(Key <>).MakeGenericType(item.PropertyType), typeof(List <>).MakeGenericType(typeBuilder.BaseType)),
true);
typeBuilder.AddMember(tpp.HasMultipleValuesProperty);
typeBuilder.AddMember(tpp.ValuesProperty);
this.TransactionProxyProperties.Add(tpp);
}
this.TargetsField = new DynamicField(Guid.NewGuid().ToString(), typeof(List <>).MakeGenericType(typeBuilder.BaseType));
typeBuilder.AddMember(this.TargetsField);
this.CommitMethod = new CommitMethod();
typeBuilder.AddMember(this.CommitMethod);
this.RollbackMethod = new RollbackMethod();
typeBuilder.AddMember(this.RollbackMethod);
this.GetTransactionProxyTargetsMethod = new Methods.GetTransactionProxyTargetsMethod();
typeBuilder.AddMember(this.GetTransactionProxyTargetsMethod);
this.GetTransactionProxyTypedTargetsMethod = new Methods.GetTransactionProxyTypedTargetsMethod(typeBuilder.BaseType);
typeBuilder.AddMember(this.GetTransactionProxyTypedTargetsMethod);
this.SetTransactionProxyTargetsMethod = new Methods.SetTransactionProxyTargetsMethod();
typeBuilder.AddMember(this.SetTransactionProxyTargetsMethod);
this.SetTransactionProxyTypedTargetsMethod = new Methods.SetTransactionProxyTypedTargetsMethod(typeBuilder.BaseType);
typeBuilder.AddMember(this.SetTransactionProxyTypedTargetsMethod);
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor <ICommitable>());
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor <ITransactionProxy>());
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor(typeof(ITransactionProxy <>).MakeGenericType(typeBuilder.BaseType)));
}
public override void Apply(DynamicTypeBuilder typeBuilder)
{
if (!this.ProxyType.GetTypeInfo().IsInterface)
{
throw new InvalidOperationException("The generic argument T must be an interface!");
}
var prop = this.ProxyTarget;
typeBuilder.AddMember(prop);
var interfaces = this.ProxyType.GetInterfaces().Union(new[] { this.ProxyType });
foreach (var item in interfaces.SelectMany(p => p.GetMethods()).Distinct())
{
typeBuilder.AddMember(new ProxyMethod(item, prop));
}
foreach (var item in interfaces.SelectMany(p => p.GetProperties()).Distinct())
{
typeBuilder.AddMember(new DynamicProxyProperty(item, prop));
}
foreach (var item in interfaces.SelectMany(p => p.GetEvents()).Distinct())
{
typeBuilder.AddMember(new DynamicProxyEvent(item, prop));
}
if (!typeBuilder.DynamicMembers.OfType <SetProxyTargetMethod>().Any())
{
typeBuilder.AddMember(new SetProxyTargetMethod());
}
if (!typeBuilder.DynamicMembers.OfType <GetProxyTargetMethod>().Any())
{
typeBuilder.AddMember(new GetProxyTargetMethod());
}
foreach (var item in interfaces)
{
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor(item));
}
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor <IDynamicProxy>());
}
public override void Apply(DynamicTypeBuilder typeBuilder)
{
if (!typeof(INotifyPropertyChanged).IsAssignableFrom(typeBuilder.BaseType))
{
if (!typeBuilder.Interceptors.OfType <ImplementInterfaceInterceptor <INotifyPropertyChanged> >().Any())
{
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor <INotifyPropertyChanged>());
}
if (typeBuilder.BaseType.GetEvent("PropertyChanged") == null && !typeBuilder.DynamicMembers.OfType <DynamicEvent>().Any(p => p.MemberName == "PropertyChanged"))
{
typeBuilder.AddMember(new DynamicEvent("PropertyChanged", typeof(PropertyChangedEventHandler)));
typeBuilder.AddMember(new RaisePropertyChangedMethod());
}
}
typeBuilder.DynamicMembers.OfType <DynamicProperty>().ToList().ForEach(p => p.AddSetInterceptor(new RaisePropertyChangedInterceptor()));
}
public void TestDynamicVoid()
{
DynamicTypeBuilder <DynamicVoidTestClass> builder = new DynamicTypeBuilder <DynamicVoidTestClass>(
new DynamicMember[] {
new DynamicProperty("Property1", typeof(string)),
new DynamicVoid("TestVoid", typeof(string)),
new DynamicVoid("TestVoid2", typeof(TestClass)),
new DynamicVoid("TestVoid3")
}
);
builder.AddInterceptor(new ImplementInterfaceInterceptor <ITestVoidInterface>());
var type = builder.GeneratedType;
var implementation = Activator.CreateInstance(type) as DynamicVoidTestClass;
string randomSring = new Random().Next().ToString();
string testValue = null;
bool secondCalled = false;
bool testClassCalled = false;
Assert.NotNull(type);
Assert.NotNull(type.GetMethod("TestVoid"));
Assert.Equal(typeof(void), type.GetMethod("TestVoid").ReturnType);
Assert.Single(type.GetMethod("TestVoid").GetParameters());
implementation.Void <ITestVoidInterface, string>(p => p.TestVoid).Subscribe(p => testValue = p);
implementation.Void <ITestVoidInterface, string>(p => p.TestVoid).Subscribe(p => secondCalled = true);
implementation.Void <ITestVoidInterface, TestClass>(p => p.TestVoid2).Subscribe(p => testClassCalled = true);
type.GetMethod("TestVoid").Invoke(implementation, new[] { randomSring });
type.GetMethod("TestVoid2").Invoke(implementation, new[] { new TestClass() });
type.GetMethod("TestVoid3").Invoke(implementation, new object[] { });
Assert.Equal(randomSring, testValue);
Assert.True(secondCalled);
Assert.True(testClassCalled);
}
public ChannelProxyCacheItem(AssemblyBuilderFactory assemblyFactory)
{
var serviceContract = typeof(TChannel).GetCustomAttributes(typeof(ServiceContractAttribute), true).OfType <ServiceContractAttribute>().FirstOrDefault();
if (serviceContract != null)
{
this.HasCallback = serviceContract.CallbackContract != null;
this.CallbackType = serviceContract.CallbackContract;
}
var members = new List <DynamicMember>();
if (HasCallback)
{
foreach (var item in CallbackType.GetInterfaces().Union(new[] { CallbackType }))
{
if (item.GetProperties().Any() ||
item.GetEvents().Any() ||
item.GetMethods().Where(p => p.ReturnType != typeof(void)).Any())
{
throw new InvalidOperationException("Only methods and only void retrun types are allowed for callback contracts.");
}
members.AddRange(item.GetMethods().Select(p => new DynamicVoid(p.Name, p.GetParameters().Select(x => x.ParameterType).ToArray())));
}
}
var dtb = new DynamicTypeBuilder <TProxy>(members, assemblyFactory);
dtb.AddConvention(new ProxyConvention <TChannel>());
if (HasCallback)
{
dtb.AddInterceptor(new ImplementInterfaceInterceptor(this.CallbackType));
}
this.proxyType = dtb.GeneratedType;
createProxyDelegate = Expression.Lambda <Func <TProxy> >(Expression.New(this.proxyType)).Compile();
}
{ public override void Apply(DynamicTypeBuilder typeBuilder)
{
var isDynamicObject = typeof(DynamicObjectBase).IsAssignableFrom(typeBuilder.BaseType);
var hasPropertyHostInterface = typeof(IDynamicPropertyHost).IsAssignableFrom(typeBuilder.BaseType);
if (typeBuilder.DynamicMembers.OfType <DynamicProperty>().Any() || isDynamicObject)
{
if (!typeBuilder.DynamicMembers.OfType <SetValueMethod>().Any())
{
typeBuilder.AddMember(new SetValueMethod());
}
if (!typeBuilder.DynamicMembers.OfType <GetValueMethod>().Any())
{
typeBuilder.AddMember(new GetValueMethod());
}
if (!hasPropertyHostInterface)
{
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor <IDynamicPropertyHost>());
}
}
}
public override void Apply(DynamicTypeBuilder typeBuilder)
{
foreach (var item in InterfaceType.GetProperties())
{
typeBuilder.AddMember(new DynamicInterfaceProperty(item.Name, item.PropertyType));
}
foreach (var item in InterfaceType.GetEvents())
{
typeBuilder.AddMember(new DynamicEvent(item.Name, item.EventHandlerType));
}
foreach (var item in InterfaceType.GetMethods().Except(InterfaceType.GetProperties().SelectMany(p => p.GetAccessors())))
{
if (item.ReturnType != typeof(void))
{
throw new InvalidOperationException("The interface can only contain void Methods, Properties and Events!");
}
typeBuilder.AddMember(new DynamicVoid(item.Name, item.GetParameters().Select(p => p.ParameterType).ToArray()));
}
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor(InterfaceType));
}
public override void Apply(DynamicTypeBuilder typeBuilder)
{
var properties = from p in ItemType.GetProperties()
let set = p.GetSetMethod(true)
where set != null && (set.IsPublic || set.IsFamily)
select p;
this.TransactionProxyProperties = new Collection <TransactionProxyProperty>();
var baseTypeNotifications = !ItemType.IsInterface && ItemType.GetInterfaces().Contains(typeof(INotifyPropertyChanged));
foreach (var item in properties)
{
DynamicProperty baseProp = null;
if (IsInterface)
{
baseProp = new DynamicInterfaceProperty(item.Name, item.PropertyType);
}
else
{
baseProp = new DynamicProperty(item.Name, item.PropertyType);
}
var tpp = new TransactionProxyProperty {
Property = item, DynamicProperty = baseProp
};
tpp.HasMultipleValuesProperty = new DynamicProperty(
$"{item.Name}_HasMultipleValues",
typeof(bool),
false);
tpp.ValuesProperty = new DynamicProperty(
$"{item.Name}_Values",
typeof(Dictionary <,>).MakeGenericType(typeof(Key <>).MakeGenericType(item.PropertyType), typeof(List <>).MakeGenericType(ItemType)),
true);
typeBuilder.AddMember(baseProp);
typeBuilder.AddMember(tpp.HasMultipleValuesProperty);
typeBuilder.AddMember(tpp.ValuesProperty);
if (NotifyPropertyChanged)
{
tpp.DynamicProperty.AddSetInterceptor(new ResetHasMultipleValuesInterceptor());
}
this.TransactionProxyProperties.Add(tpp);
}
this.TargetsField = new DynamicField(Guid.NewGuid().ToString(), typeof(List <>).MakeGenericType(ItemType));
typeBuilder.AddMember(this.TargetsField);
this.CommitMethod = new CommitMethod();
typeBuilder.AddMember(this.CommitMethod);
this.RollbackMethod = new RollbackMethod();
typeBuilder.AddMember(this.RollbackMethod);
this.GetTransactionProxyTargetsMethod = new Methods.GetTransactionProxyTargetsMethod();
typeBuilder.AddMember(this.GetTransactionProxyTargetsMethod);
this.GetTransactionProxyTypedTargetsMethod = new Methods.GetTransactionProxyTypedTargetsMethod(ItemType);
typeBuilder.AddMember(this.GetTransactionProxyTypedTargetsMethod);
this.SetTransactionProxyTargetsMethod = new Methods.SetTransactionProxyTargetsMethod();
typeBuilder.AddMember(this.SetTransactionProxyTargetsMethod);
this.SetTransactionProxyTypedTargetsMethod = new Methods.SetTransactionProxyTypedTargetsMethod(ItemType);
typeBuilder.AddMember(this.SetTransactionProxyTypedTargetsMethod);
this.GetValueEntiresMethod = new Methods.GetValueEntriesMethod();
typeBuilder.AddMember(this.GetValueEntiresMethod);
this.GetValueEntiresTypedMethod = new Methods.GetValueEntriesTypedMethod(ItemType);
typeBuilder.AddMember(this.GetValueEntiresTypedMethod);
this.HasMultipleValuesMethod = new Methods.HasMultipleValuesMethod();
typeBuilder.AddMember(this.HasMultipleValuesMethod);
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor <ICommitable>());
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor <ITransactionProxy>());
typeBuilder.AddInterceptor(new ImplementInterfaceInterceptor(typeof(ITransactionProxy <>).MakeGenericType(ItemType)));
}
