C# version of scala.util.Try - 2nd draft

TryAction

using System;

namespace CSharpExtensions.Monads
{
    public abstract class Try
    {
        public static Try Invoke(Action action)
        {
            try
            {
                action();
                return Success.Instance;
            }
            catch (Exception e)
            {
                return new Failure(action, e);
            }
        }

        public abstract bool IsSuccess();
        public abstract bool IsFailure();
    }

    public class Failure : Try
    {
        private readonly Action m_action;

        public Exception InnerException
        {
            get;
            private set;
        }

        public Failure(Action action, Exception exception)
        {
            m_action = action;
            InnerException = exception;
        }

        public string Message
        {
            get { return InnerException.Message; }
        }

        public override bool IsSuccess()
        {
            return false;
        }

        public override bool IsFailure()
        {
            return true;
        }

        public Try Retry()
        {
            return Invoke(m_action);
        }

        public void ThrowableRetry()
        {
            m_action();
        }
    }

    public abstract class Try<T>
    {
        public static Try<T> Invoke(Func<T> func)
        {
            try
            {
                var t = func();
                return new Success<T>(t);
            }
            catch (Exception e)
            {
                return new Failure<T>(func,e);
            }
        }

        public abstract bool IsSuccess();
        public abstract bool IsFailure();

        public abstract T Get();
    }

    public class Failure<T> : Try<T>
    {
        private readonly Func<T> m_func;

        public Exception InnerException
        {
            get;
            private set;
        }        

        public string Message
        {
            get { return InnerException.Message; }
        }

        public Failure(Func<T> func, Exception exception)
        {
            this.InnerException = exception;
            this.m_func = func;
        }

        public override bool IsSuccess()
        {
            return false;
        }

        public override bool IsFailure()
        {
            return true;
        }

        public override T Get()
        {
            throw new InvalidOperationException("Cannot perform Get() on a failed operation.");
        }

        public Try<T> Retry()
        {
            return Invoke(m_func);
        }

        public T ThrowableRetry()
        {
            return m_func();
        }
    }

    public class Success : Try
    {
        public static readonly Success Instance = new Success();

        public override bool IsSuccess()
        {
            return true;
        }

        public override bool IsFailure()
        {
            return false;
        }
    }

    public class Success<T> : Try<T>
    {
        private readonly T m_innerValue;

        public Success() { }

        public Success(T t)
        {
            m_innerValue = t;
        }        

        public override bool IsSuccess()
        {
            return true;
        }

        public override bool IsFailure()
        {
            return false;
        }

        public override T Get()
        {
            return m_innerValue;
        }
    }
}

Next, support monad operations (map,flatMap,flatten)