public static void ServiceContract_TypedProxy_AsyncTask_CallbackReturn()
{
DuplexChannelFactory<IWcfDuplexTaskReturnService> factory = null;
Guid guid = Guid.NewGuid();
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
DuplexTaskReturnServiceCallback callbackService = new DuplexTaskReturnServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
try
{
factory = new DuplexChannelFactory<IWcfDuplexTaskReturnService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_TaskReturn_Address));
IWcfDuplexTaskReturnService serviceProxy = factory.CreateChannel();
Task<Guid> task = serviceProxy.Ping(guid);
Guid returnedGuid = task.Result;
Assert.Equal(guid, returnedGuid);
factory.Close();
}
finally
{
if (factory != null && factory.State != CommunicationState.Closed)
{
factory.Abort();
}
}
}
public static void NetTcpBinding_DuplexCallback_ReturnsXmlComplexType()
{
DuplexChannelFactory<IWcfDuplexService_Xml> factory = null;
NetTcpBinding binding = null;
WcfDuplexServiceCallback callbackService = null;
InstanceContext context = null;
IWcfDuplexService_Xml serviceProxy = null;
Guid guid = Guid.NewGuid();
try
{
binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
callbackService = new WcfDuplexServiceCallback();
context = new InstanceContext(callbackService);
factory = new DuplexChannelFactory<IWcfDuplexService_Xml>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_XmlDuplexCallback_Address));
serviceProxy = factory.CreateChannel();
serviceProxy.Ping_Xml(guid);
XmlCompositeTypeDuplexCallbackOnly returnedType = callbackService.XmlCallbackGuid;
// validate response
Assert.True((guid.ToString() == returnedType.StringValue), String.Format("The Guid to string value sent was not the same as what was returned.\nSent: {0}\nReturned: {1}", guid.ToString(), returnedType.StringValue));
((ICommunicationObject)serviceProxy).Close();
factory.Close();
}
finally
{
ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)serviceProxy, factory);
}
}
public void Setup()
{
_handler = new SitecoreLinkedHandler();
_database = global::Sitecore.Configuration.Factory.GetDatabase("master");
_target = _database.GetItem("/sitecore/content/Glass/ItemLinksTest");
SitecoreProperty idProperty = new SitecoreProperty(){
Attribute = new SitecoreIdAttribute(),
Property = typeof(SitecoreLinkedHandlerFixtureNS.LinkedTestClass).GetProperty("Id")
};
SitecoreIdDataHandler idHandler = new SitecoreIdDataHandler();
idHandler.ConfigureDataHandler(idProperty);
var context = new InstanceContext(
(new SitecoreClassConfig[]{
new SitecoreClassConfig(){
ClassAttribute = new SitecoreClassAttribute(),
Properties = new SitecoreProperty[]{
idProperty
},
Type = typeof(SitecoreLinkedHandlerFixtureNS.LinkedTestClass),
DataHandlers = new AbstractSitecoreDataHandler []{
idHandler
}
}
}).ToDictionary(), new AbstractSitecoreDataHandler[] { });
_service = new SitecoreService(_database, context);
}
public void CallbackToSyncContext()
{
var path = @"net.pipe://127.0.0.1/" + this.GetType().Name + MethodBase.GetCurrentMethod().Name;
var binding = new NetNamedPipeBinding() { MaxConnections = 5 };
using (var server = new ServiceHost(new SyncCallbackService(), new Uri(path)))
{
server.AddServiceEndpoint(typeof(ISyncCallbackService), binding, path);
server.Open();
using (var syncContext = new StaSynchronizationContext())
{
InstanceContext context = null;
NDceRpc.ServiceModel.DuplexChannelFactory<ISyncCallbackService> channelFactory = null;
ISyncCallbackService client = null;
syncContext.Send(_ => SynchronizationContext.SetSynchronizationContext(syncContext), null);
syncContext.Send(_ => context = new InstanceContext(new SyncCallbackServiceCallback()), null);
syncContext.Send(_ => channelFactory = new NDceRpc.ServiceModel.DuplexChannelFactory<ISyncCallbackService>(context, binding),null);
syncContext.Send(_ => client = channelFactory.CreateChannel(new EndpointAddress(path)),null);
using (channelFactory)
{
var callbackThread = client.Call();
Assert.AreEqual(syncContext.ManagedThreadId, callbackThread);
}
}
}
}
public static void RequestResponseOverWebSocketManually_Echo_RoundTrips_Guid()
{
DuplexChannelFactory<IWcfDuplexService> factory = null;
IWcfDuplexService duplexProxy = null;
Guid guid = Guid.NewGuid();
try
{
// *** SETUP *** \\
NetHttpBinding binding = new NetHttpBinding();
binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address));
duplexProxy = factory.CreateChannel();
// *** EXECUTE *** \\
Task.Run(() => duplexProxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
// *** VALIDATE *** \\
Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid));
// *** CLEANUP *** \\
factory.Close();
((ICommunicationObject)duplexProxy).Close();
}
finally
{
// *** ENSURE CLEANUP *** \\
ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)duplexProxy, factory);
}
}
public static void RequestResponseOverWebSocketManually_Echo_RoundTrips_Guid()
{
DuplexChannelFactory<IWcfDuplexService> factory = null;
Guid guid = Guid.NewGuid();
NetHttpBinding binding = new NetHttpBinding();
binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
try
{
factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.NetHttpWebSocketTransport_Address));
IWcfDuplexService duplexProxy = factory.CreateChannel();
Task.Run(() => duplexProxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid));
}
finally
{
if (factory != null && factory.State != CommunicationState.Closed)
{
factory.Abort();
}
}
}
public static void DuplexClientBaseOfT_OverNetTcp_Synchronous_Call()
{
DuplexClientBase<IWcfDuplexService> duplexService = null;
Guid guid = Guid.NewGuid();
try
{
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_Callback_Address));
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
// Ping on another thread.
Task.Run(() => proxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
Assert.True(guid == returnedGuid,
string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid));
((ICommunicationObject)duplexService).Close();
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
}
public object AfterReceiveRequest (ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
if (RequestReceived != null)
return RequestReceived (ref request, channel, instanceContext);
else
return null;
}
public void Setup()
{
_handler = new SitecoreFieldIEnumerableHandler();
var context = new InstanceContext(
new Dictionary<Type, SitecoreClassConfig>(),
new AbstractSitecoreDataHandler[] { new SitecoreFieldIntegerHandler() });
_service = new SitecoreService("master");
}
public ContactCenterCallback(IContactCenterCallbackHandler handler)
{
this._handler = handler;
InstanceContext site = new InstanceContext(this);
this._proxy = new ContactCenterProxy(site);
handler.ContactCenterProxy = this._proxy;
this._proxy.BeginJoin(handler.ServiceID, new AsyncCallback(OnEndJoin), null);
}
public object GetInstance(InstanceContext instanceContext, Message message)
{
if (instanceContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("instanceContext");
}
return instanceContext.Extensions.Find<DurableInstance>();
}
internal object GetInstance(InstanceContext instanceContext)
{
if (_provider == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxNoDefaultConstructor));
}
return _provider.GetInstance(instanceContext);
}
internal object GetInstance(InstanceContext instanceContext, Message request)
{
if (_provider == null)
{
throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR.SFxNoDefaultConstructor), request);
}
return _provider.GetInstance(instanceContext, request);
}
public static void CreateDuplexClientBase_Binding_Url_Mismatch_Throws()
{
InstanceContext context = new InstanceContext(new WcfDuplexServiceCallback());
Binding binding = new NetTcpBinding();
EndpointAddress endpoint = new EndpointAddress(FakeAddress.HttpAddress);
Assert.Throws<ArgumentException>("via", () => {
MyDuplexClientBase<IWcfDuplexService> duplexClientBase = new MyDuplexClientBase<IWcfDuplexService>(context, binding, endpoint);
((ICommunicationObject)duplexClientBase).Open();
});
}
public static void CreateChannel_EmptyEndpointAddress_AsString_ThrowsUriFormat()
{
WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callback);
Binding binding = new NetTcpBinding();
Assert.Throws<UriFormatException>(() =>
{
DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, string.Empty);
});
}
// valid address, but the scheme is incorrect
public static void CreateChannel_ExpectedNetTcpScheme_InvalidScheme_ThrowsUriFormat()
{
WcfDuplexServiceCallback callback = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callback);
Binding binding = new NetTcpBinding();
Assert.Throws<ArgumentException>("via", () =>
{
DuplexChannelFactory<IWcfDuplexService> factory = new DuplexChannelFactory<IWcfDuplexService>(context, binding, "qwerty://not-the-right-scheme");
factory.CreateChannel();
});
}
private void ConnectToService()
{
InstanceContext site = new InstanceContext(this);
NetTcpBinding tcpBinding = new NetTcpBinding();
tcpBinding.TransactionFlow = false;
tcpBinding.ReliableSession.Ordered = true;
tcpBinding.Security.Message.ClientCredentialType = MessageCredentialType.None;
tcpBinding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None;
tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None;
tcpBinding.Security.Mode = SecurityMode.None;
}
public static void DuplexClientBase_Aborts_Changes_CommunicationState()
{
InstanceContext context = new InstanceContext(new WcfDuplexServiceCallback());
Binding binding = new NetTcpBinding();
EndpointAddress endpoint = new EndpointAddress(FakeAddress.TcpAddress);
MyDuplexClientBase<IWcfDuplexService> duplexClientBase = new MyDuplexClientBase<IWcfDuplexService>(context, binding, endpoint);
Assert.Equal<CommunicationState>(CommunicationState.Created, duplexClientBase.State);
duplexClientBase.Abort();
Assert.Equal<CommunicationState>(CommunicationState.Closed, duplexClientBase.State);
}
public static void DuplexClientBase_Ctor_Initializes_State()
{
InstanceContext context = new InstanceContext(new WcfDuplexServiceCallback());
Binding binding = new NetTcpBinding();
EndpointAddress endpoint = new EndpointAddress(Endpoints.Tcp_NoSecurity_Callback_Address);
MyDuplexClientBase<IWcfDuplexService> duplexClientBase = new MyDuplexClientBase<IWcfDuplexService>(context, binding, endpoint);
Assert.Equal<EndpointAddress>(endpoint, duplexClientBase.Endpoint.Address);
Assert.Equal<CommunicationState>(CommunicationState.Created, duplexClientBase.State);
duplexClientBase.Abort();
}
public static void DuplexClientBaseOfT_OverHttp_Call_Throws_InvalidOperation()
{
#if FULLXUNIT_NOTSUPPORTED
bool root_Certificate_Installed = Root_Certificate_Installed();
if (!root_Certificate_Installed)
{
Console.WriteLine("---- Test SKIPPED --------------");
Console.WriteLine("Attempting to run the test in ToF, a ConditionalFact evaluated as FALSE.");
Console.WriteLine("Root_Certificate_Installed evaluated as {0}", root_Certificate_Installed);
return;
}
#endif
DuplexClientBase<IWcfDuplexService> duplexService = null;
IWcfDuplexService proxy = null;
try
{
// *** SETUP *** \\
BasicHttpBinding binding = new BasicHttpBinding(BasicHttpSecurityMode.None);
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Https_DefaultBinding_Address));
// *** EXECUTE *** \\
var exception = Assert.Throws<InvalidOperationException>(() =>
{
proxy = duplexService.ChannelFactory.CreateChannel();
});
// *** VALIDATE *** \\
// Can't compare the entire exception message - .NET Native doesn't necessarily output the entire message, just params
// "Contract requires Duplex, but Binding 'BasicHttpBinding' doesn't support it or isn't configured properly to support it"
Assert.True(exception.Message.Contains("BasicHttpBinding"));
Assert.Throws<CommunicationObjectFaultedException>(() =>
{
// You can't gracefully close a Faulted CommunicationObject, so we should make sure it throws here too
((ICommunicationObject)duplexService).Close();
});
// *** CLEANUP *** \\
// proxy will be null here so can't close.
// duplexService is closed prior to this as part of an assert to verify an expected exception.
}
finally
{
// *** ENSURE CLEANUP *** \\
ScenarioTestHelpers.CloseCommunicationObjects((ICommunicationObject)proxy, duplexService);
}
}
public object AfterReceiveRequest (
ref Message request,
IClientChannel channel,
InstanceContext instanceContext)
{
MessageBuffer buf = request.CreateBufferedCopy (0x10000);
request = buf.CreateMessage ();
using (XmlWriter w = XmlWriter.Create (Console.Error, s)) {
buf.CreateMessage ().WriteMessage (w);
}
Console.Error.WriteLine ("======================");
return Guid.NewGuid ();
}
private static void AddInstanceToList( InstanceContext instance )
{
lock( _instancesByThread )
{
List<InstanceContext> threadList;
if( !_instancesByThread.TryGetValue( instance.ConceptionThread, out threadList ) )
{
threadList = new List<InstanceContext>();
_instancesByThread[instance.ConceptionThread] = threadList;
}
threadList.Add( instance );
}
}
public MexInstanceContextProvider (ServiceHostBase service_host)
{
foreach (IServiceBehavior beh in service_host.Description.Behaviors) {
ServiceMetadataBehavior mex_beh = beh as ServiceMetadataBehavior;
if (mex_beh == null)
continue;
MetadataExchange mex_instance = new MetadataExchange (mex_beh);
ctx = new InstanceContext (mex_instance);
break;
}
//if (ctx == null)
}
public virtual void InitializeInstanceContext(InstanceContext instanceContext, Message message, IContextChannel channel)
{
if (instanceContext == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("instanceContext");
}
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
if (channel == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("channel");
}
Guid instanceId = GetInstanceIdFromMessage(message);
DurableInstance durableInstance;
if (instanceId == Guid.Empty) //Activation Request.
{
instanceId = Guid.NewGuid();
durableInstance = this.OnCreateNewInstance(instanceId);
message.Properties[DurableMessageDispatchInspector.NewDurableInstanceIdPropertyName] = instanceId;
}
else
{
durableInstance = this.OnGetExistingInstance(instanceId);
}
Fx.Assert(durableInstance != null, "Durable instance should never be null at this point.");
durableInstance.Open();
instanceContext.Extensions.Add(durableInstance);
if (!string.IsNullOrEmpty(channel.SessionId))
{
instanceContext.IncomingChannels.Add(channel);
}
contextCache.AddInstanceContext(instanceId, instanceContext);
if (DiagnosticUtility.ShouldTraceInformation)
{
string traceText = SR.GetString(SR.TraceCodeDICPInstanceContextCached, instanceId);
TraceUtility.TraceEvent(TraceEventType.Information,
TraceCode.DICPInstanceContextCached, SR.GetString(SR.TraceCodeDICPInstanceContextCached),
new StringTraceRecord("InstanceDetail", traceText),
this, null);
}
}
public static void ServiceContract_TypedProxy_DuplexCallback()
{
DuplexChannelFactory<IDuplexChannelService> factory = null;
StringBuilder errorBuilder = new StringBuilder();
Guid guid = Guid.NewGuid();
try
{
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
DuplexChannelServiceCallback callbackService = new DuplexChannelServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
factory = new DuplexChannelFactory<IDuplexChannelService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_DuplexCallback_Address));
IDuplexChannelService serviceProxy = factory.CreateChannel();
serviceProxy.Ping(guid);
Guid returnedGuid = callbackService.CallbackGuid;
if (guid != returnedGuid)
{
errorBuilder.AppendLine(String.Format("The sent GUID does not match the returned GUID. Sent: {0} Received: {1}", guid, returnedGuid));
}
factory.Close();
}
catch (Exception ex)
{
errorBuilder.AppendLine(String.Format("Unexpected exception was caught: {0}", ex.ToString()));
for (Exception innerException = ex.InnerException; innerException != null; innerException = innerException.InnerException)
{
errorBuilder.AppendLine(String.Format("Inner exception: {0}", innerException.ToString()));
}
}
finally
{
if (factory != null && factory.State != CommunicationState.Closed)
{
factory.Abort();
}
}
if (errorBuilder.Length != 0)
{
Assert.True(errorBuilder.Length == 0, string.Format("Test Scenario: ServiceContract_TypedProxy_DuplexCallback FAILED with the following errors: {0}", errorBuilder));
}
}
public override void ReleaseInstance(InstanceContext instanceContext, object instance)
{
WorkflowDurableInstance workflowDurableInstance = null;
//If InstanceContext is taken down due to Exception(Like PersistenceException);
//Make sure we inform LifeTimeManager to cleanup the record.
if (instanceContext.State == CommunicationState.Faulted || instanceContext.Aborted)
{
if (this.instanceContextProvider.InstanceLifeTimeManager != null)
{
workflowDurableInstance = (WorkflowDurableInstance) instance;
this.instanceContextProvider.InstanceLifeTimeManager.CleanUp(workflowDurableInstance.InstanceId);
}
}
base.ReleaseInstance(instanceContext, instance);
}
private void ConnectToService()
{
InstanceContext site = new InstanceContext(this);
NetTcpBinding tcpBinding = new NetTcpBinding();
tcpBinding.TransactionFlow = false;
tcpBinding.ReliableSession.Ordered = true;
tcpBinding.Security.Message.ClientCredentialType = MessageCredentialType.None;
tcpBinding.Security.Transport.ProtectionLevel = System.Net.Security.ProtectionLevel.None;
tcpBinding.Security.Transport.ClientCredentialType = TcpClientCredentialType.None;
tcpBinding.Security.Mode = SecurityMode.None;
EndpointAddress myEndpoint = new EndpointAddress("net.tcp://" + Common.WcfServer + ":8731/WCFService/");
var myChannelFactory = new DuplexChannelFactory<IWCFService>(site, tcpBinding);
wcfObj = myChannelFactory.CreateChannel(myEndpoint);
wcfObj.Subscribe();
}
public static void TransportUsageAlways_WebSockets_Synchronous_Call()
{
DuplexClientBase<IWcfDuplexService> duplexService = null;
Guid guid = Guid.NewGuid();
try
{
NetHttpBinding binding = new NetHttpBinding();
binding.WebSocketSettings.TransportUsage = WebSocketTransportUsage.Always;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
var uri = new Uri(Endpoints.HttpBaseAddress_NetHttpWebSocket);
UriBuilder builder = new UriBuilder(Endpoints.HttpBaseAddress_NetHttpWebSocket);
switch (uri.Scheme.ToLowerInvariant())
{
case "http":
builder.Scheme = "ws";
break;
case "https":
builder.Scheme = "wss";
break;
}
duplexService = new MyDuplexClientBase<IWcfDuplexService>(context, binding, new EndpointAddress(builder.Uri));
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
// Ping on another thread.
proxy.Ping(guid);
//Task.Run(() => proxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
Assert.True(guid == returnedGuid,
string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid));
((ICommunicationObject)duplexService).Close();
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
}
public static void DuplexClientBaseOfT_OverNetTcp_Call()
{
DuplexClientBase<IWcfDuplexService> duplexService = null;
StringBuilder errorBuilder = new StringBuilder();
Guid guid = Guid.NewGuid();
try
{
NetTcpBinding binding = new NetTcpBinding();
binding.Security.Mode = SecurityMode.None;
WcfDuplexServiceCallback callbackService = new WcfDuplexServiceCallback();
InstanceContext context = new InstanceContext(callbackService);
duplexService = new MyDuplexClientBase<IWcfDuplexService>(context, binding, new EndpointAddress(Endpoints.Tcp_NoSecurity_Callback_Address));
IWcfDuplexService proxy = duplexService.ChannelFactory.CreateChannel();
// Ping on another thread.
Task.Run(() => proxy.Ping(guid));
Guid returnedGuid = callbackService.CallbackGuid;
if (guid != returnedGuid)
{
errorBuilder.AppendLine(String.Format("The sent GUID does not match the returned GUID. Sent: {0} Received: {1}", guid, returnedGuid));
}
duplexService.Close();
}
catch (Exception ex)
{
errorBuilder.AppendLine(String.Format("Unexpected exception was caught: {0}", ex.ToString()));
for (Exception innerException = ex.InnerException; innerException != null; innerException = innerException.InnerException)
{
errorBuilder.AppendLine(String.Format("Inner exception: {0}", innerException.ToString()));
}
}
finally
{
if (duplexService != null && duplexService.State != CommunicationState.Closed)
{
duplexService.Abort();
}
}
Assert.True(errorBuilder.Length == 0, string.Format("Test Scenario: DuplexClientBaseOfT_OverNetTcp_Call FAILED with the following errors: {0}", errorBuilder));
}
public void Setup(){
var context = new InstanceContext(
(new SitecoreClassConfig[]{
new SitecoreClassConfig(){
ClassAttribute = new SitecoreClassAttribute(),
Properties = new SitecoreProperty[]{},
Type = typeof(ProxyClassInterceptorFixtureNS.TestClass),
DataHandlers = new AbstractSitecoreDataHandler[]{}
}
}).ToDictionary(), new AbstractSitecoreDataHandler[]{});
_db = global::Sitecore.Configuration.Factory.GetDatabase("master");
_service = new SitecoreService(_db, context);
_itemId = new Guid("{8A317CBA-81D4-4F9E-9953-64C4084AECCA}");
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
if (logger.IsInfoEnabled)
{
var bufferedCopy = request.CreateBufferedCopy(int.MaxValue);
LogMessage("request", bufferedCopy.CreateMessage());
request = bufferedCopy.CreateMessage();
}
return(null);
}
protected override void OnReleaseInstance(InstanceContext instanceContext, object instance)
{
this.resourceFactory.ReleaseInstance(instanceContext, instance);
}
public void NotifyIdle(InstanceContextIdleCallback callback, InstanceContext instanceContext)
{
res.string_res += "NotifyIdle , ";
res.AddCurrentOperationContextInfo();
}
public ServiceProxy(InstanceContext callbackInstance, Binding binding, EndpointAddress remoteAddress) : base(callbackInstance, binding, remoteAddress)
{
}
public object GetInstance(InstanceContext instanceContext)
{
return(_getInstance(instanceContext));
}
public MySubscriptionServiceProxy(InstanceContext inputInstance) : base(inputInstance)
{
}
public MyDuplexClientBase(InstanceContext callbackInstance, Binding binding, EndpointAddress endpointAddress)
: base(callbackInstance, binding, endpointAddress)
{
}
public bool IsIdle(InstanceContext instanceContext)
{
return(true);
}
public MySubscriptionServiceProxy(InstanceContext inputInstance, string endpointConfigurationName, EndpointAddress remoteAddress) : base(inputInstance, endpointConfigurationName, remoteAddress)
{
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
var httpRequest = (HttpRequestMessageProperty)request.Properties[HttpRequestMessageProperty.Name];
return(new
{
origin = httpRequest.Headers["Origin"],
handlePreflight = httpRequest.Method.Equals("OPTIONS", StringComparison.InvariantCultureIgnoreCase)
});
}
public DuplexServiceClient <TChannel> GetDuplexClient <TChannel>(InstanceContext callbackInstance)
where TChannel : class
{
return(new DuplexServiceClient <TChannel>(callbackInstance));
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
return(null);
}
public void ReleaseInstance(InstanceContext instanceContext, object instance)
{
}
public object GetInstance(InstanceContext instanceContext)
{
return(GetInstance(instanceContext, null));
}
public void InitializeInstanceContext(InstanceContext instanceContext, System.ServiceModel.Channels.Message message, IContextChannel channel)
{
}
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
{
res.string_res += "AfterReceiveRequest , ";
res.AddCurrentOperationContextInfo();
return(null);
}
public MySubscriptionServiceProxy(InstanceContext inputInstance, string endpointConfigurationName) : base(inputInstance, endpointConfigurationName)
{
}
public EventBehaviorContext(InstanceContext <TInstance> context)
: base(context)
{
_context = context;
}
protected override object OnGetInstance(InstanceContext instanceContext, System.Net.Http.HttpRequestMessage request)
{
return(this.resourceFactory.GetInstance(serviceType, instanceContext, request));
}
public void InitializeInstanceContext(InstanceContext instanceContext, Message message, IContextChannel channel)
{
res.string_res += "InitializeInstanceContext , ";
res.AddCurrentOperationContextInfo();
}
public ServiceProxy(InstanceContext callbackInstance, string endpointConfigurationName, string remoteAddress) : base(callbackInstance, endpointConfigurationName, remoteAddress)
{
}
public void Initialize(InstanceContext instanceContext, Message message)
{
res.string_res += "Initialize , ";
res.AddCurrentOperationContextInfo();
}
public bool IsIdle(InstanceContext instanceContext)
{
res.string_res += "IsIdle , ";
res.AddCurrentOperationContextInfo();
return(false);
}
public void NotifyIdle(InstanceContextIdleCallback callback, InstanceContext instanceContext)
{
}
public object GetInstance(InstanceContext instanceContext, System.ServiceModel.Channels.Message message)
{
return(_getInstance(instanceContext));
}
protected override object OnGetInstance(InstanceContext instanceContext)
{
return(OnGetInstance(instanceContext, null));
}
public void ReleaseInstance(InstanceContext instanceContext, object instance)
{
res.string_res += "ReleaseInstance , ";
res.AddCurrentOperationContextInfo();
}
public MyInstanceContextProvider(InstanceContext exist, Result result)
{
existing = exist;
res = result;
}
public object GetInstance(InstanceContext instanceContext, Message message)
{
return(serviceInstance);
}
public object GetInstance(InstanceContext instanceContext)
{
res.string_res += "GetInstance2 , ";
res.AddCurrentOperationContextInfo();
return(instance);
}
