параметров - формальные параметры c#




Как использовать необязательные параметры в C#? (13)

Привет, дополнительный мир

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

using System;
using System.Runtime.InteropServices;
using System.Reflection;

namespace ConsoleApplication1
{
    class Class1
    {
        public static void sayHelloTo(
            [Optional,
            DefaultParameterValue("world")] string whom)
        {
            Console.WriteLine("Hello " + whom);
        }

        [STAThread]
        static void Main(string[] args)
        {
            MethodInfo mi = typeof(Class1).GetMethod("sayHelloTo");
            mi.Invoke(null, new Object[] { Missing.Value });
        }
    }
}

Примечание. Этот вопрос задавали в то время, когда C # еще не поддерживал необязательные параметры (т.е. до C # 4).

Мы создаем веб-API, который программно генерируется из класса C #. Класс имеет метод GetFooBar(int a, int b) и API имеет метод GetFooBar принимает параметры запроса, такие как &a=foo &b=bar .

Классы должны поддерживать необязательные параметры, которые не поддерживаются на языке C #. Какой лучший подход?


В C # я обычно использовал несколько форм метода:

void GetFooBar(int a) { int defaultBValue;  GetFooBar(a, defaultBValue); }
void GetFooBar(int a, int b)
{
 // whatever here
}

ОБНОВЛЕНИЕ: Это упомянутое выше было способом, которым я использовал значения по умолчанию с C # 2.0. Проекты, над которыми я сейчас работаю, используют C # 4.0, который теперь напрямую поддерживает дополнительные параметры. Вот пример, который я использовал только в своем собственном коде:

public EDIDocument ApplyEDIEnvelop(EDIVanInfo sender, 
                                   EDIVanInfo receiver, 
                                   EDIDocumentInfo info,
                                   EDIDocumentType type 
                                     = new EDIDocumentType(EDIDocTypes.X12_814),
                                   bool Production = false)
{
   // My code is here
}

Вы можете использовать необязательные параметры в C # 4.0 без каких-либо проблем. Если у нас есть такой метод, как:

int MyMetod(int param1, int param2, int param3=10, int param4=20){....}

когда вы вызываете метод, вы можете пропустить такие параметры:

int variab = MyMethod(param3:50; param1:10);

C # 4.0 реализует функцию под названием «именованные параметры», вы можете передавать параметры по их именам, и, конечно же, вы можете передавать параметры в любом порядке, который вам нужен :)


Вы можете использовать перегрузку метода ...

GetFooBar()
GetFooBar(int a)
GetFooBar(int a, int b)

Это зависит от сигнатур метода, в приведенном примере отсутствует метод «int b», поскольку он будет иметь такую ​​же подпись, что и метод «int a».

Вы можете использовать типы Nullable ...

GetFooBar(int? a, int? b)

Затем вы можете проверить, используя a.HasValue, чтобы узнать, был ли установлен параметр.

Другой вариант - использовать параметр «params».

GetFooBar(params object[] args)

Если бы вы захотели пойти с именованными параметрами, нужно было бы создать тип для их обработки, хотя я думаю, что для веб-приложений уже есть что-то подобное.


Вы можете попробовать это тоже
Тип 1
public void YourMethod(int a=0, int b = 0) { //some code }


Тип 2
public void YourMethod(int? a, int? b) { //some code }


Другой вариант - использовать ключевое слово params

public void DoSomething(params object[] theObjects)
{
  foreach(object o in theObjects)
  {
    // Something with the Objects…
  }
}

Называется ...

DoSomething(this, that, theOther);

Немного поздно на вечеринку, но я искал ответ на этот вопрос и, в конечном счете, выяснил еще один способ сделать это. Объявить типы данных для дополнительных аргументов вашего веб-метода как типа XmlNode. Если опционный аргумент arg опущен, он будет установлен в null, и если он присутствует, вы можете получить значение строки, вызывая arg.Value, т. Е.

[WebMethod]
public string Foo(string arg1, XmlNode optarg2)
{
    string arg2 = "";
    if (optarg2 != null)
    {
        arg2 = optarg2.Value;
    }
    ... etc
}

Что же касается этого подхода, то это хорошая домашняя страница .NET, для которой ws по-прежнему показывает список аргументов (хотя вы теряете удобные текстовые поля для тестирования).


Необязательные параметры - это ничего, кроме параметров по умолчанию! Я предлагаю вам указать оба параметра по умолчанию. GetFooBar (int a = 0, int b = 0), если у вас нет перегруженного метода, приведет к a = 0, b = 0, если вы не пройдете никаких значений, если вы пройдете 1 значение, это приведет к , переданное значение для a, 0, и если вы пройдете 2 значения, то 1-й будет назначен a, а второй - b.

Надеюсь это ответит на твой вопрос.


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


У меня есть веб-сервис для записи, который принимает 7 параметров. Каждый из них является необязательным атрибутом запроса для оператора sql, заверенного этим веб-сервисом. Поэтому приходят в голову два обходных пути к необязательным параметрам ... оба довольно бедные:

method1 (param1, param2, param 3, param 4, param 5, param 6, param7) method1 (param1, param2, param3, param 4, param5, param 6) метод 1 (param1, param2, param3, param4, param5, param7 ) ... начните видеть картинку. Этот путь - безумие. Путь слишком много комбинаций.

Теперь для более простого способа, который выглядит неудобно, но должен работать: method1 (param1, bool useParam1, param2, bool useParam2 и т. Д.)

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

Это взломать, но это сработает.


Элегантный и простой способ, который позволяет опускать любые параметры в любом положении , используя типы с нулевым значением, выглядит следующим образом:

public void PrintValues(int? a = null, int? b = null, float? c = null, string s = "")
{
    if(a.HasValue)
        Console.Write(a);
    else
        Console.Write("-");

    if(b.HasValue)
        Console.Write(b);
    else
        Console.Write("-");

    if(c.HasValue)
        Console.Write(c);
    else
        Console.Write("-");

    if(string.IsNullOrEmpty(s)) // Different check for strings
        Console.Write(s);
    else
        Console.Write("-");
}

Строки уже имеют типы с нулевым значением, поэтому они не нужны ? ,

После того, как у вас есть этот метод, действуют все следующие вызовы:

PrintValues (1, 2, 2.2f);
PrintValues (1, c: 1.2f);
PrintValues(b:100);
PrintValues (c: 1.2f, s: "hello");
PrintValues();

Когда вы определяете метод таким образом, у вас есть свобода устанавливать только нужные вам параметры, называя их. Дополнительную информацию о названных и дополнительных параметрах см. В следующей ссылке:

Именованные и необязательные аргументы (Руководство по программированию на C #) @ MSDN


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


необязательные параметры для методов. если вам нужны дополнительные аргументы для класса, и вы:

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

    class myClass
    {
        public myClass(int myInt = 1, string myString =
                               "wow, this is cool: i can have a default string")
        {
            // do something here if needed
        }
    }
    
  • используя версии c #, предшествующие c # 4.0: вы должны использовать цепочку конструкторов (используя это: это ключевое слово), где более простые конструкторы приводят к «мастер-конструктору». пример:

    class myClass
    {
        public myClass()
        {
        // this is the default constructor
        }
    
        public myClass(int myInt)
            : this(myInt, "whatever")
        {
            // do something here if needed
        }
        public myClass(string myString)
            : this(0, myString)
        {
            // do something here if needed
        }
        public myClass(int myInt, string myString)
        {
            // do something here if needed - this is the master constructor
        }
    }
    




optional-parameters