diff --git a/inc/content/manager.hpp b/inc/content/manager.hpp
index 54af74d..13c2f4f 100644
--- a/inc/content/manager.hpp
+++ b/inc/content/manager.hpp
@@ -32,8 +32,10 @@ namespace xna {
 		}
 
 		template <typename T>
-		T Load(String const& assetName) {
-			if (assetName.empty()) return T();			
+		auto Load(String const& assetName) {
+			if (assetName.empty()) {
+				return ReturnDefaultOrNull<T>();
+			}
 
 			auto obj2 = ReadAsset<T>(assetName); 
 
@@ -42,15 +44,16 @@ namespace xna {
 
 	protected:
 		template <typename T>
-		T ReadAsset(String const& assetName) {
+		auto ReadAsset(String const& assetName) {
 			auto input = OpenStream(assetName);
 
 			if (input->IsClosed())
-				return T();
+				return ReturnDefaultOrNull<T>();
 
 			auto contentReader = ContentReader::Create(this, input, assetName);
 
-			return contentReader->ReadAsset<T>();
+			auto asset = contentReader->ReadAsset<T>();
+			return asset;
 		}
 
 		sptr<Stream> OpenStream(String const& assetName) {
diff --git a/inc/content/reader.hpp b/inc/content/reader.hpp
index 241467e..52cf449 100644
--- a/inc/content/reader.hpp
+++ b/inc/content/reader.hpp
@@ -15,19 +15,19 @@ namespace xna {
 		static sptr<ContentReader> Create(ContentManager* contentManager, sptr<Stream>& input, String const& assetName);
 
 		template <typename T>
-		T ReadAsset();
+		auto ReadAsset();
 
 		template <typename T>
-		T ReadObject();
+		auto ReadObject();
 
 		template <typename T>
-		T ReadObject(T existingInstance);
+		auto ReadObject(T existingInstance);
 
 		template <typename T>
-		T ReadObject(ContentTypeReader& typeReader);
+		auto ReadObject(ContentTypeReader& typeReader);
 
 		template <typename T>
-		T ReadObject(ContentTypeReader& typeReader, T existingInstance);
+		auto ReadObject(ContentTypeReader& typeReader, T existingInstance);
 
 		Vector2 ReadVector2();
 		Vector3 ReadVector3();
@@ -49,13 +49,13 @@ namespace xna {
 		Int ReadHeader();
 
 		template <typename T>
-		T ReadObjectInternal(std::any& existingInstance, xna_error_nullarg);
+		auto ReadObjectInternal(std::any& existingInstance, xna_error_nullarg);
 		
 		template <typename T>
-		T ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_nullarg);
+		auto ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_nullarg);
 
 		template <typename T>
-		T InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_nullarg);
+		auto InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_nullarg);
 
 	private:
 		ContentManager* _contentManager = nullptr;
@@ -70,12 +70,12 @@ namespace xna {
 	};
 
 	template<typename T>
-	inline T ContentReader::ReadObjectInternal(std::any& existingInstance, xna_error_ptr_arg)
+	inline auto ContentReader::ReadObjectInternal(std::any& existingInstance, xna_error_ptr_arg)
 	{
 		const auto num = Read7BitEncodedInt();
 
 		if (num == 0) {
-			return T();
+			ReturnDefaultOrNull<T>();
 		}
 
 		const auto index = num - 1;
@@ -83,33 +83,16 @@ namespace xna {
 		if (index >= typeReaders.size()) {
 			xna_error_apply(err, XnaErrorCode::ARGUMENT_OUT_OF_RANGE);
 			
-			return T();
+			ReturnDefaultOrNull<T>();
 		}		
 		
 		auto reader = typeReaders[index];		
-
-		//Verificação necessária pois a depender da situação é encontrado um reader errado
-		/*auto typeT = typeof<T>();
-		auto typeThash = typeT->GetHashCode();
-		auto readerType = reader->TargetType();
-
-		if (readerType->GetHashCode() != typeThash) {
-			for (auto const& item : typeReaders) {
-				if (item->TargetType()->GetHashCode() == typeThash) {
-					reader = item;
-					break;
-				}
-			}
-
-			if(reader->TargetType()->GetHashCode() != typeThash)
-				throw std::runtime_error("ContentReader::ReadObjectInternal: wrong reader!");
-		}	*/
-
+		
 		return InvokeReader<T>(*reader, existingInstance, err);
 	}
 
 	template<typename T>
-	inline T ContentReader::InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_ptr_arg)
+	inline auto ContentReader::InvokeReader(ContentTypeReader& reader, std::any& existingInstance, xna_error_ptr_arg)
 	{
 		auto contentTypeReader = reinterpret_cast<ContentTypeReaderT<T>*>(&reader);
 		T objB;
@@ -120,11 +103,11 @@ namespace xna {
 			return objB;
 		}
 
-		return T();
+		return ReturnDefaultOrNull<T>();
 	}
 
 	template<typename T>
-	inline T ContentReader::ReadAsset()
+	inline auto ContentReader::ReadAsset()
 	{
 		const auto sharedResourceCount = ReadHeader();
 		auto obj = ReadObject<T>();
@@ -132,33 +115,33 @@ namespace xna {
 	}
 
 	template<typename T>
-	inline T ContentReader::ReadObject()
+	inline auto ContentReader::ReadObject()
 	{
 		auto a = std::any();
 		return ReadObjectInternal<T>(a);
 	}
 
 	template<typename T>
-	inline T ContentReader::ReadObject(T existingInstance)
+	inline auto ContentReader::ReadObject(T existingInstance)
 	{
 		return ReadObjectInternal<T>(std::any(existingInstance));
 	}
 
 	template<typename T>
-	inline T ContentReader::ReadObject(ContentTypeReader& typeReader)
+	inline auto ContentReader::ReadObject(ContentTypeReader& typeReader)
 	{
 		auto obj = std::any();
 		return ReadObjectInternal<T>(typeReader, obj);
 	}
 
 	template<typename T>
-	inline T ContentReader::ReadObject(ContentTypeReader& typeReader, T existingInstance)
+	inline auto ContentReader::ReadObject(ContentTypeReader& typeReader, T existingInstance)
 	{
 		return ReadObjectInternal<T>(typeReader, std::any(existingInstance));
 	}
 
 	template<typename T>
-	inline T ContentReader::ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_ptr_arg)
+	inline auto ContentReader::ReadObjectInternal(ContentTypeReader& typeReader, std::any& existingInstance, xna_error_ptr_arg)
 	{
 		return typeReader.TargetIsValueType
 			? InvokeReader<T>(typeReader, existingInstance, err)
diff --git a/inc/helpers.hpp b/inc/helpers.hpp
index afc396c..d1af0c1 100644
--- a/inc/helpers.hpp
+++ b/inc/helpers.hpp
@@ -24,10 +24,26 @@ namespace xna {
 	}
 
 	template <class T>
-	static constexpr void XnaHHashCombine(std::size_t& seed, const T& v) {
+	constexpr void XnaHHashCombine(std::size_t& seed, const T& v) {
 		std::hash<T> hasher;
 		seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 	}
+
+	template<typename T> struct is_shared_ptr : std::false_type {};
+	template<typename T> struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+
+	template<typename T>
+	inline auto ReturnDefaultOrNull() {
+		if constexpr (is_shared_ptr<T>::value)
+			return (T)nullptr;
+		else
+			return T();
+	}
+
+	/*template<typename T>
+	inline auto ReturnAuto(T& value) {
+		return value;
+	}*/
 }
 
 #endif
\ No newline at end of file