Last out parameter used as return value in CorDebugger wrapper; Methods starting with Get or Is converted to properties

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@933 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Breakpoints/Breakpoint.cs

@@ -49,9 +49,7 @@ namespace Debugger
 		public bool Enabled {
 			get {
 				if (HadBeenSet) {
-					int active;
+					enabled = (corBreakpoint.IsActive == 1);
-					corBreakpoint.IsActive(out active);
-					enabled = (active == 1);
 				}
 				return enabled;
 			}
@@ -127,10 +125,7 @@ namespace Debugger
 				return false;
 			}
 			
-			ICorDebugCode code;
+			corBreakpoint = corFunction.ILCode.CreateBreakpoint((uint)ilOffset);
-			corFunction.GetILCode(out code);
-
-			code.CreateBreakpoint((uint)ilOffset, out corBreakpoint);
 			
 			hadBeenSet = true;
 			corBreakpoint.Activate(enabled?1:0);

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Debugger/Internal/ManagedCallback.cs

@@ -59,10 +59,7 @@ namespace Debugger
 		{
 			EnterCallback(name);
 			
-			ICorDebugProcess pProcess;
+			callingProcess = debugger.GetProcess(pAppDomain.Process);
-			pAppDomain.GetProcess(out pProcess);
-			
-			callingProcess = debugger.GetProcess(pProcess);
 			callingProcess.IsRunning = false;
 		}
 		

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Modules/Module.cs

@@ -22,9 +22,6 @@ namespace Debugger
 		bool   unloaded = false;
 		string fullPath;
 		string fullPathPDB;
-		ulong  baseAdress;
-		int    isDynamic;
-		int    isInMemory;
 		
 		int orderOfLoading = 0;
 		readonly ICorDebugModule corModule;
@@ -63,19 +60,19 @@ namespace Debugger
 		
 		public ulong BaseAdress { 
 			get {
-				return baseAdress;
+				return corModule.BaseAddress;
 			} 
 		}
 		
 		public bool IsDynamic { 
 			get {
-				return isDynamic == 1;
+				return corModule.IsDynamic == 1;
 			} 
 		}
 		
 		public bool IsInMemory { 
 			get {
-				return isInMemory == 1;
+				return corModule.IsInMemory == 1;
 			} 
 		}
 		
@@ -129,15 +126,8 @@ namespace Debugger
 			
 			corModule = pModule;
 			
-			pModule.GetBaseAddress(out baseAdress);
-			
-			pModule.IsDynamic(out isDynamic);
-			
-			pModule.IsInMemory(out isInMemory);
-			
 			Guid metaDataInterfaceGuid = new Guid("{ 0x7dac8207, 0xd3ae, 0x4c75, { 0x9b, 0x67, 0x92, 0x80, 0x1a, 0x49, 0x7d, 0x44 } }");
-			object pMetaDataInterface;
+			object pMetaDataInterface = pModule.GetMetaDataInterface(ref metaDataInterfaceGuid);
-			pModule.GetMetaDataInterface(ref metaDataInterfaceGuid, out pMetaDataInterface);
 			
 			metaDataInterface = (IMetaDataImport) pMetaDataInterface;
 			

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Exception.cs

@@ -40,7 +40,7 @@ namespace Debugger
 			creationTime = DateTime.Now;
 			this.debugger = thread.Debugger;
 			this.thread = thread;
-			thread.CorThread.GetCurrentException(out corValue);
+			corValue = thread.CorThread.CurrentException;
 			exceptionType = thread.CurrentExceptionType;
 			runtimeValue = Value.CreateValue(debugger, corValue);
 			runtimeValueException = runtimeValue as ObjectValue;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Function.cs

@@ -65,9 +65,7 @@ namespace Debugger
 
 		internal ICorDebugClass ContaingClass {
 			get {
-				ICorDebugClass corClass;
+				return corFunction.Class;
-				corFunction.GetClass(out corClass);
-				return corClass;
 			}
 		}
 		
@@ -88,9 +86,7 @@ namespace Debugger
 					if (this.HasExpired) {
 						return new UnavailableValue(debugger, "Function has expired");
 					} else {
-						ICorDebugValue argThis = null;
+						return new ObjectValue(debugger, CorILFrame.GetArgument(0), ContaingClass);
-						CorILFrame.GetArgument(0, out argThis);
-						return new ObjectValue(debugger, argThis, ContaingClass);
 					}
 				}
 			}
@@ -104,14 +100,10 @@ namespace Debugger
 			this.frameIndex = frameIndex;
 			this.corILFrame = corILFrame;
 			this.corILFrameDebuggerSessionID = debugger.SessionID;
-			corILFrame.GetFunction(out corFunction);
+			corFunction = corILFrame.Function;
-			uint functionToken;
+			module = debugger.GetModule(corFunction.Module);
-			corFunction.GetToken(out functionToken);
-			ICorDebugModule corModule;
-			corFunction.GetModule(out corModule);
-			module = debugger.GetModule(corModule);
 			
-			methodProps = module.MetaData.GetMethodProps(functionToken);
+			methodProps = module.MetaData.GetMethodProps(corFunction.Token);
 			
 			// Expiry the function when it is finished
 			Stepper tracingStepper = thread.CreateStepper();
@@ -136,8 +128,7 @@ namespace Debugger
 		internal uint corInstructionPtr {
 			get	{
 				uint corInstructionPtr;
-				CorDebugMappingResult MappingResult;
+				CorILFrame.GetIP(out corInstructionPtr);
-				CorILFrame.GetIP(out corInstructionPtr,out MappingResult);
 				return corInstructionPtr;
 			}
 		}
@@ -176,8 +167,7 @@ namespace Debugger
 
 		public void StepOut()
 		{
-			ICorDebugStepper stepper;
+			ICorDebugStepper stepper = CorILFrame.CreateStepper();
-			CorILFrame.CreateStepper(out stepper);
 			stepper.StepOut();
 			
 			debugger.CurrentThread.AddActiveStepper(stepper);
@@ -201,7 +191,7 @@ namespace Debugger
 			ICorDebugStepper stepper;
 			
 			if (stepIn) {
-				CorILFrame.CreateStepper(out stepper);
+				stepper = CorILFrame.CreateStepper();
 				
 				if (stepper.Is<ICorDebugStepper2>()) { // Is the debuggee .NET 2.0?
 					stepper.SetUnmappedStopMask(CorDebugUnmappedStop.STOP_NONE);
@@ -218,7 +208,7 @@ namespace Debugger
 			// Mind that step in which ends in code without symblols is cotinued
 			// so the next step over ensures that we atleast do step over
 			
-			CorILFrame.CreateStepper(out stepper);
+			stepper = CorILFrame.CreateStepper();
 			
 			if (stepper.Is<ICorDebugStepper2>()) { // Is the debuggee .NET 2.0?
 				stepper.SetUnmappedStopMask(CorDebugUnmappedStop.STOP_NONE);
@@ -286,14 +276,11 @@ namespace Debugger
 			for (int i = sequencePointCount - 1; i >= 0; i--) // backwards
 				if (offsets[i] <= offset || i == 0) {
 					// Set inforamtion about current IL range
-					ICorDebugCode code;
+					int codeSize = (int)corFunction.ILCode.Size;
-					corFunction.GetILCode(out code);
-					uint codeSize;
-					code.GetSize(out codeSize);
 					
 					retVal.ILOffset = (int)offset;
 					retVal.ILStart = offsets[i];
-					retVal.ILEnd = (i + 1 < sequencePointCount) ? offsets[i + 1] : (int)codeSize;
+					retVal.ILEnd = (i + 1 < sequencePointCount) ? offsets[i + 1] : codeSize;
 					
 					// 0xFeeFee means "code generated by compiler"
 					// If we are in generated sequence use to closest real one instead,
@@ -302,7 +289,7 @@ namespace Debugger
 					// Look ahead for 'real' sequence
 					while (i + 1 < sequencePointCount && startLine[i] == 0xFeeFee) {
 						i++;
-						retVal.ILEnd = (i + 1 < sequencePointCount) ? offsets[i + 1] : (int)codeSize;
+						retVal.ILEnd = (i + 1 < sequencePointCount) ? offsets[i + 1] : codeSize;
 					}
 					// Look back for 'real' sequence
 					while (i - 1 >= 0 && startLine[i] == 0xFeeFee) {
@@ -339,7 +326,7 @@ namespace Debugger
 							if (j + 1 < sequencePointCount) {
 								stepRanges.Add(offsets[j + 1]);
 							} else {
-								stepRanges.Add((int)codeSize);
+								stepRanges.Add(codeSize);
 							}
 						}
 					}
@@ -371,9 +358,7 @@ namespace Debugger
 			if (!suggestion.GetFunctionAndOffset(debugger, false, out corFunction, out ilOffset)) {
 				return null;
 			} else {
-				uint token;
+				if (corFunction.Token != methodProps.Token) {
-				corFunction.GetToken(out token);
-				if (token != methodProps.Token) {
 					return null;
 				} else {
 					try {
@@ -428,10 +413,8 @@ namespace Debugger
 		
 		public int ArgumentCount {
 			get {
-				ICorDebugValueEnum argumentEnum;
+				ICorDebugValueEnum argumentEnum = CorILFrame.EnumerateArguments();
-				CorILFrame.EnumerateArguments(out argumentEnum);
+				uint argCount = argumentEnum.Count;
-				uint argCount;
-				argumentEnum.GetCount(out argCount);
 				if (!IsStatic) {
 					argCount--; // Remove 'this' from count
 				}
@@ -441,10 +424,8 @@ namespace Debugger
 		
 		internal ICorDebugValue GetArgumentValue(int index)
 		{
-			ICorDebugValue arg;
 			// Non-static functions include 'this' as first argument
-			CorILFrame.GetArgument((uint)(IsStatic? index : (index + 1)), out arg);
+			return CorILFrame.GetArgument((uint)(IsStatic? index : (index + 1)));
-			return arg;
 		}
 		
 		public Variable GetArgumentVariable(int index)
@@ -508,7 +489,7 @@ namespace Debugger
 			                    	} else {
 			                    		ICorDebugValue corValue;
 			                    		try {
-			                    			CorILFrame.GetLocalVariable((uint)symVar.AddressField1, out corValue);
+			                    			corValue = CorILFrame.GetLocalVariable((uint)symVar.AddressField1);
 			                    		} catch (COMException e) {
 			                    			if ((uint)e.ErrorCode == 0x80131304) return new UnavailableValue(debugger, "Unavailable in optimized code");
 			                    			throw;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Process.cs

@@ -104,6 +104,7 @@ namespace Debugger
 			
 			fixed (uint* pprocessStartupInfo = processStartupInfo)
 				fixed (uint* pprocessInfo = processInfo)
+					outProcess =
 						debugger.CorDebug.CreateProcess(
 							filename,   // lpApplicationName
 							  // If we do not prepend " ", the first argument migh just get lost
@@ -116,8 +117,7 @@ namespace Debugger
 							workingDirectory,                       // lpCurrentDirectory
 							(uint)pprocessStartupInfo,        // lpStartupInfo
 							(uint)pprocessInfo,               // lpProcessInformation,
-						CorDebugCreateProcessFlags.DEBUG_NO_SPECIAL_OPTIONS,   // debuggingFlags
+							CorDebugCreateProcessFlags.DEBUG_NO_SPECIAL_OPTIONS   // debuggingFlags
-						out outProcess      // ppProcess
 							);
 			
 			return new Process(debugger, outProcess);
@@ -160,10 +160,8 @@ namespace Debugger
 
 		public void Terminate()
 		{
-			int running;
-			corProcess.IsRunning(out running);
 			// Resume stoped tread
-			if (running == 0) {
+			if (corProcess.IsRunning == 0) {
 				Continue(); // TODO: Remove this...
 			}
 			// Stop&terminate - both must be called

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/SourcecodeSegment.cs

@@ -212,9 +212,7 @@ namespace Debugger
 			ISymbolMethod symMethod;
 			symMethod = symReader.GetMethodFromDocumentPosition(symDoc, StartLine, StartColumn);
 			
-			ICorDebugFunction corFunction;
+			function = module.CorModule.GetFunctionFromToken((uint)symMethod.Token.GetToken());
-			module.CorModule.GetFunctionFromToken((uint)symMethod.Token.GetToken(), out corFunction);
-			function = corFunction;
 			
 			ilOffset = symMethod.GetOffset(symDoc, StartLine, StartColumn);
 			

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Threads/Thread.cs

@@ -82,20 +82,16 @@ namespace Debugger
 		{
 			this.debugger = debugger;
 			this.corThread = corThread;
-			corThread.GetID(out id);
+			id = corThread.ID;
 			
-			ICorDebugProcess corProcess;
+			this.process = debugger.GetProcess(corThread.Process);
-			corThread.GetProcess(out corProcess);
-			this.process = debugger.GetProcess(corProcess);
 		}
 		
 		public bool Suspended {
 			get {
 				if (process.IsRunning) return lastSuspendedState;
 				
-				CorDebugThreadState state;
+				lastSuspendedState = (corThread.DebugState == CorDebugThreadState.THREAD_SUSPEND);
-				corThread.GetDebugState(out state);
-				lastSuspendedState = (state == CorDebugThreadState.THREAD_SUSPEND);
 				return lastSuspendedState;
 			}
 			set {
@@ -120,9 +116,7 @@ namespace Debugger
 				if (!HasBeenLoaded) throw new DebuggerException("Thread has not started jet");
 				process.AssertPaused();
 				
-				ICorDebugValue corValue;
+				return Value.CreateValue(debugger, corThread.Object);
-				corThread.GetObject(out corValue);
-				return Value.CreateValue(debugger, corValue);
 			}
 		}
 
@@ -149,10 +143,7 @@ namespace Debugger
 		
 		internal Stepper CreateStepper()
 		{
-			ICorDebugStepper corStepper;
+			Stepper stepper = new Stepper(debugger, corThread.CreateStepper());
-			corThread.CreateStepper(out corStepper);
-			
-			Stepper stepper = new Stepper(debugger, corStepper);
 			stepper.StepComplete += delegate {
 				steppers.Remove(stepper);
 			};
@@ -192,9 +183,7 @@ namespace Debugger
 		internal void DeactivateAllSteppers()
 		{
 			foreach(ICorDebugStepper stepper in activeSteppers) {
-				int active;
+				if (stepper.IsActive != 0) {
-				stepper.IsActive(out active);
-				if (active != 0) {
 					stepper.Deactivate();
 					debugger.TraceMessage("Stepper deactivated");
 				}
@@ -241,11 +230,9 @@ namespace Debugger
 		{
 			process.AssertPaused();
 			
-			ICorDebugChainEnum corChainEnum;
+			ICorDebugChainEnum corChainEnum = corThread.EnumerateChains();
-			corThread.EnumerateChains(out corChainEnum);
 			
-			uint chainCount;
+			uint chainCount = corChainEnum.Count;
-			corChainEnum.GetCount(out chainCount);
 			
 			uint chainIndex = chainCount;
 			
@@ -258,25 +245,19 @@ namespace Debugger
 			}
 			
 			while (true) {
-				uint chainsFetched;
 				ICorDebugChain[] corChains = new ICorDebugChain[1]; // One at time
-				corChainEnum.Next(1, corChains, out chainsFetched);
+				uint chainsFetched = corChainEnum.Next(1, corChains);
 				if (chainsFetched == 0) break; // We are done
 				
 				chainIndex--;
 				
-				CorDebugChainReason reason;
+				CorDebugChainReason reason = corChains[0].Reason;
-				corChains[0].GetReason(out reason);
 				
-				int isManaged;
+				if (corChains[0].IsManaged == 0) continue; // Only managed ones
-				corChains[0].IsManaged(out isManaged);
-				if (isManaged == 0) continue; // Only managed ones
 				
-				ICorDebugFrameEnum corFrameEnum;
+				ICorDebugFrameEnum corFrameEnum = corChains[0].EnumerateFrames();
-				corChains[0].EnumerateFrames(out corFrameEnum);
 				
-				uint frameCount;
+				uint frameCount = corFrameEnum.Count;
-				corFrameEnum.GetCount(out frameCount);
 				
 				uint frameIndex = frameCount;
 				
@@ -288,9 +269,8 @@ namespace Debugger
 				}
 				
 				while (true) {
-					uint framesFetched;
 					ICorDebugFrame[] corFrames = new ICorDebugFrame[1]; // Only one at time
-					corFrameEnum.Next(1, corFrames, out framesFetched);
+					uint framesFetched = corFrameEnum.Next(1, corFrames);
 					if (framesFetched == 0) break; // We are done
 					
 					frameIndex--;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ArrayValue.cs

@@ -58,12 +58,10 @@ namespace Debugger
 		internal unsafe ArrayValue(NDebugger debugger, ICorDebugValue corValue):base(debugger, corValue)
 		{
 			corArrayValue = this.corValue.CastTo<ICorDebugArrayValue>();
-			uint corElementTypeRaw;
+			corElementType = (CorElementType)corArrayValue.ElementType;
-			corArrayValue.GetElementType(out corElementTypeRaw);
-			corElementType = (CorElementType)corElementTypeRaw;
 			
-			corArrayValue.GetRank(out rank);
+			rank = corArrayValue.Rank;
-			corArrayValue.GetCount(out lenght);
+			lenght = corArrayValue.Count;
 			
 			dimensions = new uint[rank];
 			fixed (void* pDimensions = dimensions)
@@ -112,7 +110,7 @@ namespace Debugger
 			                    		ICorDebugValue element;
 			                    		unsafe {
 			                    			fixed (void* pIndices = indices) {
-			                    				updatedVal.corArrayValue.GetElement(rank, new IntPtr(pIndices), out element);
+			                    				element = updatedVal.corArrayValue.GetElement(rank, new IntPtr(pIndices));
 			                    			}
 			                    		}
 			                    		return Value.CreateValue(debugger, element);

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Evals/Eval.cs

@@ -122,7 +122,7 @@ namespace Debugger
 			ICorDebugValue[] args = getArgs();
 			
 			// TODO: What if this thread is not suitable?
-			targetThread.CorThread.CreateEval(out corEval);
+			corEval = targetThread.CorThread.CreateEval();
 			
 			try {
 				corEval.CallFunction(corFunction, (uint)args.Length, args);
@@ -152,9 +152,7 @@ namespace Debugger
 		
 		protected internal virtual void OnEvalComplete(bool successful) 
 		{
-			ICorDebugValue corValue;
+			result = Value.CreateValue(debugger, corEval.Result);
-			corEval.GetResult(out corValue);
-			result = Value.CreateValue(debugger, corValue);
 			
 			if (result == null) {
 				evalState = EvalState.EvaluatedNoResult;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/ObjectValue.cs

@@ -73,9 +73,7 @@ namespace Debugger
 				if (heapValue == null) { // TODO: Investigate
 					return null;
 				}
-				ICorDebugHandleValue corHandle;
+				return heapValue.CreateHandle(CorDebugHandleType.HANDLE_WEAK_TRACK_RESURRECTION);
-				heapValue.CreateHandle(CorDebugHandleType.HANDLE_WEAK_TRACK_RESURRECTION, out corHandle);
-				return corHandle;
 			}
 		}
 		
@@ -99,7 +97,7 @@ namespace Debugger
 		
 		internal unsafe ObjectValue(NDebugger debugger, ICorDebugValue corValue):base(debugger, corValue)
 		{
-			this.corValue.CastTo<ICorDebugObjectValue>().GetClass(out corClass);
+			corClass = this.corValue.CastTo<ICorDebugObjectValue>().Class;
 			InitObjectVariable();
 		}
 
@@ -111,13 +109,9 @@ namespace Debugger
 
 		void InitObjectVariable ()
 		{
-			uint classToken;
+			corModule = corClass.Module;
-			corClass.GetToken(out classToken);
-			corClass.GetModule(out corModule);
 			metaData = Module.MetaData;
-			
+			classProps = metaData.GetTypeDefProps(corClass.Token);
-			classProps = metaData.GetTypeDefProps(classToken);
-			
 			corModuleSuperclass = corModule;
 		}
 
@@ -188,8 +182,7 @@ namespace Debugger
 		
 		Eval CreatePropertyEval(MethodProps method, ValueGetter getter)
 		{
-			ICorDebugFunction evalCorFunction;
+			ICorDebugFunction evalCorFunction = Module.CorModule.GetFunctionFromToken(method.Token);
-			Module.CorModule.GetFunctionFromToken(method.Token, out evalCorFunction);
 			
 			return new Eval(debugger, evalCorFunction, delegate {
 			                	if (method.IsStatic) {
@@ -218,9 +211,9 @@ namespace Debugger
 			try {
 				ICorDebugValue fieldValue;
 				if (field.IsStatic) {
-					corClass.GetStaticFieldValue(field.Token, curFrame, out fieldValue);
+					fieldValue = corClass.GetStaticFieldValue(field.Token, curFrame);
 				} else {
-					(val.CorValue.CastTo<ICorDebugObjectValue>()).GetFieldValue(corClass, field.Token, out fieldValue);
+					fieldValue = (val.CorValue.CastTo<ICorDebugObjectValue>()).GetFieldValue(corClass, field.Token);
 				}
 				return Value.CreateValue(debugger, fieldValue);
 			} catch {
@@ -297,8 +290,7 @@ namespace Debugger
 			if ((classProps.SuperClassToken & 0x00FFFFFF) == 0)	{
 				throw new DebuggerException("Unable to get base class: " + fullTypeName);
 			} else {
-				ICorDebugClass superClass;
+				ICorDebugClass superClass = corModuleSuperclass.GetClassFromToken(classProps.SuperClassToken);
-				corModuleSuperclass.GetClassFromToken(classProps.SuperClassToken, out superClass);
 				return new ObjectValue(debugger, corValue, superClass);
 			}
 		}

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Variables/Value.cs

@@ -119,9 +119,7 @@ namespace Debugger
 			if (corValue == null) {
 				return (CorElementType)0;
 			}
-			uint typeRaw;
+			return (CorElementType)corValue.Type;
-			corValue.GetType(out typeRaw);
-			return (CorElementType)typeRaw;
 		}
 
 		internal static System.Type CorTypeToManagedType(CorElementType corType)
@@ -161,12 +159,11 @@ namespace Debugger
 		internal static ICorDebugValue DereferenceUnbox(ICorDebugValue corValue)
 		{
 			if (corValue.Is<ICorDebugReferenceValue>()) {
-				int isNull;
+				int isNull = corValue.CastTo<ICorDebugReferenceValue>().IsNull;
-				(corValue.CastTo<ICorDebugReferenceValue>()).IsNull(out isNull);
 				if (isNull == 0) {
 					ICorDebugValue dereferencedValue;
 					try {
-						(corValue.CastTo<ICorDebugReferenceValue>()).Dereference(out dereferencedValue);
+						dereferencedValue = (corValue.CastTo<ICorDebugReferenceValue>()).Dereference();
 					} catch {
 						// Error during dereferencing
 						return null;
@@ -178,9 +175,7 @@ namespace Debugger
 			}
 			
 			if (corValue.Is<ICorDebugBoxValue>()) {
-				ICorDebugObjectValue corUnboxedValue;
+				return DereferenceUnbox(corValue.CastTo<ICorDebugBoxValue>().Object.CastTo<ICorDebugValue>()); // Try again
-				(corValue.CastTo<ICorDebugBoxValue>()).GetObject(out corUnboxedValue);
-				return DereferenceUnbox(corUnboxedValue.CastTo<ICorDebugValue>()); // Try again
 			}
 			
 			return corValue;

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/CorDebugClass.cs

@@ -85,32 +85,40 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.CanLaunchOrAttach(dwProcessId, win32DebuggingEnabled);
 		}
 		
-		public void CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, ((Debugger.Interop.CorDebug.CorDebugCreateProcessFlags)(debuggingFlags)), out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess DebugActiveProcess(uint id, int win32Attach)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess)
+		public ICorDebugProcessEnum EnumerateProcesses()
 		{
+			ICorDebugProcessEnum ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess;
 			this.WrappedObject.EnumerateProcesses(out out_ppProcess);
 			ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess GetProcess(uint dwProcessId)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
 		public void Initialize()

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/EmbeddedCLRCorDebugClass.cs

@@ -85,32 +85,40 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.CanLaunchOrAttach(dwProcessId, win32DebuggingEnabled);
 		}
 		
-		public void CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, ((Debugger.Interop.CorDebug.CorDebugCreateProcessFlags)(debuggingFlags)), out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess DebugActiveProcess(uint id, int win32Attach)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess)
+		public ICorDebugProcessEnum EnumerateProcesses()
 		{
+			ICorDebugProcessEnum ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess;
 			this.WrappedObject.EnumerateProcesses(out out_ppProcess);
 			ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess GetProcess(uint dwProcessId)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
 		public void Initialize()

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebug.cs

@@ -100,32 +100,40 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetUnmanagedHandler(pCallback.WrappedObject);
 		}
 		
-		public void CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess CreateProcess(string lpApplicationName, string lpCommandLine, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpProcessAttributes, ref Debugger.Interop.CorDebug._SECURITY_ATTRIBUTES lpThreadAttributes, int bInheritHandles, uint dwCreationFlags, System.IntPtr lpEnvironment, string lpCurrentDirectory, uint lpStartupInfo, uint lpProcessInformation, CorDebugCreateProcessFlags debuggingFlags)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.CreateProcess(lpApplicationName, lpCommandLine, ref lpProcessAttributes, ref lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment, lpCurrentDirectory, lpStartupInfo, lpProcessInformation, ((Debugger.Interop.CorDebug.CorDebugCreateProcessFlags)(debuggingFlags)), out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void DebugActiveProcess(uint id, int win32Attach, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess DebugActiveProcess(uint id, int win32Attach)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.DebugActiveProcess(id, win32Attach, out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void EnumerateProcesses(out ICorDebugProcessEnum ppProcess)
+		public ICorDebugProcessEnum EnumerateProcesses()
 		{
+			ICorDebugProcessEnum ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcessEnum out_ppProcess;
 			this.WrappedObject.EnumerateProcesses(out out_ppProcess);
 			ppProcess = ICorDebugProcessEnum.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
-		public void GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess)
+		public ICorDebugProcess GetProcess(uint dwProcessId)
 		{
+			ICorDebugProcess ppProcess;
 			Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 			this.WrappedObject.GetProcess(dwProcessId, out out_ppProcess);
 			ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+			return ppProcess;
 		}
 		
 		public void CanLaunchOrAttach(uint dwProcessId, int win32DebuggingEnabled)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Continue(fIsOutOfBand);
 		}
 		
-		public void IsRunning(out int pbRunning)
+		public int IsRunning
 		{
+			get
+			{
+				int pbRunning;
 				this.WrappedObject.IsRunning(out pbRunning);
+				return pbRunning;
+			}
 		}
 		
-		public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued)
+		public int HasQueuedCallbacks(ICorDebugThread pThread)
 		{
+			int pbQueued;
 			this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued);
+			return pbQueued;
 		}
 		
-		public void EnumerateThreads(out ICorDebugThreadEnum ppThreads)
+		public ICorDebugThreadEnum EnumerateThreads()
 		{
+			ICorDebugThreadEnum ppThreads;
 			Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads;
 			this.WrappedObject.EnumerateThreads(out out_ppThreads);
 			ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads);
+			return ppThreads;
 		}
 		
 		public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread)
@@ -122,62 +131,84 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Terminate(exitCode);
 		}
 		
-		public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
+		public ICorDebugErrorInfoEnum CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
 		{
+			ICorDebugErrorInfoEnum pError;
 			Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject;
 			Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError;
 			this.WrappedObject.CanCommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError);
 			pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots);
 			pError = ICorDebugErrorInfoEnum.Wrap(out_pError);
+			return pError;
 		}
 		
-		public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
+		public ICorDebugErrorInfoEnum CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
 		{
+			ICorDebugErrorInfoEnum pError;
 			Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject;
 			Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError;
 			this.WrappedObject.CommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError);
 			pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots);
 			pError = ICorDebugErrorInfoEnum.Wrap(out_pError);
+			return pError;
 		}
 		
-		public void GetProcess(out ICorDebugProcess ppProcess)
+		public ICorDebugProcess Process
+		{
+			get
 			{
+				ICorDebugProcess ppProcess;
 				Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 				this.WrappedObject.GetProcess(out out_ppProcess);
 				ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+				return ppProcess;
+			}
 		}
 		
-		public void EnumerateAssemblies(out ICorDebugAssemblyEnum ppAssemblies)
+		public ICorDebugAssemblyEnum EnumerateAssemblies()
 		{
+			ICorDebugAssemblyEnum ppAssemblies;
 			Debugger.Interop.CorDebug.ICorDebugAssemblyEnum out_ppAssemblies;
 			this.WrappedObject.EnumerateAssemblies(out out_ppAssemblies);
 			ppAssemblies = ICorDebugAssemblyEnum.Wrap(out_ppAssemblies);
+			return ppAssemblies;
 		}
 		
-		public void GetModuleFromMetaDataInterface(object pIMetaData, out ICorDebugModule ppModule)
+		public ICorDebugModule GetModuleFromMetaDataInterface(object pIMetaData)
 		{
+			ICorDebugModule ppModule;
 			Debugger.Interop.CorDebug.ICorDebugModule out_ppModule;
 			this.WrappedObject.GetModuleFromMetaDataInterface(pIMetaData, out out_ppModule);
 			ppModule = ICorDebugModule.Wrap(out_ppModule);
+			return ppModule;
 		}
 		
-		public void EnumerateBreakpoints(out ICorDebugBreakpointEnum ppBreakpoints)
+		public ICorDebugBreakpointEnum EnumerateBreakpoints()
 		{
+			ICorDebugBreakpointEnum ppBreakpoints;
 			Debugger.Interop.CorDebug.ICorDebugBreakpointEnum out_ppBreakpoints;
 			this.WrappedObject.EnumerateBreakpoints(out out_ppBreakpoints);
 			ppBreakpoints = ICorDebugBreakpointEnum.Wrap(out_ppBreakpoints);
+			return ppBreakpoints;
 		}
 		
-		public void EnumerateSteppers(out ICorDebugStepperEnum ppSteppers)
+		public ICorDebugStepperEnum EnumerateSteppers()
 		{
+			ICorDebugStepperEnum ppSteppers;
 			Debugger.Interop.CorDebug.ICorDebugStepperEnum out_ppSteppers;
 			this.WrappedObject.EnumerateSteppers(out out_ppSteppers);
 			ppSteppers = ICorDebugStepperEnum.Wrap(out_ppSteppers);
+			return ppSteppers;
 		}
 		
-		public void IsAttached(out int pbAttached)
+		public int IsAttached
+		{
+			get
 			{
+				int pbAttached;
 				this.WrappedObject.IsAttached(out pbAttached);
+				return pbAttached;
+			}
 		}
 		
 		public void GetName(uint cchName, out uint pcchName, System.IntPtr szName)
@@ -185,11 +216,16 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.GetName(cchName, out pcchName, szName);
 		}
 		
-		public void GetObject(out ICorDebugValue ppObject)
+		public ICorDebugValue Object
+		{
+			get
 			{
+				ICorDebugValue ppObject;
 				Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
 				this.WrappedObject.GetObject(out out_ppObject);
 				ppObject = ICorDebugValue.Wrap(out_ppObject);
+				return ppObject;
+			}
 		}
 		
 		public void Attach()
@@ -197,9 +233,14 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Attach();
 		}
 		
-		public void GetID(out uint pId)
+		public uint ID
 		{
+			get
+			{
+				uint pId;
 				this.WrappedObject.GetID(out pId);
+				return pId;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomain2.cs

@@ -80,20 +80,24 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetArrayOrPointerType(uint elementType, uint nRank, ICorDebugType pTypeArg, out ICorDebugType ppType)
+		public ICorDebugType GetArrayOrPointerType(uint elementType, uint nRank, ICorDebugType pTypeArg)
 		{
+			ICorDebugType ppType;
 			Debugger.Interop.CorDebug.ICorDebugType out_ppType;
 			this.WrappedObject.GetArrayOrPointerType(elementType, nRank, pTypeArg.WrappedObject, out out_ppType);
 			ppType = ICorDebugType.Wrap(out_ppType);
+			return ppType;
 		}
 		
-		public void GetFunctionPointerType(uint nTypeArgs, ref ICorDebugType ppTypeArgs, out ICorDebugType ppType)
+		public ICorDebugType GetFunctionPointerType(uint nTypeArgs, ref ICorDebugType ppTypeArgs)
 		{
+			ICorDebugType ppType;
 			Debugger.Interop.CorDebug.ICorDebugType ref_ppTypeArgs = ppTypeArgs.WrappedObject;
 			Debugger.Interop.CorDebug.ICorDebugType out_ppType;
 			this.WrappedObject.GetFunctionPointerType(nTypeArgs, ref ref_ppTypeArgs, out out_ppType);
 			ppTypeArgs = ICorDebugType.Wrap(ref_ppTypeArgs);
 			ppType = ICorDebugType.Wrap(out_ppType);
+			return ppType;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAppDomainEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr values)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, values, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugArrayValue.cs

@@ -80,53 +80,92 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
 		{
+			get
+			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
 		{
+			get
+			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void IsValid(out int pbValid)
+		public int IsValid
+		{
+			get
 			{
+				int pbValid;
 				this.WrappedObject.IsValid(out pbValid);
+				return pbValid;
+			}
 		}
 		
-		public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateRelocBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void GetElementType(out uint pType)
+		public uint ElementType
+		{
+			get
 			{
+				uint pType;
 				this.WrappedObject.GetElementType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetRank(out uint pnRank)
+		public uint Rank
+		{
+			get
 			{
+				uint pnRank;
 				this.WrappedObject.GetRank(out pnRank);
+				return pnRank;
+			}
 		}
 		
-		public void GetCount(out uint pnCount)
+		public uint Count
 		{
+			get
+			{
+				uint pnCount;
 				this.WrappedObject.GetCount(out pnCount);
+				return pnCount;
+			}
 		}
 		
 		public void GetDimensions(uint cdim, System.IntPtr dims)
@@ -134,9 +173,11 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.GetDimensions(cdim, dims);
 		}
 		
-		public void HasBaseIndicies(out int pbHasBaseIndicies)
+		public int HasBaseIndicies()
 		{
+			int pbHasBaseIndicies;
 			this.WrappedObject.HasBaseIndicies(out pbHasBaseIndicies);
+			return pbHasBaseIndicies;
 		}
 		
 		public void GetBaseIndicies(uint cdim, System.IntPtr indicies)
@@ -144,18 +185,22 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.GetBaseIndicies(cdim, indicies);
 		}
 		
-		public void GetElement(uint cdim, System.IntPtr indices, out ICorDebugValue ppValue)
+		public ICorDebugValue GetElement(uint cdim, System.IntPtr indices)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetElement(cdim, indices, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetElementAtPosition(uint nPosition, out ICorDebugValue ppValue)
+		public ICorDebugValue GetElementAtPosition(uint nPosition)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetElementAtPosition(nPosition, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssembly.cs

@@ -80,25 +80,37 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetProcess(out ICorDebugProcess ppProcess)
+		public ICorDebugProcess Process
 		{
+			get
+			{
+				ICorDebugProcess ppProcess;
 				Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 				this.WrappedObject.GetProcess(out out_ppProcess);
 				ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+				return ppProcess;
+			}
 		}
 		
-		public void GetAppDomain(out ICorDebugAppDomain ppAppDomain)
+		public ICorDebugAppDomain AppDomain
 		{
+			get
+			{
+				ICorDebugAppDomain ppAppDomain;
 				Debugger.Interop.CorDebug.ICorDebugAppDomain out_ppAppDomain;
 				this.WrappedObject.GetAppDomain(out out_ppAppDomain);
 				ppAppDomain = ICorDebugAppDomain.Wrap(out_ppAppDomain);
+				return ppAppDomain;
+			}
 		}
 		
-		public void EnumerateModules(out ICorDebugModuleEnum ppModules)
+		public ICorDebugModuleEnum EnumerateModules()
 		{
+			ICorDebugModuleEnum ppModules;
 			Debugger.Interop.CorDebug.ICorDebugModuleEnum out_ppModules;
 			this.WrappedObject.EnumerateModules(out out_ppModules);
 			ppModules = ICorDebugModuleEnum.Wrap(out_ppModules);
+			return ppModules;
 		}
 		
 		public void GetCodeBase(uint cchName, out uint pcchName, System.IntPtr szName)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugAssemblyEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr values)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, values, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBoxValue.cs

@@ -80,45 +80,74 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
+		{
+			get
 			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
+		{
+			get
 			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void IsValid(out int pbValid)
+		public int IsValid
+		{
+			get
 			{
+				int pbValid;
 				this.WrappedObject.IsValid(out pbValid);
+				return pbValid;
+			}
 		}
 		
-		public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateRelocBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void GetObject(out ICorDebugObjectValue ppObject)
+		public ICorDebugObjectValue Object
 		{
+			get
+			{
+				ICorDebugObjectValue ppObject;
 				Debugger.Interop.CorDebug.ICorDebugObjectValue out_ppObject;
 				this.WrappedObject.GetObject(out out_ppObject);
 				ppObject = ICorDebugObjectValue.Wrap(out_ppObject);
+				return ppObject;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpoint.cs

@@ -85,9 +85,14 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Activate(bActive);
 		}
 		
-		public void IsActive(out int pbActive)
+		public int IsActive
 		{
+			get
+			{
+				int pbActive;
 				this.WrappedObject.IsActive(out pbActive);
+				return pbActive;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugBreakpointEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr breakpoints, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr breakpoints)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, breakpoints, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChain.cs

@@ -80,84 +80,138 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetThread(out ICorDebugThread ppThread)
+		public ICorDebugThread Thread
 		{
+			get
+			{
+				ICorDebugThread ppThread;
 				Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
 				this.WrappedObject.GetThread(out out_ppThread);
 				ppThread = ICorDebugThread.Wrap(out_ppThread);
+				return ppThread;
+			}
 		}
 		
-		public void GetStackRange(out ulong pStart, out ulong pEnd)
+		public ulong GetStackRange(out ulong pStart)
 		{
+			ulong pEnd;
 			this.WrappedObject.GetStackRange(out pStart, out pEnd);
+			return pEnd;
 		}
 		
-		public void GetContext(out ICorDebugContext ppContext)
+		public ICorDebugContext Context
+		{
+			get
 			{
+				ICorDebugContext ppContext;
 				Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
 				this.WrappedObject.GetContext(out out_ppContext);
 				ppContext = ICorDebugContext.Wrap(out_ppContext);
+				return ppContext;
+			}
 		}
 		
-		public void GetCaller(out ICorDebugChain ppChain)
+		public ICorDebugChain Caller
+		{
+			get
 			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetCaller(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void GetCallee(out ICorDebugChain ppChain)
+		public ICorDebugChain Callee
+		{
+			get
 			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetCallee(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void GetPrevious(out ICorDebugChain ppChain)
+		public ICorDebugChain Previous
 		{
+			get
+			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetPrevious(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void GetNext(out ICorDebugChain ppChain)
+		public ICorDebugChain Next
 		{
+			get
+			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetNext(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void IsManaged(out int pManaged)
+		public int IsManaged
+		{
+			get
 			{
+				int pManaged;
 				this.WrappedObject.IsManaged(out pManaged);
+				return pManaged;
+			}
 		}
 		
-		public void EnumerateFrames(out ICorDebugFrameEnum ppFrames)
+		public ICorDebugFrameEnum EnumerateFrames()
 		{
+			ICorDebugFrameEnum ppFrames;
 			Debugger.Interop.CorDebug.ICorDebugFrameEnum out_ppFrames;
 			this.WrappedObject.EnumerateFrames(out out_ppFrames);
 			ppFrames = ICorDebugFrameEnum.Wrap(out_ppFrames);
+			return ppFrames;
 		}
 		
-		public void GetActiveFrame(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame ActiveFrame
+		{
+			get
 			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetActiveFrame(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters)
+		public ICorDebugRegisterSet RegisterSet
+		{
+			get
 			{
+				ICorDebugRegisterSet ppRegisters;
 				Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
 				this.WrappedObject.GetRegisterSet(out out_ppRegisters);
 				ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
+				return ppRegisters;
+			}
 		}
 		
-		public void GetReason(out CorDebugChainReason pReason)
+		public CorDebugChainReason Reason
 		{
+			get
+			{
+				CorDebugChainReason pReason;
 				Debugger.Interop.CorDebug.CorDebugChainReason out_pReason;
 				this.WrappedObject.GetReason(out out_pReason);
 				pReason = ((CorDebugChainReason)(out_pReason));
+				return pReason;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugChainEnum.cs

@@ -90,20 +90,28 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, ICorDebugChain[] chains, out uint pceltFetched)
+		public uint Next(uint celt, ICorDebugChain[] chains)
 		{
+			uint pceltFetched;
 			Debugger.Interop.CorDebug.ICorDebugChain[] array_chains = new Debugger.Interop.CorDebug.ICorDebugChain[chains.Length];
 			for (int i = 0; (i < chains.Length); i = (i + 1))
 			{
@@ -123,6 +131,7 @@ namespace Debugger.Wrappers.CorDebug
 					chains[i] = null;
 				}
 			}
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass.cs

@@ -80,23 +80,35 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetModule(out ICorDebugModule pModule)
+		public ICorDebugModule Module
 		{
+			get
+			{
+				ICorDebugModule pModule;
 				Debugger.Interop.CorDebug.ICorDebugModule out_pModule;
 				this.WrappedObject.GetModule(out out_pModule);
 				pModule = ICorDebugModule.Wrap(out_pModule);
+				return pModule;
+			}
 		}
 		
-		public void GetToken(out uint pTypeDef)
+		public uint Token
 		{
+			get
+			{
+				uint pTypeDef;
 				this.WrappedObject.GetToken(out pTypeDef);
+				return pTypeDef;
+			}
 		}
 		
-		public void GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
+		public ICorDebugValue GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetStaticFieldValue(fieldDef, pFrame.WrappedObject, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugClass2.cs

@@ -80,13 +80,15 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetParameterizedType(uint elementType, uint nTypeArgs, ref ICorDebugType ppTypeArgs, out ICorDebugType ppType)
+		public ICorDebugType GetParameterizedType(uint elementType, uint nTypeArgs, ref ICorDebugType ppTypeArgs)
 		{
+			ICorDebugType ppType;
 			Debugger.Interop.CorDebug.ICorDebugType ref_ppTypeArgs = ppTypeArgs.WrappedObject;
 			Debugger.Interop.CorDebug.ICorDebugType out_ppType;
 			this.WrappedObject.GetParameterizedType(elementType, nTypeArgs, ref ref_ppTypeArgs, out out_ppType);
 			ppTypeArgs = ICorDebugType.Wrap(ref_ppTypeArgs);
 			ppType = ICorDebugType.Wrap(out_ppType);
+			return ppType;
 		}
 		
 		public void SetJMCStatus(int bIsJustMyCode)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCode.cs

@@ -80,43 +80,72 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void IsIL(out int pbIL)
+		public int IsIL
 		{
+			get
+			{
+				int pbIL;
 				this.WrappedObject.IsIL(out pbIL);
+				return pbIL;
+			}
 		}
 		
-		public void GetFunction(out ICorDebugFunction ppFunction)
+		public ICorDebugFunction Function
+		{
+			get
 			{
+				ICorDebugFunction ppFunction;
 				Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 				this.WrappedObject.GetFunction(out out_ppFunction);
 				ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+				return ppFunction;
+			}
 		}
 		
-		public void GetAddress(out ulong pStart)
+		public ulong Address
+		{
+			get
 			{
+				ulong pStart;
 				this.WrappedObject.GetAddress(out pStart);
+				return pStart;
+			}
 		}
 		
-		public void GetSize(out uint pcBytes)
+		public uint Size
+		{
+			get
 			{
+				uint pcBytes;
 				this.WrappedObject.GetSize(out pcBytes);
+				return pcBytes;
+			}
 		}
 		
-		public void CreateBreakpoint(uint offset, out ICorDebugFunctionBreakpoint ppBreakpoint)
+		public ICorDebugFunctionBreakpoint CreateBreakpoint(uint offset)
 		{
+			ICorDebugFunctionBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(offset, out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugFunctionBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void GetCode(uint startOffset, uint endOffset, uint cBufferAlloc, System.IntPtr buffer, out uint pcBufferSize)
+		public uint GetCode(uint startOffset, uint endOffset, uint cBufferAlloc, System.IntPtr buffer)
 		{
+			uint pcBufferSize;
 			this.WrappedObject.GetCode(startOffset, endOffset, cBufferAlloc, buffer, out pcBufferSize);
+			return pcBufferSize;
 		}
 		
-		public void GetVersionNumber(out uint nVersion)
+		public uint VersionNumber
 		{
+			get
+			{
+				uint nVersion;
 				this.WrappedObject.GetVersionNumber(out nVersion);
+				return nVersion;
+			}
 		}
 		
 		public void GetILToNativeMapping(uint cMap, out uint pcMap, System.IntPtr map)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugCodeEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr values)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, values, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugContext.cs

@@ -80,64 +80,105 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
 		{
+			get
+			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
 		{
+			get
+			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void GetClass(out ICorDebugClass ppClass)
+		public ICorDebugClass Class
+		{
+			get
 			{
+				ICorDebugClass ppClass;
 				Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
 				this.WrappedObject.GetClass(out out_ppClass);
 				ppClass = ICorDebugClass.Wrap(out_ppClass);
+				return ppClass;
+			}
 		}
 		
-		public void GetFieldValue(ICorDebugClass pClass, uint fieldDef, out ICorDebugValue ppValue)
+		public ICorDebugValue GetFieldValue(ICorDebugClass pClass, uint fieldDef)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetFieldValue(pClass.WrappedObject, fieldDef, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetVirtualMethod(uint memberRef, out ICorDebugFunction ppFunction)
+		public ICorDebugFunction GetVirtualMethod(uint memberRef)
 		{
+			ICorDebugFunction ppFunction;
 			Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 			this.WrappedObject.GetVirtualMethod(memberRef, out out_ppFunction);
 			ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+			return ppFunction;
 		}
 		
-		public void GetContext(out ICorDebugContext ppContext)
+		public ICorDebugContext Context
+		{
+			get
 			{
+				ICorDebugContext ppContext;
 				Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
 				this.WrappedObject.GetContext(out out_ppContext);
 				ppContext = ICorDebugContext.Wrap(out_ppContext);
+				return ppContext;
+			}
 		}
 		
-		public void IsValueClass(out int pbIsValueClass)
+		public int IsValueClass
+		{
+			get
 			{
+				int pbIsValueClass;
 				this.WrappedObject.IsValueClass(out pbIsValueClass);
+				return pbIsValueClass;
+			}
 		}
 		
-		public void GetManagedCopy(out object ppObject)
+		public object ManagedCopy
 		{
+			get
+			{
+				object ppObject;
 				this.WrappedObject.GetManagedCopy(out ppObject);
+				return ppObject;
+			}
 		}
 		
 		public void SetFromManagedCopy(object pObject)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugController.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Continue(fIsOutOfBand);
 		}
 		
-		public void IsRunning(out int pbRunning)
+		public int IsRunning
 		{
+			get
+			{
+				int pbRunning;
 				this.WrappedObject.IsRunning(out pbRunning);
+				return pbRunning;
+			}
 		}
 		
-		public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued)
+		public int HasQueuedCallbacks(ICorDebugThread pThread)
 		{
+			int pbQueued;
 			this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued);
+			return pbQueued;
 		}
 		
-		public void EnumerateThreads(out ICorDebugThreadEnum ppThreads)
+		public ICorDebugThreadEnum EnumerateThreads()
 		{
+			ICorDebugThreadEnum ppThreads;
 			Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads;
 			this.WrappedObject.EnumerateThreads(out out_ppThreads);
 			ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads);
+			return ppThreads;
 		}
 		
 		public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread)
@@ -122,22 +131,26 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Terminate(exitCode);
 		}
 		
-		public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
+		public ICorDebugErrorInfoEnum CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
 		{
+			ICorDebugErrorInfoEnum pError;
 			Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject;
 			Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError;
 			this.WrappedObject.CanCommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError);
 			pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots);
 			pError = ICorDebugErrorInfoEnum.Wrap(out_pError);
+			return pError;
 		}
 		
-		public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
+		public ICorDebugErrorInfoEnum CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
 		{
+			ICorDebugErrorInfoEnum pError;
 			Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject;
 			Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError;
 			this.WrappedObject.CommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError);
 			pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots);
 			pError = ICorDebugErrorInfoEnum.Wrap(out_pError);
+			return pError;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEditAndContinueSnapshot.cs

@@ -80,24 +80,41 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void CopyMetaData(IStream pIStream, out System.Guid pMvid)
+		public System.Guid CopyMetaData(IStream pIStream)
 		{
+			System.Guid pMvid;
 			this.WrappedObject.CopyMetaData(pIStream.WrappedObject, out pMvid);
+			return pMvid;
 		}
 		
-		public void GetMvid(out System.Guid pMvid)
+		public System.Guid Mvid
 		{
+			get
+			{
+				System.Guid pMvid;
 				this.WrappedObject.GetMvid(out pMvid);
+				return pMvid;
+			}
 		}
 		
-		public void GetRoDataRVA(out uint pRoDataRVA)
+		public uint RoDataRVA
+		{
+			get
 			{
+				uint pRoDataRVA;
 				this.WrappedObject.GetRoDataRVA(out pRoDataRVA);
+				return pRoDataRVA;
+			}
 		}
 		
-		public void GetRwDataRVA(out uint pRwDataRVA)
+		public uint RwDataRVA
+		{
+			get
 			{
+				uint pRwDataRVA;
 				this.WrappedObject.GetRwDataRVA(out pRwDataRVA);
+				return pRwDataRVA;
+			}
 		}
 		
 		public void SetPEBytes(IStream pIStream)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEnum.cs

@@ -90,16 +90,23 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugErrorInfoEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr errors, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr errors)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, errors, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval.cs

@@ -125,9 +125,14 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.NewArray(elementType, pElementClass.WrappedObject, rank, ref dims, ref lowBounds);
 		}
 		
-		public void IsActive(out int pbActive)
+		public int IsActive
 		{
+			get
+			{
+				int pbActive;
 				this.WrappedObject.IsActive(out pbActive);
+				return pbActive;
+			}
 		}
 		
 		public void Abort()
@@ -135,25 +140,37 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Abort();
 		}
 		
-		public void GetResult(out ICorDebugValue ppResult)
+		public ICorDebugValue Result
+		{
+			get
 			{
+				ICorDebugValue ppResult;
 				Debugger.Interop.CorDebug.ICorDebugValue out_ppResult;
 				this.WrappedObject.GetResult(out out_ppResult);
 				ppResult = ICorDebugValue.Wrap(out_ppResult);
+				return ppResult;
+			}
 		}
 		
-		public void GetThread(out ICorDebugThread ppThread)
+		public ICorDebugThread Thread
+		{
+			get
 			{
+				ICorDebugThread ppThread;
 				Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
 				this.WrappedObject.GetThread(out out_ppThread);
 				ppThread = ICorDebugThread.Wrap(out_ppThread);
+				return ppThread;
+			}
 		}
 		
-		public void CreateValue(uint elementType, ICorDebugClass pElementClass, out ICorDebugValue ppValue)
+		public ICorDebugValue CreateValue(uint elementType, ICorDebugClass pElementClass)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.CreateValue(elementType, pElementClass.WrappedObject, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugEval2.cs

@@ -89,11 +89,13 @@ namespace Debugger.Wrappers.CorDebug
 			ppArgs = ICorDebugValue.Wrap(ref_ppArgs);
 		}
 		
-		public void CreateValueForType(ICorDebugType pType, out ICorDebugValue ppValue)
+		public ICorDebugValue CreateValueForType(ICorDebugType pType)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.CreateValueForType(pType.WrappedObject, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
 		public void NewParameterizedObject(ICorDebugFunction pConstructor, uint nTypeArgs, ref ICorDebugType ppTypeArgs, uint nArgs, ref ICorDebugValue ppArgs)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrame.cs

@@ -80,56 +80,90 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetChain(out ICorDebugChain ppChain)
+		public ICorDebugChain Chain
 		{
+			get
+			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetChain(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void GetCode(out ICorDebugCode ppCode)
+		public ICorDebugCode Code
+		{
+			get
 			{
+				ICorDebugCode ppCode;
 				Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
 				this.WrappedObject.GetCode(out out_ppCode);
 				ppCode = ICorDebugCode.Wrap(out_ppCode);
+				return ppCode;
+			}
 		}
 		
-		public void GetFunction(out ICorDebugFunction ppFunction)
+		public ICorDebugFunction Function
+		{
+			get
 			{
+				ICorDebugFunction ppFunction;
 				Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 				this.WrappedObject.GetFunction(out out_ppFunction);
 				ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+				return ppFunction;
+			}
 		}
 		
-		public void GetFunctionToken(out uint pToken)
+		public uint FunctionToken
 		{
+			get
+			{
+				uint pToken;
 				this.WrappedObject.GetFunctionToken(out pToken);
+				return pToken;
+			}
 		}
 		
-		public void GetStackRange(out ulong pStart, out ulong pEnd)
+		public ulong GetStackRange(out ulong pStart)
 		{
+			ulong pEnd;
 			this.WrappedObject.GetStackRange(out pStart, out pEnd);
+			return pEnd;
 		}
 		
-		public void GetCaller(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame Caller
+		{
+			get
 			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetCaller(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void GetCallee(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame Callee
+		{
+			get
 			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetCallee(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void CreateStepper(out ICorDebugStepper ppStepper)
+		public ICorDebugStepper CreateStepper()
 		{
+			ICorDebugStepper ppStepper;
 			Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
 			this.WrappedObject.CreateStepper(out out_ppStepper);
 			ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
+			return ppStepper;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFrameEnum.cs

@@ -90,20 +90,28 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, ICorDebugFrame[] frames, out uint pceltFetched)
+		public uint Next(uint celt, ICorDebugFrame[] frames)
 		{
+			uint pceltFetched;
 			Debugger.Interop.CorDebug.ICorDebugFrame[] array_frames = new Debugger.Interop.CorDebug.ICorDebugFrame[frames.Length];
 			for (int i = 0; (i < frames.Length); i = (i + 1))
 			{
@@ -123,6 +131,7 @@ namespace Debugger.Wrappers.CorDebug
 					frames[i] = null;
 				}
 			}
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction.cs

@@ -80,54 +80,91 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetModule(out ICorDebugModule ppModule)
+		public ICorDebugModule Module
 		{
+			get
+			{
+				ICorDebugModule ppModule;
 				Debugger.Interop.CorDebug.ICorDebugModule out_ppModule;
 				this.WrappedObject.GetModule(out out_ppModule);
 				ppModule = ICorDebugModule.Wrap(out_ppModule);
+				return ppModule;
+			}
 		}
 		
-		public void GetClass(out ICorDebugClass ppClass)
+		public ICorDebugClass Class
 		{
+			get
+			{
+				ICorDebugClass ppClass;
 				Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
 				this.WrappedObject.GetClass(out out_ppClass);
 				ppClass = ICorDebugClass.Wrap(out_ppClass);
+				return ppClass;
+			}
 		}
 		
-		public void GetToken(out uint pMethodDef)
+		public uint Token
 		{
+			get
+			{
+				uint pMethodDef;
 				this.WrappedObject.GetToken(out pMethodDef);
+				return pMethodDef;
+			}
 		}
 		
-		public void GetILCode(out ICorDebugCode ppCode)
+		public ICorDebugCode ILCode
+		{
+			get
 			{
+				ICorDebugCode ppCode;
 				Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
 				this.WrappedObject.GetILCode(out out_ppCode);
 				ppCode = ICorDebugCode.Wrap(out_ppCode);
+				return ppCode;
+			}
 		}
 		
-		public void GetNativeCode(out ICorDebugCode ppCode)
+		public ICorDebugCode NativeCode
+		{
+			get
 			{
+				ICorDebugCode ppCode;
 				Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
 				this.WrappedObject.GetNativeCode(out out_ppCode);
 				ppCode = ICorDebugCode.Wrap(out_ppCode);
+				return ppCode;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugFunctionBreakpoint ppBreakpoint)
+		public ICorDebugFunctionBreakpoint CreateBreakpoint()
 		{
+			ICorDebugFunctionBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugFunctionBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugFunctionBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void GetLocalVarSigToken(out uint pmdSig)
+		public uint LocalVarSigToken
+		{
+			get
 			{
+				uint pmdSig;
 				this.WrappedObject.GetLocalVarSigToken(out pmdSig);
+				return pmdSig;
+			}
 		}
 		
-		public void GetCurrentVersionNumber(out uint pnCurrentVersion)
+		public uint CurrentVersionNumber
 		{
+			get
+			{
+				uint pnCurrentVersion;
 				this.WrappedObject.GetCurrentVersionNumber(out pnCurrentVersion);
+				return pnCurrentVersion;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunction2.cs

@@ -85,21 +85,33 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetJMCStatus(bIsJustMyCode);
 		}
 		
-		public void GetJMCStatus(out int pbIsJustMyCode)
+		public int JMCStatus
 		{
+			get
+			{
+				int pbIsJustMyCode;
 				this.WrappedObject.GetJMCStatus(out pbIsJustMyCode);
+				return pbIsJustMyCode;
+			}
 		}
 		
-		public void EnumerateNativeCode(out ICorDebugCodeEnum ppCodeEnum)
+		public ICorDebugCodeEnum EnumerateNativeCode()
 		{
+			ICorDebugCodeEnum ppCodeEnum;
 			Debugger.Interop.CorDebug.ICorDebugCodeEnum out_ppCodeEnum;
 			this.WrappedObject.EnumerateNativeCode(out out_ppCodeEnum);
 			ppCodeEnum = ICorDebugCodeEnum.Wrap(out_ppCodeEnum);
+			return ppCodeEnum;
 		}
 		
-		public void GetVersionNumber(out uint pnVersion)
+		public uint VersionNumber
 		{
+			get
+			{
+				uint pnVersion;
 				this.WrappedObject.GetVersionNumber(out pnVersion);
+				return pnVersion;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugFunctionBreakpoint.cs

@@ -85,21 +85,36 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Activate(bActive);
 		}
 		
-		public void IsActive(out int pbActive)
+		public int IsActive
 		{
+			get
+			{
+				int pbActive;
 				this.WrappedObject.IsActive(out pbActive);
+				return pbActive;
+			}
 		}
 		
-		public void GetFunction(out ICorDebugFunction ppFunction)
+		public ICorDebugFunction Function
+		{
+			get
 			{
+				ICorDebugFunction ppFunction;
 				Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 				this.WrappedObject.GetFunction(out out_ppFunction);
 				ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+				return ppFunction;
+			}
 		}
 		
-		public void GetOffset(out uint pnOffset)
+		public uint Offset
+		{
+			get
 			{
+				uint pnOffset;
 				this.WrappedObject.GetOffset(out pnOffset);
+				return pnOffset;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugGenericValue.cs

@@ -80,26 +80,43 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
+		{
+			get
 			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
+		{
+			get
 			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
 		public void GetValue(System.IntPtr pTo)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHandleValue.cs

@@ -80,36 +80,63 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
+		{
+			get
 			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
+		{
+			get
 			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void IsNull(out int pbNull)
+		public int IsNull
 		{
+			get
+			{
+				int pbNull;
 				this.WrappedObject.IsNull(out pbNull);
+				return pbNull;
+			}
 		}
 		
-		public void GetValue(out ulong pValue)
+		public ulong Value
+		{
+			get
 			{
+				ulong pValue;
 				this.WrappedObject.GetValue(out pValue);
+				return pValue;
+			}
 		}
 		
 		public void SetValue(ulong value)
@@ -117,25 +144,34 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetValue(value);
 		}
 		
-		public void Dereference(out ICorDebugValue ppValue)
+		public ICorDebugValue Dereference()
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.Dereference(out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void DereferenceStrong(out ICorDebugValue ppValue)
+		public ICorDebugValue DereferenceStrong()
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.DereferenceStrong(out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetHandleType(out CorDebugHandleType pType)
+		public CorDebugHandleType HandleType
+		{
+			get
 			{
+				CorDebugHandleType pType;
 				Debugger.Interop.CorDebug.CorDebugHandleType out_pType;
 				this.WrappedObject.GetHandleType(out out_pType);
 				pType = ((CorDebugHandleType)(out_pType));
+				return pType;
+			}
 		}
 		
 		public void Dispose()

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue.cs

@@ -80,38 +80,62 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
 		{
+			get
+			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
 		{
+			get
+			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void IsValid(out int pbValid)
+		public int IsValid
 		{
+			get
+			{
+				int pbValid;
 				this.WrappedObject.IsValid(out pbValid);
+				return pbValid;
+			}
 		}
 		
-		public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateRelocBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugHeapValue2.cs

@@ -80,11 +80,13 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void CreateHandle(CorDebugHandleType type, out ICorDebugHandleValue ppHandle)
+		public ICorDebugHandleValue CreateHandle(CorDebugHandleType type)
 		{
+			ICorDebugHandleValue ppHandle;
 			Debugger.Interop.CorDebug.ICorDebugHandleValue out_ppHandle;
 			this.WrappedObject.CreateHandle(((Debugger.Interop.CorDebug.CorDebugHandleType)(type)), out out_ppHandle);
 			ppHandle = ICorDebugHandleValue.Wrap(out_ppHandle);
+			return ppHandle;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame.cs

@@ -80,63 +80,99 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetChain(out ICorDebugChain ppChain)
+		public ICorDebugChain Chain
 		{
+			get
+			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetChain(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void GetCode(out ICorDebugCode ppCode)
+		public ICorDebugCode Code
 		{
+			get
+			{
+				ICorDebugCode ppCode;
 				Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
 				this.WrappedObject.GetCode(out out_ppCode);
 				ppCode = ICorDebugCode.Wrap(out_ppCode);
+				return ppCode;
+			}
 		}
 		
-		public void GetFunction(out ICorDebugFunction ppFunction)
+		public ICorDebugFunction Function
 		{
+			get
+			{
+				ICorDebugFunction ppFunction;
 				Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 				this.WrappedObject.GetFunction(out out_ppFunction);
 				ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+				return ppFunction;
+			}
 		}
 		
-		public void GetFunctionToken(out uint pToken)
+		public uint FunctionToken
+		{
+			get
 			{
+				uint pToken;
 				this.WrappedObject.GetFunctionToken(out pToken);
+				return pToken;
+			}
 		}
 		
-		public void GetStackRange(out ulong pStart, out ulong pEnd)
+		public ulong GetStackRange(out ulong pStart)
 		{
+			ulong pEnd;
 			this.WrappedObject.GetStackRange(out pStart, out pEnd);
+			return pEnd;
 		}
 		
-		public void GetCaller(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame Caller
+		{
+			get
 			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetCaller(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void GetCallee(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame Callee
+		{
+			get
 			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetCallee(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void CreateStepper(out ICorDebugStepper ppStepper)
+		public ICorDebugStepper CreateStepper()
 		{
+			ICorDebugStepper ppStepper;
 			Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
 			this.WrappedObject.CreateStepper(out out_ppStepper);
 			ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
+			return ppStepper;
 		}
 		
-		public void GetIP(out uint pnOffset, out CorDebugMappingResult pMappingResult)
+		public CorDebugMappingResult GetIP(out uint pnOffset)
 		{
+			CorDebugMappingResult pMappingResult;
 			Debugger.Interop.CorDebug.CorDebugMappingResult out_pMappingResult;
 			this.WrappedObject.GetIP(out pnOffset, out out_pMappingResult);
 			pMappingResult = ((CorDebugMappingResult)(out_pMappingResult));
+			return pMappingResult;
 		}
 		
 		public void SetIP(uint nOffset)
@@ -144,44 +180,59 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetIP(nOffset);
 		}
 		
-		public void EnumerateLocalVariables(out ICorDebugValueEnum ppValueEnum)
+		public ICorDebugValueEnum EnumerateLocalVariables()
 		{
+			ICorDebugValueEnum ppValueEnum;
 			Debugger.Interop.CorDebug.ICorDebugValueEnum out_ppValueEnum;
 			this.WrappedObject.EnumerateLocalVariables(out out_ppValueEnum);
 			ppValueEnum = ICorDebugValueEnum.Wrap(out_ppValueEnum);
+			return ppValueEnum;
 		}
 		
-		public void GetLocalVariable(uint dwIndex, out ICorDebugValue ppValue)
+		public ICorDebugValue GetLocalVariable(uint dwIndex)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetLocalVariable(dwIndex, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void EnumerateArguments(out ICorDebugValueEnum ppValueEnum)
+		public ICorDebugValueEnum EnumerateArguments()
 		{
+			ICorDebugValueEnum ppValueEnum;
 			Debugger.Interop.CorDebug.ICorDebugValueEnum out_ppValueEnum;
 			this.WrappedObject.EnumerateArguments(out out_ppValueEnum);
 			ppValueEnum = ICorDebugValueEnum.Wrap(out_ppValueEnum);
+			return ppValueEnum;
 		}
 		
-		public void GetArgument(uint dwIndex, out ICorDebugValue ppValue)
+		public ICorDebugValue GetArgument(uint dwIndex)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetArgument(dwIndex, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetStackDepth(out uint pDepth)
+		public uint StackDepth
 		{
+			get
+			{
+				uint pDepth;
 				this.WrappedObject.GetStackDepth(out pDepth);
+				return pDepth;
+			}
 		}
 		
-		public void GetStackValue(uint dwIndex, out ICorDebugValue ppValue)
+		public ICorDebugValue GetStackValue(uint dwIndex)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetStackValue(dwIndex, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
 		public void CanSetIP(uint nOffset)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugILFrame2.cs

@@ -85,11 +85,13 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.RemapFunction(newILOffset);
 		}
 		
-		public void EnumerateTypeParameters(out ICorDebugTypeEnum ppTyParEnum)
+		public ICorDebugTypeEnum EnumerateTypeParameters()
 		{
+			ICorDebugTypeEnum ppTyParEnum;
 			Debugger.Interop.CorDebug.ICorDebugTypeEnum out_ppTyParEnum;
 			this.WrappedObject.EnumerateTypeParameters(out out_ppTyParEnum);
 			ppTyParEnum = ICorDebugTypeEnum.Wrap(out_ppTyParEnum);
+			return ppTyParEnum;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugInternalFrame.cs

@@ -80,63 +80,102 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetChain(out ICorDebugChain ppChain)
+		public ICorDebugChain Chain
 		{
+			get
+			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetChain(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void GetCode(out ICorDebugCode ppCode)
+		public ICorDebugCode Code
 		{
+			get
+			{
+				ICorDebugCode ppCode;
 				Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
 				this.WrappedObject.GetCode(out out_ppCode);
 				ppCode = ICorDebugCode.Wrap(out_ppCode);
+				return ppCode;
+			}
 		}
 		
-		public void GetFunction(out ICorDebugFunction ppFunction)
+		public ICorDebugFunction Function
 		{
+			get
+			{
+				ICorDebugFunction ppFunction;
 				Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 				this.WrappedObject.GetFunction(out out_ppFunction);
 				ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+				return ppFunction;
+			}
 		}
 		
-		public void GetFunctionToken(out uint pToken)
+		public uint FunctionToken
+		{
+			get
 			{
+				uint pToken;
 				this.WrappedObject.GetFunctionToken(out pToken);
+				return pToken;
+			}
 		}
 		
-		public void GetStackRange(out ulong pStart, out ulong pEnd)
+		public ulong GetStackRange(out ulong pStart)
 		{
+			ulong pEnd;
 			this.WrappedObject.GetStackRange(out pStart, out pEnd);
+			return pEnd;
 		}
 		
-		public void GetCaller(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame Caller
+		{
+			get
 			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetCaller(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void GetCallee(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame Callee
+		{
+			get
 			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetCallee(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void CreateStepper(out ICorDebugStepper ppStepper)
+		public ICorDebugStepper CreateStepper()
 		{
+			ICorDebugStepper ppStepper;
 			Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
 			this.WrappedObject.CreateStepper(out out_ppStepper);
 			ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
+			return ppStepper;
 		}
 		
-		public void GetFrameType(out CorDebugInternalFrameType pType)
+		public CorDebugInternalFrameType FrameType
 		{
+			get
+			{
+				CorDebugInternalFrameType pType;
 				Debugger.Interop.CorDebug.CorDebugInternalFrameType out_pType;
 				this.WrappedObject.GetFrameType(out out_pType);
 				pType = ((CorDebugInternalFrameType)(out_pType));
+				return pType;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugMDA.cs

@@ -102,9 +102,14 @@ namespace Debugger.Wrappers.CorDebug
 			pFlags = ((CorDebugMDAFlags)(ref_pFlags));
 		}
 		
-		public void GetOSThreadId(out uint pOsTid)
+		public uint OSThreadId
 		{
+			get
+			{
+				uint pOsTid;
 				this.WrappedObject.GetOSThreadId(out pOsTid);
+				return pOsTid;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule.cs

@@ -80,23 +80,38 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetProcess(out ICorDebugProcess ppProcess)
+		public ICorDebugProcess Process
 		{
+			get
+			{
+				ICorDebugProcess ppProcess;
 				Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 				this.WrappedObject.GetProcess(out out_ppProcess);
 				ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+				return ppProcess;
+			}
 		}
 		
-		public void GetBaseAddress(out ulong pAddress)
+		public ulong BaseAddress
 		{
+			get
+			{
+				ulong pAddress;
 				this.WrappedObject.GetBaseAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void GetAssembly(out ICorDebugAssembly ppAssembly)
+		public ICorDebugAssembly Assembly
 		{
+			get
+			{
+				ICorDebugAssembly ppAssembly;
 				Debugger.Interop.CorDebug.ICorDebugAssembly out_ppAssembly;
 				this.WrappedObject.GetAssembly(out out_ppAssembly);
 				ppAssembly = ICorDebugAssembly.Wrap(out_ppAssembly);
+				return ppAssembly;
+			}
 		}
 		
 		public void GetName(uint cchName, out uint pcchName, System.IntPtr szName)
@@ -114,71 +129,108 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.EnableClassLoadCallbacks(bClassLoadCallbacks);
 		}
 		
-		public void GetFunctionFromToken(uint methodDef, out ICorDebugFunction ppFunction)
+		public ICorDebugFunction GetFunctionFromToken(uint methodDef)
 		{
+			ICorDebugFunction ppFunction;
 			Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 			this.WrappedObject.GetFunctionFromToken(methodDef, out out_ppFunction);
 			ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+			return ppFunction;
 		}
 		
-		public void GetFunctionFromRVA(ulong rva, out ICorDebugFunction ppFunction)
+		public ICorDebugFunction GetFunctionFromRVA(ulong rva)
 		{
+			ICorDebugFunction ppFunction;
 			Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 			this.WrappedObject.GetFunctionFromRVA(rva, out out_ppFunction);
 			ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+			return ppFunction;
 		}
 		
-		public void GetClassFromToken(uint typeDef, out ICorDebugClass ppClass)
+		public ICorDebugClass GetClassFromToken(uint typeDef)
 		{
+			ICorDebugClass ppClass;
 			Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
 			this.WrappedObject.GetClassFromToken(typeDef, out out_ppClass);
 			ppClass = ICorDebugClass.Wrap(out_ppClass);
+			return ppClass;
 		}
 		
-		public void CreateBreakpoint(out ICorDebugModuleBreakpoint ppBreakpoint)
+		public ICorDebugModuleBreakpoint CreateBreakpoint()
 		{
+			ICorDebugModuleBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugModuleBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugModuleBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void GetEditAndContinueSnapshot(out ICorDebugEditAndContinueSnapshot ppEditAndContinueSnapshot)
+		public ICorDebugEditAndContinueSnapshot EditAndContinueSnapshot
 		{
+			get
+			{
+				ICorDebugEditAndContinueSnapshot ppEditAndContinueSnapshot;
 				Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot out_ppEditAndContinueSnapshot;
 				this.WrappedObject.GetEditAndContinueSnapshot(out out_ppEditAndContinueSnapshot);
 				ppEditAndContinueSnapshot = ICorDebugEditAndContinueSnapshot.Wrap(out_ppEditAndContinueSnapshot);
+				return ppEditAndContinueSnapshot;
+			}
 		}
 		
-		public void GetMetaDataInterface(ref System.Guid riid, out object ppObj)
+		public object GetMetaDataInterface(ref System.Guid riid)
 		{
+			object ppObj;
 			this.WrappedObject.GetMetaDataInterface(ref riid, out ppObj);
+			return ppObj;
 		}
 		
-		public void GetToken(out uint pToken)
+		public uint Token
 		{
+			get
+			{
+				uint pToken;
 				this.WrappedObject.GetToken(out pToken);
+				return pToken;
+			}
 		}
 		
-		public void IsDynamic(out int pDynamic)
+		public int IsDynamic
 		{
+			get
+			{
+				int pDynamic;
 				this.WrappedObject.IsDynamic(out pDynamic);
+				return pDynamic;
+			}
 		}
 		
-		public void GetGlobalVariableValue(uint fieldDef, out ICorDebugValue ppValue)
+		public ICorDebugValue GetGlobalVariableValue(uint fieldDef)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetGlobalVariableValue(fieldDef, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetSize(out uint pcBytes)
+		public uint Size
 		{
+			get
+			{
+				uint pcBytes;
 				this.WrappedObject.GetSize(out pcBytes);
+				return pcBytes;
+			}
 		}
 		
-		public void IsInMemory(out int pInMemory)
+		public int IsInMemory
 		{
+			get
+			{
+				int pInMemory;
 				this.WrappedObject.IsInMemory(out pInMemory);
+				return pInMemory;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModule2.cs

@@ -95,9 +95,14 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetJITCompilerFlags(dwFlags);
 		}
 		
-		public void GetJITCompilerFlags(out uint pdwFlags)
+		public uint JITCompilerFlags
 		{
+			get
+			{
+				uint pdwFlags;
 				this.WrappedObject.GetJITCompilerFlags(out pdwFlags);
+				return pdwFlags;
+			}
 		}
 		
 		public void ResolveAssembly(uint tkAssemblyRef, ref ICorDebugAssembly ppAssembly)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleBreakpoint.cs

@@ -85,16 +85,26 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Activate(bActive);
 		}
 		
-		public void IsActive(out int pbActive)
+		public int IsActive
 		{
+			get
+			{
+				int pbActive;
 				this.WrappedObject.IsActive(out pbActive);
+				return pbActive;
+			}
 		}
 		
-		public void GetModule(out ICorDebugModule ppModule)
+		public ICorDebugModule Module
 		{
+			get
+			{
+				ICorDebugModule ppModule;
 				Debugger.Interop.CorDebug.ICorDebugModule out_ppModule;
 				this.WrappedObject.GetModule(out out_ppModule);
 				ppModule = ICorDebugModule.Wrap(out_ppModule);
+				return ppModule;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugModuleEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr modules, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr modules)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, modules, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugNativeFrame.cs

@@ -80,61 +80,100 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetChain(out ICorDebugChain ppChain)
+		public ICorDebugChain Chain
 		{
+			get
+			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetChain(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void GetCode(out ICorDebugCode ppCode)
+		public ICorDebugCode Code
 		{
+			get
+			{
+				ICorDebugCode ppCode;
 				Debugger.Interop.CorDebug.ICorDebugCode out_ppCode;
 				this.WrappedObject.GetCode(out out_ppCode);
 				ppCode = ICorDebugCode.Wrap(out_ppCode);
+				return ppCode;
+			}
 		}
 		
-		public void GetFunction(out ICorDebugFunction ppFunction)
+		public ICorDebugFunction Function
 		{
+			get
+			{
+				ICorDebugFunction ppFunction;
 				Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 				this.WrappedObject.GetFunction(out out_ppFunction);
 				ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+				return ppFunction;
+			}
 		}
 		
-		public void GetFunctionToken(out uint pToken)
+		public uint FunctionToken
 		{
+			get
+			{
+				uint pToken;
 				this.WrappedObject.GetFunctionToken(out pToken);
+				return pToken;
+			}
 		}
 		
-		public void GetStackRange(out ulong pStart, out ulong pEnd)
+		public ulong GetStackRange(out ulong pStart)
 		{
+			ulong pEnd;
 			this.WrappedObject.GetStackRange(out pStart, out pEnd);
+			return pEnd;
 		}
 		
-		public void GetCaller(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame Caller
 		{
+			get
+			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetCaller(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void GetCallee(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame Callee
 		{
+			get
+			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetCallee(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void CreateStepper(out ICorDebugStepper ppStepper)
+		public ICorDebugStepper CreateStepper()
 		{
+			ICorDebugStepper ppStepper;
 			Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
 			this.WrappedObject.CreateStepper(out out_ppStepper);
 			ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
+			return ppStepper;
 		}
 		
-		public void GetIP(out uint pnOffset)
+		public uint IP
 		{
+			get
+			{
+				uint pnOffset;
 				this.WrappedObject.GetIP(out pnOffset);
+				return pnOffset;
+			}
 		}
 		
 		public void SetIP(uint nOffset)
@@ -142,46 +181,61 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetIP(nOffset);
 		}
 		
-		public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters)
+		public ICorDebugRegisterSet RegisterSet
 		{
+			get
+			{
+				ICorDebugRegisterSet ppRegisters;
 				Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
 				this.WrappedObject.GetRegisterSet(out out_ppRegisters);
 				ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
+				return ppRegisters;
+			}
 		}
 		
-		public void GetLocalRegisterValue(CorDebugRegister reg, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
+		public ICorDebugValue GetLocalRegisterValue(CorDebugRegister reg, uint cbSigBlob, uint pvSigBlob)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetLocalRegisterValue(((Debugger.Interop.CorDebug.CorDebugRegister)(reg)), cbSigBlob, pvSigBlob, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetLocalDoubleRegisterValue(CorDebugRegister highWordReg, CorDebugRegister lowWordReg, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
+		public ICorDebugValue GetLocalDoubleRegisterValue(CorDebugRegister highWordReg, CorDebugRegister lowWordReg, uint cbSigBlob, uint pvSigBlob)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetLocalDoubleRegisterValue(((Debugger.Interop.CorDebug.CorDebugRegister)(highWordReg)), ((Debugger.Interop.CorDebug.CorDebugRegister)(lowWordReg)), cbSigBlob, pvSigBlob, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetLocalMemoryValue(ulong address, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
+		public ICorDebugValue GetLocalMemoryValue(ulong address, uint cbSigBlob, uint pvSigBlob)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetLocalMemoryValue(address, cbSigBlob, pvSigBlob, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetLocalRegisterMemoryValue(CorDebugRegister highWordReg, ulong lowWordAddress, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
+		public ICorDebugValue GetLocalRegisterMemoryValue(CorDebugRegister highWordReg, ulong lowWordAddress, uint cbSigBlob, uint pvSigBlob)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetLocalRegisterMemoryValue(((Debugger.Interop.CorDebug.CorDebugRegister)(highWordReg)), lowWordAddress, cbSigBlob, pvSigBlob, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetLocalMemoryRegisterValue(ulong highWordAddress, CorDebugRegister lowWordRegister, uint cbSigBlob, uint pvSigBlob, out ICorDebugValue ppValue)
+		public ICorDebugValue GetLocalMemoryRegisterValue(ulong highWordAddress, CorDebugRegister lowWordRegister, uint cbSigBlob, uint pvSigBlob)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetLocalMemoryRegisterValue(highWordAddress, ((Debugger.Interop.CorDebug.CorDebugRegister)(lowWordRegister)), cbSigBlob, pvSigBlob, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
 		public void CanSetIP(uint nOffset)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr objects, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr objects)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, objects, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue.cs

@@ -80,64 +80,105 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
 		{
+			get
+			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
 		{
+			get
+			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void GetClass(out ICorDebugClass ppClass)
+		public ICorDebugClass Class
+		{
+			get
 			{
+				ICorDebugClass ppClass;
 				Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
 				this.WrappedObject.GetClass(out out_ppClass);
 				ppClass = ICorDebugClass.Wrap(out_ppClass);
+				return ppClass;
+			}
 		}
 		
-		public void GetFieldValue(ICorDebugClass pClass, uint fieldDef, out ICorDebugValue ppValue)
+		public ICorDebugValue GetFieldValue(ICorDebugClass pClass, uint fieldDef)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetFieldValue(pClass.WrappedObject, fieldDef, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetVirtualMethod(uint memberRef, out ICorDebugFunction ppFunction)
+		public ICorDebugFunction GetVirtualMethod(uint memberRef)
 		{
+			ICorDebugFunction ppFunction;
 			Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 			this.WrappedObject.GetVirtualMethod(memberRef, out out_ppFunction);
 			ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
+			return ppFunction;
 		}
 		
-		public void GetContext(out ICorDebugContext ppContext)
+		public ICorDebugContext Context
+		{
+			get
 			{
+				ICorDebugContext ppContext;
 				Debugger.Interop.CorDebug.ICorDebugContext out_ppContext;
 				this.WrappedObject.GetContext(out out_ppContext);
 				ppContext = ICorDebugContext.Wrap(out_ppContext);
+				return ppContext;
+			}
 		}
 		
-		public void IsValueClass(out int pbIsValueClass)
+		public int IsValueClass
+		{
+			get
 			{
+				int pbIsValueClass;
 				this.WrappedObject.IsValueClass(out pbIsValueClass);
+				return pbIsValueClass;
+			}
 		}
 		
-		public void GetManagedCopy(out object ppObject)
+		public object ManagedCopy
 		{
+			get
+			{
+				object ppObject;
 				this.WrappedObject.GetManagedCopy(out ppObject);
+				return ppObject;
+			}
 		}
 		
 		public void SetFromManagedCopy(object pObject)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugObjectValue2.cs

@@ -80,13 +80,15 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetVirtualMethodAndType(uint memberRef, out ICorDebugFunction ppFunction, out ICorDebugType ppType)
+		public ICorDebugType GetVirtualMethodAndType(uint memberRef, out ICorDebugFunction ppFunction)
 		{
+			ICorDebugType ppType;
 			Debugger.Interop.CorDebug.ICorDebugFunction out_ppFunction;
 			Debugger.Interop.CorDebug.ICorDebugType out_ppType;
 			this.WrappedObject.GetVirtualMethodAndType(memberRef, out out_ppFunction, out out_ppType);
 			ppFunction = ICorDebugFunction.Wrap(out_ppFunction);
 			ppType = ICorDebugType.Wrap(out_ppType);
+			return ppType;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Continue(fIsOutOfBand);
 		}
 		
-		public void IsRunning(out int pbRunning)
+		public int IsRunning
 		{
+			get
+			{
+				int pbRunning;
 				this.WrappedObject.IsRunning(out pbRunning);
+				return pbRunning;
+			}
 		}
 		
-		public void HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued)
+		public int HasQueuedCallbacks(ICorDebugThread pThread)
 		{
+			int pbQueued;
 			this.WrappedObject.HasQueuedCallbacks(pThread.WrappedObject, out pbQueued);
+			return pbQueued;
 		}
 		
-		public void EnumerateThreads(out ICorDebugThreadEnum ppThreads)
+		public ICorDebugThreadEnum EnumerateThreads()
 		{
+			ICorDebugThreadEnum ppThreads;
 			Debugger.Interop.CorDebug.ICorDebugThreadEnum out_ppThreads;
 			this.WrappedObject.EnumerateThreads(out out_ppThreads);
 			ppThreads = ICorDebugThreadEnum.Wrap(out_ppThreads);
+			return ppThreads;
 		}
 		
 		public void SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread)
@@ -122,56 +131,78 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Terminate(exitCode);
 		}
 		
-		public void CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
+		public ICorDebugErrorInfoEnum CanCommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
 		{
+			ICorDebugErrorInfoEnum pError;
 			Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject;
 			Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError;
 			this.WrappedObject.CanCommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError);
 			pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots);
 			pError = ICorDebugErrorInfoEnum.Wrap(out_pError);
+			return pError;
 		}
 		
-		public void CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError)
+		public ICorDebugErrorInfoEnum CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots)
 		{
+			ICorDebugErrorInfoEnum pError;
 			Debugger.Interop.CorDebug.ICorDebugEditAndContinueSnapshot ref_pSnapshots = pSnapshots.WrappedObject;
 			Debugger.Interop.CorDebug.ICorDebugErrorInfoEnum out_pError;
 			this.WrappedObject.CommitChanges(cSnapshots, ref ref_pSnapshots, out out_pError);
 			pSnapshots = ICorDebugEditAndContinueSnapshot.Wrap(ref_pSnapshots);
 			pError = ICorDebugErrorInfoEnum.Wrap(out_pError);
+			return pError;
 		}
 		
-		public void GetID(out uint pdwProcessId)
+		public uint ID
+		{
+			get
 			{
+				uint pdwProcessId;
 				this.WrappedObject.GetID(out pdwProcessId);
+				return pdwProcessId;
+			}
 		}
 		
-		public void GetHandle(out uint phProcessHandle)
+		public uint Handle
+		{
+			get
 			{
+				uint phProcessHandle;
 				this.WrappedObject.GetHandle(out phProcessHandle);
+				return phProcessHandle;
+			}
 		}
 		
-		public void GetThread(uint dwThreadId, out ICorDebugThread ppThread)
+		public ICorDebugThread GetThread(uint dwThreadId)
 		{
+			ICorDebugThread ppThread;
 			Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
 			this.WrappedObject.GetThread(dwThreadId, out out_ppThread);
 			ppThread = ICorDebugThread.Wrap(out_ppThread);
+			return ppThread;
 		}
 		
-		public void EnumerateObjects(out ICorDebugObjectEnum ppObjects)
+		public ICorDebugObjectEnum EnumerateObjects()
 		{
+			ICorDebugObjectEnum ppObjects;
 			Debugger.Interop.CorDebug.ICorDebugObjectEnum out_ppObjects;
 			this.WrappedObject.EnumerateObjects(out out_ppObjects);
 			ppObjects = ICorDebugObjectEnum.Wrap(out_ppObjects);
+			return ppObjects;
 		}
 		
-		public void IsTransitionStub(ulong address, out int pbTransitionStub)
+		public int IsTransitionStub(ulong address)
 		{
+			int pbTransitionStub;
 			this.WrappedObject.IsTransitionStub(address, out pbTransitionStub);
+			return pbTransitionStub;
 		}
 		
-		public void IsOSSuspended(uint threadID, out int pbSuspended)
+		public int IsOSSuspended(uint threadID)
 		{
+			int pbSuspended;
 			this.WrappedObject.IsOSSuspended(threadID, out pbSuspended);
+			return pbSuspended;
 		}
 		
 		public void GetThreadContext(uint threadID, uint contextSize, System.IntPtr context)
@@ -184,14 +215,18 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetThreadContext(threadID, contextSize, context);
 		}
 		
-		public void ReadMemory(ulong address, uint size, System.IntPtr buffer, out uint read)
+		public uint ReadMemory(ulong address, uint size, System.IntPtr buffer)
 		{
+			uint read;
 			this.WrappedObject.ReadMemory(address, size, buffer, out read);
+			return read;
 		}
 		
-		public void WriteMemory(ulong address, uint size, ref byte buffer, out uint written)
+		public uint WriteMemory(ulong address, uint size, ref byte buffer)
 		{
+			uint written;
 			this.WrappedObject.WriteMemory(address, size, ref buffer, out written);
+			return written;
 		}
 		
 		public void ClearCurrentException(uint threadID)
@@ -209,30 +244,44 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.ModifyLogSwitch(ref pLogSwitchName, lLevel);
 		}
 		
-		public void EnumerateAppDomains(out ICorDebugAppDomainEnum ppAppDomains)
+		public ICorDebugAppDomainEnum EnumerateAppDomains()
 		{
+			ICorDebugAppDomainEnum ppAppDomains;
 			Debugger.Interop.CorDebug.ICorDebugAppDomainEnum out_ppAppDomains;
 			this.WrappedObject.EnumerateAppDomains(out out_ppAppDomains);
 			ppAppDomains = ICorDebugAppDomainEnum.Wrap(out_ppAppDomains);
+			return ppAppDomains;
 		}
 		
-		public void GetObject(out ICorDebugValue ppObject)
+		public ICorDebugValue Object
+		{
+			get
 			{
+				ICorDebugValue ppObject;
 				Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
 				this.WrappedObject.GetObject(out out_ppObject);
 				ppObject = ICorDebugValue.Wrap(out_ppObject);
+				return ppObject;
+			}
 		}
 		
-		public void ThreadForFiberCookie(uint fiberCookie, out ICorDebugThread ppThread)
+		public ICorDebugThread ThreadForFiberCookie(uint fiberCookie)
 		{
+			ICorDebugThread ppThread;
 			Debugger.Interop.CorDebug.ICorDebugThread out_ppThread;
 			this.WrappedObject.ThreadForFiberCookie(fiberCookie, out out_ppThread);
 			ppThread = ICorDebugThread.Wrap(out_ppThread);
+			return ppThread;
 		}
 		
-		public void GetHelperThreadID(out uint pThreadID)
+		public uint HelperThreadID
 		{
+			get
+			{
+				uint pThreadID;
 				this.WrappedObject.GetHelperThreadID(out pThreadID);
+				return pThreadID;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcess2.cs

@@ -80,21 +80,30 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetThreadForTaskID(ulong taskid, out ICorDebugThread2 ppThread)
+		public ICorDebugThread2 GetThreadForTaskID(ulong taskid)
 		{
+			ICorDebugThread2 ppThread;
 			Debugger.Interop.CorDebug.ICorDebugThread2 out_ppThread;
 			this.WrappedObject.GetThreadForTaskID(taskid, out out_ppThread);
 			ppThread = ICorDebugThread2.Wrap(out_ppThread);
+			return ppThread;
 		}
 		
-		public void GetVersion(out Debugger.Interop.CorDebug._COR_VERSION version)
+		public Debugger.Interop.CorDebug._COR_VERSION Version
 		{
+			get
+			{
+				Debugger.Interop.CorDebug._COR_VERSION version;
 				this.WrappedObject.GetVersion(out version);
+				return version;
+			}
 		}
 		
-		public void SetUnmanagedBreakpoint(ulong address, uint bufsize, System.IntPtr buffer, out uint bufLen)
+		public uint SetUnmanagedBreakpoint(ulong address, uint bufsize, System.IntPtr buffer)
 		{
+			uint bufLen;
 			this.WrappedObject.SetUnmanagedBreakpoint(address, bufsize, buffer, out bufLen);
+			return bufLen;
 		}
 		
 		public void ClearUnmanagedBreakpoint(ulong address)
@@ -107,16 +116,23 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetDesiredNGENCompilerFlags(pdwFlags);
 		}
 		
-		public void GetDesiredNGENCompilerFlags(out uint pdwFlags)
+		public uint DesiredNGENCompilerFlags
 		{
+			get
+			{
+				uint pdwFlags;
 				this.WrappedObject.GetDesiredNGENCompilerFlags(out pdwFlags);
+				return pdwFlags;
+			}
 		}
 		
-		public void GetReferenceValueFromGCHandle(uint handle, out ICorDebugReferenceValue pOutValue)
+		public ICorDebugReferenceValue GetReferenceValueFromGCHandle(uint handle)
 		{
+			ICorDebugReferenceValue pOutValue;
 			Debugger.Interop.CorDebug.ICorDebugReferenceValue out_pOutValue;
 			this.WrappedObject.GetReferenceValueFromGCHandle(handle, out out_pOutValue);
 			pOutValue = ICorDebugReferenceValue.Wrap(out_pOutValue);
+			return pOutValue;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugProcessEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr processes, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr processes)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, processes, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugReferenceValue.cs

@@ -80,36 +80,63 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
+		{
+			get
 			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
+		{
+			get
 			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void IsNull(out int pbNull)
+		public int IsNull
+		{
+			get
 			{
+				int pbNull;
 				this.WrappedObject.IsNull(out pbNull);
+				return pbNull;
+			}
 		}
 		
-		public void GetValue(out ulong pValue)
+		public ulong Value
 		{
+			get
+			{
+				ulong pValue;
 				this.WrappedObject.GetValue(out pValue);
+				return pValue;
+			}
 		}
 		
 		public void SetValue(ulong value)
@@ -117,18 +144,22 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetValue(value);
 		}
 		
-		public void Dereference(out ICorDebugValue ppValue)
+		public ICorDebugValue Dereference()
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.Dereference(out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void DereferenceStrong(out ICorDebugValue ppValue)
+		public ICorDebugValue DereferenceStrong()
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.DereferenceStrong(out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugRegisterSet.cs

@@ -80,9 +80,14 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetRegistersAvailable(out ulong pAvailable)
+		public ulong RegistersAvailable
 		{
+			get
+			{
+				ulong pAvailable;
 				this.WrappedObject.GetRegistersAvailable(out pAvailable);
+				return pAvailable;
+			}
 		}
 		
 		public void GetRegisters(ulong mask, uint regCount, System.IntPtr regBuffer)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepper.cs

@@ -80,9 +80,14 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void IsActive(out int pbActive)
+		public int IsActive
 		{
+			get
+			{
+				int pbActive;
 				this.WrappedObject.IsActive(out pbActive);
+				return pbActive;
+			}
 		}
 		
 		public void Deactivate()

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStepperEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr steppers, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr steppers)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, steppers, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugStringValue.cs

@@ -80,43 +80,72 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
+		{
+			get
 			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
+		{
+			get
 			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void IsValid(out int pbValid)
+		public int IsValid
+		{
+			get
 			{
+				int pbValid;
 				this.WrappedObject.IsValid(out pbValid);
+				return pbValid;
+			}
 		}
 		
-		public void CreateRelocBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateRelocBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateRelocBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 		
-		public void GetLength(out uint pcchString)
+		public uint Length
 		{
+			get
+			{
+				uint pcchString;
 				this.WrappedObject.GetLength(out pcchString);
+				return pcchString;
+			}
 		}
 		
 		public void GetString(uint cchString, out uint pcchString, System.IntPtr szString)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread.cs

@@ -80,28 +80,48 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetProcess(out ICorDebugProcess ppProcess)
+		public ICorDebugProcess Process
 		{
+			get
+			{
+				ICorDebugProcess ppProcess;
 				Debugger.Interop.CorDebug.ICorDebugProcess out_ppProcess;
 				this.WrappedObject.GetProcess(out out_ppProcess);
 				ppProcess = ICorDebugProcess.Wrap(out_ppProcess);
+				return ppProcess;
+			}
 		}
 		
-		public void GetID(out uint pdwThreadId)
+		public uint ID
+		{
+			get
 			{
+				uint pdwThreadId;
 				this.WrappedObject.GetID(out pdwThreadId);
+				return pdwThreadId;
+			}
 		}
 		
-		public void GetHandle(out uint phThreadHandle)
+		public uint Handle
+		{
+			get
 			{
+				uint phThreadHandle;
 				this.WrappedObject.GetHandle(out phThreadHandle);
+				return phThreadHandle;
+			}
 		}
 		
-		public void GetAppDomain(out ICorDebugAppDomain ppAppDomain)
+		public ICorDebugAppDomain AppDomain
 		{
+			get
+			{
+				ICorDebugAppDomain ppAppDomain;
 				Debugger.Interop.CorDebug.ICorDebugAppDomain out_ppAppDomain;
 				this.WrappedObject.GetAppDomain(out out_ppAppDomain);
 				ppAppDomain = ICorDebugAppDomain.Wrap(out_ppAppDomain);
+				return ppAppDomain;
+			}
 		}
 		
 		public void SetDebugState(CorDebugThreadState state)
@@ -109,25 +129,40 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetDebugState(((Debugger.Interop.CorDebug.CorDebugThreadState)(state)));
 		}
 		
-		public void GetDebugState(out CorDebugThreadState pState)
+		public CorDebugThreadState DebugState
+		{
+			get
 			{
+				CorDebugThreadState pState;
 				Debugger.Interop.CorDebug.CorDebugThreadState out_pState;
 				this.WrappedObject.GetDebugState(out out_pState);
 				pState = ((CorDebugThreadState)(out_pState));
+				return pState;
+			}
 		}
 		
-		public void GetUserState(out CorDebugUserState pState)
+		public CorDebugUserState UserState
+		{
+			get
 			{
+				CorDebugUserState pState;
 				Debugger.Interop.CorDebug.CorDebugUserState out_pState;
 				this.WrappedObject.GetUserState(out out_pState);
 				pState = ((CorDebugUserState)(out_pState));
+				return pState;
+			}
 		}
 		
-		public void GetCurrentException(out ICorDebugValue ppExceptionObject)
+		public ICorDebugValue CurrentException
+		{
+			get
 			{
+				ICorDebugValue ppExceptionObject;
 				Debugger.Interop.CorDebug.ICorDebugValue out_ppExceptionObject;
 				this.WrappedObject.GetCurrentException(out out_ppExceptionObject);
 				ppExceptionObject = ICorDebugValue.Wrap(out_ppExceptionObject);
+				return ppExceptionObject;
+			}
 		}
 		
 		public void ClearCurrentException()
@@ -135,53 +170,79 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.ClearCurrentException();
 		}
 		
-		public void CreateStepper(out ICorDebugStepper ppStepper)
+		public ICorDebugStepper CreateStepper()
 		{
+			ICorDebugStepper ppStepper;
 			Debugger.Interop.CorDebug.ICorDebugStepper out_ppStepper;
 			this.WrappedObject.CreateStepper(out out_ppStepper);
 			ppStepper = ICorDebugStepper.Wrap(out_ppStepper);
+			return ppStepper;
 		}
 		
-		public void EnumerateChains(out ICorDebugChainEnum ppChains)
+		public ICorDebugChainEnum EnumerateChains()
 		{
+			ICorDebugChainEnum ppChains;
 			Debugger.Interop.CorDebug.ICorDebugChainEnum out_ppChains;
 			this.WrappedObject.EnumerateChains(out out_ppChains);
 			ppChains = ICorDebugChainEnum.Wrap(out_ppChains);
+			return ppChains;
 		}
 		
-		public void GetActiveChain(out ICorDebugChain ppChain)
+		public ICorDebugChain ActiveChain
 		{
+			get
+			{
+				ICorDebugChain ppChain;
 				Debugger.Interop.CorDebug.ICorDebugChain out_ppChain;
 				this.WrappedObject.GetActiveChain(out out_ppChain);
 				ppChain = ICorDebugChain.Wrap(out_ppChain);
+				return ppChain;
+			}
 		}
 		
-		public void GetActiveFrame(out ICorDebugFrame ppFrame)
+		public ICorDebugFrame ActiveFrame
+		{
+			get
 			{
+				ICorDebugFrame ppFrame;
 				Debugger.Interop.CorDebug.ICorDebugFrame out_ppFrame;
 				this.WrappedObject.GetActiveFrame(out out_ppFrame);
 				ppFrame = ICorDebugFrame.Wrap(out_ppFrame);
+				return ppFrame;
+			}
 		}
 		
-		public void GetRegisterSet(out ICorDebugRegisterSet ppRegisters)
+		public ICorDebugRegisterSet RegisterSet
+		{
+			get
 			{
+				ICorDebugRegisterSet ppRegisters;
 				Debugger.Interop.CorDebug.ICorDebugRegisterSet out_ppRegisters;
 				this.WrappedObject.GetRegisterSet(out out_ppRegisters);
 				ppRegisters = ICorDebugRegisterSet.Wrap(out_ppRegisters);
+				return ppRegisters;
+			}
 		}
 		
-		public void CreateEval(out ICorDebugEval ppEval)
+		public ICorDebugEval CreateEval()
 		{
+			ICorDebugEval ppEval;
 			Debugger.Interop.CorDebug.ICorDebugEval out_ppEval;
 			this.WrappedObject.CreateEval(out out_ppEval);
 			ppEval = ICorDebugEval.Wrap(out_ppEval);
+			return ppEval;
 		}
 		
-		public void GetObject(out ICorDebugValue ppObject)
+		public ICorDebugValue Object
+		{
+			get
 			{
+				ICorDebugValue ppObject;
 				Debugger.Interop.CorDebug.ICorDebugValue out_ppObject;
 				this.WrappedObject.GetObject(out out_ppObject);
 				ppObject = ICorDebugValue.Wrap(out_ppObject);
+				return ppObject;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThread2.cs

@@ -85,19 +85,34 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.GetActiveFunctions(cFunctions, out pcFunctions, pFunctions);
 		}
 		
-		public void GetConnectionID(out uint pdwConnectionId)
+		public uint ConnectionID
 		{
+			get
+			{
+				uint pdwConnectionId;
 				this.WrappedObject.GetConnectionID(out pdwConnectionId);
+				return pdwConnectionId;
+			}
 		}
 		
-		public void GetTaskID(out ulong pTaskId)
+		public ulong TaskID
+		{
+			get
 			{
+				ulong pTaskId;
 				this.WrappedObject.GetTaskID(out pTaskId);
+				return pTaskId;
+			}
 		}
 		
-		public void GetVolatileOSThreadID(out uint pdwTid)
+		public uint VolatileOSThreadID
+		{
+			get
 			{
+				uint pdwTid;
 				this.WrappedObject.GetVolatileOSThreadID(out pdwTid);
+				return pdwTid;
+			}
 		}
 		
 		public void InterceptCurrentException(ICorDebugFrame pFrame)

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugThreadEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr threads, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr threads)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, threads, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugType.cs

@@ -80,49 +80,78 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint ty)
+		public uint Type
 		{
+			get
+			{
+				uint ty;
 				this.WrappedObject.GetType(out ty);
+				return ty;
+			}
 		}
 		
-		public void GetClass(out ICorDebugClass ppClass)
+		public ICorDebugClass Class
+		{
+			get
 			{
+				ICorDebugClass ppClass;
 				Debugger.Interop.CorDebug.ICorDebugClass out_ppClass;
 				this.WrappedObject.GetClass(out out_ppClass);
 				ppClass = ICorDebugClass.Wrap(out_ppClass);
+				return ppClass;
+			}
 		}
 		
-		public void EnumerateTypeParameters(out ICorDebugTypeEnum ppTyParEnum)
+		public ICorDebugTypeEnum EnumerateTypeParameters()
 		{
+			ICorDebugTypeEnum ppTyParEnum;
 			Debugger.Interop.CorDebug.ICorDebugTypeEnum out_ppTyParEnum;
 			this.WrappedObject.EnumerateTypeParameters(out out_ppTyParEnum);
 			ppTyParEnum = ICorDebugTypeEnum.Wrap(out_ppTyParEnum);
+			return ppTyParEnum;
 		}
 		
-		public void GetFirstTypeParameter(out ICorDebugType value)
+		public ICorDebugType FirstTypeParameter
+		{
+			get
 			{
+				ICorDebugType value;
 				Debugger.Interop.CorDebug.ICorDebugType out_value;
 				this.WrappedObject.GetFirstTypeParameter(out out_value);
 				value = ICorDebugType.Wrap(out_value);
+				return value;
+			}
 		}
 		
-		public void GetBase(out ICorDebugType pBase)
+		public ICorDebugType Base
+		{
+			get
 			{
+				ICorDebugType pBase;
 				Debugger.Interop.CorDebug.ICorDebugType out_pBase;
 				this.WrappedObject.GetBase(out out_pBase);
 				pBase = ICorDebugType.Wrap(out_pBase);
+				return pBase;
+			}
 		}
 		
-		public void GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
+		public ICorDebugValue GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame)
 		{
+			ICorDebugValue ppValue;
 			Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 			this.WrappedObject.GetStaticFieldValue(fieldDef, pFrame.WrappedObject, out out_ppValue);
 			ppValue = ICorDebugValue.Wrap(out_ppValue);
+			return ppValue;
 		}
 		
-		public void GetRank(out uint pnRank)
+		public uint Rank
 		{
+			get
+			{
+				uint pnRank;
 				this.WrappedObject.GetRank(out pnRank);
+				return pnRank;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugTypeEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr values)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, values, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue.cs

@@ -80,26 +80,43 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetType(out uint pType)
+		public uint Type
 		{
+			get
+			{
+				uint pType;
 				this.WrappedObject.GetType(out pType);
+				return pType;
+			}
 		}
 		
-		public void GetSize(out uint pSize)
+		public uint Size
+		{
+			get
 			{
+				uint pSize;
 				this.WrappedObject.GetSize(out pSize);
+				return pSize;
+			}
 		}
 		
-		public void GetAddress(out ulong pAddress)
+		public ulong Address
+		{
+			get
 			{
+				ulong pAddress;
 				this.WrappedObject.GetAddress(out pAddress);
+				return pAddress;
+			}
 		}
 		
-		public void CreateBreakpoint(out ICorDebugValueBreakpoint ppBreakpoint)
+		public ICorDebugValueBreakpoint CreateBreakpoint()
 		{
+			ICorDebugValueBreakpoint ppBreakpoint;
 			Debugger.Interop.CorDebug.ICorDebugValueBreakpoint out_ppBreakpoint;
 			this.WrappedObject.CreateBreakpoint(out out_ppBreakpoint);
 			ppBreakpoint = ICorDebugValueBreakpoint.Wrap(out_ppBreakpoint);
+			return ppBreakpoint;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValue2.cs

@@ -80,11 +80,16 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void GetExactType(out ICorDebugType ppType)
+		public ICorDebugType ExactType
 		{
+			get
+			{
+				ICorDebugType ppType;
 				Debugger.Interop.CorDebug.ICorDebugType out_ppType;
 				this.WrappedObject.GetExactType(out out_ppType);
 				ppType = ICorDebugType.Wrap(out_ppType);
+				return ppType;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueBreakpoint.cs

@@ -85,16 +85,26 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Activate(bActive);
 		}
 		
-		public void IsActive(out int pbActive)
+		public int IsActive
 		{
+			get
+			{
+				int pbActive;
 				this.WrappedObject.IsActive(out pbActive);
+				return pbActive;
+			}
 		}
 		
-		public void GetValue(out ICorDebugValue ppValue)
+		public ICorDebugValue Value
 		{
+			get
+			{
+				ICorDebugValue ppValue;
 				Debugger.Interop.CorDebug.ICorDebugValue out_ppValue;
 				this.WrappedObject.GetValue(out out_ppValue);
 				ppValue = ICorDebugValue.Wrap(out_ppValue);
+				return ppValue;
+			}
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ICorDebugValueEnum.cs

@@ -90,21 +90,30 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Reset();
 		}
 		
-		public void Clone(out ICorDebugEnum ppEnum)
+		public ICorDebugEnum Clone()
 		{
+			ICorDebugEnum ppEnum;
 			Debugger.Interop.CorDebug.ICorDebugEnum out_ppEnum;
 			this.WrappedObject.Clone(out out_ppEnum);
 			ppEnum = ICorDebugEnum.Wrap(out_ppEnum);
+			return ppEnum;
 		}
 		
-		public void GetCount(out uint pcelt)
+		public uint Count
 		{
+			get
+			{
+				uint pcelt;
 				this.WrappedObject.GetCount(out pcelt);
+				return pcelt;
+			}
 		}
 		
-		public void Next(uint celt, System.IntPtr values, out uint pceltFetched)
+		public uint Next(uint celt, System.IntPtr values)
 		{
+			uint pceltFetched;
 			this.WrappedObject.Next(celt, values, out pceltFetched);
+			return pceltFetched;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/ISequentialStream.cs

@@ -80,14 +80,18 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void RemoteRead(out byte pv, uint cb, out uint pcbRead)
+		public uint RemoteRead(out byte pv, uint cb)
 		{
+			uint pcbRead;
 			this.WrappedObject.RemoteRead(out pv, cb, out pcbRead);
+			return pcbRead;
 		}
 		
-		public void RemoteWrite(ref byte pv, uint cb, out uint pcbWritten)
+		public uint RemoteWrite(ref byte pv, uint cb)
 		{
+			uint pcbWritten;
 			this.WrappedObject.RemoteWrite(ref pv, cb, out pcbWritten);
+			return pcbWritten;
 		}
 	}
 }

src/AddIns/Misc/Debugger/Debugger.Core/Project/Src/Wrappers/CorDebug/IStream.cs

@@ -80,19 +80,25 @@ namespace Debugger.Wrappers.CorDebug
 		}
 		
 		
-		public void RemoteRead(out byte pv, uint cb, out uint pcbRead)
+		public uint RemoteRead(out byte pv, uint cb)
 		{
+			uint pcbRead;
 			this.WrappedObject.RemoteRead(out pv, cb, out pcbRead);
+			return pcbRead;
 		}
 		
-		public void RemoteWrite(ref byte pv, uint cb, out uint pcbWritten)
+		public uint RemoteWrite(ref byte pv, uint cb)
 		{
+			uint pcbWritten;
 			this.WrappedObject.RemoteWrite(ref pv, cb, out pcbWritten);
+			return pcbWritten;
 		}
 		
-		public void RemoteSeek(Debugger.Interop.CorDebug._LARGE_INTEGER dlibMove, uint dwOrigin, out Debugger.Interop.CorDebug._ULARGE_INTEGER plibNewPosition)
+		public Debugger.Interop.CorDebug._ULARGE_INTEGER RemoteSeek(Debugger.Interop.CorDebug._LARGE_INTEGER dlibMove, uint dwOrigin)
 		{
+			Debugger.Interop.CorDebug._ULARGE_INTEGER plibNewPosition;
 			this.WrappedObject.RemoteSeek(dlibMove, dwOrigin, out plibNewPosition);
+			return plibNewPosition;
 		}
 		
 		public void SetSize(Debugger.Interop.CorDebug._ULARGE_INTEGER libNewSize)
@@ -100,9 +106,11 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.SetSize(libNewSize);
 		}
 		
-		public void RemoteCopyTo(IStream pstm, Debugger.Interop.CorDebug._ULARGE_INTEGER cb, out Debugger.Interop.CorDebug._ULARGE_INTEGER pcbRead, out Debugger.Interop.CorDebug._ULARGE_INTEGER pcbWritten)
+		public Debugger.Interop.CorDebug._ULARGE_INTEGER RemoteCopyTo(IStream pstm, Debugger.Interop.CorDebug._ULARGE_INTEGER cb, out Debugger.Interop.CorDebug._ULARGE_INTEGER pcbRead)
 		{
+			Debugger.Interop.CorDebug._ULARGE_INTEGER pcbWritten;
 			this.WrappedObject.RemoteCopyTo(pstm.WrappedObject, cb, out pcbRead, out pcbWritten);
+			return pcbWritten;
 		}
 		
 		public void Commit(uint grfCommitFlags)
@@ -130,11 +138,13 @@ namespace Debugger.Wrappers.CorDebug
 			this.WrappedObject.Stat(out pstatstg, grfStatFlag);
 		}
 		
-		public void Clone(out IStream ppstm)
+		public IStream Clone()
 		{
+			IStream ppstm;
 			Debugger.Interop.CorDebug.IStream out_ppstm;
 			this.WrappedObject.Clone(out out_ppstm);
 			ppstm = IStream.Wrap(out_ppstm);
+			return ppstm;
 		}
 	}
 }

src/Tools/WrapperGenerator/CodeGenerator.cs

@@ -319,8 +319,9 @@ namespace WrapperGenerator
 		
 		class MethodContext
 		{
-			CodeMemberMethod codeMemberMethod = new CodeMemberMethod();
+			public CodeTypeMember CodeMemberMethod = new CodeMemberMethod();
 			CodeGenerator generator;
+			MethodInfo method;
 			
 			public string Name;
 			public bool IsReturnTypeWrapped;
@@ -329,12 +330,14 @@ namespace WrapperGenerator
 			
 			public List<CodeParameterDeclarationExpression> WrapperParams = new List<CodeParameterDeclarationExpression>();
 			public List<CodeStatement> DoBeforeInvoke = new List<CodeStatement>();
+			CodeStatement doInvoke;
 			public List<CodeExpression> BaseMethodInvokeParams = new List<CodeExpression>();
 			public List<CodeStatement> DoAfterInvoke = new List<CodeStatement>();
 			
 			public MethodContext(CodeGenerator generator, MethodInfo method)
 			{
 				this.generator = generator;
+				this.method = method;
 				Name = method.Name;
 				RawReturnType = method.ReturnType;
 				IsReturnTypeWrapped = generator.ShouldIncludeType(method.ReturnType);
@@ -343,28 +346,22 @@ namespace WrapperGenerator
 				} else {
 					WrappedReturnType = method.ReturnType.FullName;
 				}
-				
-				codeMemberMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
-				codeMemberMethod.ReturnType = new CodeTypeReference(WrappedReturnType);
-				codeMemberMethod.Name = method.Name;
 			}
 			
-			public CodeMemberMethod Emit()
+			void AddBaseInvokeCode()
 			{
 				CodeExpression baseInvoke = 
 					new CodeMethodInvokeExpression(
 						new CodeMethodReferenceExpression(
 							generator.ExpressionForWrappedObjectProperty,
-							Name),
+							method.Name),
 						BaseMethodInvokeParams.ToArray());
 				
 				if (IsReturnTypeWrapped) {
 					baseInvoke = generator.Wrap(RawReturnType, baseInvoke);
 				}
 				
-				CodeStatement doInvoke;
+				if (RawReturnType != typeof(void)) {
-				
-				if (WrappedReturnType != typeof(void).FullName) {
 					if (DoAfterInvoke.Count == 0) {
 						doInvoke = new CodeMethodReturnStatement(baseInvoke);
 					} else {
@@ -381,13 +378,31 @@ namespace WrapperGenerator
 				} else {
 					doInvoke = new CodeExpressionStatement(baseInvoke);
 				}
+			}
 			
-				codeMemberMethod.Statements.AddRange(DoBeforeInvoke.ToArray());
+			public CodeTypeMember Emit()
-				codeMemberMethod.Statements.Add(doInvoke);
+			{
-				codeMemberMethod.Statements.AddRange(DoAfterInvoke.ToArray());
+				AddBaseInvokeCode();
-				codeMemberMethod.Parameters.AddRange(WrapperParams.ToArray());
+				
+				List<CodeStatement> body = new List<CodeStatement>();
+				body.AddRange(DoBeforeInvoke);
+				body.Add(doInvoke);
+				body.AddRange(DoAfterInvoke);
+				
+				CodeMemberMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
+				CodeMemberMethod.Name = Name;
+				
+				if (CodeMemberMethod is CodeMemberMethod) {
+					((CodeMemberMethod)CodeMemberMethod).ReturnType = new CodeTypeReference(WrappedReturnType);
+					((CodeMemberMethod)CodeMemberMethod).Parameters.AddRange(WrapperParams.ToArray());
+					((CodeMemberMethod)CodeMemberMethod).Statements.AddRange(body.ToArray());
+				} else {
+					((CodeMemberProperty)CodeMemberMethod).Type = new CodeTypeReference(WrappedReturnType);
+					((CodeMemberProperty)CodeMemberMethod).HasGet = true;
+					((CodeMemberProperty)CodeMemberMethod).GetStatements.AddRange(body.ToArray());
+				}
 				
-				return codeMemberMethod;
+				return CodeMemberMethod;
 			}
 		}
 		
@@ -435,16 +450,17 @@ namespace WrapperGenerator
 			}
 		}
 		
-		CodeMemberMethod MakeMember(MethodInfo method)
+		CodeTypeMember MakeMember(MethodInfo method)
 		{
 			MethodContext methodContext = new MethodContext(this, method);
 			
-			foreach(ParameterInfo par in method.GetParameters()) {
+			ParameterInfo[] pars = method.GetParameters();
-				ParamContext parContext = new ParamContext(this, par);
+			for(int i = 0; i < pars.Length; i++) {
+				ParamContext parContext = new ParamContext(this, pars[i]);
 				
 				if (parContext.IsWrapped) {
 					if (parContext.Direction == FieldDirection.In) {
-						if (par.ParameterType.IsArray) {
+						if (pars[i].ParameterType.IsArray) {
 							UnwrapArrayArgument(methodContext, parContext);
 						} else {
 							UnwrapArgument(methodContext, parContext);
@@ -455,6 +471,33 @@ namespace WrapperGenerator
 				} else {
 					PassArgument(methodContext, parContext);
 				}
+				
+				// If last parameter is 'out' and method returns void
+				if (i == pars.Length - 1 &&
+				    parContext.Direction == FieldDirection.Out &&
+				    methodContext.RawReturnType == typeof(void)) {
+					
+					// Placeholder for the parameter
+					methodContext.DoBeforeInvoke.Insert(0,
+						new CodeVariableDeclarationStatement(parContext.WrappedType, parContext.Name));
+					// Remove the parameter
+					methodContext.WrapperParams.RemoveAt(methodContext.WrapperParams.Count - 1);
+					
+					methodContext.WrappedReturnType = parContext.WrappedType;
+					methodContext.DoAfterInvoke.Add(
+						new CodeMethodReturnStatement(
+							new CodeVariableReferenceExpression(parContext.Name)));
+				}
+			}
+			
+			if (methodContext.WrapperParams.Count == 0) {
+				if (methodContext.Name.StartsWith("Is")) {
+					methodContext.CodeMemberMethod = new CodeMemberProperty();
+				}
+				if (methodContext.Name.StartsWith("Get")) {
+					methodContext.CodeMemberMethod = new CodeMemberProperty();
+					methodContext.Name = methodContext.Name.Remove(0, 3);
+				}
 			}
 			
 			return methodContext.Emit();