using System;
using System.Collections.Generic;
using System.Text;

namespace Project.YourNamespace {
    /// <summary>
    /// Provides parsing functionality for <see cref="System.Nullable{T}"/> value types.
    /// </summary>
    public static class NullableParser {
        #region private delegate

        private delegate bool TryParseDelegate<T>(string s, out T result) where T : struct;

        #endregion
        
        #region private methods

        private static bool TryParseNullable<T>(string value, out Nullable<T> result, TryParseDelegate<T> tryParse, bool alwaysNull) where T : struct {
            if(string.IsNullOrEmpty(value)) {
                if(alwaysNull) {
                    result = null;
                    return false;
                } else {
                    result = default(T);
                    return false;
                }
            }
            T tempResult;
            bool success = tryParse(value, out tempResult);
            result = tempResult;
            return success;
        }

        #endregion

        #region byte TryParse

        /// <summary>
        /// Converts the string representation of a number to its byte equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the byte value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out byte? result, bool alwaysNull) {
            return TryParseNullable<byte>(value, out result, byte.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the string representation of a number to its byte equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the byte value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out byte? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region sbyte TryParse

        /// <summary>
        /// Converts the string representation of a number to its sbyte equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the sbyte value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        [method: CLSCompliant(false)]
        public static bool TryParse(string value, out sbyte? result, bool alwaysNull) {
            return TryParseNullable<sbyte>(value, out result, sbyte.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the string representation of a number to its sbyte equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the sbyte value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        [method: CLSCompliant(false)]
        public static bool TryParse(string value, out sbyte? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region short TryParse

        /// <summary>
        /// Converts the string representation of a number to its 16-bit signed integer equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 16-bit signed integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out short? result, bool alwaysNull) {
            return TryParseNullable<short>(value, out result, short.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the string representation of a number to its 16-bit signed integer equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 16-bit signed integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out short? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region ushort TryParse

        /// <summary>
        /// Converts the string representation of a number to its 16-bit unsigned integer equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 16-bit unsigned integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        [method: CLSCompliant(false)]
        public static bool TryParse(string value, out ushort? result, bool alwaysNull) {
            return TryParseNullable<ushort>(value, out result, ushort.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the string representation of a number to its 16-bit unsigned integer equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 16-bit unsigned integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        [method: CLSCompliant(false)]
        public static bool TryParse(string value, out ushort? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region int TryParse

        /// <summary>
        /// Converts the string representation of a number to its 32-bit signed integer equivalent. A return value indicates whether the operation succeeded.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 32-bit signed integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out int? result, bool alwaysNull) {
            return TryParseNullable<int>(value, out result, int.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the string representation of a number to its 32-bit signed integer equivalent. A return value indicates whether the operation succeeded.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 32-bit signed integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out int? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region uint TryParse

        /// <summary>
        /// Converts the string representation of a number to its 32-bit unsigned integer equivalent. A return value indicates whether the operation succeeded.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 32-bit unsigned integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        [method: CLSCompliant(false)]
        public static bool TryParse(string value, out uint? result, bool alwaysNull) {
            return TryParseNullable<uint>(value, out result, uint.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the string representation of a number to its 32-bit unsigned integer equivalent. A return value indicates whether the operation succeeded.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 32-bit unsigned integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        [method: CLSCompliant(false)]
        public static bool TryParse(string value, out uint? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region long TryParse

        /// <summary>
        /// Converts the string representation of a number to its 64-bit signed integer equivalent. A return value indicates whether the operation succeeded.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 64-bit signed integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out long? result, bool alwaysNull) {
            return TryParseNullable<long>(value, out result, long.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the string representation of a number to its 64-bit signed integer equivalent. A return value indicates whether the operation succeeded.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 64-bit signed integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out long? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region ulong TryParse

        /// <summary>
        /// Converts the string representation of a number to its 64-bit unsigned integer equivalent. A return value indicates whether the operation succeeded.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 64-bit unsigned integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        [method: CLSCompliant(false)]
        public static bool TryParse(string value, out ulong? result, bool alwaysNull) {
            return TryParseNullable<ulong>(value, out result, ulong.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the string representation of a number to its 64-bit unsigned integer equivalent. A return value indicates whether the operation succeeded.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the 64-bit unsigned integer value equivalent to the number contained in value, if the conversion succeeded, or zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not of the correct format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        [method: CLSCompliant(false)]
        public static bool TryParse(string value, out ulong? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region decimal TryParse

        /// <summary>
        /// Converts the String representation of a number to its Decimal equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the Decimal number that is equivalent to the numeric value contained in value, if the conversion succeeded, or is zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not a number in a valid format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out decimal? result, bool alwaysNull) {
            return TryParseNullable<decimal>(value, out result, decimal.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the String representation of a number to its Decimal equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the Decimal number that is equivalent to the numeric value contained in s, if the conversion succeeded, or is zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not a number in a valid format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out decimal? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region double TryParse

        /// <summary>
        /// Converts the String representation of a number to its Double equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the Double number that is equivalent to the numeric value contained in value, if the conversion succeeded, or is zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not a number in a valid format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out double? result, bool alwaysNull) {
            return TryParseNullable<double>(value, out result, double.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the String representation of a number to its Double equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the Double number that is equivalent to the numeric value contained in value, if the conversion succeeded, or is zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not a number in a valid format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out double? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region single TryParse

        /// <summary>
        /// Converts the String representation of a number to its Single equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the Single number that is equivalent to the numeric value contained in value, if the conversion succeeded, or is zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not a number in a valid format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out Single? result, bool alwaysNull) {
            return TryParseNullable<Single>(value, out result, Single.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the String representation of a number to its Single equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a number to convert.</param>
        /// <param name="result">When this method returns, contains the Single number that is equivalent to the numeric value contained in value, if the conversion succeeded, or is zero if the conversion failed. The conversion fails if the s parameter is a null reference (Nothing in Visual Basic), is not a number in a valid format, or represents a number less than MinValue or greater than MaxValue. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out Single? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region boolean TryParse

        /// <summary>
        /// Converts the specified string representation of a logical value to its Boolean equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a value to convert.</param>
        /// <param name="result">When this method returns, if the conversion succeeded, contains true if value is equivalent to TrueString or false if value is equivalent to FalseString. If the conversion failed, contains false. The conversion fails if value is a null reference (Nothing in Visual Basic) or is not equivalent to either TrueString or FalseString. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out bool? result, bool alwaysNull) {
            return TryParseNullable<bool>(value, out result, bool.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the specified string representation of a logical value to its Boolean equivalent. A return value indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a value to convert.</param>
        /// <param name="result">When this method returns, if the conversion succeeded, contains true if value is equivalent to TrueString or false if value is equivalent to FalseString. If the conversion failed, contains false. The conversion fails if value is a null reference (Nothing in Visual Basic) or is not equivalent to either TrueString or FalseString. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out bool? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region char TryParse

        /// <summary>
        /// Converts the value of the specified string to its equivalent Unicode character. A return code indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a single character or a null reference (Nothing in Visual Basic).</param>
        /// <param name="result">When this method returns, contains a Unicode character equivalent to the sole character in value, if the conversion succeeded, or an undefined value if the conversion failed. The conversion fails if the value parameter is a null reference (Nothing in Visual Basic) or the length of value is not 1. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out char? result, bool alwaysNull) {
            return TryParseNullable<char>(value, out result, char.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the value of the specified string to its equivalent Unicode character. A return code indicates whether the conversion succeeded or failed.
        /// </summary>
        /// <param name="value">A string containing a single character or a null reference (Nothing in Visual Basic).</param>
        /// <param name="result">When this method returns, contains a Unicode character equivalent to the sole character in value, if the conversion succeeded, or an undefined value if the conversion failed. The conversion fails if the value parameter is a null reference (Nothing in Visual Basic) or the length of value is not 1. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out char? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region DateTime TryParse

        /// <summary>
        /// Converts the specified string representation of a date and time to its DateTime equivalent.
        /// </summary>
        /// <param name="value">A string containing a date and time to convert.</param>
        /// <param name="result">When this method returns, contains the DateTime value equivalent to the date and time contained in value, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the value parameter is a null reference (Nothing in Visual Basic), or does not contain a valid string representation of a date and time. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out DateTime? result, bool alwaysNull) {
            return TryParseNullable<DateTime>(value, out result, DateTime.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the specified string representation of a date and time to its DateTime equivalent.
        /// </summary>
        /// <param name="value">A string containing a date and time to convert.</param>
        /// <param name="result">When this method returns, contains the DateTime value equivalent to the date and time contained in value, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the value parameter is a null reference (Nothing in Visual Basic), or does not contain a valid string representation of a date and time. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out DateTime? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region DateTimeOffset TryParse

        /// <summary>
        /// Converts the specified string representation of a offset and time to its DateTimeOffset equivalent.
        /// </summary>
        /// <param name="value">A string containing a offset to convert.</param>
        /// <param name="result">When this method returns, contains the DateTimeOffset value equivalent to the offset contained in value, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the value parameter is a null reference (Nothing in Visual Basic), or does not contain a valid string representation of an offset. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out DateTimeOffset? result, bool alwaysNull) {
            return TryParseNullable<DateTimeOffset>(value, out result, DateTimeOffset.TryParse, alwaysNull);
        }

        /// <summary>
        /// Converts the specified string representation of a offset and time to its DateTimeOffset equivalent.
        /// </summary>
        /// <param name="value">A string containing a offset to convert.</param>
        /// <param name="result">When this method returns, contains the DateTimeOffset value equivalent to the offset contained in value, if the conversion succeeded, or MinValue if the conversion failed. The conversion fails if the value parameter is a null reference (Nothing in Visual Basic), or does not contain a valid string representation of an offset. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out DateTimeOffset? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region TimeSpan TryParse

        /// <summary>
        /// Constructs a new TimeSpan object from a time interval specified in a string. Parameters specify the time interval and the variable where the new TimeSpan object is returned.
        /// </summary>
        /// <param name="value">A string that specifies a time interval.</param>
        /// <param name="result">When this method returns, contains an object that represents the time interval specified by value, or Zero if the conversion failed. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out TimeSpan? result, bool alwaysNull) {
            return TryParseNullable<TimeSpan>(value, out result, TimeSpan.TryParse, alwaysNull);
        }

        /// <summary>
        /// Constructs a new TimeSpan object from a time interval specified in a string. Parameters specify the time interval and the variable where the new TimeSpan object is returned.
        /// </summary>
        /// <param name="value">A string that specifies a time interval.</param>
        /// <param name="result">When this method returns, contains an object that represents the time interval specified by value, or Zero if the conversion failed. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out TimeSpan? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion

        #region Guid TryParse

        /// <summary>
        /// Constructs a new guid struct from a guid (unique identifier) specified in a string. Parameters specify the guid and the variable where the new guid struct is returned.
        /// </summary>
        /// <param name="value">A string that specifies a valid guid.</param>
        /// <param name="result">When this method returns, contains an object that represents the guid specified by value, or guid.empty if the conversion failed. This parameter is passed uninitialized.</param>
        /// <param name="alwaysNull">true to set the value of result to null if the value to parse is null or empty; otherwise false to have result set using the default value of the type.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out Guid? result, bool alwaysNull) {
            result = Guid.Empty;
            if (string.IsNullOrEmpty(value)) {
                if (alwaysNull) {
                    result = null;
                    return false;
                } else {
                    return false;
                }
            }

            try {
                result = new Guid(value);
                return true;
            } catch {
                return false;   
            }
        }

        /// <summary>
        /// Constructs a new guid struct from a guid (unique identifier) specified in a string. Parameters specify the guid and the variable where the new guid struct is returned.
        /// </summary>
        /// <param name="value">A string that specifies a valid guid.</param>
        /// <param name="result">When this method returns, contains an object that represents the guid specified by value, or guid.empty if the conversion failed. This parameter is passed uninitialized.</param>
        /// <returns>true if the value parameter was converted successfully; otherwise, false.</returns>
        public static bool TryParse(string value, out Guid? result) {
            return NullableParser.TryParse(value, out result, false);
        }

        #endregion
    }
}