Develop Reference

TimeSpan calculation is different between TimeOnly and DateTime

I'm having a hard time understanding why this is happening or even if this should be happening. If I calculate the TimeSpan between two DateTime objects (same date, different times) and compare it to the same calculation using two TimeOnly objects I get different results.
var start = new DateTime(1, 1, 1, 14, 0, 0);
var end = new DateTime(1, 1, 1, 10, 0, 0);
Console.WriteLine(end - start); // Prints -4 hours
However...
var start = new TimeOnly(14, 0, 0);
var end = new TimeOnly(10, 0, 0);
Console.WriteLine(end - start); // Prints 20 hours???
Isn't the span between starting at 2pm and ending at 10am always a span of -4 hours? Interestingly enough if I take the second one and do Console.WriteLine(end.ToTimeSpan() - start.ToTimeSpan()); I end up with -4 hours.
This feels like an error on TimeOnly's part but I don't know. Here is a fiddle I did comparing results between NodaTime, System.DateTime, converting System.TimeOnly to TimeSpan, and System.TimeOnly.

Difference between two times C# [duplicate]

How do I get the time difference between two DateTime objects using C#?

The following example demonstrates how to do this:
DateTime a = new DateTime(2010, 05, 12, 13, 15, 00);
DateTime b = new DateTime(2010, 05, 12, 13, 45, 00);
Console.WriteLine(b.Subtract(a).TotalMinutes);
When executed this prints "30" since there is a 30 minute difference between the date/times.
The result of DateTime.Subtract(DateTime x) is a TimeSpan Object which gives other useful properties.

You want the TimeSpan struct:
TimeSpan diff = dateTime1 - dateTime2;
A TimeSpan object represents a time interval (duration of time or elapsed time) that is measured as a positive or negative number of days, hours, minutes, seconds, and fractions of a second. The TimeSpan structure can also be used to represent the time of day, but only if the time is unrelated to a particular date.
There are various methods for getting the days, hours, minutes, seconds and milliseconds back from this structure.
If you are just interested in the difference then:
TimeSpan diff = (dateTime1 - dateTime2)).Duration();
will give you the positive difference between the times regardless of the order.
If you have just got the time component but the times could be split by midnight then you need to add 24 hours to the span to get the actual difference:
TimeSpan diff = dateTime1 - dateTime2;
if (diff < 0)
{
diff = diff + TimeSpan.FromDays(1);
}

What you need is to use the DateTime classs Subtract method, which returns a TimeSpan.
var dateOne = DateTime.Now;
var dateTwo = DateTime.Now.AddMinutes(-5);
var diff = dateTwo.Subtract(dateOne);
var res = String.Format("{0}:{1}:{2}", diff.Hours,diff.Minutes,diff.Seconds));

The way I usually do it is subtracting the two DateTime and this gets me a TimeSpan that will tell me the diff.
Here's an example:
DateTime start = DateTime.Now;
// Do some work
TimeSpan timeDiff = DateTime.Now - start;
timeDiff.TotalMilliseconds;

IF they are both UTC date-time values you can do TimeSpan diff = dateTime1 - dateTime2;
Otherwise your chance of getting the correct answer in every single possible case is zero.

var startDate = new DateTime(2007, 3, 24);
var endDate = new DateTime(2009, 6, 26);
var dateDiff = endDate.Subtract(startDate);
var date = string.Format("{0} years {1} months {2} days", (int)dateDiff.TotalDays / 365,
(int)(dateDiff.TotalDays % 365) / 30, (int)(dateDiff.TotalDays % 365) / 30);
Console.WriteLine(date);

private void button1_Click(object sender, EventArgs e)
{
TimeSpan timespan;
timespan = dateTimePicker2.Value - dateTimePicker1.Value;
int timeDifference = timespan.Days;
MessageBox.Show(timeDifference.ToString());
}

You can use in following manner to achieve difference between two Datetime Object. Suppose there are DateTime objects dt1 and dt2 then the code.
TimeSpan diff = dt2.Subtract(dt1);

You need to use a TimeSpan. Here is some sample code:
TimeSpan sincelast = TimeSpan.FromTicks(DateTime.Now.Ticks - LastUpdate.Ticks);

String format with a negative timespan

I have an issue with a string format with a timespan.
string.Format("{0:00}:{1:00}", Math.Floor(ts.TotalHours), ts.Minutes)
Which produce this result 12:08 but the problem is that it can go in minus then it look like this -01:-59 which is not correct it should look like this -01:59.
I have tried to use the Math.Abs, but it will just show a 0 even if the number is -56
What is the best way to handle this?

You can use Math.Abs:
string.Format("{0:00}:{1:00}", Math.Floor((decimal)ts.Hours), Math.Abs(ts.Minutes))
Examples:
TimeSpan ts = new TimeSpan(-1, -1, 0); // returns -01:01
ts = new TimeSpan(-1, 1, 0); // returns -00:59
ts = new TimeSpan(1, 1, 0); // returns 01:01

c# - Substracting two times returns negative value

I'm having problems when I'm trying to substract hr2 with hr1 in a specific situation, for example, when hr1 = 13:00 and hr2 = 15:00, ok, the result is 02:00.
But when the values are: hr1 = 22:00 and hr2 = 02:00, the result is 20:00.
The result should be 04:00.
TimeSpan ts1 = hr1.Subtract(hr2).Duration();
TextBox1.Text = ts1.ToString();
How can I solve this problem?

I understand what you want, but how you currently try to achieve it makes no sense. 22 hours minus 20 hours is 2 hours, which is correct.
You probably want this:
new DateTime(1, 1, 2, 2, 0, 0) - new DateTime(1, 1, 1, 22, 0, 0)
You don't want to subtract TimeSpan's, you want to subtract dates (fake dates in this case).

Invoking Duration() will always result in a positive TimeSpan. The problem is coming from the fact that you are discarding days in your calculation. 22:00-02:00 is 20:00. I believe you are expecting it to be 04:00 because 02:00 represents "tomorrow." If that is what you want, you will need to calculate 22:00-(02:00+24:00) which will give you -04:00, which will become 04:00 when you invoke Duration().

You are trying to subtract two "spans", or durations, of time--not fixed points in time. What your code is currently saying is, I want to subtract two hours from twenty hours (which is indeed twenty hours). Instead, you need to use DateTimes. The hard part is going to be deciding the date for your timespans. I would rework the code to use DateTimes and preserve the "moments" in time that you are actually attempting to calculate.
Edit: Converting from a TimeSpan to a DateTime can cause you to lose information that affects the outcome of the result:
var ts1 = new DateTime (1, 1, 1, hr1.Hours, hr1.Minutes, hr1.Seconds, hr1.Milliseconds) -
new DateTime (1, 1, 1, hr2.Hours, hr2.Minutes, hr2.Seconds, hr2.Milliseconds);
is different than:
var ts1 = new DateTime (1, 1, 1, hr1.Hours, hr1.Minutes, hr1.Seconds, hr1.Milliseconds) -
new DateTime (1, 1, 2, hr2.Hours, hr2.Minutes, hr2.Seconds, hr2.Milliseconds);
or:
var ts1 = new DateTime (1, 1, 2, hr1.Hours, hr1.Minutes, hr1.Seconds, hr1.Milliseconds) -
new DateTime (1, 1, 1, hr2.Hours, hr2.Minutes, hr2.Seconds, hr2.Milliseconds);
Which is why you need to maintain the "point in time" with a DateTime.

How do I format hours in DateTime to return 0 instead of 12?

By default, the hour in a format string for a DateTime transforms 0 into 12.
For example, if you have
DateTime dt = new DateTime(1999, 1, 1, 0, 0, 0);
string s = dt.ToString("h:mm:ss");
the value of s will be "12:0:0", not "0:0:0". Is there a way to get "0:00:00" instead?

Try
string s = dt.ToString("H:mm:ss");
Here's the reference page.

You were close, try using this instead:
string s = dt.ToString("H:mm:ss");

string s = (dt.Hour >= 12 ? dt.Hour - 12 : dt.Hour).ToString() +
dt.ToString(":mm:ss");
Apparently this was not what you were looking for. The way I read your post, you wanted a 12-hour clock that remapped "12:00" to "0:00" (some international clocks do this), which this produces. There is no format string for this behavior, so you have to create the string yourself.
You can also read more on DateTime format strings here.

Instead of "h:mm:ss", use "H:mm:ss"

You need to use a capital H instead of the lowercase h inside the ToString method.
I.e.
DateTime dt = new DateTime(1999, 1, 1, 0, 0, 0);
string s = dt.ToString("H:mm:ss");