update code

afifi-ins · afifi-ins · commit 259b43e7b243 · 2023-11-03T09:58:30.000+02:00
diff --git a/framework/wcf/Extensibility/Instancing/Lifetime/CS/client/Client.cs b/framework/wcf/Extensibility/Instancing/Lifetime/CS/client/Client.cs
@@ -7,19 +7,19 @@
 namespace Microsoft.ServiceModel.Samples
 {
     [ServiceContract(SessionMode = SessionMode.Required)]
-    interface IEchoService
+    internal interface IEchoService
     {
         [OperationContract]
         string Echo(string value);
     }
 
     public static class CustomHeader
     {
-        public static readonly string HeaderName = "InstanceId";
-        public static readonly string HeaderNamespace = "http://Microsoft.ServiceModel.Samples/Lifetime";
+        public const string HeaderName = "InstanceId";
+        public const string HeaderNamespace = "http://Microsoft.ServiceModel.Samples/Lifetime";
     }
 
-    class Program
+    internal class Program
     {
         static void Main(string[] args)
         {
diff --git a/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/CustomLeaseExtension.cs b/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/CustomLeaseExtension.cs
@@ -12,7 +12,7 @@
 
 namespace Microsoft.ServiceModel.Samples
 {
-    interface ICustomLease
+    internal interface ICustomLease
     {
         bool IsIdle { get; }
         InstanceContextIdleCallback Callback { get; set; }
@@ -22,41 +22,33 @@ interface ICustomLease
     /// This class contains the implementation of an extension to InstanceContext. 
     /// This enables extended lifetime for the InstanceContext.
     /// </summary>
-    class CustomLeaseExtension : IExtension<InstanceContext>, ICustomLease
+    internal class CustomLeaseExtension : IExtension<InstanceContext>, ICustomLease
     {
         #region Private Fields
 
         // Reference to the InstanceContext instance owns this 
         // extension instance.
-        InstanceContext owner;
+        private InstanceContext _owner;
+        private bool _isIdle;
+        private readonly object _thisLock;
+        private readonly Timer _idleTimer;
+        private readonly double _idleTimeout;
+        private InstanceContextIdleCallback _callback;
 
-        bool isIdle;
-        object thisLock;
-        Timer idleTimer;
-        double idleTimeout;
-        InstanceContextIdleCallback callback;
-        string instanceId;
-
-        public string InstanceId
-        {
-            get
-            {
-                return this.instanceId;
-            }
-        }
+        public string InstanceId { get; }
 
         #endregion
 
         #region Constructor
 
         public CustomLeaseExtension(double idleTimeout, string instanceId)
         {
-            owner = null;
-            isIdle = false;
-            thisLock = new object();
-            idleTimer = new Timer();
-            this.idleTimeout = idleTimeout;
-            this.instanceId = instanceId;
+            _owner = null;
+            _isIdle = false;
+            _thisLock = new object();
+            _idleTimer = new Timer();
+            _idleTimeout = idleTimeout;
+            InstanceId = instanceId;
         }
 
         #endregion
@@ -71,10 +63,7 @@ public CustomLeaseExtension(double idleTimeout, string instanceId)
         /// This method is called by WCF at the time it attaches this
         /// extension.
         /// </remarks>
-        public void Attach(InstanceContext owner)
-        {
-            this.owner = owner;
-        }
+        public void Attach(InstanceContext owner) => _owner = owner;
 
         public void Detach(InstanceContext owner)
         {
@@ -92,9 +81,9 @@ public bool IsIdle
         {
             get
             {
-                lock (thisLock)
+                lock (_thisLock)
                 {
-                    if (isIdle)
+                    if (_isIdle)
                     {
                         return true;
                     }
@@ -114,23 +103,23 @@ public InstanceContextIdleCallback Callback
         {
             get
             {
-                lock (thisLock)
+                lock (_thisLock)
                 {
-                    return callback;
+                    return _callback;
                 }
             }
             set
             {
                 // Immutable state.
-                if (idleTimer.Enabled)
+                if (_idleTimer.Enabled)
                 {
                     throw new InvalidOperationException(
                         ResourceHelper.GetString("ExCannotChangeCallback"));
                 }
 
-                lock (thisLock)
+                lock (_thisLock)
                 {
-                    callback = value;
+                    _callback = value;
                 }
             }
         }
@@ -142,43 +131,43 @@ public InstanceContextIdleCallback Callback
         /// <summary>
         /// Starts the timer.
         /// </summary>
-        void StartTimer()
+        private void StartTimer()
         {
-            lock (thisLock)
+            lock (_thisLock)
             {
-                idleTimer.Interval = idleTimeout;
-                idleTimer.Elapsed += new ElapsedEventHandler(idleTimer_Elapsed);
+                _idleTimer.Interval = _idleTimeout;
+                _idleTimer.Elapsed += new ElapsedEventHandler(idleTimer_Elapsed);
 
-                if (!idleTimer.Enabled)
+                if (!_idleTimer.Enabled)
                 {
-                    idleTimer.Start();
+                    _idleTimer.Start();
                 }
             }
         }
 
         public void StopTimer()
         {
-            lock (thisLock)
+            lock (_thisLock)
             {
-                if (idleTimer.Enabled)
+                if (_idleTimer.Enabled)
                 {
-                    idleTimer.Stop();
+                    _idleTimer.Stop();
                 }
             }
         }
 
         /// <summary>
         /// Timer elapsed event handler.
         /// </summary>        
-        void idleTimer_Elapsed(object sender, ElapsedEventArgs args)
+        private void idleTimer_Elapsed(object sender, ElapsedEventArgs args)
         {
-            lock (thisLock)
+            lock (_thisLock)
             {
                 StopTimer();
-                isIdle = true;
+                _isIdle = true;
                 Utility.WriteMessageToConsole(
                     ResourceHelper.GetString("MsgLeaseExpired"));
-                callback(owner);
+                _callback(_owner);
             }
         }
 
diff --git a/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/CustomLeaseTimeAttribute.cs b/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/CustomLeaseTimeAttribute.cs
@@ -17,20 +17,14 @@ public sealed class CustomLeaseTimeAttribute : Attribute, IServiceBehavior
     {
         #region Private Fields
 
-        double timeout;
-
         #endregion
 
         #region Properties
 
         /// <summary>
         /// Gets or sets the custom lease time.
         /// </summary>
-        public double Timeout
-        {
-            get { return this.timeout; }
-            set { this.timeout = value; }
-        }
+        public double Timeout { get; set; }
 
         #endregion
 
@@ -49,7 +43,7 @@ public void AddBindingParameters(ServiceDescription description, ServiceHostBase
         /// </remarks>
         public void ApplyDispatchBehavior(ServiceDescription description, ServiceHostBase serviceHostBase)
         {
-            CustomLifetimeLease customLease = new CustomLifetimeLease(timeout);
+            CustomLifetimeLease customLease = new CustomLifetimeLease(Timeout);
 
             foreach (ChannelDispatcherBase cdb in serviceHostBase.ChannelDispatchers)
             {
diff --git a/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/CustomLifetimeLease.cs b/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/CustomLifetimeLease.cs
@@ -9,8 +9,8 @@ namespace Microsoft.ServiceModel.Samples
 {
     public static class CustomHeader
     {
-        public static readonly string HeaderName = "InstanceId";
-        public static readonly string HeaderNamespace = "http://Microsoft.ServiceModel.Samples/Lifetime";
+        public const string HeaderName = "InstanceId";
+        public const string HeaderNamespace = "http://Microsoft.ServiceModel.Samples/Lifetime";
     }
 
     /// <summary>
@@ -19,13 +19,13 @@ public static class CustomHeader
     /// IShareableInstanceContextLifetime in order to be able 
     /// to attach to the service model layer.
     /// </summary>
-    class CustomLifetimeLease : IInstanceContextProvider
+    internal class CustomLifetimeLease : IInstanceContextProvider
     {
         #region Private Fields
 
-        double timeout;
-        bool isIdle;
-        Dictionary<string, InstanceContext> instanceContextCache;
+        private readonly double _timeout;
+        private bool _isIdle;
+        private readonly Dictionary<string, InstanceContext> _instanceContextCache;
 
         // Lock must be acquired on this before
         // accessing the isIdle member.
@@ -38,7 +38,7 @@ class CustomLifetimeLease : IInstanceContextProvider
         // it will result in a considerable perf hit or 
         // even cause dead locks depending on how 
         // service model handles threads. 
-        object thisLock;
+        private readonly object _thisLock;
 
         #endregion
 
@@ -49,9 +49,9 @@ class CustomLifetimeLease : IInstanceContextProvider
         /// </summary>
         public CustomLifetimeLease(double timeout)
         {
-            this.timeout = timeout;
-            thisLock = new object();
-            this.instanceContextCache = new Dictionary<string, InstanceContext>();
+            _timeout = timeout;
+            _thisLock = new object();
+            _instanceContextCache = new Dictionary<string, InstanceContext>();
         }
 
         #endregion
@@ -60,9 +60,9 @@ public CustomLifetimeLease(double timeout)
 
         public bool IsIdle(InstanceContext instanceContext)
         {
-            lock (thisLock)
+            lock (_thisLock)
             {
-                if (isIdle)
+                if (_isIdle)
                 {
                     Utility.WriteMessageToConsole(
                         ResourceHelper.GetString("MsgIdle"));
@@ -73,23 +73,23 @@ public bool IsIdle(InstanceContext instanceContext)
                         ResourceHelper.GetString("MsgNotIdle"));
                 }
 
-                bool idleCopy = isIdle;
-                isIdle = false;
+                bool idleCopy = _isIdle;
+                _isIdle = false;
                 return idleCopy;
             }
         }
 
         public void NotifyIdle(InstanceContextIdleCallback callback,
             InstanceContext instanceContext)
         {
-            lock (thisLock)
+            lock (_thisLock)
             {
                 ICustomLease customLease =
                     instanceContext.Extensions.Find<ICustomLease>();
 
                 customLease.Callback = callback;
-                isIdle = customLease.IsIdle;
-                if (isIdle)
+                _isIdle = customLease.IsIdle;
+                if (_isIdle)
                 {
                     callback(instanceContext);
                 }
@@ -110,11 +110,11 @@ public InstanceContext GetExistingInstanceContext(System.ServiceModel.Channels.M
             if (message.Headers.FindHeader(CustomHeader.HeaderName, CustomHeader.HeaderNamespace) != -1)
             {
                 string sharingId = message.Headers.GetHeader<string>(CustomHeader.HeaderName, CustomHeader.HeaderNamespace);
-                if (sharingId != null && instanceContextCache.ContainsKey(sharingId))
+                if (sharingId != null && _instanceContextCache.ContainsKey(sharingId))
                 {
                     Utility.WriteMessageToConsole(string.Format(ResourceHelper.GetString("InstanceContextLookup"), sharingId));
                     //Retrieve the InstanceContext from the map
-                    InstanceContext context = instanceContextCache[sharingId];
+                    InstanceContext context = _instanceContextCache[sharingId];
                     if (context != null)
                     {
                         //Before returning, stop the timer on this InstanceContext
@@ -123,7 +123,7 @@ public InstanceContext GetExistingInstanceContext(System.ServiceModel.Channels.M
                         extension.StopTimer();
 
                         Utility.WriteMessageToConsole(ResourceHelper.GetString("CachedInstanceContextFound"));
-                        return instanceContextCache[sharingId];
+                        return _instanceContextCache[sharingId];
                     }
                 }
             }
@@ -152,13 +152,13 @@ public void InitializeInstanceContext(InstanceContext instanceContext, System.Se
             Utility.WriteMessageToConsole(string.Format(ResourceHelper.GetString("InstanceContextAddedToCache"), headerId));
 
             //Add this to the Cache
-            this.instanceContextCache[headerId] = instanceContext;
+            _instanceContextCache[headerId] = instanceContext;
 
             //Register the Closing event of this InstancContext so it can be removed from the collection
-            instanceContext.Closing += this.RemoveInstanceContext;
+            instanceContext.Closing += RemoveInstanceContext;
 
             IExtension<InstanceContext> customLeaseExtension =
-                new CustomLeaseExtension(timeout, headerId);
+                new CustomLeaseExtension(_timeout, headerId);
             instanceContext.Extensions.Add(customLeaseExtension);
         }
 
@@ -167,10 +167,10 @@ public void RemoveInstanceContext(object o, EventArgs args)
             InstanceContext context = o as InstanceContext;
             CustomLeaseExtension extension = context.Extensions.Find<CustomLeaseExtension>();
             string id = (extension != null) ? extension.InstanceId : null;
-            if (this.instanceContextCache[id] != null)
+            if (_instanceContextCache[id] != null)
             {
                 Utility.WriteMessageToConsole(string.Format(ResourceHelper.GetString("InstanceContextRemovedFromCache"), id));
-                this.instanceContextCache.Remove(id);
+                _instanceContextCache.Remove(id);
             }
         }
         #endregion
diff --git a/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/ResourceHelper.cs b/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/ResourceHelper.cs
@@ -13,7 +13,7 @@ namespace Microsoft.ServiceModel.Samples
     /// This is a helper class for accessing the 
     /// resource file.
     /// </summary>
-    class ResourceHelper
+    internal class ResourceHelper
     {
 
         #region Public Static Members
diff --git a/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/Utility.cs b/framework/wcf/Extensibility/Instancing/Lifetime/CS/extensions/Utility.cs
@@ -4,7 +4,7 @@
 
 namespace Microsoft.ServiceModel.Samples
 {
-    class Utility
+    internal class Utility
     {
         public static void WriteMessageToConsole(string message)
         {
diff --git a/framework/wcf/Extensibility/Instancing/Lifetime/CS/service/Service.cs b/framework/wcf/Extensibility/Instancing/Lifetime/CS/service/Service.cs

Original file line number	Diff line number	Diff line change
`@@ -7,19 +7,19 @@`
`7`	`7`	`namespace Microsoft.ServiceModel.Samples`
`8`	`8`	`{`
`9`	`9`	`[ServiceContract(SessionMode = SessionMode.Required)]`
`10`		`- interface IEchoService`
	`10`	`+ internal interface IEchoService`
`11`	`11`	`{`
`12`	`12`	`[OperationContract]`
`13`	`13`	`string Echo(string value);`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`public static class CustomHeader`
`17`	`17`	`{`
`18`		`- public static readonly string HeaderName = "InstanceId";`
`19`		`- public static readonly string HeaderNamespace = "http://Microsoft.ServiceModel.Samples/Lifetime";`
	`18`	`+ public const string HeaderName = "InstanceId";`
	`19`	`+ public const string HeaderNamespace = "http://Microsoft.ServiceModel.Samples/Lifetime";`
`20`	`20`	`}`
`21`	`21`
`22`		`- class Program`
	`22`	`+ internal class Program`
`23`	`23`	`{`
`24`	`24`	`static void Main(string[] args)`
`25`	`25`	`{`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@`
`12`	`12`
`13`	`13`	`namespace Microsoft.ServiceModel.Samples`
`14`	`14`	`{`
`15`		`- interface ICustomLease`
	`15`	`+ internal interface ICustomLease`
`16`	`16`	`{`
`17`	`17`	`bool IsIdle { get; }`
`18`	`18`	`InstanceContextIdleCallback Callback { get; set; }`
`@@ -22,41 +22,33 @@ interface ICustomLease`
`22`	`22`	`/// This class contains the implementation of an extension to InstanceContext.`
`23`	`23`	`/// This enables extended lifetime for the InstanceContext.`
`24`	`24`	`/// </summary>`
`25`		`- class CustomLeaseExtension : IExtension<InstanceContext>, ICustomLease`
	`25`	`+ internal class CustomLeaseExtension : IExtension<InstanceContext>, ICustomLease`
`26`	`26`	`{`
`27`	`27`	`#region Private Fields`
`28`	`28`
`29`	`29`	`// Reference to the InstanceContext instance owns this`
`30`	`30`	`// extension instance.`
`31`		`- InstanceContext owner;`
	`31`	`+ private InstanceContext _owner;`
	`32`	`+ private bool _isIdle;`
	`33`	`+ private readonly object _thisLock;`
	`34`	`+ private readonly Timer _idleTimer;`
	`35`	`+ private readonly double _idleTimeout;`
	`36`	`+ private InstanceContextIdleCallback _callback;`
`32`	`37`
`33`		`- bool isIdle;`
`34`		`- object thisLock;`
`35`		`- Timer idleTimer;`
`36`		`- double idleTimeout;`
`37`		`- InstanceContextIdleCallback callback;`
`38`		`- string instanceId;`
`39`		`-`
`40`		`- public string InstanceId`
`41`		`- {`
`42`		`- get`
`43`		`- {`
`44`		`- return this.instanceId;`
`45`		`- }`
`46`		`- }`
	`38`	`+ public string InstanceId { get; }`
`47`	`39`
`48`	`40`	`#endregion`
`49`	`41`
`50`	`42`	`#region Constructor`
`51`	`43`
`52`	`44`	`public CustomLeaseExtension(double idleTimeout, string instanceId)`
`53`	`45`	`{`
`54`		`- owner = null;`
`55`		`- isIdle = false;`
`56`		`- thisLock = new object();`
`57`		`- idleTimer = new Timer();`
`58`		`- this.idleTimeout = idleTimeout;`
`59`		`- this.instanceId = instanceId;`
	`46`	`+ _owner = null;`
	`47`	`+ _isIdle = false;`
	`48`	`+ _thisLock = new object();`
	`49`	`+ _idleTimer = new Timer();`
	`50`	`+ _idleTimeout = idleTimeout;`
	`51`	`+ InstanceId = instanceId;`
`60`	`52`	`}`
`61`	`53`
`62`	`54`	`#endregion`
`@@ -71,10 +63,7 @@ public CustomLeaseExtension(double idleTimeout, string instanceId)`
`71`	`63`	`/// This method is called by WCF at the time it attaches this`
`72`	`64`	`/// extension.`
`73`	`65`	`/// </remarks>`
`74`		`- public void Attach(InstanceContext owner)`
`75`		`- {`
`76`		`- this.owner = owner;`
`77`		`- }`
	`66`	`+ public void Attach(InstanceContext owner) => _owner = owner;`
`78`	`67`
`79`	`68`	`public void Detach(InstanceContext owner)`
`80`	`69`	`{`
`@@ -92,9 +81,9 @@ public bool IsIdle`
`92`	`81`	`{`
`93`	`82`	`get`
`94`	`83`	`{`
`95`		`- lock (thisLock)`
	`84`	`+ lock (_thisLock)`
`96`	`85`	`{`
`97`		`- if (isIdle)`
	`86`	`+ if (_isIdle)`
`98`	`87`	`{`
`99`	`88`	`return true;`
`100`	`89`	`}`
`@@ -114,23 +103,23 @@ public InstanceContextIdleCallback Callback`
`114`	`103`	`{`
`115`	`104`	`get`
`116`	`105`	`{`
`117`		`- lock (thisLock)`
	`106`	`+ lock (_thisLock)`
`118`	`107`	`{`
`119`		`- return callback;`
	`108`	`+ return _callback;`
`120`	`109`	`}`
`121`	`110`	`}`
`122`	`111`	`set`
`123`	`112`	`{`
`124`	`113`	`// Immutable state.`
`125`		`- if (idleTimer.Enabled)`
	`114`	`+ if (_idleTimer.Enabled)`
`126`	`115`	`{`
`127`	`116`	`throw new InvalidOperationException(`
`128`	`117`	`ResourceHelper.GetString("ExCannotChangeCallback"));`
`129`	`118`	`}`
`130`	`119`
`131`		`- lock (thisLock)`
	`120`	`+ lock (_thisLock)`
`132`	`121`	`{`
`133`		`- callback = value;`
	`122`	`+ _callback = value;`
`134`	`123`	`}`
`135`	`124`	`}`
`136`	`125`	`}`
`@@ -142,43 +131,43 @@ public InstanceContextIdleCallback Callback`
`142`	`131`	`/// <summary>`
`143`	`132`	`/// Starts the timer.`
`144`	`133`	`/// </summary>`
`145`		`- void StartTimer()`
	`134`	`+ private void StartTimer()`
`146`	`135`	`{`
`147`		`- lock (thisLock)`
	`136`	`+ lock (_thisLock)`
`148`	`137`	`{`
`149`		`- idleTimer.Interval = idleTimeout;`
`150`		`- idleTimer.Elapsed += new ElapsedEventHandler(idleTimer_Elapsed);`
	`138`	`+ _idleTimer.Interval = _idleTimeout;`
	`139`	`+ _idleTimer.Elapsed += new ElapsedEventHandler(idleTimer_Elapsed);`
`151`	`140`
`152`		`- if (!idleTimer.Enabled)`
	`141`	`+ if (!_idleTimer.Enabled)`
`153`	`142`	`{`
`154`		`- idleTimer.Start();`
	`143`	`+ _idleTimer.Start();`
`155`	`144`	`}`
`156`	`145`	`}`
`157`	`146`	`}`
`158`	`147`
`159`	`148`	`public void StopTimer()`
`160`	`149`	`{`
`161`		`- lock (thisLock)`
	`150`	`+ lock (_thisLock)`
`162`	`151`	`{`
`163`		`- if (idleTimer.Enabled)`
	`152`	`+ if (_idleTimer.Enabled)`
`164`	`153`	`{`
`165`		`- idleTimer.Stop();`
	`154`	`+ _idleTimer.Stop();`
`166`	`155`	`}`
`167`	`156`	`}`
`168`	`157`	`}`
`169`	`158`
`170`	`159`	`/// <summary>`
`171`	`160`	`/// Timer elapsed event handler.`
`172`	`161`	`/// </summary>`
`173`		`- void idleTimer_Elapsed(object sender, ElapsedEventArgs args)`
	`162`	`+ private void idleTimer_Elapsed(object sender, ElapsedEventArgs args)`
`174`	`163`	`{`
`175`		`- lock (thisLock)`
	`164`	`+ lock (_thisLock)`
`176`	`165`	`{`
`177`	`166`	`StopTimer();`
`178`		`- isIdle = true;`
	`167`	`+ _isIdle = true;`
`179`	`168`	`Utility.WriteMessageToConsole(`
`180`	`169`	`ResourceHelper.GetString("MsgLeaseExpired"));`
`181`		`- callback(owner);`
	`170`	`+ _callback(_owner);`
`182`	`171`	`}`
`183`	`172`	`}`
`184`	`173`
Original file line number	Diff line number	Diff line change
`@@ -9,8 +9,8 @@ namespace Microsoft.ServiceModel.Samples`
`9`	`9`	`{`
`10`	`10`	`public static class CustomHeader`
`11`	`11`	`{`
`12`		`- public static readonly string HeaderName = "InstanceId";`
`13`		`- public static readonly string HeaderNamespace = "http://Microsoft.ServiceModel.Samples/Lifetime";`
	`12`	`+ public const string HeaderName = "InstanceId";`
	`13`	`+ public const string HeaderNamespace = "http://Microsoft.ServiceModel.Samples/Lifetime";`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`/// <summary>`
`@@ -19,13 +19,13 @@ public static class CustomHeader`
`19`	`19`	`/// IShareableInstanceContextLifetime in order to be able`
`20`	`20`	`/// to attach to the service model layer.`
`21`	`21`	`/// </summary>`
`22`		`- class CustomLifetimeLease : IInstanceContextProvider`
	`22`	`+ internal class CustomLifetimeLease : IInstanceContextProvider`
`23`	`23`	`{`
`24`	`24`	`#region Private Fields`
`25`	`25`
`26`		`- double timeout;`
`27`		`- bool isIdle;`
`28`		`- Dictionary<string, InstanceContext> instanceContextCache;`
	`26`	`+ private readonly double _timeout;`
	`27`	`+ private bool _isIdle;`
	`28`	`+ private readonly Dictionary<string, InstanceContext> _instanceContextCache;`
`29`	`29`
`30`	`30`	`// Lock must be acquired on this before`
`31`	`31`	`// accessing the isIdle member.`
`@@ -38,7 +38,7 @@ class CustomLifetimeLease : IInstanceContextProvider`
`38`	`38`	`// it will result in a considerable perf hit or`
`39`	`39`	`// even cause dead locks depending on how`
`40`	`40`	`// service model handles threads.`
`41`		`- object thisLock;`
	`41`	`+ private readonly object _thisLock;`
`42`	`42`
`43`	`43`	`#endregion`
`44`	`44`
`@@ -49,9 +49,9 @@ class CustomLifetimeLease : IInstanceContextProvider`
`49`	`49`	`/// </summary>`
`50`	`50`	`public CustomLifetimeLease(double timeout)`
`51`	`51`	`{`
`52`		`- this.timeout = timeout;`
`53`		`- thisLock = new object();`
`54`		`- this.instanceContextCache = new Dictionary<string, InstanceContext>();`
	`52`	`+ _timeout = timeout;`
	`53`	`+ _thisLock = new object();`
	`54`	`+ _instanceContextCache = new Dictionary<string, InstanceContext>();`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`#endregion`
`@@ -60,9 +60,9 @@ public CustomLifetimeLease(double timeout)`
`60`	`60`
`61`	`61`	`public bool IsIdle(InstanceContext instanceContext)`
`62`	`62`	`{`
`63`		`- lock (thisLock)`
	`63`	`+ lock (_thisLock)`
`64`	`64`	`{`
`65`		`- if (isIdle)`
	`65`	`+ if (_isIdle)`
`66`	`66`	`{`
`67`	`67`	`Utility.WriteMessageToConsole(`
`68`	`68`	`ResourceHelper.GetString("MsgIdle"));`
`@@ -73,23 +73,23 @@ public bool IsIdle(InstanceContext instanceContext)`
`73`	`73`	`ResourceHelper.GetString("MsgNotIdle"));`
`74`	`74`	`}`
`75`	`75`
`76`		`- bool idleCopy = isIdle;`
`77`		`- isIdle = false;`
	`76`	`+ bool idleCopy = _isIdle;`
	`77`	`+ _isIdle = false;`
`78`	`78`	`return idleCopy;`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`public void NotifyIdle(InstanceContextIdleCallback callback,`
`83`	`83`	`InstanceContext instanceContext)`
`84`	`84`	`{`
`85`		`- lock (thisLock)`
	`85`	`+ lock (_thisLock)`
`86`	`86`	`{`
`87`	`87`	`ICustomLease customLease =`
`88`	`88`	`instanceContext.Extensions.Find<ICustomLease>();`
`89`	`89`
`90`	`90`	`customLease.Callback = callback;`
`91`		`- isIdle = customLease.IsIdle;`
`92`		`- if (isIdle)`
	`91`	`+ _isIdle = customLease.IsIdle;`
	`92`	`+ if (_isIdle)`
`93`	`93`	`{`
`94`	`94`	`callback(instanceContext);`
`95`	`95`	`}`
`@@ -110,11 +110,11 @@ public InstanceContext GetExistingInstanceContext(System.ServiceModel.Channels.M`
`110`	`110`	`if (message.Headers.FindHeader(CustomHeader.HeaderName, CustomHeader.HeaderNamespace) != -1)`
`111`	`111`	`{`
`112`	`112`	`string sharingId = message.Headers.GetHeader<string>(CustomHeader.HeaderName, CustomHeader.HeaderNamespace);`
`113`		`- if (sharingId != null && instanceContextCache.ContainsKey(sharingId))`
	`113`	`+ if (sharingId != null && _instanceContextCache.ContainsKey(sharingId))`
`114`	`114`	`{`
`115`	`115`	`Utility.WriteMessageToConsole(string.Format(ResourceHelper.GetString("InstanceContextLookup"), sharingId));`
`116`	`116`	`//Retrieve the InstanceContext from the map`
`117`		`- InstanceContext context = instanceContextCache[sharingId];`
	`117`	`+ InstanceContext context = _instanceContextCache[sharingId];`
`118`	`118`	`if (context != null)`
`119`	`119`	`{`
`120`	`120`	`//Before returning, stop the timer on this InstanceContext`
`@@ -123,7 +123,7 @@ public InstanceContext GetExistingInstanceContext(System.ServiceModel.Channels.M`
`123`	`123`	`extension.StopTimer();`
`124`	`124`
`125`	`125`	`Utility.WriteMessageToConsole(ResourceHelper.GetString("CachedInstanceContextFound"));`
`126`		`- return instanceContextCache[sharingId];`
	`126`	`+ return _instanceContextCache[sharingId];`
`127`	`127`	`}`
`128`	`128`	`}`
`129`	`129`	`}`
`@@ -152,13 +152,13 @@ public void InitializeInstanceContext(InstanceContext instanceContext, System.Se`
`152`	`152`	`Utility.WriteMessageToConsole(string.Format(ResourceHelper.GetString("InstanceContextAddedToCache"), headerId));`
`153`	`153`
`154`	`154`	`//Add this to the Cache`
`155`		`- this.instanceContextCache[headerId] = instanceContext;`
	`155`	`+ _instanceContextCache[headerId] = instanceContext;`
`156`	`156`
`157`	`157`	`//Register the Closing event of this InstancContext so it can be removed from the collection`
`158`		`- instanceContext.Closing += this.RemoveInstanceContext;`
	`158`	`+ instanceContext.Closing += RemoveInstanceContext;`
`159`	`159`
`160`	`160`	`IExtension<InstanceContext> customLeaseExtension =`
`161`		`- new CustomLeaseExtension(timeout, headerId);`
	`161`	`+ new CustomLeaseExtension(_timeout, headerId);`
`162`	`162`	`instanceContext.Extensions.Add(customLeaseExtension);`
`163`	`163`	`}`
`164`	`164`
`@@ -167,10 +167,10 @@ public void RemoveInstanceContext(object o, EventArgs args)`
`167`	`167`	`InstanceContext context = o as InstanceContext;`
`168`	`168`	`CustomLeaseExtension extension = context.Extensions.Find<CustomLeaseExtension>();`
`169`	`169`	`string id = (extension != null) ? extension.InstanceId : null;`
`170`		`- if (this.instanceContextCache[id] != null)`
	`170`	`+ if (_instanceContextCache[id] != null)`
`171`	`171`	`{`
`172`	`172`	`Utility.WriteMessageToConsole(string.Format(ResourceHelper.GetString("InstanceContextRemovedFromCache"), id));`
`173`		`- this.instanceContextCache.Remove(id);`
	`173`	`+ _instanceContextCache.Remove(id);`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`	`#endregion`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace Microsoft.ServiceModel.Samples`
`13`	`13`	`/// This is a helper class for accessing the`
`14`	`14`	`/// resource file.`
`15`	`15`	`/// </summary>`
`16`		`- class ResourceHelper`
	`16`	`+ internal class ResourceHelper`
`17`	`17`	`{`
`18`	`18`
`19`	`19`	`#region Public Static Members`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`
`5`	`5`	`namespace Microsoft.ServiceModel.Samples`
`6`	`6`	`{`
`7`		`- class Utility`
	`7`	`+ internal class Utility`
`8`	`8`	`{`
`9`	`9`	`public static void WriteMessageToConsole(string message)`
`10`	`10`	`{`