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

You raise an interesting point about VB/C# compilation that I can't really speak to.  If you're looking for a solution, here's a way to do it from the question [How can I recognize a generic class?](https://stackoverflow.com/a/2478022/1366033)

Define these functions:



    Public Function IsSubclassOf(ByVal childType As Type, ByVal parentType As Type) As Boolean
        Dim isParentGeneric As Boolean = parentType.IsGenericType

        Return IsSubclassOf(childType, parentType, isParentGeneric)
    End Function

    Private Function IsSubclassOf(ByVal childType As Type, ByVal parentType As Type, ByVal isParentGeneric As Boolean) As Boolean
        If childType Is Nothing Then
            Return False
        End If

        If isParentGeneric AndAlso childType.IsGenericType Then
            childType = childType.GetGenericTypeDefinition()
        End If

        If childType Is parentType Then
            Return True
        End If

        Return IsSubclassOf(childType.BaseType, parentType, isParentGeneric)
    End Function

Call like this:

    Dim baseType As Type = GetType(MyBaseClass(Of ))
    Dim childType As Type = GetType(MyOtherChildClass)

    Console.WriteLine(IsSubclassOf(childType, baseType))
    'Writes: True

Here's a [Microsoft Connect Ticket](http://connect.microsoft.com/VisualStudio/feedback/details/95768/a-call-to-type-basetype-on-an-open-generic-hierarchy-will-produce-a-unexpected-typehandle) that might deal with this issue and give some explanation as to whether this was a feature or a bug of generic typing.

Although this case doesn't seem supported by the [`Type Of`](http://msdn.microsoft.com/en-us/library/0ec5kw18.aspx) documentation which states that for classes, typeof will return true if:

>*objectexpression* is of type *typename* or **inherits** from *typename*

When comparing types in VB the following works as expected and enables the current instance to be compared against a specific inherited class, in this case returning `False` (snippet from [LINQPad][1])

	Sub Main
		Dim a As New MyOtherChildClass
	
		a.IsType().Dump()
	End Sub
	
	' Define other methods and classes here
	MustInherit class MyBaseClass
		Public Function IsType() As Boolean
			Return TypeOf Me Is MyChildClass
		End Function
	End Class
	
	Class MyChildClass 
		Inherits MyBaseClass
	End Class
	
	Class MyOtherChildClass
		Inherits MyBaseClass
	End Class

However when generics are introduced the VB compiler fails with the error `Expression of type 'UserQuery.MyBaseClass(Of T)' can never be of type 'UserQuery.MyChildClass'.`

	' Define other methods and classes here
	MustInherit class MyBaseClass(Of T)
		Public Function IsType() As Boolean
			Return TypeOf Me Is MyChildClass
		End Function
	End Class
	
	Class MyChildClass 
		Inherits MyBaseClass(Of String)
	End Class
	
	Class MyOtherChildClass
		Inherits MyBaseClass(Of String)
	End Class

The equivalent code in **C#** compiles and allows the comparison, returning the correct result



	void Main()
	{
		var a = new MyOtherChildClass();
	
		a.IsType().Dump();
	}
	
	// Define other methods and classes here
	
	abstract class MyBaseClass<T>
	{
		public bool IsType()
		{
			return this is MyChildClass;
		}
	}
	
	class MyChildClass : MyBaseClass<string>
	{
	}
	
	class MyOtherChildClass : MyBaseClass<string>
	{
	}

Why does the VB compiler not allow this comparison?

  [1]: http://www.linqpad.net/

VB typeof operator with generics

Generics can be ***anything***, so the compiler has no way of knowing that you only intend to call this method on types that inherit from `System.Web.UI.Control`.  You could, in fact, call the function with Type `Integer`, in which case the conversion will fail.  

What you need to do is convince the compiler that you will only pass in certain types by using  [**Generic Constraints**][constraints].  Then you can only allow applicable types to call into the method.

All you need to do is modify your signature like this:



<pre><code>Private Function GetAllChildControlsInDataGrid(Of T <b>As Control</b>)(
                      ByVal grid As DataGridItemCollection) As List(Of T)
</code></pre>

[constraints]: http://msdn.microsoft.com/en-us/library/w256ka79.aspx#sectionToggle3

I'm trying to write a method to return a list of all of a particular type  of control:

So I have something like the following method:



    Private Function GetAllChildControls(Of T)(ByVal grid As DataGridItemCollection) 
                                               As List(Of T)
        Dim childControls As New List(Of T)
        For Each item As DataGridItem In grid 
            For Each tableCell As TableCell In item.Cells
                If tableCell.HasControls Then
                    For Each tableCellControl As Control In tableCell.Controls
                        If tableCellControl.GetType Is GetType(T) Then

                            childControls.Add(DirectCast(tableCellControl, T))

                        End If
                    Next
                End If
            Next
        Next
        Return childControls
    End Function

But this fails on the following code:



    childControls.Add(DirectCast(tableCellControl, T))

I get the message:

> Cannot cast expression of type `System.Web.UI.Control` to type `T`.

How can I return a type specific list?

Cast to Generic Type in Generic Method

A potential solution is to use `CTypeDynamic` instead of `CType`.

    Private Function GenericCastV2(Of T)(input As Object, output As T) As T
    	output = CTypeDynamic(Of T)(input)
    	Return output
    End Function

I know this does not answer your "why" question, but it would just be supposition on my part.  My gut answer is that it has to do with the decisions that the VB compiler makes in deciding which helper method to call to complete conversion.  As a potential clue to the problem, following concept function will not event compile as valid conversion from String for all types would be required.

    Private Function GenericCastConcept(Of T)(input As Object, output As T) As T
    	output = CType(input.ToString, T)
    	Return output
    End Function



### Setup

I have a class with an [overloaded assignment operator][1]



    Public Class Timestamp
    
        ReadOnly _value As String
    
        Public Sub New(value As String)
            Me._value = value
        End Sub
    
        Public Shared Widening Operator CType(ByVal input As String) As Timestamp
            Return New Timestamp(input)
        End Operator
    
    End Class

This allows both of the following widening conversions to occur:



    Dim t1 As Timestamp = "1314"
    Dim t2 As Timestamp = CType("1314", Timestamp)

So it will happily change from type `String` into type `Timestamp`.  

### Problem

However, if I have a method that takes Timestamp as a generic, the conversion no longer works.  
For example, for the following method:



    Private Function GenericCast(Of T)(input As Object, output As T) As T
        Return CType(input, T)
    End Function


If I call it like this:



    Dim t3 as Timestamp
    t3 = GenericCast("1314", t3)


I'll get the following error:

> Unable to cast object of type 'System.String' to type 'Timestamp'.
[![Unable to cast object of type 'System.String' to type 'Timestamp'.][2]][2]

But we already know that I definitely can convert between those types.  
Why does it it not work with Generics at runtime?


  [1]: https://msdn.microsoft.com/en-us/library/yf7b9sy7.aspx
  [2]: http://i.stack.imgur.com/gvZMw.png

Generic Casting doesn't work with overloaded Assignment Operator

If you want complete control of your classes, and allow them to evolve independently, then you can have one base class that owns the Method, and then as many subclasses as you want with their own definition of the payload.

First, parse into the baseclass, just to get a strongly typed deserialization of `Method`

Then, there are a lot of patterns to address branching logic.  

* If you have 1-2 cases, an `if` statement is fine
* If you have 3-5 cases, you can use a `switch`
* If you have 6-10 cases, you can create a `dictionary` that maps method name to class type
* If you have more than that, you can use the [strategy pattern][1] and pass an interface around

Here's an example of how you could write the code:

```cs
var json = @"{
    'method': 'Model',
    'payload': {
        'key': 'value'
    }
}";

var modelBase = JsonConvert.DeserializeObject<ModelBase>(json);

var methodMapping = new Dictionary<string, Type>()
{
    {MethodTypes.Model.ToString(), typeof(Model)},
    {MethodTypes.OtherModel.ToString(), typeof(OtherModel)},
};
            
Type methodClass = methodMapping[modelBase.Method];

var result = JsonConvert.DeserializeObject(json, methodClass);
```

> **Note**: Since we're programmatically determining the correct type, it's hard to [pass to a generic `<T>`][6], so this uses the overload of `DeserializeObject` that takes `type` as a param

And here are the classes that model incoming messages

```cs
public enum MethodTypes
{
    Model,
    OtherModel
}

public class ModelBase
{
    public string Method { get; set; }
}

public class Model : ModelBase
{
    public ModelInfo Payload { get; set; }

    public class ModelInfo
    {
        public string Key { get; set; }
    }
}

public class OtherModel : ModelBase
{
    public ModelInfo Payload { get; set; }

    public class ModelInfo
    {
        public string Foo { get; set; }
    }
}
```

### `Dictionary<string,string>`

If your data is always going to be `"foo":"bar"` or `"key":"value"` .... `string:string`, then Cid's suggesting to use `Dictionary<string,string> Payload` makes a lot of sense.  Then figure out however you want to map from that c# class in a c# constructor that returns whatever type you want.


### Additional Resources:

* [How to handle both a single item and an array for the same property using JSON.net][4]
* [Deserializing polymorphic json classes without type information using json.net][5]
* [JSON.NET - Conditional Type Deserialization][2]
* [Conditionally deserialize JSON string or array property to C# object using JSON.NET?][3]


[1]: https://en.wikipedia.org/wiki/Strategy_pattern
[2]: https://stackoverflow.com/q/7816780/1366033
[3]: https://stackoverflow.com/q/35782400/1366033
[4]: https://stackoverflow.com/q/18994685/1366033
[5]: https://stackoverflow.com/q/19307752/1366033
[6]: https://stackoverflow.com/q/1292480/1366033

I have a converter class that receives json in input, here are 2 valid examples:

```js
{
  "method": "Model",
  "payload": {
    "key": "value"
  }
}
```

and

```js
{
  "method": "OtherModel",
  "payload": {
    "foo": "bar"
  }
}
```

In C#, I have classes mapped to each possible model:

```cs
public class Model
{
  public string Key { get; set; }
}

public class OtherModel
{
  public string Foo { get; set; }
}
```

I need a generic converter

How can I use the string value in the `method` of the JSON to convert in a generic way the content of the payload field?

Is using a huge switch the only way? This is the prototype I have so far but there are hundreds of different models so it will grow quite large...

```cs
public IResult ParseJson(string json)
{
  Regex regexMessageName = new Regex("\"messageName\": \"(.*?)\"", RegexOptions.Compiled);
  var messageName = regexMessageName.Match(json).Groups[1].Value;
  switch (messageName)
  {
    case "Model":
      var raw = JsonConvert.DeserializeObject<JsonData<Model>>(json);
      return new LogInfoRequestResult<Model> { Raw = raw };
    case "OtherModel":
      var raw = JsonConvert.DeserializeObject<JsonData<OtherModel>>(json);
      return new LogInfoRequestResult<OtherModel> { Raw = raw };

  }
}
```