在类声明中参数化通用接口

Question

So I needed to implement a search using vertices and edges that are already being computed in another part of the code (I'm treating that part like a black box).

So I have my graph, with a list of vertices and edges:

class Graph {
    List<Vertex> vertices;
    List<Edge> edges;
}

I decided to make a generic implementation for the search, and created a wrapper for the vertices:

class Node<T> {...}

and created an interface for the edges so that I can use them in the search:

interface ISearchLink<T> {...}

as a result, the search method header looks like this:

public static List<Node<T>> Search(List<Node<T>> nodes, List<ISearchLink<T>> links);

now, because the edges are already using the type I wanted them to, and to keep it consitent with the other part, I changed the Edge class declaration to look like this (and implemented the interface methods):

class Edge : ISearchLink<Vertex> {...}

so now when I call the search, it says I have invalid arguments

List<Node<T>> table = search(vertices, edges);

which seems to indicate that the Edge declaration is invalid (even though I got no complaints from VS). Is this declaration invalid and if so, why is there no error? And if it isn't invalid, what seems to be the problem? (it seems VS can't convert List«Edge» to List«ISearchLink«Vertex»»)

edit: the errors in specific are:

The best overloaded method match for Node<Vertex>.search(System.Collections.Generic.List<Vertex>, System.Collections.Generic.List<ISearchLink<Vertex>>)' has some invalid arguments

and

cannot convert from 'System.Collections.Generic.List<Edge>' to 'System.Collections.Generic.List<ISearchLink<Vertex>>'

Answer 1

The problem is that your Search method is taking in Lists:

public static List<Node<T>> Search<T>(List<Node<T>> nodes, List<ISearchLink<T>> links)

When you say "it seems VS can't convert List<Edge> to List<ISearchLink<Vertex>> ", that's because a List<Edge> really isn't a List<ISearchLink<Vertex>> . VS shouldn't convert like this for you, because List<T> is invariant in T .

By saying that your method should take in List s, you are telling the caller that you could access and use items in that collection (which means that the type you are expecting as a parameter must be assignable from the type the caller provides), but you also might insert something into that collection (which means the type the caller provides must be assignable from the type you are expecting)! This locks the caller in to providing exactly the expected type.

IEnumerable<T> , on the other hand, is covariant in T . You can't insert new items into an IEnumerable<T> ; you can only get stuff out. That means that the type you are expecting as a parameter must be assignable from the type the caller provides- which corresponds to the situation where you are expecting ISearchLink<T> , which is assignable from Edge. But it's fine if the type provided by the caller is not assignable from the type expected as a parameter, because there won't be any assignments flowing in that direction.

So change the function to have the signature

public static List<Node<T>> Search<T>(List<Node<T>> nodes, IEnumerable<ISearchLink<T>> links)

Now VS will happily convert the List<Edge> to IEnumerable<ISearchLink<Vertex>> , because it knows you're only going to be pulling stuff out of the list and not doing things like inserting MyEvilSearchLink<Vertex>> into what is actually a List<Edge> .

Answer 2

The correct function header would

public static List<Node<T>> Search<T>(List<Node<T>> nodes, List<ISearchLink<T>> links)
{

}

Don't forget the <T> after Search