Передача нулевых аргументов методам С#

Есть ли способ передать нулевые аргументы методам С# (что-то вроде нулевых аргументов в С++)?

Например:

Можно ли перевести следующую функцию С++ в метод С#:

private void Example(int* arg1, int* arg2)
{
    if(arg1 == null)
    {
        //do something
    }
    if(arg2 == null)
    {
        //do something else
    }
}

Ответ 1

Да. В .NET существуют два типа типов: ссылочные типы и типы значений.

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

Типы значений (например, int) по умолчанию не имеют понятия null. Тем не менее, для них есть оболочка Nullable. Это позволяет вам инкапсулировать тип значения, который не является нулевым, и содержать нулевую информацию.

Использование немного отличается.

// Both of these types mean the same thing, the ? is just C# shorthand.
private void Example(int? arg1, Nullable<int> arg2)
{
    if (arg1.HasValue)
        DoSomething();

    arg1 = null; // Valid.
    arg1 = 123;  // Also valid.

    DoSomethingWithInt(arg1); // NOT valid!
    DoSomethingWithInt(arg1.Value); // Valid.
}

Ответ 2

Я думаю, что ближайший эквивалент С# к int* будет ref int?. Поскольку ref int? позволяет вызываемому методу передать значение обратно вызывающему методу.

int*

Может быть null.
Может быть непустым и указывать на целочисленное значение.
Если не null, значение можно изменить, и это изменение распространяется на вызывающего.
Настройка на null не возвращается обратно вызывающему.

ref int?

Может быть null.
Может иметь целочисленное значение.
Значение всегда можно изменить, и изменение распространяется на вызывающего.
Значение может быть установлено равным нулю, и это изменение также будет распространяться на вызывающего.

Ответ 3

Для этого можно использовать NullableValueTypes (например, int?). Код будет выглядеть следующим образом:

private void Example(int? arg1, int? arg2)
{
    if(!arg1.HasValue)
    {
        //do something
    }
    if(!arg2.HasValue)
    {
        //do something else
    }
}

Ответ 4

Из С# 2.0:

private void Example(int? arg1, int? arg2)
{
    if(arg1 == null)
    {
        //do something
    }
    if(arg2 == null)
    {
        //do something else
    }
}

Ответ 5

Начиная с С# 2.0, вы можете использовать nullable generic type Nullable, а в С# - сокращенное обозначение типа, за которым следует?

например.

private void Example(int? arg1, int? arg2)
{
    if(arg1 == null)
    {
        //do something
    }
    if(arg2 == null)
    {
        //do something else
    }
}

Ответ 6

Вопрос OP уже хорошо ответил, но заголовок достаточно широк, что, по-моему, он выигрывает от следующего праймера:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace consolePlay
{
    class Program
    {
        static void Main(string[] args)
        {
            Program.test(new DateTime());
            Program.test(null);
            //Program.test(); // <<< Error.  
            // "No overload for method 'test' takes 0 arguments"  
            // So don't mistake nullable to be optional.

            Console.WriteLine("Done.  Return to quit");
            Console.Read();
        }

        static public void test(DateTime? dteIn)
        {
            Console.WriteLine("#" + dteIn.ToString() + "#");
        }
    }
}

выход:

#1/1/0001 12:00:00 AM#
##
Done.  Return to quit

Ответ 7

Вы можете использовать 2 способа: int? или Nullable, оба имеют одинаковое поведение. Вы можете сделать микс без проблем, но лучше выбрать один, чтобы сделать код чистым.

Вариант 1 (с?):

private void Example(int? arg1, int? arg2)
    {
        if (arg1.HasValue)
        {
            //do something
        }
        if (arg1.HasValue)
        {
            //do something else
        }
    }

Вариант 2 (с Nullable):

private void Example(Nullable<int> arg1, Nullable<int> arg2)
    {
        if (arg1.HasValue)
        {
            //do something
        }
        if (arg1.HasValue)
        {
            //do something else
        }
    }

Из С# 4.0 появляется новый способ сделать то же самое с большей гибкостью, в этом случае фреймворк предлагает дополнительные параметры со значениями по умолчанию, таким образом вы можете установить значение по умолчанию, если метод вызывается без всех параметров.

Вариант 3 (со значениями по умолчанию)

private void Example(int arg1 = 0, int arg2 = 1)
    {
        //do something else
    }