protected async Task ConnectAsyncCore(CancellationToken cancellationToken)
{
try
{
await OnConnectAsync(cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
System.Diagnostics.Debug.Assert(_connectedStream != null, "Connected stream must be not null here!");
if (_connectionSettings.UseBufferedStream)
{
//_sendingStream = new NetworkWriteStream(new BufferedStream(_connectedStream));
//_receivingStream = new NetworkReadStream(new BufferedStream(_connectedStream));
_sendingStream = new BufferedStream(_connectedStream);
_receivingStream = new BufferedStream(_connectedStream);
}
else
{
//_sendingStream = new NetworkWriteStream(_connectedStream);
//_receivingStream = new NetworkReadStream(_connectedStream);
_sendingStream = _connectedStream;
_receivingStream = _connectedStream;
}
ServiceRef.Call(this, async() =>
{
if (State == ConnectionState.Connecting ||
State == ConnectionState.LinkError)
{
//await SetStateAsync(ConnectionTrigger.Connected).ConfigureAwait(false);
SetState(ConnectionTrigger.Connected);
await RunConnection();
}
});
}
catch (OperationCanceledException)
{
}
#if DEBUG
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine($"{GetType()}{Environment.NewLine}{ex}");
#else
catch (Exception)
{
#endif
ServiceRef.Call(this, () =>
{
if (State == ConnectionState.Connecting)
{
SetState(ConnectionTrigger.LinkError);
}
});
}
finally
{
}
}
public async Task TestImageServiceAsync()
{
var imageService = ServiceRef.Create <IImageService>(new ImageServiceAsync());
//await imageService.GetOrDownloadAsync("https://myimage");
//Assert.AreEqual(1, imageService.Images.Count);
//Assert.AreEqual("https://myimage", imageService.Images[0].Url);
//Assert.IsTrue(imageService.Images[0].Data.Length > 0);
var callTracer = new SimpleCallMonitorTracer();
ActionQueue.BeginMonitor(callTracer);
try
{
await imageService.GetOrDownloadAsync("https://myimage");
Assert.AreEqual(1, imageService.Images.Count);
}
finally
{
ActionQueue.ExitMonitor(callTracer);
}
}
OnBrowseReply
(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String name,
String type,
String domain)
{
if (errorCode == ErrorCode.NoError)
{
PeerData peer = new PeerData();
peer.InterfaceIndex = interfaceIndex;
peer.Name = name;
peer.Type = type;
peer.Domain = domain;
peer.Address = null;
if ((flags & ServiceFlags.Add) != 0)
{
Invoke(addPeerCallback, new Object[] { peer });
}
else if ((flags == 0) || ((flags & ServiceFlags.MoreComing) != 0))
{
Invoke(removePeerCallback, new Object[] { peer });
}
}
else
{
MessageBox.Show("OnBrowseReply returned an error code " + errorCode, "Error");
}
}
//
// called when the type field changes
//
private void typeBox_SelectedIndexChanged(object sender, System.EventArgs e)
{
browseList.Items.Clear();
if (browser != null)
{
browser.Dispose();
}
nameField.Text = "";
typeField.Text = "";
domainField.Text = "";
hostField.Text = "";
portField.Text = "";
serviceTextField.Items.Clear();
try
{
browser = DNSService.Browse(0, 0, typeBox.SelectedItem.ToString(), null, new DNSService.BrowseReply(OnBrowseReply));
}
catch
{
MessageBox.Show("Browse Failed", "Error");
Application.Exit();
}
}
OnQueryRecordReply
(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String fullName,
int rrtype,
int rrclass,
Byte[] rdata,
int ttl
)
{
if (errorCode == ErrorCode.NoError)
{
uint bits = BitConverter.ToUInt32(rdata, 0);
System.Net.IPAddress data = new System.Net.IPAddress(bits);
Invoke(resolveAddressCallback, new Object[] { data });
}
else
{
MessageBox.Show("OnQueryRecordReply returned an error code: " + errorCode, "Error");
}
}
private void OnResolveReply
(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String fullName,
String hostName,
int port,
Byte[] txtRecord
)
{
if (errorCode == ErrorCode.NoError)
{
ResolveData data = new ResolveData();
data.InterfaceIndex = interfaceIndex;
data.FullName = fullName;
data.HostName = hostName;
data.Port = port;
data.TxtRecord = txtRecord;
Invoke(resolveServiceCallback, new Object[] { data });
}
else
{
MessageBox.Show("OnResolveReply returned an error code: " + errorCode, "Error");
}
}
public async Task <bool> SaveInfoInRepository(string repositoryAlias, string subjet, string message, int?folderNumber)
{
ServiceRef serviceRef = GetServiceRef(repositoryAlias);
NoteDto note = (await serviceRef.Service.Notes.NewAsync()).Entity;
note.Topic = subjet;
note.Description = message;
if (folderNumber == null)
{
note.FolderId = (await serviceRef.Service.Folders.GetHomeAsync()).Entity.FolderId;
}
else
{
var folder = (await serviceRef.Service.Folders.GetAsync((int)folderNumber)).Entity;
if (folder != null)
{
note.FolderId = folder.FolderId;
}
else
{
throw new Exception("Invalid parameter.");
}
}
var res = (await serviceRef.Service.Notes.SaveAsync(note)).IsValid;
return(res);
}
//
// OnBrowseReply
//
// This call is invoked by the DNSService core. It is
// executed in the context of a worker thread, not the
// main (GUI) thread. We create a BrowseData object
// and invoked the appropriate method in the GUI thread
// so we can update the UI
//
private void OnBrowseReply
(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String name,
String type,
String domain
)
{
if (errorCode == ErrorCode.NoError)
{
BrowseData data = new BrowseData();
data.InterfaceIndex = interfaceIndex;
data.Name = name;
data.Type = type;
data.Domain = domain;
if ((flags & ServiceFlags.Add) != 0)
{
Invoke(addServiceCallback, new Object[] { data });
}
else if ((flags == 0) || ((flags & ServiceFlags.MoreComing) != 0))
{
Invoke(removeServiceCallback, new Object[] { data });
}
}
else
{
MessageBox.Show("OnBrowseReply returned an error code: " + errorCode, "Error");
}
}
public async Task TestImageServiceAsync()
{
var wrappedImageService = new ImageServiceAsync();
var imageService = ServiceRef.Create <IImageService>(wrappedImageService);
Assert.IsTrue(ServiceRef.TryGetWrappedObject <ImageServiceAsync>(imageService, out var returnedWrappedObject));
Assert.AreSame(wrappedImageService, returnedWrappedObject);
//await imageService.GetOrDownloadAsync("https://myimage");
//Assert.AreEqual(1, imageService.Images.Count);
//Assert.AreEqual("https://myimage", imageService.Images[0].Url);
//Assert.IsTrue(imageService.Images[0].Data.Length > 0);
var callTracer = new SimpleCallMonitorTracer();
ActionQueue.BeginMonitor(callTracer);
try
{
await imageService.GetOrDownloadAsync("https://myimage");
Assert.AreEqual(1, imageService.Images.Count);
}
finally
{
ActionQueue.ExitMonitor(callTracer);
}
}
public void TestImageServiceAsyncMultiple()
{
var imageService = ServiceRef.Create <IImageService>(new ImageServiceAsync());
var callTracer = new SimpleCallMonitorTracer();
ActionQueue.BeginMonitor(callTracer);
try
{
Task.WaitAll(
Enumerable
.Range(1, 5)
.Select(i => Task.Factory.StartNew(async() =>
{
await imageService.GetOrDownloadAsync("https://myimage" + i);
}))
.ToArray());
Assert.AreEqual(5, imageService.Images.Count);
}
finally
{
ActionQueue.ExitMonitor(callTracer);
}
}
public Task GetOrDownloadAsync(string url)
{
//simulate image download
IPendingOperation pendingOperation = null;
Console.WriteLine($"Downloading {url}");
Task.Delay(2000).ContinueWith(_ =>
{
Console.WriteLine($"Downloaded {url}");
pendingOperation.Complete();
});
pendingOperation = ServiceRef.RegisterPendingOperation(this, actionOnCompletion: (res) =>
{
//Accessing _images here would be risky, just wrap the call...
ServiceRef.Call(this, () =>
{
Console.WriteLine($"Adding to images {url}");
_images.Add(new ImageStuff()
{
Url = url, Data = new byte[] { 0x01 }
});
Console.WriteLine($"Added to images {url}");
});
});
return(Task.CompletedTask);
}
private void Form1_Load(object sender, EventArgs e)
{
IPEndPoint localEP = new IPEndPoint(System.Net.IPAddress.Any, 0);
//
// create the socket and bind to INADDR_ANY
//
socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socket.Bind(localEP);
localEP = (IPEndPoint)socket.LocalEndPoint;
//
// start asynchronous read
//
SocketStateObject so = new SocketStateObject(socket);
socket.BeginReceive(so.m_buffer, 0, SocketStateObject.BUFFER_SIZE, 0, new AsyncCallback(this.OnReadSocket), so);
try
{
//
// start the register and browse operations
//
registrar = DNSService.Register(0, 0, System.Environment.UserName, "_p2pchat._udp", null, null, localEP.Port, null, new DNSService.RegisterReply(OnRegisterReply));
browser = DNSService.Browse(0, 0, "_p2pchat._udp", null, new DNSService.BrowseReply(OnBrowseReply));
}
catch
{
MessageBox.Show("DNSServices Not Available", "Error");
Application.Exit();
}
}
protected internal virtual ServiceRef CreateServiceRef(IOrchestrationBinding orchestrationBinding)
{
// see https://msdn.microsoft.com/en-us/library/microsoft.biztalk.deployment.binding.serviceref.aspx
var serviceRef = new ServiceRef {
Description = orchestrationBinding.Description,
// TODO EndpointInfo =
Host = new HostRef {
Name = orchestrationBinding.Host,
// TODO NTGroupName = "",
// TODO Trusted = false,
// TODO Type = (int) HostType.InProcess
},
Name = orchestrationBinding.Type.FullName,
// TODO allow to change State
State = ServiceRef.ServiceRefState.Enlisted,
// TODO allow to change TackingOption
TrackingOption = OrchestrationTrackingTypes.None
};
// ensure service ref port collection is initialized even if there are only direct ports
var serviceRefPorts = serviceRef.Ports;
foreach (var portBinding in orchestrationBinding.PortBindings)
{
serviceRefPorts.Add(CreateServicePortRef(portBinding));
}
// TODO Roles =
return(serviceRef);
}
public async Task TestImageServiceWithPendingOperation()
{
var imageService = ServiceRef.Create <IImageService>(new ImageServiceWithPendingOperation());
await imageService.GetOrDownloadAsync("https://myimage");
Assert.AreEqual(1, imageService.Images.Count);
Assert.AreEqual("https://myimage", imageService.Images[0].Url);
Assert.IsTrue(imageService.Images[0].Data.Length > 0);
}
public async Task TestPendingOperationsAsyncVersion()
{
var pendingOpsTestService = ServiceRef.Create <IPendingOpsServiceAsync>(new PendingOpsServiceAsync());
Assert.IsFalse(pendingOpsTestService.OperationCompleted);
await pendingOpsTestService.BeginOperationAsync();
Assert.IsTrue(pendingOpsTestService.OperationCompleted);
}
public void TestPendingOperations()
{
var pendingOpsTestService = ServiceRef.Create <IPendingOpsService>(new PendingOpsService());
Assert.IsFalse(pendingOpsTestService.OperationCompleted);
pendingOpsTestService.BeginOperation();
Assert.IsTrue(pendingOpsTestService.OperationCompleted);
}
//
// OnResolveService
//
// This method is "Invoked" by OnResolveReply. This call
// executes in the context of the main thread
//
private void OnResolveService
(
ResolveData data
)
{
resolver.Dispose();
resolver = null;
Populate((BrowseData)browseList.SelectedItem, data);
}
public NoteDto GetNoteByNum(string repositoryAlias, int noteNumber)
{
ServiceRef serviceRef = GetServiceRef(repositoryAlias);
Task <Result <NoteDto> > task = serviceRef.Service.Notes.GetAsync(noteNumber);
task.Wait();
Result <NoteDto> result = task.Result;
return(result.Entity);
}
public void TestPendingOperationsT()
{
var pendingOpsTestService = ServiceRef.Create <IPendingOpsService <string> >(new PendingOpsService <string>("DONE"));
Assert.IsFalse(pendingOpsTestService.OperationCompleted);
Assert.IsNull(pendingOpsTestService.Result);
pendingOpsTestService.BeginOperation();
Assert.IsTrue(pendingOpsTestService.OperationCompleted);
Assert.AreEqual("DONE", pendingOpsTestService.Result);
}
public void BeginOperation()
{
_pendingOperation = ServiceRef.RegisterPendingOperation(this);
Task.Factory.StartNew(() =>
{
//simulate some work
Task.Delay(1000).Wait();
ServiceRef.Create <IPendingOpsService>(this)
.CompleteOperation();
});
}
public FolderDto GetFolderByNum(string repositoryAlias, int folderNumber)
{
ServiceRef serviceRef = GetServiceRef(repositoryAlias);
Task <Result <FolderDto> > task = serviceRef.Service.Folders.GetAsync(folderNumber);
task.Wait();
Result <FolderDto> result = task.Result;
return(result.Entity);
}
public async Task <List <FolderDto> > LoadEntities(ServiceRef serviceRef)
{
try
{
return((await serviceRef.Service.Folders.GetTreeAsync()).Entity);
}
catch (Exception ex)
{
View.ShowInfo(ex.Message);
throw;
}
}
public AncillaryServicePrice DeepCopy()
{
var result = new AncillaryServicePrice();
result.Value = Value?.Copy();
result.ServiceRef = ServiceRef?.DeepCopy();
result.SegmentRef = SegmentRef?.DeepCopy();
result.LoyaltyCardRef = LoyaltyCardRef?.DeepCopy();
result.TravellersTypes = TravellersTypes != null ? new HashSet <PassTypes>(TravellersTypes) : null;
result.TravellerRef = TravellerRef?.DeepCopy();
return(result);
}
//
// called when peer target changes
//
/// <summary>
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void comboBox1_SelectedIndexChanged(object sender, System.EventArgs e)
{
PeerData peer = (PeerData)comboBox1.SelectedItem;
try
{
resolver = DNSService.Resolve(0, 0, peer.Name, peer.Type, peer.Domain, new DNSService.ResolveReply(OnResolveReply));
}
catch
{
MessageBox.Show("Unable to Resolve service", "Error");
Application.Exit();
}
}
public Task <bool> BeginOperationAsync()
{
_pendingOperation = ServiceRef.RegisterPendingOperation(this, () => OperationCompleted);
Task.Run(async() =>
{
//simulate some work
await Task.Delay(1000);
await ServiceRef.Create <IPendingOpsServiceAsync>(this)
.CompleteOperationAsync();
});
return(Task.FromResult(false));
}
/// <summary>
/// Проверяет данный элемент на привязку к какой либо из указанных услуг брони
/// </summary>
/// <param name="serviceREfs">Список ИД услуг в брони, принадлежность к которым требуется проверить</param>
/// <param name="notLinkedAsAll">Включает определение DataItem'ов без привязки к услугам, как привязанных ко всем</param>
/// <returns>Признак привязки данного элемент к одной из указанных услуг</returns>
public bool IsLinkedToServices(IEnumerable <int> serviceREfs, bool notLinkedAsAll = false)
{
if (serviceREfs == null || !serviceREfs.Any())
{
return(true);
}
if (ServiceRef == null || !ServiceRef.Any())
{
return(notLinkedAsAll);
}
return(ServiceRef.Intersect(serviceREfs).Any());
}
public Guid TestTaskToSecuential()
{
ServiceRef serviceRef = GetServiceRef(null);
Task <Result <FolderDto> > task = serviceRef.Service.Folders.GetHomeAsync();
task.Wait();
Result <FolderDto> result = task.Result;
var r = result.Entity.FolderId;
return(r);
}
private void StartChildConnections()
{
foreach (var childConnection in _connections)
{
childConnection.Start(
receivedActionStreamAsync:
(connection, networkStream, cancellationToken)
=> ServiceRef.CallAndWaitAsync(this, async() => await OnReceivedDataFromChildChannel(connection, networkStream, cancellationToken)),
connectionStateChangedAction:
(connection, fromState, toState)
=> ServiceRef.Call(this, () => OnChildChannelConnectionStateChanged(connection, fromState, toState)));
}
}
private async Task OnReceivedDataFromChildChannel(IConnection connection, Stream networkStream, CancellationToken cancellationToken)
{
int messageCounter = BitConverter.ToInt32(await networkStream.ReadBytesAsync(4), 0);
if (messageCounter == _receivedMessageCounter + 1)
{
//ok new message in sync arrived
_receivedMessageCounter++;
#pragma warning disable IDE0068 // Use recommended dispose pattern
var thisRef = ServiceRef.Create <IConnection>(this);
#pragma warning restore IDE0068 // Use recommended dispose pattern
if (_receivedActionStreamAsync != null)
{
await _receivedActionStreamAsync(thisRef, networkStream, cancellationToken);
await networkStream.FlushAsync();
}
else
{
var messageData = await networkStream.ReadBytesAsync((int)networkStream.Length - 4 /* messageCounter size */);
if (_receivedActionAsync != null)
{
await _receivedActionAsync(thisRef, messageData, cancellationToken);
}
else
{
_receivedAction?.Invoke(thisRef, messageData);
}
}
}
else if (messageCounter <= _receivedMessageCounter)
{
//ok it's an old message from slow or reconnected channel
//nothing to do
}
else //if (messageCounter > _receivedMessageCounter)
{
//not good: I'm no more in sync with other peer
//a reconnection is required
_connectionStateMachine.Fire(ConnectionTrigger.LinkError);
}
}
OnRegisterReply
(
ServiceRef sdRef,
ServiceFlags flags,
ErrorCode errorCode,
String name,
String regtype,
String domain)
{
if (errorCode == ErrorCode.NoError)
{
Invoke(registerServiceCallback, new Object[] { name });
}
else
{
MessageBox.Show("OnRegisterReply returned an error code " + errorCode, "Error");
}
}
//
// OnResolveService
//
// Called when DNSServices has resolved a service.
//
// This is called (indirectly) from OnResolveService()
//
private void OnResolveService(
ResolveData data
)
{
resolver.Dispose();
PeerData peer = (PeerData) comboBox1.SelectedItem;
peer.Port = data.Port;
try
{
resolver = DNSService.QueryRecord(0, 0, data.HostName, /* ns_t_a */ 1, /* ns_t_c */ 1, new DNSService.QueryRecordReply(OnQueryRecordReply));
}
catch
{
MessageBox.Show("QueryRecord Failed", "Error");
Application.Exit();
}
}
//
// OnResolveReply
//
// Called by DNSServices core as a result of DNSService.Resolve()
// call
//
// This is called from a worker thread by DNSService core.
//
private void OnResolveReply(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String fullName,
String hostName,
int port,
Byte[] txtRecord
)
{
if (errorCode == ErrorCode.NoError)
{
ResolveData data = new ResolveData();
data.InterfaceIndex = interfaceIndex;
data.FullName = fullName;
data.HostName = hostName;
data.Port = port;
data.TxtRecord = txtRecord;
Invoke(resolveServiceCallback, new Object[]{data});
}
else
{
MessageBox.Show("OnResolveReply returned an error code: " + errorCode, "Error");
}
}
//
// OnRegisterReply
//
// Called by DNSServices core as a result of DNSService.Register()
// call
//
// This is called from a worker thread by DNSService core.
//
private void OnRegisterReply(
ServiceRef sdRef,
ServiceFlags flags,
ErrorCode errorCode,
String name,
String regtype,
String domain)
{
if (errorCode == ErrorCode.NoError)
{
Invoke(registerServiceCallback, new Object[]{name});
}
else
{
MessageBox.Show("OnRegisterReply returned an error code " + errorCode, "Error");
}
}
//
// OnQueryRecordReply
//
// Called by DNSServices core as a result of DNSService.QueryRecord()
// call
//
// This is called from a worker thread by DNSService core.
//
private void OnQueryRecordReply(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String fullName,
int rrtype,
int rrclass,
Byte[] rdata,
int ttl
)
{
if (errorCode == ErrorCode.NoError)
{
uint bits = BitConverter.ToUInt32(rdata, 0);
System.Net.IPAddress data = new System.Net.IPAddress(bits);
Invoke(resolveAddressCallback, new Object[]{data});
}
else
{
MessageBox.Show("OnQueryRecordReply returned an error code: " + errorCode, "Error");
}
}
//
// OnBrowseReply
//
// Called by DNSServices core as a result of DNSService.Browse()
// call
//
// This is called from a worker thread by DNSService core.
//
private void OnBrowseReply(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String name,
String type,
String domain)
{
if (errorCode == ErrorCode.NoError)
{
PeerData peer = new PeerData();
peer.InterfaceIndex = interfaceIndex;
peer.Name = name;
peer.Type = type;
peer.Domain = domain;
peer.Address = null;
if ((flags & ServiceFlags.Add) != 0)
{
Invoke(addPeerCallback, new Object[]{peer});
}
else if ((flags == 0) || ((flags & ServiceFlags.MoreComing) != 0))
{
Invoke(removePeerCallback, new Object[]{peer});
}
}
else
{
MessageBox.Show("OnBrowseReply returned an error code " + errorCode, "Error");
}
}
private void Form1_Load(object sender, EventArgs e)
{
IPEndPoint localEP = new IPEndPoint(System.Net.IPAddress.Any, 0);
//
// create the socket and bind to INADDR_ANY
//
socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
socket.Bind(localEP);
localEP = (IPEndPoint) socket.LocalEndPoint;
//
// start asynchronous read
//
SocketStateObject so = new SocketStateObject(socket);
socket.BeginReceive(so.m_buffer, 0, SocketStateObject.BUFFER_SIZE, 0, new AsyncCallback(this.OnReadSocket), so);
try
{
//
// start the register and browse operations
//
registrar = DNSService.Register(0, 0, System.Environment.UserName, "_p2pchat._udp", null, null, localEP.Port, null, new DNSService.RegisterReply(OnRegisterReply));
browser = DNSService.Browse(0, 0, "_p2pchat._udp", null, new DNSService.BrowseReply(OnBrowseReply));
}
catch
{
MessageBox.Show("DNSServices Not Available", "Error");
Application.Exit();
}
}
//
// called when peer target changes
//
/// <summary>
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void comboBox1_SelectedIndexChanged(object sender, System.EventArgs e)
{
PeerData peer = (PeerData) comboBox1.SelectedItem;
try
{
resolver = DNSService.Resolve(0, 0, peer.Name, peer.Type, peer.Domain, new DNSService.ResolveReply(OnResolveReply));
}
catch
{
MessageBox.Show("Unable to Resolve service", "Error");
Application.Exit();
}
}
private void listBox1_SelectedIndexChanged(object sender, System.EventArgs e)
{
if (resolver != null)
{
resolver.Dispose();
}
if (browseList.SelectedItem != null)
{
try
{
BrowseData data = (BrowseData) browseList.SelectedItem;
resolver = DNSService.Resolve(0, 0, data.Name, data.Type, data.Domain, new DNSService.ResolveReply(OnResolveReply));
}
catch
{
MessageBox.Show("Resolve Failed", "Error");
Application.Exit();
}
}
}
//
// OnBrowseReply
//
// This call is invoked by the DNSService core. It is
// executed in the context of a worker thread, not the
// main (GUI) thread. We create a BrowseData object
// and invoked the appropriate method in the GUI thread
// so we can update the UI
//
private void OnBrowseReply(
ServiceRef sdRef,
ServiceFlags flags,
int interfaceIndex,
ErrorCode errorCode,
String name,
String type,
String domain
)
{
if (errorCode == ErrorCode.NoError)
{
BrowseData data = new BrowseData();
data.InterfaceIndex = interfaceIndex;
data.Name = name;
data.Type = type;
data.Domain = domain;
if ((flags & ServiceFlags.Add) != 0)
{
Invoke(addServiceCallback, new Object[]{data});
}
else if ((flags == 0) || ((flags & ServiceFlags.MoreComing) != 0))
{
Invoke(removeServiceCallback, new Object[]{data});
}
}
else
{
MessageBox.Show("OnBrowseReply returned an error code: " + errorCode, "Error");
}
}
//
// OnResolveService
//
// This method is "Invoked" by OnResolveReply. This call
// executes in the context of the main thread
//
private void OnResolveService(
ResolveData data
)
{
resolver.Dispose();
resolver = null;
Populate((BrowseData) browseList.SelectedItem, data);
}
//
// called when the type field changes
//
private void typeBox_SelectedIndexChanged(object sender, System.EventArgs e)
{
browseList.Items.Clear();
if (browser != null)
{
browser.Dispose();
}
nameField.Text = "";
typeField.Text = "";
domainField.Text = "";
hostField.Text = "";
portField.Text = "";
serviceTextField.Items.Clear();
try
{
browser = DNSService.Browse(0, 0, typeBox.SelectedItem.ToString(), null, new DNSService.BrowseReply(OnBrowseReply));
}
catch
{
MessageBox.Show("Browse Failed", "Error");
Application.Exit();
}
}
