Kerosene ORM: a dynamic, configuration-less and self-adaptive ORM for POCO objects supporting a SQL-like syntax from C#

// ======================================================== 
namespace Kerosene.Tools
{
	using System;
	using System.Reflection;

	// ==================================================== 
	/// <summary>
	/// Helpers and extensions for working with 'Type' objects and reflection.
	/// </summary>
	public static class TypeHelper
	{
		/// <summary>
		/// Returns a string with the C#-alike name of the given type.
		/// </summary>
		/// <param name="type">The type to get its easy name from.</param>
		/// <param name="withParentType">True to include the names from its parents' chain.</param>
		public static string EasyName(this Type type, bool withParentType = false)
		{
			if (type == null) throw new ArgumentNullException("type", "Type cannot be null.");

			var str = type.FullName; if (str == null) str = type.Name;
			var i = str.IndexOf('['); if (i >= 0) str = str.Substring(0, i);

			if (!withParentType)
			{
				i = str.LastIndexOf('.');
				if (i >= 0) str = str.Substring(i + 1);
			}

			str = str.Replace('+', '.'); // nested types

			i = str.IndexOf('`'); if (i >= 0) // generics
			{
				str = str.Substring(0, i);
				str += '<';

				var types = type.GetGenericArguments(); bool first = true; foreach (var temp in types)
				{
					if (first) first = false; else str += ", ";
					str += temp.EasyName(withParentType);
				}
				str += '>';
			}

			return str;
		}

		public const BindingFlags InstancePublicAndHidden = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
		public const BindingFlags PublicAndHidden = BindingFlags.Public | BindingFlags.NonPublic;
		public const BindingFlags Inherited = BindingFlags.FlattenHierarchy;
		public const BindingFlags InstanceAndStatic = BindingFlags.Instance | BindingFlags.Static;

		/// <summary>
		/// Non-exhaustive list of characters that cannot be used with multipart member names.
		/// </summary>
		public static char[] InvalidMultipartMemberChars
		{
			get { return _InvalidMultipartMemberChars.ToCharArray(); }
		}
		static readonly string _InvalidMultipartMemberChars = " /^%[]{}()!\"\\&=?¿+-*";

		/// <summary>
		/// Non-exhaustive list of characters that cannot be used with member names.
		/// </summary>
		public static char[] InvalidMemberChars
		{
			get { return _InvalidMemberChars.ToCharArray(); }
		}
		static readonly string _InvalidMemberChars = "." + _InvalidMultipartMemberChars;

		/// <summary>
		/// Returns whether this type is a nullable one or not.
		/// </summary>
		/// <param name="type">This type.</param>
		public static bool IsNullableType(this Type type)
		{
			if (type == null) throw new ArgumentNullException("type", "Type cannot be null.");

			Type generic = type.IsGenericType ? type.GetGenericTypeDefinition() : null;
			if (generic != null && generic.Equals(typeof(Nullable<>))) return true;

			if (type.IsClass) return true;
			if (type.IsValueType) return false;
			return false;
		}

		/// <summary>
		/// Returns, if possible, a cloned instance of the one given, or otherwise returns the original instance.
		/// </summary>
		/// <param name="source">The instance to clone.</param>
		/// <param name="tryExtended">True to try a parameterless 'Clone()' method even if the type is not ICloneable.</param>
		public static object TryClone(this object source, bool tryExtended = false)
		{
			if (source == null) return null;
			if (source is ICloneable) return ((ICloneable)source).Clone();

			if (tryExtended)
			{
				MethodInfo method = source.GetType().GetMethod("Clone", Type.EmptyTypes); if (method != null)
				{
					if (method.ReturnType == typeof(void)) return source;
					return method.Invoke(source, null);
				}
			}
			return source;
		}
	}
}
// ========================================================