Generic Repository vs Non-generic Repository Generic repository is not a pattern. Generic repository is just a wrapper. It can be useful for some special scenarios as a base class for specific repositories but in most cases it is just over used and over hyped nonsense. Navigation properties Repository itself should be used with aggregate root. … Read more
I recommend that you not think of this as “using async within LINQ”. Keep in mind what’s in-between the two: delegates. Several LINQ operators take delegates, and async can be used to create an asynchronous delegate. So, when you have an asynchronous method BazAsync that returns a Task: Task BazAsync(TBar bar); then this code results … Read more
The documentation for the Except function states: Produces the set difference of two sequences by using the default equality comparer to compare values. The set difference of two sets is defined as the members of the first set that do not appear in the second set. The important word here is set, which is defined … Read more
It sounds like you want something like: // No need to sort sites first var grouped = sites.OrderBy(x => x.Type) .GroupBy(x => x.Type); Then just serialize grouped. However, I don’t know quite what an IGrouping will look like in JSON… and the type will be present in each case. You may want something like: var … Read more
You can find your duplicates by grouping your elements by ValueA and ValueB. Do a count on them afterwards and you will find which ones are duplicates. This is how you would isolate the dupes : var duplicates = items.GroupBy(i => new {i.ValueA, i.ValueB}) .Where(g => g.Count() > 1) .Select(g => g.Key);
Generally methods that return a sequence use deferred execution: IEnumerable<X> —> Select —> IEnumerable<Y> and methods that return a single object doesn’t: IEnumerable<X> —> First —> Y So, methods like Where, Select, Take, Skip, GroupBy and OrderBy use deferred execution because they can, while methods like First, Single, ToList and ToArray don’t because they can’t. … Read more
In any case, you have to loop through it. Linq offers the Count method: var result = myenum.Count();
Use the method-syntax where Enumerable.Select has an overload with the index: var myResult = someTable.Select((r, i) => new { Row = r, Index = i }) .Where(x => x.Row.someCategory == someCategoryValue) .OrderByDescending(x => x.Row.createdDate); Note that this approach presumes that you want the original index of the row in the table and not in the … Read more
Use String.Equals with the appropriate parameters to make it case insensitive mySource.Where(s => String.Equals(s, “Foo”, StringComparison.CurrentCultureIgnoreCase));
You can use “group by” + “orderby”. See LINQ 101 for details var list = new List<string> {“a”, “b”, “a”, “c”, “a”, “b”}; var q = from x in list group x by x into g let count = g.Count() orderby count descending select new {Value = g.Key, Count = count}; foreach (var x in … Read more