You can't always cast any collection type into any other collection. In terms of when the the compiler checks casting, check out this post on [Compile-time vs runtime casting](https://stackoverflow.com/a/4499558/1366033)

However, you can easily produce a `BindingList` from an enumerable by doing some of the plumbing yourself. Just add the following Extension Method onto any Enumerable type to  convert the collection into a BindingList.


**C#**:



    static class ExtensionMethods
    {
        public static BindingList<T> ToBindingList<T>(this IEnumerable<T> range)
        {
            return new BindingList<T>(range.ToList());
        }
    }

    //use like this:
    var newBindingList = (from i in new[]{1,2,3,4} select i).ToBindingList();

**VB**:



    Module ExtensionMethods
        <Extension()> _
        Public Function ToBindingList(Of T)(ByVal range As IEnumerable(Of T)) As BindingList(Of T)
            Return New BindingList(Of T)(range.ToList())
        End Function
    End Module

    'use like this:
    Dim newBindingList = (From i In {1, 2, 3, 4}).ToBindingList()

I am new with Linq and I would like to sort some data that are in the BindingList. Once I did my Linq query, I need to use back the BindingList collection to bind my data.


     var orderedList = //Here is linq query
     return (BindingList<MyObject>)orderedList;

This compiled but fails in execution, what is the trick?

BindingList and LINQ?

In order to allow short circuiting if the duplicate exists early in the list, you can add a [`HashSet<T>`][HashSet] and check the return value of its `.Add` method.  

By using `.Any` you can short circuit the enumeration as soon as you find a duplicate.

Here's a LINQ extension method in both C# and VB:  

### CSharp:



    public static bool ContainsDuplicates<T>(this IEnumerable<T> enumerable)
    {
        var knownKeys = new HashSet<T>();
        return enumerable.Any(item => !knownKeys.Add(item));
    }

### Visual Basic:



    <Extension>
    Public Function ContainsDuplicates(Of T)(ByVal enumerable As IEnumerable(Of T)) As Boolean
        Dim knownKeys As New HashSet(Of T)
        Return enumerable.Any(Function(item) Not knownKeys.Add(item))
    End Function

**Note**: to check if there are *no* duplicates, just change `Any` to `All`

[HashSet]: http://msdn.microsoft.com/en-us/library/bb359438(v=vs.110).aspx

Requirement: In an unsorted List, determine if a duplicate exists.  The typical way I would do this is an n-squared nested loop.  I'm wondering how others solve this.  Is there an elegant, high performance method in Linq?  Something generic that takes a lambda or a comparer would be nice. 

C# Determine Duplicate in List

Here are [Tim S's examples](https://stackoverflow.com/a/6781292/1366033) as extension methods on top of the Collection Class:

### CS with `FirstOrDefault`



    public static void ReplaceItem<T>(this Collection<T> col, Func<T, bool> match, T newItem)
    {
        var oldItem = col.FirstOrDefault(i => match(i));
        var oldIndex = col.IndexOf(oldItem);
        col[oldIndex] = newItem;
    }

### CS with Indexed Loop



    public static void ReplaceItem<T>(this Collection<T> col, Func<T, bool> match, T newItem)
    {
        for (int i = 0; i <= col.Count - 1; i++)
        {
            if (match(col[i]))
            {
                col[i] = newItem;
                break;
            }
        }
    }

### Usage

Imagine you have this class setup



    public class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

You can call either of the following functions/implementations like this where the `match` parameter is used to identify the item you'd like to replace:



    var people = new Collection<Person>
    {
        new Person() { Id = 1, Name = "Kyle"},
        new Person() { Id = 2, Name = "Mit"}
    };

    people.ReplaceItem(x => x.Id == 2, new Person() { Id = 3, Name = "New Person" });


----

### VB with Indexed Loop
        


    <Extension()>
    Public Sub ReplaceItem(Of T)(col As Collection(Of T), match As Func(Of T, Boolean), newItem As T)
        For i = 0 To col.Count - 1
            If match(col(i)) Then
                col(i) = newItem
                Exit For
            End If
        Next
    End Sub  

### VB with `FirstOrDefault`



    <Extension()>
    Public Sub ReplaceItem(Of T)(col As Collection(Of T), match As Func(Of T, Boolean), newItem As T)
        Dim oldItem = col.FirstOrDefault(Function(i) match(i))
        Dim oldIndex = col.IndexOf(oldItem)
        col(oldIndex) = newItem      
    End Sub

How do I update a single item in an ObservableCollection class?

I know how to do an Add.  And I know how to search the ObservableCollection one item at a time in a "for" loop (using Count as a representation of the amout of items) but how do I chage an existing item.  If I do a "foreach" and find which item needs updating, how to I put that back into the ObservableCollection>



How do I update a single item in an ObservableCollection class?

Try using this in LinqPad, and subbing out for your database entity it should get you closer. 

	Public Sub grouper2()
		Dim numbers = New Integer() {1,1,2,2,2,3}
	
		Dim numberGroups = From w In numbers _
						Group w By Key = w Into Group _
						Select Number = Key, numbersCount = Group.Count()
	
		'linqpad specific output
		'numberGroups.Dump()
		
		For Each g In numberGroups
			Console.WriteLine("Numbers that match '{0}':", g.Number)
				Console.WriteLine(g.numbersCount)        
		Next
	
	End Sub


I'm trying to use a LINQ query to determine how many of each particular object type I have and record those values into an anonymous type.

Let's say I have some data that looks like this (there are really objects exposing this property, but it'll work the same)

    GroupId
    1
    1
    2
    2
    2
    3

I know how to format my query in SQL.  It would be something like this:



    SELECT grp = GroupId, cnt = COUNT(*)
    FROM myTable
    GROUP BY GroupId

In this case the output would be something like [this SQL Fiddle][1]:

    GroupID  Count
    1        2
    2        3
    3        1

How can I do the same thing with LINQ in vb.net



    Dim groupCounts = From person In data
                      Group By person.GroupId
                      Select new {group = person.GroupId, count = count(*)}

That's not quite right, but I think it's close.

Also, not knowing much about anonymous types, can I actually declare `groupCounts` ahead of time that it will be an enumeration of items which each have a group and count property?

[1]: http://sqlfiddle.com/#!9/ef3427/1

LINQ query with GROUP BY and Count(*) into Anonymous Type

I think this is a Resharper bug and I'd submit it there. There can't be a modified closure in a linq statement that's executing immediately, like `Any` does.

VB is not my 'native language', but afaik the parentheses shouldn't make any difference in VB.Net (as it did in VB6).

Resharper's [`Access to Modified Closure`](http://confluence.jetbrains.com/display/ReSharper/Access+to+modified+closure) warnings are usually quite helpful. I was just noticing that when I call the [`Any`](http://msdn.microsoft.com/en-us/library/system.linq.enumerable.any.aspx) method inside of a for each loop, I'll get a warning if I don't use the open and close parenthesis. As soon as I add `()`, the error goes away.

Does the error itself go away, or have I just accidentally tricked Resharper's static code analysis detection.



    Dim groupExists as Boolean
    
    For each oldPerson in oldData

        'access to modified closure warning on oldPerson.groupId
        groupExists = (From newPerson In newData 
                       Where newPerson.GroupId = oldPerson.groupId).Any

        'no closure problem reported
        groupExists = (From newPerson In newData 
                       Where newPerson.GroupId = oldPerson.groupId).Any()

    Next

Of course, I can fix this by putting the following code inside the `For Each` loop and comparing the `newPerson.GroupId` to the locally declared variable.  




    'declare locally to avoid access to modified closure
    Dim groupId as Integer = person.groupId

Why does Access to Modified Closure Warning Disappear When Enumerable Method called with ()

If you want to abstract away some of the logic into a reusable extension method, you can add the following:


```cs
public static IEnumerable<TSource> DistinctBy<TSource, TKey>
    (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
{
    HashSet<TKey> seenKeys = new HashSet<TKey>();
    foreach (TSource element in source)
    {
        if (!seenKeys.Contains(keySelector(element)))
        {
            seenKeys.Add(keySelector(element));
            yield return element;
        }
    }
}
```

This will work for both single properties and composite properties and return the first
matching element

```cs
// distinct by single property
var productsByTitle = animals.DistinctBy(a => a.Title);

// distinct by multiple properties
var productsByTitleAndColor = animals.DistinctBy(a => new { a.Title, a.Color} );
```

One benefit to this approach (instead of group by + first) is you can return a yieldable enumerable in case you have later criteria that don't force you to loop through the entire collection

**Further Reading**: [linq query to return distinct field values from a list of objects][1]

[1]: https://stackoverflow.com/a/35795985/1366033


How can I using c# and Linq to get a `result` from the next list:

     var pr = new List<Product>()
       {
           new Product() {Title="Boots",Color="Red",    Price=1},
           new Product() {Title="Boots",Color="Green",  Price=1},
           new Product() {Title="Boots",Color="Black",  Price=2},
         
           new Product() {Title="Sword",Color="Gray", Price=2},
           new Product() {Title="Sword",Color="Green",Price=2}
       };

 
  `Result`:

            {Title="Boots",Color="Red",  Price=1},               
            {Title="Boots",Color="Black",  Price=2},             
            {Title="Sword",Color="Gray", Price=2}
               

I know that I should use `GroupBy` or `Distinct`, but understand how to get what is needed
 

       List<Product> result = pr.GroupBy(g => g.Title, g.Price).ToList(); //not working
       List<Product> result  = pr.Distinct(...);
Please help

linq distinct or group by multiple properties

I don't know VB that well but you could just use SelectMany to flatten the arrays. in C#

    strings.SelectMany(o=>o.Split(","));

I have a list of string elements, each of which can contain a comma separated list of values.  From that, I want to generate a list of all the distinct values in the entire set.

Take the following set of strings for example:



    Dim strings = New List(Of String) From {"A", "B,C,D", "D,E"}

I'd like to turn this into:

    {"A", "B", "C", "D", "E"}

Using linq, I could take each element and convert it into a string array.  The following query will just split each string into an array, but it will stay stuffed in it's own array element.

    Dim fieldsLinq = (From s In strings
                      Select s.Split(",")) _
                     .Distinct()

I want to concatenate the all of the values into a single array of strings.

I could start by joining all the elements with a comma and THEN splitting the single string, but this feels like the wrong approach.


    Dim fieldsJoin = String.Join(",", strings) _
                           .Split(",") _
                           .Distinct()

Are there any better solutions?

Concatenate Split Array from Select Field in LINQ

### Solution

You can do this by passing a callback as the third parameter like this:



<pre><code>var grouped = Enumerable.from(dataArray).groupBy("$.person", null, <i>(key, g) =&gt; {
  return { 
      person: key, 
      likes: <b>g.sum("$.likes | 0")</b>
 }
}</i>).toArray()</code></pre>


### Explanation

In `groupBy`, the third parameter allows you to modify the results before emitting:


[![GroupBy > ResultSelector][1]][1]

In JS, the [bitwise or operator][2] (a single pipe `|`) returns the first value if it exists, otherwise it returns the second one.  Without it, trying to sum an undefined value with a real one, will return [`NaN`][NaN]

```
undefined + 1 // NaN
```


Without `| 0`, the result would look like this:

![NaN][3]


This example uses shorthand syntax, but if you prefer anytime you see a string with a dollar sign, you can replace it with the lambda syntax like this (they both do the same exact thing):

<pre><code>// Shorthand
.Select("<b>$</b>.impressions")
// Lambda
.Select(<b>function (x) { return x</b>.impressions })</code></pre>



### Working demo with Stack Snippets:





    var dataArray = [
      {
        person: "james",
        likes: 100
      }, 
      {
        person: "james",
        likes: 250
      }, 
      {
        person: "kyle",
        likes: 300
      }, 
      {
        person: "kyle"
        //,likes: 450
      }
    ];

    var grouped = Enumerable.from(dataArray).groupBy("$.person", null, (key, g) => {
      return { person: key, likes: g.sum("$.likes | 0") }
    }).toArray()

    console.log(grouped);



    <script src="https://unpkg.com/linq@3.2.0/linq.js"></script>



### Further Reading: 

 * [SO - linqjs group by with a sum][4]

[NaN]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN "Not-A-Number"


  [1]: https://i.stack.imgur.com/IJ5Vw.png
  [2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_OR)
  [3]: https://i.stack.imgur.com/YRPcR.png
  [4]: https://stackoverflow.com/q/17824008/1366033

I want to use linq.js to group the following data by date. 



    data2 = [{
        "date": 1399298400.0,
        "adId": 1057946139383,
        "impressions": 1000000
      }, {
        "date": 1399298400.0,
        "adId": 3301784671323,
        "impressions": 535714
      }...... etc.
    ]; 


Here's my attempt:



    var linq = Enumerable.From(data2);
    data2 = linq.GroupBy(function (x) {
      return x.date;
    }).Select(function (x) {
      return {
        date: x.Key(),
        impressions: x.Sum(function (y) {
          return y.impressions | 0;
        })
      };
    }).ToArray();

However, It's not working correctly because the sum of all the `impressions` before and after the `GroupBy` are close but not identical. 

What is the correct way to use group by in linq.js in this case?

Here's [an example in fiddle][1] with full dataset here which alerts the total impressions before and after using the `GroupBy`. 

[1]: http://jsfiddle.net/hohenheim/j8cTE/23/

linq.js to group by array of objects in javascript

From [Can LINQ be used to find gaps in a sorted list?][1]: 


    var strings = new string[] { "7", "13", "8", "12", "10", "11", "14" };
    var list = strings.OrderBy(s => int.Parse(s));
    var result = Enumerable.Range(list.Min(), list.Count).Except(list).First(); // 9

Basically, order the list.  Then create an array of sequential numbers (`1,2,3...`) from the minimum all the way to the max.  Check for missing values in the list, and grab the first one.  That's the first missing number.

[1]: https://stackoverflow.com/q/4270321/1366033

One of my small database management projects (written in delphi) used sql queries to find the first free id of mysql table.

Example: I have to find the first free id (hole) in a table like this:



    | id   | Col1 |
    |------|------|
    | 5101 | ABC  |
    | 5102 | BCD  |
    | 5103 | CDE  |
    | 5105 | EFG  | 🡔 first missing id
    | 5106 | GHI  |
    | 5108 | ILM  |

The code should find the first free id `5104` 

Here's how I'd do it in SQL (in old project): 



    SELECT
      MIN((doc.id + 1)) AS nextID
    FROM (doc
      LEFT JOIN doc doc1
        ON (((doc.id + 1) = doc1.id)))
    WHERE (ISNULL(doc1.id) AND (doc.id > 5000))


Now, which I am rewriting in c # language, I need to convert sql statements into a LINQ query (which uses Devart dotConnect for mysql Entity Framework).
Starting from here:

    DC db = new DC();
    var nums = db.Documentos.OrderBy(x => x.Id);