Q:

Check if two variables are of the same when the type is dynamic and both variables are the derivatives of same base class

Is it possible to check if the list contains an object of given (but dynamic) type, derrived from same basic abstract class?
The main problem is not about the list, but about comparing types itself. 
In single variables and static variables, it's easy: 
if(someVariable is int)

Checking the list with static type is also easy, like:
SomeList.OfType<int>().Any()

or
(from _Object in SomeList.OfType<int> where _Object is int select _Object).Count() == 0

but I cant't handle it if the type I want to check is dynamic, f.e. passed as method parameter:
abstract class BasicClass;
class DerivativeOne : BasicClass { }
class DerivativeTwo : BasicClass { }

// in main:

List<BasicClass> _List = new List<BasicClass>();
DerivativeOne a = new DerivativeOne();
DerivativeTwo b = new DerivativeTwo();
DerivativeOne c = new DerivativeOne();

if(!CheckIfTypeExistsInList(a, _List)
{
    _List.Add(a);
}
if(!CheckIfTypeExistsInList(b, _List)
{
    _List.Add(b);
}
if(!CheckIfTypeExistsInList(c, _List)
{
    _List.Add(c);  // this is what I don't want to happen,
           // because I already have one object of type DerivativeOne in my list.
}

// the function:
bool CheckIfTypeExistsInList(BasicClass pObject, List<BasicClass> pList)
{
    /// few attempts:
    pList.OfType<(pObject.GetType()>().Any();  // attempt one, error
    return  (from _Object in SomeList.OfType<(pObject.GetType())> where _Object is int select _Object).Count() == 0;    // attempt two, error
}

PS. I am aware that the code doesn't look neat, but I tried to show just the problem itself, skipping extra logic and stuff.
PS2. I am aware that the solution to the problem would be just to put some attribute to BasicClass and make each derivative to have unique value of the attribute, but still - I'm not looking for another route to solve the problem, I'm just interested if it's possible to do it "this" way.

A:

When the type is known only at runtime, you cannot use it in a generic without using reflection. However, your task is simpler than that - you can use type equality to achieve the results that you want:
Type targetType = pObject.GetType();
if (SomeList.Any(o => targetType.Equals(o.GetType()))) {
    ...
}

