csharp dose no emit warning when implementing/overriding nullable reference type parameter

[MauNguyenVan]

I have implemented an interface IBase1 with string Foo(string para); in the Base1 class with public string Foo(string? para){}.
I think implementing para string? Foo(string? para){} in class for string Foo(string para); in the interface is not true, but csharp compiler does not warn and allow some mistakes when sending parameters after that

I'm using VS 17.5.1, C# 11, Net core 7.0

namespace ConsoleApp.Classes
{
    interface IBase1
    {
        string Foo(string para); // string- none nullable para
        string Foo1(string para) => "default";
        string Foo2(string? para);

    }
    internal abstract class Base1 : IBase1
    {
        public string Foo(string? para)// string?- nullable para  => must be Foo(string para) => should be emit a warning
        {
            return "Why no warning at `Foo(string? para)` when implement `Foo(string para)` from non nullable to nullable reference type parameter";
        }
        string IBase1.Foo1(string? para)
        {
            return "the same, why no warning Foo1(string? para)";
        }
       
        public  string Foo2(string para)
        {
            return "OK";
        }
    }
}

[Joe4evr]

Because adding the ? annotation is always allowed. Consider if the interface was declared in an older assembly from before nullability annotations, and now that assembly calls your implementation with para: null. If you weren't able to say in your own code "Even if the interface doesn't say so, these variables could actually be null", then the compiler couldn't help you write null-safe code.

[svick]

Because adding the ? annotation is always allowed.

Note that it's allowed on regular parameters. On return types and out parameters, the opposite is true: a derived method is allowed to remove ?, but not to add it.

Consider if the interface was declared in an older assembly from before nullability annotations

That's a different situation. If the interface does not have annotations, the derived type can specify nullability however it wants and there will be no warnings, I believe.

[MauNguyenVan]

Consider if the interface was declared in an older assembly from before nullability annotations, and now that assembly calls your implementation with para: null

It just emits an error CS8767 like line 27 of code above (see waring in picture above)
Warning CS8767 Nullability of reference types in type of parameter 'para' of 'string Base1.Foo2(string para)' doesn't match implicitly implemented member 'string IBase1.Foo2(string? para)' (possibly because of nullability attributes).