Refactored both script libraries so they no longer reference mono runtime directly

Fixed a few compile errors caused by refactors

Source/BansheeMono/Include/BsMonoArray.h

@@ -4,8 +4,8 @@
 
 #include "BsMonoPrerequisites.h"
 #include "BsScriptMeta.h"
+#include "BsMonoUtil.h"
 #include "BsMonoManager.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {
@@ -40,20 +40,20 @@ namespace BansheeEngine
 			assert(sizeof(T) == elementSize());
 #endif
 
-			return (T*)mono_array_addr(mInternal, T, idx);
+			return (T*)getArrayAddr(mInternal, sizeof(T), idx);
 		}
 
 		/** 
 		 * Returns the raw object from the array at the specified index. Provided size determines the size of each
 		 * element in the array. Caller must ensure it is correct for the specified array.
 		 */
-		UINT8* getRawPtr(UINT32 size, UINT32 idx = 0)
+		UINT8* getRawPtr(UINT32 size, UINT32 idx)
 		{
 #if BS_DEBUG_MODE
 			assert(size == elementSize());
 #endif
 
-			return (UINT8*)mono_array_addr_with_size(mInternal, size, idx);
+			return getArrayAddr(mInternal, size, idx);
 		}
 
 		/** 
@@ -73,6 +73,24 @@ namespace BansheeEngine
 		/** Returns the managed object representing this array. */
 		MonoArray* getInternal() const { return mInternal; }
 
+		/** 
+		 * Returns the address of an array item at the specified index. 
+		 *
+		 * @param[in]	array	Array from which to retrieve the item.
+		 * @param[in]	size	Size of a single item in the array.
+		 * @param[in]	idx		Index of the item to retrieve.
+		 * @return				Address of the array item at the requested index. 
+		 */
+		static UINT8* getArrayAddr(MonoArray* array, UINT32 size, UINT32 idx);
+
+		/** Returns the class of the elements within an array class. */
+		static ::MonoClass* getElementClass(::MonoClass* arrayClass);
+
+		/** Returns the rank of the provided array class. */
+		static UINT32 getRank(::MonoClass* arrayClass);
+
+		/** Builds an array class from the provided element class and a rank. */
+		static ::MonoClass* buildArrayClass(::MonoClass* elementClass, UINT32 rank);
 	private:
 		MonoArray* mInternal;
 	};
@@ -86,16 +104,19 @@ namespace BansheeEngine
 	{
 		// A layer of indirection for all methods specialized by ScriptArray. */
 
+
+
 		template<class T>
 		T ScriptArray_get(MonoArray* array, UINT32 idx)
 		{
-			return mono_array_get(array, T, idx);
+			return *(T*)ScriptArray::getArrayAddr(array, sizeof(T), idx);
 		}
 
 		template<class T>
 		void ScriptArray_set(MonoArray* array, UINT32 idx, const T& value)
 		{
-			mono_array_set(array, T, idx, value);
+			T* item = (T*)ScriptArray::getArrayAddr(array, sizeof(T), idx);
+			*item = value;
 		}
 
 		template<>
@@ -119,49 +140,49 @@ namespace BansheeEngine
 		template<>
 		inline ScriptArray ScriptArray_create<UINT32>(UINT32 size)
 		{
-			return ScriptArray(mono_get_uint32_class(), size);
+			return ScriptArray(MonoUtil::getUINT32Class(), size);
 		}
 
 		template<>
 		inline ScriptArray ScriptArray_create<INT32>(UINT32 size)
 		{
-			return ScriptArray(mono_get_int32_class(), size);
+			return ScriptArray(MonoUtil::getINT32Class(), size);
 		}
 
 		template<>
 		inline ScriptArray ScriptArray_create<UINT64>(UINT32 size)
 		{
-			return ScriptArray(mono_get_uint64_class(), size);
+			return ScriptArray(MonoUtil::getUINT64Class(), size);
 		}
 
 		template<>
 		inline ScriptArray ScriptArray_create<INT64>(UINT32 size)
 		{
-			return ScriptArray(mono_get_int64_class(), size);
+			return ScriptArray(MonoUtil::getINT64Class(), size);
 		}
 
 		template<>
 		inline ScriptArray ScriptArray_create<WString>(UINT32 size)
 		{
-			return ScriptArray(mono_get_string_class(), size);
+			return ScriptArray(MonoUtil::getStringClass(), size);
 		}
 
 		template<>
 		inline ScriptArray ScriptArray_create<String>(UINT32 size)
 		{
-			return ScriptArray(mono_get_string_class(), size);
+			return ScriptArray(MonoUtil::getStringClass(), size);
 		}
 
 		template<>
 		inline ScriptArray ScriptArray_create<float>(UINT32 size)
 		{
-			return ScriptArray(mono_get_single_class(), size);
+			return ScriptArray(MonoUtil::getFloatClass(), size);
 		}
 
 		template<>
 		inline ScriptArray ScriptArray_create<bool>(UINT32 size)
 		{
-			return ScriptArray(mono_get_boolean_class(), size);
+			return ScriptArray(MonoUtil::getBoolClass(), size);
 		}
 	}
 

Source/BansheeMono/Include/BsMonoAssembly.h

@@ -3,8 +3,6 @@
 #pragma once
 
 #include "BsMonoPrerequisites.h"
-#include <mono/jit/jit.h>
-#include <mono/metadata/assembly.h>
 
 namespace BansheeEngine
 {

Source/BansheeMono/Include/BsMonoClass.h

@@ -3,7 +3,6 @@
 #pragma once
 
 #include "BsMonoPrerequisites.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {
@@ -177,6 +176,9 @@ namespace BansheeEngine
 
 		/**	Returns the internal mono representation of the class. */
 		::MonoClass* _getInternalClass() const { return mClass; }
+
+		/** Invokes the parameterless constructor on the provided object. */
+		static void construct(MonoObject* object);
 	private:
 		friend class MonoAssembly;
 

Source/BansheeMono/Include/BsMonoField.h

@@ -3,8 +3,6 @@
 #pragma once
 
 #include "BsMonoPrerequisites.h"
-#include <mono/jit/jit.h>
-#include <mono/metadata/class.h>
 
 namespace BansheeEngine
 {

Source/BansheeMono/Include/BsMonoManager.h

@@ -5,7 +5,6 @@
 #include "BsMonoPrerequisites.h"
 #include "BsScriptMeta.h"
 #include "BsModule.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/BansheeMono/Include/BsMonoMethod.h

@@ -3,7 +3,6 @@
 #pragma once
 
 #include "BsMonoPrerequisites.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/BansheeMono/Include/BsMonoPrerequisites.h

@@ -38,4 +38,40 @@ namespace BansheeEngine
 	class MonoMethod;
 	class MonoField;
 	class MonoProperty;
-}
+
+	/** A list of all valid Mono primitive types. */
+	enum class MonoPrimitiveType
+	{
+		Boolean,
+		Char,
+		I8,
+		U8,
+		I16,
+		U16,
+		I32,
+		U32,
+		I64,
+		U64,
+		R32,
+		R64,
+		String,
+		ValueType,
+		Class,
+		Array,
+		Generic,
+		Unknown
+	};
+}
+
+typedef struct _MonoClass MonoClass;
+typedef struct _MonoDomain MonoDomain;
+typedef struct _MonoImage MonoImage;
+typedef struct _MonoAssembly MonoAssembly;
+typedef struct _MonoMethod MonoMethod;
+typedef struct _MonoProperty MonoProperty;
+typedef struct _MonoObject MonoObject;
+typedef struct _MonoString MonoString;
+typedef struct _MonoArray MonoArray;
+typedef struct _MonoReflectionType MonoReflectionType;
+typedef struct _MonoException MonoException;
+typedef struct _MonoClassField MonoClassField;

Source/BansheeMono/Include/BsMonoProperty.h

@@ -3,7 +3,6 @@
 #pragma once
 
 #include "BsMonoPrerequisites.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/BansheeMono/Include/BsMonoUtil.h

@@ -3,11 +3,6 @@
 #pragma once
 
 #include "BsMonoPrerequisites.h"
-#include "BsException.h"
-#include "BsDebug.h"
-#include "BsMonoArray.h"
-#include <mono/jit/jit.h>
-#include <codecvt>
 
 namespace BansheeEngine
 {
@@ -20,133 +15,112 @@ namespace BansheeEngine
 	{
 	public:
 		/**	Converts a Mono (managed) string to a native wide string. */
-		static WString monoToWString(MonoString* str)
-		{
-			if(str == nullptr)
-				return StringUtil::WBLANK;
+		static WString monoToWString(MonoString* str);
 
-			int len = mono_string_length(str);
-			mono_unichar2* monoChars = mono_string_chars(str);
+		/**	Converts a Mono (managed) string to a native narrow string. */
+		static String monoToString(MonoString* str);
 
-			WString ret(len, '0');
-			for(int i = 0; i < len; i++)
-				ret[i] = monoChars[i];
+		/**	Converts a native wide string to a Mono (managed) string. */
+		static MonoString* wstringToMono(const WString& str);
 
-			return ret;
-		}
+		/**	Converts a native narrow string to a Mono (managed) string. */
+		static MonoString* stringToMono(const String& str);
 
-		/**	Converts a Mono (managed) string to a native narrow string. */
-		static String monoToString(MonoString* str)
-		{
-			if(str == nullptr)
-				return StringUtil::BLANK;
+		/**	Outputs name and namespace for the type of the specified object. */
+		static void getClassName(MonoObject* obj, String& ns, String& typeName);
 
-			int len = mono_string_length(str);
-			mono_unichar2* monoChars = mono_string_chars(str);
+		/**	Outputs name and namespace for the specified type. */
+		static void getClassName(::MonoClass* monoClass, String& ns, String& typeName);
 
-			String ret(len, '0');
-			for(int i = 0; i < len; i++)
-				ret[i] = (char)monoChars[i];
+		/**	Outputs name and namespace for the specified type. */
+		static void getClassName(MonoReflectionType* monoReflType, String& ns, String& typeName);
 
-			return ret;
-		}
+		/** Returns the class of the provided object. */
+		static ::MonoClass* getClass(MonoObject* object);
 
-		/**	Converts a native wide string to a Mono (managed) string. */
-		static MonoString* wstringToMono(const WString& str)
-		{
-			if (sizeof(wchar_t) == 2) // Assuming UTF-16
-				return mono_string_from_utf16((mono_unichar2*)str.c_str());
-			else // Assuming UTF-32
-			{
-				const std::codecvt_mode convMode = (std::codecvt_mode)(std::little_endian);
-				typedef std::codecvt_utf16<UINT32, 1114111, convMode> utf16utf32;
-
-				std::wstring_convert<utf16utf32, UINT32> conversion("?");
-				UINT32* start = (UINT32*)str.data();
-				UINT32* end = (start + (str.size() - 1) / 4);
-
-				mono_unichar2* convertedStr = (mono_unichar2*)conversion.to_bytes(start, end).c_str();
-				return mono_string_from_utf16(convertedStr);
-			}
-		}
+		/** Returns the class of the provided type. */
+		static ::MonoClass* getClass(MonoReflectionType* type);
 
-		/**	Converts a native narrow string to a Mono (managed) string. */
-		static MonoString* stringToMono(const String& str)
-		{
-			return wstringToMono(toWString(str));
-		}
+		/** Returns the type of the provided object. */
+		static MonoReflectionType* getType(MonoObject* object);
 
-		/**	Outputs name and namespace for the type of the specified object. */
-		static void getClassName(MonoObject* obj, String& ns, String& typeName)
-		{
-			if (obj == nullptr)
-				return;
+		/** Returns the type of the provided class. */
+		static MonoReflectionType* getType(::MonoClass* klass);
 
-			::MonoClass* monoClass = mono_object_get_class(obj);
-			getClassName(monoClass, ns, typeName);
-		}
+		/** Creates a new GC handle for the provided managed object, ensuring it doesn't go out of scope. */
+		static UINT32 newGCHandle(MonoObject* object);
 
-		/**	Outputs name and namespace for the specified type. */
-		static void getClassName(::MonoClass* monoClass, String& ns, String& typeName)
-		{
-			::MonoClass* nestingClass = mono_class_get_nesting_type(monoClass);
-
-			if (nestingClass == nullptr)
-			{
-				ns = mono_class_get_namespace(monoClass);
-				typeName = mono_class_get_name(monoClass);
-
-				return;
-			}
-			else
-			{
-				typeName = String("+") + mono_class_get_name(monoClass);
-
-				do 
-				{
-					::MonoClass* nextNestingClass = mono_class_get_nesting_type(nestingClass);
-					if (nextNestingClass != nullptr)
-					{
-						typeName = String("+") + mono_class_get_name(nestingClass) + typeName;
-						nestingClass = nextNestingClass;
-					}
-					else
-					{
-						ns = mono_class_get_namespace(nestingClass);
-						typeName = mono_class_get_name(nestingClass) + typeName;
-
-						break;
-					}
-				} while (true);
-			}
-		}
+		/** Frees a GC handle previously allocated with newGCHandle. */
+		static void freeGCHandle(UINT32 handle);
+
+		/** Converts a managed value type into a reference type by boxing it. */
+		static MonoObject* box(::MonoClass* klass, void* value);
+
+		/** Unboxes a managed object back to a raw value type. */
+		static void* unbox(MonoObject* object);
+
+		/**	Checks if this class is a sub class of the specified class. */
+		static bool isSubClassOf(::MonoClass* subClass, ::MonoClass* parentClass);
+
+		/** Checks is the specified class a value type. */
+		static bool isValueType(::MonoClass* object);
+
+		/** Checks is the specified class an enum. */
+		static bool isEnum(::MonoClass* object);
+
+		/** Returns the underlying primitive type for an enum. */
+		static MonoPrimitiveType getEnumPrimitiveType(::MonoClass* enumClass);
+
+		/** Returns the primitive type of the provided class. */
+		static MonoPrimitiveType getPrimitiveType(::MonoClass* monoClass);
+
+		/** Binds parameters to a generic class, and returns a new instantiable class with the bound parameters. */
+		static ::MonoClass* bindGenericParameters(::MonoClass* klass, ::MonoClass** params, UINT32 numParams);
+
+		/** Returns Mono class for a 16-bit unsigned integer. */
+		static ::MonoClass* getUINT16Class();
+
+		/** Returns Mono class for a 16-bit signed integer. */
+		static ::MonoClass* getINT16Class();
+
+		/** Returns Mono class for a 32-bit unsigned integer. */
+		static ::MonoClass* getUINT32Class();
+
+		/** Returns Mono class for a 32-bit signed integer. */
+		static ::MonoClass* getINT32Class();
+
+		/** Returns Mono class for a 64-bit unsigned integer. */
+		static ::MonoClass* getUINT64Class();
+
+		/** Returns Mono class for a 32-bit signed integer. */
+		static ::MonoClass* getINT64Class();
+
+		/** Returns Mono class for a string. */
+		static ::MonoClass* getStringClass();
+
+		/** Returns Mono class for a floating point number. */
+		static ::MonoClass* getFloatClass();
+
+		/** Returns Mono class for a double floating point number. */
+		static ::MonoClass* getDoubleClass();
+
+		/** Returns Mono class for a boolean. */
+		static ::MonoClass* getBoolClass();
+
+		/** Returns Mono class for an unsigned byte. */
+		static ::MonoClass* getByteClass();
+
+		/** Returns Mono class for a byte. */
+		static ::MonoClass* getSByteClass();
+
+		/** Returns Mono class for a char. */
+		static ::MonoClass* getCharClass();
 
 		/** @copydoc throwIfException(MonoObject*) */
-		static void throwIfException(MonoException* exception)
-		{
-			throwIfException(reinterpret_cast<MonoObject*>(exception));
-		}
+		static void throwIfException(MonoException* exception);
 
 		/**	Throws a native exception if the provided object is a valid managed exception. */
-		static void throwIfException(MonoObject* exception)
-		{
-			if(exception != nullptr)
-			{
-				::MonoClass* exceptionClass = mono_object_get_class(exception);
-				::MonoProperty* exceptionMsgProp = mono_class_get_property_from_name(exceptionClass, "Message");
-				::MonoMethod* exceptionMsgGetter = mono_property_get_get_method(exceptionMsgProp);
-				MonoString* exceptionMsg = (MonoString*)mono_runtime_invoke(exceptionMsgGetter, exception, nullptr, nullptr);
-
-				::MonoProperty* exceptionStackProp = mono_class_get_property_from_name(exceptionClass, "StackTrace");
-				::MonoMethod* exceptionStackGetter = mono_property_get_get_method(exceptionStackProp);
-				MonoString* exceptionStackTrace = (MonoString*)mono_runtime_invoke(exceptionStackGetter, exception, nullptr, nullptr);
-
-				// Note: If you modify this format make sure to also modify Debug.ParseExceptionMessage in managed code.
-				String msg =  "Managed exception: " + toString(monoToWString(exceptionMsg)) + "\n" + toString(monoToWString(exceptionStackTrace));
-
-				LOGERR(msg);
-			}
-		}
+		static void throwIfException(MonoObject* exception);
 
 		/** Invokes a thunk retrieved from MonoMethod::getThunk const and automatically handles exceptions. */
 		template<class T, class... Args>
@@ -160,4 +134,6 @@ namespace BansheeEngine
 	};
 
 	/** @} */
-}
+}
+
+#include "BsMonoArray.h"

Source/BansheeMono/Source/BsMonoArray.cpp

@@ -4,6 +4,7 @@
 #include "BsMonoManager.h"
 #include "BsMonoClass.h"
 #include "BsMonoUtil.h"
+#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {
@@ -72,4 +73,24 @@ namespace BansheeEngine
 
 		return (UINT32)mono_class_array_element_size(elementClass);
 	}
+
+	UINT8* ScriptArray::getArrayAddr(MonoArray* array, UINT32 size, UINT32 idx)
+	{
+		return (UINT8*)mono_array_addr_with_size(array, size, idx);
+	}
+
+	::MonoClass* ScriptArray::getElementClass(::MonoClass* arrayClass)
+	{
+		return mono_class_get_element_class(arrayClass);
+	}
+
+	UINT32 ScriptArray::getRank(::MonoClass* arrayClass)
+	{
+		return (UINT32)mono_class_get_rank(arrayClass);
+	}
+
+	::MonoClass* ScriptArray::buildArrayClass(::MonoClass* elementClass, UINT32 rank)
+	{
+		return mono_array_class_get(elementClass, rank);
+	}
 }

Source/BansheeMono/Source/BsMonoAssembly.cpp

@@ -8,6 +8,8 @@
 #include "BsDataStream.h"
 #include "BsException.h"
 
+#include <mono/jit/jit.h>
+#include <mono/metadata/assembly.h>
 #include <mono/metadata/debug-helpers.h>
 #include <mono/metadata/tokentype.h>
 #include <mono/metadata/mono-debug.h>

Source/BansheeMono/Source/BsMonoClass.cpp

@@ -8,8 +8,9 @@
 #include "BsMonoManager.h"
 #include "BsException.h"
 #include "BsMonoUtil.h"
+
+#include <mono/jit/jit.h>
 #include <mono/metadata/debug-helpers.h>
-#include "BsDebug.h"
 
 namespace BansheeEngine
 {
@@ -269,6 +270,11 @@ namespace BansheeEngine
 		return obj;
 	}
 
+	void MonoClass::construct(MonoObject* object)
+	{
+		mono_runtime_object_init(object);
+	}
+
 	bool MonoClass::hasAttribute(MonoClass* monoClass) const
 	{
 		// TODO - Consider caching custom attributes or just initializing them all at load

Source/BansheeMono/Source/BsMonoField.cpp

@@ -5,6 +5,8 @@
 #include "BsMonoManager.h"
 
 #include <mono/metadata/attrdefs.h>
+#include <mono/jit/jit.h>
+#include <mono/metadata/class.h>
 
 namespace BansheeEngine
 {

Source/BansheeMono/Source/BsMonoManager.cpp

@@ -7,8 +7,10 @@
 #include "BsMonoClass.h"
 #include "BsMonoUtil.h"
 #include "BsFileSystem.h"
+#include "BsException.h"
 #include "BsApplication.h"
 
+#include "mono/jit/jit.h"
 #include <mono/metadata/assembly.h>
 #include <mono/metadata/mono-config.h>
 #include <mono/metadata/mono-gc.h>

Source/BansheeMono/Source/BsMonoMethod.cpp

@@ -4,6 +4,8 @@
 #include "BsMonoManager.h"
 #include "BsMonoUtil.h"
 #include "BsMonoClass.h"
+#include "BsException.h"
+#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/BansheeMono/Source/BsMonoProperty.cpp

@@ -3,6 +3,7 @@
 #include "BsMonoProperty.h"
 #include "BsMonoMethod.h"
 #include "BsMonoManager.h"
+#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/BansheeMono/Source/BsMonoUtil.cpp

@@ -1,3 +1,327 @@
 //********************************** Banshee Engine (www.banshee3d.com) **************************************************//
 //**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#include "BsMonoUtil.h"
+#include "BsMonoUtil.h"
+#include "BsDebug.h"
+#include <mono/jit/jit.h>
+#include <codecvt>
+
+namespace BansheeEngine
+{
+	WString MonoUtil::monoToWString(MonoString* str)
+	{
+		if (str == nullptr)
+			return StringUtil::WBLANK;
+
+		int len = mono_string_length(str);
+		mono_unichar2* monoChars = mono_string_chars(str);
+
+		WString ret(len, '0');
+		for (int i = 0; i < len; i++)
+			ret[i] = monoChars[i];
+
+		return ret;
+	}
+
+	String MonoUtil::monoToString(MonoString* str)
+	{
+		if (str == nullptr)
+			return StringUtil::BLANK;
+
+		int len = mono_string_length(str);
+		mono_unichar2* monoChars = mono_string_chars(str);
+
+		String ret(len, '0');
+		for (int i = 0; i < len; i++)
+			ret[i] = (char)monoChars[i];
+
+		return ret;
+	}
+
+	MonoString* MonoUtil::wstringToMono(const WString& str)
+	{
+		if (sizeof(wchar_t) == 2) // Assuming UTF-16
+			return mono_string_from_utf16((mono_unichar2*)str.c_str());
+		else // Assuming UTF-32
+		{
+			const std::codecvt_mode convMode = (std::codecvt_mode)(std::little_endian);
+			typedef std::codecvt_utf16<UINT32, 1114111, convMode> utf16utf32;
+
+			std::wstring_convert<utf16utf32, UINT32> conversion("?");
+			UINT32* start = (UINT32*)str.data();
+			UINT32* end = (start + (str.size() - 1) / 4);
+
+			mono_unichar2* convertedStr = (mono_unichar2*)conversion.to_bytes(start, end).c_str();
+			return mono_string_from_utf16(convertedStr);
+		}
+	}
+
+	MonoString* MonoUtil::stringToMono(const String& str)
+	{
+		return wstringToMono(toWString(str));
+	}
+
+	void MonoUtil::getClassName(MonoObject* obj, String& ns, String& typeName)
+	{
+		if (obj == nullptr)
+			return;
+
+		::MonoClass* monoClass = mono_object_get_class(obj);
+		getClassName(monoClass, ns, typeName);
+	}
+
+	void MonoUtil::getClassName(::MonoClass* monoClass, String& ns, String& typeName)
+	{
+		::MonoClass* nestingClass = mono_class_get_nesting_type(monoClass);
+
+		if (nestingClass == nullptr)
+		{
+			ns = mono_class_get_namespace(monoClass);
+			typeName = mono_class_get_name(monoClass);
+
+			return;
+		}
+		else
+		{
+			typeName = String("+") + mono_class_get_name(monoClass);
+
+			do
+			{
+				::MonoClass* nextNestingClass = mono_class_get_nesting_type(nestingClass);
+				if (nextNestingClass != nullptr)
+				{
+					typeName = String("+") + mono_class_get_name(nestingClass) + typeName;
+					nestingClass = nextNestingClass;
+				}
+				else
+				{
+					ns = mono_class_get_namespace(nestingClass);
+					typeName = mono_class_get_name(nestingClass) + typeName;
+
+					break;
+				}
+			} while (true);
+		}
+	}
+
+	void MonoUtil::getClassName(MonoReflectionType* monoReflType, String& ns, String& typeName)
+	{
+		MonoType* monoType = mono_reflection_type_get_type(monoReflType);
+		::MonoClass* monoClass = mono_type_get_class(monoType);
+
+		getClassName(monoClass, ns, typeName);
+	}
+
+	::MonoClass* MonoUtil::getClass(MonoObject* object)
+	{
+		return mono_object_get_class(object);
+	}
+
+	::MonoClass* MonoUtil::getClass(MonoReflectionType* type)
+	{
+		MonoType* monoType = mono_reflection_type_get_type(type);
+		return mono_type_get_class(monoType);
+	}
+
+	MonoReflectionType* MonoUtil::getType(MonoObject* object)
+	{
+		::MonoClass* klass = getClass(object);
+		return getType(klass);
+	}
+
+	MonoReflectionType* MonoUtil::getType(::MonoClass* klass)
+	{
+		MonoType* monoType = mono_class_get_type(klass);
+		return mono_type_get_object(MonoManager::instance().getDomain(), monoType);
+	}
+
+	UINT32 MonoUtil::newGCHandle(MonoObject* object)
+	{
+		return mono_gchandle_new(object, false);
+	}
+
+	void MonoUtil::freeGCHandle(UINT32 handle)
+	{
+		mono_gchandle_free(handle);
+	}
+
+	MonoObject* MonoUtil::box(::MonoClass* klass, void* value)
+	{
+		return mono_value_box(MonoManager::instance().getDomain(), klass, value);
+	}
+
+	void* MonoUtil::unbox(MonoObject* object)
+	{
+		return mono_object_unbox(object);
+	}
+
+	bool MonoUtil::isSubClassOf(::MonoClass* subClass, ::MonoClass* parentClass)
+	{
+		return mono_class_is_subclass_of(subClass, parentClass, true) != 0;
+	}
+
+	bool MonoUtil::isValueType(::MonoClass* klass)
+	{
+		return mono_class_is_valuetype(klass) != 0;
+	}
+
+	bool MonoUtil::isEnum(::MonoClass* object)
+	{
+		return mono_class_is_enum(object) != 0;
+	}
+
+	MonoPrimitiveType MonoUtil::getEnumPrimitiveType(::MonoClass* enumClass)
+	{
+		MonoType* monoType = mono_class_get_type(enumClass);
+		MonoType* underlyingType = mono_type_get_underlying_type(monoType);
+
+		return getPrimitiveType(mono_type_get_class(underlyingType));
+	}
+
+	MonoPrimitiveType MonoUtil::getPrimitiveType(::MonoClass* monoClass)
+	{
+		MonoType* monoType = mono_class_get_type(monoClass);
+		int monoPrimitiveType = mono_type_get_type(monoType);
+
+		switch(monoPrimitiveType)
+		{
+		case MONO_TYPE_BOOLEAN:
+			return MonoPrimitiveType::Boolean;
+		case MONO_TYPE_CHAR:
+			return MonoPrimitiveType::Char;
+		case MONO_TYPE_I1:
+			return MonoPrimitiveType::I8;
+		case MONO_TYPE_U1:
+			return MonoPrimitiveType::U8;
+		case MONO_TYPE_I2:
+			return MonoPrimitiveType::I16;
+		case MONO_TYPE_U2:
+			return MonoPrimitiveType::U16;
+		case MONO_TYPE_I4:
+			return MonoPrimitiveType::I32;
+		case MONO_TYPE_U4:
+			return MonoPrimitiveType::U32;
+		case MONO_TYPE_I8:
+			return MonoPrimitiveType::I32;
+		case MONO_TYPE_U8:
+			return MonoPrimitiveType::U32;
+		case MONO_TYPE_R4:
+			return MonoPrimitiveType::R32;
+		case MONO_TYPE_R8:
+			return MonoPrimitiveType::R64;
+		case MONO_TYPE_STRING:
+			return MonoPrimitiveType::String;
+		case MONO_TYPE_CLASS:
+			return MonoPrimitiveType::Class;
+		case MONO_TYPE_VALUETYPE:
+			return MonoPrimitiveType::ValueType;
+		case MONO_TYPE_ARRAY:
+		case MONO_TYPE_SZARRAY:
+			return MonoPrimitiveType::Array;
+		case MONO_TYPE_GENERICINST:
+			return MonoPrimitiveType::Generic;
+		default:
+			break;
+		}
+
+		return MonoPrimitiveType::Unknown;
+	}
+
+	::MonoClass* MonoUtil::bindGenericParameters(::MonoClass* klass, ::MonoClass** params, UINT32 numParams)
+	{
+		MonoType** types = (MonoType**)bs_alloc(sizeof(MonoType*) * numParams);
+		for (UINT32 i = 0; i < numParams; i++)
+			types[i] = mono_class_get_type(params[i]);
+
+		return mono_class_bind_generic_parameters(klass, numParams, types, false);
+	}
+
+	::MonoClass* MonoUtil::getUINT16Class()
+	{
+		return mono_get_uint16_class();
+	}
+
+	::MonoClass* MonoUtil::getINT16Class()
+	{
+		return mono_get_int16_class();
+	}
+
+	::MonoClass* MonoUtil::getUINT32Class()
+	{
+		return mono_get_uint32_class();
+	}
+
+	::MonoClass* MonoUtil::getINT32Class()
+	{
+		return mono_get_int32_class();
+	}
+
+	::MonoClass* MonoUtil::getUINT64Class()
+	{
+		return mono_get_uint64_class();
+	}
+
+	::MonoClass* MonoUtil::getINT64Class()
+	{
+		return mono_get_int64_class();
+	}
+
+	::MonoClass* MonoUtil::getStringClass()
+	{
+		return mono_get_string_class();
+	}
+
+	::MonoClass* MonoUtil::getFloatClass()
+	{
+		return mono_get_single_class();
+	}
+
+	::MonoClass* MonoUtil::getDoubleClass()
+	{
+		return mono_get_double_class();
+	}
+
+	::MonoClass* MonoUtil::getBoolClass()
+	{
+		return mono_get_boolean_class();
+	}
+
+	::MonoClass* MonoUtil::getByteClass()
+	{
+		return mono_get_byte_class();
+	}
+
+	::MonoClass* MonoUtil::getSByteClass()
+	{
+		return mono_get_sbyte_class();
+	}
+
+	::MonoClass* MonoUtil::getCharClass()
+	{
+		return mono_get_char_class();
+	}
+
+	void MonoUtil::throwIfException(MonoException* exception)
+	{
+		throwIfException(reinterpret_cast<MonoObject*>(exception));
+	}
+
+	void MonoUtil::throwIfException(MonoObject* exception)
+	{
+		if (exception != nullptr)
+		{
+			::MonoClass* exceptionClass = mono_object_get_class(exception);
+			::MonoProperty* exceptionMsgProp = mono_class_get_property_from_name(exceptionClass, "Message");
+			::MonoMethod* exceptionMsgGetter = mono_property_get_get_method(exceptionMsgProp);
+			MonoString* exceptionMsg = (MonoString*)mono_runtime_invoke(exceptionMsgGetter, exception, nullptr, nullptr);
+
+			::MonoProperty* exceptionStackProp = mono_class_get_property_from_name(exceptionClass, "StackTrace");
+			::MonoMethod* exceptionStackGetter = mono_property_get_get_method(exceptionStackProp);
+			MonoString* exceptionStackTrace = (MonoString*)mono_runtime_invoke(exceptionStackGetter, exception, nullptr, nullptr);
+
+			// Note: If you modify this format make sure to also modify Debug.ParseExceptionMessage in managed code.
+			String msg = "Managed exception: " + toString(monoToWString(exceptionMsg)) + "\n" + toString(monoToWString(exceptionStackTrace));
+
+			LOGERR(msg);
+		}
+	}
+}

Source/MBansheeEditor/Window/MenuItems.cs

@@ -12,7 +12,7 @@ namespace BansheeEditor
     /// <summary>
     /// Contains various menu item callbacks for the main editor menu bar.
     /// </summary>
-    static private class MenuItems
+    static class MenuItems
     {
         /// <summary>
         /// Adds a camera component to the currently selected scene object.

Source/MBansheeEngine/Physics/CharacterController.cs

@@ -338,7 +338,7 @@ namespace BansheeEngine
         /// Holds all data the character controller component needs to persist through serialization.
         /// </summary>
         [SerializeObject]
-        private class SerializableData
+        internal class SerializableData
         {
             public float contactOffset = 0.1f;
             public float stepOffset = 0.5f;

Source/RenderBeast/Include/BsRenderTexturePool.h

@@ -80,6 +80,8 @@ namespace BansheeEngine
 	struct POOLED_RENDER_TEXTURE_DESC
 	{
 	public:
+		POOLED_RENDER_TEXTURE_DESC() {}
+
 		/**
 		 * Creates a descriptor for a two dimensional render texture.
 		 *
@@ -120,8 +122,6 @@ namespace BansheeEngine
 			INT32 usage = TU_STATIC);
 
 	private:
-		POOLED_RENDER_TEXTURE_DESC() {}
-
 		friend class RenderTexturePool;
 
 		UINT32 width;

Source/SBansheeEditor/Include/BsScriptHandleManager.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEditorPrerequisites.h"
 #include "BsHandleManager.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEditor/Source/BsScriptBrowseDialog.cpp

@@ -25,18 +25,15 @@ namespace BansheeEngine
 		Vector<Path> paths;
 		if (Platform::openBrowseDialog(type, defaultFolderNative, filterListNative, paths))
 		{
-			MonoArray* pathArray = mono_array_new(MonoManager::instance().getDomain(),
-				mono_get_string_class(), (UINT32)paths.size());
+			ScriptArray pathArray(MonoUtil::getStringClass(), (UINT32)paths.size());
 
 			for (UINT32 i = 0; i < (UINT32)paths.size(); i++)
 			{
 				MonoString* monoString = MonoUtil::wstringToMono(paths[i].toWString());
-
-				void* elemAddr = mono_array_addr_with_size(pathArray, sizeof(MonoString*), i);
-				memcpy(elemAddr, &monoString, sizeof(MonoString*));
+				pathArray.set(i, monoString);
 			}
 
-			*outPaths = pathArray;
+			*outPaths = pathArray.getInternal();
 			return true;
 		}
 		else

Source/SBansheeEditor/Source/BsScriptDragDropManager.cpp

@@ -156,8 +156,7 @@ namespace BansheeEngine
 
 	MonoObject* ScriptResourceDragDropData::create(const Vector<Path>& paths)
 	{
-		MonoArray* rawArray = mono_array_new(MonoManager::instance().getDomain(), mono_get_string_class(), (UINT32)paths.size());
-		ScriptArray arrStrings(rawArray);
+		ScriptArray arrStrings(MonoUtil::getStringClass(), (UINT32)paths.size());
 
 		UINT32 idx = 0;
 		for (auto& path : paths)
@@ -190,10 +189,7 @@ namespace BansheeEngine
 
 	MonoArray* ScriptResourceDragDropData::internal_GetPaths(ScriptResourceDragDropData* instance)
 	{
-		MonoArray* rawArray = mono_array_new(MonoManager::instance().getDomain(),
-			mono_get_string_class(), (UINT32)instance->mPaths.size());
-
-		ScriptArray arrStrings(rawArray);
+		ScriptArray arrStrings(MonoUtil::getStringClass(), (UINT32)instance->mPaths.size());
 
 		UINT32 idx = 0;
 		for (auto& path : instance->mPaths)

Source/SBansheeEditor/Source/BsScriptDropDownWindow.cpp

@@ -126,13 +126,13 @@ namespace BansheeEngine
 		, mUpdateThunk(nullptr), mIsInitialized(false), mManagedInstance(managedInstance), mGCHandle(0)
 		, mScriptParent(nullptr), mContentsPanel(nullptr)
 	{
-		mGCHandle = mono_gchandle_new(mManagedInstance, false);
+		mGCHandle = MonoUtil::newGCHandle(mManagedInstance);
 
 		MonoObject* guiPanel = ScriptGUIPanel::createFromExisting(mContents);
 		mContentsPanel = ScriptGUILayout::toNative(guiPanel);
 		ScriptDropDownWindow::guiPanelField->setValue(mManagedInstance, guiPanel);
 
-		::MonoClass* rawMonoClass = mono_object_get_class(mManagedInstance);
+		::MonoClass* rawMonoClass = MonoUtil::getClass(mManagedInstance);
 		MonoClass* monoClass = MonoManager::instance().findClass(rawMonoClass);
 
 		mNamespace = monoClass->getNamespace();
@@ -149,7 +149,7 @@ namespace BansheeEngine
 		triggerOnDestroy();
 		mScriptParent->notifyWindowClosed();
 
-		mono_gchandle_free(mGCHandle);
+		MonoUtil::freeGCHandle(mGCHandle);
 		mGCHandle = 0;
 	}
 

Source/SBansheeEditor/Source/BsScriptEditorUtility.cpp

@@ -39,10 +39,11 @@ namespace BansheeEngine
 	{
 		Vector<HSceneObject> sceneObjects;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(objects);
+		ScriptArray scriptArray(objects);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
 		{
-			MonoObject* curObject = mono_array_get(objects, MonoObject*, i);
+			MonoObject* curObject = scriptArray.get<MonoObject*>(i);
 
 			ScriptSceneObject* scriptSO = ScriptSceneObject::toNative(curObject);
 

Source/SBansheeEditor/Source/BsScriptEditorWindow.cpp

@@ -121,7 +121,7 @@ namespace BansheeEngine
 		{
 			EditorWindowHandle handle = iterFind->second;
 
-			mono_gchandle_free(handle.gcHandle);
+			MonoUtil::freeGCHandle(handle.gcHandle);
 			iterFind->second.gcHandle = 0;
 		}
 
@@ -141,7 +141,7 @@ namespace BansheeEngine
 		{
 			auto iterFind = OpenScriptEditorWindows.find(mName);
 			if (iterFind != OpenScriptEditorWindows.end())
-				iterFind->second.gcHandle = mono_gchandle_new(mManagedInstance, false);
+				iterFind->second.gcHandle = MonoUtil::newGCHandle(mManagedInstance);
 		}
 		else
 		{
@@ -346,7 +346,7 @@ namespace BansheeEngine
 
 		ScriptEditorWindow::registerScriptEditorWindow(nativeInstance);
 
-		mono_runtime_object_init(editorWidget->getManagedInstance()); // Construct it
+		MonoClass::construct(editorWidget->getManagedInstance());
 		editorWidget->setScriptOwner(nativeInstance);
 
 		return editorWidget;
@@ -362,7 +362,7 @@ namespace BansheeEngine
 		{
 			EditorWindowHandle newHandle;
 			newHandle.nativeObj = editorWindow;
-			newHandle.gcHandle = mono_gchandle_new(editorWindow->mManagedInstance, false);
+			newHandle.gcHandle = MonoUtil::newGCHandle(editorWindow->mManagedInstance);
 
 			OpenScriptEditorWindows[editorWindow->mName] = newHandle;
 		}
@@ -374,7 +374,7 @@ namespace BansheeEngine
 		if(findIter != OpenScriptEditorWindows.end())
 		{
 			EditorWindowHandle& foundHandle = findIter->second;
-			mono_gchandle_free(foundHandle.gcHandle);
+			MonoUtil::freeGCHandle(foundHandle.gcHandle);
 
 			OpenScriptEditorWindows.erase(findIter);
 		}

Source/SBansheeEditor/Source/BsScriptGUIColorField.cpp

@@ -38,9 +38,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUIEnumField.cpp

@@ -44,9 +44,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUIFloatField.cpp

@@ -42,9 +42,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUIGameObjectField.cpp

@@ -39,14 +39,14 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 
-		MonoType* monoType = mono_reflection_type_get_type(type);
-		::MonoClass* monoClass = mono_type_get_class(monoType);
+		::MonoClass* monoClass = MonoUtil::getClass(type);
 
 		String typeNamespace;
 		String typeName;

Source/SBansheeEditor/Source/BsScriptGUIIntField.cpp

@@ -42,9 +42,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
-		for(UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUIListBoxField.cpp

@@ -44,17 +44,19 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 
-		UINT32 elementsArrayLen = (UINT32)mono_array_length(elements);
+		ScriptArray elementsArray(elements);
+		UINT32 elementsArrayLen = elementsArray.size();
 		Vector<HString> nativeElements;
 		for (UINT32 i = 0; i < elementsArrayLen; i++)
 		{
-			MonoObject* stringManaged = (MonoObject*)mono_array_get(elements, MonoObject*, i);
+			MonoObject* stringManaged = elementsArray.get<MonoObject*>(i);
 
 			if (stringManaged == nullptr)
 				nativeElements.push_back(HString::dummy());
@@ -117,11 +119,12 @@ namespace BansheeEngine
 
 	void ScriptGUIListBoxField::internal_setElements(ScriptGUIListBoxField* nativeInstance, MonoArray* elements)
 	{
-		UINT32 elementsArrayLen = (UINT32)mono_array_length(elements);
+		ScriptArray elementsArray(elements);
+		UINT32 elementsArrayLen = elementsArray.size();
 		Vector<HString> nativeElements;
 		for (UINT32 i = 0; i < elementsArrayLen; i++)
 		{
-			MonoObject* stringManaged = (MonoObject*)mono_array_get(elements, MonoObject*, i);
+			MonoObject* stringManaged = elementsArray.get<MonoObject*>(i);
 
 			if (stringManaged == nullptr)
 				nativeElements.push_back(HString::dummy());

Source/SBansheeEditor/Source/BsScriptGUIResourceField.cpp

@@ -44,14 +44,13 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
-
-		MonoType* monoType = mono_reflection_type_get_type(type);
-		::MonoClass* monoClass = mono_type_get_class(monoType);
+		::MonoClass* monoClass = MonoUtil::getClass(type);
 
 		String typeNamespace;
 		String typeName;

Source/SBansheeEditor/Source/BsScriptGUISceneTreeView.cpp

@@ -74,9 +74,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUISliderField.cpp

@@ -41,9 +41,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUITextField.cpp

@@ -41,9 +41,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUITextureField.cpp

@@ -43,9 +43,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUIToggleField.cpp

@@ -38,9 +38,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUIVector2Field.cpp

@@ -43,9 +43,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUIVector3Field.cpp

@@ -43,9 +43,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptGUIVector4Field.cpp

@@ -42,9 +42,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		String styleName = toString(MonoUtil::monoToWString(style));
 

Source/SBansheeEditor/Source/BsScriptHandleManager.cpp

@@ -44,7 +44,7 @@ namespace BansheeEngine
 			ActiveCustomHandleData& newHandleData = mActiveGlobalHandles.back();
 
 			newHandleData.object = newHandleInstance;
-			newHandleData.gcHandle = mono_gchandle_new(newHandleInstance, false);
+			newHandleData.gcHandle = MonoUtil::newGCHandle(newHandleInstance);
 		}
 
 		mGlobalHandlesToCreate.clear();
@@ -64,7 +64,7 @@ namespace BansheeEngine
 			for (auto& handle : mActiveHandleData.handles)
 			{
 				callDestroy(handle.object);
-				mono_gchandle_free(handle.gcHandle);
+				MonoUtil::freeGCHandle(handle.gcHandle);
 			}
 
 			mActiveHandleData.selectedObject = newSelectedObject;
@@ -96,7 +96,7 @@ namespace BansheeEngine
 					ActiveCustomHandleData& newHandleData = mActiveHandleData.handles.back();
 
 					newHandleData.object = newHandleInstance;
-					newHandleData.gcHandle = mono_gchandle_new(newHandleInstance, false);
+					newHandleData.gcHandle = MonoUtil::newGCHandle(newHandleInstance);
 				}
 			}
 		}
@@ -104,7 +104,7 @@ namespace BansheeEngine
 		if (mDefaultHandleManager == nullptr)
 		{
 			mDefaultHandleManager = mDefaultHandleManagerClass->createInstance(true);
-			mDefaultHandleManagerGCHandle = mono_gchandle_new(mDefaultHandleManager, false);
+			mDefaultHandleManagerGCHandle = MonoUtil::newGCHandle(mDefaultHandleManager);
 		}
 
 		callPreInput(mDefaultHandleManager);
@@ -146,7 +146,7 @@ namespace BansheeEngine
 		for (auto& handle : mActiveGlobalHandles)
 		{
 			callDestroy(handle.object);
-			mono_gchandle_free(handle.gcHandle);
+			MonoUtil::freeGCHandle(handle.gcHandle);
 		}
 
 		mActiveGlobalHandles.clear();
@@ -154,7 +154,7 @@ namespace BansheeEngine
 		for (auto& handle : mActiveHandleData.handles)
 		{
 			callDestroy(handle.object);
-			mono_gchandle_free(handle.gcHandle);
+			MonoUtil::freeGCHandle(handle.gcHandle);
 		}
 
 		mActiveHandleData.selectedObject = HSceneObject();
@@ -163,7 +163,7 @@ namespace BansheeEngine
 		if (mDefaultHandleManager != nullptr)
 		{
 			callDestroy(mDefaultHandleManager);
-			mono_gchandle_free(mDefaultHandleManagerGCHandle);
+			MonoUtil::freeGCHandle(mDefaultHandleManagerGCHandle);
 		}
 
 		mDefaultHandleManager = nullptr;
@@ -243,8 +243,7 @@ namespace BansheeEngine
 		// Handle shown only when specific component type is selected
 		if (attribReflType != nullptr)
 		{
-			MonoType* attribType = mono_reflection_type_get_type(attribReflType);
-			::MonoClass* attribMonoClass = mono_class_from_mono_type(attribType);
+			::MonoClass* attribMonoClass = MonoUtil::getClass(attribReflType);
 
 			MonoClass* attribClass = MonoManager::instance().findClass(attribMonoClass);
 			if (attribClass != nullptr)

Source/SBansheeEditor/Source/BsScriptImportOptions.cpp

@@ -38,16 +38,12 @@ namespace BansheeEngine
 		{
 		case TID_TextureImportOptions:
 			return ScriptTextureImportOptions::create(std::static_pointer_cast<TextureImportOptions>(importOptions));
-			break;
 		case TID_MeshImportOptions:
 			return ScriptMeshImportOptions::create(std::static_pointer_cast<MeshImportOptions>(importOptions));
-			break;
 		case TID_FontImportOptions:
 			return ScriptFontImportOptions::create(std::static_pointer_cast<FontImportOptions>(importOptions));
-			break;
 		case TID_ScriptCodeImportOptions:
 			return ScriptScriptCodeImportOptions::create(std::static_pointer_cast<ScriptCodeImportOptions>(importOptions));
-			break;
 		}
 
 		MonoObject* managedInstance = metaData.scriptClass->createInstance();

Source/SBansheeEditor/Source/BsScriptInspectorUtility.cpp

@@ -82,8 +82,7 @@ namespace BansheeEngine
 				MonoReflectionType* referencedReflType = nullptr;
 				mTypeField->getValue(attrib, &referencedReflType);
 
-				MonoType* referencedType = mono_reflection_type_get_type(referencedReflType);
-				::MonoClass* referencedMonoClass = mono_class_from_mono_type(referencedType);
+				::MonoClass* referencedMonoClass = MonoUtil::getClass(referencedReflType);
 
 				MonoClass* referencedClass = MonoManager::instance().findClass(referencedMonoClass);
 				if (referencedClass == nullptr)
@@ -112,8 +111,7 @@ namespace BansheeEngine
 		if (reflType == nullptr)
 			return nullptr;
 
-		MonoType* type = mono_reflection_type_get_type(reflType);
-		::MonoClass* monoClass = mono_class_from_mono_type(type);
+		::MonoClass* monoClass = MonoUtil::getClass(reflType);
 
 		MonoClass* klass = MonoManager::instance().findClass(monoClass);
 		if (klass == nullptr)
@@ -131,8 +129,7 @@ namespace BansheeEngine
 		if (reflType == nullptr)
 			return nullptr;
 
-		MonoType* type = mono_reflection_type_get_type(reflType);
-		::MonoClass* monoClass = mono_class_from_mono_type(type);
+		::MonoClass* monoClass = MonoUtil::getClass(reflType);
 
 		MonoClass* klass = MonoManager::instance().findClass(monoClass);
 		if (klass == nullptr)
@@ -141,12 +138,7 @@ namespace BansheeEngine
 		// Try to find an inspectable field implementation directly referencing the class
 		auto iterFind = mInspectableFieldTypes.find(klass);
 		if (iterFind != mInspectableFieldTypes.end())
-		{
-			::MonoClass* outMonoClass = iterFind->second->_getInternalClass();
-			MonoType* outMonoType = mono_class_get_type(outMonoClass);
-
-			return mono_type_get_object(MonoManager::instance().getDomain(), outMonoType);
-		}
+			return MonoUtil::getType(iterFind->second->_getInternalClass());
 
 		// Try to find an inspectable field implementation referencing any of the class' attributes
 		Vector<MonoClass*> attribs = klass->getAllAttributes();
@@ -154,12 +146,7 @@ namespace BansheeEngine
 		{
 			auto iterFind = mInspectableFieldTypes.find(attrib);
 			if (iterFind != mInspectableFieldTypes.end())
-			{
-				::MonoClass* outMonoClass = iterFind->second->_getInternalClass();
-				MonoType* outMonoType = mono_class_get_type(outMonoClass);
-
-				return mono_type_get_object(MonoManager::instance().getDomain(), outMonoType);
-			}
+				return MonoUtil::getType(iterFind->second->_getInternalClass());
 		}
 
 		return nullptr;

Source/SBansheeEditor/Source/BsScriptModalWindow.cpp

@@ -130,13 +130,13 @@ namespace BansheeEngine
 		, mUpdateThunk(nullptr), mOnWindowResizedMethod(nullptr), mIsInitialized(false), mManagedInstance(managedInstance)
 		, mGCHandle(0), mScriptParent(nullptr), mContentsPanel(nullptr)
 	{
-		mGCHandle = mono_gchandle_new(mManagedInstance, false);
+		mGCHandle = MonoUtil::newGCHandle(mManagedInstance);
 
 		MonoObject* guiPanel = ScriptGUIPanel::createFromExisting(mContents);
 		mContentsPanel = ScriptGUILayout::toNative(guiPanel);
 		ScriptModalWindow::guiPanelField->setValue(mManagedInstance, guiPanel);
 
-		::MonoClass* rawMonoClass = mono_object_get_class(mManagedInstance);
+		::MonoClass* rawMonoClass = MonoUtil::getClass(mManagedInstance);
 		MonoClass* monoClass = MonoManager::instance().findClass(rawMonoClass);
 
 		mNamespace = monoClass->getNamespace();
@@ -162,7 +162,7 @@ namespace BansheeEngine
 			if (editorWindowClass != nullptr)
 			{
 				mManagedInstance = editorWindowClass->createInstance(false);
-				mGCHandle = mono_gchandle_new(mManagedInstance, false);
+				mGCHandle = MonoUtil::newGCHandle(mManagedInstance);
 
 				MonoObject* guiPanel = ScriptGUIPanel::createFromExisting(mContents);
 				mContentsPanel = ScriptGUILayout::toNative(guiPanel);
@@ -178,7 +178,7 @@ namespace BansheeEngine
 
 	void ManagedModalWindow::releaseManagedInstance()
 	{
-		mono_gchandle_free(mGCHandle);
+		MonoUtil::freeGCHandle(mGCHandle);
 		mGCHandle = 0;
 	}
 

Source/SBansheeEditor/Source/BsScriptSelection.cpp

@@ -46,19 +46,17 @@ namespace BansheeEngine
 		Vector<HSceneObject> sceneObjects = Selection::instance().getSceneObjects();
 
 		::MonoClass* sceneObjectMonoClass = ScriptSceneObject::getMetaData()->scriptClass->_getInternalClass();
-		MonoArray* sceneObjectArray = mono_array_new(MonoManager::instance().getDomain(),
-			sceneObjectMonoClass, (UINT32)sceneObjects.size());
+		ScriptArray sceneObjectArray(sceneObjectMonoClass, (UINT32)sceneObjects.size());
 
 		for (UINT32 i = 0; i < (UINT32)sceneObjects.size(); i++)
 		{
 			ScriptSceneObject* scriptSceneObject = ScriptGameObjectManager::instance().getOrCreateScriptSceneObject(sceneObjects[i]);
 			MonoObject* sceneMonoObject = scriptSceneObject->getManagedInstance();
 
-			void* elemAddr = mono_array_addr_with_size(sceneObjectArray, sizeof(MonoObject*), i);
-			memcpy(elemAddr, &sceneMonoObject, sizeof(MonoObject*));
+			sceneObjectArray.set(i, sceneMonoObject);
 		}
 
-		*selection = sceneObjectArray;
+		*selection = sceneObjectArray.getInternal();
 	}
 
 	void ScriptSelection::internal_SetSceneObjectSelection(MonoArray* selection)
@@ -67,10 +65,12 @@ namespace BansheeEngine
 
 		if (selection != nullptr)
 		{
-			UINT32 arrayLen = (UINT32)mono_array_length(selection);
+			ScriptArray scriptArray(selection);
+
+			UINT32 arrayLen = scriptArray.size();
 			for (UINT32 i = 0; i < arrayLen; i++)
 			{
-				MonoObject* monoSO = mono_array_get(selection, MonoObject*, i);
+				MonoObject* monoSO = scriptArray.get<MonoObject*>(i);
 				ScriptSceneObject* scriptSO = ScriptSceneObject::toNative(monoSO);
 
 				if (scriptSO == nullptr)
@@ -87,29 +87,26 @@ namespace BansheeEngine
 	void ScriptSelection::internal_GetResourceUUIDSelection(MonoArray** selection)
 	{
 		Vector<String> uuids = Selection::instance().getResourceUUIDs();
-
-		MonoArray* uuidArray = mono_array_new(MonoManager::instance().getDomain(),
-			mono_get_string_class(), (UINT32)uuids.size());
+		ScriptArray uuidArray(MonoUtil::getStringClass(), (UINT32)uuids.size());
 
 		for (UINT32 i = 0; i < (UINT32)uuids.size(); i++)
 		{
 			MonoString* monoString = MonoUtil::stringToMono(uuids[i]);
-
-			void* elemAddr = mono_array_addr_with_size(uuidArray, sizeof(MonoString*), i);
-			memcpy(elemAddr, &monoString, sizeof(MonoString*));
+			uuidArray.set(i, monoString);
 		}
 
-		*selection = uuidArray;
+		*selection = uuidArray.getInternal();
 	}
 
 	void ScriptSelection::internal_SetResourceUUIDSelection(MonoArray* selection)
 	{
 		Vector<String> uuids;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(selection);
+		ScriptArray uuidArray(selection);
+		UINT32 arrayLen = uuidArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
 		{
-			MonoString* monoString = mono_array_get(selection, MonoString*, i);
+			MonoString* monoString = uuidArray.get<MonoString*>(i);
 			String uuid = MonoUtil::monoToString(monoString);
 
 			uuids.push_back(uuid);
@@ -121,29 +118,26 @@ namespace BansheeEngine
 	void ScriptSelection::internal_GetResourcePathSelection(MonoArray** selection)
 	{
 		Vector<Path> paths = Selection::instance().getResourcePaths();
-
-		MonoArray* pathArray = mono_array_new(MonoManager::instance().getDomain(),
-			mono_get_string_class(), (UINT32)paths.size());
+		ScriptArray pathArray(MonoUtil::getStringClass(), (UINT32)paths.size());
 
 		for (UINT32 i = 0; i < (UINT32)paths.size(); i++)
 		{
 			MonoString* monoString = MonoUtil::stringToMono(paths[i].toString());
-
-			void* elemAddr = mono_array_addr_with_size(pathArray, sizeof(MonoString*), i);
-			memcpy(elemAddr, &monoString, sizeof(MonoString*));
+			pathArray.set(i, monoString);
 		}
 
-		*selection = pathArray;
+		*selection = pathArray.getInternal();
 	}
 
 	void ScriptSelection::internal_SetResourcePathSelection(MonoArray* selection)
 	{
 		Vector<Path> paths;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(selection);
+		ScriptArray pathArray(selection);
+		UINT32 arrayLen = pathArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
 		{
-			MonoString* monoString = mono_array_get(selection, MonoString*, i);
+			MonoString* monoString = pathArray.get<MonoString*>(i);
 			Path path  = MonoUtil::monoToString(monoString);
 
 			paths.push_back(path);

Source/SBansheeEngine/Include/BsManagedComponent.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsComponent.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsManagedResource.h

@@ -4,8 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsResource.h"
-#include <mono/jit/jit.h>
-#include <mono/metadata/object.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsManagedSerializableArray.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsIReflectable.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsManagedSerializableDictionary.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsIReflectable.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsManagedSerializableField.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsIReflectable.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsManagedSerializableList.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsIReflectable.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsManagedSerializableObject.h

@@ -5,7 +5,6 @@
 #include "BsScriptEnginePrerequisites.h"
 #include "BsIReflectable.h"
 #include "BsManagedSerializableField.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsManagedSerializableObjectInfo.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsIReflectable.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsScriptAssemblyManager.h

@@ -5,7 +5,6 @@
 #include "BsScriptEnginePrerequisites.h"
 #include "BsManagedSerializableObjectInfo.h"
 #include "BsModule.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsScriptGameObjectManager.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsModule.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsScriptObject.h

@@ -8,7 +8,6 @@
 #include "BsMonoManager.h"
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Include/BsScriptResource.h

@@ -4,6 +4,7 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsScriptObject.h"
+#include "BsMonoUtil.h"
 
 namespace BansheeEngine
 {
@@ -71,7 +72,7 @@ namespace BansheeEngine
 		TScriptResource(MonoObject* instance, const ResourceHandle<ResType>& resource)
 			:ScriptObject<ScriptClass, ScriptResourceBase>(instance), mResource(resource)
 		{
-			mManagedHandle = mono_gchandle_new(instance, false);
+			mManagedHandle = MonoUtil::newGCHandle(instance);
 
 			BS_DEBUG_ONLY(mHandleValid = true);
 		}
@@ -85,7 +86,7 @@ namespace BansheeEngine
 		virtual void endRefresh(const ScriptObjectBackup& backupData) override
 		{
 			BS_ASSERT(!mHandleValid);
-			mManagedHandle = mono_gchandle_new(this->mManagedInstance, false);
+			mManagedHandle = MonoUtil::newGCHandle(this->mManagedInstance);
 
 			ScriptObject<ScriptClass, ScriptResourceBase>::endRefresh(backupData);
 		}
@@ -95,14 +96,14 @@ namespace BansheeEngine
 		 */
 		void notifyResourceDestroyed() override
 		{
-			mono_gchandle_free(mManagedHandle);
+			MonoUtil::freeGCHandle(mManagedHandle);
 			BS_DEBUG_ONLY(mHandleValid = false);
 		}
 
 		/**	Called when the managed instance gets finalized by the CLR. */
 		void _onManagedInstanceDeleted() override
 		{
-			mono_gchandle_free(mManagedHandle);
+			MonoUtil::freeGCHandle(mManagedHandle);
 			BS_DEBUG_ONLY(mHandleValid = false);
 
 			this->destroy();

Source/SBansheeEngine/Include/BsScriptResourceManager.h

@@ -4,7 +4,6 @@
 
 #include "BsScriptEnginePrerequisites.h"
 #include "BsModule.h"
-#include <mono/jit/jit.h>
 
 namespace BansheeEngine
 {

Source/SBansheeEngine/Source/BsManagedComponent.cpp

@@ -29,10 +29,7 @@ namespace BansheeEngine
 		, mOnResetThunk(nullptr), mOnDestroyThunk(nullptr), mOnDisabledThunk(nullptr), mOnEnabledThunk(nullptr)
 		, mOnTransformChangedThunk(nullptr), mCalculateBoundsMethod(nullptr)
 	{
-		MonoType* monoType = mono_reflection_type_get_type(mRuntimeType);
-		::MonoClass* monoClass = mono_type_get_class(monoType);
-
-		MonoUtil::getClassName(monoClass, mNamespace, mTypeName);
+		MonoUtil::getClassName(mRuntimeType, mNamespace, mTypeName);
 		setName(mTypeName);
 	}
 
@@ -84,7 +81,7 @@ namespace BansheeEngine
 			if (mManagedInstance != nullptr)
 			{
 				mManagedInstance = nullptr;
-				mono_gchandle_free(mManagedHandle);
+				MonoUtil::freeGCHandle(mManagedHandle);
 				mManagedHandle = 0;
 			}
 
@@ -139,11 +136,10 @@ namespace BansheeEngine
 		MonoClass* managedClass = nullptr;
 		if (mManagedInstance != nullptr)
 		{
-			mManagedHandle = mono_gchandle_new(mManagedInstance, false);
+			mManagedHandle = MonoUtil::newGCHandle(mManagedInstance);
 
-			::MonoClass* monoClass = mono_object_get_class(object);
-			MonoType* monoType = mono_class_get_type(monoClass);
-			mRuntimeType = mono_type_get_object(MonoManager::instance().getDomain(), monoType);
+			::MonoClass* monoClass = MonoUtil::getClass(object);
+			mRuntimeType = MonoUtil::getType(monoClass);
 
 			managedClass = MonoManager::instance().findClass(monoClass);
 		}
@@ -262,7 +258,7 @@ namespace BansheeEngine
 			MonoObject* areBoundsValidObj = mCalculateBoundsMethod->invokeVirtual(mManagedInstance, params);
 
 			bool areBoundsValid;
-			areBoundsValid = *(bool*)mono_object_unbox(areBoundsValidObj);
+			areBoundsValid = *(bool*)MonoUtil::unbox(areBoundsValidObj);
 
 			bounds = Bounds(box, sphere);
 			return areBoundsValid;
@@ -391,7 +387,7 @@ namespace BansheeEngine
 		}
 
 		mManagedInstance = nullptr;
-		mono_gchandle_free(mManagedHandle);
+		MonoUtil::freeGCHandle(mManagedHandle);
 	}
 
 	void ManagedComponent::onEnabled()

Source/SBansheeEngine/Source/BsManagedResource.cpp

@@ -60,7 +60,7 @@ namespace BansheeEngine
 			if (mManagedInstance != nullptr)
 			{
 				mManagedInstance = nullptr;
-				mono_gchandle_free(mManagedHandle);
+				MonoUtil::freeGCHandle(mManagedHandle);
 				mManagedHandle = 0;
 			}
 		}
@@ -74,7 +74,7 @@ namespace BansheeEngine
 
 		if (mManagedInstance != nullptr)
 		{
-			mManagedHandle = mono_gchandle_new(mManagedInstance, false);
+			mManagedHandle = MonoUtil::newGCHandle(mManagedInstance);
 
 			if (data.data != nullptr)
 			{
@@ -119,7 +119,7 @@ namespace BansheeEngine
 	void ManagedResource::setHandle(MonoObject* object, const HManagedResource& myHandle)
 	{
 		mManagedInstance = object;
-		mManagedHandle = mono_gchandle_new(mManagedInstance, false);
+		mManagedHandle = MonoUtil::newGCHandle(mManagedInstance);
 		mMyHandle = myHandle.getWeak();
 
 		ScriptManagedResource* scriptInstance;
@@ -134,7 +134,7 @@ namespace BansheeEngine
 		if (mManagedInstance != nullptr)
 		{
 			mManagedInstance = nullptr;
-			mono_gchandle_free(mManagedHandle);
+			MonoUtil::freeGCHandle(mManagedHandle);
 		}
 
 		ManagedResourceManager::instance().unregisterManagedResource(mMyHandle);

Source/SBansheeEngine/Source/BsManagedSerializableArray.cpp

@@ -7,6 +7,7 @@
 #include "BsManagedSerializableField.h"
 #include "BsMonoClass.h"
 #include "BsMonoMethod.h"
+#include "BsMonoArray.h"
 
 namespace BansheeEngine
 {
@@ -21,8 +22,8 @@ namespace BansheeEngine
 		, mElemSize(0)
 		
 	{
-		::MonoClass* monoClass = mono_object_get_class(mManagedInstance);
-		mElemSize = mono_array_element_size(monoClass);
+		ScriptArray scriptArray((MonoArray*)mManagedInstance);
+		mElemSize = scriptArray.elementSize();
 
 		initMonoObjects();
 
@@ -60,17 +61,12 @@ namespace BansheeEngine
 		MonoClass* arrayClass = ScriptAssemblyManager::instance().getSystemArrayClass();
 
 		MonoMethod* createInstance = arrayClass->getMethodExact("CreateInstance", "Type,int[]");
-		MonoArray* lengthArray = mono_array_new(MonoManager::instance().getDomain(), mono_get_int32_class(), (UINT32)sizes.size());
 
+		ScriptArray lengthArray(MonoUtil::getINT32Class(), (UINT32)sizes.size());
 		for (UINT32 i = 0; i < (UINT32)sizes.size(); i++)
-		{
-			void* elemAddr = mono_array_addr_with_size(lengthArray, sizeof(int), i);
-			memcpy(elemAddr, &sizes[i], sizeof(int));
-		}
-
-		void* params[2] = {
-			mono_type_get_object(MonoManager::instance().getDomain(), mono_class_get_type(typeInfo->mElementType->getMonoClass())), lengthArray };
+			lengthArray.set(i, sizes[i]);
 
+		void* params[2] = { MonoUtil::getType(typeInfo->mElementType->getMonoClass()), lengthArray.getInternal() };
 		return createInstance->invoke(nullptr, params);
 	}
 
@@ -78,7 +74,7 @@ namespace BansheeEngine
 	{
 		if (mManagedInstance != nullptr)
 		{
-			if (mono_class_is_valuetype(mElementMonoClass))
+			if (MonoUtil::isValueType(mElementMonoClass))
 				setValueInternal(arrayIdx, val->getValue(mArrayTypeInfo->mElementType));
 			else
 			{
@@ -97,18 +93,19 @@ namespace BansheeEngine
 		if (mManagedInstance != nullptr)
 		{
 			MonoArray* array = (MonoArray*)mManagedInstance;
+			ScriptArray scriptArray(array);
 
-			UINT32 numElems = (UINT32)mono_array_length(array);
+			UINT32 numElems = scriptArray.size();
 			assert(arrayIdx < numElems);
 
-			void* arrayValue = mono_array_addr_with_size(array, mElemSize, arrayIdx);
+			void* arrayValue = scriptArray.getRawPtr(mElemSize, arrayIdx);
 
-			if (mono_class_is_valuetype(mElementMonoClass))
+			if (MonoUtil::isValueType(mElementMonoClass))
 			{
 				MonoObject* boxedObj = nullptr;
 
 				if (arrayValue != nullptr)
-					boxedObj = mono_value_box(MonoManager::instance().getDomain(), mElementMonoClass, arrayValue);
+					boxedObj = MonoUtil::box(mElementMonoClass, arrayValue);
 
 				return ManagedSerializableFieldData::create(mArrayTypeInfo->mElementType, boxedObj);
 			}
@@ -151,8 +148,8 @@ namespace BansheeEngine
 			return;
 		}
 
-		::MonoClass* monoClass = mono_object_get_class(mManagedInstance);
-		mElemSize = mono_array_element_size(monoClass);
+		ScriptArray scriptArray((MonoArray*)mManagedInstance);
+		mElemSize = scriptArray.elementSize();
 
 		initMonoObjects();
 
@@ -174,10 +171,11 @@ namespace BansheeEngine
 	{
 		MonoArray* array = (MonoArray*)mManagedInstance;
 
-		UINT32 numElems = (UINT32)mono_array_length(array);
+		ScriptArray scriptArray(array);
+		UINT32 numElems = (UINT32)scriptArray.size();
 		assert(arrayIdx < numElems);
 	
-		void* elemAddr = mono_array_addr_with_size(array, mElemSize, arrayIdx);
+		void* elemAddr = scriptArray.getRawPtr(mElemSize, arrayIdx);
 		memcpy(elemAddr, val, mElemSize);
 	}
 
@@ -255,7 +253,7 @@ namespace BansheeEngine
 		void* params[1] = { &dimension };
 		MonoObject* returnObj = getLength->invoke(mManagedInstance, params);
 
-		return *(UINT32*)mono_object_unbox(returnObj);
+		return *(UINT32*)MonoUtil::unbox(returnObj);
 	}
 
 	UINT32 ManagedSerializableArray::getTotalLength() const

Source/SBansheeEngine/Source/BsManagedSerializableDictionary.cpp

@@ -76,10 +76,10 @@ namespace BansheeEngine
 		if (mInstance != nullptr)
 		{
 			MonoObject* returnVal = mParent->mEnumMoveNext->invoke(mInstance, nullptr);
-			bool isValid = *(bool*)mono_object_unbox(returnVal);
+			bool isValid = *(bool*)MonoUtil::unbox(returnVal);
 
 			if (isValid)
-				mCurrent = (MonoObject*)mono_object_unbox(mParent->mEnumCurrentProp->get(mInstance));
+				mCurrent = (MonoObject*)MonoUtil::unbox(mParent->mEnumCurrentProp->get(mInstance));
 			else
 				mCurrent = nullptr;
 
@@ -110,7 +110,7 @@ namespace BansheeEngine
 		, mContainsKeyMethod(nullptr), mGetEnumerator(nullptr), mEnumMoveNext(nullptr), mEnumCurrentProp(nullptr)
 		, mKeyProp(nullptr), mValueProp(nullptr), mDictionaryTypeInfo(typeInfo)
 	{
-		MonoClass* dictClass = MonoManager::instance().findClass(mono_object_get_class(managedInstance));
+		MonoClass* dictClass = MonoManager::instance().findClass(MonoUtil::getClass(managedInstance));
 		if (dictClass == nullptr)
 			return;
 
@@ -162,7 +162,7 @@ namespace BansheeEngine
 		if (mManagedInstance == nullptr)
 			return;
 
-		MonoClass* dictionaryClass = MonoManager::instance().findClass(mono_object_get_class(mManagedInstance));
+		MonoClass* dictionaryClass = MonoManager::instance().findClass(MonoUtil::getClass(mManagedInstance));
 		if (dictionaryClass == nullptr)
 			return;
 
@@ -235,10 +235,10 @@ namespace BansheeEngine
 
 			MonoObject* boxedValue = value;
 			::MonoClass* valueTypeClass = mDictionaryTypeInfo->mValueType->getMonoClass();
-			if (mono_class_is_valuetype(valueTypeClass))
+			if (MonoUtil::isValueType(valueTypeClass))
 			{
 				if (value != nullptr)
-					boxedValue = mono_value_box(MonoManager::instance().getDomain(), valueTypeClass, &value);
+					boxedValue = MonoUtil::box(valueTypeClass, &value);
 			}
 
 			return ManagedSerializableFieldData::create(mDictionaryTypeInfo->mValueType, boxedValue);
@@ -290,7 +290,7 @@ namespace BansheeEngine
 			params[0] = key->getValue(mDictionaryTypeInfo->mKeyType);
 
 			MonoObject* returnVal = mContainsKeyMethod->invoke(mManagedInstance, params);
-			return *(bool*)mono_object_unbox(returnVal);
+			return *(bool*)MonoUtil::unbox(returnVal);
 		}
 		else
 			return mCachedEntries.find(key) != mCachedEntries.end();
@@ -298,7 +298,7 @@ namespace BansheeEngine
 
 	ManagedSerializableDictionary::Enumerator ManagedSerializableDictionary::getEnumerator() const
 	{
-		return Enumerator((MonoObject*)mono_object_unbox(mGetEnumerator->invoke(mManagedInstance, nullptr)), this);
+		return Enumerator((MonoObject*)MonoUtil::unbox(mGetEnumerator->invoke(mManagedInstance, nullptr)), this);
 	}
 
 	void ManagedSerializableDictionary::initMonoObjects(MonoClass* dictionaryClass)

Source/SBansheeEngine/Source/BsManagedSerializableField.cpp

@@ -203,7 +203,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataBool>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -211,7 +211,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataChar>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -219,7 +219,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataI8>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -227,7 +227,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataU8>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -235,7 +235,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataI16>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -243,7 +243,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataU16>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -251,7 +251,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataI32>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -259,7 +259,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataU32>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -267,7 +267,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataI64>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -275,7 +275,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataU64>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -283,7 +283,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataFloat>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -291,7 +291,7 @@ namespace BansheeEngine
 				{
 					auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataDouble>();
 					if(value != nullptr)
-						memcpy(&fieldData->value, mono_object_unbox(value), sizeof(fieldData->value));
+						memcpy(&fieldData->value, MonoUtil::unbox(value), sizeof(fieldData->value));
 
 					return fieldData;
 				}
@@ -633,7 +633,7 @@ namespace BansheeEngine
 					MonoObject* managedInstance = value->getManagedInstance();
 					
 					if(managedInstance != nullptr)
-						return mono_object_unbox(managedInstance); // Structs are passed as raw types because mono expects them as such
+						return MonoUtil::unbox(managedInstance); // Structs are passed as raw types because mono expects them as such
 				}
 				else
 					return value->getManagedInstance();
@@ -700,7 +700,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::Bool)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_boolean_class(), &value);
+				return MonoUtil::box(MonoUtil::getBoolClass(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -713,7 +713,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::Char)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_char_class(), &value);
+				return MonoUtil::box(MonoUtil::getCharClass(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -726,7 +726,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::I8)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_sbyte_class(), &value);
+				return MonoUtil::box(MonoUtil::getSByteClass(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -739,7 +739,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::U8)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_byte_class(), &value);
+				return MonoUtil::box(MonoUtil::getByteClass(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -752,7 +752,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::I16)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_int16_class(), &value);
+				return MonoUtil::box(MonoUtil::getINT16Class(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -765,7 +765,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::U16)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_uint16_class(), &value);
+				return MonoUtil::box(MonoUtil::getUINT16Class(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -778,7 +778,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::I32)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_int32_class(), &value);
+				return MonoUtil::box(MonoUtil::getINT32Class(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -791,7 +791,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::U32)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_uint32_class(), &value);
+				return MonoUtil::box(MonoUtil::getUINT32Class(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -804,7 +804,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::I64)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_int64_class(), &value);
+				return MonoUtil::box(MonoUtil::getINT64Class(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -817,7 +817,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::U64)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_uint64_class(), &value);
+				return MonoUtil::box(MonoUtil::getUINT64Class(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -830,7 +830,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::Float)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_single_class(), &value);
+				return MonoUtil::box(MonoUtil::getFloatClass(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");
@@ -843,7 +843,7 @@ namespace BansheeEngine
 		{
 			auto primitiveTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoPrimitive>(typeInfo);
 			if (primitiveTypeInfo->mType == ScriptPrimitiveType::Double)
-				return mono_value_box(MonoManager::instance().getDomain(), mono_get_double_class(), &value);
+				return MonoUtil::box(MonoUtil::getDoubleClass(), &value);
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");

Source/SBansheeEngine/Source/BsManagedSerializableList.cpp

@@ -23,7 +23,7 @@ namespace BansheeEngine
 		: mManagedInstance(managedInstance), mAddMethod(nullptr), mAddRangeMethod(nullptr), mClearMethod(nullptr)
 		, mCopyToMethod(nullptr), mItemProp(nullptr), mCountProp(nullptr), mListTypeInfo(typeInfo), mNumElements(0)
 	{
-		MonoClass* listClass = MonoManager::instance().findClass(mono_object_get_class(managedInstance));
+		MonoClass* listClass = MonoManager::instance().findClass(MonoUtil::getClass(managedInstance));
 		if(listClass == nullptr)
 			return;
 
@@ -189,7 +189,7 @@ namespace BansheeEngine
 		if(length == nullptr)
 			return 0;
 
-		return *(UINT32*)mono_object_unbox(length);
+		return *(UINT32*)MonoUtil::unbox(length);
 	}
 
 	void ManagedSerializableList::initMonoObjects(MonoClass* listClass)

Source/SBansheeEngine/Source/BsManagedSerializableObjectInfo.cpp

@@ -133,31 +133,31 @@ namespace BansheeEngine
 		switch(mType)
 		{
 		case ScriptPrimitiveType::Bool:
-			return mono_get_boolean_class();
+			return MonoUtil::getBoolClass();
 		case ScriptPrimitiveType::Char:
-			return mono_get_char_class();
+			return MonoUtil::getCharClass();
 		case ScriptPrimitiveType::I8:
-			return mono_get_sbyte_class();
+			return MonoUtil::getSByteClass();
 		case ScriptPrimitiveType::U8:
-			return mono_get_byte_class();
+			return MonoUtil::getByteClass();
 		case ScriptPrimitiveType::I16:
-			return mono_get_int16_class();
+			return MonoUtil::getINT16Class();
 		case ScriptPrimitiveType::U16:
-			return mono_get_uint16_class();
+			return MonoUtil::getUINT16Class();
 		case ScriptPrimitiveType::I32:
-			return mono_get_int32_class();
+			return MonoUtil::getINT32Class();
 		case ScriptPrimitiveType::U32:
-			return mono_get_uint32_class();
+			return MonoUtil::getUINT32Class();
 		case ScriptPrimitiveType::I64:
-			return mono_get_int64_class();
+			return MonoUtil::getINT64Class();
 		case ScriptPrimitiveType::U64:
-			return mono_get_uint64_class();
+			return MonoUtil::getUINT64Class();
 		case ScriptPrimitiveType::Float:
-			return mono_get_single_class();
+			return MonoUtil::getFloatClass();
 		case ScriptPrimitiveType::Double:
-			return mono_get_double_class();
+			return MonoUtil::getDoubleClass();
 		case ScriptPrimitiveType::String:
-			return mono_get_string_class();
+			return MonoUtil::getStringClass();
 		default:
 			break;
 		}
@@ -335,7 +335,7 @@ namespace BansheeEngine
 		if(elementClass == nullptr)
 			return nullptr;
 
-		return mono_array_class_get(mElementType->getMonoClass(), mRank);
+		return ScriptArray::buildArrayClass(mElementType->getMonoClass(), mRank);
 	}
 
 	RTTITypeBase* ManagedSerializableTypeInfoArray::getRTTIStatic()
@@ -370,9 +370,9 @@ namespace BansheeEngine
 			return nullptr;
 
 		MonoClass* genericListClass = ScriptAssemblyManager::instance().getSystemGenericListClass();
-		MonoType* genParams[1] = { mono_class_get_type(elementClass) };
+		::MonoClass* genParams[1] = { elementClass };
 
-		return mono_class_bind_generic_parameters(genericListClass->_getInternalClass(), 1, genParams, false);
+		return MonoUtil::bindGenericParameters(genericListClass->_getInternalClass(), genParams, 1);
 	}
 
 	RTTITypeBase* ManagedSerializableTypeInfoList::getRTTIStatic()
@@ -408,9 +408,9 @@ namespace BansheeEngine
 			return nullptr;
 
 		MonoClass* genericDictionaryClass = ScriptAssemblyManager::instance().getSystemGenericDictionaryClass();
-		MonoType* genParams[2] = { mono_class_get_type(keyClass), mono_class_get_type(valueClass) };
 
-		return mono_class_bind_generic_parameters(genericDictionaryClass->_getInternalClass(), 2, genParams, false);
+		::MonoClass* params[2] = { keyClass, valueClass };
+		return MonoUtil::bindGenericParameters(genericDictionaryClass->_getInternalClass(), params, 2);
 	}
 
 	RTTITypeBase* ManagedSerializableTypeInfoDictionary::getRTTIStatic()

Source/SBansheeEngine/Source/BsScriptAssemblyManager.cpp

@@ -82,10 +82,9 @@ namespace BansheeEngine
 				typeInfo->mTypeName = curClass->getTypeName();
 				typeInfo->mTypeId = mUniqueTypeId++;
 
-				MonoType* monoType = mono_class_get_type(curClass->_getInternalClass());
-				int monoPrimitiveType = mono_type_get_type(monoType);
+				MonoPrimitiveType monoPrimitiveType = MonoUtil::getPrimitiveType(curClass->_getInternalClass());
 
-				if(monoPrimitiveType == MONO_TYPE_VALUETYPE)
+				if(monoPrimitiveType == MonoPrimitiveType::ValueType)
 					typeInfo->mValueType = true;
 				else
 					typeInfo->mValueType = false;
@@ -175,99 +174,95 @@ namespace BansheeEngine
 		if(!mBaseTypesInitialized)
 			BS_EXCEPT(InvalidStateException, "Calling determineType without previously initializing base types.");
 
-		MonoType* monoType = mono_class_get_type(monoClass->_getInternalClass());
-		int monoPrimitiveType = mono_type_get_type(monoType);
+		MonoPrimitiveType monoPrimitiveType = MonoUtil::getPrimitiveType(monoClass->_getInternalClass());
 		
 		// If enum get the enum base data type
-		bool isEnum = mono_class_is_enum(monoClass->_getInternalClass()) == 1;
+		bool isEnum = MonoUtil::isEnum(monoClass->_getInternalClass());
 		if (isEnum)
-		{
-			MonoType* underlyingType = mono_type_get_underlying_type(monoType);
-			monoPrimitiveType = mono_type_get_type(underlyingType);
-		}
+			monoPrimitiveType = MonoUtil::getEnumPrimitiveType(monoClass->_getInternalClass());
 
 		//  Determine field type
 		switch(monoPrimitiveType)
 		{
-		case MONO_TYPE_BOOLEAN:
+		case MonoPrimitiveType::Boolean:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::Bool;
 				return typeInfo;
 			}
-		case MONO_TYPE_CHAR:
+		case MonoPrimitiveType::Char:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::Char;
 				return typeInfo;
 			}
-		case MONO_TYPE_I1:
+		case MonoPrimitiveType::I8:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::I8;
 				return typeInfo;
 			}
-		case MONO_TYPE_U1:
+		case MonoPrimitiveType::U8:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::U8;
 				return typeInfo;
 			}
-		case MONO_TYPE_I2:
+		case MonoPrimitiveType::I16:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::I16;
 				return typeInfo;
 			}
-		case MONO_TYPE_U2:
+		case MonoPrimitiveType::U16:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::U16;
 				return typeInfo;
 			}
-		case MONO_TYPE_I4:
+		case MonoPrimitiveType::I32:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::I32;
 				return typeInfo;
 			}
-		case MONO_TYPE_U4:
+		case MonoPrimitiveType::U32:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::U32;
 				return typeInfo;
 			}
-		case MONO_TYPE_I8:
+		case MonoPrimitiveType::I64:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::I64;
 				return typeInfo;
 			}
-		case MONO_TYPE_U8:
+		case MonoPrimitiveType::U64:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::U64;
 				return typeInfo;
 			}
-		case MONO_TYPE_STRING:
+		case MonoPrimitiveType::String:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::String;
 				return typeInfo;
 			}
-		case MONO_TYPE_R4:
+		case MonoPrimitiveType::R32:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::Float;
 				return typeInfo;
 			}
-		case MONO_TYPE_R8:
+		case MonoPrimitiveType::R64:
 			{
 				SPtr<ManagedSerializableTypeInfoPrimitive> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoPrimitive>();
 				typeInfo->mType = ScriptPrimitiveType::Double;
 				return typeInfo;
 			}
-		case MONO_TYPE_CLASS:
+		case MonoPrimitiveType::Class:
 			if(monoClass->isSubClassOf(ScriptResource::getMetaData()->scriptClass)) // Resource
 			{
 				SPtr<ManagedSerializableTypeInfoRef> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoRef>();
@@ -340,7 +335,7 @@ namespace BansheeEngine
 			}
 
 			break;
-		case MONO_TYPE_VALUETYPE:
+		case MonoPrimitiveType::ValueType:
 			{
 				SPtr<ManagedSerializableObjectInfo> objInfo;
 				if (getSerializableObjectInfo(monoClass->getNamespace(), monoClass->getTypeName(), objInfo))
@@ -348,7 +343,7 @@ namespace BansheeEngine
 			}
 
 			break;
-		case MONO_TYPE_GENERICINST:
+		case MonoPrimitiveType::Generic:
 			if(monoClass->getFullName() == mSystemGenericListClass->getFullName()) // Full name is part of CIL spec, so it is just fine to compare like this
 			{
 				SPtr<ManagedSerializableTypeInfoList> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoList>();
@@ -391,12 +386,11 @@ namespace BansheeEngine
 				return typeInfo;
 			}
 			break;
-		case MONO_TYPE_SZARRAY:
-		case MONO_TYPE_ARRAY:
+		case MonoPrimitiveType::Array:
 			{
 				SPtr<ManagedSerializableTypeInfoArray> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoArray>();
 
-				::MonoClass* elementClass = mono_class_get_element_class(monoClass->_getInternalClass());
+				::MonoClass* elementClass = ScriptArray::getElementClass(monoClass->_getInternalClass());
 				if(elementClass != nullptr)
 				{
 					MonoClass* monoElementClass = MonoManager::instance().findClass(elementClass);
@@ -407,10 +401,12 @@ namespace BansheeEngine
 				if (typeInfo->mElementType == nullptr)
 					return nullptr;
 
-				typeInfo->mRank = (UINT32)mono_class_get_rank(monoClass->_getInternalClass());
+				typeInfo->mRank = ScriptArray::getRank(monoClass->_getInternalClass());
 
 				return typeInfo;
 			}
+		default:
+			break;
 		}
 
 		return nullptr;

Source/SBansheeEngine/Source/BsScriptBoneWeight.cpp

@@ -17,12 +17,11 @@ namespace BansheeEngine
 	MonoObject* ScriptBoneWeight::box(const BoneWeight& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	BoneWeight ScriptBoneWeight::unbox(MonoObject* obj)
 	{
-		return *(BoneWeight*)mono_object_unbox(obj);
+		return *(BoneWeight*)MonoUtil::unbox(obj);
 	}
 }

Source/SBansheeEngine/Source/BsScriptCollisionData.cpp

@@ -41,13 +41,12 @@ namespace BansheeEngine
 	MonoObject* ScriptCollisionDataHelper::box(const ScriptCollisionData& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	ScriptCollisionData ScriptCollisionDataHelper::unbox(MonoObject* obj)
 	{
-		return *(ScriptCollisionData*)mono_object_unbox(obj);
+		return *(ScriptCollisionData*)MonoUtil::unbox(obj);
 	}
 
 	ScriptContactPointHelper::ScriptContactPointHelper(MonoObject* instance)
@@ -60,12 +59,11 @@ namespace BansheeEngine
 	MonoObject* ScriptContactPointHelper::box(const ContactPoint& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	ContactPoint ScriptContactPointHelper::unbox(MonoObject* obj)
 	{
-		return *(ContactPoint*)mono_object_unbox(obj);
+		return *(ContactPoint*)MonoUtil::unbox(obj);
 	}
 }

Source/SBansheeEngine/Source/BsScriptColor.cpp

@@ -17,12 +17,11 @@ namespace BansheeEngine
 	MonoObject* ScriptColor::box(const Color& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	Color ScriptColor::unbox(MonoObject* obj)
 	{
-		return *(Color*)mono_object_unbox(obj);
+		return *(Color*)MonoUtil::unbox(obj);
 	}
 }

Source/SBansheeEngine/Source/BsScriptComponent.cpp

@@ -58,8 +58,7 @@ namespace BansheeEngine
 		if (checkIfDestroyed(so))
 			return nullptr;
 
-		MonoType* baseType = mono_reflection_type_get_type(type);
-		::MonoClass* baseClass = mono_type_get_class(baseType);
+		::MonoClass* baseClass = MonoUtil::getClass(type);
 
 		const Vector<HComponent>& mComponents = so->getComponents();
 		for(auto& component : mComponents)
@@ -69,10 +68,9 @@ namespace BansheeEngine
 				GameObjectHandle<ManagedComponent> managedComponent = static_object_cast<ManagedComponent>(component);
 
 				MonoReflectionType* componentReflType = managedComponent->getRuntimeType();
-				MonoType* componentType = mono_reflection_type_get_type(componentReflType);
-				::MonoClass* componentClass = mono_type_get_class(componentType);
+				::MonoClass* componentClass = MonoUtil::getClass(componentReflType);
 				
-				if(mono_class_is_subclass_of(componentClass, baseClass, true))
+				if(MonoUtil::isSubClassOf(componentClass, baseClass))
 				{
 					return managedComponent->getManagedInstance();
 				}
@@ -87,9 +85,7 @@ namespace BansheeEngine
 		ScriptSceneObject* scriptSO = ScriptSceneObject::toNative(parentSceneObject);
 		HSceneObject so = static_object_cast<SceneObject>(scriptSO->getNativeHandle());
 
-		MonoType* baseType = mono_reflection_type_get_type(type);
-		::MonoClass* baseClass = mono_type_get_class(baseType);
-
+		::MonoClass* baseClass = MonoUtil::getClass(type);
 		Vector<MonoObject*> managedComponents;
 
 		if (!checkIfDestroyed(so))
@@ -102,25 +98,19 @@ namespace BansheeEngine
 					GameObjectHandle<ManagedComponent> managedComponent = static_object_cast<ManagedComponent>(component);
 
 					MonoReflectionType* componentReflType = managedComponent->getRuntimeType();
-					MonoType* componentType = mono_reflection_type_get_type(componentReflType);
-					::MonoClass* componentClass = mono_type_get_class(componentType);
+					::MonoClass* componentClass = MonoUtil::getClass(componentReflType);
 
-					if (mono_class_is_subclass_of(componentClass, baseClass, true))
+					if (MonoUtil::isSubClassOf(componentClass, baseClass))
 						managedComponents.push_back(managedComponent->getManagedInstance());
 				}
 			}
 		}
 
-		MonoArray* componentArray = mono_array_new(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (UINT32)managedComponents.size());
-
+		ScriptArray scriptArray(metaData.scriptClass->_getInternalClass(), (UINT32)managedComponents.size());
 		for (UINT32 i = 0; i < (UINT32)managedComponents.size(); i++)
-		{
-			void* elemAddr = mono_array_addr_with_size(componentArray, sizeof(MonoObject*), i);
-			memcpy(elemAddr, &managedComponents[i], sizeof(MonoObject*));
-		}
+			scriptArray.set(i, managedComponents[i]);
 
-		return componentArray;
+		return scriptArray.getInternal();
 	}
 
 	MonoArray* ScriptComponent::internal_getComponents(MonoObject* parentSceneObject)
@@ -144,16 +134,11 @@ namespace BansheeEngine
 			}
 		}
 
-		MonoArray* componentArray = mono_array_new(MonoManager::instance().getDomain(), 
-			metaData.scriptClass->_getInternalClass(), (UINT32)managedComponents.size());
-
+		ScriptArray scriptArray(metaData.scriptClass->_getInternalClass(), (UINT32)managedComponents.size());
 		for(UINT32 i = 0; i < (UINT32)managedComponents.size(); i++)
-		{
-			void* elemAddr = mono_array_addr_with_size(componentArray, sizeof(MonoObject*), i);
-			memcpy(elemAddr, &managedComponents[i], sizeof(MonoObject*));
-		}
+			scriptArray.set(i, managedComponents[i]);
 
-		return componentArray;
+		return scriptArray.getInternal();
 	}
 
 	void ScriptComponent::internal_removeComponent(MonoObject* parentSceneObject, MonoReflectionType* type)
@@ -164,8 +149,7 @@ namespace BansheeEngine
 		if (checkIfDestroyed(so))
 			return;
 
-		MonoType* baseType = mono_reflection_type_get_type(type);
-		::MonoClass* baseClass = mono_type_get_class(baseType);
+		::MonoClass* baseClass = MonoUtil::getClass(type);
 
 		const Vector<HComponent>& mComponents = so->getComponents();
 		for(auto& component : mComponents)
@@ -175,10 +159,9 @@ namespace BansheeEngine
 				GameObjectHandle<ManagedComponent> managedComponent = static_object_cast<ManagedComponent>(component);
 
 				MonoReflectionType* componentReflType = managedComponent->getRuntimeType();
-				MonoType* componentType = mono_reflection_type_get_type(componentReflType);
-				::MonoClass* componentClass = mono_type_get_class(componentType);
+				::MonoClass* componentClass = MonoUtil::getClass(componentReflType);
 
-				if (mono_class_is_subclass_of(componentClass, baseClass, true))
+				if (MonoUtil::isSubClassOf(componentClass, baseClass))
 				{
 					managedComponent->destroy();
 					return;

Source/SBansheeEngine/Source/BsScriptControllerCollision.cpp

@@ -4,6 +4,7 @@
 #include "BsMonoManager.h"
 #include "BsMonoClass.h"
 #include "BsCollider.h"
+#include "BsMonoUtil.h"
 
 namespace BansheeEngine
 {
@@ -49,12 +50,11 @@ namespace BansheeEngine
 	MonoObject* ScriptControllerCollisionHelper::box(const ScriptControllerCollision& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	ScriptControllerCollision ScriptControllerCollisionHelper::unbox(MonoObject* obj)
 	{
-		return *(ScriptControllerCollision*)mono_object_unbox(obj);
+		return *(ScriptControllerCollision*)MonoUtil::unbox(obj);
 	}
 }

Source/SBansheeEngine/Source/BsScriptGUIButton.cpp

@@ -45,9 +45,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for(UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUIContent nativeContent(ScriptGUIContent::getText(content), ScriptGUIContent::getImage(content), ScriptGUIContent::getTooltip(content));
 		GUIButton* guiButton = GUIButton::create(nativeContent, options, toString(MonoUtil::monoToWString(style)));

Source/SBansheeEngine/Source/BsScriptGUIInputBox.cpp

@@ -37,9 +37,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for(UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUIInputBox* guiInputBox = GUIInputBox::create(multiline, options, toString(MonoUtil::monoToWString(style)));
 		guiInputBox->onValueChanged.connect(std::bind(&ScriptGUIInputBox::onChanged, instance, _1));

Source/SBansheeEngine/Source/BsScriptGUILabel.cpp

@@ -34,9 +34,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
-		for(UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUIContent nativeContent(ScriptGUIContent::getText(content), ScriptGUIContent::getImage(content), ScriptGUIContent::getTooltip(content));
 		GUILabel* guiLabel = GUILabel::create(nativeContent, options, toString(MonoUtil::monoToWString(style)));

Source/SBansheeEngine/Source/BsScriptGUILayout.cpp

@@ -11,6 +11,7 @@
 #include "BsGUILayoutY.h"
 #include "BsGUIPanel.h"
 #include "BsGUIScrollArea.h"
+#include "BsMonoUtil.h"
 
 namespace BansheeEngine
 {
@@ -57,7 +58,7 @@ namespace BansheeEngine
 		ChildInfo childInfo;
 
 		childInfo.element = element;
-		childInfo.gcHandle = mono_gchandle_new(element->getManagedInstance(), false);
+		childInfo.gcHandle = MonoUtil::newGCHandle(element->getManagedInstance());
 
 		mChildren.push_back(childInfo);
 	}
@@ -67,7 +68,7 @@ namespace BansheeEngine
 		ChildInfo childInfo;
 
 		childInfo.element = element;
-		childInfo.gcHandle = mono_gchandle_new(element->getManagedInstance(), false);
+		childInfo.gcHandle = MonoUtil::newGCHandle(element->getManagedInstance());
 
 		mChildren.insert(mChildren.begin() + idx, childInfo);
 	}
@@ -82,7 +83,7 @@ namespace BansheeEngine
 
 		if (iterFind != mChildren.end())
 		{
-			mono_gchandle_free(iterFind->gcHandle);
+			MonoUtil::freeGCHandle(iterFind->gcHandle);
 			mChildren.erase(iterFind);
 		}
 	}
@@ -91,9 +92,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUILayout* layout = GUILayoutX::create(options);
 
@@ -104,9 +106,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUILayout* layout = GUILayoutY::create(options);
 
@@ -117,9 +120,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUILayout* layout = GUIPanel::create(depth, depthRangeMin, depthRangeMax, options);
 
@@ -191,7 +195,7 @@ namespace BansheeEngine
 
 		for (auto& child : instance->mChildren)
 		{
-			mono_gchandle_free(child.gcHandle);
+			MonoUtil::freeGCHandle(child.gcHandle);
 
 			child.element->setParent(nullptr);
 			child.element->destroy();

Source/SBansheeEngine/Source/BsScriptGUIListBox.cpp

@@ -45,15 +45,17 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 optionsArrayLen = (UINT32)mono_array_length(guiOptions);
-		for(UINT32 i = 0; i < optionsArrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(scriptArray.get<GUIOption>(i));
 
-		UINT32 elementsArrayLen = (UINT32)mono_array_length(elements);
+		ScriptArray elemsArray(elements);
+		UINT32 elementsArrayLen = elemsArray.size();
 		Vector<HString> nativeElements;
 		for(UINT32 i = 0; i < elementsArrayLen; i++)
 		{
-			MonoObject* stringManaged = (MonoObject*)mono_array_get(elements, MonoObject*, i);
+			MonoObject* stringManaged = elemsArray.get<MonoObject*>(i);
 
 			if(stringManaged == nullptr)
 				nativeElements.push_back(HString::dummy());
@@ -72,11 +74,12 @@ namespace BansheeEngine
 
 	void ScriptGUIListBox::internal_setElements(ScriptGUIListBox* nativeInstance, MonoArray* elements)
 	{
-		UINT32 elementsArrayLen = (UINT32)mono_array_length(elements);
+		ScriptArray elemsArray(elements);
+		UINT32 elementsArrayLen = elemsArray.size();
 		Vector<HString> nativeElements;
 		for(UINT32 i = 0; i < elementsArrayLen; i++)
 		{
-			MonoObject* stringManaged = (MonoObject*)mono_array_get(elements, MonoObject*, i);
+			MonoObject* stringManaged = elemsArray.get<MonoObject*>(i);
 
 			if(stringManaged == nullptr)
 				nativeElements.push_back(HString::dummy());

Source/SBansheeEngine/Source/BsScriptGUIProgressBar.cpp

@@ -38,9 +38,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUIProgressBar* progressBar = GUIProgressBar::create(options, toString(MonoUtil::monoToWString(style)));
 		new (bs_alloc<ScriptGUIProgressBar>()) ScriptGUIProgressBar(instance, progressBar);

Source/SBansheeEngine/Source/BsScriptGUIRenderTexture.cpp

@@ -36,9 +36,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		SPtr<RenderTexture> renderTexture;
 		if (texture != nullptr)

Source/SBansheeEngine/Source/BsScriptGUIScrollArea.cpp

@@ -74,9 +74,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
-		for(UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUIScrollArea* guiScrollArea = GUIScrollArea::create(vertBarType, horzBarType, options, 
 			toString(MonoUtil::monoToWString(scrollBarStyle)), toString(MonoUtil::monoToWString(scrollAreaStyle)));

Source/SBansheeEngine/Source/BsScriptGUISlider.cpp

@@ -46,9 +46,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUISliderHorz* guiSlider = GUISliderHorz::create(options, toString(MonoUtil::monoToWString(style)));
 		guiSlider->onChanged.connect(std::bind(&ScriptGUISliderH::onChanged, instance, _1));
@@ -129,9 +130,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		GUISliderVert* guiSlider = GUISliderVert::create(options, toString(MonoUtil::monoToWString(style)));
 		guiSlider->onChanged.connect(std::bind(&ScriptGUISliderV::onChanged, instance, _1));

Source/SBansheeEngine/Source/BsScriptGUITexture.cpp

@@ -36,9 +36,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
-		for(UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		HSpriteTexture nativeTexture;
 		if(texture != nullptr)

Source/SBansheeEngine/Source/BsScriptGUIToggle.cpp

@@ -54,9 +54,10 @@ namespace BansheeEngine
 	{
 		GUIOptions options;
 
-		UINT32 arrayLen = (UINT32)mono_array_length(guiOptions);
-		for(UINT32 i = 0; i < arrayLen; i++)
-			options.addOption(mono_array_get(guiOptions, GUIOption, i));
+		ScriptArray scriptArray(guiOptions);
+		UINT32 arrayLen = scriptArray.size();
+		for (UINT32 i = 0; i < arrayLen; i++)
+			options.addOption(scriptArray.get<GUIOption>(i));
 
 		ScriptGUIToggleGroup* scriptToggleGroup = nullptr;
 		SPtr<GUIToggleGroup> toggleGroup;

Source/SBansheeEngine/Source/BsScriptJointCommon.cpp

@@ -24,7 +24,7 @@ namespace BansheeEngine
 		MonoObject* boxedOutput = getNativeDataThunk(instance, &exception);
 
 		MonoUtil::throwIfException(exception);
-		return *(D6Joint::Drive*)mono_object_unbox(boxedOutput);
+		return *(D6Joint::Drive*)MonoUtil::unbox(boxedOutput);
 	}
 
 	ScriptHingeJointDrive::GetNativeDataThunkDef ScriptHingeJointDrive::getNativeDataThunk = nullptr;
@@ -44,7 +44,7 @@ namespace BansheeEngine
 		MonoObject* boxedOutput = getNativeDataThunk(instance, &exception);
 
 		MonoUtil::throwIfException(exception);
-		return *(HingeJoint::Drive*)mono_object_unbox(boxedOutput);
+		return *(HingeJoint::Drive*)MonoUtil::unbox(boxedOutput);
 	}
 
 	ScriptLimitLinearRange::GetNativeDataThunkDef ScriptLimitLinearRange::getNativeDataThunk = nullptr;
@@ -64,7 +64,7 @@ namespace BansheeEngine
 		MonoObject* boxedOutput = getNativeDataThunk(instance, &exception);
 
 		MonoUtil::throwIfException(exception);
-		return *(LimitLinearRange*)mono_object_unbox(boxedOutput);
+		return *(LimitLinearRange*)MonoUtil::unbox(boxedOutput);
 	}
 
 	ScriptLimitLinear::GetNativeDataThunkDef ScriptLimitLinear::getNativeDataThunk = nullptr;
@@ -84,7 +84,7 @@ namespace BansheeEngine
 		MonoObject* boxedOutput = getNativeDataThunk(instance, &exception);
 
 		MonoUtil::throwIfException(exception);
-		return *(LimitLinear*)mono_object_unbox(boxedOutput);
+		return *(LimitLinear*)MonoUtil::unbox(boxedOutput);
 	}
 
 	ScriptLimitAngularRange::GetNativeDataThunkDef ScriptLimitAngularRange::getNativeDataThunk = nullptr;
@@ -104,7 +104,7 @@ namespace BansheeEngine
 		MonoObject* boxedOutput = getNativeDataThunk(instance, &exception);
 
 		MonoUtil::throwIfException(exception);
-		return *(LimitAngularRange*)mono_object_unbox(boxedOutput);
+		return *(LimitAngularRange*)MonoUtil::unbox(boxedOutput);
 	}
 
 	ScriptLimitConeRange::GetNativeDataThunkDef ScriptLimitConeRange::getNativeDataThunk = nullptr;
@@ -124,6 +124,6 @@ namespace BansheeEngine
 		MonoObject* boxedOutput = getNativeDataThunk(instance, &exception);
 
 		MonoUtil::throwIfException(exception);
-		return *(LimitConeRange*)mono_object_unbox(boxedOutput);
+		return *(LimitConeRange*)MonoUtil::unbox(boxedOutput);
 	}
 }

Source/SBansheeEngine/Source/BsScriptMesh.cpp

@@ -21,13 +21,12 @@ namespace BansheeEngine
 	MonoObject* ScriptSubMesh::box(const SubMeshData& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	SubMeshData ScriptSubMesh::unbox(MonoObject* obj)
 	{
-		return *(SubMeshData*)mono_object_unbox(obj);
+		return *(SubMeshData*)MonoUtil::unbox(obj);
 	}
 
 	ScriptMesh::ScriptMesh(MonoObject* instance, const HMesh& mesh)

Source/SBansheeEngine/Source/BsScriptPhysicsQueryHit.cpp

@@ -36,12 +36,11 @@ namespace BansheeEngine
 	MonoObject* ScriptPhysicsQueryHitHelper::box(const ScriptPhysicsQueryHit& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	ScriptPhysicsQueryHit ScriptPhysicsQueryHitHelper::unbox(MonoObject* obj)
 	{
-		return *(ScriptPhysicsQueryHit*)mono_object_unbox(obj);
+		return *(ScriptPhysicsQueryHit*)MonoUtil::unbox(obj);
 	}
 }

Source/SBansheeEngine/Source/BsScriptPixelData.cpp

@@ -90,8 +90,8 @@ namespace BansheeEngine
 
 		::MonoClass* colorClass = ScriptColor::getMetaData()->scriptClass->_getInternalClass();
 		UINT32 totalNumElements = width * height * depth;
-		MonoArray* colorArray = mono_array_new(MonoManager::instance().getDomain(),
-			colorClass, totalNumElements);
+
+		ScriptArray scriptArray(colorClass, totalNumElements);
 
 		PixelFormat format = pixelData->getFormat();
 		UINT32 pixelSize = PixelUtil::getNumElemBytes(format);
@@ -117,12 +117,12 @@ namespace BansheeEngine
 					UINT32 dataIdx = x * pixelSize + yDataIdx + zDataIdx;
 
 					UINT8* dest = data + dataIdx;
-					mono_array_set(colorArray, Color, arrayIdx, *(Color*)dest);
+					scriptArray.set(arrayIdx, *(Color*)dest);
 				}
 			}
 		}
 
-		*value = colorArray;
+		*value = scriptArray.getInternal();
 
 	}
 
@@ -137,7 +137,9 @@ namespace BansheeEngine
 		UINT32 height = pixelVolume.getHeight();
 		UINT32 width = pixelVolume.getWidth();
 
-		UINT32 arrayLen = (UINT32)mono_array_length(value);
+		ScriptArray scriptArray(value);
+
+		UINT32 arrayLen = scriptArray.size();
 		UINT32 totalNumElements = width * height * depth;
 		if (arrayLen != totalNumElements)
 		{
@@ -169,7 +171,7 @@ namespace BansheeEngine
 
 					UINT8* dest = data + dataIdx;
 
-					Color color = mono_array_get(value, Color, arrayIdx);
+					Color color = scriptArray.get<Color>(arrayIdx);
 					PixelUtil::packColor(color, format, dest);
 				}
 			}
@@ -187,8 +189,7 @@ namespace BansheeEngine
 		UINT32 height = pixelVolume.getHeight();
 		UINT32 width = pixelVolume.getWidth();
 
-		MonoArray* byteArray = mono_array_new(MonoManager::instance().getDomain(),
-			mono_get_byte_class(), pixelData->getSize());
+		ScriptArray scriptArray(MonoUtil::getByteClass(), pixelData->getSize());
 
 		PixelFormat format = pixelData->getFormat();
 		UINT32 pixelSize = PixelUtil::getNumElemBytes(format);
@@ -214,12 +215,12 @@ namespace BansheeEngine
 					UINT32 dataIdx = x * pixelSize + yDataIdx + zDataIdx;
 
 					UINT8* dest = data + dataIdx;
-					mono_array_set(byteArray, char, arrayIdx, *dest);
+					scriptArray.set(arrayIdx, *dest);
 				}
 			}
 		}
 
-		*value = byteArray;
+		*value = scriptArray.getInternal();
 	}
 
 	void ScriptPixelData::internal_setRawPixels(ScriptPixelData* thisPtr, MonoArray* value)
@@ -233,7 +234,8 @@ namespace BansheeEngine
 		UINT32 height = pixelVolume.getHeight();
 		UINT32 width = pixelVolume.getWidth();
 
-		UINT32 arrayLen = (UINT32)mono_array_length(value);
+		ScriptArray scriptArray(value);
+		UINT32 arrayLen = scriptArray.size();
 		if (pixelData->getSize() != arrayLen)
 		{
 			LOGERR("Unable to set colors, invalid array size.")
@@ -264,7 +266,7 @@ namespace BansheeEngine
 					UINT32 dataIdx = x * pixelSize + yDataIdx + zDataIdx;
 
 					UINT8* dest = data + dataIdx;
-					*dest = mono_array_get(value, char, arrayIdx);
+					*dest = scriptArray.get<char>(arrayIdx);
 				}
 			}
 		}

Source/SBansheeEngine/Source/BsScriptPixelUtility.cpp

@@ -100,17 +100,15 @@ namespace BansheeEngine
 		Vector<SPtr<PixelData>> mipmaps = PixelUtil::genMipmaps(*sourcePixelData, *options);
 
 		UINT32 numElements = (UINT32)mipmaps.size();
-		MonoArray* outputArray = mono_array_new(MonoManager::instance().getDomain(),
-			ScriptPixelData::getMetaData()->scriptClass->_getInternalClass(), numElements);
+		ScriptArray scriptArray(ScriptPixelData::getMetaData()->scriptClass->_getInternalClass(), numElements);
 
 		for (UINT32 i = 0; i < numElements; i++)
 		{
 			MonoObject* managedPixelData = ScriptPixelData::create(mipmaps[i]);
-
-			mono_array_set(outputArray, MonoObject*, i, managedPixelData);
+			scriptArray.set(i, managedPixelData);
 		}
 
-		return outputArray;
+		return scriptArray.getInternal();
 	}
 
 	MonoObject* ScriptPixelUtility::internal_scale(MonoObject* source, PixelVolume* newSize, PixelUtil::Filter filter)

Source/SBansheeEngine/Source/BsScriptSceneObject.cpp

@@ -15,7 +15,7 @@ namespace BansheeEngine
 	ScriptSceneObject::ScriptSceneObject(MonoObject* instance, const HSceneObject& sceneObject)
 		:ScriptObject(instance), mSceneObject(sceneObject)
 	{
-		mManagedHandle = mono_gchandle_new(instance, false);
+		mManagedHandle = MonoUtil::newGCHandle(instance);
 	}
 
 	void ScriptSceneObject::initRuntimeData()
@@ -386,7 +386,7 @@ namespace BansheeEngine
 			ScriptGameObjectManager::instance().destroyScriptSceneObject(this);
 		else
 		{
-			mono_gchandle_free(mManagedHandle);
+			MonoUtil::freeGCHandle(mManagedHandle);
 			mManagedHandle = 0;
 		}
 	}
@@ -394,14 +394,14 @@ namespace BansheeEngine
 	MonoObject* ScriptSceneObject::_createManagedInstance(bool construct)
 	{
 		MonoObject* managedInstance = metaData.scriptClass->createInstance(construct);
-		mManagedHandle = mono_gchandle_new(managedInstance, false);
+		mManagedHandle = MonoUtil::newGCHandle(managedInstance);
 
 		return managedInstance;
 	}
 
 	void ScriptSceneObject::_notifyDestroyed()
 	{
-		mono_gchandle_free(mManagedHandle);
+		MonoUtil::freeGCHandle(mManagedHandle);
 		mManagedHandle = 0;
 	}
 

Source/SBansheeEngine/Source/BsScriptScriptCode.cpp

@@ -89,21 +89,17 @@ namespace BansheeEngine
 		{
 			SPtr<ManagedSerializableObjectInfo> objInfo;
 			if (ScriptAssemblyManager::instance().getSerializableObjectInfo(toString(type.first), toString(type.second), objInfo))
-			{
-				MonoType* monoType = mono_class_get_type(objInfo->mTypeInfo->getMonoClass());
-				validTypes.push_back(mono_type_get_object(MonoManager::instance().getDomain(), monoType));
-			}
+				validTypes.push_back(MonoUtil::getType(objInfo->mTypeInfo->getMonoClass()));
 		}
 
 		UINT32 numValidTypes = (UINT32)validTypes.size();
-
 		MonoClass* typeClass = ScriptAssemblyManager::instance().getSystemTypeClass();
-		MonoArray* output = mono_array_new(MonoManager::instance().getDomain(), typeClass->_getInternalClass(), numValidTypes);
 
+		ScriptArray scriptArray(typeClass->_getInternalClass(), numValidTypes);
 		for (UINT32 i = 0; i < numValidTypes; i++)
-			mono_array_set(output, MonoReflectionType*, i, validTypes[i]);
+			scriptArray.set(i, validTypes[i]);
 
-		return output;
+		return scriptArray.getInternal();
 	}
 
 	MonoObject* ScriptScriptCode::createInstance()

Source/SBansheeEngine/Source/BsScriptSerializableArray.cpp

@@ -5,6 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
+#include "BsMonoUtil.h"
 #include "BsScriptAssemblyManager.h"
 #include "BsManagedSerializableObjectInfo.h"
 #include "BsScriptSerializableProperty.h"
@@ -26,8 +27,7 @@ namespace BansheeEngine
 	{
 		SPtr<ManagedSerializableTypeInfoArray> arrayTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoArray>(parentProperty->getTypeInfo());
 
-		MonoType* monoInternalElementType = mono_class_get_type(arrayTypeInfo->mElementType->getMonoClass());
-		MonoReflectionType* internalElementType = mono_type_get_object(MonoManager::instance().getDomain(), monoInternalElementType);
+		MonoReflectionType* internalElementType = MonoUtil::getType(arrayTypeInfo->mElementType->getMonoClass());
 
 		void* params[2] = { internalElementType, parentProperty->getManagedInstance() };
 		MonoObject* managedInstance = metaData.scriptClass->createInstance(params, 2);

Source/SBansheeEngine/Source/BsScriptSerializableDictionary.cpp

@@ -5,6 +5,7 @@
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
 #include "BsMonoManager.h"
+#include "BsMonoUtil.h"
 #include "BsScriptAssemblyManager.h"
 #include "BsManagedSerializableObjectInfo.h"
 #include "BsScriptSerializableProperty.h"
@@ -27,11 +28,8 @@ namespace BansheeEngine
 	{
 		SPtr<ManagedSerializableTypeInfoDictionary> dictTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoDictionary>(parentProperty->getTypeInfo());
 
-		MonoType* monoInternalKeyType = mono_class_get_type(dictTypeInfo->mKeyType->getMonoClass());
-		MonoReflectionType* internalKeyType = mono_type_get_object(MonoManager::instance().getDomain(), monoInternalKeyType);
-
-		MonoType* monoInternalValueType = mono_class_get_type(dictTypeInfo->mValueType->getMonoClass());
-		MonoReflectionType* internalValueType = mono_type_get_object(MonoManager::instance().getDomain(), monoInternalValueType);
+		MonoReflectionType* internalKeyType = MonoUtil::getType(dictTypeInfo->mKeyType->getMonoClass());
+		MonoReflectionType* internalValueType = MonoUtil::getType(dictTypeInfo->mValueType->getMonoClass());
 
 		void* params[3] = { internalKeyType, internalValueType, parentProperty->getManagedInstance() };
 		MonoObject* managedInstance = metaData.scriptClass->createInstance(params, 3);

Source/SBansheeEngine/Source/BsScriptSerializableField.cpp

@@ -27,8 +27,7 @@ namespace BansheeEngine
 	ScriptSerializableField* ScriptSerializableField::create(MonoObject* parentObject, const SPtr<ManagedSerializableFieldInfo>& fieldInfo)
 	{
 		MonoString* monoStrName = MonoUtil::wstringToMono(toWString(fieldInfo->mName));
-		MonoType* monoInternalType = mono_class_get_type(fieldInfo->mTypeInfo->getMonoClass());
-		MonoReflectionType* internalType = mono_type_get_object(MonoManager::instance().getDomain(), monoInternalType);
+		MonoReflectionType* internalType = MonoUtil::getType(fieldInfo->mTypeInfo->getMonoClass());
 		UINT32 fieldFlags = (UINT32)fieldInfo->mFlags;
 
 		void* params[4] = { parentObject, monoStrName, &fieldFlags, internalType };
@@ -53,9 +52,9 @@ namespace BansheeEngine
 
 	void ScriptSerializableField::internal_setValue(ScriptSerializableField* nativeInstance, MonoObject* instance, MonoObject* value)
 	{
-		if (value != nullptr && mono_class_is_valuetype(mono_object_get_class(value)))
+		if (value != nullptr && MonoUtil::isValueType((MonoUtil::getClass(value))))
 		{
-			void* rawValue = mono_object_unbox(value);
+			void* rawValue = MonoUtil::unbox(value);
 			nativeInstance->mFieldInfo->mMonoField->setValue(instance, rawValue);
 		}
 		else

Source/SBansheeEngine/Source/BsScriptSerializableList.cpp

@@ -8,6 +8,7 @@
 #include "BsScriptAssemblyManager.h"
 #include "BsManagedSerializableObjectInfo.h"
 #include "BsScriptSerializableProperty.h"
+#include "BsMonoUtil.h"
 
 namespace BansheeEngine
 {
@@ -25,9 +26,7 @@ namespace BansheeEngine
 	ScriptSerializableList* ScriptSerializableList::create(const ScriptSerializableProperty* parentProperty)
 	{
 		SPtr<ManagedSerializableTypeInfoList> listTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoList>(parentProperty->getTypeInfo());
-
-		MonoType* monoInternalElementType = mono_class_get_type(listTypeInfo->mElementType->getMonoClass());
-		MonoReflectionType* internalElementType = mono_type_get_object(MonoManager::instance().getDomain(), monoInternalElementType);
+		MonoReflectionType* internalElementType = MonoUtil::getType(listTypeInfo->mElementType->getMonoClass());
 
 		void* params[2] = { internalElementType, parentProperty->getManagedInstance() };
 		MonoObject* managedInstance = metaData.scriptClass->createInstance(params, 2);

Source/SBansheeEngine/Source/BsScriptSerializableObject.cpp

@@ -29,8 +29,7 @@ namespace BansheeEngine
 
 	ScriptSerializableObject* ScriptSerializableObject::create(const ScriptSerializableProperty* property)
 	{
-		MonoType* monoInternalElementType = mono_class_get_type(property->getTypeInfo()->getMonoClass());
-		MonoReflectionType* internalElementType = mono_type_get_object(MonoManager::instance().getDomain(), monoInternalElementType);
+		MonoReflectionType* internalElementType = MonoUtil::getType(property->getTypeInfo()->getMonoClass());
 
 		void* params[2] = { internalElementType, property->getManagedInstance() };
 		MonoObject* managedInstance = metaData.scriptClass->createInstance(params, 2);
@@ -42,8 +41,7 @@ namespace BansheeEngine
 
 	void ScriptSerializableObject::internal_createInstance(MonoObject* instance, MonoReflectionType* type)
 	{
-		MonoType* internalType = mono_reflection_type_get_type(type);
-		::MonoClass* monoClass = mono_type_get_class(internalType);
+		::MonoClass* monoClass = MonoUtil::getClass(type);
 
 		String elementNs;
 		String elementTypeName;
@@ -83,8 +81,7 @@ namespace BansheeEngine
 		});
 
 		::MonoClass* serializableFieldClass = ScriptSerializableField::getMetaData()->scriptClass->_getInternalClass();
-		MonoArray* serializableFieldArray = mono_array_new(MonoManager::instance().getDomain(),
-			serializableFieldClass, (UINT32)sortedFields.size());
+		ScriptArray scriptArray(serializableFieldClass, (UINT32)sortedFields.size());
 
 		UINT32 i = 0;
 		for (auto& field : sortedFields)
@@ -92,13 +89,11 @@ namespace BansheeEngine
 			ScriptSerializableField* serializableField = ScriptSerializableField::create(instance, field);
 			MonoObject* fieldManagedInstance = serializableField->getManagedInstance();
 
-			void* elemAddr = mono_array_addr_with_size(serializableFieldArray, sizeof(MonoObject*), i);
-			memcpy(elemAddr, &fieldManagedInstance, sizeof(MonoObject*));
-
+			scriptArray.set(i, fieldManagedInstance);
 			i++;
 		}
 
-		FieldsField->setValue(instance, serializableFieldArray);
+		FieldsField->setValue(instance, scriptArray.getInternal());
 
 		return nativeInstance;
 	}

Source/SBansheeEngine/Source/BsScriptSerializableProperty.cpp

@@ -54,8 +54,7 @@ namespace BansheeEngine
 		if (reflType == nullptr)
 			return;
 
-		MonoType* type = mono_reflection_type_get_type(reflType);
-		::MonoClass* monoClass = mono_type_get_class(type);
+		::MonoClass* monoClass = MonoUtil::getClass(reflType);
 		MonoClass* engineClass = MonoManager::instance().findClass(monoClass);
 
 		SPtr<ManagedSerializableTypeInfo> typeInfo = ScriptAssemblyManager::instance().getTypeInfo(engineClass);
@@ -105,10 +104,12 @@ namespace BansheeEngine
 
 	MonoObject* ScriptSerializableProperty::internal_createManagedArrayInstance(ScriptSerializableProperty* nativeInstance, MonoArray* sizes)
 	{
+		ScriptArray scriptArray(sizes);
+
 		Vector<UINT32> nativeSizes;
-		UINT32 arrayLen = (UINT32)mono_array_length(sizes);
+		UINT32 arrayLen = scriptArray.size();
 		for (UINT32 i = 0; i < arrayLen; i++)
-			nativeSizes.push_back(mono_array_get(sizes, UINT32, i));
+			nativeSizes.push_back(scriptArray.get<UINT32>(i));
 
 		SPtr<ManagedSerializableTypeInfoArray> arrayTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoArray>(nativeInstance->mTypeInfo);
 		return ManagedSerializableArray::createManagedInstance(arrayTypeInfo, nativeSizes);

Source/SBansheeEngine/Source/BsScriptSerializableUtility.cpp

@@ -26,7 +26,7 @@ namespace BansheeEngine
 		if (original == nullptr)
 			return nullptr;
 
-		::MonoClass* monoClass = mono_object_get_class(original);
+		::MonoClass* monoClass = MonoUtil::getClass(original);
 		MonoClass* engineClass = MonoManager::instance().findClass(monoClass);
 
 		SPtr<ManagedSerializableTypeInfo> typeInfo = ScriptAssemblyManager::instance().getTypeInfo(engineClass);
@@ -55,8 +55,7 @@ namespace BansheeEngine
 		if (reflType == nullptr)
 			return nullptr;
 
-		MonoType* type = mono_reflection_type_get_type(reflType);
-		::MonoClass* monoClass = mono_type_get_class(type);
+		::MonoClass* monoClass = MonoUtil::getClass(reflType);
 		MonoClass* engineClass = MonoManager::instance().findClass(monoClass);
 
 		SPtr<ManagedSerializableTypeInfo> typeInfo = ScriptAssemblyManager::instance().getTypeInfo(engineClass);

Source/SBansheeEngine/Source/BsScriptTexture2D.cpp

@@ -90,8 +90,10 @@ namespace BansheeEngine
 
 	void ScriptTexture2D::internal_setPixelsArray(ScriptTexture2D* thisPtr, MonoArray* colors, UINT32 mipLevel)
 	{
-		Color* colorsRaw = (Color*)mono_array_addr_with_size(colors, sizeof(Color), 0);
-		UINT32 numElements = (UINT32)mono_array_length(colors);
+		ScriptArray scriptArray(colors);
+
+		Color* colorsRaw = (Color*)scriptArray.getRawPtr(sizeof(Color), 0);
+		UINT32 numElements = (UINT32)scriptArray.size();
 
 		HTexture texture = thisPtr->getHandle();
 		const TextureProperties& props = texture->getProperties();

Source/SBansheeEngine/Source/BsScriptVector.cpp

@@ -17,13 +17,12 @@ namespace BansheeEngine
 	MonoObject* ScriptVector2::box(const Vector2& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	Vector2 ScriptVector2::unbox(MonoObject* obj)
 	{
-		return *(Vector2*)mono_object_unbox(obj);
+		return *(Vector2*)MonoUtil::unbox(obj);
 	}
 
 	ScriptVector3::ScriptVector3(MonoObject* instance)
@@ -36,13 +35,12 @@ namespace BansheeEngine
 	MonoObject* ScriptVector3::box(const Vector3& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	Vector3 ScriptVector3::unbox(MonoObject* obj)
 	{
-		return *(Vector3*)mono_object_unbox(obj);
+		return *(Vector3*)MonoUtil::unbox(obj);
 	}
 
 	ScriptVector4::ScriptVector4(MonoObject* instance)
@@ -55,12 +53,11 @@ namespace BansheeEngine
 	MonoObject* ScriptVector4::box(const Vector4& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(),
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	Vector4 ScriptVector4::unbox(MonoObject* obj)
 	{
-		return *(Vector4*)mono_object_unbox(obj);
+		return *(Vector4*)MonoUtil::unbox(obj);
 	}
 }

Source/SBansheeEngine/Source/BsScriptVector2I.cpp

@@ -17,12 +17,11 @@ namespace BansheeEngine
 	MonoObject* ScriptVector2I::box(const Vector2I& value)
 	{
 		// We're casting away const but it's fine since structs are passed by value anyway
-		return mono_value_box(MonoManager::instance().getDomain(), 
-			metaData.scriptClass->_getInternalClass(), (void*)&value);
+		return MonoUtil::box(metaData.scriptClass->_getInternalClass(), (void*)&value);
 	}
 
 	Vector2I ScriptVector2I::unbox(MonoObject* obj)
 	{
-		return *(Vector2I*)mono_object_unbox(obj);
+		return *(Vector2I*)MonoUtil::unbox(obj);
 	}
 }