diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs
index 9813e890da..60a34fe522 100644
--- a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs
+++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs
@@ -412,28 +412,26 @@ namespace Debugger
 			}
 		}
 		
-		internal ICorDebugValue GetArgumentValue(int index)
-		{
-			// Non-static functions include 'this' as first argument
-			return CorILFrame.GetArgument((uint)(IsStatic? index : (index + 1)));
-		}
-		
 		public Variable GetArgumentVariable(int index)
 		{
 			return new Variable(debugger,
 			                    GetParameterName(index),
-			                    delegate {
-			                    	if (this.HasExpired) {
-			                    		return new UnavailableValue(debugger, "Function has expired");
-			                    	} else {
-			                    		try {
-			                    			return Value.CreateValue(debugger, GetArgumentValue(index));
-			                    		} catch (COMException e) {
-			                    			if ((uint)e.ErrorCode == 0x80131304) return new UnavailableValue(debugger, "Unavailable in optimized code");
-			                    			throw;
-			                    		}
-			                    	}
-			                    });
+			                    delegate { return GetArgumentValue(index); });
+		}
+		
+		Value GetArgumentValue(int index)
+		{
+			if (this.HasExpired) {
+				return new UnavailableValue(debugger, "Function has expired");
+			} else {
+				try {
+					// Non-static functions include 'this' as first argument
+					return Value.CreateValue(debugger, CorILFrame.GetArgument((uint)(IsStatic? index : (index + 1))));
+				} catch (COMException e) {
+					if ((uint)e.ErrorCode == 0x80131304) return new UnavailableValue(debugger, "Unavailable in optimized code");
+					throw;
+				}
+			}
 		}
 		
 		public IEnumerable<Variable> ArgumentVariables {
@@ -473,20 +471,23 @@ namespace Debugger
 		{
 			return new Variable(debugger,
 			                    symVar.Name,
-			                    delegate {
-			                    	if (this.HasExpired) {
-			                    		return new UnavailableValue(debugger, "Function has expired");
-			                    	} else {
-			                    		ICorDebugValue corValue;
-			                    		try {
-			                    			corValue = CorILFrame.GetLocalVariable((uint)symVar.AddressField1);
-			                    		} catch (COMException e) {
-			                    			if ((uint)e.ErrorCode == 0x80131304) return new UnavailableValue(debugger, "Unavailable in optimized code");
-			                    			throw;
-			                    		}
-			                    		return Value.CreateValue(debugger, corValue);
-			                    	}
-			                    });
+			                    delegate { return GetValueOfLocalVariable(symVar); });
+		}
+		
+		Value GetValueOfLocalVariable(ISymUnmanagedVariable symVar)
+		{
+			if (this.HasExpired) {
+				return new UnavailableValue(debugger, "Function has expired");
+			} else {
+				ICorDebugValue corValue;
+				try {
+					corValue = CorILFrame.GetLocalVariable((uint)symVar.AddressField1);
+				} catch (COMException e) {
+					if ((uint)e.ErrorCode == 0x80131304) return new UnavailableValue(debugger, "Unavailable in optimized code");
+					throw;
+				}
+				return Value.CreateValue(debugger, corValue);
+			}
 		}
 	}
 }
diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs
index 0721f27cc7..96ac91f22c 100644
--- a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs
+++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs
@@ -106,20 +106,23 @@ namespace Debugger
 			
 			return new Variable(debugger,
 			                    elementName,
-			                    delegate {
-			                    	ArrayValue updatedVal = getter() as ArrayValue;
-			                    	if (this.IsEquivalentValue(updatedVal)) {
-			                    		ICorDebugValue element;
-			                    		unsafe {
-			                    			fixed (void* pIndices = indices) {
-			                    				element = updatedVal.corArrayValue.GetElement(rank, new IntPtr(pIndices));
-			                    			}
-			                    		}
-			                    		return Value.CreateValue(debugger, element);
-			                    	} else {
-			                    		return new UnavailableValue(debugger, "Value is not array");
-			                    	}
-			                    });
+			                    delegate { return GetValueOfItem(indices, getter); });
+		}
+		
+		Value GetValueOfItem(uint[] indices, ValueGetter getter)
+		{
+			ArrayValue updatedVal = getter() as ArrayValue;
+			if (this.IsEquivalentValue(updatedVal)) {
+				ICorDebugValue element;
+				unsafe {
+					fixed (void* pIndices = indices) {
+						element = updatedVal.corArrayValue.GetElement(rank, new IntPtr(pIndices));
+					}
+				}
+				return Value.CreateValue(debugger, element);
+			} else {
+				return new UnavailableValue(debugger, "Value is not array");
+			}
 		}
 		
 		public override bool MayHaveSubVariables {
diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValue.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValue.cs
index 271fae0f0a..4bd2359d55 100644
--- a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValue.cs
+++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValue.cs
@@ -146,15 +146,18 @@ namespace Debugger
 				                               field.Name,
 				                               field.IsStatic,
 				                               field.IsPublic,
-				                               delegate {
-				                               	Value updatedVal = getter();
-				                               	if (updatedVal is UnavailableValue) return updatedVal;
-				                               	if (this.IsEquivalentValue(updatedVal)) {
-				                               		return GetValue(updatedVal, field);
-				                               	} else {
-				                               		return new UnavailableValue(debugger, "Object type changed");
-				                               	}
-				                               });
+				                               delegate { return GetValueOfField(field, getter); });
+			}
+		}
+		
+		Value GetValueOfField(FieldProps field, ValueGetter getter)
+		{
+			Value updatedVal = getter();
+			if (updatedVal is UnavailableValue) return updatedVal;
+			if (this.IsEquivalentValue(updatedVal)) {
+				return GetValue(updatedVal, field);
+			} else {
+				return new UnavailableValue(debugger, "Object type changed");
 			}
 		}
 		
@@ -167,35 +170,36 @@ namespace Debugger
 					                                  method.Name.Remove(0, 4),
 					                                  method.IsStatic,
 					                                  method.IsPublic,
-					                                  delegate {
-					                                  	Value updatedVal = getter();
-					                                  	if (updatedVal is UnavailableValue) return null;
-					                                  	if (this.IsEquivalentValue(updatedVal) && ((ObjectValue)updatedVal).SoftReference != null) {
-					                                  		return CreatePropertyEval(method, getter);
-					                                  	} else {
-					                                  		return null;
-					                                  	}
-					                                  });
+					                                  delegate { return CreatePropertyEval(method, getter); });
 				}
 			}
 		}
 		
 		Eval CreatePropertyEval(MethodProps method, ValueGetter getter)
 		{
-			ICorDebugFunction evalCorFunction = Module.CorModule.GetFunctionFromToken(method.Token);
-			
-			return new Eval(debugger, evalCorFunction, delegate {
-			                	Value updatedVal = getter();
-			                	if (this.IsEquivalentValue(updatedVal) && ((ObjectValue)updatedVal).SoftReference != null) {
-				                	if (method.IsStatic) {
-				                		return new ICorDebugValue[] {};
-				                	} else {
-				                		return new ICorDebugValue[] {((ObjectValue)updatedVal).SoftReference.CastTo<ICorDebugValue>()};
-				                	}
-			                	} else {
-			                		return null;
-			                	}
-			                });
+			Value updatedVal = getter();
+			if (updatedVal is UnavailableValue) return null;
+			if (this.IsEquivalentValue(updatedVal) && ((ObjectValue)updatedVal).SoftReference != null) {
+				ICorDebugFunction evalCorFunction = Module.CorModule.GetFunctionFromToken(method.Token);
+				
+				return new Eval(debugger, evalCorFunction, delegate { return GetArgsForEval(method, getter); });
+			} else {
+				return null;
+			}
+		}
+		
+		ICorDebugValue[] GetArgsForEval(MethodProps method, ValueGetter getter)
+		{
+			Value updatedVal = getter();
+			if (this.IsEquivalentValue(updatedVal) && ((ObjectValue)updatedVal).SoftReference != null) {
+				if (method.IsStatic) {
+					return new ICorDebugValue[] {};
+				} else {
+					return new ICorDebugValue[] {((ObjectValue)updatedVal).SoftReference.CastTo<ICorDebugValue>()};
+				}
+			} else {
+				return null;
+			}
 		}
 		
 		public override bool IsEquivalentValue(Value val)
@@ -231,20 +235,23 @@ namespace Debugger
 			if (HasBaseClass) {
 				return new Variable(debugger,
 				                    "<Base class>",
-				                    delegate {
-				                    	Value updatedVal = getter();
-				                    	if (updatedVal is UnavailableValue) return updatedVal;
-				                    	if (this.IsEquivalentValue(updatedVal)) {
-				                    		return ((ObjectValue)updatedVal).BaseClass;
-				                    	} else {
-				                    		return new UnavailableValue(debugger, "Object type changed");
-				                    	}
-				                    });
+				                    delegate { return GetBaseClassValue(getter); });
 			} else {
 				return null;
 			}
 		}
 		
+		Value GetBaseClassValue(ValueGetter getter)
+		{
+			Value updatedVal = getter();
+			if (updatedVal is UnavailableValue) return updatedVal;
+			if (this.IsEquivalentValue(updatedVal)) {
+				return ((ObjectValue)updatedVal).BaseClass;
+			} else {
+				return new UnavailableValue(debugger, "Object type changed");
+			}
+		}
+		
 		public unsafe ObjectValue BaseClass {
 			get	{
 				if (baseClass == null) baseClass = GetBaseClass();
diff --git a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/PropertyVariable.cs b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/PropertyVariable.cs
index 109239235d..7630245812 100644
--- a/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/PropertyVariable.cs
+++ b/src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/PropertyVariable.cs
@@ -24,13 +24,16 @@ namespace Debugger
 		internal PropertyVariable(NDebugger debugger, string name, bool isStatic, bool isPublic, EvalCreator evalCreator):base(debugger, name, isStatic, isPublic, null)
 		{
 			this.evalCreator = evalCreator;
-			this.valueGetter = delegate {
-			                   	if (Eval != null) {
-			                   		return Eval.Result;
-			                   	} else {
-			                   		return new UnavailableValue(debugger, "Property has expired");
-			                   	}
-			                   };
+			this.valueGetter = delegate { return GetValueOfResult(); };
+		}
+		
+		Value GetValueOfResult()
+		{
+			if (Eval != null) {
+				return Eval.Result;
+			} else {
+				return new UnavailableValue(debugger, "Property has expired");
+			}
 		}
 		
 		public bool IsEvaluated {