Pass derived class to method which use parent class c#

Question

Today I took part in test in where was the task to add static method getMovingVehicles to already written code. I did it like you can see below, but after passing it online compiler I can see there are errors like:

Compilation error (line 28, col 39): The best overloaded method match for 'Rextester.Program.getMovingVehicles(System.Collections.Generic.List<Rextester.Vehicle>)' has some invalid arguments
Compilation error (line 28, col 57): Argument 1: cannot convert from 'System.Collections.Generic.List<Rextester.Car>' to 'System.Collections.Generic.List<Rextester.Vehicle>'
Compilation error (line 29, col 41): The best overloaded method match for 'Rextester.Program.getMovingVehicles(System.Collections.Generic.List<Rextester.Vehicle>)' has some invalid arguments
Compilation error (line 29, col 59): Argument 1: cannot convert from 'System.Collections.Generic.List<Rextester.Plane>' to 'System.Collections.Generic.List<Rextester.Vehicle>'

How should I pass derived class to method which uses parent class to make that work correctly?

namespace Rextester
{
 abstract class Vehicle{
    public int Speed; 
    }

     class Car: Vehicle{
     public String VIN;   
    }

     class Plane : Vehicle{
     public int altitude;   
    }

public class Program
{


    public static void Main(string[] args)
    {

        var cars= new List<Car>();
        var planes = new List<Plane>();
        List<Vehicle> movingCars= getMovingVehicles(cars);
        List<Vehicle> movingPlanes=getMovingVehicles(planes);

    }

     static List<Vehicle> getMovingVehicles(List<Vehicle> vehicles){
        List<Vehicle> movingVehicles=new List<Vehicle>();
        foreach( Vehicle v in vehicles){
        if(v.Speed>0)
             movingVehicles.Add(v);

        }

        return movingVehicles;
    }

}
}

Learn about C# naming conventions. Public names should be UpperCamelCase. — SLaks, May 22 '18 at 20:11
Related: [C# variance problem: Assigning List as List](https://stackoverflow.com/q/2033912/3224483) — Rainbolt, May 22 '18 at 20:18

score 3 · Answer 1 · answered May 22 '18 at 20:14

The problem is not that you are passing derived class in place of a base class; that would be allowed. The problem is that you are passing a mutable collection of items of derived class, which is not allowed.

Fortunately, you are not treating the list of vehicles as a full list: you use only one aspect of it - namely, its ability to be enumerated. Therefore, you could replace List<Vehicle> with IEnumerable<Vehicle>, which is a lot more "forgiving". In particular, it lets you pass an IEnumerable<Car> in its place, as long as Car inherits from Vehicle:

static List<Vehicle> GetMovingVehicles(IEnumerable<Vehicle> vehicles) {
    return vehicles.Where(v => v.Speed != 0).ToList();
}

Note the use of LINQ to produce the results that you need without using a loop.

score 1 · Accepted Answer · answered May 22 '18 at 21:27

Another option is to use a generic

      static List<Vehicle> getMovingVehicles<T>(List<T> vehicles) where T:Vehicle {
            List<Vehicle> movingVehicles=new List<Vehicle>();
            foreach( Vehicle v in vehicles){
            if(v.Speed>0)
                 movingVehicles.Add(v);

            }

        return movingVehicles;
    }

score 0 · Answer 3 · answered May 22 '18 at 20:14

0

Simply change your function to take an IReadOnlyList<Vehicle>. The List<Vehicle> type is in-variant whereas IReadOnlyList<Vehicle> is co-variant, which accepts collections of the derived type:

static List<Vehicle> getMovingVehicles(IReadOnlyList<Vehicle> vehicles){

If this isn't possible, then you may convert your list to the appropriate type when passing it to the method:

getMovingVehicles(cars.ConvertAll(x => (Vehicle) x));

More info about covariance: https://learn.microsoft.com/en-us/dotnet/standard/generics/covariance-and-contravariance

answered May 22 '18 at 20:14

jspcal

50,847
7
72
76

Maybe this is a separate question, but how did you determine that `IReadOnlyList` is co-variant? And how do you know that `List` is not? – Rainbolt May 22 '18 at 20:21
@Rainbolt The "`out`" in `interface IReadOnlyList` means covariant. With `interface List` you see no `out`. (Had there been an "`in`" instead, it would have been contravariance.) – Jeppe Stig Nielsen May 22 '18 at 20:26
The type parameter in the interface definition has the `out` keyword (`IReadOnlyList`), which specifies that the type is covariant. – jspcal May 22 '18 at 20:26

FractalCode · Answer 4 · 2018-05-22T23:26:51.930

0

You can convert the list or cast it using linq. Take a look at: this

You can do:

List<BaseClass> listOfBaseClass= new List<DerivedClass>().ConvertAll(x => (BaseClass)x);

Or:

List<BaseClass> listOfBaseClass = new List<DerivedClass>().Cast<BaseClass>().ToList();

edited May 22 '18 at 23:26

answered May 22 '18 at 20:15

FractalCode

360
1
4

Pass derived class to method which use parent class c#

4 Answers4