Is there a way to define C# strongly-typed aliases of existing primitive types like `string` or `int`?
alias, c#, strong-typing
Solution
If you look at the .NET Framework System.Uri is the closest example that is similar to an email address. In .NET the pattern is to wrap something in a class and add constraints that way.
Adding strong typing that adds additional constraints to simple types is an interesting language feature that I believe some functional language has. I can't recall the name of the language which would let you add dimensional units such as feet to your values and do a dimensional analysis on your equations to ensure that the units matched.
Problem
Perhaps I am demonstrating my ignorance of some oft-used feautre of C# or the .NET framework, but I would like to know if there is a natively-supported way to create a type alias like `EmailAddress` which aliases `string` but such that I can extend it with my own methods like `bool Validate()`? I know of the `using x = Some.Type;` aliases but these are not global nor do they provide type safety, i.e. one could swap out an ordinary `string` for the using alias in the current file. I would like my `EmailAddress` to be its own type, independent and not interchangeable with the `string` type that it shadows. My current solution is to generate `public sealed partial EmailAddress : IEquatable<EmailAddress>, IXmlSerializable` classes with a T4 template generating the boilerplate implicit string conversion operators and other such things. This is fine with me for now and gives me a lot of flexibility but at the back of my mind it seems silly that I have to generate such copious amounts of boilerplate code to do something as simple as creating a strong type alias. Maybe this is not possible other than with code generation, but I am curious if others have attempted something similar with their designs and what your experiences have been. If nothing else, perhaps this could serve as a good use-case for such an alias feature in a hypothetical future version of C#. Thanks! EDIT: The real value that I want out of this is to be able to get type safety with primitive types that represent different types/formats for data. For instance, an `EmailAddress` and a `SocialSecurityNumber` and a `PhoneNumber`, all of which use `string` as their underlying type but which are not interchangeable types in and of themselves. I think this gets you much more readable and self-documenting code, not to mention added benefits of more method overload possibilities that are less ambiguous.