AM/PM pour un jour de temps en minuscules à l'aide de seulement un format datetime

Question

Je suis pour obtenir un format DateTime personnalisé, y compris l'indicateur AM/PM, mais je veux le "AM" ou "PM" pour être en minuscules , sans le reste de caractères en minuscules.

Est-ce possible à l'aide d'un format unique et sans l'aide d'une regex?

Voici ce que j'ai maintenant:

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

Un exemple de la sortie à droite maintenant, ce serait le samedi, janvier 31, 2009 à 1:34PM

Answer 1

Personnellement, je ne format en deux parties: la non-am/pm, et le am/pm de la partie avec ToLower:

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

Une autre option (je vais étudier dans une seconde), c'est de prendre le courant DateTimeFormatInfo, créer une copie, et l'ensemble de l'am/pm indicatifs pour le bas du cas de la version. Ensuite utiliser ce format de l'info pour la mise en forme normale. Vous souhaitez mettre en cache les DateTimeFormatInfo, évidemment...

EDIT: en Dépit de mon commentaire, j'ai écrit la mise en cache peu de toute façon. Il ne sera probablement pas plus rapide que le code ci-dessus (car il implique une serrure et d'une recherche dans le dictionnaire), mais elle permet de faire le code appelant de plus simple:

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

Voici un programme complet pour le démontrer:

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;
        }
    }
}

Answer 2

Vous pourriez diviser la chaîne de format en deux parties, puis minuscules AM/PM de la partie, comme suit:

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

Cependant, je pense que la solution la plus élégante est d'utiliser un DateTimeFormatInfo exemple que vous construisez et remplacer l' AMDesignator et PMDesignator propriétés avec "am" et "pm", respectivement:

DateTimeFormatInfo fi = new DateTimeFormatInfo();

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

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

Vous pouvez utiliser l' DateTimeFormatInfo exemple de personnaliser de nombreux autres aspects de la transformation d'un DateTime d'un string.

Answer 3

EDIT: Jon exemple est beaucoup mieux, mais je pense que la méthode d'extension est toujours la voie à suivre si vous n'avez pas à répéter le code partout. J'ai enlevé le remplacer et l'ont remplacé par Jon premier exemple en place de la méthode d'extension. Mes applications sont généralement intranet, applications et je n'ai pas à vous soucier de la non-US cultures.

Ajouter une méthode d'extension pour le faire pour vous.

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: d'Autres idées sur la façon de faire cela à l' http://stackoverflow.com/questions/448634/how-to-format-a-datetime-like-oct-10-2008-1043am-cst-in-c.

Answer 4

Le problème avec les approches décrites ci-dessus, c'est que la raison principale pour laquelle vous utilisez une chaîne de format est de permettre la localisation, et les approches donné jusqu'à présent de pause pour un pays ou une culture qui ne souhaite pas inclure une finale am ou pm. Donc ce que j'ai fait est écrit d'une méthode d'extension qui comprend un format supplémentaire de la séquence 'TT', ce qui signifie une minuscule am/pm. Le code ci-dessous est débogage pour mon cas, mais peut-être pas encore parfait:

    /// <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;
    }

Answer 5

Ce devrait être la plus performante de toutes ces options. Mais dommage qu'ils ne pouvaient pas travailler dans un minuscule option dans le format DateTime (tt en face de TT?).

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