Passwort des MACs vergessen?

Kurze einfache Anleitung um einen neuen Benutzer mit Administrationsrechten auf einem MAC zu erstellen.

  1. Power-On
  2. Sofort ⌘S gedrückt halten (Einzelbenutzermodus)
  3. Root mounten: mount -uaw /
  4. Setup-Datei löschen: rm /var/db/.AppleSetupDone
  5. reboot

Nun wird das Setup der Erstinstallation nochmals durchgeführt. Ein paar klicks und man kann den neuen Benutzer erstellen.

C# events ein bisschen #er

Die Standardimplementation von Events wird hier nicht behandelt.

Das neue Generic EventHandler<T>

Bei den meisten Events handelt es sich um standardmässig Implementationen mit den Definitionnen einer delegate als EventHandler, einem Event und den EvengArgs (oder einer Ableitung davon). Hier bietet bereits C# 2.0 eine Vereinfachung durch das Generic delegate EventHandler<TEventArgs>. Der zu definierende EventHandler kann mit dieser generischen delegate ersetzt werden. Nun wird die Definition eines Events einfacher und theoretisch auf einer einzigen Zeile möglich.

Beispiel:

public class PropertyChangedEventArgs : EventArgs { }
public event EventHandler<PropertyChangedEventArgs> PropertyChanged;

Events registrieren

Früher musste man die Events mit komplettem Syntax registrieren:

this.MyLinkControl.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.MyLinkControl_LinkClicked);

Hier die Kurzform:

this.MyLinkControl.EnterPress += this.MyLinkControl_EnterPress;

Die Event Accessors

Das ist ein wirklich cooles Feature. Standardmässig werden die Accessoren implizit vom Kompiler bei der Defintion erzeugt.

public event EventHandler PropertyChanged;

Möchte man nun die Accessoren selber manipulieren können, muss man den automatisch erzeugten Code vom Kompiler einfach selber schreiben.

Beispiel:

private EventHandler _propertyChanged;
public event EventHandler PropertyChanged
{
add { _propertyChanged += value; }
remove { _propertyChanged -= value; }
}

Nun ist es problemlos möglich noch Aktionen durchzuführen, bevor ein Event angehängt resp. wieder entfernt wird.

Veröffentlicht unter Coding | Verschlagwortet mit ,

TotalCommander vs. Windows Standard Tools

Es gibt immer wieder Leute, die die Vorteile des Total Commanders (TC) nicht kennen und kommen von den Windows Tools nicht los. Ich versuche in diesem Artikel die Hauptfeatures vom Total Commander kurz vorzustellen.

Der Total Commander ist meines Erachtens eines der momentan besten und hilfreichsten Tools auf dem Markt. Mit einer Lizenzgebühr von ca. 40.- ist er zudem äusserst preiswert.

Alle unten beschriebenen Kurztasten, können in der Konfiguration der Software benutzerspezifisch angepasst werden. Weiterlesen

Extension Methods

Mit Extension Methods können bestehende Typen mit zusätzlichen Methoden erweitert werden. Diese Methoden sehen aus wie Instanz-Methoden, sind jedoch statische Methoden einer Hilfsklasse.

Sie haben einen speziellen Syntax. Der erste Parameter einer Extension Methode kennzeichnet die jeweilige Klasse, die erweitert werden soll. Zudem muss er mit this markiert werden. Zudem muss die Klasse, welche die Extension Methode behinhaltet und auch die Methode statisch sein.

Beispie zur Erweiterung der string-Klasse:

public static class StringExtensions
{
public static bool StartsWithUpperCase(this string value)
{
if (value.Length > 0) return char.IsUpper(value[0]);
return false;
}
}

Danach kann die Methode benutzt werden:

string s = „Test“;
bool b = s.StartsWithUpperCase();

Was macht der Compiler im Hintergrund? Schauen wir uns das Code-Stück davon mal in IL-Code an:

.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// Code size 20 (0x14)
.maxstack 1
.locals init ([0] string s)
IL_0000: nop
IL_0001: ldstr „Hallo“
IL_0006: stloc.0
IL_0007: ldloc.0
IL_0008: call string MyApp.StringExtensions::TimWhiteSpaces(string)
IL_000d: callvirt instance string [mscorlib]System.String::ToUpper()
IL_0012: stloc.0
IL_0013: ret
} // end of method Program::Main

Die Extension Methode wird ganz normal als Klassenmethode aufgerufen. War ja nicht anders zu erwarten. Die Extenstion Methoden sind somit nur eine Hilfe für faule Programmierer :-).

Method Chaining

In vielen Fällen ist es hilfreich, wenn man das Method Chaining unterstützt. Dies bedeutet, dass man anstelle von void den jeweiligen Typen wieder zurückgibt.

public static class StringExtensions
{
public static string TimWhiteSpaces(this string value)
{
return value.Trim(‚ ‚, ‚\t‘, ‚\r‘, ‚\n‘);
}
}

Somit können auf dem Rückgabe-Objekt weitere Methoden aufgerufen werden:

string s = „\tTest  „;
s = s.TimWhiteSpaces().ToUpper();

Meine Empfehlung

Extension Methods sind cool – nichts desto trotz verschlechtern sie meines Erachtens eher das Software-Design. Im Hintergrund bleibt alles beim Alten. Es wird dem Entwickler einfach vorgegaukelt, es handle sich um eine Instanzmethode. Zudem kann es häufig der Fall sein, dass man in einem Modul eine Extension Methode benutzen möchte (an welche man sich gewöhnt hat), diese jedoch nicht auffindbar ist. Dann geht die Suche los, in welche Klasse sich diese Methode befinden, damit man sie inkludieren und benutzen kann. Soweit ich weiss, hat Microsoft die Extension Methoden eingeführt, damit LINQ gut ins Framework integriert werden konnte. Ich empfehle somit, alle eigenen Extenstion Methoden in ein spezielles Assembly auszulagern und nur zu verwenden, wenn es die Arbeit massiv erleichtet.
Veröffentlicht unter Coding | Verschlagwortet mit ,

Lambda Expressions

Die Lambda Expressions sind ein neues Feature von C# 3.0. Sie stellen Funktionen dar, die zur Laufzeit bereits kompiliert worden sind oder kompiliert werden können. Überall wo man in C# 2.0 eine Delegate schreiben musste, kann man in C# 3.0 auch eine Lambda Expressions benutzen.

Ohne grosse verbale Abhandlungen, versuche ich den Syntax von Lambda an ein paar einfachen Beispielen zu erklären…

Beispiel einer Delegate mit einem Parameter:

delegate int Calculator(int i);
Calculator square = delegate(int x) {return x * x;};
int result = square(3);   // Ergibt 9

Beispiel einer Lambda-Funktion mit einem Parameter

delegate int Calculator(int i);
Calculator square = x => x * x;
int result = square(3);   // Ergibt 9

Beispiel mit zwei Parameter:

delegate int Calculator(int i, int k);
Calculator multiply = (x,y) => x * y;
int result = multiply(3,4);   // Ergibt12

Beispiel einer Operation ohne Parameter

delegate int Sequence();
int seed = 0;
Sequence counter = () => seed++;
counter();   // seed ist 1
counter();   // seed ist 2

Wie man erkennen kann, beschreibt die Definitionen vor dem Lambda-Operator „=>“ die jeweiligen Parameter. Formal betrachtet könnte man den Lambda-Syntax folgendermassen beschreiben:(input parameters) => expression resp. (input parameters) => {statement;}

Wie man sieht, sind Lambda Funktionen und Expressions sind extrem allgemein gehalten. Wie man Lambda-Ausdrücke dynamisch on-the-fly erzeugen kann, werde ich in einem späteren Artikel erklären. Dies ist dann schon ein wenig komplexer.

Das generische Func<> delegate

Wie man oben gesehen hat, werden Lambda-Ausdrücke in delegates übersetzt, um ausgeführt zu werden. Um nicht für jede Funktion eine delegate zu deklarieren (wie oben), gibt es neu die generischen Func<> delegates. Damit lassen sich die eigenen Deklarationen zu einem grossen Teil eleminieren und muss nicht auf die Typsicherheit verzichten.

Beispiel:

Func<int, int> square = x => x * x;
int result = square(3);   // Ergibt 9

Folgende 5 verschiedene Func<> delegates gibt es:

public delegate TResult Func<TResult>();
public delegate TResult Func<T, TResult>(T arg);
public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);
public delegate TResult Func<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3);
public delegate TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

Damit lassen sich somit Funktionen bis zu 4 Parameter abdecken, ohne eigene Delegates zu deklarieren.

Das generische Action<> delegate

Das generische Action<> delegate ist dem Func<> sehr ähnlich. Der einzige Unterschied befindet sich darin, dass Func<> eine Funktion ist und einen Rückgabewert besitzt. Der Rückgabewert von Action<> ist immer void.

Beispiel:

Action<string> writeCons = x => Console.WriteLine(x.ToString());
writeCons(„Test“);

Die 4 verschiedenen Action<> delegates lassen vermuten, dass es sich hierbei auch wiederum um eine Vereinfachung für den Entwickler handelt. Delegates bis zu 4 Parameter braucht man nicht mehr selber zu deklarieren, sondern kann die generischen Standard-Delegates vom System-Namespace nehmen.

public delegate void Action<T>(T obj);
public delegate void Action<T1, T2>(T1 arg1, T2 arg2);
public delegate void Action<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3);
public delegate void Action<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

Wichtiger Hinweis

Anfänglich ist der gebraucht von Lambda extrem umständlich und verwirrend. Der Quellcode sieht zu beginn auch sehr befrendend, seltsam und unübersichtlich aus. Doch das ist normal und man gewöhnt sich recht schnell daran (…wie ehem. VB-Programmierer an die C#-Klammern – gell Urs!). Lambda ist meines Erachtens eine super Sache und erleichtert die Programmierung und Übersicht merklich. Zudem sind Lambda-Ausdrücke und das Verständnis, wie sie funktionieren für LINQ unabdingbar. Ohne Lambda kein LINQ!

Veröffentlicht unter Coding | Verschlagwortet mit ,