Programming C#

• Accessing the file system
• Streams
• Performing web requests
• Serializing data in C#
• The XML serializer
• The IDisposable interface
• Releasing resources
• The C# event system

• Task: Get information about a directory
• Or tell me everything about a file
• We need to read out information of the FS
• Luckily Windows knows everything and has good APIs
• The .NET-Framework opens those APIs for us
• Important: When handling files think about threading
• We do not want to block the UI thread

• The static helper class Path
• Two important classes: Directory and File
• Encapsulations like DirectoryInfo, FileInfo
• Or more specialized DriveInfo
• All kinds of streams (memory, file, text, ...)
• The whole ACL model

• Usually every IO operation is about streaming data
• Every stream of data is dependent of the corresponding device
• e.g. HDD, RAM, ethernet, modem, ...
• The abstract base class is Stream
• Sometimes it might make sense to implement it yourself
• Reading a file has to do with streams

• A specific implemention called FileStream exists
• var fs = new FileStream("...", FileMode.Open) will give us the stream
• Now we can read a byte with ReadByte()
• Read() will read as many bytes as specified into an array
• Returns the number of read bytes (the end of the stream is a barrier)

• Writing a file is quite similar - e.g. FileMode.Create
• Here we have methods like WriteByte() and Write()
• Very important: After our operations we have to close the file
• This happens with the method Close()
• Depending on the device bytes could be buffered before any actual write
• If immediate writing is required use the Flush() method
• Always use ReadAsync() and WriteAsync()

• They are implementations of TextReader, TextWriter
• Their purpose is elegant handling of text
• They expect a Stream (or create a FileStream)
• One can set a proper text encoding (like UTF8, Unicode, ...)
• e.g. var sw = new StreamWriter("...", false, Encoding.ASCII)
• Here we have additionally WriteLine()
• All write methods accept strings or convert objects to strings

• Accessing the internet is quite easy
• WebRequest.Create() creates a new web request
• Here not blocking the UI is very important
• We can directly query URLs and more
• Direct access to the request stream (to the server)
• We first need to request a response object
• Then the request is completed
• The response stream (answer) is then received (from the server)

var request = WebRequest.Create(url);
var response = await request.GetResponseAsync();
var stream = new StreamReader(response.GetResponseStream());
var content = stream.ReadToEnd();

• Many methods have to mark resources as being in use
• The question is: How to release such resources?
• Apparently the Close() method is important
• When automatically releasing resources, how does the GC know?
• The GC will automatically call the Dispose() method
• The method is defined in the interface IDisposable
• So this is our chance to tell the GC what to do
• Additionally we have a destructor, but that is uninteresting

• We can explicitly release resources using a using construct
• The syntax is quite close to foreach
• We could also call Dispose() directly

using(var fs = new FileStream(/* ... */)) {
	/* Do something */
} // Resource automatically closed and freed

• The BitConverter is a very useful class
• The attribute [Serializable] is important
• Two ways: objects to bytes and bytes to objects

• Another way is the XML serialization
• Advantage: Human readable and standardized
• Disadvantage: Big files with overhead
• Just use the XmlSerializer class
• The method for serializing is Serialize()
• Object creation from XML files is also possible
• Here we have to use the Deserialize() method

• To save objects in binary form, use the BinaryFormatter
• The data is transferred to or from a stream
• This is useful to save objects e.g. to a file
• The method for serializing is again Serialize()
• To obtain an object from a stream use Deserialize()
• Depending on the object a typecast is necessary

• Important: The event keyword
• Events are just delegates, but with benefits
• Only accessible with the +=, -= operations (outside)
• Inside we can execute them (called firing)
• public event EventHandler MyEvent to register
• The delegate in this example is EventHandler
• .NET pattern: Arguments object, EventArgs (or derived)
• The return type should be void

• Firing an event is done in the current thread
• If necessary: perform context switch
• If the handler is not set, it will be null (check first!)
• One should prefer using overrides instead of events
• This is of course only possible when deriving from a class
• Events are (mostly) fired synchronously