Category: Microsoft .NET

FileUtility är ett bibliotek för Windows/.NET 6.0 som (för närvarande) innehåller en enda klass: PathInfo. Den kan bl.a. korta ner en filsökväg för presentation på skärmen och ange fil- och katalogstorlek i flera format, inklusive ett människovänligt textformat. Exempelkod finns här.

var max = 15;
var f = new PathInfo(new FileInfo(@"C:\Temp\hello.txt"));
Console.WriteLine(f.CompactPathForDisplay(15))

// Result: C:...\hello.txt

Har du någon gång suttit och stirrat på 5-6 tärningar och funderat på vilka formationer ögonen utgör? Nu behöver du inte fundera längre, för här är en C#-klass som ger dig svaret på nolltid! Mycket nöje!

Kodexempel: https://github.com/Anders-H/DiceFormationChecker

Ladda hem: https://www.nuget.org/packages/Winsoft.Gaming.DiceFormationChecker/

Den strängtyp som finns inbyggd i C# är “immutable”, vilket betyder att den inte kan ändra värde. Jag har skapat en “mutable string”, som kapslar strängtypen i en klass. Det innebär att man kan anropa funktioner på strängen för att få den att ändra värde. Dessa funktioner, och funktionerna för att analysera strängens innehåll, har färdiga implementationer, men dessa kan ersättas. T.ex. kan funktionen Is svara på frågan om två strängar har samma värde, enligt de flaggor som angavs när strängen skapades, eller så kan man skicka med egen kod som utför jämförelsen som argument till funktionen Is. Mer information finns här: https://github.com/Anders-H/MutableStringLibrary

Biblioteket TextAdventureGameInputParser kan användas för att parsa användarens input i ett textäventyr. Parsern tar en mening i stil med GO NORT, OPEN DOOR, USE GOLD KEY ON DOOR eller GIVE FOOD TO GANDALF och ger en struktur med ordklasser och referenser till objekt som är registrerade i parsern.

Lite exempel finns tillgängliga i parserns GitHub-repository, och parsern kan installeras (.NET 5.0) från Nuget.

En ganska enkel men ytterst trevligt tillägg i C# version 9 är möjligheten att skapa en extension method av GetEnumerator (som konsulteras när en samling ska enumereras). Betrakta denna lilla lista:

var people = new List<string>
{
    "Sven",
    "Nils",
    "Niklas",
    "Janne"
};

Om jag skulle vilja ha samtliga poster i listan för utskrift på skärmen, kan denna kod användas:

foreach (var p in people)
    Console.WriteLine(p);

GetEnumerator används implicit. Men om jag bara är intresserad av att ha med poster vars förnamn börjar på N, så måste det formuleras någonstans. Jag kan t.ex. kopiera listan och exkludera ointressanta poster, eller så skulle jag kunna iterera genom svaret från LINQ-API:et enligt:

foreach (var p in people.Where(x => x.StartsWith("N")))
    Console.WriteLine(p);

Extension methods har fördelen att de är tillgängliga i filer som läst in dess namnrymd, men är i övrigt otillgängliga. Det innebär att man kan begränsa funktionalitet till vissa filer genom att skapa en extension metod. Om jag generellt sett är intresserad av att ha personerna som börjar på N tillgängliga i den aktuella filen (eller på annat sätt kunna använda manipulerat data) kan jag deklarera en egen GetEnumerator som en extension method. Är den tillgänglig, kommer kompilatorn att välja den. I detta fall kommer man troligtvis att vilja ha full tillgänglighet för metoden.

static class MyEnumerator
{
    public static IEnumerator<T> GetEnumerator<T>(this IEnumerator<T> list) =>
        list;
}

Med denna på plats, öppnas en ny möjlighet. Svaret från den funktionen, kan itereras. Nu kan jag skapa en enumerator som t.ex. skickar tillbaka personerna som börjar på N. Med det gjort, blir iterationen lika enkel som i första exemplet, fast med den skillnaden att jag nu kontrollerar dess innehåll.

var somePeople = people
   .Where(x => x.StartsWith("N"))
   .GetEnumerator();

foreach (var p in somePeople)
    Console.WriteLine(p);

Detta är egentligen inte en stor sak, men det bidrar till kodens elegans – något som har blivit ett av kännetecknen för C#.

If you are using .NET Core (or .NET 5.0) you can easily activate the ability to run C# code from the command window (Windows Terminal or the old cmd.exe).

To get started, install dotnet-script by typing:

dotnet tool install --global dotnet-script

Once installed, you can start the dotnet-script program just by typing:

dotnet-script

The prompt now looks like a greater than-sign (>). From here, you can type any C# code and you can reference anything within the System namespace. For example, if you type:

Console.WriteLine("Hello world!");

…you will get the following answer:

Hello world!

A few things to keep in mind: Types you add will be remembered for the whole session. For example, if you type in a class, you can use that class in the session. And if the command windows expect further input, the prompt will change from a greater than-signe to an asterisk sign (*). So if you type in something like class MyClass { and press Enter, nothing will be executed. Instead, the command window will indicate that more input is expected by displaying an asterisk sign. To try this out, type something like this (terminating each statement with Enter):

class MyClass {
public void DoSomething() {
Console.WriteLine("Hello!");
}
}

And then, you can use your new type like this:

new MyClass().DoSomething();

The response will be:

Hello!

The picture shows the different prompts when you type in a simple for loop:

This is a very powerful tool to use when you want to perform tasks that are a bit too complicated for a calculator, but perhaps a bit too simple fore an advanced computer program, or when you want to try out some API you are working on. Happy programming!

Här är källkoden Othello, till ett enkelt strategispel för Windows-skrivbordet. Du vinner över datorn genom att ha se till att spelplanen innehåller fler svarta brickor än vita. Reglerna finns på Wikipedia.

Uppdatering 2023-02-11: Installationsprogram för Windows 10/11 finns här.

I C# 8 är fortfarande funktioner ett slags “andra klassens medborgare” i jämförelse med variabler. Man kan alltså fortfarande göra mer med en variabel än en funktion i C# 8.

Varken variabler eller funktioner kan skapas i namnrymder, båda kan skapas i en klass och båda kan skapas i en funktion, vilket illustreras av detta exempel:

namespace ConsoleApp1
{
    public class MyClass
    {
        public int VariableInClass;

        public void FunctionInClass()
        {
            int variableInFunction;
            
            void functionInFunction() { }
        }
    }
}

Eftersom det finns saker som du kan göra med variabler som du inte kan göra med funktioner, så är funktioner fortfarande att betrakta som ett slags andra klassens medborgare. Du kan inte lagra en funktion i en variabel, du kan inte skicka funktioner som argument och du kan inte använda type inference när du skapar funktioner.

var x = 10;

//Variabel som påverkar x
Action y = () => x++;
y();
Console.WriteLine(x);

//Funktion som påverkar x
void z() => x++;
z();
Console.WriteLine(x);

Att man inte kan lagra funktioner i variabler spelar inte någon jättestor roll. Som namnet antyder beskriver funktioner ofta något funktionellt, vilket i praktiken innebär att de innehåller programsatser. Programsatser kan även lagras i variabler, vilket innebär att funktionalitet kan lagras i en variabel och skickas som argument. Detta exempel visar hur instruktionen att summera två tal lagras i en variabel:

//Add the ability to add
//two integers in x.
Func<int, int, int> x =
    (int a, int b) => a + b;

//Execute the content
//of x, save the result in y.
var y = x(10, 20);

Detta exempel visar hur samma instruktion skickas som parameter till en funktion:

GiveMeFunctionality((a, b) => a + b);

C#-programmets startpunkt kan inte ersättas av en variabel, utan måste vara en riktig funktion kallad Main. I vissa fall kan man kringgå att en funktion inte kan användas som en variabel genom att skapa en variabel som anropar en funktion, och skicka den istället. T.ex. så här:

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            GiveMeFunctionality(
                Functionality);
        }

        static int Functionality
            (int a, int b) =>
            a + b;
        
        static void GiveMeFunctionality(
            Func<int, int, int> x)
        {
            Console.WriteLine(x(10, 20));
        }
    }
}

Men till skillnad från variabler kan funktioner vara rekursiva. En funktion kan alltid anropas från en annan funktion, och tack vara stödet för reflection i C# (som t.ex. C++ saknar) kan funktioner alltid anropas oberoende av var i koden de är deklarerade.

var x = 0;
void i()
{
    x++;
    while (x < 10) 
        i();
}

Motsvarigheten skulle kunna vara något i den här stilen, vilket kräver att variabeln i finns medan den fortfarande deklareras:

var x = 0;
var i = () => {
    x++;
    while (x < 10) 
        i();
};

En av många anledningar till att jag älskar C#: Språkligt stöd för value tuples!

A* (A-star) är en snabb pathfinder-algoritm som kan användas i t.ex. strategispel för att hitta vägar genom labyrinter eller terräng. Christoph Husse publicerade 2010 en briljant implementation i C# som tillåter egna kriterier, definierade i en solver, för kostnaden att flytta sig från en nod till en annan. I följande exempel har jag använt Christophs kod, men jag har skalat bort hans solver och istället hårdkodat in en viktad terräng. Kartan i exemplet är liten, endast 50×25 celler, och kostnaden för att gå på en cell sträcker sig från 0 till 99. De celler som har värdet 100 betraktas som ett oöverstigligt hinder. Bilden visar en körning, där startpositionen är längst ner till vänster.

Det hela utspelar sig i ett vanligt Windows Forms-fönster som har en karta (typen Map) och en stig (typen Path). Både Map och Path presenteras nedan. (De första fyra kodblocken visar alltså innehållet i fönstret, och de resterande kodblocken visar klasserna som används i projektet.)

private Map Map { get; set; }
private Path Path { get; set; }

I fönstrets Load-event skapar jag kartan, kartans terräng och använder sedan klassen som implementerar A* för att hitta den bästa vägen från start (längst ner till vänster) till mål (längst upp till höger). Funktionen FindPath ger null om det inte finns någon väg mellan punkterna.

private void Form1_Load(object sender, EventArgs e)
{
    Map = new Map(50, 25);
    CreateTerrain(Map);
    var aStar = new AStar(Map);
    Path = aStar.FindPath(
        new Point(0, Map.Height - 1),
        new Point(Map.Width - 1, 0))
        ?? new Path();
    Invalidate();
}

Funktionen för att generera terrängen, CreateTerrain, skapar ett godtyckligt bergslandskap.

private void CreateTerrain(Map map)
{
    var rnd = new Random();
    var walkcosts = new int[map.Width + 2, map.Height + 2];
    for (var y = 0; y < map.Height + 2; y++)
        for (var x = 0; x < map.Width + 2; x++)
            if (rnd.Next(0, 3) == 1)
                walkcosts[x, y] = rnd.Next(-10, 300);
    int GetAverage(int[,] a, int x, int y) =>
        (a[x - 1, y - 1] + a[x, y - 1] + a[x + 1, y - 1]
         + a[x - 1, y] + a[x, y] + a[x + 1, y]
         + a[x - 1, y + 1] + a[x, y + 1] + a[x + 1, y + 1]) / 9;
    for (var y = 0; y < map.Height; y++)
    {
        for (var x = 0; x < map.Width; x++)
        {
            var avg = GetAverage(walkcosts, x + 1, y + 1);
            if (avg < 0)
                avg = 0;
            else if (avg > 100)
                avg = 100;
            map.SetWalkCost(x, y, (byte)avg);
        }
    }
}

I fönstrets Paint-event ritas det hela ut på skärmen.

private void Form1_Paint(object sender, PaintEventArgs e)
{
    e.Graphics.Clear(Color.Black);
    var m = new MapRenderer(Map, Path, 24);
    m.Draw(e.Graphics, 0, 0);
}

Klassen MapRenderer som ansvarar för ritandet ser ut så här:

using System.Drawing;
using System.Drawing.Drawing2D;

namespace PathFinderAStar
{
    public class MapRenderer
    {
        public Map Map { get; }
        public Path Path { get; }
        public int CellSize { get; }

        public MapRenderer(Map map, Path path, int cellSize)
        {
            Map = map;
            Path = path;
            CellSize = cellSize;
        }

        public void Draw(Graphics g, int offsetX, int offsetY)
        {
            var xpos = offsetX;
            var ypos = offsetY;
            using (var font = new Font(FontFamily.GenericSansSerif, 8))
            {
                for (var y = 0; y < Map.Height; y++)
                {
                    for (var x = 0; x < Map.Width; x++)
                    {
                        g.SmoothingMode = SmoothingMode.None;
                        g.DrawRectangle(
                            Pens.Gray,
                            xpos,
                            ypos,
                            CellSize,
                            CellSize);
                        using (var b = new SolidBrush(
                            Color.FromArgb(Map.GetWalkCost(x, y) * 2,
                            0,
                            0)))
                            g.FillRectangle(
                                b,
                                xpos + 2,
                                ypos + 2,
                                CellSize - 3,
                                CellSize - 3);
                        var pathCell = Path.GetCellAt(x, y);
                        g.SmoothingMode = SmoothingMode.HighQuality;
                        if (pathCell != null)
                            g.FillEllipse(
                                Brushes.CadetBlue,
                                xpos + 5,
                                ypos + 5,
                                CellSize - 9,
                                CellSize - 9);
                        g.DrawString(
                            Map.GetWalkCost(x, y).ToString(),
                            font,
                            Brushes.White,
                            xpos + 1,
                            ypos + 1);
                        xpos += CellSize;
                    }
                    xpos = offsetX;
                    ypos += CellSize;
                }
            }
        }
    }
}

Klassen Map beskriver en 2-dimensionell karta, på vilken vi ska hitta en stig.

using System;
using System.Diagnostics;
using System.Drawing;

namespace PathFinderAStar
{
    public class Map
    {
        private readonly MapCell[,] _terrain;
        public int Width { get; }
        public int Height { get; }

        public Map(int width, int height)
        {
            if (width < 2 || width > 2000)
                throw new ArgumentOutOfRangeException(nameof(width));
            if (height < 2 || height > 2000)
                throw new ArgumentOutOfRangeException(nameof(height));
            Width = width;
            Height = height;
            _terrain = new MapCell[width, height];
        }

        public byte GetWalkCost(int x, int y)
        {
            if (x < 0 || x >= Width)
                throw new ArgumentOutOfRangeException(nameof(x));
            if (y < 0 || y >= Height)
                throw new ArgumentOutOfRangeException(nameof(y));
            var cell = _terrain[x, y];
            if (cell == null)
                return 0;
            Debug.Assert(cell.X == x);
            Debug.Assert(cell.Y == y);
            return cell.WalkCost;
        }

        public void SetWalkCost(int x, int y, byte walkCost)
        {
            if (x < 0 || x >= Width)
                throw new ArgumentOutOfRangeException(nameof(x));
            if (y < 0 || y >= Height)
                throw new ArgumentOutOfRangeException(nameof(y));
            if (walkCost > 100)
                throw new ArgumentOutOfRangeException(nameof(walkCost));
            var cell = _terrain[x, y];
            if (cell == null)
            {
                cell = new MapCell(x, y, walkCost);
                _terrain[x, y] = cell;
                return;
            }
            Debug.Assert(cell.X == x);
            Debug.Assert(cell.Y == y);
            cell.WalkCost = walkCost;
        }

        public void Clear()
        {
            for (var y = 0; y < Height; y++)
                for (var x = 0; x < Width; x++)
                    _terrain[x, y] = null;
        }

        public MapCell GetCell(int x, int y) =>
            GetCell(new Point(x, y));

        public MapCell GetCell(Point p)
        {
            if (p.X < 0 || p.X >= Width || p.Y < 0 || p.Y >= Height)
                return null;
            var c = _terrain[p.X, p.Y];
            return c;
        }

        public double GetDistance(MapCell start, MapCell goal)
        {
            var actualDistance = Math.Sqrt((start.X - goal.X)
                * (start.X - goal.X)
                + (start.Y - goal.Y)
                * (start.Y - goal.Y));
            return actualDistance + (double)goal.WalkCost / 10;
        }

        public void Add(MapCell cell)
        {
            if (cell == null)
                throw new ArgumentNullException(nameof(cell));
            if (cell.X < 0 || cell.X >= Width)
                throw new ArgumentOutOfRangeException(nameof(cell.X));
            if (cell.Y < 0 || cell.Y >= Height)
                throw new ArgumentOutOfRangeException(nameof(cell.Y));
            if (_terrain[cell.X, cell.Y] != null)
                throw new SystemException();
            _terrain[cell.X, cell.Y] = cell;
        }

        public void Remove(MapCell cell)
        {
            if (cell == null)
                throw new ArgumentNullException(nameof(cell));
            if (_terrain[cell.X, cell.Y] == null)
                throw new SystemException();
            if (_terrain[cell.X, cell.Y] != cell)
                throw new SystemException();
            _terrain[cell.X, cell.Y] = null;
        }

        public bool Contains(MapCell cell) =>
            _terrain[cell.X, cell.Y] != null;

        public void SetWithHistory(int x, int y, MapCell cell) =>
            _terrain[x, y] = cell;

        public bool IsEmpty
        {
            get
            {
                for (var y = 0; y < Height; y++)
                    for (var x = 0; x < Width; x++)
                        if (_terrain[x, y] != null)
                            return false;
                return true;
            }
        }

        public int CompareCells(MapCell c1, MapCell c2)
        {
            if (c1 == null)
                throw new ArgumentNullException(nameof(c1));
            if (c2 == null)
                throw new ArgumentNullException(nameof(c2));
            if (c1.F < c2.F)
                return -1;
            if (c1.F > c2.F)
                return 1;
            return 0;
        }

    }
}

Stigen beskrivs av klassen Path:

using System.Collections.Generic;
using System.Linq;

namespace PathFinderAStar
{
    public class Path : List<MapCell>
    {
        public Path()
        {
        }

        public Path(int count)
        {
            for (var i = 0; i < count; i++)
                Add(null);
        }

        public MapCell GetCellAt(int x, int y) =>
            this.FirstOrDefault(c => c.X == x && c.Y == y);
    }
}

Både kartan (Map) och stigen (Path) består av referenser till celler som beskriver hur terrängen ser ut på en specifik plats. Typen heter MapCell (G, H, F och Index används av A*.):

namespace PathFinderAStar
{
    public class MapCell
    {
        private byte _walkCost;
        public int X { get; }
        public int Y { get; }
        public double G { get; set; }
        public double H { get; set; }
        public double F { get; set; }
        public int Index { get; set; }

        public byte WalkCost
        {
            get => _walkCost;
            set => _walkCost = value > 100 ? (byte)100 : value;
        }

        public bool IsWall =>
            WalkCost >= 100;

        public MapCell(int x, int y, byte walkCost)
        {
            X = x;
            Y = y;
            WalkCost = walkCost;
        }
    }
}

Sen har vi själva A*-algoritmen, såsom den implementerats av Christoph Husse, med mina förenklingar. Den konsumeras direkt i formulärets Load-event och ligger i klassen AStar.

using System.Drawing;

namespace PathFinderAStar
{
    public class AStar
    {
        private Map Map { get; }
        private Map ClosedSet { get; }
        private Map OpenSet { get; }
        private Map CameFrom { get; }
        private Map RuntimeGrid { get; }
        private PriorityQueue OrderedOpenSet { get; }

        public AStar(Map map)
        {
            Map = map;
            ClosedSet = new Map(Map.Width, Map.Height);
            OpenSet = new Map(Map.Width, Map.Height);
            CameFrom = new Map(Map.Width, Map.Height);
            RuntimeGrid = new Map(Map.Width, Map.Height);
            OrderedOpenSet = new PriorityQueue(Map);
        }

        public Path FindPath(Point start, Point goal)
        {
            var startCell = Map.GetCell(start);
            var goalCell = Map.GetCell(goal);
            if (startCell == goalCell)
                return new Path { startCell };
            ClosedSet.Clear();
            OpenSet.Clear();
            CameFrom.Clear();
            RuntimeGrid.Clear();
            OrderedOpenSet.Clear();
            startCell.G = 0.0;
            startCell.H = Map.GetDistance(startCell, goalCell);
            startCell.F = startCell.H;
            OpenSet.Add(startCell);
            OrderedOpenSet.Push(startCell);
            RuntimeGrid.Add(startCell);
            var neighbours = new Path(8);
            while (!OpenSet.IsEmpty)
            {
                var next = OrderedOpenSet.Pop();
                if (next == goalCell)
                {
                    var result = ReconstructPath(
                        CameFrom,
                        CameFrom.GetCell(goalCell.X, goalCell.Y));
                    result.Add(goalCell);
                    return result;
                }
                OpenSet.Remove(next);
                ClosedSet.Add(next);
                StoreNeighbours(next, neighbours);
                foreach (var currentNeighbour in neighbours)
                {
                    if (currentNeighbour == null
                        || currentNeighbour.IsWall
                        || ClosedSet.Contains(currentNeighbour))
                        continue;
                    var tentativeG = RuntimeGrid.GetCell(next.X, next.Y).G
                        + Map.GetDistance(next, currentNeighbour);
                    if (!TentativeIsBetter(currentNeighbour,
                        tentativeG, out var added))
                        continue;
                    CameFrom.SetWithHistory(
                        currentNeighbour.X,
                        currentNeighbour.Y,
                       next);
                    if (!RuntimeGrid.Contains(currentNeighbour))
                        RuntimeGrid.Add(currentNeighbour);
                    currentNeighbour.G = tentativeG;
                    currentNeighbour.H = Map.GetDistance(
                        currentNeighbour,
                        goalCell);
                    currentNeighbour.F = currentNeighbour.G
                        + currentNeighbour.H;
                    if (added)
                        OrderedOpenSet.Push(currentNeighbour);
                    else
                        OrderedOpenSet.Update(currentNeighbour);
                }

            }
            return null;
        }

        private bool TentativeIsBetter(
            MapCell currentNeighbour,
            double tentativeG,
            out bool added)
        {
            if (!OpenSet.Contains(currentNeighbour))
            {
                OpenSet.Add(currentNeighbour);
                added = true;
                return true;
            }
            added = false;
            return tentativeG < RuntimeGrid.GetCell(
                currentNeighbour.X,
                currentNeighbour.Y).G;
        }

        private void StoreNeighbours(MapCell c, Path neighbours)
        {
            neighbours[0] = Map.GetCell(c.X - 1, c.Y - 1);
            neighbours[1] = Map.GetCell(c.X, c.Y - 1);
            neighbours[2] = Map.GetCell(c.X + 1, c.Y - 1);
            neighbours[3] = Map.GetCell(c.X - 1, c.Y);
            neighbours[4] = Map.GetCell(c.X + 1, c.Y);
            neighbours[5] = Map.GetCell(c.X - 1, c.Y + 1);
            neighbours[6] = Map.GetCell(c.X, c.Y + 1);
            neighbours[7] = Map.GetCell(c.X + 1, c.Y + 1);
        }

        private Path ReconstructPath(Map cameFrom, MapCell currentCell)
        {
            void ReconstructPathRecursive(
                Map recursiveCameFrom,
                MapCell recursiveCurrentCell,
                Path result)
            {
                var item = recursiveCameFrom.GetCell(
                    recursiveCurrentCell.X,
                    recursiveCurrentCell.Y);
                if (item != null)
                    ReconstructPathRecursive(
                        recursiveCameFrom,
                        item,
                        result);
                result.Add(recursiveCurrentCell);

            }
            var path = new Path();
            ReconstructPathRecursive(cameFrom, currentCell, path);
            return path;
        }
    }
}

Och slutligen, typen PriorityQueue som algoritmen använder för att hålla reda på vilka celler som undersöks, ser ut så här:

using System.Collections.Generic;

namespace PathFinderAStar
{
    public class PriorityQueue
    {
        private List<MapCell> InnerList { get; } = new List<MapCell>();
        private Map Map { get; }

        public PriorityQueue(Map map)
        {
            Map = map;
        }

        public void Clear() =>
            InnerList.Clear();

        public int Push(MapCell c)
        {
            var index1 = InnerList.Count;
            c.Index = index1;
            InnerList.Add(c);
            do
            {
                if (index1 <= 0)
                    break;
                var index2 = (index1 - 1) / 2;
                if (Compare(index1, index2) < 0)
                {
                    SwitchElements(index1, index2);
                    index1 = index2;
                    continue;
                }
                break;

            } while (true);
            return index1;
        }

        public MapCell Pop()
        {
            var result = InnerList[0];
            InnerList[0] = InnerList[InnerList.Count - 1];
            InnerList[0].Index = 0;
            InnerList.RemoveAt(InnerList.Count - 1);
            result.Index = -1;
            var p = 0;
            do
            {
                var pn = p;
                var p1 = 2 * p + 1;
                var p2 = 2 * p + 2;
                if (InnerList.Count > p1 && Compare(p, p1) > 0)
                    p = p1;
                if (InnerList.Count > p2 && Compare(p, p2) > 0)
                    p = p2;
                if (p == pn)
                    break;
                SwitchElements(p, pn);
            } while (true);
            return result;
        }

        public void Update(MapCell cell)
        {
            var count = InnerList.Count;
            while (cell.Index - 1 > 0
                && Compare(cell.Index - 1, cell.Index) > 0)
                SwitchElements(cell.Index - 1, cell.Index);
            while (cell.Index + 1 < count
                && Compare(cell.Index + 1, cell.Index) < 0)
                SwitchElements(cell.Index + 1, cell.Index);
        }

        private int Compare(int i1, int i2) =>
            Map.CompareCells(InnerList[i1], InnerList[i2]);

        private void SwitchElements(int i1, int i2)
        {
            var c1 = InnerList[i1];
            InnerList[i1] = InnerList[i2];
            InnerList[i2] = c1;
            InnerList[i1].Index = i1;
            InnerList[i2].Index = i2;
        }
    }
}

Med denna kod på plats har man en enkel funktion (FindPath) att anropa för att hitta en stig mellan två punkter (om sådan finns). Och om man vill anpassa kriterierna för hur en stig väljs, t.ex. hur terrängen ska viktas mot avståndet, görs det i funktionen GetDistance i klassen Map.

IMDb Scraper is a simple library for extracting a movie title and year from a IMDb ID.

Installation (.NET Framework 4.6):

Install-Package ImdbScraper

Example:

var repository = new Repository();
var result = repository.GetMovie(87332);
Console.WriteLine(result.ToString());

Update 2023-06-18: The scraper now requires .NET 7.0, and it also downloads the movie rating from imdb.com.

Jag har skrivit fem inlägg om C# på Nethouse blogg som jag tänkte be att få dela med mig av.

Kortare kod med mönstermatchning i C# 7

Förenklad hantering av funktioner som producerar multipla värden i C#

Skalning i MonoGame

Late binding i C#

Lazy evaluated string interpolation

Uppdatering 2017-09-22:

Kort kod och syftningsfel

Uppdatering 2018-01-26:

Microsoft Cognitive Services: Computer Vision

Entity Framework 6 (EF6) är mycket enkelt att komma igång med. För att få tillgång till aktuell version, använd Nuget-paketet EntityFramework. Den här bloggposten visar det minsta man behöver veta för att komma igång med EF6 i sitt program.

Install-Package EntityFramework

Dessutom behöver du ha en tom databas att jobba mot. I detta exempel antar jag att databasen heter EfTest. Anslutningssträngen lagras i konfigurationsfilen. I mitt fall är det en vanlig Console Application.

  <connectionStrings>
    <add name="EfTest" providerName="System.Data.SqlClient" connectionString="Data Source=XXX;Initial Catalog=EfTest;Integrated Security=True" />
  </connectionStrings>

Nästa steg är att skapa DbContext-objektet. Denna ärver från System.Data.Entity.DbContext. Basklassen behöver veta vilken anslutningssträng som ska användas. Antingen skickar man in själva anslutningssträngen, eller så hänvisar man till ett namn. De tabeller som ska användas beskrivs av klasser och väljs in som argument till den generiska DbSet (också i System.Data.Entity). Här har jag helt enkelt skapat två klasser som heter Tabell1 och Tabell2.

    public class TestContext : DbContext
    {
        public TestContext() : base("name=EfTest")
        {
        }
        public DbSet<Tabell1> Tabell1 { get; set; }
        public DbSet<Tabell2> Tabell2 { get; set; }
    }

Låt oss titta på klassen Tabell1. Den innehåller en primärnyckel (int) och en sträng som heter Value. Attributet Key på fältet (System.ComponentModel.DataAnnotations) anger att motsvarande kolumn i databasen är en primärnyckel. Attributet DatabaseGenerated (System.ComponentModel.DataAnnotations.Schema) använder jag här för att säga att kolumnen ska vara en räknare, och alltså inte något som jag ska tillhandahålla data till vid tillägg. Det innebär alltså att nya poster skapas genom att Value får ett värde, inte Tabell1Id.

    using (var db = new TestContext())
    {
        db.Tabell1.Add(new Tabell1 {Value = "Hej"});
        db.SaveChanges();
    }

När tabellen läses av, kan man konstatera att nyckelkolumnen i detta fall ska ha fått sitt värde ändå.

    using (var db = new TestContext())
    {
        foreach (var tabell1 in db.Tabell1)
        {
            Console.WriteLine($"{tabell1.Tabell1Id} - {tabell1.Value}");
        }
    }

Det är när programmet körs första gången som databasen byggs upp automatiskt. Om en befintlig tabell förändras, t.ex. genom att klassen Tabell1 får en till property (vilket motsvarar en till kolumn) kommer programmet inte längre att fungera. Då måste en strategi för uppgradering tillhandahållas. T.ex. kan man säga att databasschemat helt enkelt ska genereras om vid förändring. Det innebär att man förlorar allt data, så med denna strategi vill man förmodligen komplettera med kod som lägger in lite testdata.

Database.SetInitializer(new DropCreateDatabaseIfModelChanges<TestContext>());

För att tillhandahålla testdata, skriv en egen initializer, baserad på den som du vill använda, och tillhandahåll testdata i funktionen Seed.

    public class DropCreateInitializer : DropCreateDatabaseIfModelChanges<TestContext>
    {
        protected override void Seed(TestContext context)
        {
            context.Tabell1.Add(new Tabell1 { Value = "Hej" });
            context.Tabell1.Add(new Tabell1 { Value = "Oj" });
        }
    }

Sen är det bara att använda sin egna initializer.

Database.SetInitializer(new DropCreateInitializer());

Jag har börjat arbeta med ett datorspel i kategorin roguelike. Varje spel ska vara unikt, så kartan genereras när en användare spelar spelet. Vid uppstart skapar jag en labyrint som sen används som kontur för rummen som genereras efter behov. De rum som spelaren inte besöker behöver man trots allt inte hålla i RAM, men jag vill ha konturen färdig för att kunna ha lite kontroll över kartans kvalité.

    private void Form1_Paint(object sender, PaintEventArgs e)
    {
        const int size = 20;
        for (var y = 0; y < Labyrinth.Height; y++)
            for (var x = 0; x < Labyrinth.Width; x++)
            {
                if (Labyrinth.Cells[x, y].WallEast)
                    e.Graphics.DrawLine(Pens.Black, x * size + (size - 1), y * size, x * size + (size - 1), y * size + (size - 1));
                if (Labyrinth.Cells[x, y].WallSouth)
                    e.Graphics.DrawLine(Pens.Black, x * size, y * size + (size - 1), x * size + (size - 1), y * size + (size - 1));
            }
    }

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        private Labyrinth Labyrinth { get; } = new Labyrinth();
        public Form1()
        {
            InitializeComponent();
        }

    private void Form1_Paint(object sender, PaintEventArgs e)
    {
        const int size = 20;
        for (var y = 0; y < Labyrinth.Height; y++)
            for (var x = 0; x < Labyrinth.Width; x++)
            {
                if (Labyrinth.Cells[x, y].WallEast)
                    e.Graphics.DrawLine(Pens.Black, x * size + (size - 1), y * size, x * size + (size - 1), y * size + (size - 1));
                if (Labyrinth.Cells[x, y].WallSouth)
                    e.Graphics.DrawLine(Pens.Black, x * size, y * size + (size - 1), x * size + (size - 1), y * size + (size - 1));
            }
    }
    }
    public class Cell
    {
        public bool WallNorth { get; set; } = true;
        public bool WallEast { get; set; } = true;
        public bool WallSouth { get; set; } = true;
        public bool WallWest { get; set; } = true;
        public int X { get; }
        public int Y { get; }
        public Cell(int x, int y)
        {
            X = x;
            Y = y;
        }
        public int WallsCount
        {
            get
            {
                var c = WallNorth ? 1 : 0;
                c += WallEast ? 1 : 0;
                c += WallSouth ? 1 : 0;
                c += WallWest ? 1 : 0;
                return c;
            }
        }
        public Point Position => new Point(X, Y);
    }
    public class Labyrinth
    {
        public static int Width { get; } = 10;
        public static int Height { get; } = 10;
        public Cell[,] Cells = new Cell[Width, Height];
        public Labyrinth()
        {
            var rnd = new Random();
            for (var y = 0; y < Height; y++)
                for (var x = 0; x < Width; x++)
                    Cells[x, y] = new Cell(x, y);
            Func<int, int, List<Point>> getNeighbours = (x, y) =>
            {
                var ret = new List<Point>();
                if (y > 0 && Cells[x, y - 1].WallsCount >= 4)
                    ret.Add(Cells[x, y - 1].Position);
                if (x < Width - 1 && Cells[x + 1, y].WallsCount >= 4)
                    ret.Add(Cells[x + 1, y].Position);
                if (y < Height - 1 && Cells[x, y + 1].WallsCount >= 4)
                    ret.Add(Cells[x, y + 1].Position);
                if (x > 0 && Cells[x - 1, y].WallsCount >= 4)
                    ret.Add(Cells[x - 1, y].Position);
                return ret;
            };
            Action<Cell, Point> knockWall = (cell1, cell2) =>
            {
                if (cell2.Y < cell1.Y)
                {
                    cell1.WallNorth = false;
                    Cells[cell2.X, cell2.Y].WallSouth = false;
                    return;
                }
                if (cell2.X > cell1.X)
                {
                    cell1.WallEast = false;
                    Cells[cell2.X, cell2.Y].WallWest = false;
                    return;
                }
                if (cell2.Y > cell1.Y)
                {
                    cell1.WallSouth = false;
                    Cells[cell2.X, cell2.Y].WallNorth = false;
                    return;
                }
                if (cell2.X < cell1.X)
                {
                    cell1.WallWest = false;
                    Cells[cell2.X, cell2.Y].WallEast = false;
                    return;
                }
            };
            var queue = new Queue<Cell>();
            var c = Cells[rnd.Next(Width), rnd.Next(Height)];
            queue.Enqueue(c);
            while (queue.Count > 0)
            {
                var neighbours = getNeighbours(c.X, c.Y);
                if (neighbours.Count > 0)
                {
                    var neighbour = neighbours[rnd.Next(neighbours.Count)];
                    knockWall(c, neighbour);
                    queue.Enqueue(c);
                    c = Cells[neighbour.X, neighbour.Y];
                }
                else
                {
                    c = queue.Dequeue();
                }
            }
        }
    }
}

Till en viss grad har man kunnat skapa lokala funktioner i C# under en tid.

public void DoSomething()
{
    Func<int, int> d = (x) => x * 2;
    for (var i = 1; i <= 8; i++)
        Console.WriteLine(d(i));
}

I C# 7 kan man skapa fullvärdiga funktioner i en annan funktion. Det enda som egentligen skiljer en lokal funktion från en medlemsfunktion (eller en static) är att lokala funktioner inte har någon angiven synlighet, eftersom det inte är relevant.

public void DoSomething()
{
    int d(int x) => x * 2;
    for (var i = 1; i <= 8; i++)
        Console.WriteLine(d(i));
}

Fördelen med riktiga lokala funktioner är att det ger tillgång till parameterarrayer, referensparametrar, utparametrar och generics, alltså sådant som inte kunde användas i gamla inline-funktioner.

Closure-hanteringen är lite intressant. Följande exempel använder bara gammal C# och kompilerar inte, eftersom variabeln MinFunktion som håller inlinefunktionen inte finns än.

public void DoSomething()
{
    MinFunktion();
    int x = 10;
    Action MinFunktion = () => x++;
    Console.WriteLine(x);
}

Om vi istället flyttar ner anropet, skrivs 11 ut på skärmen, eftersom x ökas med 1 i MinFunktion.

public void DoSomething()
{
    int x = 10;
    Action MinFunktion = () => x++;
    MinFunktion();
    Console.WriteLine(x);
}

Resultatet blir detsamma om jag ersätter MinFunktion med en fullvärdig lokal funktion. Det x som ökas i MinFunktion är en closure.

public void DoSomething()
{
    int x = 10;
    void MinFunktion() => x++;
    MinFunktion();
    Console.WriteLine(x);
}

Men detta är riktigt intressant. Eftersom MinFunktion nu är en fullvärdig funktion, så skapas den i den yttre funktionen DoSomething vid kompilering. Så nu kan jag anropa den innan variabeln x finns.

public void DoSomething()
{
    MinFunktion();
    int x = 10;
    void MinFunktion() => x++;
    Console.WriteLine(x);
}

Svaret blir då 10, eftersom det inte är closure-variabeln x som blir ökad, utan en x som är lokal för MinFunktion.

Slutligen, eftersom lokala funktioner är fullvärdiga funktioner, kan de innehålla egna lokala funktioner. Snyggt!

Så vad fungerar inte?

Generellt sett kan en värdetyp inte innehålla null, men en referenstyp kan innehålla null. Detta är vettigt, eftersom en referenstyp innehåller just en referens som kan vara eller inte vara satt.

Vi har haft nullable types i C# en tid nu. Det är en struktur som ger värdetyper en null-flagga, så att dessa kan vara null.

public int X { get; set; } //Ej initierad - innehåller 0.
public int? Y { get; set; } //Ej initierad - innehåller null.

Snart ska man kunna förhindra referenstyper från att vara null, vilket är praktiskt t.ex. om man vill att en parameter ska vara obligatorisk. Troligen kommer det att se ut ungefär så här:

public MyType A { get; set; } //Kan innehålla null
public MyType! B { get; set; } = new MyType(); //Kan inte innehålla null

C# 7 ska ha visst stöd för pattern matching, men det fungerar inte (än).

Inte heller record types fungerar. Record types är klasser som endast innehåller properties, som deklareras med en enda rad kod.

Det finns alltså anledning att titta med på C# 7 längre fram.

Hårdvarurenderade sprites i C#:

Github: https://github.com/r1sc/Sprite
Nuget: https://www.nuget.org/packages/Sprite/

…och så några “bloopers“…

To parse T-SQL from C#, add a reference to the following libraries (listed under Extensions, not under Framework):

Microsoft.Data.Schema.ScriptDom
Microsoft.Data.Schema.ScriptDom.Sql

My examples imports the following namespaces:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Data.Schema.ScriptDom;
using Microsoft.Data.Schema.ScriptDom.Sql;
using System.IO;

This code shows how to parse a boolean expression:

//Parse
var p = new TSql100Parser(false);
IList<ParseError> err;
var sql = "(a > 10) and (i < 10)";
var exp = p.ParseBooleanExpression(new StringReader(sql), out err);

//Errors? Empty if none.
Console.WriteLine($"{err.Count} errors.");
err.ToList().ForEach(x =>
   Console.WriteLine(
      $"Error \"{x.Message}\" at line {x.Line}."));

//Result. Null if errors.
if (!(exp == null))
   exp.ScriptTokenStream.ToList().ForEach(x =>
      Console.WriteLine(
         $"Token type: {x.TokenType}, source: {x.Text}"));

If you want to parse a complete Transact SQL program, call the ParseStatementList function instead of the ParseBooleanExpression function.

//Parse
var p = new TSql100Parser(false);
IList<ParseError> err;
var sql = "SELECT EmployeeID, FirstName FROM dbo.Employees WHERE FirstName LIKE 'N%'";
var exp = p.ParseStatementList(new StringReader(sql), out err);

Console.WriteLine($"{err.Count} errors.");
err.ToList().ForEach(x =>
   Console.WriteLine(
      $"Error \"{x.Message}\" at line {x.Line}."));

//Result. Null if errors.
if (!(exp == null))
   exp.ScriptTokenStream.ToList().ForEach(x =>
      Console.WriteLine(
         $"Token type: {x.TokenType}, source: {x.Text}"));

This is the expected output:

Jag fick en fråga om att räkna ut snittvärden. Det finns olika sätt att lösa det på, där det enklaste kanske är att använda Excel för att göra ett enkelt datablad. Jag tänkte visa hur man kan göra i C# för att få en start till ett registerprogram. För detta använder jag Visual Studio 2015 Community Edition som kan laddas hem gratis här. Välj att skapa ett nytt projekt.

Jag kör mot .NET Framework 4.5.2 (1) och har valt kategorin Windows under C# (2) och projekttypen Console Application (3). Se till att välja ett lämpligt projektnamn och en lämplig plats att spara projektet på (4). Sen är det bara att börja skriva.

Här har vi den grundläggande principen:

         //Några flyttal att beräkna snitt på.
         double[] tal = { 3.0, 4.0, 1.5, 2.0 };

         //Summera talen.
         var summa = 0.0;
         for (int i = 0; i < tal.Length; i++)
            summa += tal[i];

         //Dividera med antalet.
         var snitt = summa / tal.Length;

         //Presentera resultatet.
         Console.WriteLine(snitt);

         //Pausa tills användaren trycker Enter.
         Console.ReadLine();

Vi borde nu se att snittet av 3.0, 4.0, 1.5 och 2.0 är 2.625.

Eftersom vi har tillgång till namnrymden System.Linq så kan vi använda en inbyggd funktion för att räkna ut snittet. Detta ger samma resultat:

         //Några flyttal att beräkna snitt på.
         double[] tal = { 3.0, 4.0, 1.5, 2.0 };

         //Be om snittet.
         var snitt = tal.Average();

         //Presentera resultatet.
         Console.WriteLine(snitt);

         //Pausa tills användaren trycker Enter.
         Console.ReadLine();

Detta kan vi applicera om vi bygger en struktur som innehåller ett flyttal. Följande kod beskriver ett musikalbum med låtar. Låtarna har ett betyg mellan 1 och 10, och deras snitt ger oss ett betyg på musikalbumet.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Snitt
{
   class Program
   {
      static void Main(string[] args)
      {
         //Konstruera ett album.
         var a = new Album() { AlbumName = "A Night at the Opera",
                               ArtistName = "Queen" };
         //Lägg på låtar.
         a.Songs.Add(new Song() { TrackNumber = 1,
                                  TrackName = "Death on Two Legs",
                                  Rating = 7.0 });
         a.Songs.Add(new Song() { TrackNumber = 2,
                                  TrackName = "Lazing on a Sunday Afternoon",
                                  Rating = 4.0 });
         a.Songs.Add(new Song() { TrackNumber = 3,
                                  TrackName = "I'm in Love with My Car",
                                  Rating = 6.0 });

         //Hämta låtarnas betyg.
         var ratings = (from s in a.Songs
                       select s.Rating).ToArray();

         //Hämta ut låtarnas snittvärde och avrunda.
         var snitt = Math.Round(ratings.Average(), 2);

         //Presentera resultatet.
         Console.WriteLine(snitt);

         //Pausa tills användaren trycker Enter.
         Console.ReadLine();
      }
   }

   //Definiera en låt.
   public class Song
   {
      public int TrackNumber { get; set; }
      public string TrackName { get; set; }
      public double Rating { get; set; }
   }

   //Definiera ett musikalbum
   public class Album
   {
      public string ArtistName { get; set; }
      public string AlbumName { get; set; }
      public List<Song> Songs { get; set; } = new List<Song>();
   }
}

Detta ger oss svaret 5.67.

Klasserna Song och Album kan användas som en del av en Windows-applikation med ett grafiskt användargränssnitt. Projekttypen skulle kunna vara en Windows Forms Application. Att sammanställa en sådan applikation är ett ganska stort och tidskrävande projekt. En album-lista ska skapas, serialisering och deserialisering ska implementeras och det grafiska användargränssnittet ska byggas.