32

I hope I missed this in the docs. Is there a way to declare a type synonym in C#?

davidg
  • 5,868
  • 2
  • 33
  • 51
akonsu
  • 28,824
  • 33
  • 119
  • 194

7 Answers7

26

You can use the using statement to create an alias for a type.

For example, the following will create an alias for System.Int32 called MyInt

using MyInt = System.Int32;

Alternatively, you can use inheritance to help in some cases. For example

Create a type People which is a List<Person>

public class People: List<Person>
{
}

Not quite an alias, but it does simplify things, especially for more complex types like this

public class SomeStructure : List<Dictionary<string, List<Person>>>
{
}

And now you can use the type SomeStructure rather than that fun generic declaration.

For the example you have in your comments, for a Tuple you could do something like the following.

public class MyTuple : Tuple<int, string>
{
  public MyTuple(int i, string s) :
    base(i, s)
  {
  }
}
Chris Taylor
  • 52,623
  • 10
  • 78
  • 89
  • Update to include some alternatives, based on your comment referencing Tuple. – Chris Taylor Oct 07 '10 at 19:42
  • 4
    So really, the answer is no, at least not like in Haskell. `using` scopes the synonym to the local file, and you cannot define two different synonyms for the same type. Inheritance, aside from being _evil_ in itself, does not apply to sealed classes like String, which are the types we are usually _most_ interested in creating synonyms for. One additional way of "creating" synonyms would be encapsulation, or adapters. Create a `MyTuple` class that has an instance of the `Tuple` hidden inside, and forward all the calls to it (of course u must implement all interfaces of the encapsulated type). – Andriy Drozdyuk Sep 12 '12 at 16:11
  • You can also use extensions to extend a class without having to inherit or modify it directly. E.g., you can add methods to the String class, @drozzy. http://msdn.microsoft.com/en-us/library/bb383977.aspx – ps2goat May 29 '13 at 03:38
17

Perhaps you're looking for Using Alias Directives:

using MyType = MyNamespace.SomeType;

This lets you, in your code, type:

// Constructs a MyNamespace.SomeType instance...
MyType instance = new MyType();
Reed Copsey
  • 554,122
  • 78
  • 1,158
  • 1,373
  • 1
    thank you. an overwhelming amount of responses. :) i guess i did miss it. although one caveat here is that i cannot use this synonym in other files... that would be nice. – akonsu Oct 07 '10 at 19:22
  • 1
    @akonsu: No, it's a compile time construct, so it's per file (technically, per compilation unit or namespace - it may only be valid for **part** of a file, depending on where you put it). You need to copy this into any file where you wish to use it. It's the closest thing C# has to a "type synonym", however. – Reed Copsey Oct 07 '10 at 19:25
11

is there a way to declare a type synonym in c#?

No.

You can create an alias with using but that is limited to the 1 file (namespace).

H H
  • 263,252
  • 30
  • 330
  • 514
  • There is 1 trick: http://stackoverflow.com/a/41704128/3241228. This is not the solution for any case, but it's better than nothing – user1234567 Jan 19 '17 at 10:00
  • @HenkHolterman; to keep compatibility with old source code, the new class has a new namespace, but I can declare a synonymous like this: namespace BtStatus { using StatusBar = MyDevices.StatusBar; } the new class is namespace MyDevices { public partial class StatusBar : UserControl {} } in the old projects, continues using the same synthase. "BTStatus.StatusBar". – antonio Jul 19 '19 at 07:58
3

It sounds like you're talking about an alias which you can declare in your using statements at the top of your codefiles:

using MyDate = System.DateTime;
Steve Danner
  • 21,818
  • 7
  • 41
  • 51
1

@CountOren was close 

sealed public class Name
{
    private readonly string _value;
    private Name(string value) { _value = value; }
    public static implicit operator string(Name name) { return name._value; }
    public static implicit operator Name(string value) { return new Name(value); }
}

Usage

Name myName = "John";

Some types are better to go as struct in which case remove sealed and replace class with struct. It is up to you if you want to have sealed in case you want to go with class at all.

  • This is the only elegant way IMHO. I needed this for int and it works just add implicit operator for any additional behaviour if needed but those 2 will cover most of situations – BojanT Sep 16 '21 at 21:16
1

Global usings are now possible in C#10

global using MyInt = System.Int64;

ldlac
  • 11
  • 1
0

This is not the most straightforward way to solve this problem but when I need a type synonym I create a class with implicit conversions to and from the target type, for example:

Given Name needs to be synonym to string, Then you can do the following:

public class Name
{
    public string Value;
    public static implicit operator string(Name name) { return name.Value; }
    public static implicit operator Name(string name) { return new Name {Value = name}; }
}

Which will give you the ability to use Name type around your code and the compiler will let you assign values to it as well from a string.

If you have the following method signature: 

public void SomeMethodThatNeedsName(Name name)

You could do this:

SomeMethodThatNeedsName("aNameThatComesFromString")
CountOren
  • 844
  • 1
  • 9
  • 27