Develop Reference

Is it possible to get the data from a range in an easy way in C#?

I have a range of 2 dates given by my business: "we would like to have all data from July and 6 previous months". I create two dates:
_range1.MaxDateTime = new DateTime(today. Year, 7, 31);
_range1.MinDateTime = rangeLastDate.AddMonths(-6).AddDays(1);
Because the system will always perform the calculation on last 6 months. Last date is also always end of month. I have no problem to get the last day of the month. C# has the feature EndOfMonth() for this. But when I do so I always get the last day at midnight. when I create the DateTime() myself I also get a date a midnight.
In my code I use Entity Framework with LinQ. (old EF, not Core yet)
_range1_ShippedQuantities = DbContext.Job_Dtl
.Where(j=> j.LastShipDate >= _range1.MinDateTime && j.LastShipDate <= _range1.MaxDateTime)
This is not correct because my last datetime is the 31 at midnight and not the first of next month at midnight. I should do
_range1_ShippedQuantities = DbContext.Job_Dtl
.Where(j=> j.LastShipDate.Date >= _range1.MinDateTime.Date && j.LastShipDate.Date <= _range1.MaxDateTime.Date)
Or I can also manipulate the dates do force the time at 23:59:59... what I don't like. I still miss 1 second. I can add 999 milliseconds but i will still tell you I miss one millisecond. I can also add one day in a temp variable and use this temp variable in my LinQ query... yes but I have the feeling there is something better. How do you deal with these ranges?
But LinQ does not allow this. LinQ for entities cannot recognize the date.

As several people have commented on your question, the simplest and most common way to solve this problem is to choose an exclusive end date rather than an inclusive one.
var minDateInclusive = rangeLastDate.AddMonths(-6).AddDays(1);
var maxDateExclusive = rangeLastDate.AddDays(1);
DbContext.Job_Dtl
.Where(j=> j.LastShipDate >= minDateInclusive
&& j.LastShipDate < maxDateExclusive);

Should i use 23:59:59 or 00:00:00 for 12 AM in 24 hours time format?

When I search about maximum time. people always answering that from VS debugger. which is 23:59:59.9999999
As I need 12 AM in 24 formats. I guess it will be 00:00:00 but...
C# .NET assume the following:
var xx = DateTime.MaxValue.ToString("HH:mm:ss.fffffff");
When debugging previous it will print 23:59:59.9999999
What should I use? does it matter? what's the difference?
Should use 00:00:00 ? or 23:59:59.9999999 Specially when
saving Time in SQL-Server.
The big problem or I mean un-good behavior for end-user when you convert 24 formats to 12 Hour format via hh:mm:ss it will show 11:59:59 PM it will be ugly isn't it? it should be 12:00:00 AM.
After All, Obsidian Age answered this well depending on the use case.

It depends on perspective:
var xx = DateTime.MaxValue.ToString("HH:mm:ss.fffffff");
var xy = DateTime.MinValue.ToString("HH:mm:ss.fffffff");
Gives
23:59:59.9999999
00:00:00.0000000
So, one is the end of the day and the other is the beginning of the day.
There's an interesting novel called 'The time between midnight'

DateTime.MaxValue is exactly that - the maximum value that DateTime can represent; that is to say, the 'last' point in a day. Conversely, the .Date property makes use of 00:00:00 by default, as it has no notion of time (unless specified).
If you have an event that occurs at exactly midnight, I would recommend storing it as 00:00:00, as the event occurs at midnight, and you want to accurately represent that.
Ultimately, it really depends on your desired use case as to which one you want to use. Do you want to state that the event occurs on day 1's evening, or day 2's beginning? That is what it boils down to, although in the vast majority of cases such a delineation makes no difference. In this case you would want to opt for both the accuracy and 'ease' of 00:00:00.

programmatically speaking, you can do both. the only difference between them (in code) is this :
// using 00:00:00 will require you to add 1 day to the end date in order to count as full day
if(time >= "2019-12-03 00:00:00" && time < "2019-12-04 00:00:00")
//using 23:59:59 will not require you to add 1 day to the end date.
if(time >= "2019-12-03 00:00:00" && time <= "2019-12-03 23:59:59")
so, basically, if you use 23:59:59 there is a one second off the grid, if any record has been stored in this second, it'll not be included in the results. while the second one will include it.
Which one to use ? surely the 00:00:00 if you want to be more precise, however, I've not seen any difference in the results in my projects as I've used both of them in different projects. But I'm sure there are some projects needs to include every micro second as this microsecond could change the result's curve (such as analytics or deep learning ..etc).
In SQL Server, don't save the time as string, save it with the correct datatype (DateTime, TimeSpan ..etc). SQL Server will reads the time perfectly fine when you pass a correspond time datatype from your application.

A few things:
The maximum value that a DateTime in C# can represent is 9999-12-31 23:59:59.9999999. In SQL Server, this corresponds to a datetime2, which has the same maximum value.
The time type in SQL Server also has a maximum value of 23:59:59.9999999 (though note that a C# TimeSpan can be much larger because it primarily represents duration instead of time of day).
If you are storing just a time range using the time type, you'll need that 23:59:59.9999999 value for the end of the day. You can get this quickly in C# with DateTime.MaxValue.TimeOfDay. Indeed it will be one tick less than a true 24:00.
There are 7 decimals of nines because that is the precision offered by the data type. If you choose a lower precision, there is some small (but not impossible) chance that a given value could fall after it. Thus when you use this technique, always align the nines with the full precision of the data type. (Don't just subtract one second or one millisecond.)
When calculating the difference of a datetime range such as 2020-01-01 00:00 to 2020-01-01 01:00, one can simply subtract the two values to get the result (1 hour in this case). However, when using 23:59:59.99999999, one has to account for the missing tick. This can get messy, and such there is a significant advantage to using 00:00 instead.
As you pointed out, when displaying 23:59:59.9999999 to an end user, you may have to write your own logic to format it as 24:00 or as "end of day", etc.
When comparing datetime ranges, you'll want to use a different operator for the end comparison:
If you use 23:59:59.9999999, use a fully-inclusive range comparison: a <= now && b >= now
If you use 00:00, use a half-open range comparison - inclusive at the start, exclusive at the end: a <= now && b > now
When comparing time-only ranges (i.e. timspan types), the same logic applies, but one also has to consider time ranges that span over midnight:
If you use 23:59:59.9999999:
if (a < b)
result = a <= now && b >= now;
else
result = a <= now || b >= now;
If you use 00:00:
if (a < b)
result = a <= now && b > now;
else
result = a <= now || b > now;
In summary, it is generally simpler to work with 00:00 values instead of 23:59:59.9999999 values, and thus you should prefer 00:00. If you find the need to use 23:59:59.9999999, you should be aware of the coding changes required.

Time-dependent coloring in C#

I need time-dependent coloring in a project. If the system is 10 minutes past the entrance time, the background will be orange. If it is 20 minutes past it will be red. I found the difference between the two dates using the
DateTime.Parse(timeNow).Subtract(DateTime.Parse(timeLogged));
but I can't compare the result.
if(Convert.ToInt32(DateTime.Parse(timeNow).Subtract(DateTime.Parse(timeLogged)))>10)
Does it have a similar use? Can you help me how to do it?
I am using Google Translate because my English is not very good, and I apologize for the language mistakes I made.

You can subtract DateTime objects. You'll get a TimeSpan. You can use that TimeSpan to determine the difference between the original objects:
DateTime now = DateTime.Parse(timeNow);
DateTime logged = DateTime.Parse(timeLogged);
TimeSpan diff = now - logged;
if (diff.TotalMinutes > 10)
// It's been more than 10 minutes.

You could do this aswell
// If older than 20 min
if(DateTime.Parse(timeLogged) < DateTime.Now.AddMinutes(-20))
{
// Do stuff
}

DateTime.Subtract returns a Timespan object that has a TotalMinutes property, so you could do this:
if (DateTime.Parse(timeNow).Subtract(DateTime.Parse(timeLogged)).TotalMinutes > 10)

Validation to make sure time difference is inside 2 hours

I have start time and end time in my asp.net web application. Now i want to validate that if start time is selected say 10:00 AM then end time should be selected with the gap of 2 hours or less. Hence if i select 01:00 PM as a end time, then this should not happen.
How can i validate the same?

If you use addition or subtraction on a DateTime class it returns a TimeSpan which can be compared in a conditional.
When creating a new TimeSpan class you can set the hours minuets and seconds in this form:
new TimeSpan(hours, minutes, seconds);
In your case you want to use:
new TimeSpan(2, 0, 0);
Try something like this:
//Assuming you created your variables and assigned them somewhere above
DateTime startTime, endTime;
if(endTime - startTime > new TimeSpan(2, 0, 0)) {
//validation error
}

Use a CompareValidator with type=DateTime to make sure EndTime > BeginTime. This will also validate they're both valid Time values.
Use a CustomValidator (C# and optionally JavaScript) to enforce the 2 hour rule.
Optionally add 1 or 2 RequiredFieldValidators

As mentioned you can use a custom validation implementation. This would check that the current time selected 'start' was no more than 2 hours previous (or exactly dependent on your conditions).
Another thing to look at is 'range-validation' which should accommodate your requirements. Take a look here on MSDN for examples: http://msdn.microsoft.com/en-us/library/aa479013.aspx#aspnet-validateaspnetservercontrols_topic5

C#: calculating time diff

using the following:-
TimeSpan diff = dt2.TimeOfDay - dt1.TimeOfDay;
d1, d2 are 2 variables of type DateTime and they have got values in them
Now I want to check if there's a difference of 12 hours b/w them
if(diff>12)
{
//do stuff
}
now of course it wont wont coz 12 is an int..so how do I check if the time is more than 12 hrs or not ?? need help with this if statement only..thnx

The general solution is to construct a TimeSpan object that corresponds to the cut-off:
if(diff > TimeSpan.FromHours(12))
{
...
}
If the cut-off corresponds to a multiple of a 'nice' unit of time like days, hours, minutes, seconds or milliseconds as in your example, you could use the TotalXXX property of TimeSpan, as others have posted:
if(diff.TotalHours > 12)
{
...
}

To plainly answer your question, you use one of the properties on the TimeSpan struct, typically the TotalHours property. There are other, simpler, answers here that tells you how to do that, so I won't repeat it.
However, this means I must trust your question to be complete, and I think that just ignoring the date portion will give you edge-cases that you at least need to know about.
For instance, with the following two time-of-day values, how much time is between them?
18:00
08:00
Is it -10 hours, or 14hours between these two?
To properly answer your question, personally I would want you to tell me how you intend to use these values, what it means to you, and give a few examples.

use
if( diff.TotalHours > 12){
....
}

Have you actually used intellisense and noticed the Hours and TotalHours properties on the diff TimeSpan object?

TimeSpan.FromHours you need to use to find the difference

TimeSpan diff = dt2.Substract(dt1);
if (diff.TotalHours > 12)
{
// Do something
}