mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
313 lines
14 KiB
C#
313 lines
14 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel
|
|
{
|
|
using System.Collections.Generic;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.ServiceModel.Channels;
|
|
using System.Collections.ObjectModel;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Runtime.Serialization;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Configuration;
|
|
|
|
public class DuplexChannelFactory<TChannel> : ChannelFactory<TChannel>
|
|
{
|
|
//Type overloads
|
|
public DuplexChannelFactory(Type callbackInstanceType)
|
|
: this((object)callbackInstanceType)
|
|
{ }
|
|
public DuplexChannelFactory(Type callbackInstanceType, Binding binding, String remoteAddress)
|
|
: this((object)callbackInstanceType, binding, new EndpointAddress(remoteAddress))
|
|
{ }
|
|
public DuplexChannelFactory(Type callbackInstanceType, Binding binding, EndpointAddress remoteAddress)
|
|
: this((object)callbackInstanceType, binding, remoteAddress)
|
|
{ }
|
|
public DuplexChannelFactory(Type callbackInstanceType, Binding binding)
|
|
: this((object)callbackInstanceType, binding)
|
|
{ }
|
|
public DuplexChannelFactory(Type callbackInstanceType, string endpointConfigurationName, EndpointAddress remoteAddress)
|
|
: this((object)callbackInstanceType, endpointConfigurationName, remoteAddress)
|
|
{ }
|
|
public DuplexChannelFactory(Type callbackInstanceType, string endpointConfigurationName)
|
|
: this((object)callbackInstanceType, endpointConfigurationName)
|
|
{ }
|
|
public DuplexChannelFactory(Type callbackInstanceType, ServiceEndpoint endpoint)
|
|
: this((object)callbackInstanceType, endpoint)
|
|
{ }
|
|
|
|
//InstanceContext overloads
|
|
public DuplexChannelFactory(InstanceContext callbackInstance)
|
|
: this((object)callbackInstance)
|
|
{ }
|
|
public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding, String remoteAddress)
|
|
: this((object)callbackInstance, binding, new EndpointAddress(remoteAddress))
|
|
{ }
|
|
public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding, EndpointAddress remoteAddress)
|
|
: this((object)callbackInstance, binding, remoteAddress)
|
|
{ }
|
|
public DuplexChannelFactory(InstanceContext callbackInstance, Binding binding)
|
|
: this((object)callbackInstance, binding)
|
|
{ }
|
|
public DuplexChannelFactory(InstanceContext callbackInstance, string endpointConfigurationName, EndpointAddress remoteAddress)
|
|
: this((object)callbackInstance, endpointConfigurationName, remoteAddress)
|
|
{ }
|
|
public DuplexChannelFactory(InstanceContext callbackInstance, string endpointConfigurationName)
|
|
: this((object)callbackInstance, endpointConfigurationName)
|
|
{ }
|
|
public DuplexChannelFactory(InstanceContext callbackInstance, ServiceEndpoint endpoint)
|
|
: this((object)callbackInstance, endpoint)
|
|
{ }
|
|
|
|
// TChannel provides ContractDescription
|
|
public DuplexChannelFactory(object callbackObject)
|
|
: base(typeof(TChannel))
|
|
{
|
|
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity() : null)
|
|
{
|
|
if (DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityConstructChannelFactory, TraceUtility.CreateSourceString(this)), ActivityType.Construct);
|
|
}
|
|
if (callbackObject == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackObject");
|
|
}
|
|
|
|
this.CheckAndAssignCallbackInstance(callbackObject);
|
|
this.InitializeEndpoint((string)null, (EndpointAddress)null);
|
|
}
|
|
}
|
|
|
|
// TChannel provides ContractDescription, attr/config [TChannel,name] provides Address,Binding
|
|
public DuplexChannelFactory(object callbackObject, string endpointConfigurationName)
|
|
: this(callbackObject, endpointConfigurationName, null)
|
|
{
|
|
}
|
|
|
|
// TChannel provides ContractDescription, attr/config [TChannel,name] provides Binding, provide Address explicitly
|
|
public DuplexChannelFactory(object callbackObject, string endpointConfigurationName, EndpointAddress remoteAddress)
|
|
: base(typeof(TChannel))
|
|
{
|
|
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity() : null)
|
|
{
|
|
if (DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityConstructChannelFactory, TraceUtility.CreateSourceString(this)), ActivityType.Construct);
|
|
}
|
|
if (callbackObject == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackObject");
|
|
}
|
|
|
|
if (endpointConfigurationName == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpointConfigurationName");
|
|
}
|
|
|
|
this.CheckAndAssignCallbackInstance(callbackObject);
|
|
this.InitializeEndpoint(endpointConfigurationName, remoteAddress);
|
|
}
|
|
}
|
|
|
|
// TChannel provides ContractDescription, attr/config [TChannel,name] provides Address,Binding
|
|
public DuplexChannelFactory(object callbackObject, Binding binding)
|
|
: this(callbackObject, binding, (EndpointAddress)null)
|
|
{
|
|
}
|
|
|
|
// TChannel provides ContractDescription, provide Address,Binding explicitly
|
|
public DuplexChannelFactory(object callbackObject, Binding binding, String remoteAddress)
|
|
: this(callbackObject, binding, new EndpointAddress(remoteAddress))
|
|
{
|
|
}
|
|
// TChannel provides ContractDescription, provide Address,Binding explicitly
|
|
public DuplexChannelFactory(object callbackObject, Binding binding, EndpointAddress remoteAddress)
|
|
: base(typeof(TChannel))
|
|
{
|
|
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity() : null)
|
|
{
|
|
if (DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityConstructChannelFactory, TraceUtility.CreateSourceString(this)), ActivityType.Construct);
|
|
}
|
|
if (callbackObject == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackObject");
|
|
}
|
|
|
|
if (binding == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("binding");
|
|
}
|
|
|
|
this.CheckAndAssignCallbackInstance(callbackObject);
|
|
this.InitializeEndpoint(binding, remoteAddress);
|
|
}
|
|
}
|
|
|
|
// provide ContractDescription,Address,Binding explicitly
|
|
public DuplexChannelFactory(object callbackObject, ServiceEndpoint endpoint)
|
|
: base(typeof(TChannel))
|
|
{
|
|
using (ServiceModelActivity activity = DiagnosticUtility.ShouldUseActivity ? ServiceModelActivity.CreateBoundedActivity() : null)
|
|
{
|
|
if (DiagnosticUtility.ShouldUseActivity)
|
|
{
|
|
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityConstructChannelFactory, TraceUtility.CreateSourceString(this)), ActivityType.Construct);
|
|
}
|
|
if (callbackObject == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("callbackObject");
|
|
}
|
|
|
|
if (endpoint == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoint");
|
|
}
|
|
|
|
this.CheckAndAssignCallbackInstance(callbackObject);
|
|
this.InitializeEndpoint(endpoint);
|
|
}
|
|
}
|
|
|
|
internal void CheckAndAssignCallbackInstance(object callbackInstance)
|
|
{
|
|
if (callbackInstance is Type)
|
|
{
|
|
this.CallbackType = (Type)callbackInstance;
|
|
}
|
|
else if (callbackInstance is InstanceContext)
|
|
{
|
|
this.CallbackInstance = (InstanceContext)callbackInstance;
|
|
}
|
|
else
|
|
{
|
|
this.CallbackInstance = new InstanceContext(callbackInstance);
|
|
}
|
|
}
|
|
|
|
public TChannel CreateChannel(InstanceContext callbackInstance)
|
|
{
|
|
return CreateChannel(callbackInstance, CreateEndpointAddress(this.Endpoint), null);
|
|
}
|
|
|
|
public TChannel CreateChannel(InstanceContext callbackInstance, EndpointAddress address)
|
|
{
|
|
if (address == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
|
|
}
|
|
|
|
return CreateChannel(callbackInstance, address, address.Uri);
|
|
}
|
|
|
|
public override TChannel CreateChannel(EndpointAddress address, Uri via)
|
|
{
|
|
return CreateChannel(this.CallbackInstance, address, via);
|
|
}
|
|
|
|
public virtual TChannel CreateChannel(InstanceContext callbackInstance, EndpointAddress address, Uri via)
|
|
{
|
|
if (address == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("address");
|
|
}
|
|
|
|
if (this.CallbackType != null && callbackInstance == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCreateDuplexChannelNoCallback1)));
|
|
}
|
|
if (callbackInstance == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCreateDuplexChannelNoCallback)));
|
|
}
|
|
|
|
if (callbackInstance.UserObject == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCreateDuplexChannelNoCallbackUserObject)));
|
|
}
|
|
|
|
if (!this.HasDuplexOperations())
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxCreateDuplexChannel1, this.Endpoint.Contract.Name)));
|
|
}
|
|
|
|
Type userObjectType = callbackInstance.UserObject.GetType();
|
|
Type callbackType = this.Endpoint.Contract.CallbackContractType;
|
|
if (callbackType != null && !callbackType.IsAssignableFrom(userObjectType))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(
|
|
SR.SFxCreateDuplexChannelBadCallbackUserObject, callbackType)));
|
|
}
|
|
|
|
EnsureOpened();
|
|
TChannel result = (TChannel)this.ServiceChannelFactory.CreateChannel(typeof(TChannel), address, via);
|
|
|
|
IDuplexContextChannel duplexChannel = result as IDuplexContextChannel;
|
|
if (duplexChannel != null)
|
|
{
|
|
duplexChannel.CallbackInstance = callbackInstance;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//Static funtions to create channels
|
|
static InstanceContext GetInstanceContextForObject(object callbackObject)
|
|
{
|
|
if (callbackObject is InstanceContext)
|
|
{
|
|
return (InstanceContext)callbackObject;
|
|
}
|
|
|
|
return new InstanceContext(callbackObject);
|
|
}
|
|
|
|
public static TChannel CreateChannel(object callbackObject, String endpointConfigurationName)
|
|
{
|
|
return CreateChannel(GetInstanceContextForObject(callbackObject), endpointConfigurationName);
|
|
}
|
|
|
|
public static TChannel CreateChannel(object callbackObject, Binding binding, EndpointAddress endpointAddress)
|
|
{
|
|
return CreateChannel(GetInstanceContextForObject(callbackObject), binding, endpointAddress);
|
|
}
|
|
|
|
public static TChannel CreateChannel(object callbackObject, Binding binding, EndpointAddress endpointAddress, Uri via)
|
|
{
|
|
return CreateChannel(GetInstanceContextForObject(callbackObject), binding, endpointAddress, via);
|
|
}
|
|
|
|
public static TChannel CreateChannel(InstanceContext callbackInstance, String endpointConfigurationName)
|
|
{
|
|
DuplexChannelFactory<TChannel> channelFactory = new DuplexChannelFactory<TChannel>(callbackInstance, endpointConfigurationName);
|
|
TChannel channel = channelFactory.CreateChannel();
|
|
SetFactoryToAutoClose(channel);
|
|
return channel;
|
|
}
|
|
|
|
public static TChannel CreateChannel(InstanceContext callbackInstance, Binding binding, EndpointAddress endpointAddress)
|
|
{
|
|
DuplexChannelFactory<TChannel> channelFactory = new DuplexChannelFactory<TChannel>(callbackInstance, binding, endpointAddress);
|
|
TChannel channel = channelFactory.CreateChannel();
|
|
SetFactoryToAutoClose(channel);
|
|
return channel;
|
|
}
|
|
|
|
public static TChannel CreateChannel(InstanceContext callbackInstance, Binding binding, EndpointAddress endpointAddress, Uri via)
|
|
{
|
|
DuplexChannelFactory<TChannel> channelFactory = new DuplexChannelFactory<TChannel>(callbackInstance, binding);
|
|
TChannel channel = channelFactory.CreateChannel(endpointAddress, via);
|
|
SetFactoryToAutoClose(channel);
|
|
return channel;
|
|
}
|
|
|
|
}
|
|
}
|