The current pattern matching is not supported. How should I use the backup plan?

[zms9110750]

public interface INode<T> where T : INode<T>
{
	public T? Parent { get; }
}
public interface IRootNode<T> : INode<T> where T : IRootNode<T>
{
	public T Root { get; }
	public int Depth { get; }
}

public static class TreeNodeExtensions
{
	public static IEnumerable<T> IterateToRoot<T>(T node) where T : INode<T>
	{

		switch (node)
		{
			case null:
				yield break;
			case IRootNode<T> rootNode:// T maby not IRootNode<T>  so can't case IRootNode<T>
				break;
			default:
				break;
		}

[zms9110750]

I can't even write it

public static class TreeNodeExtensions
{
    public static IEnumerable<TNode> IterateToRoot<TNode>(this TNode node)where TNode : IRootNode<TNode>;
    public static IEnumerable<TNode> IterateToRoot<TNode>(this TNode node)where TNode : INode<TNode>;// i have a same method

[BlinD-HuNTeR]

Seems like what you want is "overload on constraints". Constraints are not part of method signature, so you can't have two methods in the same class, with the same types of parameters, differing only by the constraints.

However, even though you can't "overload on constraints", you can simulate it with Extension Methods. Just put your two extension methods in different classes, and the compiler will pick the correct one, based on whether the constraints are satisfied.

But for your case, there is a second problem: IRootNode<T> inherits from INode<T>, which means that, when the method is called on a IRootNode<T>, both methods are applicable, and the call is ambiguous.

But this also has a solution: the Global Namespace! By default, compiler will look for extension methods in the current namespace, followed by all containing namespaces up to the Global Namespace, and only if none is found, it will look for extension methods from using namespaces.

Which means that you can put the version that is constrained to IRootNode<T> on the Global Namespace, and it will always be picked first, when the receiver is applicable:

public static class ClassWithoutANamespace
{
    public static IEnumerable<TNode> IterateToRoot<TNode>(this TNode node) where TNode : IRootNode<TNode>;
}
namespace SomeNamespace //make sure it's not the same namespace as the consuming code
{
    public static class ClassInsideANamespace
    {
        public static IEnumerable<TNode> IterateToRoot<TNode>(this TNode node) where TNode : INode<TNode>;
    }
}

With this approach, the method from ClassWithoutANamespace will always be chosen first. Only if the receiver is not a IRootNode<T>, the method from ClassInsideANamespace will be called.

[333fred]

See #6308.