Did you know?

Wir können ja hier mal ein paar Sprachfeatures sammeln, die man in der freien Wildbahn selten oder nie antrifft.

Wusstet ihr, dass man mit | und & die Short-circuit evaluation aushebeln kann?

class Program 
{
	static bool f1()
	{
		Console.Write("f1 ");
		return true;
	}

	static bool f2()
	{
		Console.Write("f2 ");
		return false;
	}

	static void Main(string[] args)
	{
		if (f1() || f2()) { } //Ausgabe: f1
		Console.WriteLine();

		if (f1() | f2()) { } //Ausgabe: f1 f2
		Console.WriteLine();

		if (f2() && f1()) { } //Ausgabe: f2
		Console.WriteLine();

		if (f2() & f1()) { } //Ausgage: f2 f1
		Console.WriteLine();

		Console.ReadKey(true);
	}
}

Firefighter

µ schrieb:

Wusstet ihr, dass man mit | und & die Short-circuit evaluation aushebeln kann?

Der Begriff sagt mir jetzt gar nichts, hast du ne Definition dafuer?

PuppetMaster2k

http://de.wikipedia.org/wiki/Kurzschlussauswertung

luker

µ schrieb:

Short-circuit evaluation aushebeln

Das zählt nicht als Aushebeln. Es ist der Normalfall.

Die "Short-circuit"-operatoren sind vielmehr eine Besser-als-normal-Variante, an die wir uns allerdings längst gewöhnt haben.

freaky

Enums können Extensionmethods haben.

enum AnEnum
{
    Element1,
    Element2
}
static class Extension
{
    public static string EnumExtension(this AnEnum e)
    {
        return "Enum Extension";
    }
}
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(AnEnum.Element1.EnumExtension());
    }
}

Nützlich, aber sieht man eher selten:

var irgendwas = GetResult() ?? String.Empty;

inflames2k

loks schrieb:

Nützlich, aber sieht man eher selten:
var irgendwas = GetResult() ?? String.Empty;

Liegt wahrscheinlich daran, das es für die wenigsten lesbar ist.

Ich bevorzuge da eher die langform. Entweder wie unten aufgeführt oder die ganz lange.

var sResult = GetResult();
var irgendwas = !String.IsNullOrEmpty(sResult) ? sResult : string.Empty;

Bashar

inflames2k schrieb:

loks schrieb:
var irgendwas = GetResult() ?? String.Empty;
Liegt wahrscheinlich daran, das es für die wenigsten lesbar ist.

Du meinst, dass die wenigsten wissen, wie ihre Sprache funktioniert? Weil: Lesbar ist das auf jeden Fall, sehr gut sogar.

inflames2k schrieb:

loks schrieb:
Nützlich, aber sieht man eher selten:
var irgendwas = GetResult() ?? String.Empty;
Liegt wahrscheinlich daran, das es für die wenigsten lesbar ist.

Ich bevorzuge da eher die langform. Entweder wie unten aufgeführt oder die ganz lange.
var sResult = GetResult();
var irgendwas = !String.IsNullOrEmpty(sResult) ? sResult : string.Empty;

Das Beispiel an sich ist natürlich Sinnfrei, aber im Bezug auf Lesbarkeit gewinnt das doch um Längen gegen den Mehrzeiler.

class A 
{
    public String Name { get; set; }

    public String Strasse{ get; set; }
}

void test()
{
    A a = new A() 
    { 
      Name = GetName() ?? String.Empty,
      Strasse = GetStrasse() ?? String.Empty
     };
}

freaky

using kann gestapelt werden.

using(StreamReader sr = new StreamReader(".txt"))
using(StreamWriter sw = new StreamWriter(".txt"))
{
    sr.ReadLine();
    sw.WriteLine();
}

Th69

Nicht gestapelt, sondern verschachtelt (wie andere Anweisungen z.B. for, if, while etc. auch).

Dein Beispiel entspricht also voll ausgeschrieben:

using(StreamReader sr = new StreamReader(".txt"))
{
    using(StreamWriter sw = new StreamWriter(".txt"))
    {
        var line = sr.ReadLine();
        sw.WriteLine(line);
    }
}

Und wie man sieht wäre dann folgendes besser

using(StreamReader sr = new StreamReader(".txt"))
{
    var line = sr.ReadLine();

    using(StreamWriter sw = new StreamWriter(".txt"))
    {
        sw.WriteLine(line);
    }
}

(oder noch gekürzt ohne die inneren geschweiften Klammern)

freaky

Mit stapeln meinte ich auch eher, dass man es genau übereinander schreiben kann, was hilfreich sein kann, wenn man 3-4 using-Blöcke brauch und nicht möchte, dass der Code unnötig weit nach rechts rückt.
Aber deine Erklärung ist natürlich richtig.

hustbaer

freaky schrieb:

... was hilfreich sein kann, wenn man 3-4 using-Blöcke brauch ...

3-4, herzig

using (var seedReader = new StreamFileReader(m_seedStreams[level], false))
				using (var seedSignatureReader = new StreamFileReader(m_seedStreams[level + 1], false))
				using (var sourceReader = CreateSourceReader(level))
				using (var countingSourceReader = new CountingFileReader(sourceReader, false))
				using (var sourceSignatureReader = new StreamFileReader(sourceSignatureStream, false))
				using (var targetSink = new StreamByteSink(targetStream, false))
				using (var reconstructingNeedSink = new ReconstructingNeedSink())
				using (var skippingNeedSink = new SkippingNeedSink())
				using (var batchShapingNeedSink = new BatchShapingNeedSink())
				{

ps:
Ist euch schonmal folgendes abgegangen?

try
    {
        ...
    }
    finally { CleanupThiny1ThatCanThrow(); }
    finally { CleanupThiny2ThatCanThrow(); }
    finally { CleanupThiny3ThatCanThrow(); }
    finally { CleanupThiny4ThatCanThrow(); }

?

Th69

Na ja, das ist ja nur ein Frage der Code-Formatierung:

for (int i=0; i<10; i++)
for (int j=0; j<10; j++)
Console.WriteLine("{0}, {1}", i, j)

oder

if (x > y)
if (x > z)
x = y + z;

:p

hustbaer

Dann zeig mal wie das für try-finally aussehen würde.

Davon abgesehen: jegliche Formatierung die VS nicht kann ist ziemlich uninteressant. Ich kämpfe nicht mehr gegen das System.
Wenns Plugins gibt die besser formatieren und sich nahtlos integrieren (Auto-Format beim Tippen von ";" usw.), OK. Immer noch doof für Leute die das Plugin dann nicht haben, aber damit könnte ich leben.

Aber manuell formatiere ich nix mehr was das nächste Ctrl+K, Ctrl+F nicht überlebt. Bin ja kein Masochist.

ps: Ich find's schrecklich dass man bei VS die Formatierungsregeln nicht zum Projekt dazuhängen kann. Wenn jmd. ein Plugin kennt das hier abhilft: bitte melden

Th69

Für automatische Code-Formatierung im VS empfehle ich {url=http://www.codemaid.net/]CodeMaid[/url].

PS: Ich bezog mich bei meinem vorherigen Beitrag auf den von freaky.
Selber nutze ich bei mehreren [i]using[i] auch eure Schreibweise - mir ging es nur um das Verständnis.