Download presentation
Presentation is loading. Please wait.
1
Network Programming Chapter 2 Streams in .NET
2
Basic Outline Streams in .NET Stream Manipulation Serialisation
3
Introduction A stream is an abstract representation of a sequence of bytes (e.g. file, I/O device or TCP/IP socket) Abstraction allows us to access different devices in the same manner (like with inheritance)
4
Streams in .NET Stream class TextReader & TextWriter classes
Abstract class Perform binary I/O operations TextReader & TextWriter classes BinaryReader & BinaryWriter classes
5
Streams in .NET Synchronous and Asynchronous I/O Stream Class
Stream class provides for both synchronous & asynchronous Stream Class FileStream Class Reading and Writing with the FileStream Class BufferedStream Class MemoryStream Class NetworkStream Class CryptoStream Class
6
Synchronous I/O Default “setting” Simplest method
Blocks processing until operation is complete (disadvantage) Not suitable for operations over a network Not good choice for large files over low bandwidth Can simulate asynchronous I/O by threading
7
Asynchronous I/O Allows other processing
Operating system notifies caller when I/O processing is done Needs separate notification mechanism Useful when application needs to process other tasks while doing I/O A separate thread is created for each I/O thread (higher O/S overhead)
8
Streams in .NET Synchronous and Asynchronous I/O Stream Class
FileStream Class Reading and Writing with the FileStream Class BufferedStream Class MemoryStream Class NetworkStream Class CryptoStream Class
9
Stream Class System.Security.Cryptography
System.Security.Cryptography.CryptoStream
10
Stream Class Base class = System.IO
Stream is base class for all other stream classes
11
Classes Derived From the Stream Class
Purpose FileStream Uses files as backing storage. This is the most widely used Stream class BufferedStream Uses a buffer s backing storage. This class is used as intermediate storage for improving performance MemoryStream Uses memory as backing storage and performs faster I/O operations when compared to other streams. NetworkStream Does not have any backing storage. This class is used with other streams for transferring data across a network. CryptoStream Used with other stream classes for performing encryption and decryption on streams.
12
Stream Members Name Description CanRead
When overridden in a derived class, gets a value indicating whether the current stream supports reading. (Returns true if the stream supports reading, otherwise; it returns false). CanSeek When overridden in a derived class, gets a value indicating whether the current stream supports seeking. Seeking is used to set the position within the current stream. A NotSupportedException is thrown if seeking is attempted on a stream that does not support it CanTimeout Gets a value that determines whether the current stream can time out. CanWrite When overridden in a derived class, gets a value indicating whether the current stream supports writing. Property should be used before doing any write operation. Length When overridden in a derived class, gets the length in bytes of the stream. This is a read-only property. Position When overridden in a derived class, gets or sets the position within the current stream. It is used for moving around within a stream. To use this property, the stream must support seeking (see the CanSeek property) ReadTimeout Gets or sets a value that determines how long the stream will attempt to read before timing out. WriteTimeout Gets or sets a value that determines how long the stream will attempt to write before timing out. The stream class has a number of methods for moving through the stream, reading from and writing, and managing the stream. Seek method is used for setting the position within stream. This method provides random access to the stream and is generally used while modifying or reading specific contents of the stream.
13
Synchronous Methods for Reading from and Writing to a Stream
Description Read When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read. Read reads a specified number of bytes and advances the position within the stream by the number of bytes read. ReadByte Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream. Write When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. WriteByte Writes a byte to the current position in the stream and advances the position within the stream by one byte.
14
Asynchronous Methods for Reading from and Writing to a Stream
Description BeginRead Begins an asynchronous read operation. BeginWrite Begins an asynchronous write operation. Write When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written. WriteByte Writes a byte to the current position in the stream and advances the position within the stream by one byte.
15
Methods for Managing a Stream
Description Flush When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device (moves information to its destination depending on the state of the Stream object). Close Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. This method automatically flushes any stored data. It is advisable to put a close method in the finally block to ensure that the stream is closed regardless of any exception thrown. SetLength When overridden in a derived class, sets the length of the current stream. Note that if the specified value is less than the current length of the stream, the stream is truncated. A stream must support both writing and seeking for SetLength
16
Streams in .NET Synchronous and Asynchronous I/O Stream Class
FileStream Class Reading and Writing with the FileStream Class BufferedStream Class MemoryStream Class NetworkStream Class CryptoStream Class
17
FileStream Class One of the most widely used of the Stream-derived classes Handles files and standard input and output devices Several ways to create a FileStream object
18
Creating a FileStream Instance with a File Path
Specify a path to a file Default buffer is 8192 bytes Buffer size may be changed in constructor Methods of creating a FileStream Specifying the File Path and Mode Specifying File Access Specifying Sharing Permissions Specifying Buffer Size Specifying Synchronous or Asynchronous State
19
FileMode Options Member name Description Append
Opens the file if it exists and seeks to the end of the file, or creates a new file. FileMode.Append can only be used in conjunction with FileAccess.Write. Any attempt to read fails and throws an ArgumentException. Create Specifies that the operating system should create a new file. If the file already exists, it will be overwritten. This requires FileIOPermissionAccess.Write. System.IO.FileMode.Create is equivalent to requesting that if the file does not exist, use CreateNew; otherwise, use Truncate. CreateNew Specifies that the operating system should create a new file. This requires FileIOPermissionAccess.Write. If the file already exists, an IOException is thrown. Open Specifies that the operating system should open an existing file. The ability to open the file is dependent on the the value specified by FileAccess. A System.IO.FileNotFoundException is thrown if the file does not exist. OpenOrCreate Specifies that the operating system should open a file if it exists; otherwise, a new file should be created. If the file is opened with FileAccess.Read, FileIOPermissionAccess.Read is required. If the file access is FileAccess.Write or FileAccess.ReadWrite, FileIOPermissionAccess.Write is required. If the file access is FileAccess.Append, then FileIOPermissionAccess.Append is required. Truncate Specifies that the operating system should open an existing file. Once opened, the file should be truncated so that its size is zero bytes. This requires FileIOPermissionAccess.Write. Attempts to read from a file opened with Truncate cause an exception.
20
FileMode Syntax To create a FileStream object that creates a new file called c:\Networking\MyStream.txt, you would use the following //Using file path and file mode FileStream inF = new FileStream(“C:\\Networking\\MyStream.txt”, FileMode.CreateNew); The following FileStream constructor opens an existing file (FileMode.Open). FileStream s2 = new FileStream(name, FileMode.Open, FileAccess.Read, FileShare.Read);
21
FileAccess Options Member name Description Read
Read access to the file. Data can be read from the file. Combine with Write for read/write access. ReadWrite Read and write access to the file. Data can be written to and read from the file. Write Write access to the file. Data can be written to the file. Combine with Read for read/write access.
22
FileAccess Syntax You can use the CanRead and CanWrite properties to check the FileAccess permission given to the file To create a new file called c:\Networking\MyStream.txt with write-only access //Using file path, file mode and file access FileStream inF = new FileStream(“C:\\Networking\\MyStream.txt”, FileMode.CreateNew, FileAccess.Write); The following FileStream constructor grants read-only access to an existing file (FileAccess.Read). FileStream s2 = new FileStream(name, FileMode.Open, FileAccess.Read, FileShare.Read);
23
FileShare Options Member name Description Delete
Allows subsequent deleting of a file. Inheritable Makes the file handle inheritable by child processes. This is not directly supported by Win32. None Declines sharing of the current file. Any request to open the file (by this process or another process) will fail until the file is closed. Read Allows subsequent opening of the file for reading. If this flag is not specified, any request to open the file for reading (by this process or another process) will fail until the file is closed. However, even if this flag is specified, additional permissions might still be needed to access the file. ReadWrite Allows subsequent opening of the file for reading or writing. If this flag is not specified, any request to open the file for reading or writing (by this process or another process) will fail until the file is closed. However, even if this flag is specified, additional permissions might still be needed to access the file. Write Allows subsequent opening of the file for writing. If this flag is not specified, any request to open the file for writing (by this process or another process) will fail until the file is closed. However, even if this flag is specified, additional permissions might still be needed to access the file.
24
FileShare Syntax Create a FileStream instance using the FileMode, FileAccess and FileShare properties //Using file path, file mode, file access and sharing permission //Open file for writing, other processes will get read-only access FileStream inF = new FileStream (“C:\\Networking\\MyStream.txt”, FileMode.Open, FileAccess.Write, FileShare.Read); The following FileStream constructor opens an existing file and grants read-only access to other users (Read). FileStream s2 = new FileStream(name, FileMode.Open, FileAccess.Read, FileShare.Read);
25
Specifying Buffer Size
You can also create a FileStream instance by specifying the size of the buffer in addition to the parameters discussed previously. Here we set the size of the buffer to 1000 bytes: //using path, mode, access, sharing permission and buffer size FileStream inF = new FileStream(“C:\\Networking\\MyStream.txt”, FileMode.Open, FileAccess.Write, FileShare.Read, 1000); If the buffer size specified is between 0 and 8 bytes, the actually buffer is set to 8 bytes
26
Specifying Synchronous or Asynchronous State
//Using path, mode, access, sharing permission, buffer size and specifying asynchronous operations FileStream outF = new FileStream(“C:\\Networking\\MyStream.txt”, FileMode.Open, FileAccess.Write, FileShare.Read, 1000, true);
27
File Handle A file handle is a unique identifier that the operating system assigns to a file when the file is opened or created A file handle is represented using the IntPrt structure, which represents an integer of platform-specific length. Using the file handle, you may specify several properties of the stream //Create FileStream Instance FileStream inF = new FileStream( “C:\Neworking\\MyStream.txt”, FileMode.Open); Get the file Handle InterPtr fHanld = infHandle
28
Streams in .NET Synchronous and Asynchronous I/O Stream Class
Stream class provides for both synchronous & asynchronous Stream Class FileStream Class Reading and Writing with the FileStream Class BufferedStream Class MemoryStream Class NetworkStream Class CryptoStream Class
29
Reading & Writing Synchronous I/O Stream class Asynchronous I/O
30
Synchronous I/O Stream class Example Read method Write method
Performs synchronous I/O operations Seek method sets the position within the stream Need System.IO namespace Need System.Text (convert strings to byte arrays)
31
Synchronous I/O using System; using System.Collections.Generic;
using System.Text; using System.IO; namespace SyncIO { class Program Note: additional namespace(s)
32
Synchronous I/O static void Main(string[] args) {
//Create FileStream instance FileStream synF = new FileStream("SyncDemo.txt", FileMode.OpenOrCreate); //this will open our file if it exists; otherwise a new file is created.
33
Synchronous I/O //A character is converted to a byte and then written in a file using the WriteByte method //After the byte is written, the file position is automatically incremented by 1. Console.WriteLine("--Writebyte Method demo--"); synF.WriteByte(Convert.ToByte('A'));
34
Synchronous I/O //Converting a string to a byte array (with the GetBytes method of the Encoding class in System.Text //Write takes three parameters: // * the byte array to write // * the position or offset in the array from where to start writing // * the length of data to be written Console.WriteLine("--Write method demo--"); byte[] writeBytes = Encoding.ASCII.GetBytes(" is the first character."); synF.Write(writeBytes, 0, writeBytes.Length);
35
Synchronous I/O //Reading the data from the file
//When reading or writing on a FileStream, the current position(or pointer)of the file automatically //increases by the number of bytes read or written. //set pointer at origin (start of file or start of stream) synF.Seek(0, SeekOrigin.Begin); //Now we can read. We'll read a single byte with the ReadByte method first. //A byte is read from the stream (with the position automatically increased by 1) and converted by to char. Console.WriteLine("--Readbyte Method demo--"); //Read byte and display Console.WriteLine("First character is -> " + Convert.ToChar(synF.ReadByte()));
36
Synchronous I/O //Now we read the remainder of the file with the Read method. //This method takes 3 parameters: // * A byte array that will store the data read // * the position or offset in the array from where to start reading // * the number of bytes to read //Because we want to read all of the remaining bytes in the file, we want to read in synF.Length - 1 bytes //Use of Read method Console.WriteLine("--Read Method demo--"); //Allocate buffer byte[] readBuf = new byte[synF.Length - 1]; //Read file synF.Read(readBuf, 0, Convert.ToInt32(synF.Length - 1));
37
Synchronous I/O //The byte array is then converted to string using the GetString method of the Encoding Class //Display contents Console.WriteLine("The rest of the file is: " + Encoding.ASCII.GetString(readBuf)); //close the file synF.Close(); Console.WriteLine("Press a key to continue."); Console.ReadLine(); }
38
Asynchronous I/O FileStream opens asynchronously when you pass true to the useAsync flag A special call-back mechanism is needed to implement asynchronous I/O, and an AsyncCallback delegate provides a way for client applications to implement this call-back mechanism. This call-back delegate is supplied to the BeginRead or BeginWrite method
39
Asynchronous I/O using System; using System.Collections.Generic;
using System.Text; using System.IO; using System.Threading; namespace AsyncDemo { class Program //Stream object for reading static FileStream fileStrm; //Buffer to read static byte[] readBuff; Thread.Sleep(Int32) = Suspends the current thread for a specified time.
40
Asynchronous I/O //We declare an AsyncCallback delegate field for the callback function //AsyncCallback delegate static AsyncCallback Callback; //In the Main method, we initialize our callback delegate to point to the Callback function method //This is the method that will be called when the end of the aynchronous read operation is signalled Thread.Sleep(Int32) = Suspends the current thread for a specified time.
41
Asynchronous I/O static void Main(string[] args) {
Callback = new AsyncCallback(CallBackFunction); //now we can initialise our FileStream object, specifying asynchronous operations fileStrm = new FileStream("Test.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 64, true); readBuff = new byte[fileStrm.Length]; //we can use the BeginRead method to initiate asynchronous read opeations on the stream. //The callback delegate is passed to the BeginRead method as its second-to-last parameter. //Call async read fileStrm.BeginRead(readBuff, 0, readBuff.Length, Callback, null); Thread.Sleep(Int32) = Suspends the current thread for a specified time.
42
Asynchronous I/O //Data will be read from FileStream while we continue with other activities. //Here we simply give the appearance of doing some other work by looping and every so often putting the main thread to sleep //Once the loop has finished, the FileStream object is closed. //Simulation of main execution for (long i = 0; i < 5000; i++) { if (i % 1000 == 0) Console.WriteLine("Executing in Main - " + i.ToString()); Thread.Sleep(10) } //end of if } //end of for long fileStrm.Close(); Console.WriteLine("Press a key to continue."); Console.ReadLine(); } //end of Main Thread.Sleep(Int32) = Suspends the current thread for a specified time.
43
Asynchronous I/O static void CallBackFunction(IAsyncResult asyncResult) { //Gets called when read operation has completed int readB = fileStrm.EndRead(asyncResult); if (readB > 0) Console.WriteLine(Encoding.ASCII.GetString(readBuff, 0, readB)) } //end of if } //end of CallBackFunction } Thread.Sleep(Int32) = Suspends the current thread for a specified time.
44
Streams in .NET Synchronous and Asynchronous I/O Stream Class
Stream class provides for both synchronous & asynchronous Stream Class FileStream Class Reading and Writing with the FileStream Class BufferedStream Class MemoryStream Class NetworkStream Class CryptoStream Class
45
Buffered Stream Class A buffer is a reserved area of memory used for storing temporary data. Its main purpose is to improve I/O performance, and it’s often used to synchronise data transfer between devices of different speeds. Many online media applications use buffers as intermediate storage. BufferedStream Class Stream object Generally used with .NetworkStream to store data in memory FileStream Class has its own internal buffer MemoryStream Class does not require buffering
46
Buffered Stream Class using System; using System.Collections.Generic;
using System.Text; using System.IO; using System.Threading; namespace BufferedStreamDemo { class Program static void Main(string[] args) FileStream fStr = new FileStream("BufferDemo.txt", FileMode.OpenOrCreate); byte[] writeBytes = Encoding.ASCII.GetBytes("The difference between genius and stupidity is that genius has its limits."); fStr.Write(writeBytes, 0, writeBytes.Length); Console.WriteLine("Message written"); fStr.Seek(0, SeekOrigin.Begin); readBufStream(fStr); Console.WriteLine("Press a key to continue"); Console.ReadLine(); }
47
Buffered Stream Class //Takes a stream object parameters, wraps it in a buffered stream object and performs a read operaton //Reading Buffered Stream public static void readBufStream(Stream st) { //Compose BufferedStream BufferedStream bf = new BufferedStream(st); byte[] inData = new Byte[st.Length]; //Read and display buffered data bf.Read(inData, 0, Convert.ToInt32(st.Length)); Console.WriteLine(Encoding.ASCII.GetString(inData)); }
48
Memory Stream Class Situation where application needs data frequently (e.g. lookup table) Storing data in file Cause delays Reduce performance of application Use MemoryStream Class for cases where data needs to be stored in memory MemoryStream Class is used for fast, temporary storage
49
Memory Stream Class using System; using System.Collections.Generic;
using System.Text; using System.IO; using System.Threading; namespace MemoryStreamDemo { class Program static void Main(string[] args) //Create empty Memory stream MemoryStream ms = new MemoryStream(); byte[] memData = Encoding.ASCII.GetBytes("This will go in Memory!"); //Write data ms.Write(memData, 0, memData.Length);
50
Memory Stream Class //Set pointer at origin ms.Position = 0;
byte[] inData = new byte[100]; //Read memory ms.Read(inData, 0, 100); Console.WriteLine(Encoding.ASCII.GetString(inData)); Stream str = new FileStream("MemOutput.txt", FileMode.OpenOrCreate, FileAccess.Write); ms.WriteTo(str); str.Close(); }
51
Network Stream Class NetworkStream class is in the System.Net.Sockets namespace Unbuffered stream Does not support random access to data BufferedStream class is often used to buffer the NetworkStream
52
Properties of Network Stream
Name Description CanRead Overridden. Gets a value that indicates whether the NetworkStream supports reading. CanSeek Overridden. Gets a value that indicates whether the stream supports seeking. This property is not currently supported. This property always returns false. CanTimeout Overridden. Indicates whether timeout properties are usable for NetworkStream. CanWrite Overridden. Gets a value that indicates whether the NetworkStream supports writing. DataAvailable Gets a value that indicates whether data is available on the NetworkStream to be read. Length Overridden. Gets the length of the data available on the stream. This property is not currently supported and always throws a NotSupportedException. Position Overridden. Gets or sets the current position in the stream. This property is not currently supported and always throws a NotSupportedException. ReadTimeout Overridden. Gets or sets the amount of time that a read operation blocks waiting for data. WriteTimeout Overridden. Gets or sets the amount of time that a write operation blocks waiting for data.
53
Network Stream Class Each NetworkStream constructor requires at least one Socket. A NetworkStream object can be retrieved from a TcpClient
54
Network Stream Example (Listener)
using System; using System.Collections.Generic; using System.Text; using System.Net; using System.IO; using System.Net.Sockets; namespace TCPListenerDemo { class Program static void Main(string[] args) try //Create TCP Lister to listen on port 5001 IPAddress ipAddress = Dns.GetHostEntry("localhost").AddressList[0]; TcpListener listener = new TcpListener(ipAddress, 5001);
55
Network Stream Example (Listener)
//Start listening listener.Start(); //AcceptClient accepts a connection request, returning a TcpClient TcpClient tc = listener.AcceptTcpClient(); //we use the TcpClient's GetStream to create a NetworkStream object NetworkStream stm = tc.GetStream(); //now we can read data as we have with the other streams, using the Read method byte[] readBuf = new byte[100]; stm.Read(readBuf, 0, 100); //Display data Console.WriteLine(Encoding.ASCII.GetString(readBuf)); stm.Close(); } //end of try catch (Exception ex) { Console.WriteLine(ex.ToString()); } //end of catch }
56
Network Stream Client using System; using System.Collections.Generic;
using System.Text; using System.Net; using System.IO; using System.Net.Sockets; namespace TCPClient { class Program static void Main(string[] args) try //Create TCP Client TcpClient client = new TcpClient();
57
Network Stream Client //Connect using hostname and port
client.Connect("localhost", 5001); //Get network stream instance for sending data NetworkStream ns = client.GetStream(); //Now that we have our NetworkStream, sending data follows the same process as we've used with the other streams byte[] sendBytes = Encoding.ASCII.GetBytes("This data has come from another place!"); ns.Write(sendBytes, 0, sendBytes.Length); //Finally, close our client client.Close(); } //end of try catch (Exception ex) { Console.WriteLine(ex.Message); Console.WriteLine("The listener has probably not started."); } //end of catch }
58
CryptoStream Class Secure data CryptoStream derives from Stream class
Encrypt/decrypt with secret key CryptoStream derives from Stream class CryptoStream constructor takes 3 parameters: Stream to be used Cryptographic transformation Specific read/write access to the cryptographic stream Any cryptographic service provider that implements the ICryptoTransform interface can be used
59
CryptoStream Class using System; using System.Collections.Generic;
using System.Text; using System.IO; using System.Security.Cryptography; namespace cryptDemo { class Program static void Main(string[] args) SymmetricAlgorithm des = null; int answer = Menu(ref des); //A file stream is created to save encrypted data FileStream fs = new FileStream("SecretFile.dat", FileMode.Create, FileAccess.Write); //The interface helps define the basic operation of our cryptographic transformation ICryptoTransform desencrypt = des.CreateEncryptor(); //Wrap cryptoStream around fileStream CryptoStream cryptoStream = new CryptoStream(fs, desencrypt, CryptoStreamMode.Write); //Now we encrypt our message //Use a simple string which is converted into a byte array string theMessage = "A top secret message."; byte[] byteArrayInput = Encoding.Unicode.GetBytes(theMessage); Console.WriteLine("Original Message: {0}", theMessage);
60
CryptoStream Class //Write byte array to cryptoStream
cryptoStream.Write(byteArrayInput, 0, byteArrayInput.Length); cryptoStream.Close(); fs.Close(); //***********Time to Decrypt******************// //Create file stream to read encrypted file back FileStream fsRead = new FileStream("SecretFile.dat", FileMode.Open, FileAccess.ReadWrite); byte[] encByte = new byte[fsRead.Length]; fsRead.Read(encByte, 0, encByte.Length); Console.WriteLine("Encrypted Message: {0}", Encoding.ASCII.GetString(encByte)); //set the position of the within the filestream back to 0 before decrypting fsRead.Position = 0; //Create DES Decryptor from our des instance ICryptoTransform desdecrypt = des.CreateDecryptor(); CryptoStream cryptoStreamDecr = new CryptoStream(fsRead, desdecrypt, CryptoStreamMode.Read); byte[] decrByte = new byte[fsRead.Length]; cryptoStreamDecr.Read(decrByte, 0, (int)fsRead.Length); string output = Encoding.Unicode.GetString(decrByte); Console.WriteLine("Decrypted Message: {0}", output); cryptoStreamDecr.Close(); fsRead.Close(); Console.WriteLine("Press a key to continue."); Console.ReadLine(); } //end of Main
61
CryptoStream Class private static int Menu(ref SymmetricAlgorithm des)
{ bool isCorrect = true; int answer = 0; //Ask the user to choose a service provider //All service providers derived from the SymmetricAlgorithm class have a single secret key that is used for both encrypting and decrypting do isCorrect = true; Console.WriteLine("Select Service Provider for CryptoStream:"); Console.WriteLine("1 = DESCryptoServiceProvider"); Console.WriteLine("2 = RC2CryptoServiceProvider"); Console.WriteLine("3 = RijndaelManaged"); Console.WriteLine("4 = TripleDESCryptoServiceProvider"); Console.WriteLine("5 = SymmetricAlgorithm"); Console.Write("Enter your choice: "); //create des object switch (Console.ReadLine()) case "1": des = new DESCryptoServiceProvider(); answer = 1; break; case "2": des = new RC2CryptoServiceProvider();
62
CryptoStream Class answer = 2; break;
case "3": des = new RijndaelManaged(); answer = 3; case "4": des = new TripleDESCryptoServiceProvider(); answer = 4; case "5": des = SymmetricAlgorithm.Create(); answer = 5; default: { Console.WriteLine("Wrong Selection"); isCorrect = false; } //end of default } //end of switch } while (!(isCorrect)); return answer; } //end of Menu }
63
Basic Outline Streams in .NET Stream Manipulation Serialisation
Introduction Encoding String Data Binary Files Text Reader Text Writer Serialisation
64
Stream Manipulation System.IO namespace provides classes and methods for manipulating different data types in streams
65
Encoding String Data Without knowing what the bytes mean, transmitted data is meaningless Encoding Class in System.Text Handles UNICODE characters
66
Encoding Classes and Uses
ASCIIEncoding encodes Unicode characters as single 7-bit ASCII characters. This encoding only supports character values between U+0000 and U+007F. Code page Also available through the ASCII property. This encoding has limitations because it supports 7-bit character values, and it is not a good choice for applications that support multilingual text processing UTF7Encoding encodes Unicode characters using the UTF-7 encoding. This encoding supports all Unicode character values. Code page Also available through the UTF7 property. (UTF stands for Universal Translation Format). It is a commonly used format to send Unicode-based data across networks. UTF8Encoding encodes Unicode characters using the UTF-8 encoding. This encoding supports all Unicode character values. Code page Also available through the UTF8 property. This class supports 8-bit encoding, or UTF-8. This encoding is widely used with applications that support multilingual text processing. XML uses UTF-8 by default. UnicodeEncoding encodes Unicode characters using the UTF-16 encoding. Both little-endian (code page 1200) and big-endian (code page 1201) byte orders are supported. Also available through the Unicode property and the BigEndianUnicode property. UTF32Encoding encodes Unicode characters using the UTF-32 encoding. Both little-endian (code page 65005) and big-endian (code page 65006) byte orders are supported. Also available through the UTF32 property.
67
Encoding Class Methods
Name Description Clone When overridden in a derived class, creates a shallow copy of the current Encoding object. Convert Overloaded. Converts a byte array from one encoding to another. Equals Overloaded. Overridden. GetByteCount Overloaded. When overridden in a derived class, calculates the number of bytes produced by encoding a set of characters. GetBytes Overloaded. When overridden in a derived class, encodes a set of characters into a sequence of bytes. GetCharCount Overloaded. When overridden in a derived class, calculates the number of characters produced by decoding a sequence of bytes. GetChars Overloaded. When overridden in a derived class, decodes a sequence of bytes into a set of characters. GetDecoder When overridden in a derived class, obtains a decoder that converts an encoded sequence of bytes into a sequence of characters. GetEncoder When overridden in a derived class, obtains an encoder that converts a sequence of Unicode characters into an encoded sequence of bytes. GetEncoding Overloaded. Returns an encoding for the specified code page.
68
Encoding Class Methods
Name Description GetEncodings Returns an array containing all encodings. GetHashCode Overridden. Returns the hash code for the current instance. GetMaxByteCount When overridden in a derived class, calculates the maximum number of bytes produced by encoding the specified number of characters. GetMaxCharCount When overridden in a derived class, calculates the maximum number of characters produced by decoding the specified number of bytes. GetPreamble When overridden in a derived class, returns a sequence of bytes that specifies the encoding used. GetString Overloaded. When overridden in a derived class, decodes a sequence of bytes into a string. GetType Gets the Type of the current instance. (Inherited from Object.) IsAlwaysNormalized Overloaded. Gets a value indicating whether the current encoding is always normalized. ReferenceEquals Determines whether the specified Object instances are the same instance. (Inherited from Object.) ToString Returns a String that represents the current Object. (Inherited from Object.)
69
Encoding String Data using System; using System.Text; using System.IO;
namespace EncodingStringData { class Program static void Main(string[] args) string test = "This is our test string."; byte[] asciiBytes; byte[] unicodeBytes; byte[] UTF7Bytes; //convert our test string into the three different encodings asciiBytes = Encoding.ASCII.GetBytes(test); Console.WriteLine("ASCII Byte String"); Console.WriteLine("ASCII Encoding: {0} bytes", asciiBytes.Length); DisplayArray(asciiBytes); Console.WriteLine("Effect of converting to ASCII"); string asciiString = Encoding.ASCII.GetString(asciiBytes); Console.WriteLine(asciiString); Console.WriteLine();
70
Encoding String Data unicodeBytes = Encoding.Unicode.GetBytes(test);
Console.WriteLine("Unicode Byte String"); Console.WriteLine("Unicode Encoding: {0} bytes", unicodeBytes.Length); DisplayArray(unicodeBytes); Console.WriteLine("Effect of converting to Unicode"); string unicodeString = Encoding.ASCII.GetString(unicodeBytes); Console.WriteLine(unicodeString); Console.WriteLine(); UTF7Bytes = Encoding.UTF7.GetBytes(test); Console.WriteLine("UTF7 Byte String"); Console.WriteLine("UTF7 Encoding: {0} bytes", UTF7Bytes.Length); DisplayArray(UTF7Bytes); Console.WriteLine("Effect of converting to UTF7"); string utf7String = Encoding.ASCII.GetString(UTF7Bytes); Console.WriteLine(utf7String); Console.WriteLine("Press a key to continue."); Console.ReadLine(); }
71
Encoding String Data static void DisplayArray(byte[] b) {
for (int i = 0; i < b.Length; i++) Console.Write(b[i] + " "); Console.WriteLine(); } //end of DisplayArray }
72
Basic Outline Streams in .NET Stream Manipulation Serialisation
Introduction Encoding String Data Binary Files BinaryReader BinaryWriter Text Reader Text Writer Serialisation
73
Binary Files System.IO namespace contains
BinaryReader BinaryWriter Used for working with primitive data types from streams Each class is created around an existing Stream
74
BinaryReader Default is UTF-8 encoding
Custom encoding is possible (at instantiation) BinaryReader Read Read bytes from the stream and advances the position in the stream, returning -1 if the end of the stream is reached PeekChar To read without advancing the position in the stream Returns -1 if the end of the stream is reached or if the stream does not support seeking
75
Binary Reader Methods Name Description Close
Closes the current reader and the underlying stream. Equals Overloaded. Determines whether two Object instances are equal. (Inherited from Object.) GetHashCode Serves as a hash function for a particular type. GetHashCode is suitable for use in hashing algorithms and data structures like a hash table. (Inherited from Object.) GetType Gets the Type of the current instance. (Inherited from Object.) PeekChar Returns the next available character and does not advance the byte or character position. Read Overloaded. Reads characters from the underlying stream and advances the current position of the stream. ReadBoolean Reads a Boolean value from the current stream and advances the current position of the stream by one byte. Bytes read from Stream = 1. ReadByte Reads the next byte from the current stream and advances the current position of the stream by one byte. Bytes read from Stream = 1. ReadBytes (int count) Reads count bytes from the current stream into a byte array and advances the current position by count bytes. Bytes read from Stream = count. ReadChar Reads the next character from the current stream and advances the current position of the stream in accordance with the Encoding used and the specific character being read from the stream. Bytes read from Stream depends on the encoding used.
76
Binary Reader Methods Name Description ReadChars
Reads count characters from the current stream, returns the data in a character array, and advances the current position in accordance with the Encoding used and the specific character being read from the stream. ReadDecimal Reads a decimal value from the current stream and advances the current position of the stream by sixteen bytes. Bytes read from Stream = 16. ReadDouble Reads an 8-byte floating point value from the current stream and advances the current position of the stream by eight bytes. Bytes read from Stream = 9. ReadInt16 Reads a 2-byte signed integer from the current stream and advances the current position of the stream by two bytes. Bytes read from Stream = 2. ReadInt32 Reads a 4-byte signed integer from the current stream and advances the current position of the stream by four bytes. Bytes read from Stream = 4. ReadInt64 Reads an 8-byte signed integer from the current stream and advances the current position of the stream by eight bytes. Bytes read from Stream = 8. ReadSByte Reads a signed byte from this stream and advances the current position of the stream by one byte. ReadSingle Reads a 4-byte floating point value from the current stream and advances the current position of the stream by four bytes. Bytes read from Stream = 4. ReadString Reads a string from the current stream. The string is prefixed with the length, encoded as an integer seven bits at a time. Bytes read from Stream depends on the length of the string. ReadUInt16 Reads a 2-byte unsigned integer from the current stream using little endian encoding and advances the position of the stream by two bytes.
77
Binary Writer Used for writing primitive types in binary format to a stream Writing to the stream is achieved with the Write method. To move around the stream, the Seek method sets the position in the Stream as with the Seek method of the Stream. Standard management methods utilised Close Flush
78
Binary Reading and Writing Example
using System; using System.IO; namespace BinaryReaderAndWriter { class Program static void Main(string[] args) double angle, sinAngle; //Create a file stream called fStream that creates a file called "Sines.dat" //Stream specifies write access FileStream fStream = new FileStream("Sines.dat", FileMode.Create, FileAccess.Write); BinaryWriter bWriter = new BinaryWriter(fStream); //We calculate the sine of angles between 0 and 90 degrees at 5 degree intervals //We have to convert the angle in degrees to radians before we can calculate the sine //Then we use Write to output these values to the stream for (int i = 0; i <= 90; i += 5) double angleRads = Math.PI * i / 180; sinAngle = Math.Sin(angleRads); bWriter.Write((double)i); bWriter.Write(sinAngle); } //end of for loop bWriter.Close(); fStream.Close();
79
Binary Reading and Writing Example
// Reading from File FileStream fStrm = new FileStream("Sines.dat", FileMode.Open, FileAccess.Read); BinaryReader bReader = new BinaryReader(fStrm); int endOfFile; //use the ReadDouble method to read the data back in //If this method tries to read beyond hte end of the stream, an exception will be thrown, //so we use the PeekChar method to detect the end of the file without advancing the position do { endOfFile = bReader.PeekChar(); if (endOfFile != -1) angle = bReader.ReadDouble(); sinAngle = bReader.ReadDouble(); Console.WriteLine("{0} : {1}", angle, sinAngle); } //end of if } while (endOfFile != -1); bReader.Close(); fStrm.Close(); Console.Write("Press a key to continue."); Console.ReadLine(); }
80
Basic Outline Streams in .NET Stream Manipulation Serialisation
Introduction Encoding String Data Binary Files Text Reader Working with StreamReader Text Writer Working with StreamWriter Serialisation
81
Text Reader Used for reading text or characters in a stream
It’s an abstract class from which StreamReader and StringReader derive The text is read in by a StringReader is stored as a StringBuilder, rather than a plain string
82
TextReader Class Methods
Name Description Close Closes the TextReader and releases any system resources associated with the TextReader. CreateObjRef Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. (Inherited from MarshalByRefObject.) Dispose Overloaded. Releases all resources used by the TextReader object. Equals Overloaded. Determines whether two Object instances are equal. (Inherited from Object.) GetHashCode Serves as a hash function for a particular type. GetHashCode is suitable for use in hashing algorithms and data structures like a hash table. (Inherited from Object.) GetLifetimeService Retrieves the current lifetime service object that controls the lifetime policy for this instance. (Inherited from MarshalByRefObject.) GetType Gets the Type of the current instance. (Inherited from Object.)
83
TextReader Class Methods
Name Description InitializeLifetimeService Obtains a lifetime service object to control the lifetime policy for this instance. (Inherited from MarshalByRefObject.) Peek Reads the next character without changing the state of the reader or the character source. Returns the next available character without actually reading it from the input stream. Read Overloaded. Reads data from an input stream. ReadBlock Reads a maximum of count characters from the current stream and writes the data to buffer, beginning at index. ReadLine Reads a line of characters from the current stream and returns the data as a string. ReadToEnd Reads all characters from the current position to the end of the TextReader and returns them as one string. ReferenceEquals Determines whether the specified Object instances are the same instance. (Inherited from Object.) Synchronized Creates a thread-safe wrapper around the specified TextReader. ToString Returns a String that represents the current Object. (Inherited from Object.)
84
Working with StreamReader
Used to read characters from a byte stream Default is UTF-8 encoding Provides forward-only access to the stream
85
Example public static string fileName = @"TextOut.txt";
static void Main(string[] args) { Stream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read); //Using Stream Object StreamReader sReader = new StreamReader(fs); string data; int line = 0; while ((data = sReader.ReadLine()) != null) Console.WriteLine("Line {0}: {1}: Position = {2}", ++line, data, sReader.BaseStream.Position); //sReader.DiscardBufferedData(); } //Set position using seek property of underlying stream sReader.BaseStream.Seek(0, SeekOrigin.Begin); Console.WriteLine(); Console.WriteLine("*Reading entire file using ReadToEnd\n" + sReader.ReadToEnd()); sReader.Close(); fs.Close(); Console.Write("Press a key to continue."); Console.ReadLine();
86
TextWriter Abstract class Outputs a sequential series of characters
StreamWriter and StringWriter are derived from TextWriter
87
TextWriter Class Methods
Name Description Close Closes the current writer and releases any system resources associated with the writer. CreateObjRef Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object. (Inherited from MarshalByRefObject.) Dispose Overloaded. Releases all resources used by the TextWriter object. Equals Overloaded. Determines whether two Object instances are equal. (Inherited from Object.) Flush Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. GetHashCode Serves as a hash function for a particular type. GetHashCode is suitable for use in hashing algorithms and data structures like a hash table. (Inherited from Object.) GetLifetimeService Retrieves the current lifetime service object that controls the lifetime policy for this instance. (Inherited from MarshalByRefObject.) GetType Gets the Type of the current instance. (Inherited from Object.)
88
TextWriter Class Methods
Name Description InitializeLifetimeService Obtains a lifetime service object to control the lifetime policy for this instance. (Inherited from MarshalByRefObject.) ReferenceEquals Determines whether the specified Object instances are the same instance. (Inherited from Object.) Synchronized Creates a thread-safe wrapper around the specified TextWriter. ToString Returns a String that represents the current Object. (Inherited from Object.) Write Overloaded. Writes the given data type to a text stream. WriteLine Overloaded. Writes some data as specified by the overloaded parameters, followed by a line terminator.
89
Working with StreamWriter
Used for writing characters in a stream Default is UTF-8 Encoding StreamWriter constructor is overloaded Can pass a stream object to a StreamWriter (gives greater control over file accessibility)
90
StreamWriter static void Main(string[] args) {
string s1 = "The length of a film should be directly related to the endurance of the human bladder. - Alfred Hitchcock."; string s2 = "USA Today has come out with a new survey: Apparently three out of four people make up 75 percent of the population.-David Letterman."; Stream fs = new FileStream("TextOut.txt", FileMode.OpenOrCreate, FileAccess.Write); //Using Stream Object StreamWriter sWriter = new StreamWriter(fs); //Display the encoding type Console.WriteLine("Encoding Type: {0}", sWriter.Encoding.ToString()); //Display Format Provider Console.WriteLine("Format Provider: {0}", sWriter.FormatProvider.ToString()); sWriter.WriteLine("Today is {0}.", DateTime.Today.DayOfWeek); sWriter.WriteLine(s1); sWriter.WriteLine(s2);
91
StreamWriter for (int i = 0; i < 5; i++) {
sWriter.WriteLine("Value {0}, its square is {1}.", i, i * i); } //end of for //Writing array sWriter.Write("Arrays can be written: "); char[] myArray = new char[] { 'a', 'r', 'r', 'a', 'y' }; sWriter.Write(myArray); sWriter.WriteLine("\r\nAnd parts of arrays can be written."); sWriter.Write(myArray, 0, 3); sWriter.Close(); fs.Close(); Console.WriteLine("Press a key to continue."); Console.ReadLine(); }
92
Basic Outline Streams in .NET Stream Manipulation Serialisation
Introduction Encoding String Data Binary Files Text Reader Text Writer Serialisation Serialising into XML Format Serialising with Formatter Objects
93
Serialisation Serialisation is the process of taking objects and converting their state information into a form that can be stored or transported. The stored or transported object can then be de-serialised to re-create the original state of object. Key areas where serialisation is beneficial Object availability: A component can be saved in a file made available whenever required Object lifetime: Saving the object with its state increases its life. In normal practice, when you close an application, all associated objects are destroyed automatically Object use within networked applications: The complex form of the object has been transformed to a format that is suitable for transferring across a network and possibly through firewalls Object reliability: The saved object can be re-created as is.
94
Serialising into XML format
XML has advantages Transform system-specific state information into text (which is easily transported over a network) XML disadvantage Does not preserve the type of the various fields involved (it serialises properties/fields into XML format) XMLSerializer class in System.XML.Serialization namespace Rules for serializing a class The class must support a default public constructor with no parameters Only public properties that support both get and set operations and public data members are persisted
95
Serialisation using XML
The Customer class public class Customer { public int CustomerID; public string CustomerName; public DateTime SignUpDate; private decimal currentCredit; public void SetCurrentCredit(decimal c) currentCredit = c; } public decimal GetCurrentCredit() return currentCredit; } //end of Customer Notice the public and private fields
96
Serialising Customer to XML
using System; using System.IO; using System.Text; using System.Xml.Serialization; static void Main(string[] args) { //prepare object for serialisation Customer cm = new Customer(); cm.CustomerID = 12; cm.CustomerName = "Stuart Little"; cm.SignUpDate = DateTime.Now; cm.SetCurrentCredit(76.23M); Console.WriteLine("Now Serialising..."); //Create Stream Writer object StreamWriter writer = new StreamWriter("Customer.xml"); //Create Serialiser XmlSerializer serializer = new XmlSerializer(typeof(Customer)); //Serialise the object serializer.Serialize(writer, cm); writer.Close();
97
Serialising an object Console.WriteLine("Now Deserialising...");
//Open and create stream Stream streamOut = new FileStream("Customer.xml", FileMode.Open, FileAccess.Read); XmlSerializer deserial = new XmlSerializer(typeof(Customer)); //Deserialise the sotred stream Customer recm = (Customer)deserial.Deserialize(streamOut); streamOut.Close(); //Display sate of object Console.WriteLine("Customer ID = {0}", recm.CustomerID); Console.WriteLine("Customer name = {0}", recm.CustomerName); Console.WriteLine("Sign up Date = {0}", recm.SignUpDate); Console.WriteLine("Current Credit = {0}", recm.GetCurrentCredit()); Console.ReadLine(); }
98
Serialising with Formatter Objects
Within the System.Runtime.Serialization.Formatters namespace lie the tools for serializing object state into formats such as binary or SOAP The BinaryFormatter class provides functionality for serializing objects into binary format, and the SoapFormatter class serialises into the SOAP format Binary format serialises object state and also assembly information allowing exact reproduction of an object and its types. It also produces a compact format The SOAP format is more verbose (wordy), but it allows your object state to be passed to a web service
99
The Steps for serialising an object/class
Mark the class with the [Serializable] attribute to make it serializable Prepare the object’s state for serialization Create a new formatter object: BinaryFormatter for binary format or SoapFormatter for SOAP Call the Serialize method of the formatter object, passed in the stream to which to output the results and the object to be serialized
100
Deserializing Specify the format for deserializing the object with the relevant formatter object Call the Deserialize method of this formatter object Cast the object returned to the type you wish to re-create
101
Serializing The [Serializable] attribute is not inherited, thus derived types are not automatically serialisable. To protect confidential data, you can make a field [NonSerialized] – any such fields will not be serialised (says the book – need further testing to verify)
102
Summary
Similar presentations
© 2025 SlidePlayer.com Inc.
All rights reserved.