类型参数构造函数签名约束

Question

public static IEnumerable<TV> To<TU, TV>(this IEnumerable<TU> source) where TV : new(TU) 
{ 
    return source.Select(x => new TV(TU)); 
} 

问题是我不能给出新的（TU）约束。

• 有没有解决这个问题的方法？

Answer 1

也许最简单的方法是在调用的地方明确地将公式从TU改为TV，就像后面的选项1一样。如果您希望隐藏场景背后的转换细节，以使其在您调用扩展方法的任何位置工作以避免重复公式，那么接口是适当的，因为它可以用作扩展方法的约束：

class Program 
{ 
    static void Main(string[] args) 
    { 
     IEnumerable<U> uSequence = new List<U>(); 
     IEnumerable<V> vSequence1 = uSequence.To(u => new V(u)); //Option 1 : explicit transformation, needs neither any interface nor explicit types (type inference at work) 
     IEnumerable<V> vSequence2 = uSequence.To<U, V>(); //Option 2 : implicit transformation internally supported from U to V by type V thanks to IBuildableFrom<TV, TU>, but you must precise To<U, V>() with the types 
    } 
} 

public static class Extensions { 
    //Option 1 
    public static IEnumerable<TV> To<TU, TV>(this IEnumerable<TU> source, Func<TU,TV> transform) 
    { 
     return source.Select(tu => transform(tu)); 
    } 

    //Option 2 
    public static IEnumerable<TV> To<TU, TV>(this IEnumerable<TU> source) where TV : IBuildableFrom<TV, TU>, new() 
    { 
     return source.Select(tu => new TV().BuildFrom(tu)); 
    } 
} 

public interface IBuildableFrom<TV, TU> 
{ 
    TV BuildFrom(TU tu); 
} 

public class U { } //Cheesy concrete class playing the rôle of TU 
public class V : IBuildableFrom<V, U> //Cheesy concrete class playing the rôle of TV 
{ 
    public V BuildFrom(U u) 
    { 
     //Initialization of this' properties based on u's ones 
     return this; 
    } 

    public V(U u) { }//Used by option 1 
    public V() { } //Used by option 2 
} 

Answer 2

也许传递函数求能够从TU制作电视：

public static IEnumerable<TV> To<TU, TV>(
    this IEnumerable<TU> source, 
    Func<TU, TV> builder) 
    where TV : class 
{ 
    return source.Select(x => builder(x)); 
} 

与

tus.To(x => new TV(x)); 

Answer 3

我要告诉你两种方法调用：

首先使用Activator.CreateInstance

public static IEnumerable<TV> To<TU, TV>(this IEnumerable<TU> source) 
{ 
    return source.Select(m => (TV) Activator.CreateInstance(typeof(TV), m)); 
} 

其次，你可以使用接口来定义属性，而不是使用参数的构造函数：

public interface IRequiredMember 
{} 

public interface IHasNeccesaryMember 
{ 
    IRequiredMember Member 
    { 
    get; 
    set; 
    } 
} 

public static IEnumerable<TV> To<TU, TV>(this IEnumerable<TU> source) 
      where TV : IHasNeccesaryMember, new() 
      where TU : IRequiredMember 
{ 
    return source.Select(m => new TV{ Member = m }); 
} 

第一种方法的作品，但感觉很脏，有越来越构造函数调用错误的风险，尤其是在方法不受限制。

因此，我认为第二种方法是一个更好的解决方案。