private Options(bool pretty = false, bool excludeNulls = false, bool jsonp = false, DateTimeFormat dateFormat = DateTimeFormat.NewtonsoftStyleMillisecondsSinceUnixEpoch) { ShouldPrettyPrint = pretty; ShouldExcludeNulls = excludeNulls; IsJSONP = jsonp; UseDateTimeFormat = dateFormat; }
/// <summary> /// Configuration for Jil serialization options. /// /// Available options: /// prettyPrint - whether or not to include whitespace and newlines for ease of reading /// excludeNulls - whether or not to write object members whose value is null /// jsonp - whether or not the serialized json should be valid for use with JSONP /// dateFormat - the style in which to serialize DateTimes /// includeInherited - whether or not to serialize members declared by an objects base types /// allowHashFunction - whether or not Jil should try to use hashes instead of strings when deserializing object members, malicious content may be able to force member collisions if this is enabled /// </summary> public Options(bool prettyPrint = false, bool excludeNulls = false, bool jsonp = false, DateTimeFormat dateFormat = DateTimeFormat.NewtonsoftStyleMillisecondsSinceUnixEpoch, bool includeInherited = false, bool allowHashFunction = true) { ShouldPrettyPrint = prettyPrint; ShouldExcludeNulls = excludeNulls; IsJSONP = jsonp; UseDateTimeFormat = dateFormat; ShouldIncludeInherited = includeInherited; AllowHashFunction = allowHashFunction; }
public XmlObjectSerializerReadContextComplexJson(DataContractJsonSerializer serializer, DataContract rootTypeDataContract) : base(serializer, serializer.MaxItemsInObjectGraph, new StreamingContext(StreamingContextStates.All), serializer.IgnoreExtensionDataObject) { this.rootTypeDataContract = rootTypeDataContract; this.serializerKnownTypeList = serializer.knownTypeList; this.dataContractSurrogate = serializer.DataContractSurrogate; this.dateTimeFormat = serializer.DateTimeFormat; this.useSimpleDictionaryFormat = serializer.UseSimpleDictionaryFormat; }
/// <summary> /// Format objectDateTime according to the format enum. "[error]" if the value is invalid. /// </summary> /// <param name="dateTimeInstance"> /// The yaf date time. /// </param> /// <param name="format"> /// The format. /// </param> /// <param name="objectDateTime"> /// The object date time. /// </param> /// <returns> /// Formatted datetime or "[error]" if invalid. /// </returns> public static string Format([NotNull] this IDateTime dateTimeInstance, DateTimeFormat format, [NotNull] object objectDateTime) { CodeContracts.VerifyNotNull(dateTimeInstance, "dateTimeInstance"); CodeContracts.VerifyNotNull(objectDateTime, "objectDateTime"); try { DateTime dateTime = Convert.ToDateTime(objectDateTime); switch (format) { case DateTimeFormat.BothDateShort: return dateTimeInstance.FormatDateTimeShort(dateTime); case DateTimeFormat.BothTopic: return dateTimeInstance.FormatDateTimeTopic(dateTime); case DateTimeFormat.DateLong: return dateTimeInstance.FormatDateLong(dateTime); case DateTimeFormat.DateShort: return dateTimeInstance.FormatDateShort(dateTime); case DateTimeFormat.Time: return dateTimeInstance.FormatTime(dateTime); case DateTimeFormat.Both: default: return dateTimeInstance.FormatDateTime(dateTime); } } catch { } // failed convert... return "[error]"; }
/// <summary>Converts the given DateTime value to a string using the given summary desired format</summary> /// <param name="dt">Specifies the DateTime value to convert</param> /// <param name="dtFormat">Specifies the desired format from the set of supported enum values.</param> /// <returns>The DateTime converted to a string based on the desired format.</returns> public static string CvtToString(ref DateTime dt, DateTimeFormat dtFormat) { string result = string.Empty; switch (dtFormat) { default: case DateTimeFormat.LogDefault: result = Fcns.CheckedFormat("{0}-{1}-{2} {3}:{4}:{5}.{6}", dt.Year.ToString("D4"), dt.Month.ToString("D2"), dt.Day.ToString("D2"), dt.Hour.ToString("D2"), dt.Minute.ToString("D2"), dt.Second.ToString("D2"), dt.Millisecond.ToString("D3")); break; case DateTimeFormat.ShortWithMSec: result = Fcns.CheckedFormat("{0}{1}{2}_{3}{4}{5}.{6}", dt.Year.ToString("D4"), dt.Month.ToString("D2"), dt.Day.ToString("D2"), dt.Hour.ToString("D2"), dt.Minute.ToString("D2"), dt.Second.ToString("D2"), dt.Millisecond.ToString("D3")); break; } return result; }
/// <summary> /// Tries to find time within the passed string and return it as DateTime structure. /// It recognizes only time while ignoring date, so date in the returned DateTime is always 1/1/1. /// </summary> /// <param name="str">string that contains time</param> /// <param name="default_format">format that must be used preferably in ambivalent instances</param> /// <param name="time">parsed time output</param> /// <returns>true if time was found, else false</returns> public static bool TryParseTime(string str, DateTimeFormat default_format, out System.DateTime time) { lock (lock_variable) { ParsedDateTime parsed_time; if (!TryParseTime(str, default_format, out parsed_time, null)) { time = new System.DateTime(1, 1, 1); return false; } time = parsed_time.DateTime; return true; } }
/// <summary> /// Converts datetime to string per portal /// </summary> public abstract string DateTimeToString(DateTime dt, DateTimeFormat format = DateTimeFormat.LongDateTime, ISession session = null);
/// <summary> /// Tries to find date within the passed string and return it as DateTime structure. /// It recognizes only date while ignoring time, so time in the returned DateTime is always 0:0:0. /// If year of the date was not found then it accepts the current year. /// </summary> /// <param name="str">string that contains date</param> /// <param name="default_format">format that must be used preferably in ambivalent instances</param> /// <param name="date">parsed date output</param> /// <returns>true if date was found, else false</returns> public static bool TryParseDate(string str, DateTimeFormat default_format, out System.DateTime date) { lock (lock_variable) { ParsedDateTime parsed_date; if (!TryParseDate(str, default_format, out parsed_date)) { date = new System.DateTime(1, 1, 1); return false; } date = parsed_date.DateTime; return true; } }
private static extern int dialog_set_notification_start_date_format_elapsed(IntPtr dialog, DateTimeFormat elapsed_format);
/// <summary> /// Configuration for Jil serialization options. /// /// Available options: /// prettyPrint - whether or not to include whitespace and newlines for ease of reading /// excludeNulls - whether or not to write object members whose value is null /// jsonp - whether or not the serialized json should be valid for use with JSONP /// dateFormat - the style in which to serialize DateTimes and TimeSpans /// includeInherited - whether or not to serialize members declared by an objects base types /// unspecifiedDateTimeKindBehavior - how to treat DateTime's with a DateTimeKind of Unspecified (Jil converts all DateTimes to Utc for serialization, use DateTimeOffset to preserve time zone information) /// serializationNameFormat - how to serialize names of properties/objects unless specified explicitly by an attribute /// </summary> public Options(bool prettyPrint = false, bool excludeNulls = false, bool jsonp = false, DateTimeFormat dateFormat = DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch, bool includeInherited = false, UnspecifiedDateTimeKindBehavior unspecifiedDateTimeKindBehavior = UnspecifiedDateTimeKindBehavior.IsLocal, SerializationNameFormat serializationNameFormat = SerializationNameFormat.Verbatim) { ShouldPrettyPrint = prettyPrint; ShouldExcludeNulls = excludeNulls; IsJSONP = jsonp; #pragma warning disable 618 // upgrade from the obsolete DateTimeFormat enumeration; warning disabled to allow it, but all other references // should be expunged if (dateFormat == DateTimeFormat.NewtonsoftStyleMillisecondsSinceUnixEpoch) { dateFormat = DateTimeFormat.MicrosoftStyleMillisecondsSinceUnixEpoch; } #pragma warning restore 618 UseDateTimeFormat = dateFormat; ShouldIncludeInherited = includeInherited; UseUnspecifiedDateTimeKindBehavior = unspecifiedDateTimeKindBehavior; SerializationNameFormat = serializationNameFormat; }
/// <summary> /// Tries to find time within the passed string and return it as DateTime structure. /// It recognizes only time while ignoring date, so date in the returned DateTime is always 1/1/1. /// </summary> /// <param name="str">string that contains time</param> /// <param name="default_format">format to be used preferably in ambivalent instances</param> /// <param name="time">parsed time output</param> /// <returns>true if time was found, else false</returns> public static bool TryParseTime(this string str, DateTimeFormat default_format, out DateTime time) { ParsedDateTime parsed_time; if (!TryParseTime(str, default_format, out parsed_time, null)) { time = new DateTime(1, 1, 1); return false; } time = parsed_time.DateTime; return true; }
public override String ToString() { return(DateTimeFormat.Format(this, null, DateTimeFormatInfo.CurrentInfo)); }
public override string ToString() { return(DateTimeFormat.Format(ClockDateTime, null, null, Offset)); }
public string ToString(string format) { return(DateTimeFormat.Format(ClockDateTime, format, null, Offset)); }
public string ToString(string format) { return(DateTimeFormat.Format(this.ClockDateTime, format, DateTimeFormatInfo.CurrentInfo, this.Offset)); }
public string ToString(string format, IFormatProvider formatProvider) { return(DateTimeFormat.Format(this.ClockDateTime, format, DateTimeFormatInfo.GetInstance(formatProvider), this.Offset)); }
public override string ToString() { return(DateTimeFormat.Format(this.ClockDateTime, null, DateTimeFormatInfo.CurrentInfo, this.Offset)); }
public string ToString(string?format) => DateTimeFormat.Format(ClockDateTime, format, null, Offset);
public String ToString(String format) { return(DateTimeFormat.Format(this, format, DateTimeFormatInfo.CurrentInfo)); }
/// <summary> /// Tries to find date within the passed string and return it as ParsedDateTime object. /// It recognizes only date while ignoring time, so time in the returned ParsedDateTime is always 0:0:0. /// If year of the date was not found then it accepts the current year. /// </summary> /// <param name="str">string that contains date</param> /// <param name="default_format">format to be used preferably in ambivalent instances</param> /// <param name="parsed_date">parsed date output</param> /// <returns>true if date was found, else false</returns> public static bool TryParseDate(this string str, DateTimeFormat default_format, out ParsedDateTime parsed_date) { parsed_date = null; if (string.IsNullOrEmpty(str)) return false; //look for dd/mm/yy Match m = Regex.Match(str, @"(?<=^|[^\d])(?'day'\d{1,2})\s*(?'separator'[\\/\.])+\s*(?'month'\d{1,2})\s*\'separator'+\s*(?'year'\d{2}|\d{4})(?=$|[^\d])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (m.Success) { DateTime date; if ((default_format ^ DateTimeFormat.USA_DATE) == DateTimeFormat.USA_DATE) { if (!convert_to_date(int.Parse(m.Groups["year"].Value), int.Parse(m.Groups["day"].Value), int.Parse(m.Groups["month"].Value), out date)) return false; } else { if (!convert_to_date(int.Parse(m.Groups["year"].Value), int.Parse(m.Groups["month"].Value), int.Parse(m.Groups["day"].Value), out date)) return false; } parsed_date = new ParsedDateTime(m.Index, m.Length, -1, -1, date); return true; } //look for [yy]yy-mm-dd m = Regex.Match(str, @"(?<=^|[^\d])(?'year'\d{2}|\d{4})\s*(?'separator'[\-])\s*(?'month'\d{1,2})\s*\'separator'+\s*(?'day'\d{1,2})(?=$|[^\d])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (m.Success) { DateTime date; if (!convert_to_date(int.Parse(m.Groups["year"].Value), int.Parse(m.Groups["month"].Value), int.Parse(m.Groups["day"].Value), out date)) return false; parsed_date = new ParsedDateTime(m.Index, m.Length, -1, -1, date); return true; } //look for month dd yyyy m = Regex.Match(str, @"(?:^|[^\d\w])(?'month'Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[uarychilestmbro]*\s+(?'day'\d{1,2})(?:-?st|-?th|-?rd|-?nd)?\s*,?\s*(?'year'\d{4})(?=$|[^\d\w])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (!m.Success) //look for dd month [yy]yy m = Regex.Match(str, @"(?:^|[^\d\w:])(?'day'\d{1,2})(?:-?st\s+|-?th\s+|-?rd\s+|-?nd\s+|-|\s+)(?'month'Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[uarychilestmbro]*(?:\s*,?\s*|-)'?(?'year'\d{2}|\d{4})(?=$|[^\d\w])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (!m.Success) //look for yyyy month dd m = Regex.Match(str, @"(?:^|[^\d\w])(?'year'\d{4})\s+(?'month'Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[uarychilestmbro]*\s+(?'day'\d{1,2})(?:-?st|-?th|-?rd|-?nd)?(?=$|[^\d\w])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (!m.Success) //look for month dd hh:mm:ss MDT|UTC yyyy m = Regex.Match(str, @"(?:^|[^\d\w])(?'month'Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[uarychilestmbro]*\s+(?'day'\d{1,2})\s+\d{2}\:\d{2}\:\d{2}\s+(?:MDT|UTC)\s+(?'year'\d{4})(?=$|[^\d\w])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (!m.Success) //look for month dd [yyyy] m = Regex.Match(str, @"(?:^|[^\d\w])(?'month'Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[uarychilestmbro]*\s+(?'day'\d{1,2})(?:-?st|-?th|-?rd|-?nd)?(?:\s*,?\s*(?'year'\d{4}))?(?=$|[^\d\w])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (m.Success) { int month = -1; int index_of_date = m.Index; int length_of_date = m.Length; switch (m.Groups["month"].Value) { case "Jan": case "JAN": month = 1; break; case "Feb": case "FEB": month = 2; break; case "Mar": case "MAR": month = 3; break; case "Apr": case "APR": month = 4; break; case "May": case "MAY": month = 5; break; case "Jun": case "JUN": month = 6; break; case "Jul": month = 7; break; case "Aug": case "AUG": month = 8; break; case "Sep": case "SEP": month = 9; break; case "Oct": case "OCT": month = 10; break; case "Nov": case "NOV": month = 11; break; case "Dec": case "DEC": month = 12; break; } int year; if (!string.IsNullOrEmpty(m.Groups["year"].Value)) year = int.Parse(m.Groups["year"].Value); else year = DefaultDate.Year; DateTime date; if (!convert_to_date(year, month, int.Parse(m.Groups["day"].Value), out date)) return false; parsed_date = new ParsedDateTime(index_of_date, length_of_date, -1, -1, date); return true; } return false; }
public string ToString(string format, IFormatProvider formatProvider) { return(DateTimeFormat.Format(ClockDateTime, format, formatProvider, Offset)); }
/// <summary> /// Tries to find date and/or time within the passed string and return it as ParsedDateTime object. /// If only date was found, time in the returned ParsedDateTime is always 0:0:0. /// If only time was found, date in the returned ParsedDateTime is DefaultDate. /// </summary> /// <param name="str">string that contains date-time</param> /// <param name="default_format">format to be used preferably in ambivalent instances</param> /// <param name="parsed_date_time">parsed date-time output</param> /// <returns>true if date or time was found, else false</returns> public static bool TryParseDateOrTime(this string str, DateTimeFormat default_format, out ParsedDateTime parsed_date_time) { parsed_date_time = null; ParsedDateTime parsed_date; ParsedDateTime parsed_time; if (!TryParseDate(str, default_format, out parsed_date)) { if (!TryParseTime(str, default_format, out parsed_time, null)) return false; DateTime date_time = new DateTime(DefaultDate.Year, DefaultDate.Month, DefaultDate.Day, parsed_time.DateTime.Hour, parsed_time.DateTime.Minute, parsed_time.DateTime.Second); parsed_date_time = new ParsedDateTime(-1, -1, parsed_time.IndexOfTime, parsed_time.LengthOfTime, date_time, parsed_time.UtcOffset); } else { if (!TryParseTime(str, default_format, out parsed_time, parsed_date)) { DateTime date_time = new DateTime(parsed_date.DateTime.Year, parsed_date.DateTime.Month, parsed_date.DateTime.Day, 0, 0, 0); parsed_date_time = new ParsedDateTime(parsed_date.IndexOfDate, parsed_date.LengthOfDate, -1, -1, date_time); } else { DateTime date_time = new DateTime(parsed_date.DateTime.Year, parsed_date.DateTime.Month, parsed_date.DateTime.Day, parsed_time.DateTime.Hour, parsed_time.DateTime.Minute, parsed_time.DateTime.Second); parsed_date_time = new ParsedDateTime(parsed_date.IndexOfDate, parsed_date.LengthOfDate, parsed_time.IndexOfTime, parsed_time.LengthOfTime, date_time, parsed_time.UtcOffset); } } return true; }
public bool TryFormat(Span <char> destination, out int charsWritten, ReadOnlySpan <char> format = default, IFormatProvider formatProvider = null) => DateTimeFormat.TryFormat(ClockDateTime, destination, out charsWritten, format, formatProvider, Offset);
/// <summary> /// Tries to find time within the passed string (relatively to the passed parsed_date if any) and return it as ParsedDateTime object. /// It recognizes only time while ignoring date, so date in the returned ParsedDateTime is always 1/1/1 /// </summary> /// <param name="str">string that contains date</param> /// <param name="default_format">format to be used preferably in ambivalent instances</param> /// <param name="parsed_time">parsed date-time output</param> /// <param name="parsed_date">ParsedDateTime object if the date was found within this string, else NULL</param> /// <returns>true if time was found, else false</returns> public static bool TryParseTime(this string str, DateTimeFormat default_format, out ParsedDateTime parsed_time, ParsedDateTime parsed_date) { parsed_time = null; string time_zone_r; if (default_format == DateTimeFormat.USA_DATE) time_zone_r = @"(?:\s*(?'time_zone'UTC|GMT|CST|EST))?"; else time_zone_r = @"(?:\s*(?'time_zone'UTC|GMT))?"; Match m; if (parsed_date != null && parsed_date.IndexOfDate > -1) {//look around the found date //look for <date> hh:mm:ss <UTC offset> m = Regex.Match(str.Substring(parsed_date.IndexOfDate + parsed_date.LengthOfDate), @"(?<=^\s*,?\s+|^\s*at\s*|^\s*[T\-]\s*)(?'hour'\d{2})\s*:\s*(?'minute'\d{2})\s*:\s*(?'second'\d{2})\s+(?'offset_sign'[\+\-])(?'offset_hh'\d{2}):?(?'offset_mm'\d{2})(?=$|[^\d\w])", RegexOptions.Compiled); if (!m.Success) //look for <date> [h]h:mm[:ss] [PM/AM] [UTC/GMT] m = Regex.Match(str.Substring(parsed_date.IndexOfDate + parsed_date.LengthOfDate), @"(?<=^\s*,?\s+|^\s*at\s*|^\s*[T\-]\s*)(?'hour'\d{1,2})\s*:\s*(?'minute'\d{2})\s*(?::\s*(?'second'\d{2}))?(?:\s*(?'ampm'AM|am|PM|pm))?" + time_zone_r + @"(?=$|[^\d\w])", RegexOptions.Compiled); if (!m.Success) //look for [h]h:mm:ss [PM/AM] [UTC/GMT] <date> m = Regex.Match(str.Substring(0, parsed_date.IndexOfDate), @"(?<=^|[^\d])(?'hour'\d{1,2})\s*:\s*(?'minute'\d{2})\s*(?::\s*(?'second'\d{2}))?(?:\s*(?'ampm'AM|am|PM|pm))?" + time_zone_r + @"(?=$|[\s,]+)", RegexOptions.Compiled); if (!m.Success) //look for [h]h:mm:ss [PM/AM] [UTC/GMT] within <date> m = Regex.Match(str.Substring(parsed_date.IndexOfDate, parsed_date.LengthOfDate), @"(?<=^|[^\d])(?'hour'\d{1,2})\s*:\s*(?'minute'\d{2})\s*(?::\s*(?'second'\d{2}))?(?:\s*(?'ampm'AM|am|PM|pm))?" + time_zone_r + @"(?=$|[\s,]+)", RegexOptions.Compiled); } else//look anywhere within string { //look for hh:mm:ss <UTC offset> m = Regex.Match(str, @"(?<=^|\s+|\s*T\s*)(?'hour'\d{2})\s*:\s*(?'minute'\d{2})\s*:\s*(?'second'\d{2})\s+(?'offset_sign'[\+\-])(?'offset_hh'\d{2}):?(?'offset_mm'\d{2})?(?=$|[^\d\w])", RegexOptions.Compiled); if (!m.Success) //look for [h]h:mm[:ss] [PM/AM] [UTC/GMT] m = Regex.Match(str, @"(?<=^|\s+|\s*T\s*)(?'hour'\d{1,2})\s*:\s*(?'minute'\d{2})\s*(?::\s*(?'second'\d{2}))?(?:\s*(?'ampm'AM|am|PM|pm))?" + time_zone_r + @"(?=$|[^\d\w])", RegexOptions.Compiled); } if (!m.Success) return false; //try //{ int hour = int.Parse(m.Groups["hour"].Value); if (hour < 0 || hour > 23) return false; int minute = int.Parse(m.Groups["minute"].Value); if (minute < 0 || minute > 59) return false; int second = 0; if (!string.IsNullOrEmpty(m.Groups["second"].Value)) { second = int.Parse(m.Groups["second"].Value); if (second < 0 || second > 59) return false; } if (string.Compare(m.Groups["ampm"].Value, "PM", true) == 0 && hour < 12) hour += 12; else if (string.Compare(m.Groups["ampm"].Value, "AM", true) == 0 && hour == 12) hour -= 12; DateTime date_time = new DateTime(1, 1, 1, hour, minute, second); if (m.Groups["offset_hh"].Success) { int offset_hh = int.Parse(m.Groups["offset_hh"].Value); int offset_mm = 0; if (m.Groups["offset_mm"].Success) offset_mm = int.Parse(m.Groups["offset_mm"].Value); TimeSpan utc_offset = new TimeSpan(offset_hh, offset_mm, 0); if (m.Groups["offset_sign"].Value == "-") utc_offset = -utc_offset; parsed_time = new ParsedDateTime(-1, -1, m.Index, m.Length, date_time, utc_offset); return true; } if (m.Groups["time_zone"].Success) { TimeSpan utc_offset; switch (m.Groups["time_zone"].Value) { case "UTC": case "GMT": utc_offset = new TimeSpan(0, 0, 0); break; case "CST": utc_offset = new TimeSpan(-6, 0, 0); break; case "EST": utc_offset = new TimeSpan(-5, 0, 0); break; default: throw new Exception("Time zone: " + m.Groups["time_zone"].Value + " is not defined."); } parsed_time = new ParsedDateTime(-1, -1, m.Index, m.Length, date_time, utc_offset); return true; } parsed_time = new ParsedDateTime(-1, -1, m.Index, m.Length, date_time); //} //catch(Exception e) //{ // return false; //} return true; }
public override string ToString() => DateTimeFormat.Format(ClockDateTime, null, null, Offset);
private static extern int dialog_set_notification_start_date_format(IntPtr dialog, DateTimeFormat date_format, DateTimeFormat time_format, DateTimeFormat week_format);
public string ToString([StringSyntax(StringSyntaxAttribute.DateTimeFormat)] string?format) => DateTimeFormat.Format(ClockDateTime, format, null, Offset);
/// <summary> /// For compatibility with earlier Jil versions. /// /// Configuration for Jil serialization options. /// /// Available options: /// prettyPrint - whether or not to include whitespace and newlines for ease of reading /// excludeNulls - whether or not to write object members whose value is null /// jsonp - whether or not the serialized json should be valid for use with JSONP /// dateFormat - the style in which to serialize DateTimes and TimeSpans /// includeInherited - whether or not to serialize members declared by an objects base types /// unspecifiedDateTimeKindBehavior - how to treat DateTime's with a DateTimeKind of Unspecified (Jil converts all DateTimes to Utc for serialization, use DateTimeOffset to preserve time zone information) /// </summary> public Options(bool prettyPrint, bool excludeNulls, bool jsonp, DateTimeFormat dateFormat, bool includeInherited, UnspecifiedDateTimeKindBehavior unspecifiedDateTimeKindBehavior) : this(prettyPrint, excludeNulls, jsonp, dateFormat, includeInherited, unspecifiedDateTimeKindBehavior, SerializationNameFormat.Verbatim) { }
public string ToString(IFormatProvider?formatProvider) => DateTimeFormat.Format(ClockDateTime, null, formatProvider, Offset);
/// <summary> /// 日期格式化为一定的格式 /// </summary> /// <param name="datetime"></param> /// <returns></returns> public static string Format(System.DateTime datetime, DateTimeFormat format) { return datetime.ToString(_formatArray[(int)(format)]); }
public string ToString([StringSyntax(StringSyntaxAttribute.DateTimeFormat)] string?format, IFormatProvider?formatProvider) => DateTimeFormat.Format(ClockDateTime, format, formatProvider, Offset);
public String ToString(String format) { Contract.Ensures(Contract.Result <String>() != null); return(DateTimeFormat.Format(ClockDateTime, format, DateTimeFormatInfo.CurrentInfo, Offset)); }
public bool TryFormat(Span <char> destination, out int charsWritten, [StringSyntax(StringSyntaxAttribute.DateTimeFormat)] ReadOnlySpan <char> format = default, IFormatProvider?formatProvider = null) => DateTimeFormat.TryFormat(ClockDateTime, destination, out charsWritten, format, formatProvider, Offset);
/// <summary> /// Tries to find date and time within the passed string and return it as ParsedDateTime object. /// </summary> /// <param name="str">string that contains date-time</param> /// <param name="default_format">format that must be used preferably in ambivalent instances</param> /// <param name="parsed_date_time">parsed date-time output</param> /// <returns>true if both date and time were found, else false</returns> public static bool TryParseDateTime(string str, DateTimeFormat default_format, out ParsedDateTime parsed_date_time) { lock (lock_variable) { if (DateTimeHelper.TryParse(str, DateTimeHelper.DateTimeFormat.USA_DATE, out parsed_date_time) && parsed_date_time.IsDateFound && parsed_date_time.IsTimeFound ) return true; parsed_date_time = null; return false; } }
public String ToString(String format) { return(DateTimeFormat.Format(ClockDateTime, format, DateTimeFormatInfo.CurrentInfo, Offset)); }
/// <summary> /// Tries to find time within the passed string (relatively to the passed parsed_date if any) and return it as ParsedDateTime object. /// It recognizes only time while ignoring date, so date in the returned ParsedDateTime is always 1/1/1 /// </summary> /// <param name="str">string that contains date</param> /// <param name="default_format">format that must be used preferably in ambivalent instances</param> /// <param name="parsed_time">parsed date-time output</param> /// <param name="parsed_date">ParsedDateTime object if the date was found within this string, else NULL</param> /// <returns>true if time was found, else false</returns> public static bool TryParseTime(string str, DateTimeFormat default_format, out ParsedDateTime parsed_time, ParsedDateTime parsed_date) { lock (lock_variable) { parsed_time = null; Match m; if (parsed_date != null && parsed_date.IndexOfDate > -1) {//look around the found date //look for <date> [h]h:mm[:ss] [PM/AM] m = Regex.Match(str.Substring(parsed_date.IndexOfDate + parsed_date.LengthOfDate), @"(?<=^\s*,?\s+|^\s*at\s*|^\s*[T\-]\s*)(?'hour'\d{1,2})\s*:\s*(?'minute'\d{2})\s*(?::\s*(?'second'\d{2}))?(?:\s*([AP]M))?(?=$|[^\d\w])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (!m.Success) //look for [h]h:mm:ss <date> m = Regex.Match(str.Substring(0, parsed_date.IndexOfDate), @"(?<=^|[^\d])(?'hour'\d{1,2})\s*:\s*(?'minute'\d{2})\s*(?::\s*(?'second'\d{2}))?(?:\s*([AP]M))?(?=$|[\s,]+)", RegexOptions.Compiled | RegexOptions.IgnoreCase); } else//look anywere within string //look for [h]h:mm[:ss] [PM/AM] m = Regex.Match(str, @"(?<=^|\s+|\s*T\s*)(?'hour'\d{1,2})\s*:\s*(?'minute'\d{2})\s*(?::\s*(?'second'\d{2}))?(?:\s*([AP]M))?(?=$|[^\d\w])", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (m.Success) { try { int hour = int.Parse(m.Groups["hour"].Value); if (hour < 0 || hour > 23) return false; int minute = int.Parse(m.Groups["minute"].Value); if (minute < 0 || minute > 59) return false; int second = 0; if (!string.IsNullOrEmpty(m.Groups["second"].Value)) { second = int.Parse(m.Groups["second"].Value); if (second < 0 || second > 59) return false; } if (string.Compare(m.Groups[4].Value, "PM", true) > -1) hour += 12; System.DateTime date_time = new System.DateTime(1, 1, 1, hour, minute, second); parsed_time = new ParsedDateTime(-1, -1, m.Index, m.Length, date_time); } catch { return false; } return true; } return false; } }
public String ToString(String format, IFormatProvider formatProvider) { Contract.Ensures(Contract.Result <String>() != null); return(DateTimeFormat.Format(ClockDateTime, format, DateTimeFormatInfo.GetInstance(formatProvider), Offset)); }
/// <summary> /// Tries to find date and/or time within the passed string and return it as DateTime structure. /// If only date was found, time in the returned DateTime is always 0:0:0. /// If only time was found, date in the returned DateTime is DefaultDate. /// </summary> /// <param name="str">string that contains date and(or) time</param> /// <param name="default_format">format to be used preferably in ambivalent instances</param> /// <param name="date_time">parsed date-time output</param> /// <returns>true if date and/or time was found, else false</returns> public static bool TryParseDateOrTime(this string str, DateTimeFormat default_format, out DateTime date_time) { ParsedDateTime parsed_date_time; if (!TryParseDateOrTime(str, default_format, out parsed_date_time)) { date_time = new DateTime(1, 1, 1); return false; } date_time = parsed_date_time.DateTime; return true; }
public JsonSerializer(DateTimeFormat dateTimeFormat = DateTimeFormat.Default) { DateFormat = dateTimeFormat; }
/// <summary> /// Tries to find date and time within the passed string and return it as ParsedDateTime object. /// </summary> /// <param name="str">string that contains date-time</param> /// <param name="default_format">format to be used preferably in ambivalent instances</param> /// <param name="parsed_date_time">parsed date-time output</param> /// <returns>true if both date and time were found, else false</returns> public static bool TryParseDateTime(this string str, DateTimeFormat default_format, out ParsedDateTime parsed_date_time) { if (DateTimeRoutines.TryParseDateOrTime(str, default_format, out parsed_date_time) && parsed_date_time.IsDateFound && parsed_date_time.IsTimeFound ) return true; parsed_date_time = null; return false; }
/// <summary> /// Convert an IDictionary to a JSON string. /// </summary> /// <param name="dictionary">The value to convert.</param> /// <returns>The JSON object as a string or null when the value type is not supported.</returns> protected static string SerializeIDictionary(IDictionary dictionary, DateTimeFormat dateTimeFormat = DateTimeFormat.Default) { StringBuilder result = new StringBuilder("{"); foreach (DictionaryEntry entry in dictionary) { if (result.Length > 1) { result.Append(","); } result.Append("\"" + entry.Key + "\""); result.Append(":"); result.Append(SerializeObject(entry.Value, dateTimeFormat)); } result.Append("}"); return result.ToString(); }
/// <summary> /// Tries to find time within the passed string and return it as ParsedDateTime object. /// It recognizes only time while ignoring date, so date in the returned ParsedDateTime is always 1/1/1 /// </summary> /// <param name="str">string that contains date-time</param> /// <param name="default_format">format to be used preferably in ambivalent instances</param> /// <param name="parsed_time">parsed date-time output</param> /// <returns>true if time was found, else false</returns> public static bool TryParseTime(this string str, DateTimeFormat default_format, out ParsedDateTime parsed_time) { return TryParseTime(str, default_format, out parsed_time, null); }
public override String ToString() { Contract.Ensures(Contract.Result <String>() != null); return(DateTimeFormat.Format(ClockDateTime, null, DateTimeFormatInfo.CurrentInfo, Offset)); }
public static AttributeMetadata CreateDateTime(DateTimeFormat? format = DateTimeFormat.DateOnly, ImeMode? mode = ImeMode.Auto, string formulaDefinition = null) { return new DateTimeAttributeMetadata { Format = format, ImeMode = mode, FormulaDefinition = formulaDefinition }; }
public String ToString(String format, IFormatProvider formatProvider) { return(DateTimeFormat.Format(ClockDateTime, format, DateTimeFormatInfo.GetInstance(formatProvider), Offset)); }
/// <summary>Converts the given DateTime value to a string using the given summary desired format</summary> /// <param name="dt">Specifies the DateTime value to convert</param> /// <param name="dtFormat">Specifies the desired format from the set of supported enum values.</param> /// <returns>The DateTime converted to a string based on the desired format.</returns> public static string CvtToString(DateTime dt, DateTimeFormat dtFormat) { return CvtToString(ref dt, dtFormat); }
public bool SetStartDateTime(DateTime dateTime, DateTimeFormat date, DateTimeFormat time, DateTimeFormat week = DateTimeFormat.None) { if (dialog_set_notification_start_date_format(handle, date, time, week) != BPS.BPS_SUCCESS && dialog_set_notification_start_date_time(handle, (long)(dateTime.ToUniversalTime() - GetEpoch()).TotalMilliseconds) != BPS.BPS_SUCCESS) { return false; } return UpdateDialog(false); }
/// <summary> /// Convert an IEnumerable to a JSON string. /// </summary> /// <param name="enumerable">The value to convert.</param> /// <returns>The JSON object as a string or null when the value type is not supported.</returns> protected static string SerializeIEnumerable(IEnumerable enumerable, DateTimeFormat dateTimeFormat = DateTimeFormat.Default) { StringBuilder result = new StringBuilder("["); foreach (object current in enumerable) { if (result.Length > 1) { result.Append(","); } result.Append(SerializeObject(current, dateTimeFormat)); } result.Append("]"); return result.ToString(); }
public bool SetStartElapsedTime(TimeSpan timeSpan, DateTimeFormat format) { if (dialog_set_notification_start_date_format_elapsed(handle, format) != BPS.BPS_SUCCESS && dialog_set_notification_start_date_time(handle, (long)timeSpan.TotalMilliseconds) != BPS.BPS_SUCCESS) { return false; } return UpdateDialog(false); }
/// <summary> /// Convert an object to a JSON string. /// </summary> /// <param name="o">The value to convert. Supported types are: Boolean, String, Byte, (U)Int16, (U)Int32, Float, Double, Decimal, Array, IDictionary, IEnumerable, Guid, Datetime, DictionaryEntry, Object and null.</param> /// <returns>The JSON object as a string or null when the value type is not supported.</returns> /// <remarks>For objects, only public properties with getters are converted.</remarks> public static string SerializeObject(object o, DateTimeFormat dateTimeFormat = DateTimeFormat.Default) { if (o == null) return "null"; Type type = o.GetType(); switch (type.Name) { case "Boolean": { return (bool)o ? "true" : "false"; } case "String": case "Char": case "Guid": { return "\"" + SerializeString(o as String) + "\""; } case "Single": case "Double": case "Decimal": case "Float": case "Byte": case "SByte": case "Int16": case "UInt16": case "Int32": case "UInt32": case "Int64": case "UInt64": { return o.ToString(); } case "DateTime": { switch (dateTimeFormat) { case DateTimeFormat.Ajax: // This MSDN page describes the problem with JSON dates: // http://msdn.microsoft.com/en-us/library/bb299886.aspx return "\"" + DateTimeExtensions.ToASPNetAjax((DateTime)o) + "\""; case DateTimeFormat.ISO8601: case DateTimeFormat.Default: default: return "\"" + DateTimeExtensions.ToIso8601((DateTime)o) + "\""; } } } if (o is IDictionary && !type.IsArray) { IDictionary dictionary = o as IDictionary; return SerializeIDictionary(dictionary, dateTimeFormat); } if (o is IEnumerable) { IEnumerable enumerable = o as IEnumerable; return SerializeIEnumerable(enumerable, dateTimeFormat); } // // if (type == typeof(System.Collections.DictionaryEntry)) // { // DictionaryEntry entry = o as DictionaryEntry; // Hashtable hashtable = new Hashtable(); // hashtable.Add(entry.Key, entry.Value); // return SerializeIDictionary(hashtable, dateTimeFormat); // } if (type.IsClass) { Hashtable hashtable = new Hashtable(); // Iterate through all of the methods, looking for public GET properties MethodInfo[] methods = type.GetMethods(); foreach (MethodInfo method in methods) { // We care only about property getters when serializing if (method.Name.StartsWith("get_")) { // Ignore abstract and virtual objects if (method.IsAbstract) { continue; } // Ignore delegates and MethodInfos if ((method.ReturnType == typeof(System.Delegate)) || (method.ReturnType == typeof(System.MulticastDelegate)) || (method.ReturnType == typeof(System.Reflection.MethodInfo))) { continue; } // Ditto for DeclaringType if ((method.DeclaringType == typeof(System.Delegate)) || (method.DeclaringType == typeof(System.MulticastDelegate))) { continue; } object returnObject = method.Invoke(o, null); hashtable.Add(method.Name.Substring(4), returnObject); } } return SerializeIDictionary(hashtable, dateTimeFormat); } return null; }
public bool TryFormat(Span <char> destination, out int charsWritten, string format = null, IFormatProvider formatProvider = null) => DateTimeFormat.TryFormat(ClockDateTime, destination, out charsWritten, format, DateTimeFormatInfo.GetInstance(formatProvider), Offset);