Inledning
Dags för att titta på 10 olika tekniker så kan göra din programmering i C# både snabbare, effektivare och renare. Några av teknikerna känner du kanske till, andra kan verka helt främmande. Poängen är att visa några saker som kan verka obekväma nu men som har potential att ändra ditt sätt att programmera.
Alltså ge inte upp utan ge varje okänd teknik en chans eftersom det krävs övning innan de "sitter i ryggmärgen".
1. Villkorlig evaluering med operatorn ?
Först ut är en gammal klassiker som finns i nästan alla programmeringsspråk. Operatorn är verkligen ?. Med denna operator kan du förenkla alla enklare if-else situationer. Exempel på hur det normalt ser ut:
int x = 10;
int y = 20;
int max;
if (x > y)
max = x;
else
max = y;
Operatorn ? används som "(påstående) ? sant : falskt". Vi skriver om exemplet ovan till att använda operatorn ?:
int x = 10;
int y = 20;
int max = (x > y) ? x : y;
Du kan inte skriva om alla if-else satser till att använda ?. Det är när du vill ha fram ett värde som styrs av något villkor, t.ex. vid tilldelning som exemplet ovan, eller om du skall returnera ett värde från en metod.
2. Null-Coalesce operatorn ??
Hittade tyvärr ingen bra översättning på null-Coalesce så jag får använda den engelska termen. Denna operator skrivs som ?? och har som enda syfte att hjälpa dig när du riskerar att ha null-värden. T.ex. så kan referenser ofta ha värdet null om de inte refererar till något objekt. Strängar kan också vara null.
Mycket ofta vill man säkerställa att man har något värde, dvs. inte null. Exempel:
string value = null;
if(value == null)
{
value = "inget värde!";
}
Här säkerställer vi att variabeln value får ett värde då vi "misstänker" att den är null annars. Enligt punkt 1 så kan man skriva detta som:
string value = null;
value = (value != null) ? value : "inget värde!";
Inte direkt enklare men det är här som vi kan använda ?? operatorn:
string value = null;
value = value ?? "inget värde!";
Om värdet vänster om ??, i exemplet value, inte är null så tilldelas värdet till vänster annars tilldelas värdet till höger om ??.
3. Automatiska egenskaper i klasser
Sedan C# 3.0 kan man deklarera egenskaper (properties) i klasser på ett enklare sätt. Tidigare kunde det se ut som:
public class Person
{
private string _firstName;
public string FirstName
{
get { return _firstName; }
set { _firstName = value; }
}
}
Numera kan man förenkla till:
public class Person
{
public string Firstname { get; set; }
}
Kompilatorn kommer automatiskt att generera en privat "bakgrundsvariabel" som egenskapen använder. Denna privata variabel kan du inte nå då den inte finns förrän programmet kompileras. För att detta ska fungera måste du ha både en set- och en get-del i egenskapen.
Varför kan man inte då bara deklarera en publik strängvariabel i klassen? Visst det kan du men tänk på att en egenskap kan ingå i interface samt att egenskaper kan deklareras som virtual och då ändra beteende via arv (override). Idag använder man egenskaper i nästan 100% av fallen då man vill exponera publik data från klassen.
4. Initialisering av objekt
Efter att du skapat ett objekt så måste du kanske sätta några egenskaper t.ex:
Person p = new Person();
p.FirstName = "Sherlock";
p.Address = "221B Baker Street";
Alternativt skicka med data via en konstruktor (om en sådan finns):
Person p = new Person("Sherlock", "221B Baker Street");
Sedan C# 3.0 kan du initialisera objektets egenskaper samtidigt som det skapas. Detta gör du genom att skriva (exempel):
Person p = new Person() { FirstName = "Sherlock", Address = "221B Baker Street"};
Detta är mycket renare och snabbare än första exemplet. Jämfört med exempel 2, där en konstruktor används, så slipper du skriva en konstruktor! Hoppas det räcker som argument.
5. Tom eller null sträng
Detta är en mycket enkel metod som finns för string. Jobbar du mycket med strängar via t.ex. databaser så händer det extremt ofta att man måste kolla om strängen är null eller tom. Det är inte samma sak. Vi kan göra detta enkelt genom:
if (String.IsNullOrEmpty(s))
return "is null or empty";
else
return String.Format("(\"{0}\") is not null or empty", s);
Eller omsrkivet enligt punkt 1:
return (String.IsNullOrEmpty(s)) ? "is null or empty" : String.Format("(\"{0}\") is not null or empty", s);
6. Slutledning av typer
Traditionellt så är man noga med att deklarera sina variabler med rätt typ.
string myString = "en enkel sträng";
Uttrycket till höger om myString kommer alltid att blir string. Varför inte låta kompilatorn räkna ut vilken variabeltyp som behövs? Det kan man numera göra med det reserverade ordet var.
var myString = "en enkel sträng";
C# är fortfarande ett starkt typat språk (om man bortser från dynamic). var påverkar inte prestanda. Exemplet ovan är enkelt men det finns knepigare fall där man t.ex. vet att man skall plocka resultatet som returneras från en metod men man vet inte i förhand vilken variabeltyp som returneras. Lösningen är enkel: använd var.
7. Regioner
Gör kodfilerna lite mer lättläsliga och samtidigt delar in kod i olika "regioner" som går att fällas ihop. Resultatet blir prydligare kodfiler. Exempel:
public class TestKlass
{
#region Properties
public string Test1 { get; set; }
public string Test2 { get; set; }
#endregion
#region Methods
public void DoSomething()
{
}
#endregion
}
#region markerar start ar region följt av valfri text. Texten är det enda som syns när regionen är ihopfälld. Regionen stängs med #endregion.
8. Using direktivet
Det går att göra en hel del med using för att styra namnutrymmen. Du kan t.ex. lösa namnkonflikter men också skapa alias. Du kan använda using som alias för antingen en specifik klass eller för ett namnutrymme. Exempel:
using Word = Microsoft.Office.Interop.Word;
....
Word.Application = new Word.Application() { Visible = True; }
Här hav vi gjort ett alias för namnutrymmet Microsoft.Office.Interop.Word vilket samtidigt hjälper oss att lösa en möjlig namnkonflikt med klassen Application som även finns i Windows Forms.
9. Nullable objekt
Nullable kallas objekt som kan ha värdet null. Inte alla datatyper kan ha värdet null, t.ex. int, double, m.fl. Ibland vill behöver man ändå kunna skilja på "att ha ett värde" och "att inte ha ett värde" (null). Då kan man (sedan C# 2.0) skriva:
Nullable<int> x = null;
int? x = null;
Båda raderna i exmeplet deklarerar en nullable int x. Skrivsättet på rad 1 används inte utan notationen med ? efter variabeltyp, rad 2, är den som gäller. Många skrivsätt i C# är inbyggda makron som kompilatorn använder just variabeltyp? översätts till en Nullable generisk klass.
Nullable objekt är bra för att kunna skilja på om något är inmatat eller ej. Det är inte alla gånger ett standardvärde är önskvärt speciellt inte vid lagring i databaser.
10. Lambdauttryck
I C# 2.0 introducerades anonyma metoder som kunde definieras inom en annan metod.
class Program
{
delegate bool filter(int a);
static void Main(string[] args)
{
filter f = delegate(int a) { return a > 35; };
}
}
Med lambdauttryck blir det enklare och mer läsligt:
class Program
{
delegate bool filter(int a);
static void Main(string[] args)
{
filter f = a => a > 35;
}
}
Du kan definiera lambauttryck överallt där du annars hade skrivit en delegat, t.ex:
var SeniorStaff = Employees.Where(s => s.Age > 35);