[c# Feature Request] new options type as an alternative to Enum liked static readonly properties

[John0King]

I had this idea for several months. I want something like

public class Foo {  ... } 
public class ChildFoo:Foo {  ... }

public options<Foo>  KnowenFoo
{
    FooA = new Foo(){   ...};
    FooB = new ChildFoo() {  ... };
}

public options<Foo> KnowenFoo // options can easy to extend just like you create one
{
    FooC = new ExtendFoo();
}

public final options<string> MyStringOption  // final can not extends
{
    Click = "click";
    Tap = "tap";
}

//some method 
public void DoSomething(MyStringOption event,KnowenFoo foo) // the actual  method signature is (string event,Foo foo)

public void s()
{
  DoSomething("abcdefg",new Foo()) // and can always  pass the actual type to the method
}

the options is just a static Dictionary<string,T> ,It's not try to replace Enum, the goal is to provide more information to intellsense.

This is usefull for when you create a method like new System.Text.Encodings.Web.TextEncoderSettings(System.Text.Unicode.UnicodeRanges.All)) the
static class UnicodeRanges is better written as options<UnicodeRange>

but since "options" maybe a very common variable name, may be there's a better name for this feature

[GeirGrusom]

Duplicate of #274
Related #485

[svick]

So, when you declare variable as MyStringOption it accepts values that are not MyStringOption? I think that's very confusing.

If this is just about IntelliSense, then you don't need to change the language. For example, you could have a normal class and point IntelliSense to it using an attribute:

public void DoSomething(
    [Suggestion(typeof(MyStringOption))] string event,
    [Suggestion(typeof(KnowenFoo))] Foo foo)

[John0King]

@svick Is there a real SuggestionAttribute in .net ? what's the namespace ?

[svick]

@John0King I don't believe there is. I'm just suggesting an alternative solution.

[John0King]

@svick

[Suggestion(typeof(MyStringOption))] string event,
[Suggestion(typeof(KnowenFoo))] Foo foo)

Does that mean MyStringOption and KnowenFoo still be static class ? static class can not be extends right ?

I'm OK with method expose the actual type. but it better can be extend by another package.

So, when you declare variable as MyStringOption it accepts values that are not MyStringOption? I think that's very confusing

well , Enum kinda allow it too, public enum Foo{ A=0,B=2 } ; Foo x = (Foo)122

Besides, "the options is just a static Dictionary<string,T>" , that allow us get all members of that options without reflection.

[Pzixel]

@John0King why this doesn't work for you?

public class Foo {  ... } 
public class ChildFoo:Foo {  ... }
public class ExtendFoo:Foo{  ... }

public enum MyStringOption
{
    Click,
    Tap
}

//some method 
public void DoSomething(MyStringOption event,Foo foo)

I also don't understand how client could pass abcdefg if you only accept click or tap

[John0King]

@Pzixel

I also don't understand how client could pass abcdefg if you only accept click or tap

you can pass (MyStringOption)999 to the DoSomething right? and for sure it won't work. what I mean is : the Language Server Do NOT give you other suggession(suggession should like enum) but you can menully pass a actual type to the method .
The most user case is something like UnicodeRanges (it's a static class to provide UnicodeRange instance) ,it's silly if we can not pass a custom UnicodeRange to that method , the current enum only have string name and a int(or bits --> the FlagAttribute ) value , and because the FlagAttributes ,I don't think we can design the enum to like java and use custom type as value .
I'm sorry for that I use a bad sample on this , please see the KnownFoo type. I also see a few library use enum to define some web Api's error code (client side) , and alway have touble when a new error code has been introduced .

[Pzixel]

@John0King

you can pass (MyStringOption)999 to the DoSomething right? and for sure it won't work. what I mean is : the Language Server Do NOT give you other suggession(suggession should like enum) but you can menully pass a actual type to the method .

It's a shame that C# allows this. However, I understand, why - it's because of leaky serialization abstraction. But normally it shouldn't be allowed. Your code cannot use this unknown enum value other than throw an exception or something like that.

Sorry, but I don't see any value in this suggestion. You either has some predefined set of possible actions - then you can use public static readonly properties for them, see HttpMethod as example, or you don't have it - then I don't see any reason to limit client: just allow him to pass anything of this type and work with it.

If you want to extend default custom values by something else you probably may want #192

[John0King]

@Pzixel

You either has some predefined set of possible actions - then you can use public static readonly properties for them

The goal of this feature is replace those static readonly properties to a "virtual type" that has intellsence.

[Pzixel]

@John0King I'm not sure we are talking about the same. I have intellisense for HttpMethod, it doesn't fit you?

[HaloFour]

I'm with @svick, I don't think that this proposal necessitates any changes to the language proper. I think that if the functionality requested is found to be compelling that it could be achieved through attributes which could be added to the BCL. Visual Studio already uses quite a few attributes to drive the behavior of the tooling including hiding members from Intellisense.

[John0King]

😄 OK, ReSharp win.
However, Can you try to write a custom type that has static readonly properties .
and even that work , Can it suggession to another static class ? (microsoft use UnicodeRanges instead of inside UnicodeRange, and all code I've seen , most developer use another static class to define those instance )
and how it compare to Enum.GetValues ?
and can it be extend with a custem nuget packages ? #192 might need some CLR change and it might can not be used in a early .net .

and my idea is something like this

// new code 
public options UnicodeRanges
{
    All = new UnicodeRange(...);
   ...
}
public void  DoSometing(UnicodeRanges range); // in a class
// compile to 

public static class __namespace_global_variable
{
    public static readonly UnicodeRanges = new IReadOnlyDictionary<string,UnicodeRange>(){ {“All”,new UnicodeRange(...)} } // create a IReadonlyDictionary type by C# compiler
}

public void DoSomeThing([Suggesstion(__namespace_global_variable.UnicodeRanges)] UnicodeRange range) // in a class

only intellsence does not work today .

[Pzixel]

@John0King This is question about tooling, not about language itself. I believe that with "extension everyting" you could just add your custom static fields (for example static MyCoolHttpMethod property to HttpMethod) and have full support from intellisense. Probably with attribute, but it still being not a language issue.

"Extension everything" is highly demanded, so I expect it to be implemented realatively soon.

[Joe4evr]

OK, ReSharp win.

What? Even vanilla IntelliSense shows you static members.

[John0King]

@fanoI

One example of a thing should have been an enum and instead is a struct is System.Drawing.Color that needing to have methods (for example the one that converts the color to an ARGB int) and properties (A, R, G, B for example) needed to be a stuct with a "complex" system to construct a new Color starting from "KnowColors".

Is this feature you need ?
and @Joe4evr you already type HttpMehod , it must show class's static property.