Get just the hour of day from DateTime using either 12 or 24 hour format as defined by the current culture

Question

.Net has the built in ToShortTimeString() function for DateTime that uses the CultureInfo.CurrentCulture.DateTimeFormat.ShortTimePattern format. It returns something like this for en-US: "5:00 pm". For a 24 hour culture such as de-DE it would return "17:00".

What I want is a way to just return just the hour (So "5 pm" and "17" in the cases above) that works with every culture. What's the best/cleanest way to do this?

Thanks!

Answer 1

// displays "15" because my current culture is en-GB
Console.WriteLine(DateTime.Now.ToHourString());

// displays "3 pm"
Console.WriteLine(DateTime.Now.ToHourString(new CultureInfo("en-US")));

// displays "15"
Console.WriteLine(DateTime.Now.ToHourString(new CultureInfo("de-DE")));

// ...

public static class DateTimeExtensions
{
    public static string ToHourString(this DateTime dt)
    {
        return dt.ToHourString(null);
    }

    public static string ToHourString(this DateTime dt, IFormatProvider provider)
    {
        DateTimeFormatInfo dtfi = DateTimeFormatInfo.GetInstance(provider);

        string format = Regex.Replace(dtfi.ShortTimePattern, @"[^hHt\s]", "");
        format = Regex.Replace(format, @"\s+", " ").Trim();

        if (format.Length == 0)
            return "";

        if (format.Length == 1)
            format = '%' + format;

        return dt.ToString(format, dtfi);
    }
}

Answer 2

I would check to see whether CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern contains "h", "hh", "H", "HH", "t" or "tt", and in what order, and then build your own custom format string from those.

e.g.

• en-US: map "h:mm tt" to "h tt"
• ja-JP: map "H:mm" to "H"
• fr-FR: map "HH:mm" to "HH"

Then use .ToString(), passing in the string you built.

Example code - this basically strips out everything that's not t, T, h, H, and multiple spaces. But, as pointed out below, just a string of "H" could fail...

string full = System.Globalization.CultureInfo.CurrentCulture.DateTimeFormat.ShortTimePattern;
string sh = String.Empty;
for (int k = 0; k < full.Length; k++)
{
    char i = full[k];
    if (i == 'h' || i == 'H' || i == 't' || i == 'T' || (i == ' ' && (sh.Length == 0 || sh[sh.Length - 1] != ' ')))
    {
        sh = sh + i;
    }
}
if (sh.Length == 1)
{
  sh = sh + ' ';
  string rtnVal = DateTime.Now.ToString(sh);
  return rtnVal.Substring(0, rtnVal.Length - 1);
{
else
{
    return DateTime.Now.ToString(sh);
}

Answer 3

Use this:

bool use2fHour =
    CultureInfo
        .CurrentCulture
        .DateTimeFormat
        .ShortTimePattern.Contains("H");

Answer 4

you may use DateTime.ToString() and provide format tyou want as an argument.

Answer 5

Ugh, I didn't want to be interested but now I am! Here's the code which respects all cultures and renders the AM/PM designators in the correct position, as well as recognizing 24-hour format, all depending on the culture.

Basically, this static extension method is overloaded to take the current culture (no parameters) or a specified culture.

DateTime.Now.ToTimeString()
DateTime.Now.ToTimeString(someCultureInfo)

Code is below, includes sample program:

    public static class DateTimeStaticExtensions
    {
        private static int GetDesignatorIndex(CultureInfo info)
        {
            if (info.DateTimeFormat
                .ShortTimePattern.StartsWith("tt"))
            {
                return 0;
            }
            else if (info.DateTimeFormat
                .ShortTimePattern.EndsWith("tt"))
            {
                return 1;
            }
            else
            {
                return -1;
            }
        }

        private static string GetFormattedString(int hour, 
            CultureInfo info)
        {
            string designator = (hour > 12 ? 
                info.DateTimeFormat.PMDesignator : 
                info.DateTimeFormat.AMDesignator);

            if (designator != "")
            {
                switch (GetDesignatorIndex(info))
                {
                    case 0:
                        return string.Format("{0} {1}",
                            designator, 
                            (hour > 12 ? 
                                (hour - 12).ToString() : 
                                hour.ToString()));
                    case 1:
                        return string.Format("{0} {1}",
                            (hour > 12 ? 
                                (hour - 12).ToString() :
                                hour.ToString()), 
                            designator);
                    default:
                        return hour.ToString();
                }
            }
            else
            {
                return hour.ToString();
            }
        }

        public static string ToTimeString(this DateTime target, 
            CultureInfo info)
        {
            return GetFormattedString(target.Hour, info);
        }

        public static string ToTimeString(this DateTime target)
        {
            return GetFormattedString(target.Hour, 
                CultureInfo.CurrentCulture);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var dt = new DateTime(2010, 6, 10, 6, 0, 0, 0);

            CultureInfo[] cultures = 
                CultureInfo.GetCultures(CultureTypes.SpecificCultures);
            foreach (CultureInfo culture in cultures)
            {
                Console.WriteLine(
                    "{0}: {1} ({2}, {3}) [Sample AM: {4} / Sample PM: {5}",
                    culture.Name, culture.DateTimeFormat.ShortTimePattern,
                    (culture.DateTimeFormat.AMDesignator == "" ? 
                        "[No AM]": 
                        culture.DateTimeFormat.AMDesignator),
                    (culture.DateTimeFormat.PMDesignator == "" ? 
                        "[No PM]": 
                        culture.DateTimeFormat.PMDesignator),
                    dt.ToTimeString(culture),  // AM sample
                    dt.AddHours(12).ToTimeString(culture) // PM sample
                    );
            }

            // pause program execution to review results...
            Console.WriteLine("Press enter to exit");
            Console.ReadLine();
        }
    }

Answer 6

var culture = CultureInfo.CurrentCulture;
bool uses24HourClock = string.IsNullOrEmpty(culture.DateTimeFormat.AMDesignator);

var dt = DateTime.Now;
string formatString = uses24HourClock ? "HH" : "h tt";
Console.WriteLine(dt.ToString(formatString, culture));

Sam's edit:

Here's code to prove this doesn't work.

var date = new DateTime(2010, 1, 1, 16, 0, 0);

foreach (CultureInfo cultureInfo in CultureInfo.GetCultures(CultureTypes.InstalledWin32Cultures))
{
    bool amMethod = String.IsNullOrEmpty(cultureInfo.DateTimeFormat.AMDesignator);
    bool formatMethod = cultureInfo.DateTimeFormat.ShortTimePattern.Contains("H");

    if (amMethod != formatMethod)
    {
        Console.WriteLine("**** {0} AM: {1} Format: {2} Designator: {3}  Time: {4}",
                          cultureInfo.Name,
                          amMethod,
                          formatMethod,
                          cultureInfo.DateTimeFormat.AMDesignator,
                          date.ToString("t", cultureInfo.DateTimeFormat));
    }
}

Answer 7

Try using DateTime.Hour property.