TypeExtensionMethods.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace AnalyzeRe.Utilities
{
    public static class TypeExtensionMethods
    {
        public static string NiceTypeName(this Type t)
        {
            // TODO: Handle nested class names (e.g. Perspective.Base) to show the parent class in the name
            if (!t.IsGenericType)
                return t.Name;
            string genericTypeName = t.GetGenericTypeDefinition().Name;
            genericTypeName = genericTypeName.Substring(0,
                genericTypeName.IndexOf('`'));
            string genericArgs = String.Join(",",
                t.GetGenericArguments().Select(NiceTypeName).ToArray());
            return genericTypeName + "<" + genericArgs + ">";
        }
 
        private static readonly HashSet<Type> IntegerTypes = new HashSet<Type>
        {
            typeof(Byte),
            typeof(SByte),
            typeof(UInt16),
            typeof(UInt32),
            typeof(UInt64),
            typeof(Int16),
            typeof(Int32),
            typeof(Int64)
        };
 
        public static bool IsIntegerType(this Type t)
        {
            return IntegerTypes.Contains(t) ||
                   IntegerTypes.Contains(Nullable.GetUnderlyingType(t));
        }
 
        private static readonly HashSet<Type> NumericTypes = new HashSet<Type>(IntegerTypes)
        {
            typeof(Decimal),
            typeof(Double),
            typeof(Single),
        };
 
        public static bool IsNumeric(this Type t)
        {
            return NumericTypes.Contains(t) ||
                   NumericTypes.Contains(Nullable.GetUnderlyingType(t));
        }
 
        public static bool AlmostEquals(this double d1, double d2,
            double tolerance = 1E-14)
        {
            return d1.Equals(d2) ||
                Math.Abs((d1 - d2) / Math.Max(Math.Abs(d1), Math.Abs(d2))) <= tolerance;
        }
 
        public static bool AlmostEquals(this DateTime dt1, DateTime dt2, TimeSpan? tolerance = null)
        {
            // Note: TimeSpan.FromMilliseconds doesn't take fractional milliseconds, so we must use Ticks.
            tolerance = tolerance ?? TimeSpan.FromTicks(1000);
            return (dt1.ToUniversalTime() - dt2.ToUniversalTime()).Duration() <= tolerance;
        }
    }
}