C# – SmattyCore

Erweiterungsmethoden oder im englischen Extension Methods sind dazu gedacht, vorhandenen Datentypen, zum Beispiel string, int, float, etc., Methoden hinzufügen zu können. Erweiterungsmethoden sind statische Methoden und können verwendet werden, ohne den Datentyp abzuleiten oder kompilieren zu müssen.

Damit diese Erweiterungsmethoden beim jeweiligen Datentyp zur Verfügung stehen muss in diesem Bereich die using-Direktive verwendet werden.

namespace ExtensionMethods
{
    public static class MyExtensions
    {
        public static int WordCount(this String str)
        {
            return str.Split(new char[] { ' ', '.', '?' }, 
                             StringSplitOptions.RemoveEmptyEntries).Length;
        }
    }   
}

namespace ExtensionMethods

{

public static class MyExtensions

{

public static int WordCount(this String str)

{

return str.Split(new char[] { ' ', '.', '?' },

StringSplitOptions.RemoveEmptyEntries).Length;

}

Wie man sieht handelt es sich um eine statische Klasse und um statische Methoden. Die Besonderheit ist als Parameter versteckt und zwar (wichtig) als erster Parameter. Dieser gibt nämlich an, für wen diese Methode gilt. An dieser Stelle wird zudem der this-Modifizierer verwendet. In unserem Beispiel können wir in der Methode str verwenden wobei str für den String steht, auf den man diese Methode anwenden möchte. Man kann auch weitere Parameter an die Methode übergeben, dass sieht dann wie folgt aus:

namespace ExtensionMethods
{
    public static class MyExtensions
    {
        public static int WordCount(this String str, StringSplitOptions stringSplitOptions)
        {
            return str.Split(new char[] { ' ', '.', '?' }, 
                             stringSplitOptions).Length;
        }
    }   
}

namespace ExtensionMethods

{

public static class MyExtensions

{

public static int WordCount(this String str, StringSplitOptions stringSplitOptions)

{

return str.Split(new char[] { ' ', '.', '?' },

stringSplitOptions).Length;

}

Der Einfachheit halber habe ich das exakt selbe Beispiel verwendet und so angepasst, dass wir die StringSplitOptions als Parameter mit übergeben müssen. Im Quellcode sieht es so aus als wäre es der zweite Parameter, tatsächlich gibt es beim Aufruf später nur einen Parameter, nämlich die stringSplitOptions.

Damit wir auf Strings nun diese Methode aufrufen können, benötigen wir noch die using-Direktive:

using ExtensionMethods;

1	using ExtensionMethods;

Nun können wir die Erweiterungsmethode wie folgt verwenden:

string s = "Hello Extension Methods";  
int i = s.WordCount();

1 2	string s = "Hello Extension Methods"; int i = s.WordCount();

Verwenden wir die Variante 2 mit StringSplitOptions als Parameter würde man die Methode so verwenden:

string s = "Hello Extension Methods";  
int i = s.WordCount(StringSplitOptions.RemoveEmptyEntries);

1 2	string s = "Hello Extension Methods"; int i = s.WordCount(StringSplitOptions.RemoveEmptyEntries);

Ein Teil der Quellcodes stammt von der Microsoft-Webseite und sind hier zu finden: https://docs.microsoft.com/de-de/dotnet/csharp/programming-guide/classes-and-structs/extension-methods

Mit dieser Serie möchte ich gerne hin und wieder ein paar Dinge bezüglich der In-Game Programmierung in Space Engineers behandeln um Leuten die In-Game Programmierung, welche in C# erfolgen muss, nahe zu bringen. Zuerst einmal lautet die Frage warum überhaupt C#? Die Entwickler von Space Engineers entwickelten im Laufe der Zeit ihre eigene Engine, genannt VRAGE. Space Engineers und auch Medieval Engineers verwenden VRAGE 2.0, die älteren MinerWars Teile hingegen die VRAGE 1.0. Die VRAGE Engine wiederum basierte ursprünglich auf XNA, Microsoft Framework für Spieleentwicklung in C#. Marek Rosa, CEO und Founder der Keen Software House Firma, welche diese Spiele entwickeln kommentierte auf Facebook einen Eintrag zum Thema XNA:

Marek Rosa FireFox Bancroft: we abandoned XNA more than year ago. Now it’s DirectX only

25. März 2014 um 07:40

C# ist eine Programmiersprache die generell nur auf dem Windows Betriebssystem läuft obwohl es das sogenannte Mono-Projekt gibt, welches C# ebenso auf Linux und Mac lauffähig macht, zumindest rudimentär. Die Unity Engine verwendet Mono um C# Skripts zu kompilieren. Aber das nur als kleinen Einstieg und background information, zurück zum eigentlichen Thema: Programmierung in Space Engineers.

In Space Engineers (von nun an abgekürzt durch SE) gibt es einen Block namens: Programmierbarer Block (orig.: Probammable Block). Hat man diesen Block auf einem kleinen- oder großen Schiff oder auf einer Station platziert kann man diesen mit K öffnen und dann den Code bearbeiten oder ausführen lassen. Ich schreibe den Code vorher aber ganz gerne in einem Editor, weil man dann die offizielle Dokumentation zur In-Game Programmierung geöffnet lassen und nachschauen kann. Danach ein einfaches Copy & Paste, wo dann im Spiel der Code überprüft und ggf. korrigiert werden kann. Hier der link zur offiziellen Dokumentation, zur Zeit nur auf Englisch verfügbar:

Official Guide: Programmable Block

Anmerken sollte ich noch, dass nicht alles aus C# auch automatisch in SE nutzbar ist. Zum Zeitpunkt wo ich diesen Artikel schreibe sind noch Probleme bekannt, welche auch im offiziellen Guide erwähnt werden. Unter anderem gibt es bei manchen Systemkonfigurationen, hauptsächlich 64-bit Systeme, Probleme bei foreach-Loops. for-Loops sind aber möglich und müssen stattdessen verwendet werden.

Jedes Programm benötigt einen Einstiegspunkt, einen Punkt der dem Programm bekannt sein muss. Und in dem C# Fall und ebenso auch in SE ist dies eine Methode namens Main. Unser komplett leeres Grundgerüst sieht also wie folgt aus:

void Main
{
	//Hier kommt später unser Code rein
}

void Main

{

//Hier kommt später unser Code rein

}

Innerhalb der geschweiften Klammern müssen wir unseren Code, die Logik reinschreiben. // markiert die gesamte Zeile als Kommentar und wird vom Compiler nicht berücksichtigt. Zudem können Kommentare auch so aussehen:

void Main
{
	/*
	 * Hier kommt später unser Code rein
	 * Und dies ist ein mehrzeiliger
	 * Kommentar.
	*/
}

void Main

{

* Hier kommt später unser Code rein

* Und dies ist ein mehrzeiliger

* Kommentar.

}

Der nächste wichtige Aspekt ist zu wissen wie wir Zugriff auf die Blöcke bekommen. Im übrigen ist es aktuell nur möglich Zugriff auf die Blöcke zu bekommen, welche auf demselben Grid sind wie der programmierbare Block. In einem früheren Blogeintrag von Marek Rosa (hier, Inspiration: hier), konnte ich ihn zu einigen Dingen inspirieren die hoffentlich, bald ins Spiel aufgenommen werden. Auf das Grid bekommen wir über GridTerminalSystem Zugriff. Dabei gibt es drei Möglichkeiten Blöcke zu bekommen.

GetBlocksOfType<T>: Bei dieser Methode können wir alle Blöcke eines bestimmten Typs abrufen. Die Typen sind unterschiedlich. Jeder Block hat seinen eigenen Typ (Antenne, Leuchtfeuer, Bohrer, etc.). Zudem haben alle Blöcke aber zwei gemeinsame Typen die vererbt werden. Diese sind IMyCubeBlock und IMyTerminalBlock.
SearchBlocksOfName: Bei dieser Methode können wir alle Blöcke die einen bestimmten Namen haben abrufen. Zum Beispiel nennen wir die Blöcke alle Light, dann würden wir all diese Blöcke bekommen. Komplet typenunabhängig.
GetBlockWithName: Wie SearchBlocksOfName, nur rufen wir bei dieser Methode nur einen einzigen Block und keine Liste von Blöcken ab.

Die Blöcke dir wir dann von der Methode erhalten müssen aber zwischengespeichert werden. Dieses machen wir mit Listen. Nun folgen drei Beispiele, jeweils ein Beispiel zu jeder Methode die oben beschrieben ist.

List<IMyTerminalBlock> blocks = new List<IMyTerminalBlock>();

void Main() 
{ 
	GridTerminalSystem.GetBlocksOfType<IMyTerminalBlock>(blocks);
}

List<IMyTerminalBlock> blocks = new List<IMyTerminalBlock>();

void Main()

{

GridTerminalSystem.GetBlocksOfType<IMyTerminalBlock>(blocks);

}

List<IMyTerminalBlock> blocks = new List<IMyTerminalBlock>();

void Main() 
{ 
	GridTerminalSystem.SearchBlocksOfName("Lights", blocks);
}

List<IMyTerminalBlock> blocks = new List<IMyTerminalBlock>();

void Main()

{

GridTerminalSystem.SearchBlocksOfName("Lights", blocks);

}

IMyTerminalBlock block;

void Main() 
{ 
	GridTerminalSystem.GetBlockWithName("Light", block);
}

IMyTerminalBlock block;

void Main()

{

GridTerminalSystem.GetBlockWithName("Light", block);

}

Im letzten Code-Beispiel verwende ich keine Liste, da wir ja nur einen Block abrufen. Zu erwähnen ist hier, dass wir aber lieber unsere Variablen “leeren”, bevor wir das GridTerminalSystem verwenden. Dies würden wir bei Listen wie folgt tun:

blocks.Clear();

1	blocks.Clear();

In der kommenden Zeit werde ich des Öfteren Skripte posten und diese erklären und auch im Steam Workshop zur Verfügung stellen.

C# Extension Methods / Erweiterungsmethoden

[Space Engineers/C#] In-Game Programming – Teil 1