dotnet · BillWagner · Jan 21, 2022 · Jan 5, 2022 · Jan 5, 2022 · Jan 15, 2022
@@ -0,0 +1,108 @@
+module Calender
+
+open System
+
+let thaiBuddistEra () =
+    // <Snippet1>
+    let thTH = System.Globalization.CultureInfo "th-TH"
+    let value = DateTime(2016, 5, 28)
+
+    printfn $"{value.ToString thTH}"
+
+    thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
+
+    printfn $"{value.ToString thTH}"
+
+    // The example displays the following output:
+    //       28/5/2559 0:00:00
+    //       28/5/2016 0:00:00
+    // </Snippet1>
+
+let thaiBuddhistEraParse () =
+    // <Snippet2>
+    let thTH = System.Globalization.CultureInfo "th-TH"
+    let value = DateTime.Parse("28/05/2559", thTH)
+    printfn $"{value.ToString thTH}"
+
+    thTH.DateTimeFormat.Calendar <- System.Globalization.GregorianCalendar()
+    printfn $"{value.ToString thTH}"
+
+    // The example displays the following output:
+    //       28/5/2559 0:00:00
+    //       28/5/2016 0:00:00
+    // </Snippet2>
+
+let instantiateCalendar () =
+    // <Snippet3>
+    let thTH = System.Globalization.CultureInfo "th-TH"
+    let dat = DateTime(2559, 5, 28, thTH.DateTimeFormat.Calendar)
+
+    printfn $"""Thai Buddhist era date: {dat.ToString("d", thTH)}"""
+    printfn $"Gregorian date:   {dat:d}"
+
+    // The example displays the following output:
+    //       Thai Buddhist Era Date:  28/5/2559
+    //       Gregorian Date:     28/05/2016
+    // </Snippet3>
+
+let calendarFields () =
+    // <Snippet4>
+    let thTH = System.Globalization.CultureInfo "th-TH"
+    let cal = thTH.DateTimeFormat.Calendar
+    let dat = DateTime(2559, 5, 28, cal)
+    printfn "Using the Thai Buddhist Era calendar:"
+    printfn $"""Date: {dat.ToString("d", thTH)}"""
+    printfn $"Year: {cal.GetYear dat}"
+    printfn $"Leap year: {cal.IsLeapYear(cal.GetYear dat)}\n"
+
+    printfn "Using the Gregorian calendar:"
+    printfn $"Date: {dat:d}"
+    printfn $"Year: {dat.Year}"
+    printfn $"Leap year: {DateTime.IsLeapYear dat.Year}"
+
+    // The example displays the following output:
+    //       Using the Thai Buddhist Era calendar
+    //       Date :   28/5/2559
+    //       Year: 2559
+    //       Leap year :   True
+    //
+    //       Using the Gregorian calendar
+    //       Date :   28/05/2016
+    //       Year: 2016
+    //       Leap year :   True
+    // </Snippet4>
+
+let calculateWeeks () =
+    // <Snippet5>
+    let thTH = System.Globalization.CultureInfo "th-TH"
+    let thCalendar = thTH.DateTimeFormat.Calendar
+    let dat = DateTime(1395, 8, 18, thCalendar)
+    printfn "Using the Thai Buddhist Era calendar:"
+    printfn $"""Date: {dat.ToString("d", thTH)}"""
+    printfn $"Day of Week: {thCalendar.GetDayOfWeek dat}"
+    printfn $"Week of year: {thCalendar.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}\n"
+
+    let greg = System.Globalization.GregorianCalendar()
+    printfn "Using the Gregorian calendar:"
+    printfn $"Date: {dat:d}"
+    printfn $"Day of Week: {dat.DayOfWeek}"
+    printfn $"Week of year: {greg.GetWeekOfYear(dat, System.Globalization.CalendarWeekRule.FirstDay, DayOfWeek.Sunday)}"
+
+    // The example displays the following output:
+    //       Using the Thai Buddhist Era calendar
+    //       Date :  18/8/1395
+    //       Day of Week: Sunday
+    //       Week of year: 34
+    //
+    //       Using the Gregorian calendar
+    //       Date :  18/08/0852
+    //       Day of Week: Sunday
+    //       Week of year: 34
+    // </Snippet5>
+
+
+thaiBuddistEra ()
+thaiBuddhistEraParse ()
+instantiateCalendar ()
+calendarFields ()
+calculateWeeks ()
@@ -0,0 +1,53 @@
+module DateTimeComparisons
+
+open System
+open System.Text
+
+// <Snippet1>
+let roughlyEquals (time: DateTime) (timeWithWindow: DateTime) windowInSeconds frequencyInSeconds =
+    let delta = 
+        int64 (timeWithWindow - time).TotalSeconds % frequencyInSeconds
+
+    let delta = if delta > windowInSeconds then frequencyInSeconds - delta else delta
+    abs delta < windowInSeconds
+
+let testRoughlyEquals () =
+    let window = 10
+    let window' = 10.
+    let freq = 60 * 60 * 2 // 2 hours
+
+    let d1 = DateTime.Now
+
+    let d2 = d1.AddSeconds(2. * window')
+    let d3 = d1.AddSeconds(-2. * window')
+    let d4 = d1.AddSeconds(window' / 2.)
+    let d5 = d1.AddSeconds(-window' / 2.)
+
+    let d6 = (d1.AddHours 2).AddSeconds(2. * window')
+    let d7 = (d1.AddHours 2).AddSeconds(-2. * window')
+    let d8 = (d1.AddHours 2).AddSeconds(window' / 2.)
+    let d9 = (d1.AddHours 2).AddSeconds(-window' / 2.)
+
+    printfn $"d1 ({d1}) ~= d1 ({d1}): {roughlyEquals d1 d1 window freq}"
+    printfn $"d1 ({d1}) ~= d2 ({d2}): {roughlyEquals d1 d2 window freq}"
+    printfn $"d1 ({d1}) ~= d3 ({d3}): {roughlyEquals d1 d3 window freq}"
+    printfn $"d1 ({d1}) ~= d4 ({d4}): {roughlyEquals d1 d4 window freq}"
+    printfn $"d1 ({d1}) ~= d5 ({d5}): {roughlyEquals d1 d5 window freq}"
+
+    printfn $"d1 ({d1}) ~= d6 ({d6}): {roughlyEquals d1 d6 window freq}"
+    printfn $"d1 ({d1}) ~= d7 ({d7}): {roughlyEquals d1 d7 window freq}"
+    printfn $"d1 ({d1}) ~= d8 ({d8}): {roughlyEquals d1 d8 window freq}"
+    printfn $"d1 ({d1}) ~= d9 ({d9}): {roughlyEquals d1 d9 window freq}"
+
+// The example displays output similar to the following:
+//    d1 (1/28/2010 9:01:26 PM) ~= d1 (1/28/2010 9:01:26 PM): True
+//    d1 (1/28/2010 9:01:26 PM) ~= d2 (1/28/2010 9:01:46 PM): False
+//    d1 (1/28/2010 9:01:26 PM) ~= d3 (1/28/2010 9:01:06 PM): False
+//    d1 (1/28/2010 9:01:26 PM) ~= d4 (1/28/2010 9:01:31 PM): True
+//    d1 (1/28/2010 9:01:26 PM) ~= d5 (1/28/2010 9:01:21 PM): True
+//    d1 (1/28/2010 9:01:26 PM) ~= d6 (1/28/2010 11:01:46 PM): False
+//    d1 (1/28/2010 9:01:26 PM) ~= d7 (1/28/2010 11:01:06 PM): False
+//    d1 (1/28/2010 9:01:26 PM) ~= d8 (1/28/2010 11:01:31 PM): True
+//    d1 (1/28/2010 9:01:26 PM) ~= d9 (1/28/2010 11:01:21 PM): True
+// </Snippet1>
+testRoughlyEquals ()
@@ -0,0 +1,18 @@
+// <Snippet6>
+namespace DateTimeExtensions
+
+open System
+
+[<Serializable>]
+type DateWithTimeZone =
+    struct
+        val TimeZone: TimeZoneInfo
+        val DateTime: DateTime
+        new (dateValue, timeZone) = 
+            { DateTime = dateValue; 
+              TimeZone = 
+                if isNull timeZone then TimeZoneInfo.Local
+                else timeZone }
+    end
+
+// </Snippet6>
@@ -0,0 +1,42 @@
+module Instantiation
+
+open System
+
+let instantiateWithConstructor () =
+    // <Snippet1>
+    let date1 = DateTime(2008, 5, 1, 8, 30, 52)
+    printfn $"{date1}" 
+    // </Snippet1>
+
+let instantiateWithReturnValue () =
+    // <Snippet3>
+    let date1 = DateTime.Now
+    let date2 = DateTime.UtcNow
+    let date3 = DateTime.Today
+    // </Snippet3>
+    ()
+
+let instantiateFromString () =
+    // <Snippet4>
+    let dateString = "5/1/2008 8:30:52 AM"
+    let date1 = DateTime.Parse(dateString, System.Globalization.CultureInfo.InvariantCulture)
+    let iso8601String = "20080501T08:30:52Z"
+    let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)
+    // </Snippet4>
+    ()
+
+let instantiateUsingDftCtor () =
+    // <Snippet5>
+    let dat1 = DateTime()
+
+    // The following method call displays 1/1/0001 12:00:00 AM.
+    printfn $"{dat1.ToString System.Globalization.CultureInfo.InvariantCulture}"
+
+    // The following method call displays True.
+    printfn $"{dat1.Equals DateTime.MinValue}"
+    // </Snippet5>
+
+instantiateWithConstructor ()
+instantiateWithReturnValue ()
+instantiateFromString ()
+instantiateUsingDftCtor ()
@@ -0,0 +1,64 @@
+module Parsing
+
+open System
+
+let parseStandardFormats () =
+    // <Snippet1>
+    System.Threading.Thread.CurrentThread.CurrentCulture <-
+        System.Globalization.CultureInfo.CreateSpecificCulture "en-GB"
+
+    let date1 = DateTime(2013, 6, 1, 12, 32, 30)
+    let badFormats = ResizeArray<String>()
+
+    printfn "%-37s %-19s\n" "Date String" "Date"
+    for dateString in date1.GetDateTimeFormats() do
+        match DateTime.TryParse dateString with
+        | true, parsedDate ->
+            printfn $"%-37s{dateString} %-19O{parsedDate}\n" 
+        | _ ->
+            badFormats.Add dateString
+
+    // Display strings that could not be parsed.
+    if badFormats.Count > 0 then
+        printfn "\nStrings that could not be parsed: "
+        for badFormat in badFormats do
+            printfn $"   {badFormat}"
+    // Press "Run" to see the output.
+    // </Snippet1>
+
+let parseCustomFormats () =
+    // <Snippet2>
+    let formats = [| "yyyyMMdd"; "HHmmss" |]
+    let dateStrings = 
+        [ "20130816"; "20131608"; "  20130816   "
+          "115216"; "521116"; "  115216  " ]
+
+    for dateString in dateStrings do
+        match DateTime.TryParseExact(dateString, formats, null,
+                                    System.Globalization.DateTimeStyles.AllowWhiteSpaces |||
+                                    System.Globalization.DateTimeStyles.AdjustToUniversal) with
+        | true, parsedDate ->
+            printfn $"{dateString} --> {parsedDate:g}"
+        | _ ->
+            printfn $"Cannot convert {dateString}"
+
+    // The example displays the following output:
+    //       20130816 --> 8/16/2013 12:00 AM
+    //       Cannot convert 20131608
+    //         20130816    --> 8/16/2013 12:00 AM
+    //       115216 --> 4/22/2013 11:52 AM
+    //       Cannot convert 521116
+    //         115216   --> 4/22/2013 11:52 AM
+    // </Snippet2>
+
+let parseISO8601 () =
+    // <Snippet3>
+    let iso8601String = "20080501T08:30:52Z"
+    let dateISO8602 = DateTime.ParseExact(iso8601String, "yyyyMMddTHH:mm:ssZ", System.Globalization.CultureInfo.InvariantCulture)
+
+    printfn $"{iso8601String} --> {dateISO8602:g}"
+    // </Snippet3>
+
+parseStandardFormats ()
+parseCustomFormats ()
+parseISO8601 ()