Develop Reference

Operator cannot be applied to operands of type string and int

Error:
Operator '<=' cannot be applied to operands of type string and int.
In my case 'details[0].max' Consists of value 0.0 like this.
if (!string.IsNullOrEmpty(details[0].customsalary) && (details[0].max) <= 0 && (details[0].max) <= 0)
{
_jobdetailsmodel.Salary = details[0].customsalary;
}
if value of details[0].max is 0.0 and details[0].min is 0.0 then condition should become true.

It seems that 'details[0].max' is string type So please cast it it to Double as:
Convert.ToDouble(details[0].max)

Explicitly cast details[0].max to a number, something like
if (!string.IsNullOrEmpty(details[0].customsalary) && decimal.Parse(details[0].max) <= 0)
depending on the expected type of details[0].max.

The issue is down to your .max variables likely being strings. The below code should be enough to get your if statement to work by converting them to integers in the if statement.
I would recommend however potentially reviewing your code and maybe converting these variables to integers in order to avoid having to convert their values at all.
if (!string.IsNullOrEmpty(details[0].customsalary) && Convert.ToInt32(details[0].max) <= 0 && Convert.ToInt32(details[0].max) <= 0)
{
_jobdetailsmodel.Salary = details[0].customsalary;
}

Details[0].max is a string, therefor you need to convert to int, the below code allows for incorrectly formatted strings, where int.Parse will throw an exception if the string is invalid:
if (!string.IsNullOrEmpty(details[0].customsalary) &&
int.TryParse(details[0].max, out var max) &&
int.TryParse(details[0].min, out var min) &&
max <= 0 && min <= 0)
{
_jobdetailsmodel.Salary = details[0].customsalary;
}

details is array of what ? And max, it's an int, a double, something else ?
There is an example of a Detail class:
public class Detail1
{
public string CustomSalary { get; set; }
public int Max { get; set; }
public decimal Max2 { get; set; }
}
It could be :
public class Detail2
{
public string CustomSalary { get; set; }
public string Max { get; set; }
public string Max2 { get; set; }
}
Please be more specific
using Detail2 class, you can use Parse extension methods (numeric types has this extension method):
if(!string.IsNullOrWhiteSpace(detail[0].CustomSalary)
&& int.Parse(details[0].Max) <= 0
&& decimal.Parse(details[0].Max2 <= 0.0m))
{
//....
}
You can use System.Convert class too:
if(!string.IsNullOrWhiteSpace(detail[0].CustomSalary)
&& Convert.ToInt(details[0].Max) <= 0
&& Convert.ToDecimal(details[0].Max2 <= 0.0m))
{
//....
}
And if you're not sure there's any value (in details[0]), you can add ? after details[0] and/or use TryParse extension method:
int.TryParse(details[0].Max, out int max);
decimal.TryParse(details[0]?.Max2, out decimal max2);
if(!string.IsNullOrWhiteSpace(detail[0]?.CustomSalary)
&& max <= 0
&& max2 <= 0.0m)
{
//....
}
I this case, you don't know the type of Max and Max2 properties. (it can be a simple object)

C# Method to Compare DateTime Fields Specified During Execution?

My project has many objects with date fields, and I often need to select everything where one such field is within a date range.
For example:
public class Contract
{
public DateTime SignDate { get; set; }
public DateTime ReleaseDate { get; set; }
}
public class PersonalCheck
{
public DateTime SignDate { get; set; }
public DateTime ProcessDate { get; set; }
public DateTime VoidDate { get; set; }
}
If I only cared about SignDate, it would be easy. I would declare an Interface...
public interface IObjectWithSignDate
{
DateTime SignDate { get; set; }
}
...change my other objects to inherit from it, then create a method like this:
public static IQueryable<T> SignedWithin<T>(this IQueryable<T> items, DateTime start, DateTime end) where T : IObjectWithSignDate
{
return items.Where(q => q.SignDate >= start && q.SignDate <= end);
}
How can I avoid rewriting this function for ReleaseDate, ProcessDate, VoidDate, etc.? Can I make this method take in an IQueryable of any object and a variable telling it which date field to run this selector against?
Note this would have to be able to a) execute in LinqToEntities to run against a database and b) not add a lot of overhead (as I'm fearful reflection might do)

Simple but specific
You can add an extension method like this:
public static class DateTimeExtensions
{
public static bool IsBetween(this DateTime thisDateTime, DateTime start, DateTime end)
{
return thisDateTime >= start && thisDateTime <= end;
}
}
which you can unit test in isolation.
Then you can use this on whichever DateTime field you want to check. For example:
var start = new DateTime(2017, 1, 1);
var end = new DateTime(2017, 12, 31, 23, 59, 59);
IList<Contract> contracts = new List<Contract>(); // or anything enumerable
var contractsSignedBetween = contracts.Where(x => x.SignDate.IsBetween(start, end));
var contractsReleasedBetween = contracts.Where(x => x.ReleaseDate.IsBetween(start, end));
(Notice how I set the start datetime to have 00:00:00 time, and the end datetime to have 23:59:59 time [feel free to include milliseconds as well], so that times within the last day are included.)
Making that reusable
If you find yourself needing to do that a lot, you could do an extension for that
public static class EnumerableContractsExtensions
{
public static IEnumerable<Contract> SignedBetween(this IEnumerable<Contract> contracts, DateTime start, DateTime end)
{
return contracts.Where(x => x.SignDate.IsBetween(start, end));
}
}
and use it like this
var contractsSignedBetween = contracts.SignedBetween(start, end);
which could also be unit tested in isolation.
More flexible but specific
Use an expression to say which date you want...
public static class EnumerableContractsExtensions
{
public static IEnumerable<Contract> Between(this IEnumerable<Contract> contracts, Func<Contract, DateTime> selector, DateTime start, DateTime end)
{
return contracts.Where(x => selector(x).IsBetween(start, end));
}
}
and then do:
var contractsSignedBetween = contracts.Between(x => x.SignDate, start, end);
var contractsReleasedBetween = contracts.Between(x => x.ReleaseDate, start, end);
Flexible and generic
Go the whole hog and do it generically (although you can't make it an extension method since it's generic):
public static class EnumerableExtensions
{
public static IEnumerable<T> Between<T>(IEnumerable<T> items, Func<T, DateTime> selector, DateTime start, DateTime end)
{
return items.Where(x => selector(x).IsBetween(start, end));
}
}
again, this is testable in its own right, and can be used like this:
IList<Contract> contracts = new List<Contract>();
IList<PersonalCheck> personalChecks = new List<PersonalCheck>();
var contractsSignedBetween = EnumerableExtensions.Between(contracts, x => x.SignDate, start, end);
var checksSignedBetween = EnumerableExtensions.Between(personalChecks, x => x.SignDate, start, end);
Making it IQueryable
To make this work as IQueryable the approach needs to shift to an expression tree, since LINQ to Entities does not know how to translate a method into SQL.
public static IQueryable<TSource> Between<TSource, TKey>(
this IQueryable<TSource> source,
Expression<Func<TSource, TKey>> keySelector,
TKey low,
TKey high)
where TKey : IComparable<TKey>
{
Expression key = keySelector.Body;
Expression lowerBound = Expression.LessThanOrEqual(Expression.Constant(low), key);
Expression upperBound = Expression.LessThanOrEqual(key, Expression.Constant(high));
Expression and = Expression.AndAlso(lowerBound, upperBound);
Expression<Func<TSource, bool>> lambda =
Expression.Lambda<Func<TSource, bool>>(and, keySelector.Parameters);
return source.Where(lambda);
}
which would still be used like this:
var contractsSignedBetween = contracts.Between(x => x.SignDate, start, end);
And this works for things other than DateTimes as well. Hope this helps.

Streamline Date Parsing into method

I'm trying to think of a cleaner way to do this. I want to move this into a helper method but I do not like using out params. I realize I have to use out params for the TryParse, I don't have a choice but I'd like to get this into some kind of reusable method:
startDate and endDate are in "yyyy/mm/dd" format and are string to begin with and I'm parsing below.
DateTime startDt;
DateTime endDt;
startDt = (DateTime.TryParse(startDate, out startDt) ? startDt : DateTime.Now);
endDt = ((!DateTime.TryParse(endDate, out endDt) || string.IsNullOrEmpty(endDate))) ? (startDt.AddMinutes(Configuration.Instance.RecentOrdersWindowDurationMinutes)) : endDt;

Well, if you want two results from a single method you have to either use out parameters or some wrapping type. If you're lazy and only doing this once, you could just use Tuple<DateTime, DateTime>.
public Tuple<DateTime, DateTime> GetRange(string startDate, string endDate)
{
DateTime startDt;
DateTime endDt;
if (!DateTime.TryParse(startDate, out startDt))
startDate = DateTime.Now;
if (string.IsNullOrEmpty(endDate) || !DateTime.TryParse(endDate, out endDt))
endDt = startDt.AddMinutes(Configuration.Instance.RecentOrdersWindowDurationMinutes);
return new Tuple<DateTime, DateTime>(startDt, endDt);
}
If you're looking for the more generalized case, dealing with just one at a time, you could write a TryParse that accepts a default value.
public DateTime TryParseOrDefault(string str, DateTime def)
{
DateTime ret;
if (DateTime.TryParse(str, out ret))
return ret;
else
return def;
{
Edit:
In re to a comment, your concrete type would just look something like this:
public class DateRange
{
public DateTime StartDate { get; set; }
public DateTime EndDate { get; set; }
}
Then you could use that instead of the Tuple<DateTime, DateTime>.

You can declare your own TryParse helper method, but instead of returning bool and setting the actual DateTime value using out parameter, you can return DateTime?, which will let you set default value quite nicely using ?? operator:
public static class DateTimeUtils
{
public static DateTime? TryParse(string value)
{
DateTime result;
if (!DateTime.TryParse(value, out result))
return null;
return result;
}
}
var myString = "01/01/2015";
var myDateTime = DateTimeUtils.TryParse(myString) ?? DateTime.Now;
This way you don't have to declare myDateTime before calling TryParse, like you'd have to do with standard DateTime.TryParse method.
In your case it would be something like:
DateTime startDt = DateTimeUtils.TryParse(startDate) ?? DateTime.Now;
DateTime endDt = DateTimeUtils.TryParse(endDate) ?? startDt.AddMinutes(Configuration.Instance.RecentOrdersWindowDurationMinutes);

How to specify to validate this situation with generics?

I'm trying to validate this class: min >= max. I realized using generics I can't use the comparators.
This is my generic class.
public class Range<T>
{
public T MinValue { get; set; }
public T MaxValue { get; set; }
public Range() { }
public Range(T min, T max)
{
this.MinValue = min;
this.MaxValue = max;
}
public override bool Equals(object obj)
{
if (obj == null) return false;
var other = obj as Range<T>;
return this.MinValue.Equals(other.MinValue) &&
this.MaxValue.Equals(other.MaxValue);
}
public override string ToString()
{
return string.Format("{0},{1}", this.MinValue, this.MaxValue);
}
}
T datatype can be only numbers, is there a way to accept just numbers and accept the <=?

No, you can't constrain generics to numbers, but you can constrain T to IComparable<T> and then use CompareTo()
public class Range<T> where T : IComparable<T>
{
....
}
Then you can say:
if (min.CompareTo(max) >= 0)...
And throw a validation exception or whatever validation you'd like. You can use the same thing to make sure value is >= min and <= max.
if (value.CompareTo(min) >= 0 && value.CompareTo(max) <= 0)...

public class Range<T> where T : IComparable<T>
{
...
public bool Check(T value)
{
return value.CompareTo(min) >= 0 && value.CompareTo(max) <= 0;
}
}
If you range between 0 and 10, and want 0, 10 to fail (exclude min and max) - simply replace ">=" with ">" and "<=" with "<".
I would also recommend changing in the Equals override from:
return this.MinValue.Equals(other.MinValue) &&
this.MaxValue.Equals(other.MaxValue);
to this:
return this.MinValue.CompareTo(other.MinValue) == 0 &&
this.MaxValue.CompareTo(other.MaxValue) == 0;

How do you compare DateTime objects using a specified tolerance in C#?

By default C# compares DateTime objects to the 100ns tick. However, my database returns DateTime values to the nearest millisecond. What's the best way to compare two DateTime objects in C# using a specified tolerance?
Edit: I'm dealing with a truncation issue, not a rounding issue. As Joe points out below, a rounding issue would introduce new questions.
The solution that works for me is a combination of those below.
(dateTime1 - dateTime2).Duration() < TimeSpan.FromMilliseconds(1)
This returns true if the difference is less than one millisecond. The call to Duration() is important in order to get the absolute value of the difference between the two dates.

I usally use the TimeSpan.FromXXX methods to do something like this:
if((myDate - myOtherDate) > TimeSpan.FromSeconds(10))
{
//Do something here
}

How about an extension method for DateTime to make a bit of a fluent interface (those are all the rage right?)
public static class DateTimeTolerance
{
private static TimeSpan _defaultTolerance = TimeSpan.FromSeconds(10);
public static void SetDefault(TimeSpan tolerance)
{
_defaultTolerance = tolerance;
}
public static DateTimeWithin Within(this DateTime dateTime, TimeSpan tolerance)
{
return new DateTimeWithin(dateTime, tolerance);
}
public static DateTimeWithin Within(this DateTime dateTime)
{
return new DateTimeWithin(dateTime, _defaultTolerance);
}
}
This relies on a class to store the state and define a couple operator overloads for == and != :
public class DateTimeWithin
{
public DateTimeWithin(DateTime dateTime, TimeSpan tolerance)
{
DateTime = dateTime;
Tolerance = tolerance;
}
public TimeSpan Tolerance { get; private set; }
public DateTime DateTime { get; private set; }
public static bool operator ==(DateTime lhs, DateTimeWithin rhs)
{
return (lhs - rhs.DateTime).Duration() <= rhs.Tolerance;
}
public static bool operator !=(DateTime lhs, DateTimeWithin rhs)
{
return (lhs - rhs.DateTime).Duration() > rhs.Tolerance;
}
public static bool operator ==(DateTimeWithin lhs, DateTime rhs)
{
return rhs == lhs;
}
public static bool operator !=(DateTimeWithin lhs, DateTime rhs)
{
return rhs != lhs;
}
}
Then in your code you can do:
DateTime d1 = DateTime.Now;
DateTime d2 = d1 + TimeSpan.FromSeconds(20);
if(d1 == d2.Within(TimeSpan.FromMinutes(1))) {
// TRUE! Do whatever
}
The extension class also houses a default static tolerance so that you can set a tolerance for your whole project and use the Within method with no parameters:
DateTimeTolerance.SetDefault(TimeSpan.FromMinutes(1));
if(d1 == d2.Within()) { // Uses default tolerance
// TRUE! Do whatever
}
I have a few unit tests but that'd be a bit too much code for pasting here.

You need to remove the milliseconds component from the date object. One way is:
DateTime d = DateTime.Now;
d.Subtract(new TimeSpan(0, 0, 0, 0, d.Millisecond));
You can also subtract two datetimes
d.Subtract(DateTime.Now);
This will return a timespan object which you can use to compare the days, hours, minutes and seconds components to see the difference.

if (Math.Abs(dt1.Subtract(dt2).TotalSeconds) < 1.0)

I had a similar problem as the original questioner but to make things more interesting I was saving and retrieving Nullable<DateTime>.
I liked joshperry's answer and extended it to work for my purposes:
public static class DateTimeTolerance
{
private static TimeSpan _defaultTolerance = TimeSpan.FromMilliseconds(10); // 10ms default resolution
public static void SetDefault(TimeSpan tolerance)
{
_defaultTolerance = tolerance;
}
public static DateTimeWithin Within(this DateTime dateTime, TimeSpan tolerance)
{
return new DateTimeWithin(dateTime, tolerance);
}
public static DateTimeWithin Within(this DateTime dateTime)
{
return new DateTimeWithin(dateTime, _defaultTolerance);
}
// Additional overload that can deal with Nullable dates
// (treats null as DateTime.MinValue)
public static DateTimeWithin Within(this DateTime? dateTime)
{
return dateTime.GetValueOrDefault().Within();
}
public static DateTimeWithin Within(this DateTime? dateTime, TimeSpan tolerance)
{
return dateTime.GetValueOrDefault().Within(tolerance);
}
}
public class DateTimeWithin
{
public DateTimeWithin(DateTime dateTime, TimeSpan tolerance)
{
DateTime = dateTime;
Tolerance = tolerance;
}
public TimeSpan Tolerance { get; private set; }
public DateTime DateTime { get; private set; }
public static bool operator ==(DateTime lhs, DateTimeWithin rhs)
{
return (lhs - rhs.DateTime).Duration() <= rhs.Tolerance;
}
public static bool operator !=(DateTime lhs, DateTimeWithin rhs)
{
return (lhs - rhs.DateTime).Duration() > rhs.Tolerance;
}
public static bool operator ==(DateTimeWithin lhs, DateTime rhs)
{
return rhs == lhs;
}
public static bool operator !=(DateTimeWithin lhs, DateTime rhs)
{
return rhs != lhs;
}
// Overloads that can deal with Nullable dates
public static bool operator !=(DateTimeWithin lhs, DateTime? rhs)
{
return rhs != lhs;
}
public static bool operator ==(DateTime? lhs, DateTimeWithin rhs)
{
if (!lhs.HasValue && rhs.DateTime == default(DateTime)) return true;
if (!lhs.HasValue) return false;
return (lhs.Value - rhs.DateTime).Duration() <= rhs.Tolerance;
}
public static bool operator !=(DateTime? lhs, DateTimeWithin rhs)
{
if (!lhs.HasValue && rhs.DateTime == default(DateTime)) return true;
if (!lhs.HasValue) return false;
return (lhs.Value - rhs.DateTime).Duration() > rhs.Tolerance;
}
public static bool operator ==(DateTimeWithin lhs, DateTime? rhs)
{
return rhs == lhs;
}
}
And a quick unit test to verify everything is working correctly:
[TestMethod]
public void DateTimeExtensions_Within_WorksWithNullable()
{
var now = DateTime.Now;
var dtNow1 = new DateTime?(now);
var dtNow2 = new DateTime?(now.AddMilliseconds(1));
var dtNowish = new DateTime?(now.AddMilliseconds(25));
DateTime? dtNull = null;
Assert.IsTrue(now == dtNow1.Within()); // Compare DateTime to DateTime?
Assert.IsTrue(dtNow1 == dtNow2.Within()); // Compare two DateTime? using a different syntax
Assert.IsTrue(dtNow1 == dtNow2.Within()); // Same value should be true
Assert.IsFalse(dtNow1 == dtNowish.Within()); // Outside of the default 10ms tolerance, should not be equal
Assert.IsTrue(dtNow1 == dtNowish.Within(TimeSpan.FromMilliseconds(50))); // ... but we can override this
Assert.IsFalse(dtNow1 == dtNull.Within()); // Comparing a value to null should be false
Assert.IsTrue(dtNull == dtNull.Within()); // ... but two nulls should be true
}

By default C# compares DateTime objects to the millesecond.
Actually the resolution is to the 100ns tick.
If you're comparing two DateTime values from the database, which have 1s resolution, no problem.
If you're comparing with a DateTime from another source (e.g. the current DateTime using DateTime.Now)), then you need to decide how you want the fractions of a second to be treated. E.g. rounded to nearest or truncated? How to round if it's exactly half a second.
I suggest you round or truncate to an integral number of seconds, then compare with the value from the database. Here's a post that describes how to round a DateTime (this example rounds to minutes, but the principal is the same).

I’ve created extension methods IsSimilar
public static bool IsSimilar(this DateTime? lhs, DateTime? rhs, TimeSpan tolerance)
{
if (!lhs.HasValue && !lhs.HasValue) return true;//both are null
if (!lhs.HasValue || !lhs.HasValue) return false;//one of 2 is null
return IsSimilar(lhs.Value, rhs.Value, tolerance);
}
public static bool IsSimilar(this DateTime lhs, DateTime rhs, TimeSpan tolerance)
{
return (lhs - rhs).Duration() <= tolerance;
}