public void all_objects_in_the_object_graph_are_proxied()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var item = new Person
{
Id = "1",
Contacts = new List <Contact>
{
new Contact {
Id = "1"
}
}
};
var proxy = factory.Create(item, session);
Assert.True(ProxyUtils.IsProxy(proxy));
Assert.True(proxy.Contacts is ITrackableCollection <Contact>);
Assert.True(ProxyUtils.IsProxy(proxy.Contacts[0]));
}
}
public void nullable_types_are_ignored()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
var parentMapper = new Mock <IMapper <Parent> >();
repositoryFactory.Register <Parent>(x => parentMapper.Object);
var childMapper = new Mock <IMapper <Child> >();
repositoryFactory.Register <Child>(x => childMapper.Object);
var stateTracker = new EntityStateCache();
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
{
var entity = new EntityWithNullableType
{
Id = "1",
Date = DateTime.Now
};
var proxy = proxyFactory.Create(entity, session);
Assert.NotNull(proxy.Date);
}
}
static void Main(string[] args)
{
var type = DynamicProxyFactory.Create(typeof(ITestClass), typeof(TestClass));
var obj = (ITestClass)Activator.CreateInstance(type, "A", "B");
obj.Test("A", "B", 3);
}
public void change_tracking_is_applied_when_entity_set_in_constructor()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var mapper = new Mock <IMapper <Parent> >();
var repositoryFactory = new Mock <IRepositoryFactory>();
repositoryFactory.Setup(x => x.Create(It.IsAny <IGraphSession>(), It.IsAny <Type>())).Returns <IGraphSession, Type>((s, t) => new GenericAbstractRepository <Parent>(mapper.Object, s, new DynamicProxyFactory(metadataFactory, new NullLogger())));
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var proxy = session.Create(new Parent
{
Id = "1",
Child = new Child {
Id = "2"
}
});
var state = stateTracker.Get(proxy.Child);
Assert.Equal(EntityStatus.New, state.Status);
}
}
public AopTests()
{
ConfigurationManager.Instance.UseAutofac();
IocContainer.Instance.OnServiceTypeRegistering += (sender, e) =>
{
if (e.ServiceType == typeof(IUser))
{
e.SetNewImplementationType(DynamicProxyFactory.CreateProxyType(e.ServiceType
, e.ImplementationType
, new Type[] {
typeof(UnitOfWorkInterceptor)
, typeof(PerformanceCounterInterceptor)
}).ProxyType);
}
};
IocContainer.Instance.OnServiceInstanceRegistering += (sender, e) =>
{
if (e.ServiceType == typeof(IUser))
{
e.SetNewInstance(DynamicProxyFactory.CreateProxy(e.ServiceType
, e.Instance
, new Type[] {
typeof(UnitOfWorkInterceptor)
, typeof(PerformanceCounterInterceptor)
}));
}
};
IocContainer.RegisterByAssembly(typeof(AopTests).GetTypeInfo().Assembly);
}
public Dictionary <MethodInfo, ParameterInfo[]> GetMethods(string endpoint)
{
var factory = new DynamicProxyFactory(endpoint);
var serviceModel = new ServiceModel {
ParamsList = new Dictionary <MethodInfo, ParameterInfo[]>()
};
var contract = factory.Contracts.FirstOrDefault();
if (contract == null)
{
throw new DynamicProxyException(ErrorResource.NoContractFound);
}
var proxy = factory.CreateProxy(contract.Name);
var type = proxy.ProxyType;
var methods = proxy.ProxyType.GetMethods();
foreach (var methodInfo in methods.Where(methodInfo => methodInfo.DeclaringType == type))
{
serviceModel.MethodName = methodInfo.Name;
var paramList = methodInfo.GetParameters();
serviceModel.ParamsList.Add(methodInfo, paramList);
}
return(serviceModel.ParamsList);
}
private void cmdGetWSDL_Click(object sender, EventArgs e)
{
if (txtServiceURL.Text.Trim().Length > 0)
{
try
{
cboEndPoint.Items.Clear();
if (factoryCache == null || factoryCache.WsdlUri != txtServiceURL.Text)
{
factoryCache = new DynamicProxyFactory(txtServiceURL.Text);
}
foreach (ServiceEndpoint endpoint in factoryCache.Endpoints)
{
cboEndPoint.Items.Add(endpoint.Name);
}
}
catch (Exception ex)
{
if (ex.Message.Contains("There was an error downloading"))
{
MessageBox.Show("Specified web service invalid or not available!\r\n" + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Cursor.Current = Cursors.Default;
}
}
public void properties_which_are_marked_as_ignored_are_not_proxied()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var item = new EntityWithIgnoredProperty
{
Id = "1",
Ignored = new AnotherEntity {
Id = "2"
},
Proxied = new AnotherEntity {
Id = "3"
}
};
var proxy = factory.Create(item, session);
Assert.True(ProxyUtils.IsProxy(proxy));
Assert.True(ProxyUtils.IsProxy(proxy.Proxied));
Assert.False(ProxyUtils.IsProxy(proxy.Ignored));
}
}
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 void factory_creates_meta_data_correctly_from_a_proxy_object()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var item = new Parent
{
Id = "1",
Child = new Child {
Id = "2"
},
Children = new List <Child> {
new Child {
Id = "3"
}
}
};
var proxy = factory.Create(item, session);
var parentMetadata = metadataFactory.Create(proxy);
Assert.Equal("Parent", parentMetadata.Name);
var childMetadta = metadataFactory.Create(proxy.Child);
Assert.Equal("Child", childMetadta.Name);
}
}
public static void Test()
{
ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(SkipCertValidation);
string baseAddress = "https://" + Environment.MachineName + ":8888/Service";
ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress));
host.AddServiceEndpoint(typeof(ITest), GetBinding(), "");
host.Description.Behaviors.Add(new ServiceMetadataBehavior {
HttpsGetEnabled = true
});
host.Credentials.UserNameAuthentication.UserNamePasswordValidationMode = UserNamePasswordValidationMode.Custom;
host.Credentials.UserNameAuthentication.CustomUserNamePasswordValidator = new MyPasswordValidator();
host.Authorization.PrincipalPermissionMode = PrincipalPermissionMode.UseAspNetRoles;
host.Open();
Console.WriteLine("Host opened");
DynamicProxyFactory factory = new DynamicProxyFactory(baseAddress + "?wsdl");
DynamicProxy proxy = factory.CreateProxy("ITest");
ClientCredentials credentials = proxy.GetProperty("ClientCredentials") as ClientCredentials;
credentials.UserName.UserName = "******";
credentials.UserName.Password = "******";
Console.WriteLine(proxy.CallMethod("Hello"));
Console.Write("Press ENTER to close the host");
Console.ReadLine();
host.Close();
}
private static void DynamicServiceInvoke(string wsdlUri, string operationName, object[] operationParameters,
HeaderData headerData)
{
var factory = new DynamicProxyFactory(wsdlUri);
var serviceContract = factory.Contracts.FirstOrDefault();
// create the DynamicProxy for the contract and perform operations
#if DEBUG
Console.WriteLine("Creating DynamicProxy to GenericJobScheduler Service");
#endif
if (serviceContract != null)
{
DynamicProxy dynamicProxy = factory.CreateProxy(serviceContract.Name);
var innerChannel = dynamicProxy.GetProperty("InnerChannel") as IClientChannel;
if (innerChannel != null)
{
using (new OperationContextScope(innerChannel))
{
OperationContext.Current.OutgoingMessageHeaders.Add(MessageHeader.CreateHeader(headerData.HeaderName, headerData.HeaderNamespace,
headerData.DataAsXmlString));
var result = dynamicProxy.CallMethod(operationName, operationParameters);
}
}
}
}
public void TestWCFProxy()
{
string wsdlUrl = "http://localhost/HappyHutService/HappyHutService.svc";
DynamicProxyFactory factory = new DynamicProxyFactory(string.Format("{0}?wsdl", wsdlUrl));
Assert.IsNotNull(factory);
}
public void objects_with_inheritance_chain_are_proxied_correctly()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
var parentMapper = new Mock <IMapper <Parent> >();
repositoryFactory.Register <Parent>(x => parentMapper.Object);
var childMapper = new Mock <IMapper <Child> >();
repositoryFactory.Register <Child>(x => childMapper.Object);
var stateTracker = new EntityStateCache();
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
{
var entity = new ParentWithInheritedChild
{
Id = "1",
Type = new SuperTypeA {
Id = "1"
}
};
var proxy = proxyFactory.Create(entity, session);
Assert.True(proxy.Type is SuperTypeA);
}
}
private void cboEndPoint_SelectedIndexChanged(object sender, EventArgs e)
{
if (txtServiceURL.Text.Trim().Length > 0)
{
try
{
cboMethodName.Items.Clear();
if (factoryCache == null || factoryCache.WsdlUri != txtServiceURL.Text)
{
factoryCache = new DynamicProxyFactory(txtServiceURL.Text);
}
ServiceEndpoint endpoint = (from ep in factoryCache.Endpoints
where ep.Name == cboEndPoint.Text
select ep).FirstOrDefault();
if (endpoint != null)
{
string contractName = endpoint.Contract.Name;
DynamicProxy proxy = factoryCache.CreateProxy(contractName);
Type proxyType = proxy.ProxyType;
foreach (OperationDescription operation in endpoint.Contract.Operations)
{
cboMethodName.Items.Add(operation.Name);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
public void depdendencies_are_incremented_when_property_set()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new Mock <IRepositoryFactory>();
var stateTracker = new EntityStateCache();
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory.Object, stateTracker, proxyFactory))
{
var factory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var parent = factory.Create(new Parent {
Id = "parent"
}, session);
var child = factory.Create(new Child {
Id = "child"
}, session);
parent.Child = child;
var parentState = stateTracker.Get(parent);
Assert.Equal(2, parentState.Dependencies.Sequence);
var childState = stateTracker.Get(child);
Assert.Equal(1, childState.Dependencies.Sequence);
}
}
public void circular_dependencies_are_proxied_correctly()
{
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
var parentMapper = new Mock <IMapper <Parent> >();
repositoryFactory.Register <Parent>(x => parentMapper.Object);
var childMapper = new Mock <IMapper <Child> >();
repositoryFactory.Register <Child>(x => childMapper.Object);
var stateTracker = new EntityStateCache();
using (var session = new GraphSession(new UnitOfWork(stateTracker), new List <IListener>(), queryExecutorFactory.Object, repositoryFactory, stateTracker, proxyFactory))
{
var a = new EntityA
{
Id = "a"
};
var b = new EntityB
{
Id = "b"
};
a.EntityB = b;
b.EntityA = a;
var proxy = proxyFactory.Create(a, session);
Assert.NotNull(proxy);
Assert.NotNull(proxy.EntityB);
Assert.NotNull(proxy.EntityB.EntityA);
Assert.Same(proxy, proxy.EntityB.EntityA);
}
}
public ActionResult ResolveService()
{
string serviceAddress = Request["serviceAddress"];
ServiceInfo serviceInfo = new ServiceInfo
{
ServiceAddress = serviceAddress,
ContractInfos = new List <ServiceContractInfo>()
};
DynamicProxyFactory factory = new DynamicProxyFactory(serviceAddress);
//get contracts
var contracts = factory.Contracts;
foreach (ContractDescription contract in contracts)
{
var contractInfo = new ServiceContractInfo
{
ContractName = contract.Name,
OperationInfos = new List <ContractOperationInfo>()
};
serviceInfo.ContractInfos.Add(contractInfo);
//get methods in each contract
var operations = contract.Operations;
foreach (OperationDescription operation in operations)
{
try
{
var operationInfo = new ContractOperationInfo
{
OperationName = operation.Name,
ParameterInfos = new List <OperationParameterInfo>()
};
contractInfo.OperationInfos.Add(operationInfo);
//get parameters in each method
Type contractType = factory.ProxyAssembly.GetType(contract.Name);
var method = contractType.GetMethod(operation.Name);
if (method != null)
{
var parameters = method.GetParameters();
foreach (ParameterInfo parameter in parameters)
{
operationInfo.ParameterInfos.Add(new OperationParameterInfo
{
ParameterName = parameter.Name,
ParameterType = parameter.ParameterType.ToString()
});
}
}
}
catch (Exception ex)
{
throw ex;
}
}
}
return(Json(serviceInfo));
}
public static IServiceCollection AddWithProxy(this IServiceCollection collection, Type interfaceType, Type implementationType, ServiceLifetime lifetime)
{
var proxyType = DynamicProxyFactory.Create(interfaceType, implementationType);
var serviceDescriptor = new ServiceDescriptor(interfaceType, proxyType, lifetime);
collection.Add(serviceDescriptor);
return(collection);
}
public void dependencies_are_incremented_as_relationships_are_created()
{
var stateTracker = new EntityStateCache();
var stateFactory = new Mock <IEntityStateCacheFactory>();
stateFactory.Setup(x => x.Create()).Returns(stateTracker);
var metadataFactory = new AttributeMetadataFactory(new NullLogger());
var proxyFactory = new DynamicProxyFactory(metadataFactory, new NullLogger());
var queryExecutorFactory = new Mock <IQueryExecutorFactory>();
var repositoryFactory = new RepositoryFactory(proxyFactory);
repositoryFactory.Register <Organisation>(session => new Mapper <Organisation>(session, metadataFactory));
repositoryFactory.Register <AccessGroup>(session => new Mapper <AccessGroup>(session, metadataFactory));
repositoryFactory.Register <Site>(session => new Mapper <Site>(session, metadataFactory));
repositoryFactory.Register <Person>(session => new Mapper <Person>(session, metadataFactory));
var sessionFactory = new GraphSessionFactory(queryExecutorFactory.Object, repositoryFactory, stateFactory.Object, proxyFactory);
using (var session = sessionFactory.OpenSession())
{
var organisation = session.Create(new Organisation
{
Id = "organisation"
});
var site = session.Create(new Site
{
Id = "site"
});
var accessGroup = session.Create(new AccessGroup
{
Id = "accessGroup"
});
var person = session.Create(new Person
{
Id = "person"
});
organisation.Add(site);
organisation.Add(accessGroup);
site.Add(accessGroup);
person.Add(organisation);
person.Add(site);
var organisationMetadata = stateTracker.Get(organisation);
var siteMetadata = stateTracker.Get(site);
var accessGroupMetadata = stateTracker.Get(accessGroup);
var personMetadata = stateTracker.Get(person);
Assert.Equal(1, accessGroupMetadata.Dependencies.Sequence);
Assert.Equal(2, siteMetadata.Dependencies.Sequence);
Assert.Equal(3, organisationMetadata.Dependencies.Sequence);
Assert.Equal(4, personMetadata.Dependencies.Sequence);
}
}
public void WhenCreatingProxy_ThenImplementsIProxy()
{
var proxy = new DynamicProxyFactory().CreateProxy(typeof(IFoo), new Type[0], new object[0]);
Assert.NotNull(proxy);
Assert.IsAssignableFrom <IProxy>(proxy);
//var path = DynamicProxyFactory.Generator.ProxyBuilder.ModuleScope.SaveAssembly(false);
//Debug.WriteLine(path);
}
public void DynamicProxyFactory_SimpleAOP_Test()
{
ICalculator decorate = DynamicProxyFactory <ICalculator> .Create(_calc,
info => Trace.WriteLine($"Before {info}"),
info => Trace.WriteLine($"After {info}"),
info => Trace.WriteLine($"Error {info}"));
int i = decorate.Add(1, 2);
Trace.WriteLine($"Result = {i}");
}
public async Task DynamicProxyFactory_SimpleAOP_Async_Test()
{
ICalculatorAsync decorate = DynamicProxyFactory <ICalculatorAsync> .Create(_calcAsync,
info => Trace.WriteLine($"Before {info}"),
info => Trace.WriteLine($"After {info}"),
info => Trace.WriteLine($"Error {info}"));
int i = await decorate.AddAsync(1, 2);
Trace.WriteLine($"Result = {i}");
}
/// <inheritdoc cref="IMockedDependencyFactory" />
public IMockedDependency <T> CreateMockedDependency <T>(MockBehavior behavior)
where T : notnull
{
Ensures.IsInterface <T>();
var arrangements = new ArrangementCollection();
var interceptor = InterceptorFactory.CreateInterceptorFor(behavior, arrangements);
var proxy = DynamicProxyFactory.CreateForInterface <T>(interceptor);
return(new MockedDependency <T>(arrangements, interceptor, proxy));
}
/// <inheritdoc cref="IMockedDependencyFactory" />
public IMockedDependency <T> CreateDecoratedDependency <T>(T decoratee)
where T : notnull
{
Ensures.IsInterface <T>();
var arrangements = new ArrangementCollection();
var interceptor = InterceptorFactory.CreateInterceptorFor(MockBehavior.Partial, arrangements);
var proxy = DynamicProxyFactory.CreateDecorator <T>(decoratee, interceptor);
return(new MockedDependency <T>(arrangements, interceptor, proxy));
}
/// <summary>
/// 对标注 的所有属性进行代理
/// </summary>
/// <param name="mcf"></param>
/// <returns></returns>
public ProducerBootstrap <T> start(RabbitMQOptionsFactory <RabbitMQMsgProducerMap> mcf)
{
//精确到MsgController节省启动时间
List <Type> Producers = typeof(T).Assembly.GetTypes().AsEnumerable()
.Where(type => (typeof(MsgController).IsAssignableFrom(type) && type.IsClass && !type.IsAbstract)).ToList();
///类遍历
for (int i = 0; i < Producers.Count; i++)
{
//取到所有类的指定方法
//没找到Where条件找不到注解的原因所以要分开写
IEnumerable <FieldInfo> fieldInfos = Producers[i].GetFields();
//属性便利
foreach (var fieldinfo in fieldInfos)
{
IEnumerable <CustomAttributeData> attributes = fieldinfo.CustomAttributes;//.Where(type => type.AttributeType == typeof(EFRpcAutowiredAttribute));
///注解遍历
foreach (var ab in attributes)
{
//加载到EFRpcAutowiredAttribute注入并跳出循环
if (ab.AttributeType == typeof(EFRpcAutowiredAttribute))
{
EFRpcAutowiredAttribute autowiredAttribute = new EFRpcAutowiredAttribute();
//遍历注解信息
foreach (var kv in ab.NamedArguments)
{
if (kv.MemberName.Equals("version"))
{
autowiredAttribute.version = kv.TypedValue.Value.ToString();
}
else if (kv.MemberName.Equals("runMode"))
{
autowiredAttribute.runMode = kv.TypedValue.Value.ToString();
}
}
RabbitMQMsgProducerMap rabbitMQMsgProducer = mcf.getMsgMathsInfoMap().setOptions(mcf.opt);
rabbitMQMsgProducer.version = autowiredAttribute.version;
rabbitMQMsgProducer.GetClassInfo(Producers[i]);
rabbitMQMsgProducer.GetMathsInfoMulti(fieldinfo.FieldType);
//创建原对象
object obj = Activator.CreateInstance(Producers[i]);
//将代理对象注入到属性
fieldinfo.SetValue(obj, DynamicProxyFactory.createProxyByInterface(fieldinfo.FieldType, rabbitMQMsgProducer));
proxyObjectMap.put(Producers[i].Name, obj);
msgConsumerMaplist.Add(rabbitMQMsgProducer);
break;
}
}
}
}
return(this);
}
private static void LoggerDynamicProxyTest()
{
Console.WriteLine("-------LoggerDynamicProxyTest start-------");
DynamicProxyFactory <LoggerDynamicProxy> factory = new DynamicProxyFactory <LoggerDynamicProxy>(new DynamicInterfaceImplementor());
ILogin login = factory.CreateDynamicProxy <ILogin>();
login.LoginName = "test";
login.Password = "******";
login.TryLogin += login_TryLogin;
Console.WriteLine("-------LoggerDynamicProxyTest end-------");
Console.ReadLine();
}
public void CreateProxy()
{
var proxyFactory = new DynamicProxyFactory();
var service = proxyFactory.CreateProxy<IEchoService>(new ProxyOptions
{
EndpointUri = "localhost:3310",
ServiceKind = ServiceKind.Remote
}, new IInvokeFilter[0]);
var result = service.GetServerTime();
Assert.IsNull(result);
}
static void Main(string[] args)
{
var factory = new DynamicProxyFactory();
var evalAlgebra = new EvalAlg(factory);
var evalSubAlgebra = new EvalSubAlg(factory);
var printAlgebra = new PrintAlg(factory);
Console.WriteLine("The expression '{0}' returns: {1}", printAlgebra.Add(3, 4).Print(), evalAlgebra.Add(3, 4).Eval());
Console.ReadLine();
}
private void button1_Click(object sender, EventArgs e)
{
var serviceWsdlUri = "http://localhost.fc.local/FundConnect.Authentication.IisHost/Groups.svc?wsdl";
var factory = new DynamicProxyFactory(serviceWsdlUri);
var count = 0;
var myEndpoints = new List <string>( );
foreach (var endpoint in factory.Endpoints)
{
Console.WriteLine("Service Endpoint[{0}]", count);
Console.WriteLine("\tAddress = " + endpoint.Address);
Console.WriteLine("\tContract = " + endpoint.Contract.Name);
Console.WriteLine("\tBinding = " + endpoint.Binding.Name);
myEndpoints.Add(endpoint.Contract.Name);
}
foreach (var endpoint in myEndpoints)
{
var dp = factory.CreateProxy(endpoint);
var operations = factory.GetEndpoint(endpoint).Contract.Operations;
var proxyType = dp.ProxyType;
var mi = proxyType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
for (var i = 0; i < mi.Length; i++)
{
var name = mi[i].Name;
if (operations.FirstOrDefault(x => x.Name == name) != null)
{
var returnType = mi[i].ReturnType.ToString( );
Console.Write("Func: " + returnType + " " + name + "(");
var pi = mi[i].GetParameters( );
for (var j = 0; j < pi.Length; j++)
{
var param = pi[j].ParameterType.FullName + " " + pi[j].Name;
Console.Write((j > 0 ? "," : "") + param);
}
Console.WriteLine(")");
}
}
dp.Close( );
}
Console.ReadKey( );
}
private void ReloadFromService()
{
_dynamicProxyFactory = new DynamicProxyFactory(EvaluateExpression(cmbURL.Text.Trim(), _taskHost.VariableDispenser).ToString());
cmbServices.Items.Clear();
cmbMethods.Items.Clear();
grdParameters.Rows.Clear();
foreach (KeyValuePair <string, WebServiceMethods> service in
from contract in _dynamicProxyFactory.Contracts
from service in _dynamicProxyFactory.AvailableServices
where service.Key == contract.Name
select service)
{
cmbServices.Items.Add(new ComboBoxObjectComboItem(service.Value, service.Key));
}
}
public static void Test()
{
string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress));
host.AddServiceEndpoint(typeof(IService), new BasicHttpBinding(), "");
host.Description.Behaviors.Add(new ServiceMetadataBehavior { HttpGetEnabled = true });
host.Open();
Console.WriteLine("Host opened");
DynamicProxyFactory factory = new DynamicProxyFactory(baseAddress + "?wsdl");
DynamicProxy dynamicProxy = factory.CreateProxy("IService");
Console.WriteLine(dynamicProxy.CallMethod("GetData", 123));
Type proxyType = dynamicProxy.ProxyType;
MethodInfo getDataUsingDCMethod = proxyType.GetMethod("GetDataUsingDataContract");
Type dcType = getDataUsingDCMethod.GetParameters()[0].ParameterType;
DynamicObject obj = new DynamicObject(dcType);
obj.CallConstructor();
obj.SetProperty("BoolValue", true);
obj.SetProperty("StringValue", "Hello world");
DynamicObject result = new DynamicObject(
dynamicProxy.CallMethod(
"GetDataUsingDataContract",
obj.ObjectInstance));
Console.WriteLine(result.GetProperty("StringValue"));
Console.Write("Press ENTER to close the host");
Console.ReadLine();
host.Close();
}
private DynamicProxy GetSoapProxy(string serviceUri, string contract)
{
DynamicProxyFactory factory = null;
DynamicProxy proxy = null;
try
{
factory = new DynamicProxyFactory(serviceUri);
proxy = factory.CreateProxy(contract);
}
catch (Exception ex)
{
string errMsg = "Error creating Soap Proxy: " + ex.Message + "\n";
if (ex.InnerException != null)
errMsg += "Inner Exception = " + ex.InnerException.Message + "\n";
errMsg += "\nserviceUri: " + serviceUri;
errMsg += "\ncontract: " + contract;
m_log.WriteEntry(errMsg, EventLogEntryType.Error);
}
return proxy;
}
