Introduce abstract and virtual static. Please read the entire proposal...

[ghost]

Alrighty, I guess we have a blindspot here. Let me explain:
Assume you have this class.

public abstract class _Asset
{
    // I don't need neither of these in every Object of Asset
    public static string s_Directory; // but what if I want to change this in a subclass
    public static Icon s_Icon; // or this?
// This is what I'm actually doing right now
public static Type s_adjustableSubclassRestriction;
    

}

public class Asset
{
//this could just be abstract or virtual and wouldn't be any different, except for virtual and abstract,
//the developer using this code would be notified that he has to implement it.
public new static Type s_adjustableSubclassRestriction => typeof(SubAsset);

    // I could overwrite this in a subclass, by simply writing a static constructor there.
    // but what if I want the developer creating a subclass of this do that?
    // And make him figure that this class needs some configuration? He doesn't have a clue 
    // that he has to (abstract) or can (virtual) write a new static constructor.
    static Asset() 
    {
        s_Directory = "Data/Assets"; 
        s_Icon = Icon.Hi;
    }
}

Why is there no way can overwrite the static constructor in a subclass when at the same time I can do it with the new Modifier? abstract and virtual would actually help remind that there is something to implement.

You all know, that this would be an easy task: using a virtual static the same way we use "new". so why the dogma, that this is not and won't ever be possible?

I know, that there are reason to prevent overusing static. because it would simply clutter RAM while being there until the program exits.

But again, after having a bit more complicated container class that has to avoid Generics (Unity3D) it would be great if I could override a virtual static once, instead of every time on an object. Call it dynamic metadata, or whatever, but without, the workaround I'm currently using is quite cumbersome. And I don't want to end up overengineering code, because the provided tech refuses to take a step forward.

[jnm2]

Have you looked into getting analyzers to verify the correct coding patterns for you? They are much more flexible and can be taken advantage of today rather than three years from now.

[ghost]

Am using ReSharper, but I'm stumbling over this issue every once in a while and thought I should post it. The problem actually isn't a particular Issue of mine, but the potential of using data, object independently, whilst being flexible by enabling polymorphism even in the static area without having to gather its information from somewhere outside.

[jnm2]

Roslyn analyzers work with or without Roslyn since they are integrated into the C# compiler itself. You can enforce errors or warnings, report suggestions, apply code fixes, etc, and they will work in any C# IDE.

[svick]

after having a bit more complicated container class that has to avoid Generics (Unity3D) it would be great if I could override a virtual static once

If you can't use a C# 2.0 feature, what makes you think a C# 8.0 (or whatever) feature will be fine?

[ghost]

first of all generics don't apply polmorphism, second of all I know how to use them Unity just doesn't serialize them properly. Third of all the stuff I'm requesting is absolutely independent of generics, but nice try being a dick.

[ghost]

jnm2 so you mean I can use roslyn to make this kind of new requirement myself, that resembles a virtual/abstract static? I have roslyn included, and sometimes I use its recommendations, just like i use resharper,

[jnm2]

This explains Roslyn analyzers well: https://docs.microsoft.com/en-us/visualstudio/extensibility/getting-started-with-roslyn-analyzers

They provide ways to address these comments:

this could just be abstract or virtual and wouldn't be any different, except for virtual and abstract, the developer using this code would be notified that he has to implement it.

I could overwrite this in a subclass, by simply writing a static constructor there. but what if I want the developer creating a subclass of this do that? And make him figure that this class needs some configuration? He doesn't have a clue that he has to (abstract) or can (virtual) write a new static constructor.

Analyzers can provide a compile-time error with a rid squiggly in the editor and a code action to insert the expected members in the subclass.

@svick was asking a reasonable question. If, hypothetically, this feature landed in C# 9, how long would it take Unity to allow you to use it?

[HaloFour]

@Draethorian

That's a pretty quick way to shut down conversation on any proposal and alienate yourself from the community. Given that any proposal requires that a member of the language design team to want to champion through their design meetings in order to even have a chance at implementation it's not very conducive to address criticism through personal attack.

[ghost]

If you can't use a C# 2.0 feature, what makes you think a C# 8.0 (or whatever) feature will be fine?

Well yeah, looks I took it the wrong way.
I think Serialization is more complicated and key to performance for Unity, whereas virtual/ abstract static (dynamic/adjustable submetadata) is not.

I'm sorry for the insult, but right now I'm stuck in that phase of having to prove myself as an outsider/independent. Guess what that means in Frankfurt's CV Jerkism. So yeah, my nerves are kinda raw. Sry.

[jnm2]

Guess what that means in Frankfurt's CV Jerkism.

I don't know what "Frankfurt's CV Jerkism" is, but certainly no one is expecting you to prove yourself. We should always be careful in the way we word things. I hope you'll be able to relax, and assume the best, and participate with everyone in this repo long enough to shake off that outsider feeling! 😃

[ghost]

thx buddy, appreciate it. svick: I'm sorry I misunderstood your statement.

[DavidArno]

first of all generics don't apply polmorphism...

Have a read up of parametric polymorphism

(link now fixed, thanks @theunrepentantgeek)

[jnm2]

@DavidArno Link is broken.

[theunrepentantgeek]

Pretty sure that @DavidArno meant this link

[rossdempster]

There is at least one compelling use-case for virtual statics.

public class MessageBase
{
    protected abstract static MessageBase ReadMessage(BinaryReader reader);
}

Elsewhere, inside a generic method:

void SomeGenericMethod<T>()
    where T : MessageBase
{
    ...

    var message = T.ReadMessage(reader);
    DoSomethingWithMessage(message);

    ....
}

That is to say, it solves the where T: new() issue for parameters.

[jnm2]

That would require either the C# compiler to emit reflection code, or a new CLR feature, but it could be cool.

[theunrepentantgeek]

If memory serves (it's been a long while), this aligns with the class methods supported by Delphi's Object Pascal - they could be virtual and overridden by subclasses. They were really useful for creating factory methods and robust serialization, amongst other uses.