你可以使用我创建的一个名为LikeType的开源库和NuGet包，它会给你你正在寻找的GenericClass<int>行为。

代码如下所示:

public class SomeInt : LikeType<int>
{
    public SomeInt(int value) : base(value) { }
}

[TestClass]
public class HashSetExample
{
    [TestMethod]
    public void Contains_WhenInstanceAdded_ReturnsTrueWhenTestedWithDifferentInstanceHavingSameValue()
    {
        var myInt = new SomeInt(42);
        var myIntCopy = new SomeInt(42);
        var otherInt = new SomeInt(4111);

        Assert.IsTrue(myInt == myIntCopy);
        Assert.IsFalse(myInt.Equals(otherInt));

        var mySet = new HashSet<SomeInt>();
        mySet.Add(myInt);

        Assert.IsTrue(mySet.Contains(myIntCopy));
    }
}

在c# 10中，你可以这样做

global using Bar = Foo

它的工作方式类似于项目中的类型定义。

我还没有对它进行深入测试，所以可能会有一些怪癖。

我用它就像

global using DateTime = DontUseDateTime

其中DontUseDateTime是一个标记为Obsolete的结构体，以强制人们使用NodaTime。

不，没有typedef的真正对等物。你可以在一个文件中使用“using”指令，例如:

using CustomerList = System.Collections.Generic.List<Customer>;

但这只会影响源文件。在C和c++中，我的经验是typedef通常在广泛包含的.h文件中使用——所以一个typedef可以在整个项目中使用。这种能力在c#中是不存在的，因为c#中没有#include功能来允许你将一个文件中的using指令包含到另一个文件中。

幸运的是，您给出的示例确实有一个固定隐式方法组转换。您可以更改您的事件订阅行:

gcInt.MyEvent += gcInt_MyEvent;

:)

我认为没有类型定义。你只能在GenericClass中定义一个特定的委托类型，而不是泛型委托类型。

public delegate GenericHandler EventHandler<EventData>

这会使它更短。但是下面的建议怎么样:

使用Visual Studio。这样，当你打字的时候

gcInt.MyEvent += 

它已经从智能感知中提供了完整的事件处理程序签名。按TAB键，它就在那里。接受生成的处理程序名称或更改它，然后再次按TAB键自动生成处理程序存根。

c++和c#都缺少创建与现有类型在语义上完全相同的新类型的简单方法。我发现这样的“typedefs”对于类型安全编程来说是完全必要的，c#没有内置它们真是太遗憾了。void f(string connectionID, string username)和void f(ConID connectionID, username username)之间的区别是明显的…

(你可以在c++中通过BOOST_STRONG_TYPEDEF中的boost实现类似的功能)

使用继承可能很诱人，但它有一些主要的局限性:

它不适用于基本类型 派生类型仍然可以被转换为原始类型，即我们可以将它发送给接收原始类型的函数，这违背了整个目的 我们不能从密封类中派生(即许多.NET类是密封的)

在c#中实现类似的事情的唯一方法是将我们的类型组合在一个新类中:

class SomeType { 
  public void Method() { .. }
}

sealed class SomeTypeTypeDef {
  public SomeTypeTypeDef(SomeType composed) { this.Composed = composed; }

  private SomeType Composed { get; }

  public override string ToString() => Composed.ToString();
  public override int GetHashCode() => HashCode.Combine(Composed);
  public override bool Equals(object obj) => obj is TDerived o && Composed.Equals(o.Composed); 
  public bool Equals(SomeTypeTypeDefo) => object.Equals(this, o);

  // proxy the methods we want
  public void Method() => Composed.Method();
}

虽然这可以工作，但对于一个类型定义来说是非常冗长的。 此外，我们还有一个序列化(即Json)的问题，因为我们想通过它的compose属性序列化类。

下面是一个助手类，它使用“奇怪的重复模板模式”来简化这一点:

namespace Typedef {

  [JsonConverter(typeof(JsonCompositionConverter))]
  public abstract class Composer<TDerived, T> : IEquatable<TDerived> where TDerived : Composer<TDerived, T> {
    protected Composer(T composed) { this.Composed = composed; }
    protected Composer(TDerived d) { this.Composed = d.Composed; }

    protected T Composed { get; }

    public override string ToString() => Composed.ToString();
    public override int GetHashCode() => HashCode.Combine(Composed);
    public override bool Equals(object obj) => obj is Composer<TDerived, T> o && Composed.Equals(o.Composed); 
    public bool Equals(TDerived o) => object.Equals(this, o);
  }

  class JsonCompositionConverter : JsonConverter {
    static FieldInfo GetCompositorField(Type t) {
      var fields = t.BaseType.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy);
      if (fields.Length!=1) throw new JsonSerializationException();
      return fields[0];
    }

    public override bool CanConvert(Type t) {
      var fields = t.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.FlattenHierarchy);
      return fields.Length == 1;
    }

    // assumes Compositor<T> has either a constructor accepting T or an empty constructor
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) {
      while (reader.TokenType == JsonToken.Comment && reader.Read()) { };
      if (reader.TokenType == JsonToken.Null) return null; 
      var compositorField = GetCompositorField(objectType);
      var compositorType = compositorField.FieldType;
      var compositorValue = serializer.Deserialize(reader, compositorType);
      var ctorT = objectType.GetConstructor(new Type[] { compositorType });
      if (!(ctorT is null)) return Activator.CreateInstance(objectType, compositorValue);
      var ctorEmpty = objectType.GetConstructor(new Type[] { });
      if (ctorEmpty is null) throw new JsonSerializationException();
      var res = Activator.CreateInstance(objectType);
      compositorField.SetValue(res, compositorValue);
      return res;
    }

    public override void WriteJson(JsonWriter writer, object o, JsonSerializer serializer) {
      var compositorField = GetCompositorField(o.GetType());
      var value = compositorField.GetValue(o);
      serializer.Serialize(writer, value);
    }
  }

}

使用Composer，上面的类变得简单:

sealed Class SomeTypeTypeDef : Composer<SomeTypeTypeDef, SomeType> {
   public SomeTypeTypeDef(SomeType composed) : base(composed) {}

   // proxy the methods we want
   public void Method() => Composed.Method();
}

另外，SomeTypeTypeDef会序列化成Json，就像SomeType一样。

希望这能有所帮助!

对于非密封类，只需从它们继承:

public class Vector : List<int> { }

但是对于密封类，可以用这样的基类来模拟类型定义行为:

public abstract class Typedef<T, TDerived> where TDerived : Typedef<T, TDerived>, new()
{
    private T _value;

    public static implicit operator T(Typedef<T, TDerived> t)
    {
        return t == null ? default : t._value;
    }

    public static implicit operator Typedef<T, TDerived>(T t)
    {
        return t == null ? default : new TDerived { _value = t };
    }
}

// Usage examples

class CountryCode : Typedef<string, CountryCode> { }
class CurrencyCode : Typedef<string, CurrencyCode> { }
class Quantity : Typedef<int, Quantity> { }

void Main()
{
    var canadaCode = (CountryCode)"CA";
    var canadaCurrency = (CurrencyCode)"CAD";
    CountryCode cc = canadaCurrency;        // Compilation error
    Concole.WriteLine(canadaCode == "CA");  // true
    Concole.WriteLine(canadaCurrency);      // CAD

    var qty = (Quantity)123;
    Concole.WriteLine(qty);                 // 123
}