4. Did you know?

Did you know?

  • F

    Mit einem "Hack". Ist aber fraglich ob man sowas will und ob es schöner ist.

    //...
public U[] this[params U[] param]
{
    get
    {
        return param;
    }
}
//...
v["hallo", "welt"] = v[23, 42];
    0
  • Administrator

    Gewusst. Kennst du dies? Dürfte dir dann vielleicht auch ein Licht aufgehen, wieso params erlaubt ist 😉

    class Test
{
  public int this[int x]
  {
    get { return 0; }
  }

  public int get_Item(int x)
  {
    return 0;
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    var t = new Test();
    var r = t[0];
  }
}

    ------ Build started: Project: TestProject, Configuration: Debug x86 ------
C:\...\Program.cs(5,5): error CS0082: Type 'Test' already reserves a member called 'get_Item' with the same parameter types
C:\...\Program.cs(8,14): (Related location)

Compile complete -- 1 errors, 0 warnings

    Grüssli

    0
  • ?

    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);
	}
}
    0
  • F

    µ 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?

    0
  • P

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

    0
  • L

    µ 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.

    0
  • F

    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());
    }
}
    0
  • ?

    Nützlich, aber sieht man eher selten:

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

  • 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;
    0
  • B

    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.

    0
  • ?

    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
     };
}
    0
  • F

    using kann gestapelt werden.

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

  • 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)

    0
  • F

    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.

    0

  • 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(); }

    ?

    0

  • 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

    0

  • 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 🙂

    0

  • 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.

    0
Anmelden zum Antworten