Cast generic IFoo<T> : last level (I hope)

[Alphapage]

Hello again,

My last question which opened a big debate about casting such a generic
interface learned me a lot, but I can't find a way because of my particular
generic interface.
I will shown you my code, but when you will answer my post, don't write:
- he is stupid (I already know)
- this is not Object Oriented
- generic is not made for that ...

abstract class BaseStaticOverride<T> where T : BaseStaticOverride<T>
{

private static T _instance;

private static object _lock = new object();



public static T Instance
{

get
{

if (_instance == null)
{

lock (_lock)
{

if (_instance == null)

_instance =
(T)Activator.CreateInstance(typeof(T), true);

}

}

return _instance;

}

}


}

abstract class C1Base<T> : BaseStaticOverride<T> where T : C1Base<T>
{

protected C1Base()
{

}

public void WriteLine()
{

Console.WriteLine(Line);

}


protected abstract string Line
{

get;

}


}


class C1 : C1Base<C1>
{

protected C1()
{

}

protected override string Line
{

get { return "C1"; }

}

}

C1 can be considered as a static method with my code and so C1 and
C1Base<C1> are the same class.
The problem occures when I don't know which class implement C1Base
(C1Base<?>). Since C1Base<?> can be considered as static, I think it would be
possible to do this:
C1Base<?>.Instance.WriteLine(); // which will return "C1"

Hope you understand what I want to do.

Thanks in advance for your help.

 

[Jon Skeet [C# MVP]]

On Jul 25, 1:29 pm, Alphapage <[email protected]>
wrote:

Hope you understand what I want to do.

Not really, I'm afraid. You're referring to C1 as a static *method*
but it's a *class*.

On a somewhat different note, your use of double-checked locking isn't
threadsafe. If you make _instance volatile it would be safe, but
generally I'd just use a static initializer instead. See
http://pobox.com/~skeet/csharp/singleton.html

Jon

 

[Peter Morris]

Your reference to Java only served to confuse me further

What (in .NET) is wrong with his double-lock approach?

 

[Jon Skeet [C# MVP]]

Your reference to Java only served to confuse me further

What (in .NET) is wrong with his double-lock approach?

Without the "volatile" flag there's still the possibility that a
client will see a non-null reference before all of the writes have
been flushed, I believe. In other words, it could see a half-
constructed object.

Lock-free programming is always tricky, and almost never a good idea
for mere mortals like ourselves. I'll leave it to Joe Duffy, who knows
what he's talking about. (Even he's worried at the moment, as one
memory model isn't quite what he thought it was...)

Using a static initializer is simpler, safer, and still lazy (if you
include the static constructor).

Jon