void в дженериках C #?

У меня есть общий метод, который принимает запрос и предоставляет ответ.

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

Но мне не всегда нужен ответ на свой запрос, и я не всегда хочу передавать данные запроса, чтобы получить ответ. Я также не хочу полностью копировать и вставлять методы для внесения незначительных изменений. Я хочу сделать это:

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

Возможно ли это каким-то образом? Кажется, что конкретно использование void не работает, но я надеюсь найти что-то аналогичное.

Вы не можете использовать void, но можете использовать object: это небольшое неудобство, потому что ваши потенциальные voidфункции должны возвращаться null, но если это унифицирует ваш код, это должна быть небольшая цена.

Эта неспособность использовать voidв качестве возвращаемого типа, по крайней мере, частично ответственна за разделение между Func<...>и Action<...>семействами универсальных делегатов: если бы можно было вернуть void, все Action<X,Y,Z>стало бы просто Func<X,Y,Z,void>. К сожалению, это невозможно.

Нет, к сожалению нет. Если бы voidэто был «настоящий» тип (например, unitв F # ), жизнь была бы намного проще во многих отношениях. В частности, нам не нужны были бы Func<T>и Action<T>семьи и - просто Func<void>вместо Action, Func<T, void>вместо Action<T>и т. Д.

Это также упростило бы асинхронность - не было бы необходимости в неуниверсальном Taskтипе - у нас просто было бы Task<void>.

К сожалению, системы типа C # или .NET работают иначе ...

Вот что ты можешь сделать. Как сказал @JohnSkeet, в C # нет типа модуля, так что сделайте это самостоятельно!

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

Теперь вы всегда можете использовать Func<..., ThankYou>вместоAction<...>

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

Или используйте что-то, что уже сделано командой Rx: http://msdn.microsoft.com/en-us/library/system.reactive.unit%28v=VS.103%29.aspx

Вы можете просто использовать, Objectкак предлагали другие. Или Int32я видел какое-то применение. Использование Int32вводит «фиктивный» номер (использование 0), но, по крайней мере, вы не можете поместить в Int32ссылку какой-либо большой и экзотический объект (структуры запечатаны).

Вы также можете написать свой собственный тип "void":

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

MyVoidссылки разрешены (это не статический класс), но могут быть только null. Конструктор экземпляра является частным (и если кто-то попытается вызвать этот частный конструктор посредством отражения, ему будет выдано исключение).

Поскольку были введены кортежи значений (2017, .NET 4.7), возможно, естественно использовать структуруValueTuple (0-кортеж, неуниверсальный вариант) вместо такого MyVoid. Его экземпляр имеет ToString()возвращаемый объект "()", поэтому он выглядит как кортеж с нулем. В текущей версии C # вы не можете использовать токены ()в коде для получения экземпляра. Вместо этого вы можете использовать default(ValueTuple)или просто default(когда тип может быть определен из контекста).

Мне нравится идея Алексея Быкова выше, но ее можно немного упростить

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

Поскольку я не вижу очевидной причины, почему Nothing.AtAll не может просто дать null

Та же идея (или идея Джеппе Стига Нильсена) также отлично подходит для использования с типизированными классами.

Например, если тип используется только для описания аргументов процедуры / функции, переданной в качестве аргумента некоторому методу, и сам по себе не принимает никаких аргументов.

(Вам все равно нужно будет создать фиктивную оболочку или разрешить необязательное «Nothing». Но, IMHO, использование класса выглядит хорошо с myClass <Nothing>)

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

или

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

voidхотя и является типом, он действителен только как возвращаемый тип метода.

Это ограничение невозможно обойти void.

В настоящее время я создаю собственные запечатанные типы с помощью частного конструктора. Это лучше, чем бросать исключения в c-tor, потому что вам не нужно дойти до времени выполнения, чтобы понять, что ситуация неверна. Это немного лучше, чем возврат статического экземпляра, потому что вам не нужно выделять ни разу. Это немного лучше, чем возврат статического нуля, потому что он менее подробен на стороне вызова. Единственное, что может сделать вызывающий - дать null.

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

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