public class UserFactory
{
    public User CreateUser(string email) {
        return new User(email);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace ValueOf
{
    public class ValueOf<TValue, TThis> where TThis : ValueOf<TValue, TThis>, new()
    {
        private static readonly Func<TThis> Factory;

        /// <summary>
        /// WARNING - THIS FEATURE IS EXPERIMENTAL. I may change it to do
        /// validation in a different way.
        /// Right now, override this method, and throw any exceptions you need to.
        /// Access this.Value to check the value
        /// </summary>
        protected virtual void Validate()
        {
        }

        static ValueOf()
        {
            ConstructorInfo ctor = typeof(TThis)
                .GetTypeInfo()
                .DeclaredConstructors
                .First();

            var argsExp = new Expression[0];
            NewExpression newExp = Expression.New(ctor, argsExp);
            LambdaExpression lambda = Expression.Lambda(typeof(Func<TThis>), newExp);

            Factory = (Func<TThis>)lambda.Compile();
        }

        public TValue Value { get; protected set; }

        public static TThis From(TValue item)
        {
            TThis x = Factory();
            x.Value = item;
            x.Validate();

            return x;
        }

        protected virtual bool Equals(ValueOf<TValue, TThis> other)
        {
            return EqualityComparer<TValue>.Default.Equals(Value, other.Value);
        }

        public override bool Equals(object obj)
        {
            if (obj is null)
                return false;

            if (ReferenceEquals(this, obj))
                return true;

            return obj.GetType() == GetType() && Equals((ValueOf<TValue, TThis>)obj);
        }

        public override int GetHashCode()
        {
            return EqualityComparer<TValue>.Default.GetHashCode(Value);
        }

        public static bool operator ==(ValueOf<TValue, TThis> a, ValueOf<TValue, TThis> b)
        {
            if (a is null && b is null)
                return true;

            if (a is null || b is null)
                return false;

            return a.Equals(b);
        }

        public static bool operator !=(ValueOf<TValue, TThis> a, ValueOf<TValue, TThis> b)
        {
            return !(a == b);
        }

        public override string ToString()
        {
            return Value.ToString();
        }
    }
}

public class EmailAddress : ValueOf<string, EmailAddress> { }

EmailAddress emailAddress = EmailAddress.From("foo@bar.com");

public class Address : ValueOf<(string firstLine, string secondLine, Postcode postcode), Address> { }

 http://en.هشام.com/post/build-customizable-language-switcher-tag-helper-with-bootstrap

 WebRequest wr = WebRequest.Create(uri);
using (WebResponse response = wr.GetResponse()) { }

 The remote name could not be resolved: 'en.هشام.com'

<configuration>
    <uri>
        <idn enabled="All" />
        <iriParsing enabled="true" />
    </uri>
</configuration>

 var unicode = @"en.هشام.com";
 
var mapping = new IdnMapping(); // IDN  = Internationalizing Domain Names
var ascii = mapping.GetAscii(unicode);
Console.WriteLine(ascii);
 
string convertedBackToUnicode = mapping.GetUnicode(ascii);
Console.WriteLine(convertedBackToUnicode);

with 1.3.x, you can't declare a global constructor and use it with ng-controller as I was doing before. You have to create an angular module and add MainController as a controller 

• Add option to organize imports during document formatting. (PR: #4302)
• Update to use zero based indexes (PR: #4300)
• Improve request queues to improve code completion performance (PR: #4310)
• Add setting to control whether to show the OmniSharp log on error (#4102, #4330, PR: #4333)
• Support building launch assets for NET6-NET9 projects (#4346, PR: #4349) 

In case you are curious, a new benchmark appeared. The benchmark is really simple at present, but I think their plans are to increase the complexity over time to show a more real-world use case than something like the TechEmpower benchmarks which are typically optimized for performance.