nulo en genéricos de C #?

Tengo un método genérico que toma una solicitud y proporciona una respuesta.

public Tres DoSomething<Tres, Treq>(Tres response, Treq request)
{/*stuff*/}

Pero no siempre quiero una respuesta para mi solicitud, y no siempre quiero alimentar los datos de la solicitud para obtener una respuesta. Tampoco quiero tener que copiar y pegar métodos en su totalidad para realizar cambios menores. Lo que quiero es poder hacer esto:

public Tre DoSomething<Tres>(Tres response)
{
    return DoSomething<Tres, void>(response, null);
}

¿Es esto factible de alguna manera? Parece que usar void específicamente no funciona, pero espero encontrar algo análogo.

No puede usar void, pero puede usar object: es un pequeño inconveniente porque sus posibles voidfunciones deben regresar null, pero si unifica su código, debería ser un pequeño precio a pagar.

Esta incapacidad para usar voidcomo tipo de retorno es al menos parcialmente responsable de una división entre las familias Func<...>y Action<...>de los delegados genéricos: si hubiera sido posible regresar void, todo Action<X,Y,Z>sería simple Func<X,Y,Z,void>. Desafortunadamente, esto no es posible.

No, desafortunadamente no. Si voidfuera un tipo "real" (como uniten F # , por ejemplo) la vida sería mucho más simple en muchos sentidos. En particular, no necesitaríamos tanto a las familias Func<T>como a las Action<T>familias, simplemente habría en Func<void>lugar de Action, en Func<T, void>lugar de, Action<T>etc.

También simplificaría el async (no habría necesidad de un tipo no genérico Tasken absoluto), simplemente lo haríamos Task<void>.

Desafortunadamente, esa no es la forma en que funcionan los sistemas de tipo C # o .NET ...

Esto es lo que puede hacer. Como dijo @JohnSkeet, no hay un tipo de unidad en C #, ¡así que hágalo usted mismo!

public sealed class ThankYou {
   private ThankYou() { }
   private readonly static ThankYou bye = new ThankYou();
   public static ThankYou Bye { get { return bye; } }
}

Ahora siempre puedes usar en Func<..., ThankYou>lugar deAction<...>

public ThankYou MethodWithNoResult() {
   /* do things */
   return ThankYou.Bye;
}

O use algo que ya haya hecho el equipo de Rx: http://msdn.microsoft.com/en-us/library/system.reactive.unit%28v=VS.103%29.aspx

Simplemente puede usarlo Objectcomo otros han sugerido. O Int32que he visto algún uso. El uso Int32introduce un número "ficticio" (uso 0), pero al menos no puede poner ningún objeto grande y exótico en una Int32referencia (las estructuras están selladas).

También puede escribir su propio tipo "vacío":

public sealed class MyVoid
{
  MyVoid()
  {
    throw new InvalidOperationException("Don't instantiate MyVoid.");
  }
}

MyVoidSe permiten referencias (no es una clase estática) pero solo pueden ser null. El constructor de la instancia es privado (y si alguien intenta llamar a este constructor privado mediante la reflexión, se le lanzará una excepción).

Dado que se introdujeron las tuplas de valor (2017, .NET 4.7), tal vez sea natural usar la estructuraValueTuple (la tupla 0, la variante no genérica) en lugar de tal MyVoid. Su instancia tiene un ToString()que devuelve "()", por lo que parece una tupla cero. A partir de la versión actual de C #, no puede usar los tokens ()en el código para obtener una instancia. En su lugar, puede usar default(ValueTuple)o solo default(cuando el tipo se puede inferir del contexto).

Me gusta la idea de Aleksey Bykov anterior, pero podría simplificarse un poco

public sealed class Nothing {
    public static Nothing AtAll { get { return null; } }
}

Como no veo ninguna razón aparente por la cual Nothing.AtAll no podría simplemente dar null

La misma idea (o la de Jeppe Stig Nielsen) también es excelente para usar con clases escritas.

Por ejemplo, si el tipo solo se usa para describir los argumentos de un procedimiento / función que se pasa como argumento a algún método, y él mismo no toma ningún argumento.

(Todavía necesitará hacer una envoltura ficticia o permitir un "Nada" opcional. Pero en mi humilde opinión, el uso de la clase se ve bien con myClass <Nothing>)

void myProcWithNoArguments(Nothing Dummy){
     myProcWithNoArguments(){
}

o

void myProcWithNoArguments(Nothing Dummy=null){
    ...
}

void, aunque es un tipo, solo es válido como un tipo de retorno de un método.

No hay forma de evitar esta limitación de void.

Lo que hago actualmente es crear tipos sellados personalizados con constructor privado. Esto es mejor que lanzar excepciones en el c-tor porque no tiene que llegar hasta el tiempo de ejecución para darse cuenta de que la situación es incorrecta. Es sutilmente mejor que devolver una instancia estática porque no tiene que asignar ni una sola vez. Es sutilmente mejor que devolver un valor nulo estático porque es menos detallado en el lado de la llamada. Lo único que puede hacer la persona que llama es dar un valor nulo.

public sealed class Void {
    private Void() { }
}

public sealed class None {
    private None() { }
}