Lập trình ứng dụng nâng cao (phần 12) pot

The data is stored in a separate file for each user, but the files can be isolated even further by distinguishing among different aspects of the identity of the code by assembly or by or

You are now ready to call the formatter’sSerialize( )method, passing in the stream and the object to serialize Because this is done in a method ofSumOf, you can pass in thethis object, which points to the current object:

binaryFormatter.Serialize(fileStream,this);

This serializes theSumOf object to disk.

Deserializing the object

To reconstitute the object, open the file, and ask a binary formatter toDeSerialize it:public static SumOf DeSerialize( ){

public static void Main( )

{

Console.WriteLine("Creating first one with new ");

SumOf app = new SumOf(1,10);

Console.WriteLine(

"Creating second one with deserialize ");

SumOf newInstance = SumOf.DeSerialize( );

private int startNumber = 1;

private int endNumber;

private int[] theSums;

public static void Main( )

{

Console.WriteLine("Creating first one with new ");

SumOf app = new SumOf(1, 10);

Console.WriteLine("Creating second one with deserialize ");

SumOf newInstance = SumOf.DeSerialize( );

int count = endNumber - startNumber + 1;

theSums = new int[count];

new FileStream("DoSum.out", FileMode.Create);

// use the CLR binary formatter

BinaryFormatter binaryFormatter =

new BinaryFormatter( );

Example 22-14 Serializing and deserializing an object (continued)

The output shows that the object was created, displayed, and then serialized The object was then deserialized and output again, with no loss of data.

Handling Transient Data

In some ways, the approach to serialization demonstrated in Example 22-14 is very wasteful Because you can compute the contents of the array given its starting and ending numbers, there really is no reason to store its elements to disk Although the operation might be inexpensive with a small array, it could become costly with a very large one.

You can tell the serializer not to serialize some data by marking it with the

[NonSerialized] attribute:

[NonSerialized] private int[] theSums;

If you don’t serialize the array, however, the object you create will not be correct when you deserialize it The array will be empty Remember, when you deserialize the object, you simply read it up from its serialized form; no methods are run.

To fix the object before you return it to the caller, implement theIDeserializationCallback

interface:

[Serializable]

class SumOf : IDeserializationCallback

Also, implement the one method of this interface: OnDeserialization( ) The CLR promises that if you implement this interface, your class’ OnDeserialization( )

method will be called when the entire object graph has been deserialized This is just what you want: the CLR will reconstitute what you’ve serialized, and then you have the opportunity to fix up the parts that were not serialized.

This implementation can be very simple Just ask the object to recompute the series:public virtual void OnDeserialization (Object sender)

dese-on the array, the serialized file was 20 KB After setting[NonSerialized], the file was

1 KB Not bad Example 22-15 shows the source code using the digits 1–5 as input (to simplify the output).

Example 22-15 Working with a nonserialized object

private int startNumber = 1;

private int endNumber;

[NonSerialized]

private int[] theSums;

public static void Main( )

{

Console.WriteLine("Creating first one with new ");

SumOf app = new SumOf(1, 5);

Console.WriteLine("Creating second one with deserialize "); SumOf newInstance = SumOf.DeSerialize( );

int count = endNumber - startNumber + 1;

theSums = new int[count];

// create a file stream to write the file

Example 22-15 Working with a nonserialized object (continued)

You can see in the output that the data was successfully serialized to disk and then reconstituted by deserialization The trade-off of disk storage space versus time doesn’t make a lot of sense with five values, but it makes a great deal of sense with five million values.

FileStream fileStream =

new FileStream("DoSum.out", FileMode.Create);

// use the CLR binary formatter

// fix up the nonserialized data

public virtual void OnDeserialization(Object sender)

So far, you’ve streamed your data to disk for storage and across the network for easy communication with distant programs There is one other time you might create a stream: to store permanent configuration and status data on a per-user basis For this

purpose, the NET Framework offers isolated storage.

Isolated Storage

The NET CLR provides isolated storage to allow the application developer to store

data on a per-user basis Isolated storage provides much of the functionality of tional Windows ini files, or the more recentHKEY_CURRENT_USERkey in the Windows Registry.

tradi-Applications save data to a unique data compartment associated with the tion The CLR implements the data compartment with a data store, which is

applica-typically a directory on the filesystem.

Administrators are free to limit how much isolated storage individual applications can use They can also use security so that less-trusted code can’t call more highly trusted code to write to isolated storage.

What is important about isolated storage is that the CLR provides a standard place to store your application’s data, but it doesn’t impose (or support) any particular layout

or syntax for that data In short, you can store anything you like in isolated storage Typically, you will store text, often in the form of name-value pairs Isolated storage

is a good mechanism for saving user configuration information such as login name, the position of various windows and widgets, and other application-specific, user- specific information The data is stored in a separate file for each user, but the files can be isolated even further by distinguishing among different aspects of the identity

of the code (by assembly or by originating application domain).

Using isolated storage is fairly straightforward To write to isolated storage, create an instance of anIsolatedStorageFileStream, which you initialize with a filename and a file mode (create, append, etc.):

After running this code, search your hard disk for Tester.cfg On my machine, this

file is found in:

C:\Documents and Settings\Jesse\Local Settings\Application Data\

System.DateTime currentTime = System.DateTime.Now;

output = "Last access: " + currentTime.ToString( );

You can read this file with Notepad if what you’ve written is just text:

Example 22-17 Reading from isolated storage

private void Run( )

Chapter 23

CHAPTER 23

Programmers love a clean slate Although it would be nice if we could throw away all the code we’ve ever written and start over, this typically isn’t a viable option for most companies Over the past decade, many development organizations have made a substantial investment in developing and purchasing COM components and ActiveX controls Microsoft has made a commitment to ensure that these legacy components are usable from within NET applications, and (perhaps less important) that NET components are easily callable from COM.

This chapter describes the support NET provides for importing ActiveX controls and COM components into your application, exposing NET classes to COM-based appli- cations, and making direct calls to Win32 APIs You’ll also learn about C# pointers and keywords for accessing memory directly; this may be crucial in some applications.

Importing ActiveX Controls

ActiveX controls are COM components typically dropped into a form, which might or might not have a user interface When Microsoft developed the OCX standard, which allowed developers to build ActiveX controls in VB and use them with C++ (and vice versa), the ActiveX control revolution began Over the past few years, thousands of such controls have been developed, sold, and used They are small, easy to work with, and an effective example of binary reuse Importing ActiveX controls into NET is surprisingly easy, considering how different COM objects are from NET objects Visual Studio 2008

is able to import ActiveX controls automagically As an alternative to using Visual Studio, Microsoft has developed a command-line utility,Aximp, which will create the assemblies necessary for the control to be used in a NET application.

Creating an ActiveX Control

To demonstrate the ability to use classic ActiveX controls in a NET application, you’ll first develop a simple four-function calculator as an ActiveX control and then invoke that ActiveX control from within a C# application You’ll build the control in

VB 6, and test it in a VB 6 application If you don’t have VB 6 or don’t want to

bother creating the control, you can download the control from http://www.

JesseLiberty.com (Click on the Book site, then click on Books Navigate to this book,

and click on the source code.) Once the control is working in the standard Windows environment, you’ll import it into your Windows Forms application.

To create the control, open VB 6 and choose ActiveX control as the new project type Make the project form as small as possible because this control will not have a user interface Right-clickUserControl1 and choose Properties Rename itCalculator in the Properties window Click the Project in the Project Explorer, and in the Proper- ties window, rename itCalcControl Immediately save the project and name both the file and the projectCalcControl, as shown in Figure 23-1.

You can add the four calculator functions by right-clicking theCalcControlform, ing View Code from the pop-up menu, and typing the VB code shown in Example 23-1.

select-Figure 23-1 Creating a VB ActiveX control

Example 23-1 Implementing the CalcControl ActiveX control

This is the entire code for the control Compile this to the CalcControl.ocx file by

choos-ing File➝Make CalcControl.ocx on the VB 6 menu bar Open a second project in VB as

a standard executable (EXE) Name the formTestForm, and name the projectCalcTest Save the file and project asCalcTest Add the ActiveX control as a component by press- ing Ctrl-T and choosingCalcControl from the Controls tab, shown in Figure 23-2.

Figure 23-2 Adding the CalcControl to the VB 6 toolbox

Example 23-1 Implementing the CalcControl ActiveX control (continued)

This action puts a new control on the toolbox, as shown circled in Figure 23-3.

Drag the new control onto the formTestFormand name itCalcControl Note that the new control will not be visible This control has no user interface Add two text boxes, four buttons, and one label, as shown in Figure 23-4.

Name the buttonsbtnAdd,btnSubtract,btnMultiply, andbtnDivide All that is left is for you to implement methods for handling the button-click events of the calculator buttons.

Figure 23-3 Locating CalcControl in the VB 6 toolbox

Figure 23-4 Building the TestForm user interface

Each time a button is clicked, you want to get the values in the two text boxes, cast them todouble(as required byCalcControl) using the VB 6CDblfunction, invoke a

CalcControl function, and print the result in the label control Example 23-2 vides the complete source code.

pro-Importing a Control in NET

Now that you’ve shown that the CalcControlActiveX control is working, you can

copy the CalcControl.ocx file to your NET development environment Once you have copied it, remember that the CalcControl.ocx file requires that you register it

usingRegsvr32 (if you are running Vista, you’ll need to do this as an administrator):Regsvr32 CalcControl.ocx

You’re now ready to build a test program in NET to use the calculator.

To get started, create a Visual C# Windows Forms application in Visual Studio

2008, name the application InteropTest, and design a form (such as the TestForm

form you created in VB in the preceding section) by dragging and dropping controls onto it Name the formTestForm Figure 23-5 shows a complete sample form.

Example 23-2 Using the CalcControl ActiveX control in a VB program (TestForm)

Private Sub btnAdd_Click( )

Importing a control

There are two ways to import an ActiveX control into the Visual Studio 2008 ment environment: you can use the Visual Studio 2008 tools themselves, or you can import the control manually using theAximp utility that ships with the NET Frame- work SDK To use Visual Studio 2008, right-click on the toolbox and add a tab named

develop-COM Then right-click again and select Choose Items This will bring up the Choose Toolbox Items dialog box Select the COM Components tab, as shown in Figure 23-6.

Figure 23-5 Building a Windows Form to test the CalcControl ActiveX control

Figure 23-6 Adding the CalcControl to the toolbox

Manually importing the control

Alternatively, you can open a command box and import the control manually using theAximp.exe utility, as shown in Figure 23-7.

Aximp.exetakes one argument, the ActiveX control you want to import (CalcControl.

ocx) It produces three files:

which the NET Windows control AxCalcControl.dll was generated and import that

file into the toolbox, as shown in Figure 23-8.

Adding the control to the form

Once imported, the control appears on the toolbox menu, as shown in Figure 23-9 Now, you can drag this control onto your Windows Form and make use of its func- tions, just as you did in the VB 6 example.

Add event handlers for each of the four buttons The event handlers will delegate their work to the ActiveX control you wrote in VB 6 and imported into NET Example 23-3 shows the source code for the event handlers.

Figure 23-7 Running Aximp

Figure 23-8 Browsing for the imported control

Figure 23-9 New control in the toolbox

Each implementing method obtains the values in the text fields, converts them to double using the staticmethoddouble.Parse( ), and passes those values to the calcu- lator’s methods The results are cast back to a string and inserted in the label, as shown in Figure 23-10.

Example 23-3 Implementing the event handlers

double left = double.Parse(textBox1.Text);

double right = double.Parse(textBox2.Text);

label1.Text = axCalculator1.Add(ref left, ref right).ToString( );

}

private void btnSubtract_Click(object sender, EventArgs e)

{

double left = double.Parse(textBox1.Text);

double right = double.Parse(textBox2.Text);

label1.Text = axCalculator1.Subtract(ref left, ref right).ToString( );

}

private void btnMultiply_Click(object sender, EventArgs e)

{

double left = double.Parse(textBox1.Text);

double right = double.Parse(textBox2.Text);

label1.Text = axCalculator1.Multiply(ref left, ref right).ToString( );

}

private void btnDivide_Click(object sender, EventArgs e)

{

double left = double.Parse(textBox1.Text);

double right = double.Parse(textBox2.Text);

label1.Text = axCalculator1.Divide(ref left, ref right).ToString( );

}

}

}

It is possible to invoke unmanaged code from within C# Typically, you would do this if you needed to accomplish something you couldn’t accomplish through the FCL With the 2.0 version of NET, the use of P/Invoke will become relatively rare.

The NET platform invoke facility (P/Invoke) was originally intended only to provide

access to the Windows API, but you can use it to call functions in any DLL.

To see how this works, let’s revisit Example 22-3 from Chapter 22 You will recall that you used theFileInfo class to rename files by invoking theMoveTo( ) method:file.MoveTo(fullName + ".bak");

You can accomplish the same thing by using the Windows kernel32.dll and invoking

theMoveFilemethod.*To do so, you need to declare the method as astatic extern

and use theDllImport attribute:

[DllImport("kernel32.dll", EntryPoint="MoveFile",

ExactSpelling=false, CharSet=CharSet.Unicode,

SetLastError=true)]

static extern bool MoveFile(

string sourceFile, string destinationFile);

TheDllImportattribute class is used to indicate that an unmanaged method will be invoked through P/Invoke The parameters are as follows:

Figure 23-10 Testing the Interop control

* In fact, this is whatFileinfo.Move( ) is doing itself

The rest of the code is virtually unchanged, except for the invocation of the

MoveFile( )method itself Notice thatMoveFile( )is declared to be a static method of the class, so use static method semantics:

Tester.MoveFile(file.FullName,file.FullName + ".bak");

Pass in the original filename and the new name, and the file is moved, just as it was when calling file.MoveTo( ) In this example, there is no advantage—and actually considerable disadvantage—to using P/Invoke You have left managed code, and the result is that you’ve abandoned type safety and your code will no longer run in

“partial-trusted” scenarios Example 23-4 shows the complete source code for using P/Invoke to move the files.

Example 23-4 Using P/Invoke to call a Win32 API method

// declare the WinAPI method you wish to P/Invoke

[DllImport("kernel32.dll", EntryPoint = "MoveFile",

ExactSpelling = false, CharSet = CharSet.Unicode,

SetLastError = true)]

static extern bool MoveFile(

string sourceFile, string destinationFile);

public static void Main( )

{

// make an instance and run it

Tester t = new Tester( );

string theDirectory = @"c:\test\media";

DirectoryInfo dir =

new DirectoryInfo(theDirectory);

t.ExploreDirectory(dir);

}

// Set it running with a directory name

private void ExploreDirectory(DirectoryInfo dir)

{

// make a new subdirectory

string newDirectory = "newTest";

DirectoryInfo newSubDir =

dir.CreateSubdirectory(newDirectory);

// get all the files in the directory and

// copy them to the new directory

FileInfo[] filesInDir = dir.GetFiles( );

foreach (FileInfo file in filesInDir)

// P/Invoke the Win API

Tester.MoveFile(fullName, fullName + ".bak");

c:\test\media\chimes.wav copied to newTest

c:\test\media\chord.wav copied to newTest

c:\test\media\desktop.ini copied to newTest

Example 23-4 Using P/Invoke to call a Win32 API method (continued)

Until now, you’ve seen no code using C-/C++-style pointers Only here, in the final paragraphs of the final pages of the book, does this topicarise, even though pointers are central to the C family of languages In C#, pointers are relegated to unusual and advanced programming; typically, they are used only with P/Invoke.

C# supports the usual C pointer operators, listed in Table 23-1.

The use of pointers is almost never required, and is nearly always discouraged When you do use pointers, you must mark your code with the C# unsafe modifier The code is marked unsafe because you can manipulate memory locations directly with pointers This is a feat that is otherwise impossible within a C# program In unsafe

c:\test\media\ding.wav copied to newTest

c:\test\media\dts.wav copied to newTest

c:\test\media\flourish.mid copied to newTest

c:\test\media\ir_begin.wav copied to newTest

c:\test\media\ir_end.wav copied to newTest

c:\test\media\ir_inter.wav copied to newTest

c:\test\media\notify.wav copied to newTest

c:\test\media\onestop.mid copied to newTest

c:\test\media\recycle.wav copied to newTest

c:\test\media\ringout.wav copied to newTest

c:\test\media\Speech Disambiguation.wav copied to newTest

c:\test\media\Speech Misrecognition.wav copied to newTest

c:\test\media\newTest\chimes.wav renamed to c:\test\media\newTest\chimes.wav

c:\test\media\newTest\ringout.wav renamed to c:\test\media\newTest\ringout.wav

c:\test\media\newTest\Speech Disambiguation.wav deleted

Table 23-1 C# pointer operators

& The address-of operator returns a pointer to the address of a value

* The dereference operator returns the value at the address of a pointer

-> The member access operator is used to access the members of a type

Example 23-4 Using P/Invoke to call a Win32 API method (continued)

code, you can directly access memory, perform conversions between pointers and integral types, take the address of variables, and so forth In exchange, you give up garbage collection and protection against uninitialized variables, dangling pointers, and accessing memory beyond the bounds of an array In essence, unsafe code cre- ates an island of C++ code within your otherwise safe C# application, and your code will not work in partial-trust scenarios.

As an example of when this might be useful, read a file to the console by invoking two Win32 API calls:CreateFileandReadFile.ReadFiletakes, as its second parame- ter, a pointer to a buffer The declaration of the two imported methods is straightforward:

You will create a new class, APIFileReader, whose constructor will invoke the

CreateFile( )method The constructor takes a filename as a parameter, and passes that filename to theCreateFile( ) method:

public APIFileReader(string filename)

TheAPIFileReaderclass implements only one other method,Read( ), which invokes

ReadFile( ) It passes in the file handle created in the class constructor, along with a pointer into a buffer, a count of bytes to retrieve, and a reference to a variable that will hold the number of bytes read It is the pointer to the buffer that is of interest to

us here To invoke this API call, you must use a pointer.

Because you will access it with a pointer, the buffer needs to bepinnedin memory; the NET Framework can’t be allowed to move the buffer during garbage collection.

To accomplish this, use the C#fixedkeyword.fixedallows you to get a pointer to the memory used by the buffer, and to mark that instance so that the garbage collec- tor won’t move it.

The block of statements following thefixed keyword creates a scope, within which the memory will be pinned At the end of the fixed block, the instance will be

unmarked so that it can be moved This is known as declarative pinning:

public unsafe int Read(byte[] buffer, int index, int count)

The test program instantiates the APIFileReader and an ASCIIEncoding object It

passes the filename (8Swnn10.txt) to the constructor of theAPIFileReaderand then creates a loop to repeatedly fill its buffer by calling the Read( ) method, which

Figure 23-11 Checking “Allow unsafe code”