约束参数，新建（）

Question

有什么办法可以将的Parse方法移入抽象类？我尝试了多种方式（链接在底部），但我仍然遇到了一个或另一个障碍。

public class AnimalEntityId : EntityId<AnimalEntityId> 
{ 
    public AnimalEntityId() 
     : base() 
    { 
    } 

    private AnimalEntityId(string value) 
     : base(value) 
    { 
    } 

    public static AnimalEntityId Parse(string value) 
    { 
     return new AnimalEntityId(value); 
    } 
} 


public abstract class EntityId<TEntityId> 
{ 
    private readonly System.Guid value; 

    protected EntityId(string value) 
    { 
     this.value = System.Guid.Parse(value); 
    } 

    protected EntityId() 
    { 
     this.value = System.Guid.NewGuid(); 
    } 
} 

尝试了这些建议，没有运气：

• Passing arguments to C# generic new() of templated type

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

• https://social.msdn.microsoft.com/Forums/en-US/fd43d184-0503-4d4a-850c-999ca58e1444/creating-generic-t-with-new-constraint-that-has-parameters?forum=csharplanguage

• http://www.gamedev.net/topic/577668-c-new-constraint--is-it-possible-to-add-parameters/

在此先感谢！

Answer 1

子类。如果你不介意使用反射，你可以移动到Parse抽象类型是这样的：

public static TEntityId Parse(string val) { 
    var constr = typeof(TEntityId).GetConstructor(
     // Since the constructor is private, you need binding flags 
     BindingFlags.Instance | BindingFlags.NonPublic 
    , null 
    , new[]{ typeof(string) } 
    , null); 
    if (constr == null) { 
     throw new InvalidOperationException("No constructor"); 
    } 
    return (TEntityId)constr.Invoke(new object[] {val}); 
} 

Demo.

Answer 2

不，你不能写一个模板约束，如new(string)而不是简单的new()。你必须利用反射来得到它的工作：

public abstract class EntityId<TEntityId> 
    where TEntityId : EntityId<TEntityId> 
{ 
    private readonly System.Guid value; 

    protected EntityId(string value) 
    { 
     this.value = System.Guid.Parse(value); 
    } 

    protected EntityId() 
    { 
     this.value = System.Guid.NewGuid(); 
    } 

    public static TEntityId Parse(string value) 
    { 
     return (TEntityId)Activator.CreateInstance(typeof(TEntityId), new object[] { value }); 
    } 
} 

假设你可以构造（而不是它目前正在私人）访问。注意约束where TEntityId : EntityId<TEntityId> - 这将确保我们只返回的EntityId

Answer 3

如何使value是一个私人可变字段/属性并实际从Parse方法中设置它？

（从EntityId除去简单奇怪的是反复出现的泛型参数）

public class SimpleAnimalEntityId : EntityId 
{ 
    // Implicit parameterless constructor. 
} 

public class ParametrizedAnimalEntityId : EntityId 
{ 
    // Parametrized constructor only. 
    public ParametrizedAnimalEntityId(int ignored) 
    { 
    } 
} 

public abstract class EntityId 
{ 
    // Simple scenario: derived type has a parameterless constructor. 
    public static TEntity Parse<TEntity>(string value) 
     where TEntity : EntityId, new() 
    { 
     Guid id = Guid.Parse(value); 

     return new TEntity { value = id }; 
    } 

    // Advanced scenario: derived type constructor needs parameters injected. 
    public static TEntity Parse<TEntity>(string value, Func<TEntity> constructor) 
     where TEntity : EntityId 
    { 
     Guid id = Guid.Parse(value); 
     TEntity entity = constructor(); 

     entity.value = id; 

     return entity; 
    } 

    private Guid value; 

    protected EntityId() 
    { 
     value = Guid.NewGuid(); 
    } 
} 

现在你可以从你的Parse方法处理任何构造函数：

string id = Guid.NewGuid().ToString(); 
SimpleAnimalEntityId simple = EntityId.Parse<SimpleAnimalEntityId>(id); 
ParametrizedAnimalEntityId parametrized = EntityId.Parse(id,() => new ParametrizedAnimalEntityId(42));