private string ParseSetStringFromProxEntity(TEntity proxyEntity, List <IDbDataParameter> dbParameters)
{
Dictionary <string, object> modifiedProperties = DynamicProxy.GetModifiedProperties(proxyEntity);
List <string> values = this.ParseFromProxyEntityDictionary(modifiedProperties, dbParameters);
return(string.Join(",", values));
}
private static Tuple <DbConnection, DbTransaction> GetStore(ObjectContext objectContext)
{
DbConnection dbConnection = objectContext.Connection;
var entityConnection = dbConnection as EntityConnection;
// by-pass entity connection
if (entityConnection == null)
{
return(new Tuple <DbConnection, DbTransaction>(dbConnection, null));
}
DbConnection connection = entityConnection.StoreConnection;
// get internal transaction
dynamic connectionProxy = new DynamicProxy(entityConnection);
dynamic entityTransaction = connectionProxy.CurrentTransaction;
if (entityTransaction == null)
{
return(new Tuple <DbConnection, DbTransaction>(connection, null));
}
DbTransaction transaction = entityTransaction.StoreTransaction;
return(new Tuple <DbConnection, DbTransaction>(connection, transaction));
}
public void TestMethodNulls()
{
var t = new TestWrapper();
dynamic w = new DynamicProxy(t);
string r = w.EchoInternal(null);
Assert.Equal("Internal: ", r);
r = w.EchoInternal2(1);
Assert.Equal("Int: 1", r);
r = w.EchoInternal2("Test");
Assert.Equal("String: Test", r);
r = w.EchoInternal2("Test", "Testing");
Assert.Equal("Name: Test Value: Testing", r);
r = w.EchoInternal2("Test", null);
Assert.Equal("Name: Test Value: ", r);
r = w.EchoInternal3("Test", "Testing", null);
Assert.Equal("Name: Test Value: Testing Value2: ", r);
r = w.EchoInternal3("Test", 1, null);
Assert.Equal("Name: Test Value: 1 Value2: ", r);
}
/// <summary>
/// 获取数据库的事务信息
/// </summary>
/// <param name="objectContext"></param>
/// <returns></returns>
private Tuple <DbConnection, DbTransaction> GetStore(ObjectContext objectContext)
{
DbConnection dbConnection = objectContext.Connection;
var entityConnection = dbConnection as EntityConnection;
if (entityConnection == null)
{
return(new Tuple <DbConnection, DbTransaction>(dbConnection, null));
}
DbConnection connection = entityConnection.StoreConnection;
// 动态获取当前的数据库事务
dynamic connectionProxy = new DynamicProxy(entityConnection);
dynamic entityTransaction = connectionProxy.CurrentTransaction;
if (entityTransaction == null)
{
return(new Tuple <DbConnection, DbTransaction>(connection, null));
}
DbTransaction transaction = entityTransaction.StoreTransaction;
return(new Tuple <DbConnection, DbTransaction>(connection, transaction));
}
static void Main(string[] args)
{
//test();
Console.WriteLine("");
Console.WriteLine("CustomProxy Sample");
Console.WriteLine("================");
Console.WriteLine("");
// Create an instance of MyProxy.
DynamicProxy myProxyInstance = new DynamicProxy(typeof(Cicada));
// Get a CustomServer proxy.
IAnimal myHelloServer = (Cicada)myProxyInstance.GetTransparentProxy();
// Get stubdata.
Console.WriteLine("GetStubData = " + RealProxy.GetStubData(myProxyInstance).ToString());
// Get ProxyType.
Console.WriteLine("Type of object represented by RealProxy is :"
+ myProxyInstance.GetProxiedType());
//myHelloServer.HelloMethod("RealProxy Sample");
myHelloServer.Eating();
//Console.WriteLine("");
// Get a reference object from server.
//Console.WriteLine("Create an objRef object to be marshalled across Application Domains...");
//ObjRef CustomObjRef = myProxyInstance.CreateObjRef(typeof(CustomServer));
//Console.WriteLine("URI of 'ObjRef' object = " + CustomObjRef.URI);
}
public void Remove(Action <TAppModel> condition)
{
TAppModel local = DynamicProxy.CreateDynamicProxy <TAppModel>();
condition(local);
this._context.EntitySet <TDbEntity>().DeleteBy(DynamicProxy.GetModifiedProperties(local));
}
public void Update(TAppModel entity)
{
TDbEntity target = DynamicProxy.CreateDynamicProxy <TDbEntity>();
EntityMapper.Map <TAppModel, TDbEntity>(entity, target);
this._context.EntitySet <TDbEntity>().Update(target);
}
public IRepository <T> Create <T>(CreateType createType = CreateType.DynamicProxy)
{
IRepository <T> repository = null;
switch (createType)
{
case CreateType.DynamicProxy:
repository = new DynamicProxy <IRepository <T> >().Create(new Repository <T>(),
s => logger.Info($"{s}"),
e => logger.Error($"{e}"),
o => o?.ToString(),
TaskScheduler.Current);
break;
case CreateType.AuthenticationProxy:
repository = new AuthenticationProxy <IRepository <T> >().Create(Create <T>(CreateType.DynamicProxy), TaskScheduler.Current);
break;
case CreateType.PerformanceProxy:
repository = new PerformanceProxy <IRepository <T> >().Create(Create <T>(CreateType.AuthenticationProxy));
break;
case CreateType.LoggerRepository:
repository = new LoggerRepository <T>(new Repository <T>());
break;
}
return(repository);
}
static void Main(string[] args)
{
FreeSql.DynamicProxy.GetAvailableMeta(typeof(MyClass)); //The first dynamic compilation was slow
var dt = DateTime.Now;
var pxy = new MyClass {
T2 = "123123"
}.ToDynamicProxy();
Console.WriteLine(pxy.Get("key"));
Console.WriteLine(pxy.GetAsync().Result);
pxy.Text = "testSetProp1";
Console.WriteLine(pxy.Text);
Console.WriteLine(DateTime.Now.Subtract(dt).TotalMilliseconds + " ms\r\n");
dt = DateTime.Now;
pxy = new MyClass().ToDynamicProxy();
Console.WriteLine(pxy.Get("key1"));
Console.WriteLine(pxy.GetAsync().Result);
pxy.Text = "testSetProp2";
Console.WriteLine(pxy.Text);
Console.WriteLine(DateTime.Now.Subtract(dt).TotalMilliseconds + " ms\r\n");
var api = DynamicProxy.Resolve <IUserApi>();
api.Add(new UserInfo {
Id = "001", Remark = "add"
});
Console.WriteLine(JsonConvert.SerializeObject(api.Get <UserInfo>("001")));
}
/// <summary>
/// 使用 CZGL.AOP 处理容器中需要代理的类型
/// </summary>
/// <param name="service"></param>
/// <returns></returns>
public static IContainer BuildAopProxy(this IContainer service)
{
if (service is null)
{
throw new ArgumentNullException(nameof(service));
}
ContainerBuilder proxyServiceCollection = new ContainerBuilder();
IEnumerable <IComponentRegistration> serviceList = service.ComponentRegistry.Registrations;
foreach (ComponentRegistration item in serviceList)
{
Type newType;
Type serviceType = item.Services.OfType <IServiceWithType>().Select(x => x.ServiceType).FirstOrDefault();
Type implementationType = item.Activator.LimitType;
if (implementationType?.GetCustomAttribute(typeof(InterceptorAttribute)) == null)
{
proxyServiceCollection.RegisterComponent(item);
continue;
}
if (serviceType == implementationType)
{
newType = DynamicProxy.CreateProxyClassType(implementationType);
}
else
{
newType = DynamicProxy.CreateProxyClassType(serviceType, implementationType, false);
}
proxyServiceCollection.RegisterComponent(item);
proxyServiceCollection.RegisterType(newType).As(serviceType);
}
return(proxyServiceCollection.Build());
}
public override Expression <TDelegate> ToLambda()
{
DynamicProxy proxy = GetDynamicProxy();
ConstructorDeclaration constructor = null;
IEnumerable <Parameter> outParameters = null;
var typeResolver = DummyArgumentsResolver.Instance;
IEnumerable <ParameterExpression> parameters = null;
var visitor = new GenericTypesTransformerVisitor();
NRefactory.ConstructorDeclaration constructorDeclaration = null;
MethodDefinition methodDefinition = _ctor.ResolveConstructorDefinition();
var lambdaExpressionVisitor = new LambdaExpressionVisitor <NRefactory.ConstructorDeclaration>();
constructorDeclaration = methodDefinition.ResolveMothod <NRefactory.ConstructorDeclaration>();
constructorDeclaration = constructorDeclaration.AcceptVisitor(visitor, typeResolver) as NRefactory.ConstructorDeclaration;
constructorDeclaration.AcceptVisitor(new ThisAdditionalReturnStatmentVisitor(), null);
outParameters = proxy.GetOutParameters(constructorDeclaration);
constructor = AstExpression.Constructor(constructorDeclaration, proxy.ProxiedType, outParameters, new NRefactoryAstVisitor());
constructorDeclaration = constructorDeclaration.AcceptVisitor(lambdaExpressionVisitor);
parameters = constructor.Parameters.Concat(constructor.ContextParameter);
return(Expression.Lambda <TDelegate>(
Expression.Block(new[] { constructor.ContextParameter },
constructor),
constructor.Parameters));
}
private DynamicProxy CreateDynamicProxy()
{
string serviceWsdlUri = ServiceAddress;
// create the dynamic proxy factory, that downloads the service metadata
// and create the dynamic factory.
DynamicProxyFactory factory = new DynamicProxyFactory(serviceWsdlUri);
//Setup timeout
var bindingList = factory.Bindings;
if (bindingList != null)
{
foreach (var binding in bindingList)
{
binding.OpenTimeout = new TimeSpan(0, 30, 0);
binding.ReceiveTimeout = new TimeSpan(0, 30, 0);
binding.SendTimeout = new TimeSpan(0, 30, 0);
binding.CloseTimeout = new TimeSpan(0, 30, 0);
}
}
// operations
DynamicProxy proxy = factory.CreateProxy(OperationContractName);
return(proxy);
}
public static Type ExtractType(string strType)
{
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType != null &&
strType.Length > typeAttrInObject.Length &&
strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject)
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.UnescapeSafeString(Serializer.EatValue(strType, ref propIndex));
var type = JsConfig.TypeFinder.Invoke(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
return(null);
}
#if !SILVERLIGHT && !MONOTOUCH
if (type.IsInterface || type.IsAbstract)
{
return(DynamicProxy.GetInstanceFor(type).GetType());
}
#endif
return(type);
}
return(null);
}
public void TestMethod()
{
var t = new TestWrapper();
dynamic w = new DynamicProxy(t);
string r = w.Name;
Assert.Equal("Test", r);
r = w.Internal;
Assert.Equal("InternalTest", r);
r = w.Private;
Assert.Equal("PrivateTest", r);
r = w.EchoPublic("Tester");
Assert.Equal("Public: Tester", r);
r = w.EchoPrivate("Tester");
Assert.Equal("Private: Tester", r);
r = w.EchoInternal("Tester");
Assert.Equal("Internal: Tester", r);
r = w.EchoInternal(null);
Assert.Equal("Internal: ", r);
}
/// <summary>
/// Executes the future queries.
/// </summary>
/// <param name="context">The <see cref="ObjectContext"/> to run the queries against.</param>
/// <param name="futureQueries">The future queries list.</param>
public void ExecuteFutureQueries(ObjectContext context, IList <IFutureQuery> futureQueries)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (futureQueries == null)
{
throw new ArgumentNullException("futureQueries");
}
// used to call internal methods
dynamic contextProxy = new DynamicProxy(context);
contextProxy.EnsureConnection(false);
try
{
using (var command = CreateFutureCommand(context, futureQueries))
using (var reader = command.ExecuteReader())
{
foreach (var futureQuery in futureQueries)
{
futureQuery.SetResult(context, reader);
reader.NextResult();
}
}
}
finally
{
contextProxy.ReleaseConnection();
// once all queries processed, clear from queue
futureQueries.Clear();
}
}
/// <summary>
/// Creates an ObjectQuery from an expression.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="expression">The expression.</param>
/// <param name="type">The type.</param>
/// <returns>An ObjectQuery created from the expression.</returns>
public static ObjectQuery CreateQuery(this IQueryable source, Expression expression, Type type)
{
// first convet to object query to get the correct provider
ObjectQuery sourceQuery = source.ToObjectQuery();
if (sourceQuery == null)
{
return(null);
}
IQueryProvider provider = ((IQueryable)sourceQuery).Provider;
// create query from expression using internal ObjectQueryProvider
dynamic providerProxy = new DynamicProxy(provider);
IQueryable expressionQuery = providerProxy.CreateQuery(expression, type);
if (expressionQuery == null)
{
return(null);
}
// convert back to ObjectQuery
ObjectQuery resultQuery = expressionQuery.ToObjectQuery();
return(resultQuery);
}
public void AsyncCallbackTest()
{
bool isCallbackDone = false;
AsyncCallback callback = ar => isCallbackDone = true;
var pendingCall = new PendingCall(0, "", "", callback, this);
pendingCall.ReceiveResult(
new RpcMessage.Result {
CallResult = new RpcMessage.Parameter {
IntParam = 42
}
});
client.Setup(c =>
c.Call(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <object[]>(), It.IsAny <AsyncCallback>(),
It.IsAny <object>())).Returns(pendingCall);
dynamic serviceProxy = new DynamicProxy(client.Object, "TestServiceName");
IAsyncResult asyncResult = serviceProxy.BeginTestMethod("param", 42.0f, callback, this);
Assert.That(asyncResult.AsyncState, Is.EqualTo(this));
asyncResult.AsyncWaitHandle.WaitOne(); //not necessary, just because i can
int result = serviceProxy.EndTestMethod(asyncResult);
Assert.That(isCallbackDone);
Assert.That(asyncResult.IsCompleted);
Assert.That(result, Is.EqualTo(42));
client.Verify(c => c.Call("TestServiceName", "TestMethod", new object[] { "param", 42.0f }, callback, this));
}
public TEntity Create(TEntity entity)
{
Dictionary <string, object> modifiedProperties;
if (DynamicProxy.IsProxy(entity.GetType()))
{
modifiedProperties = DynamicProxy.GetModifiedProperties(entity);
}
else
{
modifiedProperties = this._entityMapper.GetPropertyValues(entity);
}
List <string> values = new List <string>();
List <string> list2 = new List <string>();
List <IDbDataParameter> list3 = new List <IDbDataParameter>();
foreach (PropertyInfo info in this._properties)
{
if (this._autoIncrementProperty != info)
{
values.Add("[" + info.Name + "]");
list2.Add("@" + info.Name);
IDbDataParameter item = this._helper.CreateParameter(Xinchen.DbEntity.DbHelper.TypeMapper[info.PropertyType], "@" + info.Name, DBNull.Value);
if (modifiedProperties.ContainsKey(info.Name))
{
item.Value = modifiedProperties[info.Name];
}
if (this._keyProperty == info)
{
int result = 0;
if (int.TryParse(Convert.ToString(item.Value), out result) && (result <= 0))
{
throw new EntityException("检测到主键值为" + result.ToString() + "，是否忘记给主键赋值？实体名：" + this._entityType.Name);
}
}
if (item.Value == null)
{
item.Value = DBNull.Value;
}
list3.Add(item);
}
}
string sql = string.Format("insert into {0} ({1}) values({2});", "[" + this.TableName + "]", string.Join(",", values), string.Join(",", list2));
if (this._autoIncrementProperty != null && DbHelper.ProviderName != "System.Data.OleDb")
{
sql = sql + "SELECT @@IDENTITY;";
int num2 = this._helper.ExecuteScalarCount(sql, list3.ToArray());
if (this._autoIncrementProperty != null)
{
this._entityMapper.SetValue(entity, this._autoIncrementProperty.Name, num2);
}
}
else
{
this._helper.ExecuteUpdate(sql, list3.ToArray());
}
return(DynamicProxy.CreateDynamicProxy <TEntity>(entity));
}
/// <summary>
/// Returns an instatiable class that implements the given interface class
/// </summary>
[CanBeNull] public Type WrapperTypeFor(Type t)
{
if (t == null)
{
return(null);
}
return((t.IsInterface) ? (DynamicProxy.GetInstanceFor(t)?.GetType()) : (t));
}
public static T GetServiceReference <T>(string serviceName, string nsHost = DefaultHostname, int nsPort = DefaultPort) where T : IToyOrbService
{
var lookupRequest = new NameLookupMessage(serviceName);
var lookupResponse = new Requestor <NameLookupMessage, NameResponseMessage>(nsHost, nsPort).MakeRequest(lookupRequest);
var remoteProxy = new ClientSideProxy(lookupResponse.TypeName, lookupResponse.Host, lookupResponse.Port);
return(DynamicProxy.NewProxyInstance <T>(remoteProxy));
}
public void DynamicConversionTest()
{
var obj1 = new ErrorProneAbstracted();
dynamic proxy1 = new DynamicProxy(obj1, true);
ErrorProneAbstracted abst = proxy1;
Assert.IsNotNull(abst);
}
public void CallWithResultTest()
{
dynamic serviceProxy = new DynamicProxy(client.Object, "TestServiceName");
int result = serviceProxy.TestMethod(10, "Hello", 1.0f);
Assert.That(result, Is.EqualTo(42));
client.Verify(c => c.Call("TestServiceName", "TestMethod", new object[] { 10, "Hello", 1.0f }, null, null));
}
public T GetService <T>()
{
if (typeof(T).GetInterfaces().Any(x => x == typeof(IProcedure)))
{
return(DynamicProxy.BuildProxy <T>(typeof(T)));
}
return(default(T));//DI
}
public void DynamicProxyFieldAccessTest()
{
dynamic dp = new DynamicProxy(new DynamicTestData());
dp.data = "12";
dp.Id = 12;
Console.WriteLine(dp.Id);
dp.WriteDataValue();
}
public void CallTest()
{
dynamic serviceProxy = new DynamicProxy(client.Object, "TestServiceName");
serviceProxy.TestMethod(10, "Hello", 1.0f);
client.Verify(c => c.Call("TestServiceName", "TestMethod", new object[] { 10, "Hello", 1.0f }, null, null));
}
public void DeleteBy(Action <TEntity> where)
{
TEntity local = (TEntity)Activator.CreateInstance(DynamicProxy.CreateDynamicProxyType <TEntity>());
where (local);
Dictionary <string, object> modifiedProperties = DynamicProxy.GetModifiedProperties(local);
this.DeleteBy(modifiedProperties);
}
public void Test1()
{
IAnimal animal = null;
DynamicProxy dynamicProxy = new DynamicProxy(typeof(Cicada));
// animal = (Animal)(dynamicProxy.GetTransparentProxy()) ;
animal.Eating();
Assert.Pass();
}
private static EntityMap CreateEntityMap <TEntity>(ObjectQuery query)
{
Type entityType = typeof(TEntity);
ObjectContext objectContext = query.Context;
var modelSet = objectContext.GetEntitySet <TEntity>();
if (modelSet == null)
{
return(null);
}
var entityMap = new EntityMap(entityType);
entityMap.ModelSet = modelSet;
entityMap.ModelType = entityMap.ModelSet.ElementType;
var metadata = objectContext.MetadataWorkspace;
// force metadata to load
dynamic dbProxy = new DynamicProxy(objectContext);
dbProxy.EnsureMetadata();
ItemCollection itemCollection;
if (!metadata.TryGetItemCollection(DataSpace.CSSpace, out itemCollection))
{
// force CSSpace to load
query.ToTraceString();
// try again
metadata.TryGetItemCollection(DataSpace.CSSpace, out itemCollection);
}
if (itemCollection == null)
{
return(null);
}
dynamic mappingFragmentProxy = FindMappingFragment(itemCollection, entityMap.ModelSet);
if (mappingFragmentProxy == null)
{
return(null);
}
// SModel
entityMap.StoreSet = mappingFragmentProxy.TableSet;
entityMap.StoreType = entityMap.StoreSet.ElementType;
SetProperties(entityMap, mappingFragmentProxy);
SetKeys(entityMap);
SetTableName(entityMap);
return(entityMap);
}
public void DynamicProxyExceptionIntercepterTest()
{
dynamic dp = new DynamicProxy(new ErrorProneClass());
dp.data = "12";
dp.Id = 12;
Console.WriteLine(dp.Id);
dp.DoStuff();
dp.DoStuff();
dp.WriteDataParams(1, "1");
}
public TEntity GetSingle(Action <TEntity> condition)
{
TEntity local = (TEntity)Activator.CreateInstance(DynamicProxy.CreateDynamicProxyType <TEntity>());
condition(local);
List <IDbDataParameter> dbParameters = new List <IDbDataParameter>();
string strWhere = this.ParseConditionFromProxyEntity(local, dbParameters);
return(GetList(string.Join(",", this._propertyNames), strWhere, null, dbParameters.ToArray()).FirstOrDefault());
}
public IList <TEntity> GetList(Action <TEntity> where)
{
TEntity local = (TEntity)Activator.CreateInstance(DynamicProxy.CreateDynamicProxyType <TEntity>());
where (local);
List <IDbDataParameter> dbParameters = new List <IDbDataParameter>();
string strWhere = this.ParseConditionFromProxyEntity(local, dbParameters);
return(this.GetList(string.Join(",", this._propertyNames), strWhere, null, dbParameters.ToArray()));
}
public void TestMethod4()
{//未添加 virual
IGamePlayer player = DynamicProxy <GamePlayerB> .NewProxyInstance(new InvocationHandler());
player.Upgrade();
player.KillBoss();
//Debug Trace:
//B: 升级
//B:杀怪
}
private static void SendSampleMessage()
{
var senderNode = ObjectFactory.GetInstance <ISenderNode>();
var sampleMessage = DynamicProxy.GetInstanceFor <ISampleMessage>();
sampleMessage.Text = "sample message";
senderNode.SendMessage(sampleMessage);
}
public void CallResultMissingFailedTest()
{
var pendingCall = new PendingCall(0, "", "", null, null);
pendingCall.ReceiveResult(new RpcMessage.Result());
client.Setup(c =>
c.Call(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<object[]>(), It.IsAny<AsyncCallback>(),
It.IsAny<object>())).Returns(pendingCall);
dynamic serviceProxy = new DynamicProxy(client.Object, "TestServiceName");
int x = serviceProxy.TestMethod(10, "Hello", 1.0f);
}
public void DynamicProxy_Should_Map_Instance_Method_Calls_To_The_Given_Instance()
{
const string instance = "TestString";
dynamic proxy = new DynamicProxy(instance);
char[] toCharArrayResult = proxy.ToCharArray();
char[] toCharArrayIndexResult = proxy.ToCharArray(0, 4);
var copyResult = new char[9];
proxy.CopyTo(0, copyResult, 0, 9);
Assert.AreEqual(instance, new string(toCharArrayResult));
Assert.AreEqual(new string(instance.ToCharArray(0, 4)), new string(toCharArrayIndexResult));
Assert.AreEqual(instance.Substring(0, 9), new string(copyResult));
}
public void DynamicProxy_Should_Get_Indexed_Elements_For_IDictionary_Types()
{
var dictionary = new Dictionary<string, int>(1)
{
{"One", 1}
};
dynamic proxy = new DynamicProxy(dictionary);
Assert.AreEqual(1, proxy["One"]);
var hash = new Hashtable
{
{"Two", 2}
};
proxy = new DynamicProxy(hash);
Assert.AreEqual(2, proxy["Two"]);
}
public void DynamicProxyCastOperationTest()
{
if (System.Threading.Interlocked.CompareExchange(ref this.disposed, 1, -1) == -1)
{
var real = new ErrorProneAbstracted();
dynamic proxy = new DynamicProxy(real);
IDoWork interf = proxy;
if (interf != null)
{
interf.DoWork();
Assert.IsTrue(interf.Default == 0);
interf.Default = 65;
interf.DoWorkErrored(12);
}
}
}
public void DynamicProxy_Should_Get_Indexed_Elements_For_Array_Types()
{
dynamic proxy = new DynamicProxy(new[] { "One", "Two" });
Assert.AreEqual("One", proxy[0]);
Assert.AreEqual("Two", proxy[1]);
var multiArray = new string[2, 2];
multiArray[0, 0] = "Three";
multiArray[0, 1] = "Four";
multiArray[1, 0] = "Five";
proxy = new DynamicProxy(multiArray);
Assert.AreEqual("Three", proxy[0, 0]);
Assert.AreEqual("Four", proxy[0, 1]);
Assert.AreEqual("Five", proxy[1, 0]);
Assert.IsNull(proxy[1, 1]);
}
public void DynamicProxy_Should_Map_Members_To_Given_Instance_When_Instance_Is_A_Dynamic_Type()
{
var dummy = new DummyClass("String Value");
dynamic proxy = new DynamicProxy(new DynamicProxy(new DynamicProxy(new DynamicProxy(dummy))));
const string things = "things";
dummy.WritableProperty = things;
proxy.WritableProperty = things;
Assert.AreEqual(dummy.WritableProperty, proxy.WritableProperty);
Assert.AreEqual(dummy.ReadOnlyProperty, proxy.ReadOnlyProperty);
Assert.AreEqual(dummy.ReadOnlyProperty.Length, proxy.ReadOnlyProperty.Length);
Assert.IsTrue(proxy.Equals(dummy));
Assert.AreEqual(dummy.GetInt(12), proxy.GetInt(12));
Assert.AreEqual(dummy[1, 2], proxy[1, 2]);
}
public void AsyncCallbackTest()
{
bool isCallbackDone = false;
AsyncCallback callback = ar => isCallbackDone = true;
var pendingCall = new PendingCall(0, "", "", callback, this);
pendingCall.ReceiveResult(
new RpcMessage.Result { CallResult = new RpcMessage.Parameter { IntParam = 42 } });
client.Setup(c =>
c.Call(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<object[]>(), It.IsAny<AsyncCallback>(),
It.IsAny<object>())).Returns(pendingCall);
dynamic serviceProxy = new DynamicProxy(client.Object, "TestServiceName");
IAsyncResult asyncResult = serviceProxy.BeginTestMethod("param", 42.0f, callback, this);
Assert.That(asyncResult.AsyncState, Is.EqualTo(this));
asyncResult.AsyncWaitHandle.WaitOne(); //not necessary, just because i can
int result = serviceProxy.EndTestMethod(asyncResult);
Assert.That(isCallbackDone);
Assert.That(asyncResult.IsCompleted);
Assert.That(result, Is.EqualTo(42));
client.Verify(c => c.Call("TestServiceName", "TestMethod", new object[] { "param", 42.0f }, callback, this));
}
public void FastPropertyTest()
{
var real = new ErrorProneAbstracted();
dynamic proxy = new DynamicProxy(real);
Assert.IsTrue(proxy.Default == 0);
proxy.Default = 23;
Assert.IsTrue(proxy.Default == 23);
Assert.IsTrue(TypePropertyMapper.Instance.Get(real.GetType(), "Default") != null);
}
public void DynamicProxyPropertyPerformanceSingleTest()
{
var holder1 = new PropertyHolder();
var holder2 = new PropertyHolder();
dynamic proxy = new DynamicProxy(holder1);
dynamic proxy2 = new DynamicProxy(holder2, false);
Stopwatch sw = new Stopwatch();
sw.Start();
proxy.Id = 12;
proxy.Name = "Test";
proxy.Old = true;
sw.Stop();
long ticksFast = sw.ElapsedTicks;
sw.Reset();
sw.Start();
proxy2.Id = 12;
proxy2.Name = "Test";
proxy2.Old = true;
sw.Stop();
long ticksReflection = sw.ElapsedTicks;
Debug.WriteLine((ticksFast / ticksReflection));
Assert.IsTrue(ticksFast > ticksReflection);
}
public void DynamicProxyPropertyPerformanceMultipleTest()
{
var holder1 = new PropertyHolder();
var holder2 = new PropertyHolder();
dynamic proxy = new DynamicProxy(holder1);
dynamic proxy2 = new DynamicProxy(holder2, false);
int iterCount = 10000;
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 1; i <= iterCount; i++)
{
proxy.Id = i;
proxy.Name = "Test";
proxy.Old = true;
}
sw.Stop();
long ticksFast = sw.ElapsedTicks;
sw.Reset();
sw.Start();
for (int i = 1; i <= iterCount; i++)
{
proxy2.Id = i;
proxy2.Name = "Test";
proxy2.Old = true;
}
sw.Stop();
long ticksReflection = sw.ElapsedTicks;
Debug.WriteLine((ticksReflection / ticksFast));
Assert.IsTrue(ticksFast < ticksReflection);
}
public void DynamicProxy_Should_Set_Indexed_Elements_For_IDictionary_Types()
{
var dictionary = new Dictionary<string, int>(1)
{
{"One", 1}
};
dynamic proxy = new DynamicProxy(dictionary);
Assert.AreEqual(1, proxy["One"]);
proxy["One"] = 2;
Assert.AreEqual(2, proxy["One"]);
}
public void DynamicProxy_Should_Set_Indexed_Elements_For_Array_Types()
{
dynamic proxy = new DynamicProxy(new[] { "One", "Two" });
Assert.AreEqual("One", proxy[0]);
proxy[0] = "Three";
Assert.AreEqual("Three", proxy[0]);
}
public void CallWithResultTest()
{
dynamic serviceProxy = new DynamicProxy(client.Object, "TestServiceName");
int result = serviceProxy.TestMethod(10, "Hello", 1.0f);
Assert.That(result, Is.EqualTo(42));
client.Verify(c => c.Call("TestServiceName", "TestMethod", new object[] { 10, "Hello", 1.0f }, null, null));
}
public void DynamicProxy_Should_Throw_RuntimeBinderException_When_Property_Is_Not_Writable()
{
dynamic proxy = new DynamicProxy(new DummyClass(""));
proxy.ReadOnlyProperty = "";
}
public void TestMethodThrowError()
{
var real = new ErrorProneForProxy();
dynamic proxy = new DynamicProxy(real);
int data = proxy.DoWorkNonError(15);
Assert.IsTrue(data == 20);
proxy.DefaultData = 15;
data = proxy.DoWorkNonError(15);
Assert.IsTrue(data == 30);
data = proxy.DoWorkReturnError(15);
Assert.IsTrue(data == 20);
}
public void MethodCallingPerformance()
{
int iter = 5000;
var obj1 = new ErrorProneAbstracted();
var obj2 = new ErrorProneAbstracted();
dynamic proxy1 = new DynamicProxy(obj1, true);
dynamic proxy2 = new DynamicProxy(obj2, true, true);
int result = 1;
Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < iter; i++)
{
proxy1.DoWork();
result = proxy1.DoWork2(12);
result = proxy1.DoWork3(12, 123);
}
sw.Stop();
long tick1 = sw.ElapsedMilliseconds;
sw.Reset();
sw.Start();
for (int i = 0; i < iter; i++)
{
proxy2.DoWork();
result = proxy2.DoWork2(12);
result = proxy2.DoWork3(12, 123);
}
sw.Stop();
long tick2 = sw.ElapsedMilliseconds;
Debug.WriteLine("{0} - {1} Diff: {2}", tick1, tick2, tick1 - tick2);
Assert.IsTrue(tick1 > tick2);
}
public void DynamicProxy_Should_Return_An_Object_Implementing_The_Requested_Interfaces_Properties()
{
dynamic proxy = new DynamicProxy(new DummyClass("NewString"));
IDummyProperties iDummy = proxy;
const string written = "Written";
Assert.AreEqual("NewString", iDummy.ReadOnlyProperty);
iDummy.WritableProperty = written;
Assert.AreEqual(written, iDummy.WritableProperty);
iDummy.ValueProperty = 3;
Assert.AreEqual(3, iDummy.ValueProperty);
}
public void DynamicProxyErrorTest()
{
dynamic dp = new DynamicProxy(new DynamicTestData());
dp.DoNonExistentMethod();
}
public void DynamicProxy_Should_Throw_An_Exception_For_Casts_If_The_Conversion_Is_Not_Possible_Because_Events_Do_Not_Match()
{
dynamic proxy = new DynamicProxy(new DummyClass2());
IDummyEvents iDummy = proxy;
}
public void TestMethodDoNotThrowError()
{
var real = new ErrorProneForProxy();
dynamic proxy = new DynamicProxy(real);
int data = proxy.DoWorkNonError(15);
Assert.IsTrue(data == 20);
proxy.DefaultData = 15;
data = proxy.DoWorkNonError(15);
Assert.IsTrue(data == 30);
data = -1;
data = proxy.DoWorkErrorNoThrow(15);
//Since method above in case on error will eat exception
//it must return default value as a result
Assert.IsTrue(data == 0);
}
public void DynamicProxyMapperTest()
{
dynamic dp = new DynamicProxy(new DynamicTestData());
dp.DoStuff();
dynamic dp2 = new DynamicProxy(new DynamicTestData());
dp2.DoStuff();
}
public void DynamicProxy_Should_Throw_An_Exception_For_Casts_If_The_Conversion_Is_Not_Possible_Because_Methods_Do_Not_Match()
{
dynamic proxy = new DynamicProxy("");
IDisposable iDisposable = proxy;
iDisposable.Dispose();
}
public void DynamicProxy_Should_Throw_An_Exception_For_Casts_If_The_Conversion_Is_Not_Possible_Because_Properties_Do_Not_Match()
{
dynamic proxy = new DynamicProxy("");
IDummyProperties iDummy = proxy;
}
public void CallResultTypeFailedTest()
{
dynamic serviceProxy = new DynamicProxy(client.Object, "TestServiceName");
MultiplyOutput result = serviceProxy.TestMethod(10, "Hello", 1.0f);
}
public void CallTest()
{
dynamic serviceProxy = new DynamicProxy(client.Object, "TestServiceName");
serviceProxy.TestMethod(10, "Hello", 1.0f);
client.Verify(c => c.Call("TestServiceName", "TestMethod", new object[] { 10, "Hello", 1.0f }, null, null));
}
public void DynamicProxyTest()
{
dynamic dp = new DynamicProxy(new DynamicTestData());
dp.DoStuff();
}
public void DynamicProxy_Should_Return_An_Object_Implementing_The_Requested_Interfaces_Methods()
{
dynamic proxy = new DynamicProxy(new DummyClass("NewString"));
IDummyMethods iDummy = proxy;
Assert.AreEqual("1 - 2", iDummy.GetStringValue(1, 2));
Assert.AreEqual(12, iDummy.GetInt(12));
iDummy.Statement();
}
