Using FindAll in a List with instances from two derived classes - linq

Question

I wonder if the following is possible to accomplish with the FindAll-method:
I have a base class called Animal. I have two derived classes called Fish and Dog.
Animal have:
public string Type { get; set; }
public int Height { get; set; }
public int Length { get; set; }
Dog have:
public string Color { get; set; }
Fish have: nothing extra.
I want to do something like this:
Console.Write("\nEnter keyword to search the farm: ");
string keyword = Console.ReadLine().Trim();
var mySearch = myAnimals.FindAll(p => p.Type.Contains(keyword) || p.Color.Contains(keyword));
myAnimals is a List of type Animal, containing instances of Fish and Dog.
List<Animal> myAnimals = new List<Animal>();
The problem is that Color cant be accessed from there. Only what's in the base class Animal, i.e. Type, Height and Length, are possible targets.

Answer 1

You could use the following code:
animals.FindAll(animal => animal.Type.Contains(keyword) || (((animal as Dog)?.Color.Contains(keyword)) ?? false));
So what does the part (((animal as Dog)?.Color?.Contains(keyword)) ?? false) actually do?
Let's take it into parts:
(animal as Dog) tries to cast animal to the Type Dog. If this fails there is no exception thrown, instead it returns null
As we cannot access the property Color of null (this would lead to a NullReferenceException) we need to use the ?. Operator aka Null-conditional Operator. It will only try to access Color if (animal as Dog) is not null.
If (animal as Dog) is null the whole expression becomes null.
The same with Color?.Contains() as Color itself could be null.
As we need a boolean expression after || and null would not be boolean we also use the ?? Operator aka Null-coalescing Operator. If the expression on the left is null use the value on the right. Otherwise use the value on the left.
This means if animal is a Dog which has a Color property and this property is not null use the return value of Contains(keyword) which is true or false.
Otherwise if animal is not a Dog or Color is null default to false.
Type.Contains(keyword)|| false means whatever Type.Contains(keyword) returns.
But this becomes unflexible if you add more types. What could be another approach?
E.g. using a custom Attibute:
class Animal
{
[SearchableProperty]
public string Type { get; set;}
public string ImNotSearchable { get; set;}
}
class Fish : Animal { }
class Dog : Animal
{
[SearchableProperty]
public string Color { get; set;}
}
[AttributeUsage(AttributeTargets.Property, Inherited = false)]
class SearchablePropertyAttribute : Attribute
{
}
animals.FindAll(animal => animal.GetType().GetProperties().Where(
prop => Attribute.IsDefined(prop, typeof(SearchablePropertyAttribute))).Any(p => p.GetValue(animal)?.ToString()?.Contains(keyword) ?? false))
But be aware that these kind of things can be inefficient for larger datasets.