C# Language
operatörer

Introduktion

Syntax

• public static OperandType operator operatorSymbol (OperandType operand1)
• public static OperandType operator operatorSymbol (OperandType operand1, OperandType2 operand2)

parametrar

Anmärkningar

Överbelastbara operatörer

C # tillåter användardefinierade typer att överbelasta operatörer genom att definiera statiska medlemsfunktioner med operator nyckelord.
Följande exempel illustrerar en implementering av + -operatören.

Om vi har en Complex klass som representerar ett komplext nummer:

public struct Complex
{
    public double Real { get; set; }
    public double Imaginary { get; set; }
}

Och vi vill lägga till alternativet att använda + -operatören för den här klassen. dvs:

Complex a = new Complex() { Real = 1, Imaginary = 2 };
Complex b = new Complex() { Real = 4, Imaginary = 8 };
Complex c = a + b;

Vi kommer att behöva överbelasta + operatör för klassen. Detta görs med hjälp av en statisk funktion och operator nyckelord:

public static Complex operator +(Complex c1, Complex c2)
{
   return new Complex 
   { 
       Real = c1.Real + c2.Real,
       Imaginary = c1.Imaginary + c2.Imaginary 
   };
}

Operatörer som + , - , * , / kan alla vara överbelastade. Detta inkluderar även operatörer som inte returnerar samma typ (till exempel == och != Kan överbelastas, trots att booleanerna återkommer). Regeln nedan för par tillämpas också här.

Jämförelseoperatörer måste överbelastas i par (t.ex. om < är överbelastad, > måste också överbelastas).

En fullständig lista över överbelastbara operatörer (såväl som icke överbelastbara operatörer och begränsningarna för vissa överbelastbara operatörer) kan ses på MSDN - Overloadable Operators (C # Programmeringshandbok) .

public class Cartesian
{
    public int X { get; }
    public int Y { get; }
}   

public static class Polar
{
    public static bool operator is(Cartesian c, out double R, out double Theta)
    {
        R = Math.Sqrt(c.X*c.X + c.Y*c.Y);
        Theta = Math.Atan2(c.Y, c.X);
        return c.X != 0 || c.Y != 0;
    }
}

var c = Cartesian(3, 4);
if (c is Polar(var R, *))
{
    Console.WriteLine(R);
}

Relationsoperatörer

jämlikar

Kontrollerar om de medföljande operanderna (argument) är lika

"a" == "b"     // Returns false.
"a" == "a"     // Returns true.
1 == 0         // Returns false.
1 == 1         // Returns true.
false == true  // Returns false.
false == false // Returns true.

Till skillnad från Java arbetar operatören för jämställdhetsjämförelse naturligt med sträng.

Jämställdhetsjämförelseoperatören kommer att arbeta med operander av olika typer om det finns en implicit roll från det ena till det andra. Om det inte finns någon lämplig implicit roll, kan du ringa en uttrycklig roll eller använda en metod för att konvertera till en kompatibel typ.

1 == 1.0              // Returns true because there is an implicit cast from int to double.
new Object() == 1.0   // Will not compile.
MyStruct.AsInt() == 1 // Calls AsInt() on MyStruct and compares the resulting int with 1.

Till skillnad från Visual Basic.NET är operatören för jämställdhetsjämförelse inte densamma som jämställdhetsuppdragsoperatören.

var x = new Object();
var y = new Object();
x == y // Returns false, the operands (objects in this case) have different references.
x == x // Returns true, both operands have the same reference.

^{Förväxlas inte med uppdragsoperatören ( = ).}

För värdetyper returnerar operatören true om båda operanderna har samma värde.
För referenstyper returnerar operatören true om båda operanderna är lika med referens (inte värde). Ett undantag är att strängobjekt jämförs med värdejämlikhet.

Inte lika

Kontrollerar om de medföljande operanderna inte är lika.

"a" != "b"     // Returns true.
"a" != "a"     // Returns false.
1 != 0         // Returns true.
1 != 1         // Returns false.
false != true  // Returns true.
false != false // Returns false.

var x = new Object();
var y = new Object();
x != y // Returns true, the operands have different references.
x != x // Returns false, both operands have the same reference.

Denna operatör returnerar effektivt det motsatta resultatet till det för lika ( == ) operatören

Större än

Kontrollerar om den första operanden är större än den andra operanden.

3 > 5    //Returns false.
1 > 0    //Returns true.
2 > 2    //Return false.

var x = 10;
var y = 15;
x > y    //Returns false.
y > x    //Returns true.

Mindre än

Kontrollerar om den första operanden är mindre än den andra operanden.

2 < 4     //Returns true.
1 < -3    //Returns false.
2 < 2     //Return false.

var x = 12;
var y = 22;
x < y    //Returns true.
y < x    //Returns false.

Större än lika med

Kontrollerar om den första operanden är större än lika med den andra operanden.

7 >= 8    //Returns false.
0 >= 0    //Returns true.

Mindre än lika med

Kontrollerar om den första operanden är mindre än lika med den andra operanden.

2 <= 4    //Returns true.
1 <= -3    //Returns false.
1 <= 1     //Returns true. 

Kortslutningsoperatörer

Per definition utvärderar de kortslutna booleska operatörerna endast den andra operanden om den första operanden inte kan bestämma det totala resultatet av uttrycket.

Det betyder att om du använder && operator som firstCondition && secondCondition kommer den att utvärdera secondCondition endast när firstCondition är sant och ofcource kommer det totala resultatet att vara sant endast om både firstOperand och secondOperand utvärderas till true. Detta är användbart i många scenarier, tänk dig till exempel att du vill kontrollera medan din lista har mer än tre element men du måste också kontrollera om listan har initierats för att inte komma in i NullReferenceException . Du kan uppnå detta enligt nedan:

bool hasMoreThanThreeElements = myList != null && mList.Count > 3;

mList.Count> 3 kommer inte att kontrolleras förrän myList! = null uppfylls.

Logiskt OCH

&& är den kortslutna motsvarigheten till den booleska AND ( & ) -operatörens standard.

var x = true;
var y = false;

x && x // Returns true.
x && y // Returns false (y is evaluated).
y && x // Returns false (x is not evaluated).
y && y // Returns false (right y is not evaluated).

Logiskt ELLER

|| är kortslutnings motsvarighet standard Boolean OR ( | ) operatör.

var x = true;
var y = false;

x || x // Returns true (right x is not evaluated).
x || y // Returns true (y is not evaluated).
y || x // Returns true (x and y are evaluated).
y || y // Returns false (y and y are evaluated).

Exempel på användning

if(object != null && object.Property)
// object.Property is never accessed if object is null, because of the short circuit.
    Action1();
else
    Action2();

storlek av

Returnerar en int håller storleken på en typ ^* i byte.

sizeof(bool)    // Returns 1.
sizeof(byte)    // Returns 1.
sizeof(sbyte)   // Returns 1.
sizeof(char)    // Returns 2.
sizeof(short)   // Returns 2.
sizeof(ushort)  // Returns 2.
sizeof(int)     // Returns 4.
sizeof(uint)    // Returns 4.
sizeof(float)   // Returns 4.
sizeof(long)    // Returns 8.
sizeof(ulong)   // Returns 8.
sizeof(double)  // Returns 8.
sizeof(decimal) // Returns 16.

^{* Stöder endast vissa primitiva typer i säkert sammanhang.}

I ett osäkert sammanhang kan sizeof användas för att returnera storleken på andra primitiva typer och strukturer.

public struct CustomType
{
    public int value;
}

static void Main()
{
    unsafe
    {
        Console.WriteLine(sizeof(CustomType)); // outputs: 4
    }
}

Överbelastning av jämställdhetsoperatörer

Att överbelasta bara jämställdhetsoperatörer räcker inte. Under olika omständigheter kan allt följande kallas:

1. object.Equals and object.GetHashCode
2. IEquatable<T>.Equals (valfritt, gör det möjligt att undvika boxning)
3. operator == och operator != (valfritt, tillåter användning av operatörer)

Vid åsidosättande av Equals måste GetHashCode också åsidosättas. Vid implementering av Equals finns det många speciella fall: jämföra med objekt av en annan typ, jämföra med jag själv etc.

När INTE åsidosatt Equals metoden och == operatören uppför sig annorlunda för klasser och strukturer. För klasser jämförs bara referenser, och för strukturer jämförs värden på egenskaper via reflektion vad som kan påverka prestanda negativt. == kan inte användas för att jämföra strukturer såvida det inte åsidosätts.

Generellt måste jämställdhetsarbete följa följande regler:

• Får inte kasta undantag .
• Reflexivitet: A alltid lika med A (kanske inte sant för NULL värden i vissa system).
• Transitvity: om A lika med B , och B lika med C , så är A lika med C
• Om A lika med B , har A och B lika hashkoder.
• Arvsträdets oberoende: om B och C är fall av Class2 ärvts från Class1 : Class1.Equals(A,B) måste alltid returnera samma värde som samtalet till Class2.Equals(A,B) .

class Student : IEquatable<Student>
{
    public string Name { get; set; } = "";

    public bool Equals(Student other)
    {
        if (ReferenceEquals(other, null)) return false;
        if (ReferenceEquals(other, this)) return true;
        return string.Equals(Name, other.Name);
    }

    public override bool Equals(object obj)
    {
        if (ReferenceEquals(null, obj)) return false;
        if (ReferenceEquals(this, obj)) return true;

        return Equals(obj as Student);
    }

    public override int GetHashCode()
    {
        return Name?.GetHashCode() ?? 0;
    }

    public static bool operator ==(Student left, Student right)
    {
        return Equals(left, right);
    }

    public static bool operator !=(Student left, Student right)
    {
        return !Equals(left, right);
    }
}

Klassmedlemoperatörer: medlemsåtkomst

var now = DateTime.UtcNow;
//accesses member of a class.  In this case the UtcNow property.

Klassmedlemoperatörer: Null Villkorlig medlemstillträde

var zipcode = myEmployee?.Address?.ZipCode;
//returns null if the left operand is null.  
//the above is the equivalent of:
var zipcode = (string)null;
if (myEmployee != null && myEmployee.Address != null)
    zipcode = myEmployee.Address.ZipCode;

Klassmedlemoperatörer: Funktionsinbjudan

var age = GetAge(dateOfBirth);
//the above calls the function GetAge passing parameter dateOfBirth.

Klassmedlemoperatörer: Aggregat objektindexering

var letters = "letters".ToCharArray();
char letter = letters[1];
Console.WriteLine("Second Letter is {0}",letter);
//in the above example we take the second character from the array
//by calling letters[1]
//NB: Array Indexing starts at 0; i.e. the first letter would be given by letters[0].

Klassmedlemoperatörer: Noll Villkorlig indexering

var letters = null;
char? letter = letters?[1];
Console.WriteLine("Second Letter is {0}",letter);
//in the above example  rather than throwing an error because letters is null
//letter is assigned the value null

"Exklusiv eller" operatör

Operatören för en "exklusiv eller" (för kort XOR) är: ^

Denna operatör returnerar sant när en, men bara en, av de medföljande bollarna är sanna.

true ^ false   // Returns true
false ^ true   // Returns true
false ^ false  // Returns false
true ^ true    // Returns false

Bitskiftande operatörer

Skiftoperatörerna tillåter programmerare att justera ett heltal genom att flytta alla dess bitar till vänster eller höger. Följande diagram visar påverkan av att flytta ett värde till vänster med en siffra.

Vänster Shift

uint value = 15;              // 00001111
 
uint doubled = value << 1;    // Result = 00011110 = 30
uint shiftFour = value << 4;  // Result = 11110000 = 240

Höger-Shift

uint value = 240;             // 11110000
 
uint halved = value >> 1;     // Result = 01111000 = 120
uint shiftFour = value >> 4;  // Result = 00001111 = 15

Implicit cast and Explicit Cast-operatörer

C # tillåter användardefinierade typer att styra tilldelning och casting genom användning av de explicit och implicit nyckelorden. Metodens signatur har formen:

public static <implicit/explicit> operator <ResultingType>(<SourceType> myType)

Metoden kan inte ta fler argument och det kan inte heller vara en instansmetod. Den kan dock komma åt alla privata medlemmar av den typ som den definieras inom.

Ett exempel på både en implicit och explicit rollspel:

public class BinaryImage 
{
    private bool[] _pixels;

    public static implicit operator ColorImage(BinaryImage im)
    {
        return new ColorImage(im);
    }

    public static explicit operator bool[](BinaryImage im)
    {
        return im._pixels;
    }
}

Tillåter följande cast syntax:

var binaryImage = new BinaryImage();
ColorImage colorImage = binaryImage; // implicit cast, note the lack of type 
bool[] pixels = (bool[])binaryImage; // explicit cast, defining the type

De roliga operatörerna kan arbeta båda vägarna, gå från din typ och gå till din typ:

public class BinaryImage
{
    public static explicit operator ColorImage(BinaryImage im)
    {
        return new ColorImage(im);
    }

    public static explicit operator BinaryImage(ColorImage cm)
    {
        return new BinaryImage(cm);
    }
}

Slutligen as sökord, som kan vara inblandade i gjutning inom en typ hierarki är inte giltigt i den här situationen. Även efter att du har definierat antingen en explicit eller implicit rollbesättning kan du inte göra:

ColorImage cm = myBinaryImage as ColorImage;

Det kommer att generera ett sammanställningsfel.

Binära operatörer med uppdrag

C # har flera operatörer som kan kombineras med ett = -tecken för att utvärdera operatörens resultat och sedan tilldela resultatet till den ursprungliga variabeln.

Exempel:

x += y

är det samma som

x = x + y

Uppdragsoperatörer:

• +=
• -=
• *=
• /=
• %=
• &=
• |=
• ^=
• <<=
• >>=

? : Ternary Operator

Returnerar ett av två värden beroende på värdet på ett booleskt uttryck.

Syntax:

condition ? expression_if_true : expression_if_false;

Exempel:

string name = "Frank";
Console.WriteLine(name == "Frank" ? "The name is Frank" : "The name is not Frank");

Den ternära operatören är högerassocierande som gör det möjligt att använda sammansatta ternära uttryck. Detta görs genom att lägga till ytterligare ternära ekvationer i antingen den sanna eller falska positionen för en moder ternär ekvation. Försiktighet bör vidtas för att säkerställa läsbarheten, men detta kan vara användbart kortfattat under vissa omständigheter.

I detta exempel utvärderar en sammansatt ternär operation en clamp och returnerar det aktuella värdet om det är inom intervallet, min om det är under intervallet eller max om det är över intervallet.

light.intensity = Clamp(light.intensity, minLight, maxLight);

public static float Clamp(float val, float min, float max)
{
    return (val < min) ? min : (val > max) ? max : val;
}

Ternära operatörer kan också häckas, till exempel:

a ? b ? "a is true, b is true" : "a is true, b is false" : "a is false"

// This is evaluated from left to right and can be more easily seen with parenthesis:

a ? (b ? x : y) : z

// Where the result is x if a && b, y if a && !b, and z if !a

När du skriver sammansatta ternära uttalanden är det vanligt att använda parenteser eller intryck för att förbättra läsbarheten.

Typerna av expression_if_true och expression_if_false måste vara identiska eller det måste finnas en implicit omvandling från en till en annan.

condition ? 3 : "Not three"; // Doesn't compile because `int` and `string` lack an implicit conversion.

condition ? 3.ToString() : "Not three"; // OK because both possible outputs are strings.

condition ? 3 : 3.5; // OK because there is an implicit conversion from `int` to `double`. The ternary operator will return a `double`.

condition ? 3.5 : 3; // OK because there is an implicit conversion from `int` to `double`. The ternary operator will return a `double`.

Typ- och konverteringskraven gäller också för dina egna klasser.

public class Car
{}

public class SportsCar : Car
{}

public class SUV : Car
{}

condition ? new SportsCar() : new Car(); // OK because there is an implicit conversion from `SportsCar` to `Car`. The ternary operator will return a reference of type `Car`.

condition ? new Car() : new SportsCar(); // OK because there is an implicit conversion from `SportsCar` to `Car`. The ternary operator will return a reference of type `Car`.

condition ? new SportsCar() : new SUV(); // Doesn't compile because there is no implicit conversion from `SportsCar` to SUV or `SUV` to `SportsCar`. The compiler is not smart enough to realize that both of them have an implicit conversion to `Car`.

condition ? new SportsCar() as Car : new SUV() as Car; // OK because both expressions evaluate to a reference of type `Car`. The ternary operator will return a reference of type `Car`.

sorts

System.Type objekt för en typ.

System.Type type = typeof(Point)        //System.Drawing.Point      
System.Type type = typeof(IDisposable)  //System.IDisposable
System.Type type = typeof(Colors)       //System.Drawing.Color
System.Type type = typeof(List<>)       //System.Collections.Generic.List`1[T]

För att få GetType , använd GetType metoden för att få System.Type för den aktuella instansen.

Operatör typeof tar en typ namn som parameter, som anges vid kompileringen.

public class Animal {} 
public class Dog : Animal {}

var animal = new Dog();

Assert.IsTrue(animal.GetType() == typeof(Animal)); // fail, animal is typeof(Dog) 
Assert.IsTrue(animal.GetType() == typeof(Dog));    // pass, animal is typeof(Dog)
Assert.IsTrue(animal is Animal);                   // pass, animal implements Animal

standardoperatör

Värdetyp (där T: strukt)

De inbyggda primitiva datatyperna, t.ex. char , int och float , samt användardefinierade typer som deklarerats med struct eller enum . Deras standardvärde är new T() :

default(int)            // 0
default(DateTime)       // 0001-01-01 12:00:00 AM
default(char)           // '\0' This is the "null character", not a zero or a line break.
default(Guid)           // 00000000-0000-0000-0000-000000000000
default(MyStruct)       // new MyStruct()

// Note: default of an enum is 0, and not the first *key* in that enum
// so it could potentially fail the Enum.IsDefined test
default(MyEnum)         // (MyEnum)0

Referensstyp (där T: klass)

Alla typer av class , interface , arrayer eller delegater. Deras standardvärde är null :

default(object)         // null
default(string)         // null
default(MyClass)        // null
default(IDisposable)    // null
default(dynamic)        // null

namn på operatör

Returnerar en sträng som representerar det okvalificerade namnet på en variable , type eller member .

int counter = 10;
nameof(counter); // Returns "counter"
Client client = new Client();
nameof(client.Address.PostalCode)); // Returns "PostalCode"

nameof operatören introducerades i C # 6.0. Det utvärderas vid kompileringen tid och återsträngvärdet sätts inline av kompilatorn, så att den kan användas i de flesta fall där konstanten sträng kan användas (t.ex. case etiketter i en switch uttalande, attribut, etc .. .). Det kan vara användbart i fall som höjning och loggning av undantag, attribut, MVC-åtgärdslänkar osv ...

?. (Null villkorad operatör)

var bar = Foo.GetBar()?.Value; // will return null if GetBar() returns null
var baz = Foo.GetBar()?.IntegerValue; // baz will be of type Nullable<int>, i.e. int?

event EventHandler<string> RaiseMe;
RaiseMe?.Invoke("Event raised");

Ökning och förkortning av postfix och prefix

Postfix ökning X++ lägger till 1 till x

var x = 42;
x++;
Console.WriteLine(x); // 43

X-- kommer att subtrahera en

var x = 42
x--; 
Console.WriteLine(x); // 41

++x kallas prefix inkrement det ökar värdet på x och returnerar sedan x medan x++ returnerar värdet på x och sedan steg

var x = 42;
Console.WriteLine(++x); // 43
System.out.println(x); // 43

medan

var x = 42;
Console.WriteLine(x++); // 42
System.out.println(x); // 43

båda används ofta i för loop

for(int i = 0; i < 10; i++)
{
}

=> Lambda-operatör

string[] words = { "cherry", "apple", "blueberry" };

int shortestWordLength = words.Min((string w) => w.Length); //5

int shortestWordLength = words.Min(w => w.Length); //also compiles with the same result

(input parameters) => expression

// expression
(int x, string s) => s.Length > x

// expression
(int x, int y) => x + y

// statement
(string x) => Console.WriteLine(x)

// block
(string x) => {
        x += " says Hello!";
        Console.WriteLine(x);
    }

delegate void TestDelegate(string s);

TestDelegate myDelegate = s => Console.WriteLine(s + " World");

myDelegate("Hello");

void MyMethod(string s)
{
    Console.WriteLine(s + " World");
}

delegate void TestDelegate(string s);

TestDelegate myDelegate = MyMethod;

myDelegate("Hello");

Uppdragsoperatör '='

Uppdragsoperatören = ställer in vänsteroperands värde till värdet på högeroperand och returnerar det värdet:

int a = 3;     // assigns value 3 to variable a
int b = a = 5; // first assigns value 5 to variable a, then does the same for variable b
Console.WriteLine(a = 3 + 4); // prints 7

?? Null-Coalescing-operatör

Null-Coalescing-operatören ?? kommer att återställa vänster sida när den inte är noll. Om den är noll kommer den tillbaka till höger sida.

object foo = null;
object bar = new object();

var c = foo ?? bar;
//c will be bar since foo was null

?? operatören kan kedjas som gör det möjligt att ta bort if checkar.

//config will be the first non-null returned.
var config = RetrieveConfigOnMachine() ??
             RetrieveConfigFromService() ??
             new DefaultConfiguration();