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); }