Get AM/PM for a date time in lowercase using only a datetime format

I'm to get a custom DateTime format including the AM/PM designator, but I want the "AM" or "PM" to be lowercase without making the rest of of the characters lowercase.

Is this possible using a single format and without using a regex?

Here's what I've got right now:

item.PostedOn.ToString("dddd, MMMM d, yyyy a\\t h:mmtt")

An example of the output right now would be Saturday, January 31, 2009 at 1:34PM

I would personally format it in two parts: the non-am/pm part, and the am/pm part with ToLower:

string formatted = item.PostedOn.ToString("dddd, MMMM d, yyyy a\\t h:mm") +
                   item.PostedOn.ToString("tt").ToLower();

Another option (which I'll investigate in a sec) is to grab the current DateTimeFormatInfo, create a copy, and set the am/pm designators to the lower case version. Then use that format info for the normal formatting. You'd want to cache the DateTimeFormatInfo, obviously...

EDIT: Despite my comment, I've written the caching bit anyway. It probably won't be faster than the code above (as it involves a lock and a dictionary lookup) but it does make the calling code simpler:

string formatted = item.PostedOn.ToString("dddd, MMMM d, yyyy a\\t h:mmtt",
                                          GetLowerCaseInfo());

Here's a complete program to demonstrate:

using System;
using System.Collections.Generic;
using System.Globalization;

public class Test
{
    static void Main()
    {
        Console.WriteLine(DateTime.Now.ToString("dddd, MMMM d, yyyy a\\t h:mmtt",
                                                GetLowerCaseInfo());
    }
    
    private static readonly Dictionary<DateTimeFormatInfo,DateTimeFormatInfo> cache =
        new Dictionary<DateTimeFormatInfo,DateTimeFormatInfo>();
    
    private static object cacheLock = new object();
    
    public static DateTimeFormatInfo GetLowerCaseInfo()
    {
        DateTimeFormatInfo current = CultureInfo.CurrentCulture.DateTimeFormat;
        lock (cacheLock)
        {
            DateTimeFormatInfo ret;
            if (!cache.TryGetValue(current, out ret))
            {
                ret = (DateTimeFormatInfo) current.Clone();
                ret.AMDesignator = ret.AMDesignator.ToLower();
                ret.PMDesignator = ret.PMDesignator.ToLower();
                cache[current] = ret;
            }
            return ret;
        }
    }
}

You could split the format string into two parts, and then lowercase the AM/PM part, like so:

DateTime now = DateTime.Now;
string nowString = now.ToString("dddd, MMMM d, yyyy a\\t h:mm");
nowString = nowString + now.ToString("tt").ToLower();

However, I think the more elegant solution is to use a DateTimeFormatInfo instance that you construct and replace the AMDesignator and PMDesignator properties with "am" and "pm" respectively:

DateTimeFormatInfo fi = new DateTimeFormatInfo();

fi.AMDesignator = "am";
fi.PMDesignator = "pm";

string nowString = now.ToString("dddd, MMMM d, yyyy a\\t h:mmtt", fi);

You can use the DateTimeFormatInfo instance to customize many other aspects of transforming a DateTime to a string.

EDIT: Jon's example is much better, though I think the extension method is still the way to go so you don't have to repeat the code everywhere. I've removed the replace and substituted Jon's first example in place in the extension method. My apps are typically intranet apps and I don't have to worry about non-US cultures.

Add an extension method to do this for you.

public static class DateTimeExtensions
{
    public static string MyDateFormat( this DateTime dateTime )
    {
       return dateTime.ToString("dddd, MMMM d, yyyy a\\t h:mm") +
              dateTime.ToString("tt").ToLower();
    }
}

...

item.PostedOn.MyDateFormat();

EDIT: Other ideas on how to do this at https://stackoverflow.com/questions/448634/how-to-format-a-datetime-like-oct-10-2008-1043am-cst-in-c.

The problem with the above approaches is that the main reason you use a format string is to enable localization, and the approaches given so far would break for any country or culture that does not wish to include a final am or pm. So what I've done is written out an extension method that understands an additional format sequence 'TT' which signifies a lowercase am/pm. The below code is debugged for my cases, but may not yet be perfect:

	/// <summary>
	/// Converts the value of the current System.DateTime object to its equivalent string representation using the specified format.  The format has extensions over C#s ordinary format string
	/// </summary>
	/// <param name="dt">this DateTime object</param>
	/// <param name="formatex">A DateTime format string, with special new abilities, such as TT being a lowercase version of 'tt'</param>
	/// <returns>A string representation of value of the current System.DateTime object as specified by format.</returns>
	public static string ToStringEx(this DateTime dt, string formatex)
	{
		string ret;
		if (!String.IsNullOrEmpty(formatex))
		{
			ret = "";
			string[] formatParts = formatex.Split(new[] { "TT" }, StringSplitOptions.None);
			for (int i = 0; i < formatParts.Length; i++)
			{
				if (i > 0)
				{
					//since 'TT' is being used as the seperator sequence, insert lowercase AM or PM as appropriate
					ret += dt.ToString("tt").ToLower();
				}
				string formatPart = formatParts[i];
				if (!String.IsNullOrEmpty(formatPart))
				{
					ret += dt.ToString(formatPart);
				}
			}
		}
		else
		{
			ret = dt.ToString(formatex);
		}
		return ret;
	}

This should be the most performant of all these options. But too bad they couldn't work in a lowercase option into the DateTime format (tt opposite TT?).

	public static string AmPm(this DateTime dt, bool lower = true)
	{
		return dt.Hour < 12 
			? (lower ? "am" : "AM")
			: (lower ? "pm" : "PM");
	}