Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

613 lines
22 KiB
C#

//----------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------
namespace System.ServiceModel.Discovery
{
using System;
using System.ComponentModel;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Discovery.Configuration;
using System.Threading.Tasks;
using System.Xml;
using SR2 = System.ServiceModel.Discovery.SR;
[Fx.Tag.XamlVisible(false)]
public sealed class AnnouncementClient : ICommunicationObject, IDisposable
{
IAnnouncementInnerClient innerClient;
public AnnouncementClient()
: this("*")
{
}
public AnnouncementClient(string endpointConfigurationName)
{
if (endpointConfigurationName == null)
{
throw FxTrace.Exception.ArgumentNull("endpointConfigurationName");
}
AnnouncementEndpoint announcementEndpoint =
ConfigurationUtility.LookupEndpointFromClientSection<AnnouncementEndpoint>(
endpointConfigurationName);
Initialize(announcementEndpoint);
}
public AnnouncementClient(AnnouncementEndpoint announcementEndpoint)
{
if (announcementEndpoint == null)
{
throw FxTrace.Exception.ArgumentNull("announcementEndpoint");
}
Initialize(announcementEndpoint);
}
public event EventHandler<AsyncCompletedEventArgs> AnnounceOnlineCompleted
{
add
{
if (this.InternalAnnounceOnlineCompleted == null)
{
this.innerClient.HelloOperationCompleted += OnInnerClientHelloCompleted;
}
this.InternalAnnounceOnlineCompleted += value;
}
remove
{
this.InternalAnnounceOnlineCompleted -= value;
if (this.InternalAnnounceOnlineCompleted == null)
{
this.innerClient.HelloOperationCompleted -= OnInnerClientHelloCompleted;
}
}
}
public event EventHandler<AsyncCompletedEventArgs> AnnounceOfflineCompleted
{
add
{
if (this.InternalAnnounceOfflineCompleted == null)
{
this.innerClient.ByeOperationCompleted += OnInnerClientByeCompleted;
}
this.InternalAnnounceOfflineCompleted += value;
}
remove
{
this.InternalAnnounceOfflineCompleted -= value;
if (this.InternalAnnounceOfflineCompleted == null)
{
this.innerClient.ByeOperationCompleted -= OnInnerClientByeCompleted;
}
}
}
event EventHandler<AsyncCompletedEventArgs> InternalAnnounceOnlineCompleted;
event EventHandler<AsyncCompletedEventArgs> InternalAnnounceOfflineCompleted;
event EventHandler ICommunicationObject.Closed
{
add
{
if (this.InternalClosed == null)
{
this.InnerCommunicationObject.Closed += OnInnerCommunicationObjectClosed;
}
this.InternalClosed += value;
}
remove
{
this.InternalClosed -= value;
if (this.InternalClosed == null)
{
this.InnerCommunicationObject.Closed -= OnInnerCommunicationObjectClosed;
}
}
}
event EventHandler ICommunicationObject.Closing
{
add
{
if (this.InternalClosing == null)
{
this.InnerCommunicationObject.Closing += OnInnerCommunicationObjectClosing;
}
this.InternalClosing += value;
}
remove
{
this.InternalClosing -= value;
if (this.InternalClosing == null)
{
this.InnerCommunicationObject.Closing -= OnInnerCommunicationObjectClosing;
}
}
}
event EventHandler ICommunicationObject.Faulted
{
add
{
if (this.InternalFaulted == null)
{
this.InnerCommunicationObject.Faulted += OnInnerCommunicationObjectFaulted;
}
this.InternalFaulted += value;
}
remove
{
this.InternalFaulted -= value;
if (this.InternalFaulted == null)
{
this.InnerCommunicationObject.Faulted -= OnInnerCommunicationObjectFaulted;
}
}
}
event EventHandler ICommunicationObject.Opened
{
add
{
if (this.InternalOpened == null)
{
this.InnerCommunicationObject.Opened += OnInnerCommunicationObjectOpened;
}
this.InternalOpened += value;
}
remove
{
this.InternalOpened -= value;
if (this.InternalOpened == null)
{
this.InnerCommunicationObject.Opened -= OnInnerCommunicationObjectOpened;
}
}
}
event EventHandler ICommunicationObject.Opening
{
add
{
if (this.InternalOpening == null)
{
this.InnerCommunicationObject.Opening += OnInnerCommunicationObjectOpening;
}
this.InternalOpening += value;
}
remove
{
this.InternalOpening -= value;
if (this.InternalOpening == null)
{
this.InnerCommunicationObject.Opening -= OnInnerCommunicationObjectOpening;
}
}
}
event EventHandler InternalClosed;
event EventHandler InternalClosing;
event EventHandler InternalFaulted;
event EventHandler InternalOpened;
event EventHandler InternalOpening;
public DiscoveryMessageSequenceGenerator MessageSequenceGenerator
{
get
{
return this.innerClient.DiscoveryMessageSequenceGenerator;
}
set
{
if (value == null)
{
throw FxTrace.Exception.ArgumentNull("value");
}
if (((ICommunicationObject)this).State != CommunicationState.Created)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR2.DiscoverySetMessageSequenceInvalidState));
}
this.innerClient.DiscoveryMessageSequenceGenerator = value;
}
}
public ChannelFactory ChannelFactory
{
get
{
return InnerClient.ChannelFactory;
}
}
public ClientCredentials ClientCredentials
{
get
{
return InnerClient.ClientCredentials;
}
}
public ServiceEndpoint Endpoint
{
get
{
return InnerClient.Endpoint;
}
}
public IClientChannel InnerChannel
{
get
{
return InnerClient.InnerChannel;
}
}
CommunicationState ICommunicationObject.State
{
get
{
return InnerCommunicationObject.State;
}
}
IAnnouncementInnerClient InnerClient
{
get
{
return this.innerClient;
}
}
ICommunicationObject InnerCommunicationObject
{
get
{
return InnerClient.InnerCommunicationObject;
}
}
[Fx.Tag.Blocking(CancelMethod = "Abort", CancelDeclaringType = typeof(ICommunicationObject))]
[Fx.Tag.InheritThrows(From = "Open", FromDeclaringType = typeof(ICommunicationObject))]
public void Open()
{
((ICommunicationObject)this).Open();
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
public void AnnounceOnlineAsync(EndpointDiscoveryMetadata discoveryMetadata)
{
AnnounceOnlineAsync(discoveryMetadata, null);
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
public void AnnounceOnlineAsync(EndpointDiscoveryMetadata discoveryMetadata, object userState)
{
if (discoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("discoveryMetadata");
}
using (new AnnouncementOperationContextScope(InnerChannel))
{
InnerClient.HelloOperationAsync(discoveryMetadata, userState);
}
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
public void AnnounceOfflineAsync(EndpointDiscoveryMetadata discoveryMetadata)
{
AnnounceOfflineAsync(discoveryMetadata, null);
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
public void AnnounceOfflineAsync(EndpointDiscoveryMetadata discoveryMetadata, object userState)
{
if (discoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("discoveryMetadata");
}
using (new AnnouncementOperationContextScope(InnerChannel))
{
InnerClient.ByeOperationAsync(discoveryMetadata, userState);
}
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
[Fx.Tag.Blocking(CancelMethod = "Abort")]
public void AnnounceOnline(EndpointDiscoveryMetadata discoveryMetadata)
{
if (discoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("discoveryMetadata");
}
using (new AnnouncementOperationContextScope(InnerChannel))
{
this.InnerClient.HelloOperation(discoveryMetadata);
}
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
[Fx.Tag.Blocking(CancelMethod = "Abort")]
public void AnnounceOffline(EndpointDiscoveryMetadata discoveryMetadata)
{
if (discoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("discoveryMetadata");
}
using (new AnnouncementOperationContextScope(InnerChannel))
{
this.InnerClient.ByeOperation(discoveryMetadata);
}
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
public IAsyncResult BeginAnnounceOnline(EndpointDiscoveryMetadata discoveryMetadata, AsyncCallback callback, object state)
{
if (discoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("discoveryMetadata");
}
using (new AnnouncementOperationContextScope(InnerChannel))
{
return InnerClient.BeginHelloOperation(discoveryMetadata, callback, state);
}
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
public void EndAnnounceOnline(IAsyncResult result)
{
InnerClient.EndHelloOperation(result);
}
[Fx.Tag.Throws(typeof(AggregateException), "Inherits from Task exception contract")]
public Task AnnounceOnlineTaskAsync(EndpointDiscoveryMetadata discoveryMetadata)
{
return Task.Factory.FromAsync<EndpointDiscoveryMetadata>(this.BeginAnnounceOnline, this.EndAnnounceOnline, discoveryMetadata, /* state */ null);
}
[Fx.Tag.Throws(typeof(AggregateException), "Inherits from Task exception contract")]
public Task AnnounceOfflineTaskAsync(EndpointDiscoveryMetadata discoveryMetadata)
{
return Task.Factory.FromAsync<EndpointDiscoveryMetadata>(this.BeginAnnounceOffline, this.EndAnnounceOffline, discoveryMetadata, /* state */ null);
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
public IAsyncResult BeginAnnounceOffline(EndpointDiscoveryMetadata discoveryMetadata, AsyncCallback callback, object state)
{
if (discoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("discoveryMetadata");
}
using (new AnnouncementOperationContextScope(InnerChannel))
{
return InnerClient.BeginByeOperation(discoveryMetadata, callback, state);
}
}
[Fx.Tag.Throws(typeof(CommunicationException), "Inherits from Channel exception contract")]
[Fx.Tag.Throws(typeof(TimeoutException), "Inherits from Channel exception contract")]
public void EndAnnounceOffline(IAsyncResult result)
{
InnerClient.EndByeOperation(result);
}
[Fx.Tag.Blocking(CancelMethod = "Abort", CancelDeclaringType = typeof(ICommunicationObject))]
[Fx.Tag.InheritThrows(From = "Close", FromDeclaringType = typeof(ICommunicationObject))]
public void Close()
{
((ICommunicationObject)this).Close();
}
[Fx.Tag.Blocking(CancelMethod = "Abort", CancelDeclaringType = typeof(ICommunicationObject))]
[Fx.Tag.InheritThrows(From = "Open", FromDeclaringType = typeof(ICommunicationObject))]
void ICommunicationObject.Open()
{
InnerCommunicationObject.Open();
}
[Fx.Tag.Blocking(CancelMethod = "Abort", CancelDeclaringType = typeof(ICommunicationObject))]
[Fx.Tag.InheritThrows(From = "Open", FromDeclaringType = typeof(ICommunicationObject))]
void ICommunicationObject.Open(TimeSpan timeout)
{
InnerCommunicationObject.Open(timeout);
}
[Fx.Tag.InheritThrows(From = "BeginOpen", FromDeclaringType = typeof(ICommunicationObject))]
IAsyncResult ICommunicationObject.BeginOpen(AsyncCallback callback, object state)
{
return InnerCommunicationObject.BeginOpen(callback, state);
}
[Fx.Tag.InheritThrows(From = "BeginOpen", FromDeclaringType = typeof(ICommunicationObject))]
IAsyncResult ICommunicationObject.BeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
{
return InnerCommunicationObject.BeginOpen(timeout, callback, state);
}
[Fx.Tag.InheritThrows(From = "EndOpen", FromDeclaringType = typeof(ICommunicationObject))]
void ICommunicationObject.EndOpen(IAsyncResult result)
{
InnerCommunicationObject.EndOpen(result);
}
[Fx.Tag.Blocking(CancelMethod = "Abort", CancelDeclaringType = typeof(ICommunicationObject))]
[Fx.Tag.InheritThrows(From = "Close", FromDeclaringType = typeof(ICommunicationObject))]
void ICommunicationObject.Close()
{
InnerCommunicationObject.Close();
}
[Fx.Tag.Blocking(CancelMethod = "Abort", CancelDeclaringType = typeof(ICommunicationObject))]
[Fx.Tag.InheritThrows(From = "Close", FromDeclaringType = typeof(ICommunicationObject))]
void ICommunicationObject.Close(TimeSpan timeout)
{
InnerCommunicationObject.Close(timeout);
}
[Fx.Tag.InheritThrows(From = "BeginClose", FromDeclaringType = typeof(ICommunicationObject))]
IAsyncResult ICommunicationObject.BeginClose(AsyncCallback callback, object state)
{
return InnerCommunicationObject.BeginClose(callback, state);
}
[Fx.Tag.InheritThrows(From = "BeginClose", FromDeclaringType = typeof(ICommunicationObject))]
IAsyncResult ICommunicationObject.BeginClose(TimeSpan timeout, AsyncCallback callback, object state)
{
return InnerCommunicationObject.BeginClose(timeout, callback, state);
}
[Fx.Tag.InheritThrows(From = "EndClose", FromDeclaringType = typeof(ICommunicationObject))]
void ICommunicationObject.EndClose(IAsyncResult result)
{
InnerCommunicationObject.EndClose(result);
}
[Fx.Tag.InheritThrows(From = "Abort", FromDeclaringType = typeof(ICommunicationObject))]
void ICommunicationObject.Abort()
{
InnerCommunicationObject.Abort();
}
void IDisposable.Dispose()
{
this.Close();
}
void Initialize(AnnouncementEndpoint announcementEndpoint)
{
if (announcementEndpoint.Binding != null && announcementEndpoint.Binding.MessageVersion.Addressing == AddressingVersion.None)
{
throw FxTrace.Exception.Argument(
"announcementEndpoint",
SR.EndpointWithInvalidMessageVersion(
announcementEndpoint.GetType().Name,
AddressingVersion.None,
this.GetType().Name,
AddressingVersion.WSAddressing10,
AddressingVersion.WSAddressingAugust2004));
}
this.innerClient = announcementEndpoint.DiscoveryVersion.Implementation.CreateAnnouncementInnerClient(announcementEndpoint);
}
void RaiseEvent(EventHandler handler, EventArgs e)
{
if (handler != null)
{
handler(this, e);
}
}
void OnInnerCommunicationObjectClosed(object sender, EventArgs e)
{
RaiseEvent(this.InternalClosed, e);
}
void OnInnerCommunicationObjectClosing(object sender, EventArgs e)
{
RaiseEvent(this.InternalClosing, e);
}
void OnInnerCommunicationObjectFaulted(object sender, EventArgs e)
{
RaiseEvent(this.InternalFaulted, e);
}
void OnInnerCommunicationObjectOpened(object sender, EventArgs e)
{
RaiseEvent(this.InternalOpened, e);
}
void OnInnerCommunicationObjectOpening(object sender, EventArgs e)
{
RaiseEvent(this.InternalOpening, e);
}
void OnInnerClientHelloCompleted(object sender, AsyncCompletedEventArgs e)
{
EventHandler<AsyncCompletedEventArgs> handler = this.InternalAnnounceOnlineCompleted;
if (handler != null)
{
handler(this, e);
}
}
void OnInnerClientByeCompleted(object sender, AsyncCompletedEventArgs e)
{
EventHandler<AsyncCompletedEventArgs> handler = this.InternalAnnounceOfflineCompleted;
if (handler != null)
{
handler(this, e);
}
}
sealed class AnnouncementOperationContextScope : IDisposable
{
OperationContextScope operationContextScope;
UniqueId originalMessageId = null;
public AnnouncementOperationContextScope(IClientChannel clientChannel)
{
if (DiscoveryUtility.IsCompatible(OperationContext.Current, clientChannel))
{
// reuse the same context
this.originalMessageId = OperationContext.Current.OutgoingMessageHeaders.MessageId;
}
else
{
// create new context
this.operationContextScope = new OperationContextScope(clientChannel);
}
if (this.originalMessageId == null)
{
// this is either a new context or an existing one with no message id.
OperationContext.Current.OutgoingMessageHeaders.MessageId = new UniqueId();
}
}
public void Dispose()
{
if (this.operationContextScope != null)
{
this.operationContextScope.Dispose();
}
else
{
OperationContext.Current.OutgoingMessageHeaders.MessageId = this.originalMessageId;
}
}
}
}
}