con respecto al uso de la nueva Restricción en C#

Question

Nunca uso la Restricción nueva porque el uso no es claro para mí. Aquí encontré una muestra, pero simplemente no entiendo el uso. Aquí está el código

class ItemFactory<T> where T : new() 
{ 
    public T GetNewItem() 
    { 
     return new T(); 
    } 
} 

public class ItemFactory2<T> where T : IComparable, new() 

{ 
} 

por lo que cualquiera favor hacerme entender el uso de la nueva restricción con una pequeña muestra de & fácil para su uso en el mundo real. gracias

Answer 1

Además de Darin's answer, algo como esto podría fallar porque Bar no tiene un constructor sin parámetros

class ItemFactory<T> where T : new() 
    { 
     public T GetNewItem() 
     { 
     return new T(); 
     } 
    } 

    class Foo : ItemFactory<Bar> 
    { 

    } 

    class Bar 
    { 
     public Bar(int a) 
     { 

     } 
    } 

error real es: 'Bar' must be a non-abstract type with a public parameterless constructor in order to use it as parameter 'T' in the generic type or method 'ItemFactory<T>'

La siguiente también fallará:

class ItemFactory<T> 
{ 
    public T GetNewItem() 
    { 
     return new T(); 
    } 
} 

El error real es: Cannot create an instance of the variable type 'T' because it does not have the new() constraint

Answer 2

Esta restricción requiere que el tipo genérico que se utiliza no sea abstracto y que tenga un constructor predeterminado (sin parámetros) que le permita invocarlo.

Ejemplo de trabajo:

class ItemFactory<T> where T : new() 
{ 
    public T GetNewItem() 
    { 
     return new T(); 
    } 
} 

que obviamente ahora le obligará a tener un constructor sin parámetros para el tipo que se pasa como argumento genérico:

var factory1 = new ItemFactory<Guid>(); // OK 
var factory2 = new ItemFactory<FileInfo>(); // doesn't compile because FileInfo doesn't have a default constructor 
var factory3 = new ItemFactory<Stream>(); // doesn't compile because Stream is an abstract class 

inhábiles ejemplo:

class ItemFactory<T> 
{ 
    public T GetNewItem() 
    { 
     return new T(); // error here => you cannot call the constructor because you don't know if T possess such constructor 
    } 
} 

Answer 3

La nueva restricción específica es que cualquier argumento de tipo en una declaración de clase genérica debe tener un constructor público sin parámetros.

citado del oficial website

Answer 4

Puede leer new() como si se trata de una interfaz con un constructor. Así como IComparable especifica que el tipo T tiene un método CompareTo, la nueva restricción especifica que el tipo T tiene un constructor público.

Answer 5

En su ejemplo, la restricción actúa en <T> en la declaración de clase. En el primer caso, requiere que el objeto genérico T tenga un constructor predeterminado (sin parámetros). En el segundo ejemplo, requiere que T tenga un constructor predeterminado sin parámetros y que debe implementar la interfaz IComparable.