Question: I want to specify required default constructrion options for my T:

```
  public interface IParameter<T>  /* where T : T(string) */ { 
     T Value { get; set; }
  }

```

so I would be able to construct it from given string if passible like this:

```
Value  = "bla";

```

or at least like this:

```
Value = new T("bla");

```

So how to specify in C# generics such T that is constructible from string?

Answer: 
Unfortunately, C# does not offer arbitrary constructor signature restrictions for generic parameters. Only [a restricted number of constraints are supported](https://msdn.microsoft.com/en-us/library/d5x73970.aspx), the closest one of which is the [`new` constraint](https://msdn.microsoft.com/en-us/library/sd2w2ew5.aspx). However, it serves only for enforcing a parameterless constructor.

You can, however, work around this drawback by working with a factory object that takes a `string` and returns a `T`. First, define an interface for such factory objects:

```
public interface IFactory<T>
{
    T Create(string str);
}

```

Subsequently, you can use that factory type in your interface:

```
public interface IParameter<TFactory, T>
    where TFactory : IFactory<T>
{ 
    T Value { get; set; }
}

```

If you want to be able to instantiate the factories at will, you can require them to have a parameterless constructor:

```
public interface IParameter<TFactory, T>
    where TFactory : new(), IFactory<T>
{ 
    T Value { get; set; }
}

```

Then, you could use a generic method to instantiate a `T` based on a `string`, e.g. as an extension method for your interface:

```
public static class ParameterUtilities
{
    public static void AssignValue<TFactory, T>(this IParameter<TFactory, T> prm, string str)
        where TFactory : new(), IFactory<T>
    {
        var factory = new TFactory();
        prm.Value = factory.Create(str);
    }
}

```

As an example of how to use this, let's assume the variable `myPrm` is an instance of that implements your `IParameter` interface with appropriate type arguments. You can then invoke something like this:

```
myPrm.AssignValue("Hello, World!");

```
Unfortunately, that constraint is not legal. Only the parameterless constructor constraint is allowed:

```
where T : new()

```