Extending a generic interface with a static property of the extended class [duplicate]

Question

I have a generic interface which I would like to have a property of type self i.e.

public interface IFoo<TBar> : where TBar : ISomething 
    {
        TBar Prop1 { get; set; }
        IFoo<TBar> Unset { get; }
    }

This is fine until I inherit this and create a (non-generic) class:

public class FooDesired : IFoo<Bar>
    {
        public Bar Prop1 { get; set; }
        public static Foo Unset { get { return new Foo(); } }
    }

public class FooReality : IFoo<Bar>
    {
        public Bar Prop1 { get; set; }
        public static IFoo<Bar> Unset { get { return new Foo(); } }
        public IFoo<Bar> IFoo<Bar>.Unset { get { return new Foo(); } }
    }

I have two issues with the current implementation of this:

1. This implementation does not actual allow Unset to be static. I've worked my way around that with Explicit Interface Implementation but I'm always wary of "tricking" the system.

2. If I call Foo.Unset I always have to cast it back to Foo (unless I setup an implicit operator but that's just hiding the issue rather than solving it).

Edited Real Question: How can I enforce the existence of a static property in a set of classes?

**Edit: ** For those who are keen for a use case, let's assume all Animal species have a set number of bones in their bodies once fully mature. Therefore I would like Animal to enforce a static NumBones property on Cat, Dog and Human. This doesn't cover the static property being of the original class' type but the comments have good links to answers to that.

Answer 1

Obviously this is not possible as static members do not join the inheritance-chain and belong to the types themeselfes instead of the instances. Thus a static member can also not implement any interface-member. That means you have actually two members, the one from the interface and your static one. However as you already mentioned you can wrap one of them:

public class Foo : IFoo<Bar>
{
    public Bar Prop1 { get; set; }
    public static Foo Unset { get { return new Foo(); } }
    public IFoo<Bar> IFoo<Bar>.Unset { get { (IFoo<Bar>) return Foo.Unset } }
}

Now within your consumer-code you have something like this:

var foo1 = Foo.Unset;       // compiler can infer foo1 is of type Foo, you don´t need to cast
var foo2 = new Foo().Unset; // returns IFoo<Bar> which can be cast to Foo

As the latter returns an IFoo<T> and not a Foo (at least for the compiler) you have to cast the instance.

Usually this shouldn´t be a problem as your consuming code should not even know which class Unset actually returns, it simply knows the interface IFoo and works with this. The rest is implementation-detail which you want to avoid in your cunsumer-code, don´t you?