private static AdresseClient CreateAdresseClient(string url)
{
var endpointAddress = new EndpointAddress(
new Uri(url),
AddressHeader.CreateAddressHeader("contract", "", "geonorge.Adresse.Adresse")
);
return(new AdresseClient(CreateBasicHttpBinding(), endpointAddress));
}
public void GetAddressHeaderReader()
{
var h = AddressHeader.CreateAddressHeader("foo", String.Empty, null);
var r = h.GetAddressHeaderReader();
r.MoveToContent();
Assert.AreEqual("foo", r.LocalName, "#1");
Assert.AreEqual("true", r.GetAttribute("nil", XmlSchema.InstanceNamespace), "#2");
}
static void Main(string[] args)
{
// Cria um novo client e define o responsável pelo tratamento do retorno
var soapClient = new ClientesCadastroSoapClient();
// Define os dados de autenticação
var builder = new EndpointAddressBuilder(soapClient.Endpoint.Address);
builder.Headers.Add(AddressHeader.CreateAddressHeader("app_key", "", omie_app_key));
builder.Headers.Add(AddressHeader.CreateAddressHeader("app_secret", "", omie_app_secret));
soapClient.Endpoint.Address = builder.ToEndpointAddress();
CBLog("Exemplo DotNet");
CBLog("");
CBLog(" 1 - Atualizar um cliente");
CBLog(" 2 - Listar clientes");
CBLog("");
CBLog(" Opção: ", false);
var a = Console.ReadKey();
CBLog("");
CBLog("");
if (a.KeyChar == '1')
{
// Upsert no cadastro de cliente
CBLog("Atualizando o cadastro do cliente... ", false);
var cliente = new clientes_cadastro
{
razao_social = "Omiexperience S/A",
cnpj_cpf = "18.511.742/0001-47",
cidade = "SAO PAULO (SP)",
estado = "SP",
codigo_cliente_integracao = "444"
};
// Executa a chamada
soapClient.UpsertClienteCompleted += OnSoapClientOnUpsertClienteCompleted;
soapClient.UpsertClienteAsync(cliente);
}
else if (a.KeyChar == '2')
{
CBLog("Listando clientes cadastrados... ");
var clientes_filtro = new clientes_list_request();
clientes_filtro.apenas_importado_api = "N";
clientes_filtro.pagina = "1";
clientes_filtro.registros_por_pagina = "3";
soapClient.ListarClientesCompleted += soapClient_ListarClientesCompleted;
soapClient.ListarClientesAsync(clientes_filtro);
}
Console.ReadKey();
}
private static TService HttpsCreate <TService>(string url, int TimeOut)
{
Uri uri = new Uri(url);
ServicePointManager.ServerCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback(CheckValidationResult);
WSHttpBinding binding = new System.ServiceModel.WSHttpBinding();
binding.SendTimeout = new TimeSpan(0, TimeOut / 60, TimeOut % 60);
binding.ReceiveTimeout = new TimeSpan(0, TimeOut / 60, TimeOut % 60);
#region 设置一些配置信息
binding.Security.Mode = SecurityMode.Transport;
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.None;
#endregion
System.ServiceModel.Web.WebOperationContext ctx = System.ServiceModel.Web.WebOperationContext.Current;
var token = ctx.IncomingRequest.Headers["token"].ToString();
AddressHeaderCollection addressHeaderColl;
if (!string.IsNullOrEmpty(token))
{
AddressHeader addressHeader1 = AddressHeader.CreateAddressHeader("token", "", token);
AddressHeader[] addressHeaders = new AddressHeader[] { addressHeader1 };
addressHeaderColl = new AddressHeaderCollection(addressHeaders);
}
else
{
addressHeaderColl = new AddressHeaderCollection();
}
//
//string[] cers = ZH.Security.Client.CertUtil.GetHostCertificate(uri);
//TODO 证书处理
string[] cers = "".Split('.');
var IdentityDns = EndpointIdentity.CreateDnsIdentity(cers[0]);
//
System.ServiceModel.EndpointAddress endpoint = new EndpointAddress(uri, IdentityDns, addressHeaderColl);
ChannelFactory <TService> channelfactory = new ChannelFactory <TService>(binding, endpoint);
foreach (OperationDescription op in channelfactory.Endpoint.Contract.Operations)
{
DataContractSerializerOperationBehavior dataContractBehavior = op.Behaviors.Find <DataContractSerializerOperationBehavior>() as DataContractSerializerOperationBehavior;
if (dataContractBehavior != null)
{
dataContractBehavior.MaxItemsInObjectGraph = int.MaxValue;
}
}
//
channelfactory.Credentials.ServiceCertificate.DefaultCertificate = new X509Certificate2(Convert.FromBase64String(cers[1])); // new X509Certificate2(x509certificate); \
//
//返回工厂创建
TService tservice = channelfactory.CreateChannel();
//
return(tservice);
}
public static void AddHeaders <T>(System.ServiceModel.ClientBase <T> client, string username, string password, string uygulamaKullaniciAdi) where T : class
{
EndpointAddressBuilder addressBuilder = new EndpointAddressBuilder(client.Endpoint.Address);
addressBuilder.Headers.Add(AddressHeader.CreateAddressHeader("KullaniciAdi", string.Empty, username));
addressBuilder.Headers.Add(AddressHeader.CreateAddressHeader("Parola", string.Empty, password));
addressBuilder.Headers.Add(AddressHeader.CreateAddressHeader("UygulamaKullaniciAdi", string.Empty, uygulamaKullaniciAdi));
client.Endpoint.Address = addressBuilder.ToEndpointAddress();
}
public void WriteAddressHeader()
{
var h = AddressHeader.CreateAddressHeader("foo", "urn:foo", null);
var sw = new StringWriter();
var xw = XmlDictionaryWriter.CreateDictionaryWriter(XmlWriter.Create(sw));
h.WriteAddressHeader(xw);
xw.Close();
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?><foo i:nil=\"true\" xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"urn:foo\" />", sw.ToString(), "#1");
}
// It should work, but MS implementation expects body to be
// IComparable.
public void EqualsTest()
{
AddressHeader h = AddressHeader.CreateAddressHeader(
"foo", "urn:foo", null);
AddressHeader h2 = AddressHeader.CreateAddressHeader(
"foo", "urn:foo", null);
Assert.IsFalse(h.Equals(null), "#1"); // never throw nullref
Assert.IsTrue(h.Equals(h2), "#2");
}
public static void Main()
{
// <Snippet0>
// <Snippet1>
// Name property
AddressHeader addressHeaderWithName = AddressHeader.CreateAddressHeader("MyServiceName", "http://localhost:8000/service", 1);
string addressHeaderName = addressHeaderWithName.Name;
// </Snippet1>
// <Snippet2>
//Put snippet here.
// Namespace property
AddressHeader addressHeaderWithNS = AddressHeader.CreateAddressHeader("MyServiceName", "http://localhost:8000/service", 1);
string addressHeaderNS = addressHeaderWithNS.Namespace;
// </Snippet2>
// <Snippet3>
// Obsolete
// </Snippet3>
// <Snippet4>
// Obsolete
// </Snippet4>
// <Snippet5>
// Create address headers for special services and add them to an array
AddressHeader addressHeader1 = AddressHeader.CreateAddressHeader("specialservice1", "http://localhost:8000/service", 1);
AddressHeader addressHeader2 = AddressHeader.CreateAddressHeader("specialservice2", "http://localhost:8000/service", 2);
AddressHeader[] addressHeaders = new AddressHeader[2] {
addressHeader1, addressHeader2
};
// Endpoint address constructor with URI and address headers
EndpointAddress endpointAddressWithHeaders = new EndpointAddress(
new Uri("http://localhost/silverlightsamples/service1"), addressHeaders
);
// Confirm adddressHeader1 is in endpointAddressWithHeaders - boolHeaders returns True.
AddressHeaderCollection addressHeaderCollection = endpointAddressWithHeaders.Headers;
bool boolHeaders = addressHeaderCollection.Contains(addressHeader1);
// </Snippet5>
// <Snippet10>
// <Snippet6>
//Create address headers with XmlObjectSerializer specified
XmlObjectSerializer serializer = new DataContractSerializer(typeof(int));
AddressHeader addressHeaderWithObjSer = AddressHeader.CreateAddressHeader("MyServiceName", "http://localhost:8000/service", 1, serializer);
int value = addressHeaderWithObjSer.GetValue <int>();
// </Snippet6>
// </Snippet10>
// </Snippet0>
}
public void Validate_Activity_ColorValidator()
{
IBodyArchitectAccessService service = CreateServiceProxy(AddressHeader.CreateAddressHeader("APIKey", "", "EB17BC2A-94FD-4E65-8751-15730F69E7F5"));
var sessionData = service.Login(ClientInformation, "test_user", "pwd".ToSHA1Hash());
var activity = new ActivityDTO();
activity.Name = "test";
activity.Color = "wrong";
service.SaveActivity(sessionData.Token, activity);
}
public void Validate_SaveScheduleEntryRangeParam_StartDayGreaterEndDay()
{
IBodyArchitectAccessService service = CreateServiceProxy(AddressHeader.CreateAddressHeader("APIKey", "", "EB17BC2A-94FD-4E65-8751-15730F69E7F5"));
var sessionData = service.Login(ClientInformation, "test_user", "pwd".ToSHA1Hash());
var param = new SaveScheduleEntryRangeParam();
param.StartDay = DateTime.UtcNow;
param.EndDay = DateTime.UtcNow.AddDays(-2);
service.SaveScheduleEntriesRange(sessionData.Token, param);
}
/// <summary>
/// Handles the operation of buying a selected book
/// </summary>
private void btnBuy_Click(object sender, EventArgs e)
{
// check if any book is selected for purchase
if (lstBooks.SelectedItem == null)
{
MessageBox.Show("No book selected for purchase", "BookStore Client");
}
else
{
// get the selected book ID
string selectedBookItem = lstBooks.SelectedItem.ToString();
int startPos = selectedBookItem.IndexOf('.') + 1;
int endPos = selectedBookItem.IndexOf(',');
string bookName = selectedBookItem.Substring(startPos, endPos - startPos);
bookName = bookName.Trim();
BuyBookClient myBuyBookClient = new BuyBookClient();
try
{
// Add the book name as a "resource" header to the endpoint address for the service
EndpointAddressBuilder myEndpointAddressBuilder = new EndpointAddressBuilder(myBuyBookClient.Endpoint.Address);
myEndpointAddressBuilder.Headers.Add(AddressHeader.CreateAddressHeader(Constants.BookNameHeaderName, Constants.BookNameHeaderNamespace, bookName));
myBuyBookClient.Endpoint.Address = myEndpointAddressBuilder.ToEndpointAddress();
// Send the request to the service. This will result in the following steps;
// 1. Request a security token from HomeRealmSTS authenticating using Windows credentials
// 2. Request a security token from BookStoreSTS authenticating using token from 1.
// 3. Send the BuyBook request to the BookStoreService authenticating using token from 2.
string response = myBuyBookClient.BuyBook("*****@*****.**", "One Microsoft Way, Redmond, WA 98052");
MessageBox.Show(response, "BookStore Client");
myBuyBookClient.Close();
}
catch (Exception ex)
{
myBuyBookClient.Abort();
// see if a fault has been sent back
FaultException inner = GetInnerException(ex) as FaultException;
if (inner != null)
{
MessageFault fault = inner.CreateMessageFault();
MessageBox.Show(String.Format("The server sent back a fault: {0}", fault.Reason.GetMatchingTranslation(CultureInfo.CurrentCulture).Text));
}
else
{
MessageBox.Show(String.Format("Exception while trying to purchase the selected book: {0}", ex), "BookStore Client");
}
}
}
}
/// <inheritdoc/>
public override bool SendMessage(Message message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (string.IsNullOrEmpty(Client.Address))
{
Logger.LogError("Error sending message to client via WEB.", $"The client '{Client.Name ?? Client.ID}' not specified address to send messages.", message);
return(false);
}
ChannelFactory <ICallbackSubscriber> channelFactory;
ICallbackSubscriber channel;
try
{
var endpointAddress = new EndpointAddress(new Uri(Client.Address), AddressHeader.CreateAddressHeader("headerName", Regex.Replace(Client.Address, ".asmx$", string.Empty), "headerValue"));
channelFactory = new ChannelFactory <ICallbackSubscriber>(new BasicHttpBinding(), endpointAddress);
channel = channelFactory.CreateChannel();
((IClientChannel)channel).Open();
}
catch (Exception exception)
{
Logger.LogUnhandledException(exception, message);
throw exception;
}
var sbMessage = new MessageFromESB()
{
MessageFormingTime = message.ReceivingTime,
MessageTypeID = message.MessageType.ID,
Body = message.Body,
Attachment = message.BinaryAttachment,
SenderName = message.Sender,
GroupID = message.Group,
Tags = ServiceHelper.GetTagDictionary(message),
};
return(ServiceHelper.TryWithExceptionLogging(
() => channel.AcceptMessage(sbMessage),
() =>
{
((IClientChannel)channel).Close();
channelFactory.Close();
},
$"Error sending message to the client '{Client.Name ?? Client.ID}' via WEB at address '{Client.Address}'.",
Client,
message,
Logger));
}
public void Validate_SaveCustomer_NullEmail()
{
IBodyArchitectAccessService service = CreateServiceProxy(AddressHeader.CreateAddressHeader("APIKey", "", "EB17BC2A-94FD-4E65-8751-15730F69E7F5"));
var sessionData = service.Login(ClientInformation, "test_user", "pwd".ToSHA1Hash());
var customerDto = new CustomerDTO();
customerDto.Gender = Gender.Male;
customerDto.FirstName = "name";
customerDto.Birthday = DateTime.UtcNow.AddYears(-20);
service.SaveCustomer(sessionData.Token, customerDto);
}
public Service(string baseUrl, string apiKey)
{
// Gets "FileManager" out of "IFileManagerService"
var name = typeof(T).Name.Substring(1).Replace("Service", "");
var url = baseUrl + "/" + name.ToLowerInvariant() + "/" + name + "Service";
var binding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);
// memoQ server requires "ApiKey" HTTP header for caller authentication
var header = AddressHeader.CreateAddressHeader("ApiKey", "", apiKey);
var address = new EndpointAddress(new Uri(url), header);
factory = new ChannelFactory <T>(binding, address);
proxy = factory.CreateChannel();
}
public void CycleDefinition_WithoutWeeks()
{
var definition = new SupplementCycleDefinitionDTO();
definition.Name = "test";
definition.Language = "en";
IBodyArchitectAccessService service = CreateServiceProxy(AddressHeader.CreateAddressHeader("APIKey", "", "EB17BC2A-94FD-4E65-8751-15730F69E7F5"));
var sessionData = service.Login(ClientInformation, "test_user", "pwd".ToSHA1Hash());
service.SaveSupplementsCycleDefinition(sessionData.Token, definition);
}
static void Main(string[] args)
{
Uri uri = new Uri("http://localhost:9876/calculatorservice");
var header = AddressHeader.CreateAddressHeader("UserName", "http://localhost:9876", "jqin");
EndpointAddress address = new EndpointAddress(uri, header);
using (var client = new ServiceReference1.CalculatorServiceClient(new WSHttpBinding(), address))
{
double result = client.Add(1D, 2D);
Console.WriteLine(result);
Console.ReadKey();
}
}
/// <summary>
/// Initializes the notification service client.
/// </summary>
private void InitializeClient(string addressText)
{
IPAddress ipAddress;
if (!IPAddress.TryParse(addressText, out ipAddress))
{
Messages.Text += "Invalid Machine Address entered.";
return;
}
var callbackClass = new NotificationServiceCallback();
callbackClass.NotificationReceived += OnNotificationReceived;
var notificationServiceBinding = new NetTcpBinding(SecurityMode.Message);
notificationServiceBinding.ReceiveTimeout = TimeSpan.FromSeconds(10);
notificationServiceBinding.SendTimeout = TimeSpan.FromSeconds(10);
AddressHeader header = AddressHeader.CreateAddressHeader("machine-connect", "hurco.com", "machine-connect");
EndpointAddressBuilder builder = new EndpointAddressBuilder(new EndpointAddress("net.tcp://" + ipAddress + "/NotificationService"));
builder.Headers.Add(header);
builder.Identity = EndpointIdentity.CreateDnsIdentity("machine-connect.hurco.com");
notificationServiceClient = new NotificationServiceClient(new InstanceContext(callbackClass), notificationServiceBinding, builder.ToEndpointAddress()); //create local service
ab = false;
if (notificationServiceClient.ClientCredentials == null)
{
Messages.Text += "Invalid client. Please try again.";
return;
}
////turn on security
notificationServiceBinding.Security.Mode = SecurityMode.Message;
notificationServiceBinding.Security.Message.ClientCredentialType = MessageCredentialType.UserName;
///turn on security
notificationServiceClient.ClientCredentials.UserName.UserName = "******"; // your VendorID (1234)
notificationServiceClient.ClientCredentials.UserName.Password = "******";
HeartbeatTimer = new Timer(PingWinmax, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));
try
{
notificationServiceClient.Open();
}
catch (Exception e)
{
Messages.Text += "Failed to Connect:\n" + e.Message + "\n" + e.StackTrace;
}
}
//</snippet17>
// Create EndpointAddress from Uri and Context
static public EndpointAddress CreateEndpointAddress(string uri, IDictionary <XmlQualifiedName, string> context)
{
EndpointAddress epr = null;
if (context != null && context.Count > 0)
{
AddressHeader contextHeader = AddressHeader.CreateAddressHeader(contextHeaderName, contextHeaderNamespace, new Dictionary <XmlQualifiedName, string>(context));
epr = new EndpointAddress(new Uri(uri), contextHeader);
}
else
{
epr = new EndpointAddress(uri);
}
return(epr);
}
public virtual EndpointAddress setDadosAutenticacao(EndpointAddress Adress)
{
EndpointAddressBuilder builder = new EndpointAddressBuilder(Adress);
string app_key = Parametro.GetParametro("app_key");
string app_secret = Parametro.GetParametro("app_secret");
builder.Headers.Add(AddressHeader.CreateAddressHeader("app_key", "", app_key)); // Coloque aqui a sua KEY de acesso
builder.Headers.Add(AddressHeader.CreateAddressHeader("app_secret", "", app_secret)); // Coloque aqui a SECRET de acesso
//builder.Headers.Add(AddressHeader.CreateAddressHeader("app_key", "", "1142656109")); // Coloque aqui a sua KEY de acesso
//builder.Headers.Add(AddressHeader.CreateAddressHeader("app_secret", "", "66b2a456a2c92eaf9646bc95587d47f0")); // Coloque aqui a SECRET de acesso
return(builder.ToEndpointAddress());
}
private void SetHeaders(string headerValue, bool closeExisting)
{
if (closeExisting)
{
client.Close();
client = new Proxy.Client();
}
var headers = new AddressHeader[]
{
AddressHeader.CreateAddressHeader("x-accesstoken", "", headerValue)
};
client.Endpoint.Address = new System.ServiceModel.EndpointAddress(client.Endpoint.Address.Uri, headers);
}
public static void SetupClientBase <T>(System.ServiceModel.ClientBase <T> client, HttpContext httpContext) where T : class
{
var guid = LoggingHelper.GetInstanceGUID(httpContext, () => new Guid()).GetValueOrDefault();
var sessionGUID = LoggingHelper.GetSessionGUID(httpContext, httpContext?.Handler as Page, () => new Guid()).GetValueOrDefault();
var pageGUID = LoggingHelper.GetPageGUID(httpContext, httpContext?.Handler as Page, () => new Guid()).GetValueOrDefault();
var bundleGUID = LoggingHelper.GetBundleGUID(httpContext, () => new Guid()).GetValueOrDefault();
var newLogElement = new LogElementDTO(
guid: guid,
sessionGUID: sessionGUID,
pageGUID: pageGUID,
bundleGUID: bundleGUID,
progressGUID: null,
unixTimestamp: TimeHelper.UnixTimestamp(),
logType: LogType.OnSetup,
element: $"SetupClientBase_{client.Endpoint.Address.Uri}", //LoggingHelper.StripUrlForLRAP(context.Request.RawUrl),
element2: null,
value: "", //SerializationHelper.Serialize(requestParams, SerializationType.Json),
times: 1,
unixTimestampEnd: null,
instanceTime: DateTime.Now,
stackTrace: null
);
var eab = new EndpointAddressBuilder(client.Endpoint.Address);
eab.Headers.Add(AddressHeader.CreateAddressHeader(Consts.GUIDTag,
string.Empty,
guid.ToString()));
eab.Headers.Add(AddressHeader.CreateAddressHeader(Consts.SessionGUIDTag,
string.Empty,
sessionGUID.ToString()));
eab.Headers.Add(AddressHeader.CreateAddressHeader(Consts.PageGUIDTag,
string.Empty,
pageGUID.ToString()));
eab.Headers.Add(AddressHeader.CreateAddressHeader(Consts.BundleGUIDTag,
string.Empty,
bundleGUID.ToString()));
eab.Headers.Add(AddressHeader.CreateAddressHeader(Consts.ServerGUIDTag,
string.Empty,
LoggingHelper.GetServerGUID(httpContext, () => new Guid()).GetValueOrDefault().ToString()));
client.Endpoint.Address = eab.ToEndpointAddress();
}
public void Validate_SaveScheduleEntryRangeParam_ActivityIdIsNull()
{
IBodyArchitectAccessService service = CreateServiceProxy(AddressHeader.CreateAddressHeader("APIKey", "", "EB17BC2A-94FD-4E65-8751-15730F69E7F5"));
var sessionData = service.Login(ClientInformation, "test_user", "pwd".ToSHA1Hash());
var param = new SaveScheduleEntryRangeParam();
param.StartDay = DateTime.UtcNow;
param.EndDay = DateTime.UtcNow.AddDays(2);
var dto = new ScheduleEntryDTO();
dto.StartTime = param.StartDay;
dto.EndTime = dto.StartTime + TimeSpan.FromHours(1);
param.Entries.Add(dto);
service.SaveScheduleEntriesRange(sessionData.Token, param);
}
static void Main(string[] args)
{
// <Snippet0>
// <Snippet3>
// <Snippet1>
EndpointAddressBuilder eab = new EndpointAddressBuilder();
// </Snippet1>
eab.Uri = new Uri("http://localhost/Uri");
eab.Headers.Add(AddressHeader.CreateAddressHeader("n", "ns", "val"));
// </Snippet3>
// <Snippet4>
eab.Identity = EndpointIdentity.CreateUpnIdentity("identity");
// </Snippet4>
// <Snippet5>
XmlDictionaryReader xdrExtensions = eab.GetReaderAtExtensions();
// </Snippet5>
// <Snippet6>
StringReader sr = new StringReader(@"<myExtension xmlns=""myExtNs"" />");
eab.SetExtensionReader(XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(sr)));
// </Snippet6>
// <Snippet7>
EndpointAddress ea = eab.ToEndpointAddress();
// </Snippet7>
// <Snippet8>
sr = new StringReader(@"<myMetadata xmlns=""myMetaNs"" />");
XmlDictionaryReader xdrMetaData = eab.GetReaderAtMetadata();
// </Snippet8>
// <Snippet9>
eab.SetMetadataReader(XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(sr)));
// </Snippet9>
// </Snippet0>
// <Snippet2>
EndpointAddress endpointAddress = new EndpointAddress("http://localhost/uri2");
EndpointAddressBuilder eab2 = new EndpointAddressBuilder(endpointAddress);
// </Snippet2>
}
static void Main(string[] args)
{
using (ChannelFactory <ICalculator> channelFactory = new ChannelFactory <ICalculator>("calculatorservice"))
{
ICalculator calculator = channelFactory.CreateChannel();
using (OperationContextScope contextScope = new OperationContextScope(calculator as IClientChannel))
{
string sn = "{DDA095DA-93CA-49EF-BE01-EF5B47179FD0}";
string ns = "http://www.artech.com/";
AddressHeader addressHeader = AddressHeader.CreateAddressHeader("sn", ns, sn);
MessageHeader messageHeader = addressHeader.ToMessageHeader();
OperationContext.Current.OutgoingMessageHeaders.Add(messageHeader);
Console.WriteLine("x + y = {2} when x = {0} and y = {1}", 1, 2, calculator.Add(1, 2));
}
}
Console.Read();
}
public static void SnippetReadFromVersionToString()
{
AddressHeader addressHeader1 = AddressHeader.CreateAddressHeader("specialservice1", "http://localhost:8000/service", 1);
AddressHeader addressHeader2 = AddressHeader.CreateAddressHeader("specialservice2", "http://localhost:8000/service", 2);
AddressHeader[] addressHeaders = new AddressHeader[2] {
addressHeader1, addressHeader2
};
AddressHeaderCollection headers = new AddressHeaderCollection(addressHeaders);
EndpointAddress endpointAddress = new EndpointAddress(
new Uri("http://localhost:8003/servicemodelsamples/service/incode/identity"), addressHeaders);
// <Snippet27>
string URIstring = endpointAddress.ToString();
// </Snippet27>
}
private static EndpointAddress ReadFrom(System.ServiceModel.Channels.AddressingVersion addressingVersion, XmlReader xreader)
{
string xml = xreader.ReadOuterXml();
StringReader sreader = new StringReader(xml);
XmlReader reader = XmlReader.Create(sreader);
Uri uri = null;
EndpointIdentity identity = null;
reader.MoveToContent();
List <AddressHeader> header = new List <AddressHeader> ();
while (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
{
if (reader.LocalName == "EndpointReference")
{
reader.Read();
}
else if (reader.LocalName == "Address" &&
reader.NodeType == XmlNodeType.Element &&
!reader.IsEmptyElement)
{
uri = new Uri(reader.ReadElementContentAsString());
}
else if (reader.LocalName == "Identity" &&
reader.NodeType == XmlNodeType.Element &&
!reader.IsEmptyElement)
{
//How can key re-empact Identity
identity = new X509CertificateEndpointIdentity(new System.Security.Cryptography.X509Certificates.X509Certificate2("powershell.pfx", "mono"));
break;
}
else
{
var headerName = reader.LocalName;
var headerNamespace = reader.NamespaceURI;
reader.MoveToContent();
reader.ReadStartElement();
var obj = reader.ReadElementContentAs(GetTypeFromLocalName(reader.LocalName), new XmlNamespaceManager(reader.NameTable));
header.Add(AddressHeader.CreateAddressHeader(headerName, headerNamespace, obj));
reader.MoveToContent();
reader.ReadEndElement();
}
}
return(identity == null ? new EndpointAddress(uri, header.ToArray()) : new EndpointAddress(uri, identity, header.ToArray()));
}
public void WriteAddressHeaderTest()
{
AddressHeader h = AddressHeader.CreateAddressHeader(1);
StringWriter sw = new StringWriter();
XmlWriterSettings s = new XmlWriterSettings();
s.OmitXmlDeclaration = true;
XmlWriter w = XmlWriter.Create(sw, s);
h.WriteAddressHeader(w);
w.Close();
Assert.AreEqual(
@"<int xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">1</int>",
sw.ToString());
}
static void WithHeader()
{
AddressHeader header = AddressHeader.CreateAddressHeader("UserType", "http://www.aaa.com", "Licensed User");
EndpointAddress address = new EndpointAddress(new Uri("http://127.0.0.1:23232/myservices/calculatorservice"), header);
//EndpointAddress address = new EndpointAddress(new Uri("http://127.0.0.1:23232/myservices/calculatorservice"));
Binding httpBinding = new WS2007HttpBinding();
ContractDescription contract = ContractDescription.GetContract(typeof(ICalculator));
ServiceEndpoint endPoint = new ServiceEndpoint(contract, httpBinding, address);
using (ChannelFactory <ICalculator> channelFactory = new ChannelFactory <ICalculator>(endPoint))
{
ICalculator proxy = channelFactory.CreateChannel();
Console.WriteLine("x + y = {2} when x = {0} and y = {1}", 1, 2, proxy.Add(1, 2));
Console.WriteLine("x - y = {2} when x = {0} and y = {1}", 1, 2, proxy.Substract(1, 2));
Console.WriteLine("x * y = {2} when x = {0} and y = {1}", 1, 2, proxy.Multiply(1, 2));
Console.WriteLine("x / y = {2} when x = {0} and y = {1}", 1, 2, proxy.Divide(1, 2));
}
}
public static void Snippet4()
{
AddressHeader addressHeader1 = AddressHeader.CreateAddressHeader("specialservice1", "http://localhost:8000/service", 1);
AddressHeader addressHeader2 = AddressHeader.CreateAddressHeader("specialservice2", "http://localhost:8000/service", 2);
AddressHeader[] addressHeaders = new AddressHeader[2] {
addressHeader1, addressHeader2
};
EndpointIdentity endpointIdentity = EndpointIdentity.CreateUpnIdentity(WindowsIdentity.GetCurrent().Name);
EndpointAddress endpointAddress = new EndpointAddress(
new Uri("http://localhost:8003/servicemodelsamples/service/incode/identity"), endpointIdentity, addressHeaders);
// <Snippet4>
Message msg = Message.CreateMessage(MessageVersion.Soap11, "urn:action");
endpointAddress.ApplyTo(msg);
// </Snippet4>
}
/// <summary>
/// Gets URL upon calling which the required study data can be retrieved.
/// </summary>
/// <param name="studyUIDs">List of UIDs for the studies to be retrieved</param>
/// <param name="endPointUrl">URL of the NBIA Data Service to query. This is NOT the Data Transfer URL!</param>
/// <returns>URL that returns zip file with the studies</returns>
public string retrieveStudyURL(string[] studyUIDs, string endPointUrl)
{
TransferServiceContextService.DataTransferDescriptor dtd;
using (NCIACoreServicePortTypeClient proxy = new NCIACoreServicePortTypeClient("NCIACoreServicePortTypePort", endPointUrl))
{
try
{
TransferServiceContextReference tras = proxy.retrieveDicomDataByStudyUIDs(studyUIDs); // new TransferServiceContextReference();
EndpointReferenceType endPoint = tras.EndpointReference; // new EndpointReferenceType();
AddressHeader[] ah = new AddressHeader[endPoint.ReferenceProperties.Any.Length];
for (int lcv = 0; lcv < ah.Length; lcv++)
{
XmlElement refProp = endPoint.ReferenceProperties.Any[lcv];
ah[lcv] = AddressHeader.CreateAddressHeader(refProp.LocalName, refProp.NamespaceURI, refProp.InnerText);
}
EndpointAddress ea = new EndpointAddress(new Uri(endPoint.Address.Value), ah);
// create binding by hand so we don't have to associate a config file with a dll
BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.None);
binding.Name = "TransferServiceContextPortTypePort";
TransferServiceContextPortTypeClient transProxy = new TransferServiceContextPortTypeClient(binding, ea);
dtd = transProxy.getDataTransferDescriptor();
}
catch (System.Net.WebException ex)
{
System.Console.WriteLine(ex.Message); //never gets here
throw new GridServicerException("Error querying NCIA Grid", ex);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message); //never gets here
throw new GridServicerException("Error retrieving from NCIA Grid", e);
}
}
if (string.IsNullOrEmpty(dtd.url))
{
return(dtd.url);
}
else
{
return(null);
}
}