MCTS 70-536 Lession 2 – ValueTypes / Verweistypen

Written By: Mario Priebe - Okt• 13•09

Stichpunktartig schreibe ich in den kommenden Wochen über die Lerninhalte zur Vorbereitung auf die Prüfung zum MCTS

Verweistypen bieten hohe Flexibilität und hervorragende Leistung
Die Daten werden im Heap gespeichert und auf dem Stack wird der Zeiger zu den Daten abgelegt
Runtime verwaltet den HeapSpeicher
Die Garbage Collection organisiert diesen und gibt Speicher, von Elemente auf die nicht mehr verwiesen wird, wieder frei.
GC wird nur ausgelöst, wenn Speicher benötigt wird oder durch einen Aufruf von GC.Collect
Entscheidendster Unterschied zu Werttypen liegt darin, dass beim verweisen in eine andere Variable hier nur der Zeiger (Verweis) zu den Daten im Heap, kopiert wird.
- Eingebaute Verweistypen
  - ca 2500 im .NET Framework
  - Verweistypen sind alle die, die nicht von System.ValueType ableiten
  - allgemeinster Verweistype ist System.Object, jeder VerweisTyp besitzt z.B. ToString(), GetType() und Equals
  - weitere wichtige Verweistypen: System.String, System.Text.StringBuilder, Sytem.Array, System.IO,Stream und System.Exception
Strings sind unveränderlich, wird ein string in der Runtime verändert wird ein neuer angelegt und der alte verworfen. Beim Anlegen von temporären Strings string a += “bla” wird dadurch der GC sehr beansprucht, hier lieber den StringBuilder verwenden. Siehe Tips.
Streams sind neben Strings und Stringbuilder ein weiterer wichtiger Verweistyp.
dieser ermöglicht, Daten von Laufwerken zu lesen und zu schreiben, über das Netzwerk zu kommunizieren
Stream ist der Grundtyp für z.B. FileStream, MemoryStream, StreamReader und StreamWriter
In System.Network.Sockets stehen Netzwerkstreams und in System.Security,Cryptography verschlüsselte Streams zur Verfügung
Einfachste Streamklassen sind StreamReader und StreamWriter
Konstruktor nimmt hier den Dateinamen entgegen
sollte wieder geschlossen werden – Close(), damit die Datei nicht gesperrt bleibt

Tips:

- Ziehe Concat, Format oder Join der String vor um mehrere Anweisungen miteinander zu verknüpfen und so die Perfomance zu verbessern

- Benutze die Methoden der Verweistypen wie Replace, Split, Sort

- Benutze StringBuilder um dynamische String zu erstellen, dieser kann sich über mehrere Anweisungen erstrecken und ist somit sehr flexibel

- Der Standardkonstruktor legt einen 16kb langen Puffer, der auch nach Bedarf vergrößert werden kann. Anfangswert, und –größe kann beeinflusst werden

- Sind alle von System.Object abgeleiteten Typen Verweistypen? Nein, denn auch Werttypen sind von System.Object abgeleitet.

BeispielCode:

Checking Is ValueType

#region checking IsValueType
sbyte a = 0;
byte b = 0;
Int16 c = 0;
Int32 d = 0;
Int64 e = 0;
string f = "";
Exception g = new Exception();
StringBuilder h = new StringBuilder();
object[] types = { a, b, c, d, e, f, g, h };
 
foreach (object o in types)
{
    string output;
    if (o.GetType().IsValueType)
        output = "Werttyp";
    else
        output = "Verweistyp";
 
    Console.WriteLine(output);
}
#endregion

StringBuilder, StreamWriter, StreamReader, Exceptions

using System;
using System.IO;
using System.Text;
 
namespace MCTSStringBuilder.and.StreamExample
{
    class Program
    {
        static void Main(string[] args)
        {
            #region String Methods
            string s = "Hier steht eine Menge unsinniger Uebungstext um einfach mal diesen zu splitten";
 
            //replace
            s = s.Replace("Hier", "dort");
 
            //split
            string[] sa = s.Split(' ');
 
            //sort
            Array.Sort(sa);
 
            //join
            s = String.Join(" ", sa);
 
            Console.WriteLine(s);
            #endregion

            #region Stringbuilder
            StringBuilder sb = new StringBuilder();
            sb.Append("Mein");
            sb.Append(" Name");
            sb.Append(" ist");
            sb.Append(" Mario");
            sb.Append(" Priebe");
            #endregion

            #region StreamWriter + Exception
            StreamWriter sw = new StreamWriter("myName.txt");
            try
            {
                sw.Write(sb);
                Console.WriteLine(String.Format("Die Datei mit dem Inhalt {0} wurde erfolgreich geschrieben", sb));
            }
            catch (UnauthorizedAccessException ex)
            {
                Console.WriteLine(ex.Message);
            }
            catch (IOException ex)
            {
                Console.WriteLine(ex.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                //close the streamwriter
                sw.Close();
            }
            #endregion

            #region StreamReader + Exception
            StreamReader sr = new StreamReader("myName.txt");
            try
            {
                Console.WriteLine(sr.ReadToEnd());
            }
            catch (FileNotFoundException ex)
            {
                Console.WriteLine(ex.Message);
            }
            catch (UnauthorizedAccessException ex)
            {
                Console.WriteLine(ex.Message);
            }
            catch (IOException ex)
            {
                Console.WriteLine(ex.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                //close the streamreader
                sr.Close();
            }
            #endregion
        }
    }
}