Copy Paste Visual Studio Code to Blog

Download Productivity Power Tools 2015

Herefter vil HTML formatteringen medtages når du bruger CTRL+C

Før installation af Productivity Power Tools 2015 ser formateringen  ud som nedenstående

using System;

using System.Collections.Generic;

using System.Linq;

using System.Web;

namespace WebApplicationTest.Models

{

    public class Class1

    {

        public int test { get; set; }

        public int id { get; set; }

    }

}

Før installation af Productivity Power Tools 2015 ser formateringen ud som nedenstående

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
 
namespace WebApplicationTest.Models
{
    public class Class1
    {
        public int test { get; set; }
        public int id { get; set; }
    }
}

Hændelser

De foregående indlæg har behandlet delegates, der er grundlaget for hændelser eller events.I det følgende forklares events udfra hvad der sker ved tryk på en knap.

En knap, en checkboks og andre elementer i brugerfladen i .NET er i virkeligheden klasser. Disse klasser indeholder strukturer der hedder events.

Det er ikke knappens klasse der bestemmer hvad der skal ske når der f.eks trykkes på knappen. Eventen giver blot besked til metoden / metoderne der "lytter" om at handlingen er foretaget. Det er så den lyttende kode der bestemmer hvilke metoder der skal kaldes. Lyttende metoder siges også at abonnere på hændelsen.

Man taler om Subscriber og Broadcaster.

Subscriber - Lyttende kode
I praksis laver man i den kaldende kode en metode, og lader denne metode abonnere på en event.

Man abonnerer på eventen som vi så i indlæg om delegates ved at bruge += operatoren på delegaten. Hermed knytter man i afviklingsøjeblikket de metoder der skal afvikles ved hændelsen.

Broadcaster - Knappen
Knappen bestemmer hvornår hændelsen skal ske, ved at kalde delegaten. Man definerer en hændelse med event ordet. Events er en hjælpe funktionalitet i C# . En event har en type og et navn. Eventen defineres i knappens klasse.

Typen er en delegate, som vi selv definerer, eller man kan anvende C#'s  indbygget delegate der hedder EventHandler. EventHandler har to argumenterne (object sender, EventArgs e).

Eventen defineres som sagt i knappens klasse, knappens objekt sendes sammen med argumentet e til den metode / metoder der skal foretage sig noget.

Koden der afvikles
Koden der afvikles ligger typisk udenfor selve knappen. Ser vi i  visual studio på en typisk signatur til en metode der bliver afviklet når der klikkes på en knap, kan den se således ud:

 protected void Button1_Click(object sender, EventArgs e)

Visual Studio laver netop en event med typen EventHandler delegate automatisk. Argumenterne er det objekt der har udløst eventen sender(knappen), samt eventuelle argumenter i et EventArgs objekt e.

Multicast Delegates

Alle delegate objekter har mulighed for at pege på ikke kun en men flere metoder. Dette kaldes multicast delegates. Et delegate objekt  kan altså vedligeholde en liste af metoder.

I indlægget Delegates knyttede vi metoden Velkommen.Tysk til delegaten Dele ved at bruge den som argument da vi instansierede delegaten.

VelkomstDelegate Dele = new VelkomstDelegate(Velkomst.Tysk);

Der er flere forskellige syntakser for at tilknytte endnu en metode til delegaten. En syntaks til at tilknytte metoden Velkomst.Engelsk kunne være:

Dele = Dele + Velkomst.Engelsk;

Typisk vil man bruge følgende syntaks der sematisk er det sammen som ovenstående:

Dele += Velkomst.Engelsk;

På samme måde kan man bruge - og -= operatorene til at fjerne metoder fra listen over metoder delegaten refererer til.

Man kan også assigne null til en delegate

Dele = null;

Delegates er immutable, så når man bruger operatorer som += på denne laver man i virkeligheden et nyt objekt i hukommelsen og peger delegaten på dette.

Har multicast delegaten en returtype er det retur værdien fra den sidste metode der returneres til den kaldende kode.

Delegates

Brugen af hændelser eller Events i C# er en vigtig del af brugerfladeprogrammering. Hændelser giver en klasse mulighed for at kommunikere med andre objekter. Dette betyder at hændelser kan reagere på en handling i brugergrænsefladen, det kan f.eks være tryk på en knap, markering af en checkbox etc.

Grundlaget for hændelser er de såkaldte delegates. Delegates er referncevariabler der gør det mulighed at at kalde en metode uden at definere hvilken metode der kaldes før i afviklingsøjeblikket. En delegate anvender keywordet delegate. En delegate skal have samme signatur som den metode den skal bruges til at kalde. Det vil sige samme returtype og samme antal og type argumenter.

Nedenstående eksempel viser en delegate i funktion.

    // Delegaten defineres
    public delegate void VelkomstDelegate(string navn);

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Indtast navn");
            string navn = Console.ReadLine();

            Console.WriteLine("Indtast sprog");
            string sprog = Console.ReadLine();         

            if (sprog == "tysk")
            {
                // Der laves et objekt af delegaten VelkomstDelegate, metoden bruges som argument her Velkomst.tysk
                VelkomstDelegate Dele = new VelkomstDelegate(Velkomst.tysk);

                // Delegaten bruges nu som metoden Velkomst.tysk ville være brugt
                Dele(navn);
            }
            else
            {
                // Der laves et objekt af delegaten VelkomstDelegate, metoden bruges som argument her Velkomst.engelsk
                VelkomstDelegate Dele = new VelkomstDelegate(Velkomst.engelsk);

                // Delegaten bruges nu som metoden Velkomst.engelsk ville være brugt
                Dele(navn);
            }
            Console.ReadKey();
        }
    }

    public class Velkomst
    {
        public static void tysk(string navn)
        {
            Console.WriteLine("Wilkommen {0}", navn);
        }
        public static void engelsk(string navn)
        {
            Console.WriteLine("Welcome {0}", navn);
        }
    }

Ovenstående eksempel er ikke perfekt i forhold til at illustrere det ekstra lag af fleksibilitet som delegates giver, da det er det samme stykke kode der laver delegaten som bruger den. Man skal forestille sig at en metode laver delegaten og en anden metode bruger den. Dette giver mulighed for at kalde en metode via en delegate og først runtime, altså i afviklingsøjeblikket at bestemme præcis hvilken metode delegaten kalder.

I ovenstående eksempel bruges delegate objektet til at kalde en metode. Delegate objektet kan også bruges som argument i en metode eller hændelser som beskrevet i starten af dette indlæg.

Valuevariabler og referencevariabler

I c# arbejder man med to typer variabler; referencevariabler og valuevariable.

Valuevariabler
Valuevariabler er structures der gemmes på stacken. Typiske valuevariabler er de af .NET definerede typer som;

int
short
float
double
decimal
datetime
bool
samt structs
mm.

Valuevariabler indeholder værdier direkte. Sætter man to valuevariabler lig hinanden laves der en kopi, således at de ligger to steder på stacken.

Referencevariabler
Referencevariabler er klasser. Instanser / objekter af disse klasser gemmes på heapen. Flere referencevariabler kan pege på samme objekt. Dette medfører, at hvis en variabel ændrer værdi på objekt, slår denne ændring igennem på alle variabler der peger på objektet.
Referencetyper er alle de klasser, du selv opretter i et projekt, samt de fleste af de klasser .NET stiller til rådighed.

Arbejde med strenge System.Text.StringBuilder

Strenge i c# er ikke value types, selvom de minder lidt om. De er reference types og gemmes på heapen (hukommelsen hvor reference types ligger). Streng er det man kalder immutable; dvs. de kan ikke ændres når de først ligger på heapen. 

System.String stiller en række metoder til rådighed for at manipulere strenge. Disse metoder kan fint anvendes hvis ressourceforbrug ikke er en bekymring. 

System.String bruger imidlertid en del ressourcer, da metoderne ikke arbejder med referencer men returnerer en ny streng i hukommelsen. Arbejder man således med en streng i et loop, kan det give rigtigt mange kopier af strenge, der skal oprettes i hukommelsen. Dette giver en del "Overhead" altså ressourceforbrug. 

En løsning på dette er at arbejde med StringBuilder Klassen, der findes i namespace System.Text. Ved at lave et StringBuilder objekt, kan man bruge metoder som Append og Remove på dette objekt uden at lave nye strenge i hukommelsen.

Eks 1.


        System.Text.StringBuilder sb = new StringBuilder();
        // Opretter et StringBuilder objekt sb

        sb.Append("Her er en streng");
        // Tilføjer streng til sb

        sb.Remove(0, 4);
        // Fjerner karakter i index 0-3 i sb streng

        sb.Replace("er", "Dette er");
        // Erstatter ordet "er" med "Dette er"

sb indeholder nu "Dette er en streng"

Ovenstående viser er et simpelt eksempel på brugen af metoderne Append, Remove og Replace. Istedet for System.Text.StringBuilder kan namespace System.Text selfølgelig importeres

using System.Text;

Der er flere overloadede versioner af metoderne Append, Remove ogg Replace, der gør, at man kan manipulere en streng helt efter ens eget hoved.

Læse og skrive XML via XmlDocument C#

Der er en flere forskellige tilgange til arbejde med XML i C#. .NET stiller en række klasser til rådighed til at læse og skrive XML. En simpel metode jeg vil vise i dette eksempel er at XmlDocument fra System.Xml namespace.
Med XmlDocument arbejder man med et helt XML dokument i hukommelsen, det er derfor ikke ideelt at bruge XmlDocument til meget store XML filer. Ved store filer kan klasserne XmlTextReader og XmlTextWriter anvendes, de arbejder element for element.

Eksempel 1.

            XmlDocument doc = new XmlDocument();

            XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "utf-8", null);
            doc.AppendChild(declaration);

            XmlElement cmsElement = doc.CreateElement("", "cms", "");
            doc.AppendChild(cmsElement);

            XmlElement sprogElement = doc.CreateElement("", "sprog", "");
            cmsElement.AppendChild(sprogElement);

            XmlText sprogTekst = doc.CreateTextNode("dansk");
            sprogElement.AppendChild(sprogTekst);

            XmlElement domæneElement = doc.CreateElement("", "domæne", "");
            cmsElement.AppendChild(domæneElement);

            XmlText domæneTekst = doc.CreateTextNode("eksempel.dk");
            domæneElement.AppendChild(domæneTekst);

            XmlElement mappeElement = doc.CreateElement("", "mappe", "");
            cmsElement.AppendChild(mappeElement);

            XmlText mappeTekst = doc.CreateTextNode("min mappe");
            mappeElement.AppendChild(mappeTekst);

         doc.Save("c:/filer/gemher.xml");

Resultatet af koden er filen gemher.xml i mappen filer på c drev

Hvis filen åbnes med f.eks visual studio ser indhold således ud:

<?xml version="1.0" encoding="utf-8"?>
<cms>
  <sprog>dansk</sprog>
  <domæne>eksempel.dk</domæne>
  <mappe>min mappe</mappe>
</cms>

Instance metoden CreateXmlDeclaration danner dekleration til XML filen
Instance metoden AppendChild tilføjer element
Instance metoden CreateElement danner nyt element
Instance metoden Save gemmer XML fil
XmlDeclaration klassen repræsenterer en XML dekleration
XmlElement klassen repræsenterer et element
XmlText klassen repræsenterer en tekst


Forklaring:

XmlDocument doc = new XmlDocument();
Opretter nyt XmlDocument objekt doc

XmlDeclaration declaration = doc.CreateXmlDeclaration("1.0", "utf-8", null);
Opretter XmlDeclaration objekt declaration

doc.AppendChild(declaration);
Tilføjer declaration til XmlDocument doc


XmlElement cmsElement = doc.CreateElement("", "cms", "");
Opretter XmlElement objekt cmsElement dette element hedder cms i XML fil

doc.AppendChild(cmsElement);
Tilføjer cms til XmlDocument doc, dette bliver rod element i dokumentet

XmlElement sprogElement = doc.CreateElement("", "sprog", "");
Opretter XmlElement objekt sprogElement dette element hedder sprog i XML fil

cmsElement.AppendChild(sprogElement);
Tilføjer sprog som child til cms

.
.
.
Øvrige elementer tilføjes som child til rod element cms
.
.
.
doc.Save("c:/filer/gemher.xml");
Gemmer XmlDocument doc som xml fil på placering "c:/filer/gemher.xml"

XmlDocument sørger for formattering, som eks. at afslutte elementer.

Bemærk!
Der findes en anden klasse i .NET version 3.0 og derover XDocument der yderligere forenkler arbejdet med XML.