Implemented a couple of async methods in InstanceContext as well as disposing.

[mono.git] / mcs / class / System.ServiceModel / System.ServiceModel / InstanceContext.cs

diff --git a/mcs/class/System.ServiceModel/System.ServiceModel/InstanceContext.cs b/mcs/class/System.ServiceModel/System.ServiceModel/InstanceContext.cs
index f04de622abcca59134a15397daadf39792c5f544..136ccdb7feccc1d0ace53494f629ab2b31d05209 100644 (file)
--- a/mcs/class/System.ServiceModel/System.ServiceModel/InstanceContext.cs
+++ b/mcs/class/System.ServiceModel/System.ServiceModel/InstanceContext.cs
@@ -32,14 +32,13 @@ using System.ServiceModel.Dispatcher;
 
 namespace System.ServiceModel
 {
-       [MonoTODO]
        public sealed class InstanceContext : CommunicationObject,
                IExtensibleObject<InstanceContext>
        {
                ServiceHostBase host;
                object implementation;
                int manual_flow_limit;
-               InstanceBehavior _behavior;
+               InstanceManager instance_manager;
                bool is_user_instance_provider;
                bool is_user_context_provider;
 
@@ -55,12 +54,12 @@ namespace System.ServiceModel
                {
                }
 
-               public InstanceContext (ServiceHostBase host,
-                       object implementation) : this(host, implementation, true)
-               {}
+               public InstanceContext (ServiceHostBase host, object implementation)
+                       : this (host, implementation, true)
+               {
+               }
 
-               internal InstanceContext(ServiceHostBase host, 
-                       object implementation, bool userContextProvider)
+               internal InstanceContext (ServiceHostBase host, object implementation, bool userContextProvider)
                {
                        this.host = host;
                        this.implementation = implementation;
@@ -74,18 +73,12 @@ namespace System.ServiceModel
                }
 
                internal bool IsUserProvidedContext {
-                       get {
-                               return is_user_context_provider;                                
-                       }
+                       get { return is_user_context_provider; }
                }
 
-               internal InstanceBehavior Behavior {
-                       get {
-                               return _behavior;
-                       }
-                       set {
-                               _behavior = value;
-                       }
+               internal InstanceManager InstanceManager {
+                       get { return instance_manager; }
+                       set { instance_manager = value; }
                }
 
                protected internal override TimeSpan DefaultCloseTimeout {
@@ -124,21 +117,21 @@ namespace System.ServiceModel
 
                public object GetServiceInstance (Message message)
                {
-                       if (implementation == null && Behavior != null) {
-                               implementation = Behavior.GetServiceInstance (this, message, ref is_user_instance_provider);                            
+                       if (implementation == null && instance_manager != null) {
+                               implementation = instance_manager.GetServiceInstance (this, message, ref is_user_instance_provider);                            
                        }
                        return implementation;                          
                }
 
-               public void IncrementManualFlowControlLimit (int incrementBy)
+               public int IncrementManualFlowControlLimit (int incrementBy)
                {
                        throw new NotImplementedException ();
                }
 
                internal void CloseIfIdle () {
-                       if (Behavior.InstanceContextProvider != null && !IsUserProvidedContext) {
-                               if (!Behavior.InstanceContextProvider.IsIdle (this)) {
-                                       Behavior.InstanceContextProvider.NotifyIdle (IdleCallback, this);
+                       if (instance_manager.InstanceContextProvider != null && !IsUserProvidedContext) {
+                               if (!instance_manager.InstanceContextProvider.IsIdle (this)) {
+                                       instance_manager.InstanceContextProvider.NotifyIdle (IdleCallback, this);
                                }
                                else {
                                        if (State != CommunicationState.Closed)
@@ -158,38 +151,62 @@ namespace System.ServiceModel
                }
 
                public void ReleaseServiceInstance ()
-               {                       
-                       Behavior.ReleaseServiceInstance (this, implementation);
+               {
+                       instance_manager.ReleaseServiceInstance (this, implementation);
+                       // FIXME: should Dispose() be invoked here?
                        implementation = null;
                }
 
+               void DisposeInstance ()
+               {
+                       var disp = implementation as IDisposable;
+                       if (disp != null)
+                               disp.Dispose ();
+               }
+
                protected override void OnAbort ()
                {
+                       DisposeInstance ();
+               }
+
+               protected override void OnFaulted ()
+               {
+                       DisposeInstance ();
+                       base.OnFaulted ();
                }
 
                protected override void OnClosed ()
                {
+                       DisposeInstance ();
                        base.OnClosed ();
                }
 
+               [MonoTODO]
                protected override void OnOpened ()
                {
+                       base.OnOpened ();
                }
 
-               protected override void OnOpening () {
-                       if (Behavior != null)
-                               Behavior.Initialize (this);
+               protected override void OnOpening ()
+               {
                        base.OnOpening ();
+                       if (instance_manager != null)
+                               instance_manager.Initialize (this);
                }
 
+               Action<TimeSpan> open_delegate, close_delegate;
+
                protected override IAsyncResult OnBeginOpen (
                        TimeSpan timeout, AsyncCallback callback, object state)
                {
-                       throw new NotImplementedException ();
+                       if (open_delegate == null)
+                               open_delegate = new Action<TimeSpan> (OnOpen);
+                       return open_delegate.BeginInvoke (timeout, callback, state);
                }
 
                protected override void OnEndOpen (IAsyncResult result)
                {
+                       open_delegate.EndInvoke (result);
                }
 
                protected override void OnOpen (TimeSpan timeout)
@@ -199,15 +216,18 @@ namespace System.ServiceModel
                protected override IAsyncResult OnBeginClose (
                        TimeSpan timeout, AsyncCallback callback, object state)
                {
-                       throw new NotImplementedException ();
+                       if (close_delegate == null)
+                               close_delegate = new Action<TimeSpan> (OnClose);
+                       return close_delegate.BeginInvoke (timeout, callback, state);
                }
 
                protected override void OnEndClose (IAsyncResult result)
                {
+                       close_delegate.EndInvoke (result);
                }
 
                protected override void OnClose (TimeSpan timeout)
                {
-               }               
+               }
        }
 }