Cum poți folosi parametri opționali in C#?

Sunt surprins că nimeni nu a menționat C# 4.0 opțional parametrii care funcționează ca aceasta:

public void SomeMethod(int a, int b = 0)
{
   //some code
}

Edit: știu că în momentul în care întrebarea a fost întrebat, C# 4.0 n't există. Dar această întrebare încă pe locul #1 in Google pentru "C# argumente opționale" așa că am crezut că - acest răspuns demn de a fi aici. Îmi pare rău.

O altă opțiune este de a utiliza cuvinte cheie params

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

Numit ca...

DoSomething(this, that, theOther);

În C#, în mod normal, aș folosi mai multe forme de metoda:

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

ACTUALIZARE: Acest menționat mai sus a FOST modul în care am făcut valorile implicite cu C# 2.0. Proiectele I'm de lucru pe acum folosesc C# 4.0, care acum susține în mod direct parametrii opționali. Aici este un exemplu, am folosit doar în propriul meu cod:

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

De pe acest site:

http://www.tek-tips.com/viewthread.cfm?qid=1500861&page=1

C# nu permite utilizarea [Opțional] atribut (de la VB, deși nu este funcțional în C#). Astfel încât să puteți avea o metoda de genul asta:

using System.Runtime.InteropServices;
public void Foo(int a, int b, [Optional] int c)
{
  ...
}

În API-ul nostru înveliș, putem detecta parametri opționali (ParameterInfo p.IsOptional) și setați o valoare implicită. Scopul este de a marca parametri ca opțional fără a recurge la "făcăturile" ca având "opțional" în numele parametrului.

Ai putea folosi metoda supraîncărcarea...

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

Aceasta depinde de metoda de semnături, am dat exemplu, lipsește "int b" singura metodă pentru că ar avea aceeași semnătură ca "int o" metodă.

Ai putea folosi Null tipuri...

GetFooBar(int? o, int? b)

Apoi veți putea verifica, folosind-o.HasValue, pentru a vedea dacă un parametru a fost stabilit.

O altă opțiune ar fi să utilizați un 'params' parametru.

GetFooBar(params object[] args)

Dacă ai vrut să mergi cu nume parametrii care ar avea nevoie pentru a crea un tip să se ocupe de ei, deși cred că există deja ceva de genul asta pentru aplicații web.

Puteți utiliza parametrii opționali in C# 4.0 fără griji. Dacă avem o metodă cum ar fi:

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

atunci când apelați metoda, puteți sări peste parametri, cum ar fi aceasta:

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

C# 4.0 pune în aplicare o caracteristică numit "parametri numit", puteți trece de fapt parametrii de numele lor, și, bineînțeles, puteți trece parametrii in orice ordine vrei :)

Alo Opțional Lume

Dacă doriți runtime pentru a furniza un parametru implicit valoare, trebuie să utilizați reflecție pentru a efectua apelul. Nu la fel de frumos ca alte sugestii pentru această întrebare, dar compatibil cu 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 });
        }
    }
}

O modalitate ușoară care vă permite să omiteți parametri in orice poziție, profită de null tipuri, după cum urmează:

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("-");
}

Siruri de caractere sunt deja null tipuri, astfel încât acestea să't nevoie de ?.

Odată ce aveți această metodă, următoarele apeluri toate valabile:

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

Când definiți o metodă în acest fel aveți libertatea de a stabili doar parametrii doriți de denumire le. A se vedea link-ul următor pentru mai multe informații despre nume și parametri opționali:

Nume și Argumente Opționale (C# de Programare Ghid) @ MSDN

Sunt de acord cu stephenbayer. Dar din moment ce este un serviciu web, este mai ușor pentru utilizator de a utiliza doar o formă de webmethod, decât folosind mai multe versiuni de aceeași metodă. Cred că în această situație poate fi nul Tipuri sunt perfecte pentru parametri opționali.

public void Foo(int a, int b, int? c)
{
  if(c.HasValue)
  {
    // do something with a,b and c
  }
  else
  {
    // do something with a and b only
  }  
}

parametrii opționali sunt de metode. dacă ai nevoie de argumente opționale pentru o clasă și sunt:

• folosind c# 4.0: foloseste argumente opționale în constructorul clasei, o soluție prefer, deoarece's mai aproape de ceea ce se face cu metode, atât de ușor să vă amintiți. aici's un exemplu:

clasa myClass { publice myClass(int myInt = 1, șir myString = "wow, acest lucru este cool: nu pot avea un default string") { // facem ceva aici, dacă este necesar } }

• folosind c# versiunile anterioare de c#4.0: ar trebui să utilizați constructor înlănțuirea (folosind :acest cuvânt cheie), unde mai simplu constructori conduce la o "maestru constructor". exemplu:

clasa myClass { publice myClass() { // acest lucru este implicit constructor }

publice myClass(int myInt) : acest(myInt, "orice") { // facem ceva aici, dacă este necesar } publice myClass(string myString) : acest(0, myString) { // facem ceva aici, dacă este necesar } publice myClass(int myInt, string myString) { // facem ceva aici, dacă este necesar - aceasta este maestru constructor } }

Modul tipic în care aceasta este tratată în C# ca stephen menționat este de a supraîncărca metodă. Prin crearea mai multor versiuni de metoda cu parametri diferiți ai crea în mod eficient parametrii opționali. În formele cu mai puțini parametri ai de obicei sun formă de metoda cu toți parametrii setarea valorilor implicite în apel la această metodă.

Folosind suprasarcini sau folosind C# 4.0 sau mai sus

 private void GetVal(string sName, int sRoll)
 {
   if (sRoll > 0)
   {
    // do some work
   }
 }

 private void GetVal(string sName)
 {
    GetVal("testing", 0);
 }

Puteți suprasarcină metoda ta. O metodă conține un singur parametru GetFooBar(int a) iar cealaltă conține ambii parametri, GetFooBar(int a, int b)

Un pic cam târziu la petrecere, dar am fost în căutarea pentru răspunsul la această întrebare și, în cele din urmă a dat seama încă un alt mod de a face acest lucru. Declara tipuri de date pentru opțional args de web metodă să fie de tip XmlNode. Dacă optional arg este omis acest lucru va fi setat la nul, și dacă-l's cadou puteți obține este de valoare șir de asteptare arg.Valoare, și anume,

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

Ce's, de asemenea, decent despre această abordare este .NET generat de pagina de start pentru ws prezinta in continuare lista de argumente (deși te-ai pierde la îndemână textul de intrare cutii pentru testare).

În loc de default parametri, de ce nu a construi un dicționar de clasă din querystring a trecut .. o implementare care este aproape identic cu modul asp.net forme de lucru cu querystrings.

adică Cerere.QueryString["o"]

Acest lucru va decupla frunze de clasa din fabrica / cod șabloane.

Ai, de asemenea, s-ar putea să doriți să verificați Servicii Web cu ASP.NET. Serviciile Web sunt un api web generate automat prin atribute pe C# clase.

Pentru doar în cazul în care cineva vrea să treacă un apel invers (sau "delegare") ca un parametru opțional, se poate face în acest mod.

Optional Callback parametru:

public static bool IsOnlyOneElement(this IList lst, Action callbackOnTrue = (Action)((null)), Action callbackOnFalse = (Action)((null)))
{
    var isOnlyOne = lst.Count == 1;
    if (isOnlyOne && callbackOnTrue != null) callbackOnTrue();
    if (!isOnlyOne && callbackOnFalse != null) callbackOnFalse();
    return isOnlyOne;
}

parametrii opționali sunt nimic, dar implicit parametrii! vă sugerez să vă dau ambii parametri implicite. GetFooBar(int a=0, int b=0), dacă nu't au orice metodă supraîncărcat, va duce la o=0, b=0, dacă nu't trece orice valori,dacă treci de 1 valoare, va avea ca rezultat, a trecut de valoare pentru un, 0 și, dacă treci de 2 valori 1 va fi atribuit-o și a doua pentru b.

sper că asta îți răspunde la întrebare.

În cazul în care valorile implicite sunt't la dispoziție o modalitate de a adăuga un parametru opțional este de a utiliza .NET OptionalAttribute clasa - https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.optionalattribute?view=netframework-4.8

Exemplu de cod de mai jos:

namespace OptionalParameterWithOptionalAttribute
{
    class Program
    {
        static void Main(string[] args)
        {
            //Calling the helper method Hello only with required parameters
            Hello("Vardenis", "Pavardenis");
            //Calling the helper method Hello with required and optional parameters
            Hello("Vardenis", "Pavardenis", "Palanga");
        }
        public static void Hello(string firstName, string secondName, 
            [System.Runtime.InteropServices.OptionalAttribute] string  fromCity)
        {
            string result = firstName + " " + secondName;
            if (fromCity != null)
            {
                result += " from " + fromCity;
            }
            Console.WriteLine("Hello " + result);
        }

    }
}

Am un serviciu web pentru a scrie care are 7 parametri. Fiecare este un opțional de interogare atribuie o declarație sql înfășurat de acest serviciu web. Deci două soluții non-optional params vin în minte... ambele destul de slab:

metoda1(param1, param2, param 3, param 4, param 5, param 6, param7) metoda1(param1, param2, param3, param 4, param5, param 6) metoda 1(param1, param2, param3, param4, param5, param7)... start pentru a vedea imaginea. În acest fel se află nebunie. Prea multe combinații.

Acum, pentru un mod mai simplu care arata ciudat, dar ar trebui să funcționeze: metoda1(param1, bool useParam1, param2, bool useParam2, etc...)

Ca's un apel de metodă, valorile pentru toți parametrii sunt necesare, și se va ocupa de fiecare caz în interiorul acestuia. L's, de asemenea, clar cum să-l folosească din interfață.

L's un hack, dar se va lucra.

Am avut de a face acest lucru într-un VB.Net Web 2.0 Service. Am sfârșit prin a preciza parametrii ca siruri de caractere, apoi de a le converti la orice am nevoie. Un parametru opțional a fost specificat cu un șir gol. Nu mai curată soluție, dar a mers. Doar fii atent că te prind toate excepțiile care pot apărea.