Escape-Sequenz für Zeilenumbruch bei Textbox ändern

Ehemaliges Mitglied Erhaltene Danke: 1

Wenn ich den Response von meinem Server erhalte, so ist dieser mit dem UNIX-konformen Zeilenumbruch \n versehen. Wenn ich den String-konvertierten Response an ein Textfeld übergebe, dann muss ich diesen allerdings vorher mit Replace("\n","\r\n") verarbeiten. Auch wenn das Thema für mich noch nicht aktuell ist, so habe ich immer im Hinterkopf, dass das gesamte Projekt auch portierbar sein sollte. Ein Replace würde das Projekt aber vom Betriebssystem abhängig machen.

Kann ich der Textbox während der Laufzeit eine Escape-Sequenz für Zeilenumbrüche deklarieren?

Edit:

Environment.NewLine ist mir bekannt. Schöner wäre es jedoch den Replace zu vermeiden.

Moderiert von Kha: Topic aus C# - Die Sprache verschoben am Di 10.08.2010 um 21:18

Th69 · Verfasst: Di 10.08.10 19:56

markieren

C#-Quelltext

1:
2:

if(Environment.NewLine != "\n")
  sText = sText.Replace("\n", Environment.NewLine);

so müßte es dann unter Linux (Mono) keine Ersetzung geben.

Edit: sorry, zu spät dein Edit gesehen -)
Eine andere Lösung fällt mir aber nicht ein (der TextBox kann man keine Zeilenumbruchsequenz mitgeben - die ist hart-verdrahtet -)

Ehemaliges Mitglied Erhaltene Danke: 1

Alles klar.

Dann eben so ... (Auszug)

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:

using System;

class Client : Object
{
  // speichert den ByteArray des Response-Stream
  protected Bytes[] responseBytes = null;
  public virtual Bytes[] ResponseBytes
  {
    get
    {
      return this.responseBytes;
    }
  }

  // speichert (nach erstmaligem Bedarf) eine 1:1 String-Entsprechung von ResponseBytes
  protected String responseString = null;
  public virtual String ResponseString
  {
    get
    {
      if (this.responseString == null)
      {
        this.responseString = this.EncodeResponseBytes();
      }
      return this.responseString;
    }
  }

  // speichert (nach erstmaligem Bedarf) eine dem Betriebssystem angepasste Kopie von ResponseString
  protected String responseStringOS = null;
  public virtual String ResponseStringOS
  {
    get
    {
      if (this.responseStringOS == null)
      {
        this.responseStringOS = this.responseString == null
                                ? this.EncodeResponseBytes()
                                : this.responseString;
        // Ich setze voraus, dass ich vom Server ausschließlich Antworten mit UNIX konformen Zeilenumbrüchen empfange.
        // Ich weiß, dass dies absoluter Unsinn ist, da ich dabei nur von meinem Server ausgehen kann.
        // Es geht in erster Linie um eine Idee mit Lerneffekt.
        this.responseStringOS = Environment.NewLine == "\n"
                                ? this.responseStringOS
                                : this.responseStringOS.Replace("\n", Environment.NewLine);
      }
      return this.responseStringOS;
    }
  }

  // Enkodiert (hier UTF-8 erzwungen) ResponseBytes in eine 1:1 String-Entsprechung
  protected String EncodeResponseBytes()
  {
    return Text.Encoding.UTF8.ToString(this.ResponseBytes)
  }
}

Fazit: Die Bytefolge des Response wird auf jeden Fall gespeichert und die String-Enstprechungen werden erst dann erstellt, wenn sie auch wirklich gebraucht werden und auch dann nur beim ersten Zugriff. Bei einem neuen Request werden diese Member wieder auf null gesetzt.

Das spart Overhead und Rechenzeit. Nach dem Motto: Kleinvieh macht auch Mist!

Danke für die Antwort.

Edit:

Code erneuert. Für Vorschläge zur Optimierung bin ich sehr offen.

Ralf Jansen · Verfasst: Mi 11.08.10 00:00

Code wäre wohl einfacher wenn du in der ResponseStringOS Property einfach die ResponseString Property verwendest.
Also

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

  
private String responseString = null;
public virtual String ResponseString
{
    get
    {
        if (this.responseString == null)
            this.responseString = this.EncodeResponseBytes();
        return this.responseString;
    }
}

public virtual String ResponseStringOS
{
    get
    {
        if (Environment.NewLine != "\n")
            return ResponseString.Replace("\n", Environment.NewLine);
        else
            return ResponseString;
    }
}

PS. ungetestet

Ehemaliges Mitglied Erhaltene Danke: 1

In Deinem Fall wird bei jedem Zugriff auf ResponseStringOS der ResponseString mit Replace bearbeitet. Bei einem 20 MB Response ist das Rechenzeit. Also wieso sollte ich den einmal geparsten Wert nicht zur weiteren Verwendung speichern?

Ist ein Abwägen von Ressourcenverbrauch gegen Rechenzeit. In meinem Fall werden große Responses erwartet. Die Ressourcen sind vorhanden und auf eine geringe Rechenzeit wird intensiv Wert gelegt. Die eingesetzten Betriebssysteme sind unterschiedlich.

Ralf Jansen · Verfasst: Mi 11.08.10 10:28

Zitat:

Bei einem 20 MB Response ist das Rechenzeit. Also wieso sollte ich den einmal geparsten Wert nicht zur weiteren Verwendung speichern?

Bei einem großen string gebe ich dir recht dann solltest du das zwischenspeichern. Ansonsten würde ich Lesbarkeit der Performanceoptimierung vorziehen.

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme