[Proposal] Global "alias" for Structs and Classes

[KingSora]

Hello!

I am working with classes and structs which requires more than one generic, butall types are dependent on the first generic type. Here is a example:

internal struct Struct<T, T1> : where T1 :  IInterf<T>, IInterf2<T>, IInterf3<T>, new() {
      private static readonly T1 = new T1();
}

As already mentioned, the second generic type T1 is logically dependent of the first generic type T. For example if T is int the second type T1 has to be its logical counterpart, lets name it IntFuncs. So the only logical declaration of this struct would be:

Struct<int, IntFuncs> st = new Struct<int, IntFuncs>();

A possible solution would be something like this:

internal struct Struct<T> {
      private static readonly IGenericFuncs<T> t1 = Helper.GetFuncs(typeof(T));
}

But due to the fact that I am using a interface instead of a class now, the code runs 1/3 slower then the first approach with two generics.

My proposal:
You can define a "global" alias for structs and classes, something like this:

public struct StructInt is Struct<int, IntFuncs>;

//or

public struct StructInt alias Struct<int, IntFuncs>;

This also has benefits if you're writing an library with internal generics but you want them to be easy accessed from outside. For classes this is already possible, if you simply inherit the generic class, but you have to write all your constructors again (even if youre just calling the base constructor):

internal class Class<T, T1> : where T1 :  IInterf<T>, IInterf2<T>, IInterf3<T>, new() {
      //...
     public Class(T arg1, T arg2) {
          //...
     }
}
public class ClassInt : Class<int, IntFuncs> {
    public ClassInt (T arg1, T arg2) : base(arg1, arg2) { }
}

So this could be a shortcut aswell:

public class ClassInt is Class<int, IntFuncs>;

//or

public class ClassInt alias Class<int, IntFuncs>;

Thats my proposal. In fact I would add some restrictions so that only internal structs / classes can have a public alias or something.
Yes I know you can create your own alias with

using StructInt = Struct<int, IntFuncs>;

but this must be declared in every file youre using this struct / class. And as a library developer you can't provide simple access to your structs / classes with this approach. Thats why I think my proposal would be a cool feature in an upcoming C# version.

Thank you.

[ufcpp]

#90

[KingSora]

@ufcpp
Well, #90 is something completely different.

[MkazemAkhgary]

#90 is very useful. Also having alias defined in namespace and be usable from other namespaces is neat feature. In fact for generic intensive classes and structs this can be very helpful to keep things short and concise.

Both #90 and this can help for scenarios where you have generics in generics and typing them is frustrating.

It can be helpful for generic object composition scenarios.

I have good example for that. Struct enumerators. Cool thing about struct enumerators is that they can build up together and form variety of struct enumerators in efficient way. For example

ReverseEnumerator<RangeEnumerator<SelectEnumerator<TSource, TIn, TOut>, ...>

Obviously i exegerated here but main point is Writing such thing is frustrating. Its a complex Declaration but alias can help with it.

Maybe more advanced type inference can also help where you dont need to write generic arguments anymore. Then you probably wouldnt use alias anyway. You still probably use alias if it gives meaningful name in more specific context

[dx-prog]

The look up approach of below is what you mean by 1/3 slower? Is that due to reflection?

Helper.GetFuncs(typeof(T));

What exactly is the use case that would require some sort of language change. Could you elaborate. From what code you do show, I am not sure why your problem would not be solved by IoC, or some other pattern.

[dx-prog]

The only case I see for a global alias is structs that are generics. Not structs in general.

Unless it is constrained, you will end up with typedef/define explosions that C++ suffers from where you have an absurd number of type definitions for strings.

char*, CHAR*, TCHAR*, LPTSTR,...

[KingSora]

@dx-prog
I agree with you! In fact it would only make sense for generic structs or generic classes. This should definitely be a restriction if the feature would be implemented.

The code is slower because I am using a Interface or Abstract class instead of a normal class. In a Interface or Abstract class I'm calling a virtual method which makes my struct slower. Its, well, just a tiny bit slower (and only when I have many iterations). Nevertheless, I think a global alias (with restrictions of course) wouldn't be a bad feature.

[MkazemAkhgary]

you will end up with typedef/define explosions that C++ suffers from where you have an absurd number of type definitions for strings.

@dx-prog i wouldnt be as condifent as you. The word "you will" isnt quite right. Its better to say "you probably will".

No one can stop you doing terrible things. C++ did terrible thing wasnt because of alias feature. Im pretty sure there are other reasons. Certainly c# would not introduce cryptic and confusing aliases. Its only used by developers who want to reduce amount of typing.

Yes. Having global aliases can open new path for doing terrible things. But this is true for every single feature of the language.

Think about enormous usages of pocket knife. Plenty of good stuff you can do with it, meanwhile you can kill someone using same knife. So what you say? Knife is good or bad? :)

[alrz]

#259

[bondsbw]

@dx-prog

Unless it is constrained, you will end up with typedef/define explosions that C++ suffers from where you have an absurd number of type definitions for strings.

char*, CHAR*, TCHAR*, LPTSTR,...

The CLR is designed to be cross-platform, which is why int is always Int32 is always 32-bit. So that eliminates one reason for the kinds of aliases that are so common in C++.

Another reason is that the usage of pointers in C# is much lower.

[4creators]

Copy paste of #259

While using-alias-directive "introduces an identifier that serves as an alias for a namespace or type within the immediately enclosing compilation unit or namespace body", internal aliases can be referenced anywhere within a program.

internal using StringMap = Dictionary<string , string>;

• Internal aliases will be erased during compile-time and will be replaced with the underlying type.
• Internal aliases are totally equivalent to the underlying type but, for example, IntelliSense could be extended to suggest only extension methods on the specific type alias.
• Internal aliases (along with file-scoped aliases) could also support generics (Proposal: Support generics and generic type parameters in aliases #90),

internal using Map<T> = Dictionary<string , T>;

Alternatively we could use alias or type, since internal carries some implications:

• InternalsVisibleTo should work with internal aliases but it won't.
• internal is "the default" modifier in a global or namespace context.