C# ПІДРУЧНИКИ / c# / Hungry Minds - C# Bible

class FileTestClass

{

public FileTestClass()

{

BinaryFile = new FileStream("test.dat", FileMode.Create, FileAccess.ReadWrite);

Writer = new BinaryWriter(BinaryFile);

}

public void WriteBinaryData()

{

Writer.Write('a');

Writer.Write(123);

Writer.Write(456.789); Writer.Write("test string");

}

}

class MainClass

{

static public void Main()

{

FileTestClass FileTest = new FileTestClass();

FileTest.WriteBinaryData();

}

}

The code in Listing 25-4 is structured with a class design similar to the design in Listing 25-3. The code contains a MainClass and a FileTestClass. The constructor of the FileTestClass class in Listing 25-4 creates a file stream and then creates a BinaryWriter object. A reference to the file stream is passed to the constructor of the BinaryWriter object, which sets up the relationship between the binary writer and the stream to which it writes its data. In Listing 25- 4, all data written to the binary writer eventually makes its way to the file stream set up in the constructor.

The WriteBinaryData() method writes a character, an integer, a double, and a string to the underlying stream. The BinaryWriter class implements several overloads of a method named Write(). The Write() method overloads support the writing of the following data types to the writer class:

•Booleans

•Bytes

•Arrays of bytes

•Characters

•Arrays of characters

•Decimal values

•Double values

•Signed and unsigned short integer values

•Signed and unsigned integer values

•Signed and unsigned long integer values

•Sbytes

•Floating-point values

•Strings

If you compile and execute the code in Listing 25-4, a file called test.dat is created. You can examine the contents of the new file in a hex editor to verify that binary representations of values were written to the file.

Reading from streams with BinaryReader

Listing 25-5 adds the BinaryReader class to the code in Listing 25-5. This class reassembles stream bytes back into their constituent data types and returns the values to the caller.

Listing 25-5: Working with the BinaryReader Class

using System; using System.IO;

public FileTestClass()

{

BinaryFile = new FileStream("test.dat", FileMode.Create, FileAccess.ReadWrite);

Writer = new BinaryWriter(BinaryFile); Reader = new BinaryReader(BinaryFile);

}

public void ReadBinaryData()

{

char ReadCharacter; double ReadDouble; int ReadInteger; string ReadString;

BinaryFile.Seek(0, SeekOrigin.Begin);

ReadCharacter = Reader.ReadChar();

ReadInteger = Reader.ReadInt32();

ReadDouble = Reader.ReadDouble();

ReadString = Reader.ReadString();

Console.WriteLine("Character: {0}", ReadCharacter); Console.WriteLine("Integer: {0}", ReadInteger); Console.WriteLine("Double: {0}", ReadDouble); Console.WriteLine("String: {0}", ReadString);

}

public void WriteBinaryData()

{

Writer.Write('a');

Writer.Write(123);

Writer.Write(456.789); Writer.Write("test string");

}

}

class MainClass

{

static public void Main()

{

FileTestClass FileTest = new FileTestClass();

FileTest.WriteBinaryData();

FileTest.ReadBinaryData();

}

}

Unlike the BinaryWriter class, which contained one overloaded method for all operations, the BinaryReader class contains separate read methods for each data type. The code in Listing 25- 5 uses some of these read methods, such as ReadChar() and ReadInt32(), to read values from the stream written in the WriteBinaryData() method. The values read from the stream are sent to the console. Executing Listing 25-5 should produce the following output on the console:

Character: a

Integer: 123

Double: 456.789

String: test string

Writing Well-Formed XML Using the XmlWriter Stream

Streams can do more than simply read from and write to various data streams. They can also add value to the data being sent through the stream. A good example of this technology is the XmlWriter class, which encapsulates data sent to a stream within well-formed XML elements. The result is a well-formed XML document that can be processed by any XML document processor, as shown in Listing 25-6.

Listing 25-6: Writing XML with the XmlWriter Class

using System; using System.IO; using System.Xml;

class XMLStreamWriterClass

{

private XmlTextWriter XmlWriter;

public void WriteXML()

{

XmlWriter = new XmlTextWriter(Console.Out);

XmlWriter.WriteStartDocument(); XmlWriter.WriteComment("This XML document was automatically

generated by C# code.");

XmlWriter.WriteStartElement("BOOK"); XmlWriter.WriteElementString("TITLE", "C# Bible"); XmlWriter.WriteElementString("AUTHOR", "Jeff Ferguson"); XmlWriter.WriteElementString("PUBLISHER", "Wiley");

XmlWriter.WriteEndElement();

XmlWriter.WriteEndDocument();

}

}

class MainClass

{

static public void Main()

{

XMLStreamWriterClass XMLStreamWriter = new XMLStreamWriterClass();

XMLStreamWriter.WriteXML();

}

}

The code in Listing 25-6 creates a new instance of the XmlWriter class and associates it with the console's output stream, which sends the stream's output to the application console. The code simply calls various methods in the XmlWriter class to output data, and the methods surround the data with XML elements names that are specified when the method is called. Take a look at the following line from Listing 25-6:

XmlWriter.WriteElementString("AUTHOR", "Jeff Ferguson");

This call instructs the XmlWriter class to write an XML element called <AUTHOR>, which has a value of Brian Patterson, to the stream output device. The method's implementation supplies the XML end tag automatically.

Compiling and executing the code in Listing 25-6 sends the following well-formed XML document to the application console:

<?xml version="1.0" encoding="IBM437"?>

<!--This XML document was automatically generated by C# code.--> <BOOK>

<TITLE>C# Bible</TITLE> <AUTHOR>Jeff Ferguson</AUTHOR> <PUBLISHER>Wiley</PUBLISHER> </BOOK>

Summary

Streams provide powerful support for both synchronous and asynchronous I/O for your C# applications. Streams operate at the byte level and require you to read and write blocks of bytes. Readers and writers encapsulate streams and provide access to data at a higher level.

You can use readers and writers to work with standard C# data types, enabling the readers and writers to translate between the data type values and their byte representations.

Your C# code will most likely work with readers and writers, as they provide support for working with the standard data types without forcing you to be concerned about translating between a data type value and its binary representation. Streams are available, however, should you feel the need to work with them directly. You might also want to work with streams if the data that you are reading is in a proprietary format that is not supported by the standard reader and writer classes shipped with the .NET Framework. You might also

private void createManually()

{

Graphics g;

g = this.CreateGraphics;

}

The third and final method of creating a Graphics object is to pass an image file directly to the object when you instantiate it, as the following code demonstrates by grabbing a bitmap image from the file system:

private void createFromFile()

{

Graphics g; Bitmap b;

b = new Bitmap(@"C:\Enterprise.bmp"); g = Graphics.FromImage(b);

}

If you have been adding these snippets to a WindowsForm, it is clear that nothing happens when any of the code executes. To actually implement some functionality, you need to use members of the Graphics class to make things happen.

Note If you create a Graphics object using the CreateGraphics method, you should call Dispose on that object after you finish using it. This ensures that the Graphics object is released from memory.

Table 26-1 lists the properties of the Graphics class, and Table 26-2 lists the available methods of the Graphics class. The Graphics class is located in the System.Drawing namespace, which is added as the default reference when you create a new Windows Forms application. This does not mean that you cannot use Graphics objects in ASP .NET; in fact, you can write extremely optimized image processing applications in ASP .NET using Graphics objects.

As you can see, the Graphics class provides every possible method that you would ever want to use to work with any type of GUI element. Listing 26-1 uses several of the methods in the Graphics class to produce the output displayed in Figure 26-1.

Figure 26-1: Output from using members of the Graphics class

Note As there is no AutoRedraw property, you still need a way to redraw a form if it is resized. Using the SetStyles method and passing the ControlStyles. ResizeRedraw stylecorrectly calls the Paint method of a form. After the call the InitializeComponent; in your form, you should type SetStyle- (ControlStyles.ResizeRedraw, true) to guarantee that the Paint event will be called when your form is resized. Look up SetStyle in the

.NET Framework SDK to learn more about what you can do with the SetStyle method. Listing 26-1: Using Methods from the Graphics Class

private void drawLine()

{

/* create a Graphics object that can be resued * for each of the samples */

Graphics g;

g = this.CreateGraphics();

// Use the Pen object to create a line

Pen p;

p = new Pen(Color.Red, 50);

/* DrawLine is an overloaded method,

* pass the x1, y1, x2, y2 coordinates */

g.DrawLine(p, 100F, 100F, 500F, 100F);

// draw an icon from the file system

Icon i;

i = new Icon(@"C:\Desktop.ico");