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 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 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();
}
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 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);
}
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 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);
}
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( );
}
public void Test1()
{
var obj1 = DynamicProxyFactory.CreateProxy <IUser>(new Saller(), null);
obj1.property2 = -9;
Assert.Equal(-9, obj1.property2);
obj1.Eat(new Rice());
var obj2 = DynamicProxyFactory.CreateProxyType(typeof(IUser), typeof(Supplier), null).ProxyType.GetConstructor(Type.EmptyTypes).Invoke(null);
var resolver = IocContainer.Instance.Resolve <IIocResolver>();
var user1 = resolver.Resolve <IUser>();
var val1 = user1.method2();
var val2 = user1.property1;
user1.property2 = -9;
Assert.Equal(-9, user1.property2);
user1.Eat(new Rice());
}
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();
}
public IOutputDescription ExecuteWebService(WcfService src)
{
var source = (WcfSource)src.Source;
var factory = new DynamicProxyFactory(source.EndpointUrl);
var contract = factory.Contracts.FirstOrDefault();
if (contract == null)
{
throw new DynamicProxyException(ErrorResource.NoContractFound);
}
var proxy = factory.CreateProxy(contract.Name);
var parameters = src.Method.Parameters?.Select(a => new MethodParameter {
Name = a.Name, Value = a.Value, TypeName = a.TypeName
})
.ToList() ?? new List <MethodParameter>();
var paramObjects =
parameters.Select(methodParameter => Convert.ChangeType(methodParameter.Value, Type.GetType(methodParameter.TypeName))).ToArray();
var result = proxy.CallMethod(src.Method.Name, paramObjects);
var dataBrowser = DataBrowserFactory.CreateDataBrowser();
var dataSourceShape = DataSourceShapeFactory.CreateDataSourceShape();
var method = GetMethod(src.Method.Name, proxy);
if (result != null)
{
result = AdjustPluginResult(result, method);
var tmpData = dataBrowser.Map(result);
dataSourceShape.Paths.AddRange(tmpData);
}
var output = OutputDescriptionFactory.CreateOutputDescription(OutputFormats.ShapedXML);
output.DataSourceShapes.Add(dataSourceShape);
return(output);
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="jobUrl">任务地址</param>
/// <param name="serviceName">服务名称</param>
/// <param name="methodName">方法名</param>
/// <param name="valus">值集</param>
/// <param name="internval">间隔时间</param>
/// <param name="effectHour">生效时间</param>
/// <param name="expireHour">失效时间</param>
/// <param name="name">任务名称</param>
public JobAgent(string jobUrl, string serviceName, string methodName, string valus, int internval, int effectHour, int expireHour, string name)
{
Id = Guid.NewGuid();
var factory = new DynamicProxyFactory(jobUrl);
dynamicProxy = factory.CreateProxy(serviceName);
timer = new System.Timers.Timer(internval);
this.effectHour = effectHour;
this.expireHour = expireHour;
Name = name;
this.serviceName = serviceName;
this.valus = valus;
jobAgentContract = new JobAgentContract(methodName, valus.Split(','));
timerHandler = this.timer_Elapsed;
foreach (ServiceEndpoint endpoint in factory.Endpoints)
{
Console.WriteLine("Service Endpoint={0}", endpoint.Name);
Console.WriteLine("\tAddress = " + endpoint.Address);
Console.WriteLine("\tContract = " + endpoint.Contract.Name);
Console.WriteLine("\tBinding = " + endpoint.Binding.Name);
}
}
public object ExcecuteMethod(IWcfAction action, string endpointUrl)
{
var factory = new DynamicProxyFactory(endpointUrl);
var contract = factory.Contracts.FirstOrDefault();
if (contract == null)
{
throw new DynamicProxyException(ErrorResource.NoContractFound);
}
var proxy = factory.CreateProxy(contract.Name);
var parameters = action.Inputs?.Select(
a =>
new MethodParameter
{
EmptyToNull = a.EmptyIsNull,
IsRequired = a.RequiredField,
Name = a.Name,
Value = a.Value,
TypeName = a.TypeName
}).ToList() ?? new List <MethodParameter>();
var paramObjects =
parameters.Select(methodParameter => Convert.ChangeType(methodParameter.Value, Type.GetType(methodParameter.TypeName))).ToArray();
var result = proxy.CallMethod(action.Method, paramObjects);
var method = GetMethod(action.Method, proxy);
if (result != null)
{
result = AdjustPluginResult(result, method);
}
return(result);
}
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;
}
/// <summary>
/// Se encarga de invocar un metodo de un webservice
/// </summary>
/// <param name="strMetodo"></param>
/// <param name="objParametros"></param>
/// <returns></returns>
private object InvocarWebService(string strMetodo, object[] objParametros)
{
var objRetorno = new object();
try
{
//Crear Factory
DynamicProxyFactory factory = new DynamicProxyFactory(this.strUrl, this.strUsuario, this.strPassword);
//Crear Bindings
switch (factory.Bindings.ElementAt(0).GetType().Name)
{
case "WSHttpBinding":
WSHttpBinding bdWS = (WSHttpBinding)factory.Bindings.ElementAt(0);
if (bdWS.Scheme.ToLower().Equals("http"))
{
bdWS.Security.Mode = SecurityMode.None;
bdWS.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
}
else
{
bdWS.Security.Mode = SecurityMode.Transport;
bdWS.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
}
break;
case "BasicHttpBinding":
BasicHttpBinding bdBasic = (BasicHttpBinding)factory.Bindings.ElementAt(0);
if (bdBasic.Scheme.ToLower().Equals("http"))
{
bdBasic.Security.Mode = BasicHttpSecurityMode.None;
bdBasic.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
}
else
{
bdBasic.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
bdBasic.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
}
break;
}
string strContratoWebService = string.Empty;
foreach (ContractDescription contract in factory.Contracts)
{
strContratoWebService = contract.Name;
break;
}
//Crear Proxy
DynamicProxy proxyAutenticacion = factory.CreateProxy(strContratoWebService);
//Asignar credenciales de acceso al servicio web
ClientCredentials credentials = proxyAutenticacion.GetProperty("ClientCredentials") as ClientCredentials;
credentials.UserName.UserName = this.strUsuario;
credentials.UserName.Password = this.strPassword;
//Retornar dato por parte del servicio web
objRetorno = proxyAutenticacion.CallMethod <object>(strMetodo, objParametros);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex.InnerException);
}
return(objRetorno);
}
/// <summary>
/// This method is a run-time method executed dtsexec.exe
/// </summary>
/// <param name="connections"></param>
/// <param name="variableDispenser"></param>
/// <param name="componentEvents"></param>
/// <param name="log"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public override DTSExecResult Execute(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log, object transaction)
{
bool refire = false;
componentEvents.FireInformation(0,
"SSISWCFTask",
"Prepare variables",
string.Empty,
0,
ref refire);
GetNeededVariables(variableDispenser, componentEvents);
try
{
componentEvents.FireInformation(0,
"SSISWCFTask",
string.Format("Initialize the WCF Service: {0}", EvaluateExpression(ServiceUrl, variableDispenser)),
string.Empty,
0,
ref refire);
var dynamicProxyFactory = new DynamicProxyFactory(EvaluateExpression(ServiceUrl, variableDispenser).ToString());
int count = 0;
foreach (ServiceEndpoint endpoint in dynamicProxyFactory.Endpoints.Where(endPoint => endPoint.Contract.Name == EvaluateExpression(ServiceContract, variableDispenser).ToString()))
{
componentEvents.FireInformation(0, "SSISWCFTask", string.Format("Service Endpoint[{0}]", count++), string.Empty, 0, ref refire);
componentEvents.FireInformation(0, "SSISWCFTask", string.Format("Address: {0}", endpoint.Address), string.Empty, 0, ref refire);
componentEvents.FireInformation(0, "SSISWCFTask", string.Format("Contract: {0}", endpoint.Contract.Name), string.Empty, 0, ref refire);
componentEvents.FireInformation(0, "SSISWCFTask", string.Format("Binding: {0}", endpoint.Binding.Name), string.Empty, 0, ref refire);
}
componentEvents.FireInformation(0,
"SSISWCFTask",
string.Format("InvokeRemoteMethod: {0} => {1}",
EvaluateExpression(ServiceContract, variableDispenser),
EvaluateExpression(OperationContract, variableDispenser)),
string.Empty,
0,
ref refire);
componentEvents.FireInformation(0, "SSISWCFTask", string.Format("Creating DynamicProxy to {0} ServiceContract", EvaluateExpression(ServiceContract, variableDispenser)), string.Empty, 0, ref refire);
DynamicProxy dynamicProxy = dynamicProxyFactory.CreateProxy(EvaluateExpression(ServiceContract, variableDispenser).ToString());
if (dynamicProxy == null)
{
throw new Exception("Cannot create the proxy");
}
object result = null;
componentEvents.FireInformation(0, "SSISWCFTask", "Creating the Client Channel", string.Empty, 0, ref refire);
using (IClientChannel innerChannel = dynamicProxy.GetProperty("InnerChannel") as IClientChannel)
{
if (innerChannel != null)
{
using (new OperationContextScope(innerChannel))
{
componentEvents.FireInformation(0, "SSISWCFTask", "Creating the Message Header", string.Empty, 0, ref refire);
OperationContext.Current.OutgoingMessageHeaders.Add(MessageHeader.CreateHeader("SSISDynamicWCF", "", Guid.NewGuid().ToString()));
componentEvents.FireInformation(0, "SSISWCFTask", "The used headers:", string.Empty, 0, ref refire);
foreach (var header in ((MappingHeaders)MappingHeaders))
{
var headerValue = Convert.ChangeType(EvaluateExpression(header.Value, variableDispenser).ToString(), Type.GetType(header.Type));
componentEvents.FireInformation(0, "SSISWCFTask",
string.Format("Name: {0} | Type: {1} | Value: {2}",
header.Name,
header.Type,
headerValue),
string.Empty, 0, ref refire);
OperationContext.Current.OutgoingMessageHeaders.Add(MessageHeader.CreateHeader(header.Name, "", headerValue));
}
componentEvents.FireInformation(0, "SSISWCFTask", "The used params:", string.Empty, 0, ref refire);
foreach (var param in ((MappingParams)MappingParams))
{
componentEvents.FireInformation(0, "SSISWCFTask",
string.Format("Name: {0} | Type: {1} | Value: {2}",
param.Name,
param.Type,
Convert.ChangeType(EvaluateExpression(param.Value, variableDispenser).ToString(), Type.GetType(param.Type))),
string.Empty, 0, ref refire);
}
componentEvents.FireInformation(0, "SSISWCFTask", string.Format("Call [{0}] OperationContract with parameters:", EvaluateExpression(OperationContract, variableDispenser)), string.Empty, 0, ref refire);
int countParam = ((MappingParams)MappingParams).Count;
var objParams = new object[countParam];
for (int i = 0; i < countParam; i++)
{
objParams[i] = Convert.ChangeType(EvaluateExpression(((MappingParams)MappingParams)[i].Value, variableDispenser).ToString(), Type.GetType(((MappingParams)MappingParams)[i].Type));
}
result = dynamicProxy.CallMethod(EvaluateExpression(OperationContract, variableDispenser).ToString(), objParams);
//new object[]
// {
// (from parameters in ((MappingParams)MappingParams)
// select Convert.ChangeType(EvaluateExpression(parameters.Value, variableDispenser).ToString(), Type.GetType(parameters.Type))).ToArray()
// });
}
}
else
{
componentEvents.FireInformation(0, "SSISWCFTask", "Cannot create the Inner Channel", string.Empty, 0, ref refire);
throw new Exception("Cannot Create the Inner Channel");
}
}
if (result != null)
{
if (IsValueReturned == Keys.TRUE)
{
componentEvents.FireInformation(0,
"SSISWCFTask",
string.Format("Get the Returned Value to: {0}", ReturnedValue),
string.Empty,
0,
ref refire);
string val = ReturnedValue.Split(new[] { "::" }, StringSplitOptions.RemoveEmptyEntries)[1].Trim();
componentEvents.FireInformation(0,
"SSISWCFTask",
string.Format("Get the Returned Value to {0} and convert to {1}",
val.Substring(0, val.Length - 1),
_vars[val.Substring(0, val.Length - 1)].DataType),
string.Empty,
0,
ref refire);
_vars[val.Substring(0, val.Length - 1)].Value = Convert.ChangeType(result, _vars[val.Substring(0, val.Length - 1)].DataType);
componentEvents.FireInformation(0,
"SSISWCFTask",
string.Format("The String Result is {0} ",
_vars[val.Substring(0, val.Length - 1)].Value),
string.Empty,
0,
ref refire);
}
else
{
componentEvents.FireInformation(0,
"SSISWCFTask",
"Execution without return or no associated return variable",
string.Empty,
0,
ref refire);
}
}
}
catch (Exception ex)
{
componentEvents.FireError(0,
"SSISWCFTask",
string.Format("Problem: {0}",
ex.Message + "\n" + ex.StackTrace),
"",
0);
}
finally
{
if (_vars.Locked)
{
_vars.Unlock();
}
}
return(base.Execute(connections, variableDispenser, componentEvents, log, transaction));
}
