Jämförelse mellan versioner av .NET

Inledning

Vad har egentligen skett i utveckling mellan olika versioner av .NET? Om du vill kalla dig utvecklare med fokus på .NET så bör du ha lite koll på nyheterna i de olika versionerna.

Vi skall i denna artikel gå igenom de förbättringar som språket C# har försetts med från version 2.0 till version 4.5. Vi kan inte lista alla ändringar utan nöjer oss med de viktigaste. Varje förbättring kan i sig ta mycket plats att gå igenom i detalj så endast enklare förklaring erbjuds.

.NET 2.0

.NET 2.0 kom i slutet av 2005 tillsammans med Visual Studio 2005. Detta var den första versionen av .NET som fick en större spridning. Det var först nu som språket utvecklats och berikats med funktioner som gör det användbart.

  • Template-klasser (Generics)
  • Partiella typer (Partial types)
  • Anonyma metoder (Anonymous methods)
  • Iteratorer (Iterators)
  • Nullable types
  • Privata set i properties

Template-klasser

Ett typiskt exempel är alla lagringsklasser, t.ex. List. Innan template-klasser introducerades så fick man använda object väldigt mycket oftare än idag. Numera kan man använda en uppsjö färdiga template-klasser som typbestämmer instanserna så att du slipper kasta från object till din önskade typ.

Behövs det så kan man givetvis skrivna egna generiska klasser (template-klasser). Det är kanske först då som insikten om hur användbart detta egentligen är infinner sig.

Partiella typer

Tillåter dig att bygga ut befintliga klasser eller bara dela upp koden för samma klass i fler filer. Nyckelordet partial används i klassens deklaration. 


using System;
using System.Collections.Generic;
using System.Text;

namespace ExtensionMethods
{
    partial class Program
    {
		//...
	}
}

Anonyma metoder

Minskar kodandet en hel del. Du slipper deklarera metoder i klassen som bara används på ett ställe som t.ex. till en delegat. 


void StartThread()
{
    System.Threading.Thread t1 = new System.Threading.Thread
      (delegate()
            {
                System.Console.Write("Hello, ");
                System.Console.WriteLine("World!");
            });
    t1.Start();
}

Iteratorer

En iterator hjälper dig att stega genom samlingar, t.ex. i samband med foreach. Tillsammans med IEnumerable samt yield return kan man skapa uppräkningsbara sekvenser och klasser. 


static void Main()
{
    foreach (int number in SomeNumbers())
    {
        Console.Write(number.ToString() + " ");
    }
    // Output: 3 5 8
    Console.ReadKey();
}

public static System.Collections.IEnumerable SomeNumbers()
{
    yield return 3;
    yield return 5;
    yield return 8;
}

Nullable types

En teknik vi nämnt i artikeln 10 Bra programmeringstekniker i C# på plats #9. 


	int? x = null;
	int? y = 3;
	
	Console.WriteLine("x HasValue: {0}", x.HasValue);
	Console.WriteLine("y HasValue: {0}", y.HasValue);
	Console.WriteLine("y Value: {0}", y.Value);

Privata set i properties

Du kan skydda set-delen eller get-delen på en property. Den kan vara private, protected eller internal. 


	public class Person
	{
		public Person(int id)
		{
			this.Id = id;
		}
		public int Id { get; private set; }
		public string Name { get; set; }
	}

Poängen är att du kan styra vem så får sätta property'n och samtidigt ha en property utan en massa extra privata variabler i klassen. Renare, snyggare och bättre än tidigare.

.NET 3.0/3.5

Version 3.0 kom i slutet av 2006 och 3.5 i slutet av 2007. Anledningen att dessa versioner oftas klumpas ihop är för att de båda anses höra till språket C# 3.0 men .NET-ramverket i sig uppgraderades till 3.5. En aning förvirrande.

Med .NET 3.0 kom XAML och första versionen av Expression Blend samt hörnstenar som WCF, WPF och WF. Till .NET 3.5 kom Visual Studio 2008. Vi koncentrerar oss mer på språk-nyheterna och mindre på de nya biblioteken i .NET.

  • Slutledning av typer (Implicitly typed local variables)
  • Objekt- och samlingsinitierare
  • Autoimplementerade properties
  • Anonyma typer
  • Extension methods
  • Query-uttryck
  • Lambda-uttryck
  • Partiella metoder

Varför nämnde vi inte LINQ? Jo, LINQ är egentligen ett bibliotek av Extension methods som använder Lamda-uttryck mm. LINQ i sig är alltså inte det språktekniskt intressanta.

Slutledning av typer

Se 10 Bra programmeringstekniker i C# plats #6.

Objekt- och samlingsinitierare

Se 10 Bra programmeringstekniker i C# plats #4. Ett exempel på samlingsinitiering: 


List<int> digits = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
List<int> digits2 = new List<int> { 0 + 1, 12 % 3, MakeInt() };

Autoimplementerade properties

Se 10 Bra programmeringstekniker i C# plats #3.

Anonyma typer

Anonyma typer kan vara ett bekvämt sätt att kapsla in skrivskyddad data i ett objekt utan att behöva definiera en klass för detta. Måste användas tillsammans med var då typen inte finns deklarerad, den är ju anonym! 


var v = new { Amount = 108, Message = "Hello" };
Console.WriteLine(v.Amount + v.Message);

Extension methods

Se artikeln Extension methods .

Query-uttryck

Med inspiration av SQL så har .NET fått ett eget sätt att ställa frågor på samlingar. Från valfri samling (IEnumerable) kan du välja ut, sortera, filtrera etc. på ett till synes SQL-liknande vis. Exempel:


static void Main()
{
    // Datakälla
    int[] scores = { 90, 71, 82, 93, 75, 82 };

    // Query Expression.
    IEnumerable<int> scoreQuery = 	//query variable 
        from score in scores 		//nödvändig 
        where score > 80 			// valfri 
        orderby score descending 	// valfri 
        select score; 				//måste avslutas med select or group 

    // Frågan körs ej förrän den används
    foreach (int testScore in scoreQuery)
    {
        Console.WriteLine(testScore);
    }                  
}
// Resultat: 93 90 82 82

Lambda-uttryck

Dessa används oftast tillsammans med LINQ för att skicka med anonyma funktioner. Ett lamda-uttryck är just en anonym funktion. 


delegate void TestDelegate(string s);
//...
TestDelegate myDel = n => { string s = n + " " + "World"; Console.WriteLine(s); };
myDel("Hello");

Detta område kräver mer förklaring. Kanske blir det en egen artikel snart.

Partiella metoder

Partiella metoder tillåter att implementation görs i en annan fil. Klassen som metoden hör till måste således också markeras partial. 


namespace PM
{
    partial class A
    {
        partial void OnSomethingHappened(string s);
    }

    // Nedanstående kan placeras i separat fil 
    partial class A
    {
        // Om metoden nedan kommenteras ut så kompileras allt fortfarande
        partial void OnSomethingHappened(String s)
        {
            Console.WriteLine("Something happened: {0}", s);
        }
    }
}

Det finns en del regler för partiella metoder, t.ex. att de måste returnera void. Tanken är att klasser kan lämnas öppna för komplettering/utbyggnad till t.ex. andra projekt som vill använda dem. Alternativa lösningar är t.ex. att göra en override via ett arv eller att använda eventhantering.

.NET 4.0

Denna version kom i början av 2010 tillsammans med Visual Studio 2010. Ett populärt nytt bibliotek var bl.a "Parallel Extensions" som förenklade utnyttjandet av fler processorer.

  • Dynamisk typ (Dynamic type)
  • Namngivna och villkorliga argument

Dynamisk typ

Nu introduceras en ny typ; dynamic. Med denna typ görs C# mer till ett script-språk i den mening att en dynamisk typ kan göra allt! Du kommer inte att få några kompileringsfel men däremot körfel om den används felaktigt.. 


static void Main(string[] args)
{
    dynamic dynamic_ec = new ExampleClass();

    dynamic_ec.exampleMethod1(10, 4);
    dynamic_ec.someMethod("some argument", 7, null);
    dynamic_ec.nonexistentMethod();
}

Om klassen ExampleClass inte implementerar de metoder som användes så märker du det först när programmet körs då ett exception slängs.

Detta kan vara bra t.ex. då två klasser har samma metoder men delar inget gemensamt interface. Du kan alltså inte behandla dem lika fastän de båda deklarerar samma typ av metod. Med dynamic blir det hela mycket enkelare.

Namngivna och villkorliga argument

Namngivna argument till metoder hjälper till med läsbarheten i koden. Säg att du har en metod av typen (int, int), t.ex. CalculateBMI(123, 64);. Hur läser du detta anrop? Den ena parametern är vikt o den andra höjd men vilken?. 


class NamedExample
{
    static void Main(string[] args)
    {
        // Normalt vis
        Console.WriteLine(CalculateBMI(123, 64));

        // Namngivna argument kan anges i valfri ordning
        Console.WriteLine(CalculateBMI(weight: 123, height: 64));
        Console.WriteLine(CalculateBMI(height: 64, weight: 123));
    }

    static int CalculateBMI(int weight, int height)
    {
        return (weight * 703) / (height * height);
    }
}

.NET 4.5

Denna version kom i slutet av 2012 tillsammans med Visual Studio 2012.

  • Asynkrona metoder
  • Caller info attributes

Vi erbjuder inga ytterligare förklaringar eller exempel på detta. Vi kan dock meddela att just asynkrona metoder är mycket användbara och kommer definitivt att bli ett ämne för en separat artikel.

Lämna ett svar

Din e-postadress kommer inte publiceras. Obligatoriska fält är märkta *

Scroll to top