We Keep Coding

Error while Converting specific date time to Sydney date using c# code

Using below code I am trying to convert specific date time to Sydney date time.
string datetime = "20200424-04:09:42.145";
datetime = datetime.Replace("-", " ").Insert(4, "-").Insert(7, "-");
TimeZoneInfo dest = TimeZoneInfo.FindSystemTimeZoneById("AUS Eastern Standard Time");
TimeZoneInfo src = TimeZoneInfo.FindSystemTimeZoneById("Greenwich Standard Time");
DateTime convertTime = TimeZoneInfo.ConvertTimeToUtc(Convert.ToDateTime(datetime), src);
DateTime transactTime = TimeZoneInfo.ConvertTimeBySystemTimeZoneId(convertTime, dest.Id);
Getting output invalid format - 4/24/2020 2:09:42 PM.145
System format date format dd/mm/yyyy and time in 24 hours

A few things:
That input format is non-standard and a bit strange. If you can change wherever it is constructed, that would be a better approach. In the meantime, I suggest you parse it with DateTime.ParseExact instead of replacing characters to get Convert.ToDateTime to recognize it.
Greenwich Standard Time is the local time zone identifier for Monrovia (Liberia) and Reykjavik (Iceland) (and a few others). I suspect you are actually trying to convert from GMT/UTC to Sydney time. If so, you only need one conversion function - ConvertTimeFromUtc.
You say you're getting invalid output format, but you don't show how you create that. I assume you are doing something like Console.WriteLine(transactTime), or just putting transactTime in some other place that converts it to a string. When doing so, it will use the general format controlled by the current culture. (See the Remarks section in the DateTime.ToString documentation.)
It sounds like instead you would like a specific format, which you can get by specifying the desired output in the ToString method. You can either specify a standard format token (usually used with the current culture), or your own custom formatting tokens (usually used with the InvariantCulture).
A complete example illustrating the above points:
// Parse the input string to a DateTime, from a given format
DateTime dt = DateTime.ParseExact("20200424-04:09:42.145", "yyyyMMdd-HH:mm:ss.fff", CultureInfo.InvariantCulture);
// Convert the datetime from UTC to Sydney time
TimeZoneInfo dest = TimeZoneInfo.FindSystemTimeZoneById("AUS Eastern Standard Time");
DateTime transactTime = TimeZoneInfo.ConvertTimeFromUtc(dt, dest);
// Create and output the string you want to output, in a specific format
string output = transactTime.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture);
Console.WriteLine(output);
// Output: "2020-04-24 14:09:42.145"
(Working .NET Fiddle here.)

Parse Date Time from US Time zone to Datetime.

How to parse below date time string?
2014-01-17T09:59:24.000Z
I tried below code but its, not working.
DateTime.ParseExact("2014-01-17T09:59:24.000Z", "ddd MMM dd HH:mm:ss %zzzz yyyy", CultureInfo.InvariantCulture);

With a string like "2014-01-17T09:59:24.000Z"
You can just use DateTime.Parse("2014-01-17T09:59:24.000Z")
From The Documentation:
The string to be parsed can take any of the following forms:
A string that includes time zone information and conforms to ISO 8601. In the following examples, the first string designates Coordinated Universal Time (UTC), and the second string designates the time in a time zone that's seven hours earlier than UTC:
2008-11-01T19:35:00.0000000Z
2008-11-01T19:35:00.0000000-07:00

From DateTime.ParseExact
Converts the specified string representation of a date and time to its
DateTime equivalent using the specified format and culture-specific
format information. The format of the string representation must match
the specified format exactly.
Clearly your string representation and format is not the same.
You can use it like;
var date = DateTime.ParseExact("2014-01-17T09:59:24.000Z",
"yyyy-MM-dd'T'HH:mm:ss.fff'Z'",
CultureInfo.InvariantCulture);
Console.WriteLine(date);
Output will be;
1/17/2014 9:59:24 AM
Here a demonstration.
For more information, take a look at;
Custom Date and Time Format Strings

The value you have, 2014-01-17T09:59:24.000Z is an ISO8601/RFC3339 formatted timestamp. The Z at the end is significant, which means that it represents UTC.
You have two options to correctly parse it:
You could parse it to a DateTime that has DateTimeKind.Utc for it's .Kind property:
DateTime dt = DateTime.ParseExact("2014-01-17T09:59:24.000Z",
"yyyy-MM-dd'T'HH:mm:ss.fffK",
CultureInfo.InvariantCulture,
DateTimeStyles.RoundtripKind);
Or, you could parse it to a DateTimeOffset, where UTC will correspond to an offset of zero:
DateTimeOffset dt = DateTimeOffset.ParseExact("2014-01-17T09:59:24.000Z",
"yyyy-MM-dd'T'HH:mm:ss.fffK",
CultureInfo.InvariantCulture);
Some of the other answers here are close, but are forgetting to actually consider the Z in your string, using the K specifier and the DateTimeStyles.RoundtripKind parameter. These are important, for without them you will likely end up with a resulting DateTime that has DateTimeKind.Unspecified, which could get treated as local time in certain time zone conversion functions. If you use either of the options I gave you, then the meaning of the Z is preserved.

convert date string to datetime

I have date string in format dd-MMM-yyyy and want to convert this to datetime, when I use below code
DateTime.ParseExact("20-Oct-2012", "yyyy-MM-dd HH:mm tt", null)
it causing an error
String was not recognized as a valid DateTime.
When I modify above code
DateTime.ParseExact("20-Oct-2012", "dd-MMM-yyyy", null)
then I got date time in format (mm/dd/yyyy) : 10/20/2012 12:00:00 AM
But I need it should be converted in yyyy/mm/dd format. Please help me in this regard.

You should try this
DateTime.ParseExact("20-Oct-2012", "dd-MMM-yyyy", null).ToString("yyyy/mm/dd")
For further reading on formats Check This

You need to distinguish between two separate concerns: that of parsing your original string into an abstract DateTime representation, and that of converting the latter back into another string representation.
In your code, you're only tackling the former, and relying on the implicit ToString() method call (which uses the system's current locale) to convert it back to string. If you want to control the output format, you need to specify it explicitly:
// Convert from string in "dd-MMM-yyyy" format to DateTime.
DateTime dt = DateTime.ParseExact("20-Oct-2012", "dd-MMM-yyyy", null);
// Convert from DateTime to string in "yyyy/MM/dd" format.
string str = dt.ToString("yyyy/MM/dd");
Also note that the mm format specifier represents minutes; months are represented by MM.
Edit: 'Converted date contain value "10/20/2012 12:00:00 AM".' Be careful what you mean by that. The constructed DateTime value contains an abstract representation of the parsed date and time that is independent of any format.
However, in order to display it, you need to convert it back into some string representation. When you view the variable in the debugger (as you're presumably doing), Visual Studio automatically calls the parameterless ToString() method on the DateTime, which renders the date and time under the current culture (which, in your case, assumes the US culture).
To alter this behaviour such that it renders the date and time under a custom format, you need to explicitly call the ToString(string) overload (or one of the other overloads), as I've shown in the example above.

You could try this instead :
Convert.ToDateTime("20-Oct-2012").ToString("yyyy/MM/dd")
Hope this will help !!

Converting the WhenChanged attribute (Generalized-Time) in LDAP to a DateTime in C#

I recently switch from using S.DS namespace (which uses ADSI) to the S.SD.Protocol namespace. The only problem is that ADSI handled the conversion of Generalized-Time to a DateTime for me. Now I'm getting back a value of "20070828085401.0Z" for the WhenChanged attribute. DateTime.Parse() will not convert this so is there another way?

The format you are getting is close to the round trip date time pattern ("o") and universal sortable round trip date time pattern ("u") standard date time format strings as described here.
One kludgy solution would be to massage the string you get to fit the pattern and then use the "o" or "u" standard format string with ParseExact.
A better way would be to construct a custom format string that matches the data you are already getting. In the "How Standard Format Strings Work" section of the standard date time format strings page you'll see the full custom formatting strings equivalent to "o" and "u". That should give you a good start.
EDIT: Add code
string format = "yyyyMMddHHmmss.f'Z'";
string target = "20070828085401.0Z";
DateTime d = DateTime.ParseExact(target, format, CultureInfo.InvariantCulture);
In the comments lixonn observes that, using the format string above, ParseExact will not successfully parse a time string like 199412160532-0500.
It also won't parse a number of other valid strings such as times without the trailing 'Zulu' indicator (20070828085401.0); times without a fractional part (20070828085401Z) and times that represent minutes and seconds as a fractional hour (2007082808.90028Z).
The format string can be made slightly more forgiving by replacing the hard-coded 'Z' with the K custom specifier which will accept 'Z', an offset like -0500, and nothing. Whether that additional flexibility is a good thing will depend on your application.
Note that even with the K specifier Lixonn's string won't be parsed successfully since it lacks a fractional part to match the .f component of the format string.

You'll have to use DateTime.ParseExact() specifying the exact format.
You might have to play with the format a little bit but it would be something like this.
DateTime result;
CultureInfo provider = CultureInfo.InvariantCulture;
string format="yyyyMMddhhmmss.0Z";
result = DateTime.ParseExact(dateString, format, provider);

You can use datetime's .strptime().
import datetime
# Since 0Z denotes UTC, you can get rid of it and apply the timezone
# later if you would like
time_string = "20070828085401.0Z".split('.')[0]
time_object = datetime.datetime.strptime(time_string, "%Y%m%d%H%M%S")
time_object should output as datetime.datetime(2007, 8, 28, 8, 54, 1). I believe it will be timezone naive, and equivalent to UTC time.

// WIN32 FILETIME is a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).
// While the unix timestamp represents the seconds since January 1, 1970 (UTC).
private static long Win32FileTimeToUnixTimestamp(long fileTime)
{
//return fileTime / 10000L - 11644473600000L;
return DateTimeOffset.FromFileTime(fileTime).ToUnixTimeSeconds();
}
// The GeneralizedTime follows ASN.1 format, something like: 20190903130100.0Z and 20190903160100.0+0300
private static long GeneralizedTimeToUnixTimestamp(string generalizedTime)
{
var formats = new string[] { "yyyyMMddHHmmss.fZ", "yyyyMMddHHmmss.fzzz" };
return DateTimeOffset.ParseExact(generalizedTime, formats, System.Globalization.CultureInfo.InvariantCulture).ToUnixTimeSeconds();
}

parse iCalendar date using c#

Is there a direct way to parse an iCalendar date to .net using c#?
An iCalendar date looks like this:
2009-08-11T10:00+05:0000
I need to parse it to display it in a friendly format... thanks

string strDate = "2009-08-11T10:00+05:0000";
DateTimeFormatInfo dtfi = new DateTimeFormatInfo();
dtfi.FullDateTimePattern = "yyyy-MM-ddTHH:mmzzz";
DateTime dt = DateTime.Parse(c.Substring(0, c.Length-2), dtfi);
zzz is for time zone, but is only recognized when expressed like this: +xx:xx.
I tested with your example, removing the last 2 0's then parsing with a custom DateTimeFormatInfo works.

You can use DateTime.Parse() to parse everything before the +. I do not know the iCalendar format specification but I assume after the + is the hours/minutes to add to the date before the +. So you could then use AddHours() and AddMinutes() to add the required bits to the DateTime returned by DateTime.Parse().
This requires a bit of string parsing but with a bit of regex you should be fine...

Since this is not a standard format string, but you know the exact format, you can use DateTime.ParseExact and specify a custom format string, like this:
DateTime.ParseExact(d, "yyyy-MM-ddTHH:mmzzz00", CultureInfo.InvariantCulture);
The 'zzz' specifier represents the hours and minutes offset from UTC, and the two concluding zeros are just literals to match format with which you're dealing.