Develop Reference

How to create .NET CultureInfo with Dateformat ISO 8601?

Is it possible to make .NET create the following output?
DateTime.UtcNow.ToString() --> "2017-11-07T00:40:00.123456Z"
Of course there is always the possibility to use ToString("s") or ToString("yyyy-MM-ddTHH:mm:ss.fffffffK"). But is there a way to adjust the default-behaviour for the parameterless ToString-Method to the desired output?
I tried changing the CurrentCulture. But the best I got was "2017-11-07 00:40:00.123456Z". I did not find a way to change the separator between the date and the time from a space to "T".

It is possible, but only by accessing an internal field via reflection, which is not guaranteed to work in all cases.
var culture = (CultureInfo) CultureInfo.InvariantCulture.Clone();
var field = typeof(DateTimeFormatInfo).GetField("generalLongTimePattern",
BindingFlags.NonPublic | BindingFlags.Instance);
if (field != null)
{
// we found the internal field, set it
field.SetValue(culture.DateTimeFormat, "yyyy-MM-dd'T'HH:mm:ss.FFFFFFFK");
}
else
{
// fallback to setting the separate date and time patterns
culture.DateTimeFormat.ShortDatePattern = "yyyy-MM-dd";
culture.DateTimeFormat.LongTimePattern = "HH:mm:ss.FFFFFFFK";
}
CultureInfo.CurrentCulture = culture;
Console.WriteLine(DateTime.UtcNow); // "2017-11-07T00:53:36.6922843Z"
Note that the ISO 8601 spec does allow a space to be used instead of a T. It's just preferable to use the T.

Scott Hanselmann has blogged about it here.
a little Reflectoring shows us that the default format string for System.DateTime is "G" as in System.DateTime.ToString("G") where G is one of the presets.
[...]
And gets the output he expects, indicating that "G" is the combination of a ShortDate and a LongTime.
So you should override ShortDatePattern and LongTimePattern:
I converted the code to C# and yes, it is working:
var customCulture = new CultureInfo("en-US")
{
DateTimeFormat =
{
ShortDatePattern = "yyyy-MM-dd",
LongTimePattern = "HH:mm:ss.FFFFFFFK"
}
};
Console.WriteLine(DateTime.Now);
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
System.Threading.Thread.CurrentThread.CurrentUICulture = customCulture;
Console.WriteLine(DateTime.Now);
Console.ReadLine();
However, Scott has titled his post Enabling Evil for reason. Think twice before doing that!
The T is not needed, but also can not be provided. If you still need it, you need to use Reflection, as Matt answered.

Why does AD3AD08 represent a valid date in the .NET framework?

DateTime.Parse("AD3AD08")
[2017-08-03 12:00:00 AM]
Why does that string (which looks like just a normal hex string to me) get parsed successfully as a date? I can see the 3 and the 8 get parsed as months and days. But otherwise it doesn't make sense to me.

tl;dr: You can use what DateTimeFormatInfo.GetEraName/GetAbbreviatedEraName return as delimiter, ignoring the case. The order is: day, month, year (optional).
It seems you can always use the calendar's current era's abbreviated name or full era-name as delimiter for the DateTime tokens. For english cultures it is AD or A.D., e.g. for german cultures it is n. Chr..
var enCulture = new CultureInfo("en-GB");
System.Threading.Thread.CurrentThread.CurrentCulture = enCulture;
var fi = enCulture.DateTimeFormat;
int currentEra = enCulture.Calendar.GetEra(DateTime.Now);
var eraName = fi.GetEraName(currentEra);
var shortEra = fi.GetAbbreviatedEraName(currentEra);
var date = DateTime.Parse($"{shortEra}3{shortEra}08"); // AD or A.D. works
var deCulture = new CultureInfo("de-DE");
System.Threading.Thread.CurrentThread.CurrentCulture = deCulture;
fi = deCulture.DateTimeFormat;
currentEra = deCulture.Calendar.GetEra(DateTime.Now);
eraName = fi.GetEraName(currentEra);
shortEra = fi.GetAbbreviatedEraName(currentEra);
date = DateTime.Parse($"{shortEra}3{shortEra}08"); // n. Chr. works
Interestingly it is case-insensitive, so ad works also. That is documented in DateTimeFormatInfo.GetEra:
The era name is the name a calendar uses to refer to a period of time
reckoned from a fixed point or event. For example, "A.D." or "C.E." is
the current era in the Gregorian calendar. The comparison with eraName
is case-insensitive, for example, "A.D." is equivalent to "a.d.".
The gregorian calendar has only one era, so Calendar.GetEra(DateTime.Now) isn't really necessary. I haven't found any further documentation yet.
Here are some samples that all work and will be parsed to christmas 2017:
DateTime christmas = DateTime.Parse("ad25ad12ad2017ad");
christmas = DateTime.Parse("AD25ad12ad2017");
christmas = DateTime.Parse("25ad12ad2017AD");
christmas = DateTime.Parse("25ad12ad2017");
christmas = DateTime.Parse("A.D.25ad12ad2017");
christmas = DateTime.Parse("A.D.25ad12ad"); // current year is used
christmas = DateTime.Parse("A.D.25ad12"); // current year is used

You can confirm that this is era and not some UTF encoded character by modifying culture abbreviated era name (era name is stored in DateTimeFormatInfo.m_abbrevEraNames and DateTimeFormatInfo.m_abbrevEnglishEraNames private fields, and for invariant culture abbreviated era name is string array with just one value - "AD"). m_eraNames field also stores full (non-abbreviated) era name ("A.D." for invariant culture) which can also be used instead of "AD".
var cul = (CultureInfo) CultureInfo.InvariantCulture.Clone();
// set DateTimeFormatInfo.AbbreviatedEraNames to "BLA"
typeof(DateTimeFormatInfo).GetField("m_abbrevEraNames", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(cul.DateTimeFormat, new string[] {"BLA"});
// set DateTimeFormatInfo.AbbreviatedEnglishEraNames to "BLA"
typeof(DateTimeFormatInfo).GetField("m_abbrevEnglishEraNames", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(cul.DateTimeFormat, new string[] { "BLA" });
var date = DateTime.Parse("AD03AD08", cul); // now it fails
var date = DateTime.Parse("A.D.03A.D.08", cul); // still works because we
// did not modify non-abbreviated era name
var date = DateTime.Parse("BLA03BLA08", cul); // this one works
Now why it treats era name like that is not quite obvious... Probably after meeting such token it sets date era and continues parsing, so it serves as separator in a sense it just moves to parsing next token after this one. Documentation for DateTime.Parse states that:
This method attempts to parse string completely and avoid throwing a
FormatException. It ignores unrecognized data if possible and fills in
missing month, day, and year information with the current date
While this does not mention anything about eras - such behavior aligns with "avoid throwing FormatException whenever possible" design.

How to change the Date Format '27JAN2017 to 27JA2017' in C#?

I am working WPF application using C# and .Net Framework 4.0. I want to change the format of the date and display in my application screen. Currently I am displaying the date in this format - mm/dd/yyyy that is (01/27/2017). I want to change the format from "01/27/2017" to "26JA2017".
I tried the below code,
value = Convert.ToDateTime(currentDate).ToString("ddMMMyyyy");
The above code is changing the date from "01/27/2017" to "27JAN2017". I want it to be 27JA2017. The customer is from France and he need the date format to be in French.
Can anyone of you help me in converting the date format from "27JAN2017" to "27JA2017"?

First of all, if you need a date in a language-specific format, you should pass the appropriate CultureInfo to ToString:
.ToString(..., CultureInfo.GetCultureInfo("fr-FR"));
Furthermore, this is ambiguous and not a standard format, so the easiest way is to just use a lookup table for the months and construct the string yourself.

As far as I can guess, you want kind of Canadian abbreviation:
http://interglacial.com/pub/text/Canadian_month_abbreviations.html
which is English/French names compromise
The reason that the abbreviations are a little odd at points is that
they're based on a compromise between the full English month names and
the full French month names
If it's your case, I suggest using custom DateTime Format:
// fr-FR - France (The customer is from [Mainland?] France)
// fr-CA - Canada (Origin of the abbreviations)
DateTimeFormatInfo caFormat =
(DateTimeFormatInfo) (CultureInfo.GetCultureInfo("fr-FR").DateTimeFormat.Clone());
caFormat.AbbreviatedMonthNames = new string[] {
"JA", "FE", "MR", "AL", "MA", "JN", "JL", "AU", "SE", "OC", "NO", "DE", "" };
Using
DateTime value = new DateTime(2016, 3, 1);
// Formatting as usual but with custom format
String result = value.ToString("ddMMMyyyy", caFormat);
Outcome
01MR2016

I think you are refering to a Canadian standard, as explained here
.Net does not provide that conversion,but you can do something like this:
Dictionary<string, string> abbr = new Dictionary<string, string>() {
{"Jan","JA"},
{ "Feb","FE"},
{ "Mar","MR"},
{ "Apr","AL"},
{ "May","MA"},
{ "Jun","JN"},
{ "Jul","JL"},
{ "Aug","AU"},
{ "Sep","SE"},
{ "Oct","OC"},
{ "Nov","NO"},
{ "Dec","DE"}
};
string val = Convert.ToDateTime(DateTime.Now).ToString("ddMMMyyyy",
System.Globalization.CultureInfo.InvariantCulture);
var newstr = abbr.Aggregate(val, (current, value) =>
current.Replace(value.Key, value.Value));

value = Convert.ToDateTime(currentDate).ToString("ddMMyyyy",new CultureInfo("fr-FR"));

I don't think so that its having any solution but yeah you can try split() function and by splitting date after 2 digits of day + two letters of month and again merge the string, hope that will help you.

DateTimeFormatInfo string format for day of week. Thursday becomes Th

Is there a DateTimeFormatInfo format pattern to convert a day of week to two characters? For example Tuesday becomes Tu, Wednesday becomes We. The format string needs to conform to the DateTimeFormatInfo for date formats.
Addition:
Maybe I am looking for a solution to extend DateTimeFormatInfo to include custom formats?

The closes you can get is the "ddd" custom format specifier - this produces three lettered abbreviations, so not exactly what you want. There is nothing built in that does exactly what you want.
You can always take the first two characters of that:
DateTime.Now.ToString("ddd").Substring(0,2);
Unfortunately you can't extend DateTimeFormatInfo since it is declared as sealed.

You need to get the DateTimeFormatInfo of the culture you're working with, then modify the array of strings called AbbreviatedDayNames. After that, ddd will return Th for you.
http://msdn.microsoft.com/en-us/library/system.globalization.datetimeformatinfo.abbreviateddaynames(VS.71).aspx
DateTimeFormatInfo.AbbreviatedDayNames
Gets or sets a one-dimensional array
of type String containing the
culture-specific abbreviated names of
the days of the week.
Here's a sample of how to do it:
class Program
{
static void Main()
{
var dtInfo = new System.Globalization.DateTimeFormatInfo();
Console.WriteLine("Old array of abbreviated dates:");
var dt = DateTime.Today;
for (int i = 0; i < 7; i++)
{
Console.WriteLine(dt.AddDays(i).ToString("ddd", dtInfo));
}
// change the short weekday names array
var newWeekDays =
new string[] { "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa" };
dtInfo.AbbreviatedDayNames = newWeekDays;
Console.WriteLine("New array of abbreviated dates:");
for (int i = 0; i < 7; i++)
{
Console.WriteLine(dt.AddDays(i).ToString("ddd", dtInfo));
}
Console.ReadLine();
}
}
One more note: of course, if you are constrained from providing the IFormatProvider, then you can override the current thread's CultureInfo, for example:
CultureInfo customCulture = CultureInfo.CreateSpecificCulture("en-US");
// ... set up the DateTimeFormatInfo, etc...
System.Threading.Thread.CurrentThread.CurrentCulture = customCulture;
More on CurrentCulture:
http://msdn.microsoft.com/en-us/library/system.threading.thread.currentuiculture.aspx
Thread.CurrentUICulture
Property Gets or sets the
current culture used by the Resource
Manager to look up culture-specific
resources at run time.

To use the DateTimeFormatInfo specifically you can
dtfi.GetShortestDayName(DateTime.Now.DayOfWeek);
however "ddd" is the closest you'll get for a string format

try this
string s = DateVar.ToString("ddd").SubString(0,2);
If it needs to be a FormatPattern, then try this:
var dtFI = new CultureInfo( "en-US", false).DateTimeFormat;
dtFI.DayNames = new[] {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su" };
string s = DateVar.ToString("ddd", dtFI);

Set Default DateTime Format c#

Is there a way of setting or overriding the default DateTime format for an entire application. I am writing an app in C# .Net MVC 1.0 and use alot of generics and reflection. Would be much simpler if I could override the default DateTime.ToString() format to be "dd-MMM-yyyy". I do not want this format to change when the site is run on a different machine.
Edit -
Just to clarify I mean specifically calling the ToString, not some other extension function, this is because of the reflection / generated code. Would be easier to just change the ToString output.

The "default format" of a datetime is:
ShortDatePattern + ' ' + LongTimePattern
at least in the current mono implementation.
This is particularly painful in case you want to display something like 2001-02-03T04:05:06Z i.e. the date and time combined as specified in ISO 8606, but not a big problem in your case:
using System;
using System.Globalization;
using System.Threading;
namespace test {
public static class Program {
public static void Main() {
CultureInfo culture = (CultureInfo)CultureInfo.CurrentCulture.Clone();
culture.DateTimeFormat.ShortDatePattern = "dd-MMM-yyyy";
culture.DateTimeFormat.LongTimePattern = "";
Thread.CurrentThread.CurrentCulture = culture;
Console.WriteLine(DateTime.Now);
}
}
}
This will set the default behavior of ToString on datetimes to return the format you expect.

It is dependent on your application's localization-settings. Change that accordingly to get correct format.
Otherwise have a helper-class or an extension-method which always handles your DateTime.
public static string ToMyDateTime(this DateTime dateTime) {
return dateTime.ToString("dd-MMMM-yy");
}

DateTime.ToString() combines the custom format strings returned by the ShortDatePattern and LongTimePattern properties of the DateTimeFormatInfo. You can specify these patterns in DateTimeFormatInfo.CurrentInfo.
I've never tried this my self.

If you want to be sure that your culture stays the same, just set it yourself to avoid troubles.
System.Globalization.CultureInfo ci = new System.Globalization.CultureInfo("nl-BE");
System.Threading.Thread.CurrentThread.CurrentCulture = ci;
System.Threading.Thread.CurrentThread.CurrentUICulture = ci;
The above example sets the culture of the thread to Belgian-Dutch.
CurrentCulture does all the date and time handling and CurrentUICulture handles UI localization like resources.

I'm not sure if this would work for a web app, but you could try to set the DateTimeFormat property for the current culture.
Check this and specially this.

Using .Net 6 put something like this in your program.cs after app.UseAuthentication()/app.UseAuthorization() and before app.MapControllerRoute(...):
var ci = new CultureInfo("en-US");
ci.DateTimeFormat.ShortDatePattern = "MM/dd/yyyy";
app.UseRequestLocalization(new RequestLocalizationOptions
{
DefaultRequestCulture = new Microsoft.AspNetCore.Localization.RequestCulture(ci),
SupportedCultures = new List<CultureInfo> { ci },
SupportedUICultures = new List<CultureInfo> { ci }
});
Here I'm changing the short date format, but you can also change currency symbol, decimal separator, etc.

You can write an ExtensionMethod like this:
public static string ToMyString(this DateTime dateTime)
{
return dateTime.ToString("needed format");
}