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: 
You can't, because in generic type constraints you can't say that the type must have a specific constructor (only that it must have a parameterless constructor) nor say that it must have specific methods/operators.

BUT

```
public interface IFromString<T>
{
    void DeserializeFromString(string str);
}

public class MyType : IFromString<MyType>
{
    public int Value;

    public void DeserializeFromString(string str)
    {
        Value = int.Parse(str);
    }
}

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

public class Parameter<T> : IParameter<T> where T : IFromString<T>, new()
{
    T Value { get; set; }

    public void Load(string str)
    {
        Value = new T();
        Value.DeserializeFromString(str);
    }
}

```

A classical example... an interface that says that a type can be deserialized from (something) (xml very often :-) )

Use:

```
Parameter<MyType> parameter = new Parameter<MyType>();
parameter.Load(someStringLoadedFromSomewhere);

```
You can't specify a constructor in an interface. Depending on your requirements you could use an abstract class:

Pseudo code as not at machine with VS:

```
public abstract class BaseParameter<T>
{ 
    public abstract void BaseParameter(string something);

    T Value { get; set; }
}

```