TypeExtensions.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

public static class TypeExtensions
{
    public static bool IsNumber(this Type t)
    {
        return t == typeof(sbyte)
        || t == typeof(byte)
        || t == typeof(short)
        || t == typeof(ushort)
        || t == typeof(int)
        || t == typeof(uint)
        || t == typeof(long)
        || t == typeof(ulong)
        || t == typeof(float)
        || t == typeof(double)
        || t == typeof(decimal);
    }

    public static List<PropertyInfo> GetXMLSerializableProperties(this Type t)
    {
        return t.GetProperties().Where(PI => PI.IsXMLSerializeable()).ToList();
    }


    public static bool IsGenericList(this Type type)
    {
        if (type == null) return false;

        foreach (Type @interface in type.GetInterfaces())
        {
            if (@interface.IsGenericType)
            {
                if (@interface.GetGenericTypeDefinition() == typeof(ICollection<>))
                {

                    return true;
                }
            }
        }
        return false;
    }


    public static bool IsGenericDictionary(this Type type)
    {
        if (type == null) return false;

        foreach (Type @interface in type.GetInterfaces())
        {
            if (@interface.IsGenericType)
            {
                if (@interface.GetGenericTypeDefinition() == typeof(IDictionary<,>))
                {

                    return true;
                }
            }
        }
        return false;
    }


    public static Type[] GetGetGenericCollectionTypeArguments(this Type type)
    {
        if (type == null) return null;
        if (!type.IsGenericList() && !type.IsGenericDictionary()) return null;

        foreach (Type @interface in type.GetInterfaces())
        {
            if (@interface.IsGenericType)
            {
                if (@interface.GetGenericTypeDefinition() == typeof(ICollection<>) | @interface.GetGenericTypeDefinition() == typeof(IDictionary<,>))
                {

                    return @interface.GetGenericArguments();
                }
            }
        }
        return null;
    }

    public static bool HasProperty(this Type obj, string PropertyName)
    {
        return obj.GetProperty(PropertyName) != null;
    }

    public static bool IsBuiltinType(this Type type)
    {
        return type.Namespace == "System";
    }


    public static string GetFullName(this Type t)
    {
        if (!t.IsGenericType)
            return t.Name;
        StringBuilder sb = new StringBuilder();

        sb.Append(t.Name.Substring(0, t.Name.LastIndexOf("`")));
        sb.Append(t.GetGenericArguments().Aggregate("<",

            delegate(string aggregate, Type type)
            {
                return aggregate + (aggregate == "<" ? "" : ",") + GetFullName(type);
            }
            ));
        sb.Append(">");

        return sb.ToString();
    }


    public static string GetDisplayName(this Type t)
    {
        if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>))
            return string.Format("{0}?", GetDisplayName(t.GetGenericArguments()[0]));
        if (t.IsGenericType)
            return string.Format("{0}<{1}>",
                                 t.Name.Remove(t.Name.IndexOf('`')),
                                 string.Join(",", t.GetGenericArguments().Select(at => at.GetDisplayName())));
        if (t.IsArray)
            return string.Format("{0}[{1}]",
                                 GetDisplayName(t.GetElementType()),
                                 new string(',', t.GetArrayRank() - 1));
        return t.Name;
    }
}