Dela via

Tilldelningsoperatorer (C#-referens)

Tilldelningsoperatorn =tilldelar värdet för sin högra operand till en variabel, en egenskap eller ett indexerarelement som ges av dess vänstra operand. Resultatet av ett tilldelningsuttryck är det värde som tilldelats till den vänstra operanden. Typen av den högra operanden måste vara samma som typen av den vänstra operanden eller implicit konvertibel till den.

Tilldelningsoperatorn = är rätt-associativ, det vill: ett uttryck för formuläret

a = b = c

Utvärderas som

a = (b = c)

I följande exempel visas användningen av tilldelningsoperatorn med en lokal variabel, en egenskap och ett indexerarelement som dess vänstra operand:

List<double> numbers = [1.0, 2.0, 3.0];

Console.WriteLine(numbers.Capacity);
numbers.Capacity = 100;
Console.WriteLine(numbers.Capacity);
// Output:
// 4
// 100

int newFirstElement;
double originalFirstElement = numbers[0];
newFirstElement = 5;
numbers[0] = newFirstElement;
Console.WriteLine(originalFirstElement);
Console.WriteLine(numbers[0]);
// Output:
// 1
// 5

Den vänstra operanden mottar vid en tilldelning värdet från den högra operanden. När operanderna är av värdetyper kopierar tilldelningsoperationen innehållet i höger operand. När operanderna är av referenstyper kopierar tilldelningen referensen till objektet.

Den här åtgärden kallas värdetilldelning: värdet tilldelas.

Från och med C# 14 kan den vänstra sidan av en värdetilldelning innehålla ett villkorsmedlemsuttryck för null, till exempel ?. eller ?[]. Om vänster sida är null utvärderas inte uttrycket på höger sida.

referenstilldelning

Referenstilldelningen= ref gör dess vänstra operand till ett alias till den högra operanden, vilket visas i följande exempel:

void Display(double[] s) => Console.WriteLine(string.Join(" ", s));

double[] arr = { 0.0, 0.0, 0.0 };
Display(arr);

ref double arrayElement = ref arr[0];
arrayElement = 3.0;
Display(arr);

arrayElement = ref arr[arr.Length - 1];
arrayElement = 5.0;
Display(arr);
// Output:
// 0 0 0
// 3 0 0
// 3 0 5

I föregående exempel initieras den lokala referensvariabelnarrayElement som ett alias för det första matriselementet. Sedan tilldelas ref igen för att referera till det sista matriselementet. Eftersom det är ett alias uppdateras även motsvarande matriselement när du uppdaterar dess värde med en vanlig tilldelningsoperator =.

Den vänstra operanden för ref tilldelning kan vara en lokal referensvariabel, ett ref fält och en metodparameter för ref, out eller in. Båda operanderna måste vara av samma typ.

En ref tilldelning innebär att en referensvariabel har en annan referens. Den refererar inte längre till den tidigare referensen. Om du använder ref = på en ref-parameter innebär det att parametern inte längre refererar till argumentet. Alla åtgärder som ändrar objektets tillstånd efter omtilldelningen av objektet gör dessa ändringar i det nya objektet. Tänk till exempel på följande metod:

private static void RefReassignAndModify(scoped ref string s)
{
    string sLocal = "Hello";
    Console.WriteLine(sLocal);  // Output: Hello

    s = ref sLocal;
    s = "World";
    Console.WriteLine(s);  // Output: World

Följande användning visar att tilldelningen till parametern s inte visas efter metodanropet eftersom sref omtilldelades för att referera till sLocal innan strängen ändrades:

string msg = "Hi";
RefReassignAndModify(ref msg);
Console.WriteLine(msg); // Output: Hi

Sammansatt tilldelning

För en binär operator op skrivs ett sammansatt tilldelningsuttryck på följande sätt

x op= y

Motsvarar

x = x op y

Förutom att x bara utvärderas en gång.

De aritmetiska, booleska logiska och bitvis logiska operatorerna och skiftoperatorerna stöder alla sammansatt tilldelning.

Null-sammankopplingstilldelning

Du kan använda null-coalescing-tilldelningsoperatorn ??= för att tilldela värdet av sin högra operand till sin vänstra operand endast om den vänstra operandens värde är null. Mer information finns i artikeln operatorer?? och ??= .

Överlagring av operator

En användardefinierad typ kan inte överbelasta tilldelningsoperatorn. En användardefinierad typ kan dock definiera en implicit konvertering till en annan typ. På så sätt kan värdet för en användardefinierad typ tilldelas till en variabel, en egenskap eller ett indexerarelement av en annan typ. Mer information finns i Användardefinierade konverteringsoperatorer.

Om en användardefinierad typ överbelastar en binär operator är operatorn op, om den op= finns, också implicit överbelastad. Från och med C# 14 kan en användardefinierad typ uttryckligen överbelasta de sammansatta tilldelningsoperatorerna (op=) för att tillhandahålla en effektivare implementering. Vanligtvis överbelastar en typ dessa operatorer eftersom värdet kan uppdateras på plats, i stället för att allokera en ny instans för att lagra resultatet av den binära åtgärden. Om en typ inte ger någon explicit överlagring genererar kompilatorn den implicita överbelastningen.

Språkspecifikation för C#

Mer information finns i avsnittet Tilldelningsoperatorer i C#-språkspecifikationen och funktionsspecifikationen för användardefinierade sammansatta tilldelningar .

Se även