Объявление обобщённого типа (Generic) для стандартных целочисленных типов

    public class Factorial
    {
        long _digit;
        public Factorial(long digit)
        {
            Digit = _digit;
        }
 
        public long Digit
        {
            get
            {
                return _digit;
            }
            set
            {
                Validate(value);
 
                _digit = value;
                Calculate();
            }
        }
        public long Value { get; private set; }
 
        public void Calculate()
        {
            Value = Calculate(_digit);
        }
        public static long Calculate(long digit)
        {
            Validate(digit);
            long factorial = 1; // значение факториала
            for (long i = 2; i <= digit; i++) // цикл начинаем с 2, т.к. нет смысла начинать с 1
            {
                factorial = factorial * i;
            }
            return factorial;
        }
 
        private static void Validate(long digit)
        {
            if (digit <= 0)
            {
                throw new ArgumentException("Digit can't be nonpositive.", "digit");
            }
        }

public static class Extensions
{
    public static int Factorial(this int digit)
    {
        //чтото делаете
        return res;
    }
}

int i =5;
int fact = i.Factorial();

T factorial = 1;

        T Factorial<T>(T value) where T : IConvertible
        {
            IConvertible conv = (IConvertible)value;
            decimal d = conv.ToDecimal(NumberFormatInfo.CurrentInfo);
            /*делаете работу*/
            return (T)(IConvertible)d;
        }

    static class ConvertibleExtensions
    {
        public static T Factorial<T>(this T value) where T : IConvertible
        {
            IConvertible conv = (IConvertible)value;
            decimal d = conv.ToDecimal(NumberFormatInfo.CurrentInfo);
            /*делаете работу*/
            return (T)((IConvertible)d).ToType(typeof(T), NumberFormatInfo.CurrentInfo);
        }
    }

    public class Factorial<TValue> where TValue : struct
    {
        private TValue _digit;
 
        public Factorial(TValue digit)
        {
            _digit = digit;
        }
 
        public TValue Digit
        {
            get { return _digit; }
            set
            {
                Validate(value);
 
                _digit = value;
                Calculate();
            }
        }
 
        public long Value { get; private set; }
 
        public void Calculate()
        {
            Value = Calculate(_digit);
        }
 
        public static long Calculate(TValue digit)
        {
            int digitInt = Validate(digit);
            long factorial = 1; // значение факториала
            for (long i = 2; i <= digitInt; i++) // цикл начинаем с 2, т.к. нет смысла начинать с 1
            {
                factorial = factorial*i;
            }
            return factorial;
        }
 
        private static int Validate(TValue digit)
        {
            int result;
            if (!int.TryParse(digit.ToString(), out result))
            {
                throw new ArgumentException("Digit can't be nonpositive.", "digit");
            }
            return result;
        }
    }

        private static void Main(string[] args)
        {
            new Factorial<int>(112).Calculate();
            new Factorial<double>(112.12).Calculate();
            new Factorial<decimal>((decimal) 112.45).Calculate();
 
            //Вот это тоже можно
            new Factorial<bool>(false).Calculate();
            new Factorial<MyStruct>(new MyStruct()).Calculate();
            new Factorial<DateTime>(DateTime.Now).Calculate();
 
           //Ошибка
            new Factorial<Program>(new Program()).Calculate();
        }
 
        public struct MyStruct
        {
        }

public class Factorial
    {
        private ValueType _digit;
 
        public Factorial(ValueType digit)
        {
            _digit = digit;
        }
 
        public ValueType Digit
        {
            get { return _digit; }
            set
            {
                Validate(value);
 
                _digit = value;
                Calculate();
            }
        }
 
        public long Value { get; private set; }
 
        public void Calculate()
        {
            Value = Calculate(_digit);
        }
 
        public static long Calculate(ValueType digit)
        {
            int digitInt = Validate(digit);
            long factorial = 1; // значение факториала
            for (long i = 2; i <= digitInt; i++) // цикл начинаем с 2, т.к. нет смысла начинать с 1
            {
                factorial = factorial*i;
            }
            return factorial;
        }
 
        private static int Validate(ValueType digit)
        {
            int result;
            if (!int.TryParse(digit.ToString(), out result))
            {
                throw new ArgumentException("Digit can't be nonpositive.", "digit");
            }
            return result;
        }
    }

var forp = myType.GetMember(blabla) as IFieldOrProperty 
if (forp != null)
{
  forp.SetValue(...);
}

var field = myType.GetField(blabla);
if (field == null)
{
   var property = myType.GetProperty(blabla);
   if (property != null)
    ...
}