blocks|key|2032609|text|不是的。目前，您可以指定的唯一构造函数约束是无参数构造函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2032610|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

No. At the moment the only constructor constraint you can specify is for a no-arg constructor.

blocks|key|2032908|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2032909|我使用lambda方法解决这个问题。|2032910|public+static+void+Method<T>(Func<int,T>+del)+{
++var+t+=+del(42);
}|code-block|syntax|javascript|2032911|用例|2032912|Method(x+=>+new+Foo(x));|2032913|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|N|7|@]|8|@]|9|$]]|$1|A|3|B|4|5|6|O|7|@]|8|@]|9|$]]|$1|C|3|D|4|E|6|P|7|@]|8|@]|9|$F|G]]|$1|H|3|I|4|5|6|Q|7|@]|8|@]|9|$]]|$1|J|3|K|4|E|6|R|7|@]|8|@]|9|$F|G]]|$1|L|3|-4|4|5|6|S|7|@]|8|@]|9|$]]]|M|$]]

There is no such construct. You can only specify an empty constructor constraint. 

I work around this problem with lambda methods.

<pre><code>public static void Method&lt;T&gt;(Func&lt;int,T&gt; del) {
 var t = del(42);
}
</code></pre>

Use Case

<pre><code>Method(x =&gt; new Foo(x));
</code></pre>

blocks|key|2032947|text|正如您所发现的，您不能这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2032948|作为一种解决办法，我通常提供一个可以创建T类型的对象的委托|offset|length|style|CODE|2032949|public+class+A+{

++++public+static+void+Method<T>+(T+a,+Func<float[,],+T>+creator)+{
++++++++//...do+something...
++++}

}|code-block|syntax|javascript|2032950|entityMap^0|0|K|1|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

As you've found, you can't do this.

As a workaround I normally supply a delegate that can create objects of type <code>T</code>:

<pre><code>public class A {

 public static void Method&lt;T&gt; (T a, Func&lt;float[,], T&gt; creator) {
 //...do something...
 }

}
</code></pre>

blocks|key|1819405|text|这里有一个我个人认为非常有效的变通方法。如果您想一想什么是通用参数化构造函数约束，那么它实际上是具有特定签名的类型和构造函数之间的映射。您可以使用字典创建您自己的此类映射。把它们放在一个静态的“工厂”类中，你就可以创建不同类型的对象，而不必担心每次都要构建一个构造函数lambda：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1819406|public+static+class+BaseTypeFactory
{
+++private+delegate+BaseType+BaseTypeConstructor(int+pParam1,+int+pParam2);

+++private+static+readonly+Dictionary<Type,+BaseTypeConstructor>
+++mTypeConstructors+=+new+Dictionary<Type,+BaseTypeConstructor>
+++{
++++++{+typeof(Object1),+(pParam1,+pParam2)+=>+new+Object1(pParam1,+pParam2)+},
++++++{+typeof(Object2),+(pParam1,+pParam2)+=>+new+Object2(pParam1,+pParam2)+},
++++++{+typeof(Object3),+(pParam1,+pParam2)+=>+new+Object3(pParam1,+pParam2)+}
+++};|code-block|syntax|javascript|1819407|然后在你的泛型方法中，例如：|1819408|+++public+static+T+BuildBaseType<T>(...)
++++++where+T+:+BaseType
+++{
++++++...
++++++T+myObject+=+(T)mTypeConstructors[typeof(T)](value1,+value2);
++++++...
++++++return+myObject;
+++}|1819409|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here is a workaround for this that I personally find quite effective. If you think of what a generic parameterized constructor constraint is, it's really a mapping between types and constructors with a particular signature. You can create your own such mapping by using a dictionary. Put these in a static "factory" class and you can create objects of varying type without having to worry about building a constructor lambda every time:

<pre><code>public static class BaseTypeFactory
{
 private delegate BaseType BaseTypeConstructor(int pParam1, int pParam2);

 private static readonly Dictionary&lt;Type, BaseTypeConstructor&gt;
 mTypeConstructors = new Dictionary&lt;Type, BaseTypeConstructor&gt;
 {
 { typeof(Object1), (pParam1, pParam2) =&gt; new Object1(pParam1, pParam2) },
 { typeof(Object2), (pParam1, pParam2) =&gt; new Object2(pParam1, pParam2) },
 { typeof(Object3), (pParam1, pParam2) =&gt; new Object3(pParam1, pParam2) }
 };
</code></pre>

then in your generic method, for example:

<pre><code> public static T BuildBaseType&lt;T&gt;(...)
 where T : BaseType
 {
 ...
 T myObject = (T)mTypeConstructors[typeof(T)](value1, value2);
 ...
 return myObject;
 }
</code></pre>

blocks|key|1819465|text|使用反射创建泛型对象时，类型仍然需要声明正确的构造函数，否则将抛出异常。您可以传入任何参数，只要它们与其中一个构造函数匹配。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1819466|使用这种方法，您不能在模板中对构造函数施加约束。如果构造函数丢失，则需要在运行时处理异常，而不是在编译时获得错误。|1819467|//+public+static+object+CreateInstance(Type+type,+params+object[]+args);

//+Example+1
T+t+=+(T)Activator.CreateInstance(typeof(T));
//+Example+2
T+t+=+(T)Activator.CreateInstance(typeof(T),+arg0,+arg1,+arg2,+...);
//+Example+3
T+t+=+(T)Activator.CreateInstance(typeof(T),+(string)arg0,+(int)arg1,+(bool)arg2);|code-block|syntax|javascript|1819468|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Using reflection to create a generic object, the type still needs the correct constructor declared or an exception will be thrown. You can pass in any argument as long as they match one of the constructors.

Used this way you cannot put a constraint on the constructor in the template.
If the constructor is missing, an exception needs to be handled at run-time rather than getting an error at compile time.

<pre><code>// public static object CreateInstance(Type type, params object[] args);

// Example 1
T t = (T)Activator.CreateInstance(typeof(T));
// Example 2
T t = (T)Activator.CreateInstance(typeof(T), arg0, arg1, arg2, ...);
// Example 3
T t = (T)Activator.CreateInstance(typeof(T), (string)arg0, (int)arg1, (bool)arg2);
</code></pre>

blocks|key|1820015|text|我认为这是在某种程度上限制了对象构造方式的最干净的解决方案。它不是完全在编译时检查的。当您同意让类的实际构造函数具有与IConstructor接口相同的签名时，这有点像对构造函数的约束。由于显式的接口实现，在正常使用对象时，Constructor方法是隐藏的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1820016|using+System.Runtime.Serialization;

namespace+ConsoleApp4
{
++++class+Program
++++{
++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++var+employeeWorker+=+new+GenericWorker<Employee>();
++++++++++++employeeWorker.DoWork();
++++++++}
++++}

++++public+class+GenericWorker<T>+where+T:IConstructor
++++{
++++++++public+void+DoWork()
++++++++{
++++++++++++T+employee+=+(T)FormatterServices.GetUninitializedObject(typeof(T));
++++++++++++employee.Constructor("John+Doe",+105);
++++++++}
++++}

++++public+interface+IConstructor
++++{
++++++++void+Constructor(string+name,+int+age);
++++}

++++public+class+Employee+:+IConstructor
++++{
++++++++public+string+Name+{+get;+private+set;+}
++++++++public+int+Age+{+get;+private+set;+}

++++++++public+Employee(string+name,+int+age)
++++++++{
++++++++++++((IConstructor)this).Constructor(name,+age);
++++++++}

++++++++void+IConstructor.Constructor(string+name,+int+age)
++++++++{
++++++++++++Name+=+name;
++++++++++++Age+=+age;
++++++++}
++++}
}|code-block|syntax|javascript|1820017|entityMap^0|34|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I think this is the most clean solution that kind of puts a constraint on the way an object is constructed. It is not entirely compile time checked. When you have the agreement to make the actual constructor of the classes have the same signature like the IConstructor interface, it is kind of like having a constraint on the constructor. The <code>Constructor</code> method is hidden when working normally with the object, because of the explicit interface implementation.

<pre><code>using System.Runtime.Serialization;

namespace ConsoleApp4
{
 class Program
 {
 static void Main(string[] args)
 {
 var employeeWorker = new GenericWorker&lt;Employee&gt;();
 employeeWorker.DoWork();
 }
 }

 public class GenericWorker&lt;T&gt; where T:IConstructor
 {
 public void DoWork()
 {
 T employee = (T)FormatterServices.GetUninitializedObject(typeof(T));
 employee.Constructor("John Doe", 105);
 }
 }

 public interface IConstructor
 {
 void Constructor(string name, int age);
 }

 public class Employee : IConstructor
 {
 public string Name { get; private set; }
 public int Age { get; private set; }

 public Employee(string name, int age)
 {
 ((IConstructor)this).Constructor(name, age);
 }

 void IConstructor.Constructor(string name, int age)
 {
 Name = name;
 Age = age;
 }
 }
}
</code></pre>

blocks|key|2033756|text|下面是c#维护者推荐的解决方法，如果你想保持构造函数的参数完整，可以间接调用构造函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2033757|++++++++++++i+=+(TService)Activator.CreateInstance(typeof(TService),+new+object[]+{arg});|code-block|syntax|javascript|2033758|其中TService是一个泛型，它有一个我想保留的全参数构造函数。|2033759|如果您想了解此方法的工作原理：https://docs.microsoft.com/en-us/dotnet/api/system.activator.createinstance?view=net-5.0#system-activator-createinstance(system-type-system-object-)|offset|length|2033760|Aaaaand和C#维护者的讨论：https://github.com/dotnet/csharplang/discussions/769|2033761|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.activator.createinstance?view=net-5.0#system-activator-createinstance(system-type-system-object-)|1|https://github.com/dotnet/csharplang/discussions/769^0|0|0|0|F|44|0|0|H|1G|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|11|8|@]|9|@$K|12|L|13|1|14]]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$K|16|L|17|1|18]]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

Here's the recommended workaround by c# maintainers if you'd like to keep the constructor parameter-ful, call the constructor indirectly:
<pre><code> i = (TService)Activator.CreateInstance(typeof(TService), new object[] {arg});
</code></pre>
Where TService is a generic with a parameter-full constructor that I'd like to keep.
If you'd like to read up on how this method works:
<a href="https://docs.microsoft.com/en-us/dotnet/api/system.activator.createinstance?view=net-5.0#system-activator-createinstance(system-type-system-object-)" rel="nofollow noreferrer">https://docs.microsoft.com/en-us/dotnet/api/system.activator.createinstance?view=net-5.0#system-activator-createinstance(system-type-system-object-)</a>
Aaaaand discussion by maintainers of C#:
<a href="https://github.com/dotnet/csharplang/discussions/769" rel="nofollow noreferrer">https://github.com/dotnet/csharplang/discussions/769</a>

In C# you can put a constraint on a generic method like:

<pre><code>public class A {

 public static void Method&lt;T&gt; (T a) where T : new() {
 //...do something...
 }

}
</code></pre>

Where you specify that <code>T</code> should have a constructor that requires no parameters. I'm wondering whether there is a way to add a constraint like "there exists a constructor with a <code>float[,]</code> parameter?"

The following code doesn't compile:

<pre><code>public class A {

 public static void Method&lt;T&gt; (T a) where T : new(float[,] u) {
 //...do something...
 }

}
</code></pre>

A workaround is also useful?

Is there a generic constructor with parameter constraint in C#?

在C#中，您可以对泛型方法施加约束，如下所示：public class A { public static void Method<T> (T a) where T : new() { //...do something... }}其中指定T应该有一个不需要参数的构造函数。我想知道是否有办法添...

问C#中是否有带参数约束的泛型构造函数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中是否有带参数约束的泛型构造函数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中是否有带参数约束的泛型构造函数？
EN