private void InitializeMembers() { this.encoding = null; this.culture = null; this.numberStyle = NumberStyles.Float; this.dateTimeStyle = DateTimeStyles.None; }
public static DateTime ParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style) { // Note: the Date/Time handling in java is just broken, and putting a // .NET compatibility layer on top of it will probalby not fix much if (s == null || format == null) throw new ArgumentNullException(); if ((style & DateTimeStyles.AllowLeadingWhite) != 0) s = s.TrimStart(); if ((style & DateTimeStyles.AllowTrailingWhite) != 0) s = s.TrimEnd(); if ((style & DateTimeStyles.AllowWhiteSpaces) != 0) s = s.Trim(); try { var formatter = DateFormatFactory.GetFormat(format, DateTimeKind.Unspecified, provider); formatter.Format.TimeZone = TimeZone.GetTimeZone("UTC"); // reset mutable value Date parsed = formatter.Format.Parse(s); var result = FromParsedDate(parsed, s, style, formatter.Format, formatter.ContainsK, formatter.UseUtc); return result; } catch (ArgumentException ex) { throw new FormatException(ex.Message); } catch (ParseException ex) { throw new ArgumentException(ex.Message, "s"); } }
public DateParser(string format, DateTimeKind kind) { switch (kind) { case DateTimeKind.Local: _style = DateTimeStyles.AssumeLocal; break; case DateTimeKind.Utc: _style = DateTimeStyles.AssumeUniversal; break; default: throw new ArgumentOutOfRangeException("kind"); } switch (format) { case "ABSOLUTE": break; case "ISO8601": break; case "DATE": break; } }
/// <summary> /// Convert string date to datetime /// </summary> /// <param name="strValue">string to convert</param> /// <param name="defaultValue">default value when invalid date</param> /// <param name="culture">date culture</param> /// <param name="dateTimeStyle">datetime style</param> /// <returns>datetime</returns> public static DateTime TryParseDate(this string strValue, DateTime defaultValue, CultureInfo culture, DateTimeStyles dateTimeStyle) { DateTime date; if (DateTime.TryParse(strValue, culture, dateTimeStyle, out date)) return date; #region FromOADate if (strValue.IsValidDouble(NumberStyles.Float, culture)) { var doubleValue = strValue.TryParseDouble(-99); if (doubleValue >= -657434.999 && doubleValue <= 2593589) { try { return DateTime.FromOADate(doubleValue); } catch (Exception e) { Debug.WriteLine(e); } } } #endregion return defaultValue; }
/// <summary> /// Configures <see cref="GlobalizationConfiguration"/> /// </summary> /// <param name="environment">An <see cref="INancyEnvironment"/> that should be configured.</param> /// <param name="supportedCultureNames">Cultures that the application can accept</param> /// <param name="defaultCulture">Used to set a default culture for the application</param> /// <param name="dateTimeStyles">The <see cref="DateTimeStyles"/> that should be used for date parsing.</param> /// <remarks>If defaultCulture not specified the first supported culture is used</remarks> public static void Globalization(this INancyEnvironment environment, IEnumerable<string> supportedCultureNames, string defaultCulture = null, DateTimeStyles? dateTimeStyles = null) { environment.AddValue(new GlobalizationConfiguration( supportedCultureNames: supportedCultureNames, defaultCulture: defaultCulture, dateTimeStyles: dateTimeStyles)); }
internal static readonly long TicksAt1970 = 621355968000000000L; //new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks; /// <summary> /// Parses string in following formats to DateTime representation: /// - @decimal@ - 1970-01-01 + decimal (millisec) - UTC! /// - \/Date(decimal)\/ - 1970-01-01 + decimal (millisec) - UTC! /// - \/Date(yyyy,MM,dd[,hh,mm,ss,mmm])\/ - direct params - UTC! /// - decimal - 1970-01-01 + decimal (millisec/sec) - UTC! /// - ISO format - with time zones support /// </summary> public static DateTime ParseDateTime(string text, IFormatProvider provider, DateTimeStyles styles, JSonDateTimeKind kind) { if (!String.IsNullOrEmpty(text)) { var date = text.Replace(" ", String.Empty).Replace("\t", String.Empty); if (date.Length > 2) { if (date[0] == '@' && date[date.Length - 1] == '@') return ParseDateTimeAsDecimal(date.Substring(1, date.Length - 2)); if (date.StartsWith("\\/Date(", StringComparison.OrdinalIgnoreCase) && date.EndsWith(")\\/")) return ParseDateTimeAsArrayOfDecimals(date.Substring(7, date.Length - 10)); if (date.StartsWith("/Date(", StringComparison.OrdinalIgnoreCase) && date.EndsWith(")/")) return ParseDateTimeAsArrayOfDecimals(date.Substring(6, date.Length - 8)); } } // try to parse date as a pure number: long dateValue; if (NumericHelper.TryParseInt64(text, out dateValue)) return ToDateTime(dateValue, kind); // always try to parse as ISO format, to get the result or throw a standard exception, when non-matching format given: return DateTime.Parse(text, provider, styles); }
public static DateTimeOffset? DateTimeOffsetTryParseNullable(string value, IFormatProvider provider, DateTimeStyles styles) { DateTimeOffset result; if (!DateTimeOffset.TryParse(value, provider, styles, out result)) return null; return result; }
/// <summary> /// Deserialize an object /// </summary> /// <param name="value">The object to deserialize</param> /// <param name="type">The type of object to deserialize</param> /// <param name="dateTimeStyles">The <see cref="DateTimeStyles"/> ton convert <see cref="DateTime"/> objects</param> /// <returns>A instance of <paramref name="type" /> deserialized from <paramref name="value"/></returns> public override object DeserializeObject(object value, Type type, DateTimeStyles dateTimeStyles) { var typeInfo = type.GetTypeInfo(); if (typeInfo.IsEnum || (ReflectionUtils.IsNullableType(type) && Nullable.GetUnderlyingType(type).GetTypeInfo().IsEnum)) { var typeToParse = ReflectionUtils.IsNullableType(type) ? Nullable.GetUnderlyingType(type) : type; return value == null ? null : Enum.Parse(typeToParse, value.ToString(), true); } var primitiveConverter = this.FindPrimitiveConverter(type); if (primitiveConverter != null) { return primitiveConverter.Deserialize(value, type); } var valueDictionary = value as IDictionary<string, object>; if (valueDictionary == null) { return base.DeserializeObject(value, type, dateTimeStyles); } var javascriptConverter = this.FindJavaScriptConverter(type); if (javascriptConverter != null) { return javascriptConverter.Deserialize(valueDictionary, type); } if (!typeInfo.IsGenericType) { return base.DeserializeObject(value, type, dateTimeStyles); } var genericType = typeInfo.GetGenericTypeDefinition(); var genericTypeConverter = this.FindJavaScriptConverter(genericType); if (genericTypeConverter == null) { return base.DeserializeObject(value, type, dateTimeStyles); } var values = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase); var genericArguments = type.GetGenericArguments(); for (var i = 0; i < genericArguments.Length; i++) { var deserializedObject = this.DeserializeObject(valueDictionary.Values.ElementAt(i), genericArguments[i], dateTimeStyles); values.Add(valueDictionary.Keys.ElementAt(i), deserializedObject); } return genericTypeConverter.Deserialize(values, type); }
public static bool IsDate(string date, string format, IFormatProvider provider, DateTimeStyles styles) { if (string.IsNullOrEmpty(date)) { return false; } DateTime minValue = DateTime.MinValue; return DateTime.TryParseExact(date, format, provider, styles, out minValue); }
public static DateTimeOffset? DateTimeOffsetTryParseExactNullable( string value, IEnumerable<string> formats, IFormatProvider provider, DateTimeStyles styles) { DateTimeOffset result; if (!DateTimeOffset.TryParseExact(value, formats.ToArray(), provider, styles, out result)) return null; return result; }
internal static DateTime ParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style) { DateTimeResult result = new DateTimeResult(); // The buffer to store the parsing result. result.Init(); if (TryParseExact(s, format, dtfi, style, ref result)) { return result.parsedDate; } else { throw GetDateTimeParseException(ref result); } }
internal static bool TryParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result) { result = DateTime.MinValue; DateTimeResult resultData = new DateTimeResult(); // The buffer to store the parsing result. resultData.Init(); if (TryParseExact(s, format, dtfi, style, ref resultData)) { result = resultData.parsedDate; return true; } return false; }
/// <summary> /// Converts the specified string representation of a date and time to its <see cref="DateTime" /> equivalent using the /// specified culture-specific format information and formatting style, and returns a value that indicates whether the /// conversion succeeded. /// </summary> /// <exception cref="ArgumentNullException">The value can not be null.</exception> /// <exception cref="ArgumentNullException">The format provider can not be null.</exception> /// <param name="value">A <see cref="String" /> containing a date and time to convert.</param> /// <param name="formatProvider"> /// An object that supplies culture-specific formatting information about /// <paramref name="value" />. /// </param> /// <param name="dateTimeStyle"> /// A bitwise combination of enumeration values that defines how to interpret the parsed date in relation to the /// current time zone or the current date. /// A typical value to specify is <see cref="DateTimeStyles.None" />. /// </param> /// <param name="result"> /// When this method returns, contains the <see cref="DateTime" /> value equivalent to the date and time contained in /// <paramref name="value" />, if the conversion succeeded, or /// <see cref="DateTime.MinValue" /> if the conversion failed. The conversion fails if the <paramref name="value" /> /// parameter is /// <value>null</value> /// , is an empty string (""), /// or does not contain a valid string representation of a date and time. This parameter is passed uninitialized. /// </param> /// <returns> /// <value>true</value> /// if the s parameter was converted successfully; otherwise, /// <value>false</value> /// . /// </returns> public static Boolean TryParsDateTime( this String value, IFormatProvider formatProvider, DateTimeStyles dateTimeStyle, out DateTime result ) { value.ThrowIfNull( nameof( value ) ); formatProvider.ThrowIfNull( nameof( formatProvider ) ); return DateTime.TryParse( value, formatProvider, dateTimeStyle, out result ); }
/// <remarks> /// This method uses the /// <see cref="DateTime.Parse(string,IFormatProvider,DateTimeStyles)"/> /// method to convert the "state" into its <see cref="Guid"/>. Exceptions /// throwed by this method will be propagated to the caller. /// </remarks> public virtual bool StateByName(string name, DateTimeStyles styles, out DateTime state) { string s; if (StateByName(name, out s)) { state = DateTime.Parse(s, null, styles); return true; } state = DateTime.MinValue; return false; }
/// <summary> /// Converts the specified string representation of a date and time to its DateTime equivalent using the specified /// format, /// culture-specific format information, and style. /// The format of the string representatiomust match the specified format exactly. /// The method returns a value that indicates whether the conversion succeeded. /// </summary> /// <exception cref="ArgumentNullException">value can not be null.</exception> /// <exception cref="ArgumentNullException">format can not be null.</exception> /// <exception cref="ArgumentNullException">format provider can not be null.</exception> /// <param name="value">A <see cref="String" /> containing a date and time to convert.</param> /// <param name="format">The required format of s. See the Remarks section for more information.</param> /// <param name="formatProvider"> /// An object that supplies culture-specific formatting information about /// <paramref name="value" />. /// </param> /// <param name="dateTimeStyle"> /// A bitwise combination of one or more enumeration values that indicate the permitted format /// of <paramref name="value" />. /// </param> /// <param name="outValue"> /// When this method returns, contains the s<see cref="DateTime" /> value equivalent to the date and time contained in /// <paramref name="value" />, /// if the conversion succeeded, or <see cref="DateTime.MinValue" /> if the conversion failed. /// The conversion fails if either the s or format parameter is null, is an empty string, or does not contain a date /// and time that correspond to the pattern specified in format. /// This parameter is passed uninitialized. /// </param> /// <returns>Returns true if the parsing was successful, otherwise false.</returns> public static Boolean TryParsDateTimeExact( this String value, String format, IFormatProvider formatProvider, DateTimeStyles dateTimeStyle, out DateTime outValue ) { value.ThrowIfNull( nameof( value ) ); format.ThrowIfNull( nameof( format ) ); formatProvider.ThrowIfNull( nameof( formatProvider ) ); return DateTime.TryParseExact( value, format, formatProvider, dateTimeStyle, out outValue ); }
/// <summary> /// Convert from java based date to DateTime. /// </summary> private static DateTime FromParsedDate(Date value, string originalString, DateTimeStyles style, DateFormat formatter, bool forceRoundtripKind, bool useUtc) { bool assumeLocal = (style & DateTimeStyles.AssumeLocal) != 0; bool assumeUtc = useUtc || (style & DateTimeStyles.AssumeUniversal) != 0; bool roundtripKind = forceRoundtripKind || (style & DateTimeStyles.RoundtripKind) != 0; var millis = value.Time; var ticks = (millis + DateTime.EraDifferenceInMs) * TimeSpan.TicksPerMillisecond; //long offset = 0L; DateTimeKind kind; if (roundtripKind) { var tz = formatter.TimeZone; if(tz.RawOffset == 0 || originalString.EndsWith("Z")) kind = DateTimeKind.Utc; else if(tz.RawOffset == TimeZone.Default.RawOffset) kind = DateTimeKind.Local; else kind = DateTimeKind.Unspecified; } else if (assumeUtc) { kind = DateTimeKind.Utc; } else if (assumeLocal) { kind = DateTimeKind.Local; } else { kind = DateTimeKind.Unspecified; } DateTime result; if (millis == DateTime.MinValueJavaMillies) result = new DateTime(0L, kind); else { result = new DateTime(ticks, kind); } if ((style & DateTimeStyles.AdjustToUniversal) != 0) result = result.ToUniversalTime(); else if (assumeUtc) // no typo, but bad naming/semantics in the BCL result = result.ToLocalTime(); return result; }
internal static DateTime ParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, out TimeSpan offset) { DateTimeResult result = new DateTimeResult(); // The buffer to store the parsing result. offset = TimeSpan.Zero; result.Init(); result.flags |= ParseFlags.CaptureOffset; if (TryParseExact(s, format, dtfi, style, ref result)) { offset = result.timeZoneOffset; return result.parsedDate; } else { throw GetDateTimeParseException(ref result); } }
public static bool TryParse(string s, DateTimeFormatInfo dateTimeFormatInfo, DateTimeStyles dateTimeStyles, out SystemDateTime dateTime) { try { dateTime = SystemDateTime.Parse(s, dateTimeFormatInfo, dateTimeStyles); return true; } catch (FormatException) { dateTime = SystemDateTime.MinValue; return false; } }
internal static bool TryParseExact(String s, String format, DateTimeFormatInfo dtfi, DateTimeStyles style, out DateTime result, out TimeSpan offset) { result = DateTime.MinValue; offset = TimeSpan.Zero; DateTimeResult resultData = new DateTimeResult(); // The buffer to store the parsing result. resultData.Init(); resultData.flags |= ParseFlags.CaptureOffset; if (TryParseExact(s, format, dtfi, style, ref resultData)) { result = resultData.parsedDate; offset = resultData.timeZoneOffset; return true; } return false; }
internal static bool TryParseExact(String s, String format, IFormatProvider provider, DateTimeStyles style, out DateTime result) { DateTimeFormatInfo dtfi = provider == null ? DateTimeFormatInfo.CurrentInfo : DateTimeFormatInfo.GetInstance(provider); result = DateTime.MinValue; DateTimeResult resultData = new DateTimeResult(); // The buffer to store the parsing result. resultData.Init(); if (TryParseExact(s, format, dtfi, style, ref resultData)) { result = resultData.parsedDate; return true; } return false; }
/// <summary> /// Converts the given string to a date time value. /// </summary> /// <exception cref="ArgumentNullException">The value can not be null.</exception> /// <exception cref="ArgumentNullException">The format provider can not be null.</exception> /// <param name="value">The string to convert.</param> /// <param name="formatProvider">The format provider.</param> /// <param name="dateTimeStyle">The date time style.</param> /// <param name="defaultValue">The default value, returned if the parsing fails.</param> /// <returns>The date time value.</returns> public static DateTime SaveToDateTime( this String value, IFormatProvider formatProvider, DateTimeStyles dateTimeStyle, DateTime? defaultValue = null ) { value.ThrowIfNull( nameof( value ) ); formatProvider.ThrowIfNull( nameof( formatProvider ) ); DateTime outValue; return value.TryParsDateTime( formatProvider, dateTimeStyle, out outValue ) ? outValue : ( defaultValue ?? outValue ); }
internal static DateTime ParseExact(String s, String format, IFormatProvider provider, DateTimeStyles style) { DateTimeFormatInfo dtfi = provider == null ? DateTimeFormatInfo.CurrentInfo : DateTimeFormatInfo.GetInstance(provider); DateTimeResult result = new DateTimeResult(); // The buffer to store the parsing result. result.Init(); if (TryParseExact(s, format, dtfi, style, ref result)) { return result.parsedDate; } else { throw GetDateTimeParseException(ref result); } }
/// <summary> /// Initializes a new <see cref="DateTimeFormat"/> with the specified /// formatString and formatProvider. /// </summary> /// <param name="formatString">Specifies the formatString to be used.</param> /// <param name="formatProvider">Specifies the formatProvider to be used.</param> public DateTimeFormat(string formatString, IFormatProvider formatProvider) { if (formatString == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("formatString"); } if (formatProvider == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("formatProvider"); } _formatString = formatString; _formatProvider = formatProvider; _dateTimeStyles = DateTimeStyles.RoundtripKind; }
public ParseBehaviorAttribute( string cultureName, NumberStyles numberStyle, DateTimeStyles dateTimeStyle, string dateTimeFormat, string pattern, int length ) { CultureName = cultureName; NumberStyle = numberStyle; DateTimeStyle = dateTimeStyle; DateTimeFormat = dateTimeFormat; Pattern = pattern; Length = length; }
/// <param name="format">The format to use for the conversion.</param> /// <param name="dateTimeFormatInfo">The <see cref="System.Globalization.DateTimeFormatInfo"/> that this <see cref="DateTimeConversionRule"/> uses to convert with.</param> /// <param name="dateTimeStyles">The <see cref="System.Globalization.DateTimeStyles"/> that this <see cref="DateTimeConversionRule"/> uses to convert with.</param> public DateTimeConversionRule(string format, DateTimeFormatInfo dateTimeFormatInfo, DateTimeStyles dateTimeStyles) : base(TypePointers.StringType) { Format = format; if (dateTimeFormatInfo == null) { DateTimeFormatInfo = DateTimeFormatInfo.CurrentInfo; } else { DateTimeFormatInfo = dateTimeFormatInfo; } DateTimeStyles = dateTimeStyles; }
/// <summary> /// Tries to convert the string FTP date representation into a date time object /// </summary> /// <param name="date">The date</param> /// <param name="style">UTC/Local Time</param> /// <returns>A date time object representing the date, DateTime.MinValue if there was a problem</returns> public static DateTime GetFtpDate(this string date, DateTimeStyles style) { string[] formats = new string[] { "yyyyMMddHHmmss", "yyyyMMddHHmmss.fff", "MMM dd yyyy", "MMM dd HH:mm" }; DateTime parsed; if (DateTime.TryParseExact(date, formats, CultureInfo.InvariantCulture, style, out parsed)) { return parsed; } return DateTime.MinValue; }
/// <summary> /// Tries to convert the string FTP date representation into a date time object /// </summary> /// <param name="date">The date</param> /// <param name="style">UTC/Local Time</param> /// <returns>A date time object representing the date, DateTime.MinValue if there was a problem</returns> public static DateTime GetFtpDate(this string date, DateTimeStyles style) { var formats = new[] { "yyyyMMddHHmmss", "yyyyMMddHHmmss.fff", "MMM dd yyyy", "MMM dd yyyy", "MMM dd HH:mm", "MMM d HH:mm", "YYYY-MM-DD-HH:mm" }; DateTime parsed; return DateTime.TryParseExact(date, formats, CultureInfo.InvariantCulture, style, out parsed) || DateTime.TryParseExact(date, formats, CultureInfo.CurrentUICulture, style, out parsed) ? parsed : DateTime.MinValue; }
/// <summary> /// Tries to parse a datetime value from the string. /// </summary> /// <param name="dateTimeString">string to parse</param> /// <param name="useXmlConversion">if true, uses XmlConvert. else, uses JSON.</param> /// <returns>value if found, otherwise null.</returns> public static DateTime? TryGetDateTimeValue(string dateTimeString, bool useXmlConversion = false, IFormatProvider formatter = null, DateTimeStyles parserStyles = DateTimeStyles.None) { DateTime? value = null; if (!string.IsNullOrEmpty(dateTimeString)) { try { if (useXmlConversion) { value = XmlConvert.ToDateTimeOffset(dateTimeString).DateTime; } else { DateTime parsed; if (formatter != null && parserStyles != DateTimeStyles.None) { if (DateTime.TryParse(dateTimeString, formatter, parserStyles, out parsed)) { value = parsed; } } else { if (DateTime.TryParse(dateTimeString, out parsed)) { value = parsed; } } } } catch (ArgumentNullException ex) { Debug.Fail(ex.ToString()); } catch (FormatException ex) { Debug.Fail(ex.ToString()); } } return value; }
public static bool TryParse(string input, IFormatProvider provider, DateTimeStyles styles, out DateTime result) { bool success = false; try { result = DateTime.Parse(input, provider, styles); success = true; } catch (FormatException) { result = new DateTime(); } catch (InvalidCastException) { result = new DateTime(); } return success; }
private static DateTime ParseDateTime(string dateToParse, DateTime defaultDateTime, DateTimeFormatInfo formatInfo, DateTimeStyles style, string context) { DateTime DT; if (DateTime.TryParse(dateToParse, formatInfo, style, out DT)) { return(DT); } CultureInfo defaultCulture = CultureInfo.CurrentCulture; if (DateTime.TryParse(dateToParse, out DT)) { return(DT); } Debug.LogError("Date Time: " + dateToParse + " Failed to parse correctly, resetting to defualt value: " + defaultDateTime + " Context: " + context + " Current culture: " + CultureInfo.CurrentCulture.Name); return(defaultDateTime); }
/// <summary> /// The <see cref="DateTimeStyles"/> to use when type converting. /// This is used when doing any <see cref="DateTime"/> conversions. /// </summary> /// <param name="dateTimeStyles">The date time styles.</param> public DateTimeStylesAttribute(DateTimeStyles dateTimeStyles) { DateTimeStyles = dateTimeStyles; }
public static bool TryParseExact( ReadOnlySpan <char> input, string?[]?formats, IFormatProvider?formatProvider, DateTimeStyles styles, out DateTimeOffset result) { styles = ValidateStyles(styles, nameof(styles)); bool parsed = DateTimeParse.TryParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out DateTime dateResult, out TimeSpan offset); result = new DateTimeOffset(dateResult.Ticks, offset); return(parsed); }
public NullableDateTimeConverter(string dateTimeFormat, IFormatProvider formatProvider, DateTimeStyles dateTimeStyles) : base(new DateTimeConverter(dateTimeFormat, formatProvider, dateTimeStyles)) { }
// Currently, custom format and normal date time format except 'o' or 'O' 's' are NOT supported. public static TimestampParseResult TryParseExact(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles, out Timestamp result) { if (format != "o" && format != "O" && format != "s") { result = default(Timestamp); return(TimestampParseResult.UnsupportedFormat); } var numberFormat = NumberFormatInfo.GetInstance(formatProvider); var position = 0; if (!ParseWhitespace(input, ref position, (styles & DateTimeStyles.AllowLeadingWhite) != 0, /* isTrailing */ false)) { result = default(Timestamp); return(TimestampParseResult.LeadingWhitespaceNotAllowed); } long year; if (!ParseYear(input, ref position, numberFormat, out year)) { result = default(Timestamp); return(TimestampParseResult.InvalidYear); } if (!ParseDelimiter(input, ref position, DateDelimiter)) { result = default(Timestamp); return(TimestampParseResult.InvalidYearMonthDeilimiter); } var isLeapYear = Timestamp.IsLeapYearInternal(year); int month; if (!ParseDigitRange(input, 2, ref position, 1, 12, out month)) { result = default(Timestamp); return(TimestampParseResult.InvalidMonth); } if (!ParseDelimiter(input, ref position, DateDelimiter)) { result = default(Timestamp); return(TimestampParseResult.InvalidMonthDayDelimiter); } int day; if (!ParseDay(input, ref position, month, isLeapYear, out day)) { result = default(Timestamp); return(TimestampParseResult.InvalidDay); } if (!ParseDelimiter(input, ref position, DateTimeDelimiter)) { result = default(Timestamp); return(TimestampParseResult.InvalidDateTimeDelimiter); } int hour; if (!ParseDigitRange(input, 2, ref position, 0, 23, out hour)) { result = default(Timestamp); return(TimestampParseResult.InvalidHour); } if (!ParseDelimiter(input, ref position, TimeDelimiter)) { result = default(Timestamp); return(TimestampParseResult.InvalidHourMinuteDelimiter); } int minute; if (!ParseDigitRange(input, 2, ref position, 0, 59, out minute)) { result = default(Timestamp); return(TimestampParseResult.InvalidMinute); } if (!ParseDelimiter(input, ref position, TimeDelimiter)) { result = default(Timestamp); return(TimestampParseResult.InvalidMinuteSecondDelimiter); } int second; if (!ParseDigitRange(input, 2, ref position, 0, 59, out second)) { result = default(Timestamp); return(TimestampParseResult.InvalidSecond); } var nanosecond = 0; if (format != "s") { // "o" or "O" if (!ParseDelimiter(input, ref position, SubsecondDelimiter)) { result = default(Timestamp); return(TimestampParseResult.InvalidSubsecondDelimiter); } if (!ParseDigitRange(input, 9, ref position, 0, 999999999, out nanosecond)) { result = default(Timestamp); return(TimestampParseResult.InvalidNanoSecond); } } if (!ParseDelimiter(input, ref position, UtcSign)) { result = default(Timestamp); return(TimestampParseResult.MissingUtcSign); } if (!ParseWhitespace(input, ref position, (styles & DateTimeStyles.AllowTrailingWhite) != 0, /* isTrailing */ true)) { result = default(Timestamp); return(TimestampParseResult.TrailingWhitespaceNotAllowed); } if (position != input.Length) { result = default(Timestamp); return(TimestampParseResult.ExtraCharactors); } var components = new Timestamp.Value(); components.Year = year; components.Month = month; components.Day = day; components.Hour = hour; components.Minute = minute; components.Second = second; components.Nanoseconds = unchecked (( uint )nanosecond); try { result = Timestamp.FromComponents(ref components, isLeapYear); } catch (OverflowException) { result = default(Timestamp); return(TimestampParseResult.YearOutOfRange); } return(TimestampParseResult.Success); }
public static DateTimeOffset ParseExact(string input, string[] formats, IFormatProvider?formatProvider, DateTimeStyles styles) { styles = ValidateStyles(styles, nameof(styles)); if (input == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input); } TimeSpan offset; DateTime dateResult = DateTimeParse.ParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out offset); return(new DateTimeOffset(dateResult.Ticks, offset)); }
public static DateTime?ToNullableDateTime(this object objeto, CultureInfo culture, DateTimeStyles style = DateTimeStyles.None, bool enableError = false) { try { DateTime?saida = null; if (DateTime.TryParse(objeto?.ToString(), culture, style, out DateTime teste)) { saida = teste; } else if (enableError) { throw new Exception("A conversão falhou!"); } return(saida); } catch (Exception ex) { throw ex; } }
public static DateTimeOffset ParseExact(String input, String[] formats, IFormatProvider formatProvider, DateTimeStyles styles) { styles = ValidateStyles(styles, nameof(styles)); TimeSpan offset; DateTime dateResult = DateTimeParse.ParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out offset); return(new DateTimeOffset(dateResult.Ticks, offset)); }
public static bool TryParseExact(string?input, string?[]?formats, IFormatProvider?formatProvider, DateTimeStyles styles, out DateTimeOffset result) { styles = ValidateStyles(styles, nameof(styles)); if (input == null) { result = default; return(false); } TimeSpan offset; DateTime dateResult; bool parsed = DateTimeParse.TryParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out dateResult, out offset); result = new DateTimeOffset(dateResult.Ticks, offset); return(parsed); }
public DateTimeOffset?Parse(IFormatProvider provider, DateTimeStyles styles = DateTimeStyles.AllowWhiteSpaces) { return(DateTimeStringParser.DateTimeOffsetTryParseNullable(_input, provider, styles)); }
ValueTask <DateTimeOffset> IAsyncBinaryReader.ReadDateTimeOffsetAsync(StringLengthEncoding lengthFormat, DecodingContext context, string[] formats, DateTimeStyles style, IFormatProvider?provider, CancellationToken token) => EndOfStream <DateTimeOffset>();
public static void ParseExact_Span_ValidInput_Succeeds(string input, string format, CultureInfo culture, DateTimeStyles style, DateTime?expected) { DateTime result1 = DateTime.ParseExact(input.AsReadOnlySpan(), format, culture, style); DateTime result2 = DateTime.ParseExact(input.AsReadOnlySpan(), new[] { format }, culture, style); Assert.True(DateTime.TryParseExact(input.AsReadOnlySpan(), format, culture, style, out DateTime result3)); Assert.True(DateTime.TryParseExact(input.AsReadOnlySpan(), new[] { format }, culture, style, out DateTime result4)); Assert.Equal(result1, result2); Assert.Equal(result1, result3); Assert.Equal(result1, result4); if (expected != null) // some inputs don't roundtrip well { // Normalize values to make comparison easier if (expected.Value.Kind != DateTimeKind.Utc) { expected = expected.Value.ToUniversalTime(); } if (result1.Kind != DateTimeKind.Utc) { result1 = result1.ToUniversalTime(); } Assert.Equal(expected, result1); } }
public static void ParseExact_Span_InvalidInputs_Fail(string input, string format, CultureInfo culture, DateTimeStyles style) { Assert.Throws <FormatException>(() => DateTime.ParseExact(input.AsReadOnlySpan(), format, culture, style)); Assert.Throws <FormatException>(() => DateTime.ParseExact(input.AsReadOnlySpan(), new[] { format }, culture, style)); Assert.False(DateTime.TryParseExact(input.AsReadOnlySpan(), format, culture, style, out DateTime result)); Assert.False(DateTime.TryParseExact(input.AsReadOnlySpan(), new[] { format }, culture, style, out result)); }
public DateTimeOffset?ParseInvariant(DateTimeStyles styles = DateTimeStyles.AllowWhiteSpaces) { return(Parse(CultureInfo.InvariantCulture, styles)); }
public static bool TryParseExact([NotNullWhen(true)] string?input, [NotNullWhen(true)] string?format, IFormatProvider?formatProvider, DateTimeStyles styles, out DateTimeOffset result) { styles = ValidateStyles(styles, nameof(styles)); if (input == null || format == null) { result = default; return(false); } bool parsed = DateTimeParse.TryParseExact(input, format, DateTimeFormatInfo.GetInstance(formatProvider), styles, out DateTime dateResult, out TimeSpan offset); result = new DateTimeOffset(dateResult.Ticks, offset); return(parsed); }
static public DateTime ParseDateTime(this string s, DateTime def, CultureInfo ci, DateTimeStyles ds = DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal) { DateTime ret; if (!DateTime.TryParse(s, ci, ds, out ret)) { ret = def; } return(ret); }
public void EnumNames_MatchExpectedValues(DateTimeStyles style, ulong expected) { Assert.Equal(expected, (ulong)style); }
public DateTimeOffset?ParseExact(IEnumerable <string> formats, IFormatProvider provider, DateTimeStyles styles = DateTimeStyles.AllowWhiteSpaces) { return(DateTimeStringParser.DateTimeOffsetTryParseExactNullable(_input, formats, provider, styles)); }
public static DateTime?ParseDate(this string str, string format, IFormatProvider provider = null, DateTimeStyles style = DateTimeStyles.AssumeLocal) => DateTime.TryParseExact(str, format, provider ?? CultureInfo.CurrentCulture, style, out var i) ? i : (DateTime?)null;
/// <summary> /// 是否日期 /// </summary> /// <param name="value">日期字符串</param> /// <param name="format">格式化字符串</param> /// <param name="provider">格式化提供者</param> /// <param name="styles">日期格式</param> /// <returns></returns> public static bool IsDate(string value, string format, IFormatProvider provider, DateTimeStyles styles) { if (value.IsEmpty()) { return(false); } DateTime minValue; return(DateTime.TryParseExact(value, format, provider, styles, out minValue)); }
/// <summary> /// Constructs a MobileProvision from an xml blob extracted from the real ASN.1 file /// </summary> public MobileProvision(string EmbeddedPListText) { Data = new Utilities.PListHelper(EmbeddedPListText); // Now extract things // Key: ApplicationIdentifierPrefix, Array<String> List <string> PrefixList = Data.GetArray("ApplicationIdentifierPrefix", "string"); if (PrefixList.Count > 1) { Program.Warning("Found more than one entry for ApplicationIdentifierPrefix in the .mobileprovision, using the first one found"); } if (PrefixList.Count > 0) { ApplicationIdentifierPrefix = PrefixList[0]; } // Example date string from the XML: "2014-06-30T20:45:55Z"; DateTimeStyles AppleDateStyle = DateTimeStyles.AllowWhiteSpaces | DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal; string CreationDateString; if (Data.GetDate("CreationDate", out CreationDateString)) { CreationDate = DateTime.Parse(CreationDateString, CultureInfo.InvariantCulture, AppleDateStyle); } string ExpirationDateString; if (Data.GetDate("ExpirationDate", out ExpirationDateString)) { ExpirationDate = DateTime.Parse(ExpirationDateString, CultureInfo.InvariantCulture, AppleDateStyle); } // Key: DeveloperCertificates, Array<Data> (uuencoded) string CertificatePassword = ""; List <string> CertificateList = Data.GetArray("DeveloperCertificates", "data"); foreach (string EncodedCert in CertificateList) { byte[] RawCert = Convert.FromBase64String(EncodedCert); DeveloperCertificates.Add(new X509Certificate2(RawCert, CertificatePassword)); } // Key: Name, String if (!Data.GetString("Name", out ProvisionName)) { ProvisionName = "(unknown)"; } // Key: ProvisionedDevices, Array<String> ProvisionedDeviceIDs = Data.GetArray("ProvisionedDevices", "string"); // Key: application-identifier, Array<String> Utilities.PListHelper XCentPList = null; Data.ProcessValueForKey("Entitlements", "dict", delegate(XmlNode ValueNode) { XCentPList = Utilities.PListHelper.CloneDictionaryRootedAt(ValueNode); }); // Modify the application-identifier to be fully qualified if needed if (!XCentPList.GetString("application-identifier", out ApplicationIdentifier)) { ApplicationIdentifier = "(unknown)"; } // check for get-task-allow bDebug = XCentPList.GetBool("get-task-allow"); if (!Data.GetString("UUID", out UUID)) { UUID = "(unkown)"; } List <string> Platforms = Data.GetArray("Platform", "string"); if (Platforms.Contains("iOS")) { Platform = "IOS"; } else if (Platforms.Contains("tvOS")) { Platform = "TVOS"; } else { Platform = ""; } }
public static DateTimeOffset ParseExact(ReadOnlySpan <char> input, string[] formats, IFormatProvider?formatProvider, DateTimeStyles styles = DateTimeStyles.None) { styles = ValidateStyles(styles, nameof(styles)); DateTime dateResult = DateTimeParse.ParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out TimeSpan offset); return(new DateTimeOffset(dateResult.Ticks, offset)); }
public static IOption <DateTime> ToDateTime(this string s, IFormatProvider format = null, DateTimeStyles style = DateTimeStyles.None) { return(Tryer.Invoke <string, IFormatProvider, DateTimeStyles, DateTime>(DateTime.TryParse, s, format, style)); }
private static DateTimeOffset ToDateTimeOffsetInternal(object value, IFormatProvider provider, DateTimeStyles styles) { if (value is DateTime) { return((DateTimeOffset)value); } return(DateTimeOffset.Parse(value.ToString(), provider, styles)); }
public DateTimeOffset?ParseExactInvariant(string format, DateTimeStyles styles = DateTimeStyles.AllowWhiteSpaces) { return(ParseExact(format, CultureInfo.InvariantCulture, styles)); }
public static DateTime AsDateTimeFormat(this string val, DateTime dflt, string fmt, DateTimeStyles fmtStyles = DateTimeStyles.None) { DateTime result; return(DateTime.TryParseExact(val, fmt, null, fmtStyles, out result) ? result : dflt); }
public DateTimeOffset?ParseExactInvariant(IEnumerable <string> formats, DateTimeStyles styles = DateTimeStyles.AllowWhiteSpaces) { return(ParseExact(formats, CultureInfo.InvariantCulture, styles)); }
/// <summary> /// Converts given string to <see cref="DateTime"/> or returns <paramref name="defaultValue"/> /// </summary> /// <param name="s"></param> /// <param name="style"></param> /// <param name="provider"></param> /// <param name="defaultValue"></param> /// <returns></returns> public static DateTime ToDate(this string s, DateTimeStyles style, IFormatProvider provider, DateTime defaultValue = default) { return(DateTime.TryParse(s, provider, style, out DateTime res) ? res : defaultValue); }
public DateTimeOffset?ParseCulture(DateTimeStyles styles = DateTimeStyles.AllowWhiteSpaces) { return(Parse(CultureInfo.CurrentCulture, styles)); }
public static Boolean TryParseExact(String input, String[] formats, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result) { styles = ValidateStyles(styles, nameof(styles)); TimeSpan offset; DateTime dateResult; Boolean parsed = DateTimeParse.TryParseExactMultiple(input, formats, DateTimeFormatInfo.GetInstance(formatProvider), styles, out dateResult, out offset); result = new DateTimeOffset(dateResult.Ticks, offset); return(parsed); }
/// <summary> /// Initializes a new instance of the <see cref="GlobalizationConfiguration"/> class /// </summary> /// <param name="supportedCultureNames">An array of supported cultures</param> /// <param name="defaultCulture">The default culture of the application</param> /// <param name="dateTimeStyles">The <see cref="DateTimeStyles"/> that should be used for date parsing.</param> public GlobalizationConfiguration(IEnumerable<string> supportedCultureNames, string defaultCulture = null, DateTimeStyles? dateTimeStyles = null) { if (supportedCultureNames == null) { throw new ConfigurationException("Invalid Globalization configuration. You must support at least one culture"); } supportedCultureNames = supportedCultureNames.Where(cultureName => !string.IsNullOrEmpty(cultureName)).ToArray(); if (!supportedCultureNames.Any()) { throw new ConfigurationException("Invalid Globalization configuration. You must support at least one culture"); } if (string.IsNullOrEmpty(defaultCulture)) { defaultCulture = supportedCultureNames.First(); } if (!supportedCultureNames.Contains(defaultCulture, StringComparer.OrdinalIgnoreCase)) { throw new ConfigurationException("Invalid Globalization configuration. " + defaultCulture + " does not exist in the supported culture names"); } this.DateTimeStyles = dateTimeStyles ?? Default.DateTimeStyles; this.DefaultCulture = defaultCulture; this.SupportedCultureNames = supportedCultureNames; }