< Summary - SonghayCore

Information
Class: Songhay.ProgramTypeUtility
Assembly: SonghayCore
File(s): File 1: /home/rasx/sourceRoot/SonghayCore/SonghayCore/ProgramTypeUtility._.cs
File 2: /home/rasx/sourceRoot/SonghayCore/SonghayCore/ProgramTypeUtility.Parsing.cs
Line coverage
17%
Covered lines: 40
Uncovered lines: 184
Coverable lines: 224
Total lines: 784
Line coverage: 17.8%
Branch coverage
16%
Covered branches: 19
Total branches: 114
Branch coverage: 16.6%
Method coverage

Method coverage is only available for sponsors.

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity Line coverage
File 1: ConvertDateTimeFromUnixTime(...)100%10%
File 1: ConvertDateTimeToRfc3339DateTime(...)0%20%
File 1: ConvertDateTimeToRfc822DateTime(...)100%1100%
File 1: ConvertDateTimeToUnixTime()100%10%
File 1: ConvertDateTimeToUnixTime(...)100%10%
File 1: ConvertDateTimeToUtc(...)100%10%
File 1: ConvertInchesToPoints(...)100%10%
File 1: ConvertPointsToInches(...)100%10%
File 1: GenerateRandomPassword(...)0%20%
File 1: IsNullOrEmptyString(...)0%20%
File 1: IsNullOrEmptyOrNotArray(...)0%20%
File 1: SqlDatabaseNull()100%10%
File 2: ParseBoolean(...)100%10%
File 2: ParseBoolean(...)0%120%
File 2: ParseBoolean(...)0%20%
File 2: ParseByte(...)0%40%
File 2: ParseByte(...)0%20%
File 2: ParseDateTime(...)0%40%
File 2: ParseDateTime(...)0%20%
File 2: ParseDateTimeWithFormat(...)0%40%
File 2: ParseDateTimeWithFormat(...)0%20%
File 2: ParseDecimal(...)0%40%
File 2: ParseDecimal(...)0%20%
File 2: ParseDouble(...)0%40%
File 2: ParseDouble(...)0%20%
File 2: ParseEnum(...)75%4100%
File 2: ParseInt16(...)0%40%
File 2: ParseInt16(...)0%20%
File 2: ParseInt32(...)0%40%
File 2: ParseInt32(...)0%20%
File 2: ParseInt64(...)0%40%
File 2: ParseInt64(...)0%20%
File 2: ParseRfc3339DateTime(...)0%20%
File 2: ParseRfc822DateTime(...)50%262.5%
File 2: ParseString(...)0%20%
File 2: ParseString(...)0%20%
File 2: TryParseRfc3339DateTime(...)0%20%
File 2: TryParseRfc822DateTime(...)50%272.72%
File 2: ReplaceRfc822TimeZoneWithOffset(...)50%2831.66%

File(s)

/home/rasx/sourceRoot/SonghayCore/SonghayCore/ProgramTypeUtility._.cs

#LineLine coverage
 1namespace Songhay;
 2
 3/// <summary>
 4/// Static members for type handling.
 5/// </summary>
 6/// <remarks>
 7/// Most of the Parse methods were originally meant
 8/// for unboxing values from XML documents.
 9/// </remarks>
 10public static partial class ProgramTypeUtility
 11{
 12    /// <summary>
 13    /// Converts Unix time stamps
 14    /// to <see cref="DateTime"/>.
 15    /// </summary>
 16    /// <param name="time">A <see cref="Double"/>.</param>
 17    /// <returns>A <see cref="DateTime"/>.</returns>
 18    public static DateTime ConvertDateTimeFromUnixTime(double time) =>
 019        (new DateTime(1970, 1, 1, 0, 0, 0)).AddSeconds(time);
 20
 21    /// <summary>
 22    /// Converts the specified <see cref="DateTime "/> to RFC3339.
 23    /// </summary>
 24    /// <param name="utcDateTime">The UTC date and time.</param>
 25    public static string ConvertDateTimeToRfc3339DateTime(DateTime utcDateTime)
 026    {
 027        DateTimeFormatInfo dateTimeFormat = CultureInfo.InvariantCulture.DateTimeFormat;
 28
 029        var format = (utcDateTime.Kind == DateTimeKind.Local)
 030                ? "yyyy'-'MM'-'dd'T'HH:mm:ss.ffzzz"
 031                : "yyyy'-'MM'-'dd'T'HH':'mm':'ss.ff'Z'"
 032            ;
 33
 034        return utcDateTime.ToString(format, dateTimeFormat);
 035    }
 36
 37    /// <summary>
 38    /// /// Converts the specified <see cref="DateTime "/> to RFC822.
 39    /// </summary>
 40    /// <param name="dateTime">The date and time.</param>
 41    /// <remarks>
 42    /// “Shortcomings of OPML… The RFC 822 date format is considered obsolete,
 43    /// and amongst other things permits the representation of years as two digits.
 44    /// (RFC 822 has been superseded by RFC 2822.)
 45    /// In general, date and time formats should be represented according to RFC 3339.”
 46    /// http://www.answers.com/topic/opml
 47    /// </remarks>
 48    public static string ConvertDateTimeToRfc822DateTime(DateTime dateTime)
 2149    {
 2150        DateTimeFormatInfo dateTimeFormat = CultureInfo.InvariantCulture.DateTimeFormat;
 51
 2152        return dateTime.ToString(dateTimeFormat.RFC1123Pattern, dateTimeFormat);
 2153    }
 54
 55    /// <summary>
 56    /// Converts the current time
 57    /// to a Unix time stamp.
 58    /// </summary>
 59    /// <returns>A <see cref="Double"/>.</returns>
 60    public static double ConvertDateTimeToUnixTime() =>
 061        (DateTime.UtcNow
 062         - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds;
 63
 64    /// <summary>
 65    /// Converts a <see cref="DateTime"/>
 66    /// to a Unix time stamp.
 67    /// </summary>
 68    /// <param name="dateValue">The <see cref="DateTime"/>.</param>
 69    /// <returns>A <see cref="Double"/>.</returns>
 70    public static double ConvertDateTimeToUnixTime(DateTime dateValue) =>
 071        (dateValue.ToUniversalTime()
 072         - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds;
 73
 74    /// <summary>
 75    /// Converts a <see cref="DateTime"/>
 76    /// to UTC (ISO 8601).
 77    /// </summary>
 78    /// <param name="dateValue">The <see cref="DateTime"/>.</param>
 79    /// <remarks>
 80    /// For detail, see https://stackoverflow.com/a/1728437/22944.
 81    /// </remarks>
 82    public static string ConvertDateTimeToUtc(DateTime dateValue) =>
 083        dateValue
 084            .ToUniversalTime()
 085            .ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff'Z'");
 86
 87    /// <summary>
 88    /// Converts inches as a <see cref="Single"/>
 89    /// to points.
 90    /// </summary>
 91    /// <param name="inches">The inches.</param>
 92    /// <remarks>
 93    /// 1 point = 0.013837 inch
 94    /// </remarks>
 095    public static float ConvertInchesToPoints(float inches) => inches / 0.01387f;
 96
 97    /// <summary>
 98    /// Converts points as a <see cref="Single"/>
 99    /// to inches.
 100    /// </summary>
 101    /// <param name="points">The points.</param>
 102    /// <remarks>
 103    /// 1 point = 0.013837 inch
 104    /// </remarks>
 0105    public static float ConvertPointsToInches(float points) => points * 0.01387f;
 106
 107    /// <summary>
 108    /// Generates the random password.
 109    /// </summary>
 110    /// <param name="passwordLength">Length of the password.</param>
 111    /// <remarks>
 112    /// See “Generate random password in C#” by Mads Kristensen
 113    /// [http://madskristensen.net/post/Generate-random-password-in-C]
 114    /// </remarks>
 115    public static string GenerateRandomPassword(int passwordLength)
 0116    {
 0117        var allowedChars = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789!@$?nullable-";
 0118        var chars = new char[passwordLength];
 0119        var r = new Random();
 120
 0121        for (int i = 0; i < passwordLength; i++)
 0122        {
 0123            chars[i] = allowedChars[r.Next(0, allowedChars.Length)];
 0124        }
 125
 0126        return new string(chars);
 0127    }
 128
 129    /// <summary>
 130    /// Returns <c>true</c> when the specified value
 131    /// is <c>null</c> or <see cref="String.Empty"/>.
 132    /// </summary>
 133    /// <param name="boxedString">The framework value.</param>
 134    public static bool IsNullOrEmptyString(object? boxedString) =>
 0135        boxedString == null || string.IsNullOrWhiteSpace(boxedString.ToString());
 136
 137    /// <summary>
 138    /// Returns <c>true</c> when the specified value
 139    /// is an empty array, not an array or null.
 140    /// </summary>
 141    /// <param name="boxedArray">The specified value.</param>
 142    public static bool IsNullOrEmptyOrNotArray(object? boxedArray) =>
 0143        boxedArray is not Array array || (array.Length == 0);
 144
 145    /// <summary>
 146    /// Returns the conventional database null
 147    /// (<see cref="DBNull"/>)
 148    /// for Microsoft SQL Server systems.
 149    /// </summary>
 150    /// <returns><see cref="DBNull"/></returns>
 0151    public static DBNull SqlDatabaseNull() => DBNull.Value;
 152}

/home/rasx/sourceRoot/SonghayCore/SonghayCore/ProgramTypeUtility.Parsing.cs

#LineLine coverage
 1namespace Songhay;
 2
 3public static partial class ProgramTypeUtility
 4{
 5    /// <summary>
 6    /// Tries to convert the specified value
 7    /// to the <see cref="Nullable"></see> return type.
 8    /// </summary>
 9    /// <param name="value">
 10    /// The specified <see cref="Object"></see> box.
 11    /// </param>
 12    /// <returns>
 13    /// Always returns a <see cref="Nullable"></see>
 14    /// as parse failure means <c>HasValue</c>
 15    /// is false.
 16    /// </returns>
 017    public static bool? ParseBoolean(object? value) => ParseBoolean(value, supportBitStrings: false);
 18
 19    /// <summary>
 20    /// Tries to convert the specified value
 21    /// to the <see cref="Nullable"/> return type.
 22    /// </summary>
 23    /// <param name="value">
 24    /// The specified <see cref="Object"/> box.
 25    /// </param>
 26    /// <param name="supportBitStrings">
 27    /// When <c>true</c>, support "1" and "0"
 28    /// as Boolean strings.
 29    /// </param>
 30    /// <returns>
 31    /// Always returns a <see cref="Nullable"/>
 32    /// as parse failure means <c>HasValue</c>
 33    /// is false.
 34    /// </returns>
 35    public static bool? ParseBoolean(object? value, bool supportBitStrings)
 036    {
 037        string? s = (value != null) ? value.ToString() : string.Empty;
 38
 039        if (supportBitStrings)
 040        {
 041            switch (s?.Trim())
 42            {
 43                case "0":
 044                    return false;
 45                case "1":
 046                    return true;
 47            }
 048        }
 49
 050        return bool.TryParse(s, out var bln) ? bln : default(bool?);
 051    }
 52
 53    /// <summary>
 54    /// Tries to convert the specified value
 55    /// to the <see cref="Nullable"/> return type.
 56    /// </summary>
 57    /// <param name="value">
 58    /// The specified <see cref="Object"/> box.
 59    /// </param>
 60    /// <param name="supportBitStrings">
 61    /// When <c>true</c>, support "1" and "0"
 62    /// as Boolean strings.
 63    /// </param>
 64    /// <param name="defaultValue">
 65    /// The default value to return when <c>Nullable.HasValue == false</c>.
 66    /// </param>
 67    /// <returns>
 68    /// Always returns a <see cref="Nullable"/>
 69    /// as parse failure means <c>HasValue</c>
 70    /// is false.
 71    /// </returns>
 72    public static bool? ParseBoolean(object? value, bool supportBitStrings, bool defaultValue)
 073    {
 074        bool? bln = ParseBoolean(value, supportBitStrings);
 75
 076        return bln ?? new bool?(defaultValue);
 077    }
 78
 79    /// <summary>
 80    /// Tries to convert the specified value
 81    /// to the <see cref="Nullable"/> return type.
 82    /// </summary>
 83    /// <param name="value">
 84    /// The specified <see cref="Object"/> box.
 85    /// </param>
 86    /// <returns>
 87    /// Always returns a <see cref="Nullable"/>
 88    /// as parse failure means <c>HasValue</c>
 89    /// is false.
 90    /// </returns>
 91    public static byte? ParseByte(object? value)
 092    {
 093        string? s = value != null ? value.ToString() : string.Empty;
 94
 095        return byte.TryParse(s, out var b) ? b : default(byte?);
 096    }
 97
 98    /// <summary>
 99    /// Tries to convert the specified value
 100    /// to the <see cref="Nullable"/> return type.
 101    /// </summary>
 102    /// <param name="value">
 103    /// The specified <see cref="Object"/> box.
 104    /// </param>
 105    /// <param name="defaultValue">
 106    /// The default value to return when <c>Nullable.HasValue == false</c>.
 107    /// </param>
 108    /// <returns>
 109    /// Always returns a <see cref="Nullable"/>
 110    /// as parse failure means <c>HasValue</c>
 111    /// is false.
 112    /// </returns>
 113    public static byte? ParseByte(object? value, byte defaultValue)
 0114    {
 0115        byte? b = ParseByte(value);
 116
 0117        return b ?? new byte?(defaultValue);
 0118    }
 119
 120    /// <summary>
 121    /// Tries to convert the specified value
 122    /// to the <see cref="Nullable"/> return type.
 123    /// </summary>
 124    /// <param name="value">
 125    /// The specified <see cref="Object"/> box.
 126    /// </param>
 127    /// <returns>
 128    /// Always returns a <see cref="Nullable"/>
 129    /// as parse failure means <c>HasValue</c>
 130    /// is false.
 131    /// </returns>
 132    public static DateTime? ParseDateTime(object? value)
 0133    {
 0134        string? s = value != null ? value.ToString() : string.Empty;
 135
 0136        return DateTime.TryParse(s, out var d) ? d : default(DateTime?);
 0137    }
 138
 139    /// <summary>
 140    /// Tries to convert the specified value
 141    /// to the <see cref="Nullable"/> return type.
 142    /// </summary>
 143    /// <param name="value">
 144    /// The specified <see cref="Object"/> box.
 145    /// </param>
 146    /// <param name="defaultValue">
 147    /// The default value to return when <c>Nullable.HasValue == false</c>.
 148    /// </param>
 149    /// <returns>
 150    /// Always returns a <see cref="Nullable"/>
 151    /// as parse failure means <c>HasValue</c>
 152    /// is false.
 153    /// </returns>
 154    public static DateTime? ParseDateTime(object? value, DateTime defaultValue)
 0155    {
 0156        DateTime? d = ParseDateTime(value);
 157
 0158        return d ?? new DateTime?(defaultValue);
 0159    }
 160
 161    /// <summary>
 162    /// Tries to convert the specified value
 163    /// to the <see cref="Nullable"/> return type.
 164    /// </summary>
 165    /// <param name="value">
 166    /// The specified <see cref="Object"/> box.
 167    /// </param>
 168    /// <param name="formatExpression">
 169    /// The string format expression.
 170    /// </param>
 171    /// <returns>
 172    /// Always returns a <see cref="Nullable"/>
 173    /// as parse failure means <c>HasValue</c>
 174    /// is false.
 175    /// </returns>
 176    public static string? ParseDateTimeWithFormat(object? value, string formatExpression)
 0177    {
 0178        string? s = (value != null) ? value.ToString() : string.Empty;
 179
 0180        return DateTime.TryParse(s, out var d) ? d.ToString(formatExpression, CultureInfo.CurrentCulture) : null;
 0181    }
 182
 183    /// <summary>
 184    /// Tries to convert the specified value
 185    /// to the <see cref="Nullable"/> return type.
 186    /// </summary>
 187    /// <param name="value">
 188    /// The specified <see cref="Object"/> box.
 189    /// </param>
 190    /// <param name="formatExpression">
 191    /// The string format expression.
 192    /// </param>
 193    /// <param name="defaultValue">
 194    /// The default value to return when <c>Nullable.HasValue == false</c>.
 195    /// </param>
 196    /// <returns>
 197    /// Always returns a <see cref="Nullable"/>
 198    /// as parse failure means <c>HasValue</c>
 199    /// is false.
 200    /// </returns>
 201    public static string ParseDateTimeWithFormat(object? value, string formatExpression, string defaultValue)
 0202    {
 0203        string? d = ParseDateTimeWithFormat(value, formatExpression);
 204
 0205        return string.IsNullOrWhiteSpace(d) ? defaultValue : d;
 0206    }
 207
 208    /// <summary>
 209    /// Tries to convert the specified value
 210    /// to the <see cref="Nullable"/> return type.
 211    /// </summary>
 212    /// <param name="value">
 213    /// The specified <see cref="Object"/> box.
 214    /// </param>
 215    /// <returns>
 216    /// Always returns a <see cref="Nullable"/>
 217    /// as parse failure means <c>HasValue</c>
 218    /// is false.
 219    /// </returns>
 220    public static decimal? ParseDecimal(object? value)
 0221    {
 0222        string? s = (value != null) ? value.ToString() : string.Empty;
 223
 0224        return decimal.TryParse(s, out var d) ? d : default(decimal?);
 0225    }
 226
 227    /// <summary>
 228    /// Tries to convert the specified value
 229    /// to the <see cref="Nullable"/> return type.
 230    /// </summary>
 231    /// <param name="value">
 232    /// The specified <see cref="Object"/> box.
 233    /// </param>
 234    /// <param name="defaultValue">
 235    /// The default value to return when <c>Nullable.HasValue == false</c>.
 236    /// </param>
 237    /// <returns>
 238    /// Always returns a <see cref="Nullable"/>
 239    /// as parse failure means <c>HasValue</c>
 240    /// is false.
 241    /// </returns>
 242    public static decimal? ParseDecimal(object? value, decimal defaultValue)
 0243    {
 0244        decimal? d = ParseDecimal(value);
 245
 0246        return d ?? new decimal?(defaultValue);
 0247    }
 248
 249    /// <summary>
 250    /// Tries to convert the specified value
 251    /// to the <see cref="Nullable"/> return type.
 252    /// </summary>
 253    /// <param name="value">
 254    /// The specified <see cref="Object"/> box.
 255    /// </param>
 256    /// <returns>
 257    /// Always returns a <see cref="Nullable"/>
 258    /// as parse failure means <c>HasValue</c>
 259    /// is false.
 260    /// </returns>
 261    public static double? ParseDouble(object? value)
 0262    {
 0263        string? s = value != null ? value.ToString() : string.Empty;
 264
 0265        return double.TryParse(s, out var d) ? d : default(double?);
 0266    }
 267
 268    /// <summary>
 269    /// Tries to convert the specified value
 270    /// to the <see cref="Nullable"/> return type.
 271    /// </summary>
 272    /// <param name="value">
 273    /// The specified <see cref="Object"/> box.
 274    /// </param>
 275    /// <param name="defaultValue">
 276    /// The default value to return when <c>Nullable.HasValue == false</c>.
 277    /// </param>
 278    /// <returns>
 279    /// Always returns a <see cref="Nullable"/>
 280    /// as parse failure means <c>HasValue</c>
 281    /// is false.
 282    /// </returns>
 283    public static double? ParseDouble(object? value, double defaultValue)
 0284    {
 0285        double? d = ParseDouble(value);
 286
 0287        return d ?? new double?(defaultValue);
 0288    }
 289
 290    /// <summary>
 291    /// Tries to convert the specified value
 292    /// to the <see cref="Enum"/> return type.
 293    /// </summary>
 294    /// <typeparam name="TEnum">The type of the enum.</typeparam>
 295    /// <param name="value">The value.</param>
 296    /// <param name="defaultValue">The default value.</param>
 297    /// <remarks>
 298    /// For background, see http://stackoverflow.com/a/15017429/22944
 299    /// </remarks>
 300    public static TEnum ParseEnum<TEnum>(string value, TEnum defaultValue) where TEnum : struct
 2301    {
 2302        var isDefined = !string.IsNullOrWhiteSpace(value) && Enum.IsDefined(typeof(TEnum), value);
 303
 2304        return isDefined ? (TEnum) Enum.Parse(typeof(TEnum), value) : defaultValue;
 2305    }
 306
 307    /// <summary>
 308    /// Tries to convert the specified value
 309    /// to the <see cref="Nullable"/> return type.
 310    /// </summary>
 311    /// <param name="value">
 312    /// The specified <see cref="Object"/> box.
 313    /// </param>
 314    /// <returns>
 315    /// Always returns a <see cref="Nullable"/>
 316    /// as parse failure means <c>HasValue</c>
 317    /// is false.
 318    /// </returns>
 319    public static Int16? ParseInt16(object? value)
 0320    {
 0321        string? s = (value != null) ? value.ToString() : string.Empty;
 322
 0323        return Int16.TryParse(s, out var i) ? i : default(Int16?);
 0324    }
 325
 326    /// <summary>
 327    /// Tries to convert the specified value
 328    /// to the <see cref="Nullable"/> return type.
 329    /// </summary>
 330    /// <param name="value">
 331    /// The specified <see cref="Object"/> box.
 332    /// </param>
 333    /// <param name="defaultValue">
 334    /// The default value to return when <c>Nullable.HasValue == false</c>.
 335    /// </param>
 336    /// <returns>
 337    /// Always returns a <see cref="Nullable"/>
 338    /// as parse failure means <c>HasValue</c>
 339    /// is false.
 340    /// </returns>
 341    public static Int16? ParseInt16(object? value, Int16 defaultValue)
 0342    {
 0343        Int16? i = ParseInt16(value);
 344
 0345        return i ?? new Int16?(defaultValue);
 0346    }
 347
 348    /// <summary>
 349    /// Tries to convert the specified value
 350    /// to the <see cref="Nullable"/> return type.
 351    /// </summary>
 352    /// <param name="value">
 353    /// The specified <see cref="Object"/> box.
 354    /// </param>
 355    /// <returns>
 356    /// Always returns a <see cref="Nullable"/>
 357    /// as parse failure means <c>HasValue</c>
 358    /// is false.
 359    /// </returns>
 360    public static Int32? ParseInt32(object? value)
 0361    {
 0362        string? s = value != null ? value.ToString() : string.Empty;
 363
 0364        return Int32.TryParse(s, out var i) ? i : default(Int32?);
 0365    }
 366
 367    /// <summary>
 368    /// Tries to convert the specified value
 369    /// to the <see cref="Nullable"/> return type.
 370    /// </summary>
 371    /// <param name="value">
 372    /// The specified <see cref="Object"/> box.
 373    /// </param>
 374    /// <param name="defaultValue">
 375    /// The default value to return when <c>Nullable.HasValue == false</c>.
 376    /// </param>
 377    /// <returns>
 378    /// Always returns a <see cref="Nullable"/>
 379    /// as parse failure means <c>HasValue</c>
 380    /// is false.
 381    /// </returns>
 382    public static Int32? ParseInt32(object? value, Int32 defaultValue)
 0383    {
 0384        Int32? i = ParseInt32(value);
 385
 0386        return i ?? new Int32?(defaultValue);
 0387    }
 388
 389    /// <summary>
 390    /// Tries to convert the specified value
 391    /// to the <see cref="Nullable"/> return type.
 392    /// </summary>
 393    /// <param name="value">
 394    /// The specified <see cref="Object"/> box.
 395    /// </param>
 396    /// <returns>
 397    /// Always returns a <see cref="Nullable"/>
 398    /// as parse failure means <c>HasValue</c>
 399    /// is false.
 400    /// </returns>
 401    public static Int64? ParseInt64(object? value)
 0402    {
 0403        string? s = value != null ? value.ToString() : string.Empty;
 404
 0405        return Int64.TryParse(s, out var i) ? i : default(Int64?);
 0406    }
 407
 408    /// <summary>
 409    /// Tries to convert the specified value
 410    /// to the <see cref="Nullable"/> return type.
 411    /// </summary>
 412    /// <param name="value">
 413    /// The specified <see cref="Object"/> box.
 414    /// </param>
 415    /// <param name="defaultValue">
 416    /// The default value to return when <c>Nullable.HasValue == false</c>.
 417    /// </param>
 418    /// <returns>
 419    /// Always returns a <see cref="Nullable"/>
 420    /// as parse failure means <c>HasValue</c>
 421    /// is false.
 422    /// </returns>
 423    public static Int64? ParseInt64(object? value, Int64 defaultValue)
 0424    {
 0425        Int64? i = ParseInt64(value);
 426
 0427        return i ?? new Int64?(defaultValue);
 0428    }
 429
 430    /// <summary>
 431    /// Parses the RFC3339 date and time.
 432    /// </summary>
 433    /// <param name="value">The value.</param>
 434    /// <remarks>
 435    ///     This member is based on patterns in the Argotic Syndication Framework (http://www.codeplex.com/Argotic).
 436    /// </remarks>
 437    public static DateTime ParseRfc3339DateTime(string? value)
 0438    {
 0439        value.ThrowWhenNullOrWhiteSpace();
 440
 0441        if (!TryParseRfc3339DateTime(value, out var minValue))
 0442        {
 0443            throw new FormatException(string.Format(CultureInfo.CurrentCulture,
 0444                "'{0}' is not a valid RFC-3339 formatted date-time value.", new object[] {value}));
 445        }
 446
 0447        return minValue;
 0448    }
 449
 450    /// <summary>
 451    /// Parses the RFC822 date and time.
 452    /// </summary>
 453    /// <param name="value">The value.</param>
 454    /// <remarks>
 455    ///     This member is based on patterns in the Argotic Syndication Framework (http://www.codeplex.com/Argotic).
 456    /// </remarks>
 457    public static DateTime ParseRfc822DateTime(string value)
 10458    {
 10459        value.ThrowWhenNullOrWhiteSpace();
 460
 10461        if (!TryParseRfc822DateTime(value, out var minValue))
 0462        {
 0463            throw new FormatException(string.Format(CultureInfo.CurrentCulture,
 0464                "'{0}' is not a valid RFC-822 formatted date-time value.", new object[] {value}));
 465        }
 466
 10467        return minValue;
 10468    }
 469
 470    /// <summary>
 471    /// Tries to convert the specified value
 472    /// to a <see cref="String"/>.
 473    /// </summary>
 474    /// <param name="value">
 475    /// The specified <see cref="Object"/> box.
 476    /// </param>
 0477    public static string? ParseString(object? value) => value?.ToString();
 478
 479    /// <summary>
 480    /// Tries to convert the specified value
 481    /// to a <see cref="String"/>.
 482    /// </summary>
 483    /// <param name="value">The value.</param>
 484    /// <param name="defaultValue">The default value.</param>
 485    public static string? ParseString(object? value, string? defaultValue) =>
 0486        value != null ? value.ToString() : defaultValue;
 487
 488    /// <summary>
 489    /// Tries the parse RFC3339 date and time.
 490    /// </summary>
 491    /// <param name="value">The value.</param>
 492    /// <param name="result">The result.</param>
 493    /// <remarks>
 494    ///     This member is based on patterns in the Argotic Syndication Framework (http://www.codeplex.com/Argotic).
 495    /// </remarks>
 496    public static bool TryParseRfc3339DateTime(string value, out DateTime result)
 0497    {
 0498        DateTimeFormatInfo dateTimeFormat = CultureInfo.InvariantCulture.DateTimeFormat;
 0499        string[] formats =
 0500        {
 0501            dateTimeFormat.SortableDateTimePattern, dateTimeFormat.UniversalSortableDateTimePattern,
 0502            "yyyy'-'MM'-'dd'T'HH:mm:ss'Z'", "yyyy'-'MM'-'dd'T'HH:mm:ss.f'Z'", "yyyy'-'MM'-'dd'T'HH:mm:ss.ff'Z'",
 0503            "yyyy'-'MM'-'dd'T'HH:mm:ss.fff'Z'", "yyyy'-'MM'-'dd'T'HH:mm:ss.ffff'Z'",
 0504            "yyyy'-'MM'-'dd'T'HH:mm:ss.fffff'Z'", "yyyy'-'MM'-'dd'T'HH:mm:ss.ffffff'Z'", "yyyy'-'MM'-'dd'T'HH:mm:sszzz",
 0505            "yyyy'-'MM'-'dd'T'HH:mm:ss.ffzzz", "yyyy'-'MM'-'dd'T'HH:mm:ss.fffzzz", "yyyy'-'MM'-'dd'T'HH:mm:ss.ffffzzz",
 0506            "yyyy'-'MM'-'dd'T'HH:mm:ss.fffffzzz", "yyyy'-'MM'-'dd'T'HH:mm:ss.ffffffzzz"
 0507        };
 508
 0509        if (string.IsNullOrWhiteSpace(value))
 0510        {
 0511            result = DateTime.MinValue;
 0512            return false;
 513        }
 514
 0515        return DateTime.TryParseExact(value, formats, dateTimeFormat, DateTimeStyles.AssumeUniversal, out result);
 0516    }
 517
 518    /// <summary>
 519    /// Tries the parse RFC822 date and time.
 520    /// </summary>
 521    /// <param name="value">The value.</param>
 522    /// <param name="result">The result.</param>
 523    /// <remarks>
 524    ///     This member is based on patterns in the Argotic Syndication Framework (http://www.codeplex.com/Argotic).
 525    /// </remarks>
 526    public static bool TryParseRfc822DateTime(string value, out DateTime result)
 10527    {
 10528        DateTimeFormatInfo dateTimeFormat = CultureInfo.InvariantCulture.DateTimeFormat;
 10529        string[] formats =
 10530            {dateTimeFormat.RFC1123Pattern, "ddd',' d MMM yyyy HH:mm:ss zzz", "ddd',' dd MMM yyyy HH:mm:ss zzz"};
 531
 10532        if (string.IsNullOrWhiteSpace(value))
 0533        {
 0534            result = DateTime.MinValue;
 0535            return false;
 536        }
 537
 10538        return DateTime.TryParseExact(ReplaceRfc822TimeZoneWithOffset(value), formats, dateTimeFormat,
 10539            DateTimeStyles.None, out result);
 10540    }
 541
 542    static string ReplaceRfc822TimeZoneWithOffset(string? value)
 10543    {
 10544        value.ThrowWhenNullOrWhiteSpace();
 545
 10546        value = value.Trim();
 10547        if (value.EndsWith("UT", StringComparison.OrdinalIgnoreCase))
 0548        {
 0549            return string.Format(CultureInfo.CurrentCulture, "{0}GMT",
 0550                new object[] {value.TrimEnd("UT".ToCharArray())});
 551        }
 552
 10553        if (value.EndsWith("EST", StringComparison.OrdinalIgnoreCase))
 0554        {
 0555            return string.Format(CultureInfo.CurrentCulture, "{0}-05:00",
 0556                new object[] {value.TrimEnd("EST".ToCharArray())});
 557        }
 558
 10559        if (value.EndsWith("EDT", StringComparison.OrdinalIgnoreCase))
 0560        {
 0561            return string.Format(CultureInfo.CurrentCulture, "{0}-04:00",
 0562                new object[] {value.TrimEnd("EDT".ToCharArray())});
 563        }
 564
 10565        if (value.EndsWith("CST", StringComparison.OrdinalIgnoreCase))
 0566        {
 0567            return string.Format(CultureInfo.CurrentCulture, "{0}-06:00",
 0568                new object[] {value.TrimEnd("CST".ToCharArray())});
 569        }
 570
 10571        if (value.EndsWith("CDT", StringComparison.OrdinalIgnoreCase))
 0572        {
 0573            return string.Format(CultureInfo.CurrentCulture, "{0}-05:00",
 0574                new object[] {value.TrimEnd("CDT".ToCharArray())});
 575        }
 576
 10577        if (value.EndsWith("MST", StringComparison.OrdinalIgnoreCase))
 0578        {
 0579            return string.Format(CultureInfo.CurrentCulture, "{0}-07:00",
 0580                new object[] {value.TrimEnd("MST".ToCharArray())});
 581        }
 582
 10583        if (value.EndsWith("MDT", StringComparison.OrdinalIgnoreCase))
 0584        {
 0585            return string.Format(CultureInfo.CurrentCulture, "{0}-06:00",
 0586                new object[] {value.TrimEnd("MDT".ToCharArray())});
 587        }
 588
 10589        if (value.EndsWith("PST", StringComparison.OrdinalIgnoreCase))
 0590        {
 0591            return string.Format(CultureInfo.CurrentCulture, "{0}-08:00",
 0592                new object[] {value.TrimEnd("PST".ToCharArray())});
 593        }
 594
 10595        if (value.EndsWith("PDT", StringComparison.OrdinalIgnoreCase))
 0596        {
 0597            return string.Format(CultureInfo.CurrentCulture, "{0}-07:00",
 0598                new object[] {value.TrimEnd("PDT".ToCharArray())});
 599        }
 600
 10601        if (value.EndsWith("Z", StringComparison.OrdinalIgnoreCase))
 0602        {
 0603            return string.Format(CultureInfo.CurrentCulture, "{0}GMT", new object[] {value.TrimEnd("Z".ToCharArray())});
 604        }
 605
 10606        if (value.EndsWith("A", StringComparison.OrdinalIgnoreCase))
 0607        {
 0608            return string.Format(CultureInfo.CurrentCulture, "{0}-01:00",
 0609                new object[] {value.TrimEnd("A".ToCharArray())});
 610        }
 611
 10612        if (value.EndsWith("M", StringComparison.OrdinalIgnoreCase))
 0613        {
 0614            return string.Format(CultureInfo.CurrentCulture, "{0}-12:00",
 0615                new object[] {value.TrimEnd("M".ToCharArray())});
 616        }
 617
 10618        if (value.EndsWith("N", StringComparison.OrdinalIgnoreCase))
 0619        {
 0620            return string.Format(CultureInfo.CurrentCulture, "{0}+01:00",
 0621                new object[] {value.TrimEnd("N".ToCharArray())});
 622        }
 623
 10624        if (value.EndsWith("Y", StringComparison.OrdinalIgnoreCase))
 0625        {
 0626            return string.Format(CultureInfo.CurrentCulture, "{0}+12:00",
 0627                new object[] {value.TrimEnd("Y".ToCharArray())});
 628        }
 629
 10630        return value;
 10631    }
 632}
Generated by: ReportGenerator 5.1.9.0
7/16/2022 - 9:47:57 PM
GitHub | www.palmmedia.de

Methods/Properties

ConvertDateTimeFromUnixTime(System.Double)
ConvertDateTimeToRfc3339DateTime(System.DateTime)
ConvertDateTimeToRfc822DateTime(System.DateTime)
ConvertDateTimeToUnixTime()
ConvertDateTimeToUnixTime(System.DateTime)
ConvertDateTimeToUtc(System.DateTime)
ConvertInchesToPoints(System.Single)
ConvertPointsToInches(System.Single)
GenerateRandomPassword(System.Int32)
IsNullOrEmptyString(System.Object)
IsNullOrEmptyOrNotArray(System.Object)
SqlDatabaseNull()
ParseBoolean(System.Object)
ParseBoolean(System.Object,System.Boolean)
ParseBoolean(System.Object,System.Boolean,System.Boolean)
ParseByte(System.Object)
ParseByte(System.Object,System.Byte)
ParseDateTime(System.Object)
ParseDateTime(System.Object,System.DateTime)
ParseDateTimeWithFormat(System.Object,System.String)
ParseDateTimeWithFormat(System.Object,System.String,System.String)
ParseDecimal(System.Object)
ParseDecimal(System.Object,System.Decimal)
ParseDouble(System.Object)
ParseDouble(System.Object,System.Double)
ParseEnum(System.String,TEnum)
ParseInt16(System.Object)
ParseInt16(System.Object,System.Int16)
ParseInt32(System.Object)
ParseInt32(System.Object,System.Int32)
ParseInt64(System.Object)
ParseInt64(System.Object,System.Int64)
ParseRfc3339DateTime(System.String)
ParseRfc822DateTime(System.String)
ParseString(System.Object)
ParseString(System.Object,System.String)
TryParseRfc3339DateTime(System.String,System.DateTime&)
TryParseRfc822DateTime(System.String,System.DateTime&)
ReplaceRfc822TimeZoneWithOffset(System.String)