Лаба №1 / books / DotNetBookZero11

Chapter 26. String Theory

Once a C# string is created, neither the length nor the individual characters that make up the string can be changed. A C# string is thus said to be immutable. Whenever you need to change a string in some way, you must create another string. Many members of the String class create new strings based on existing strings. Many methods and properties throughout the .NET Framework create and return strings.

You may wonder if there‘s a performance penalty associated with frequent re-creation of String objects. Consider the following program, which uses the addition compound assignment operator in 10,000 string-appending operations to construct a large string.

StringAppend.cs

//---------------------------------------------

// StringAppend.cs (c) 2006 by Charles Petzold //---------------------------------------------

using System;

using System.Diagnostics;

class StringAppend

{

const int iterations = 10000;

public static void Main()

{

Stopwatch watch = new Stopwatch(); string str = String.Empty;

watch.Start();

for (int i = 0; i < iterations; i++)

str += "abcdefghijklmnopqurstuvxyz\r\n";

watch.Stop();

Console.WriteLine(watch.ElapsedMilliseconds);

}

}

The program uses the Stopwatch class from the System.Diagnostics namespace to calculate an elapsed time. The stopwatch is started before the for loop, stopped afterwards, and then the elapsed time in milliseconds is displayed. (The Stopwatch class requires a reference to the System.dll assembly.)

Each string-appending operation causes a new string object to be created, which requires another memory allocation. Each previous string

is marked for garbage collection. How fast this program runs depends on how fast your machine is. My pokey machine requires about 8 seconds.

A better solution in this case is the appropriately named StringBuilder class, defined in the System.Text namespace. Unlike the string maintained by the String class, the string maintained by StringBuilder can be altered. StringBuilder dynamically reallocates the memory used for the string. Whenever the size of the string is about to exceed the size of the memory buffer, the buffer is doubled in size. To convert a StringBuilder object to a String object, call the ToString method.

Here‘s a revised version of the program using StringBuilder.

StringBuilderAppend.cs

//----------------------------------------------------

// StringBuilderAppend.cs (c) 2006 by Charles Petzold //----------------------------------------------------

using System;

using System.Diagnostics; using System.Text;

class StringBuilderAppend

{

const int iterations = 10000;

public static void Main()

{

StringBuilder builder = new StringBuilder(); Stopwatch watch = new Stopwatch(); watch.Start();

for (int i = 0; i < iterations; i++) builder.Append("abcdefghijklmnopqurstuvxyz\r\n");

string str = builder.ToString(); watch.Stop(); Console.WriteLine(watch.ElapsedMilliseconds);

}

}

You‘ll probably find that this program does its work a thousand times faster than the previous program. On my machine, it required 4 milliseconds.

Another efficient approach is to use the StringWriter class defined in the System.IO namespace. As I indicated in Chapter 25, both StringWriter and StreamWriter (which you use for writing to text files) derive from the abstract TextWriter class. Like StringBuilder, StringWriter assembles a composite string. The big advantage with StringWriter is that you can use the whole array of Write and WriteLine methods defined in the TextWriter class. Here‘s a sample program that performs the same task as the previous two programs but using a StringWriter object.

.NET Book Zero Charles Petzold

StringWriterAppend.cs

//---------------------------------------------------

// StringWriterAppend.cs (c) 2006 by Charles Petzold //---------------------------------------------------

using System;

using System.Diagnostics; using System.IO;

class StringWriterAppend

{

const int iterations = 10000;

public static void Main()

{

StringWriter writer = new StringWriter(); Stopwatch watch = new Stopwatch(); watch.Start();

for (int i = 0; i < iterations; i++) writer.WriteLine("abcdefghijklmnopqurstuvxyz");

string str = writer.ToString(); watch.Stop(); Console.WriteLine(watch.ElapsedMilliseconds);

}

}

The speed of this program is comparable to StringBuilderAppend.

There‘s a lesson in all this. As operating systems, programming languages, class libraries, and frameworks provide an ever increasingly higher level of abstraction, we programmers can sometimes lose sight of all the mechanisms going on beneath the surface. What looks like a simple addition in code can actually involve many layers of low-level activity.

Chapter 27. Generics

C# generics were introduced with C# 2.0, and use a syntax that is similar to the C++ template. Generics help make classes more versatile by letting them be customized for different data types. In certain circumstances, generics preserve strong typing in places where it might otherwise have to be abandoned.

Suppose you‘re designing a two-dimensional graphics programming system, and you want the programmer using your system to express coordinate points in two different ways. You want integer coordinates for performance, but floating-point coordinates for precision.

You might start out designing two different classes. Here‘s an extremely early version of the IntegerPoint class:

class IntegerPoint

{

public int X; public int Y;

public double DistanceTo(IntegerPoint pt)

{

return Math.Sqrt((X - pt.X) * (X - pt.X) + (Y - pt.Y) * (Y - pt.Y));

}

}

Of course, you know that eventually you‘ll have public properties named

X and Y, and private fields named, perhaps, x and y, and you‘ll want constructors, and probably other properties and methods. But this is how you start. Notice that the DistanceTo method has a parameter of another IntegerPoint object and calculates the distance between the two points using the Pythagorean Theorem

You also create a class named DoublePoint:

class DoublePoint

{

public double X; public double Y;

public double DistanceTo(DoublePoint pt)

{

return Math.Sqrt((X - pt.X) * (X - pt.X) + (Y - pt.Y) * (Y - pt.Y));

}

}

In this class the two fields are declared as type double, and the parameter to DistanceTo is a DoublePoint.

Even at this stage, you know that these two classes are going to be pretty similar except for the data types, and you‘d prefer not to duplicate a lot of code. The solution is to make a generic Point class:

class Point<T>

{

public T X; public T Y;

public double DistanceTo(Point<T> pt)

{

...

}

}

To make a generic class, you follow the name of the class with angle brackets enclosing a placeholder that is commonly named T for ―type,‖ although you can name it whatever you want. This is called a type parameter. Notice that the two fields are now of type T, and the parameter to the DistanceTo method is an object of type Point<T>.

However, the return value from DistanceTo is still a double because that‘s the return value from the Math.Sqrt method used for the calculation. (You can also define generic structures and generic interfaces.)

To declare a Point object where the coordinates are integers, you use:

Point<int> pti;

In declaring objects of the generic Point class you must follow the class name with an actual type in angle brackets, in this case int. You can also supply a new expression because the class has a default parameterless constructor:

Point<int> pti = new Point<int>();

The class name with the type in angle brackets is part of the new expression as well. In this case, the fields of the pti object are of type int, and you can assign these fields integer values:

pti.X = 26; pti.Y = 14;

You can declare a Point object where the coordinates are double values using:

Point<double> ptd;

Now the type of the X and Y fields are double, and you can assign the fields double values:

ptd.X = 13.25; ptd.Y = 3E-1;

However, you can indicate that T implements a particular interface (or multiple interfaces), and this is the feature that‘s going to come to our rescue. Take a look at the IConvertible interface defined in the System namespace. Classes or structures that implement this interface must support a bunch of methods for converting to the basic types, and in particular, ToDouble. All the basic types—and some other types as well— implement the IConvertible interface.

The generic Point class can include an IConvertible constraint like so:

class Point<T> where T:IConvertible

Now the compiler knows that any object of type T has a method named

ToDouble, and you can write the DistanceTo method like this:

public double DistanceTo(Point<T> pt)

{

return Math.Sqrt(Math.Pow(X.ToDouble(fmt) - pt.X.ToDouble(fmt), 2) + Math.Pow(Y.ToDouble(fmt) - pt.Y.ToDouble(fmt), 2));

}

The fmt argument to the ToDouble methods must be an object of a type that implements the IFormatProvider interface, and in this case on object of type NumberFormatInfo is suitable, such as

NumberFormatInfo.CurrentInfo. And here is the generic Point class.

Point.cs

//--------------------------------------

// Point.cs (c) 2006 by Charles Petzold //--------------------------------------

using System;

using System.Globalization;

class Point<T> where T:IConvertible

{

public T X; public T Y;

NumberFormatInfo fmt = NumberFormatInfo.CurrentInfo;

//Parameterless Constructor public Point()

{

X = default(T); Y = default(T);

}

//Two-Parameter Constructor public Point(T x, T y)

{

X = x; Y = y;

}

public double DistanceTo(Point<T> pt)

{

return Math.Sqrt(Math.Pow(X.ToDouble(fmt) - pt.X.ToDouble(fmt), 2) + Math.Pow(Y.ToDouble(fmt) - pt.Y.ToDouble(fmt), 2));

}

}

I‘ve also added a parameterless constructor and a two-parameter constructor to show you what those look like. The parameterless constructor really wants to set the two fields to zero, but it cannot. Instead, it uses a default operator that sets value types to their zero values and reference types to null.

The Point.cs file is part of the GenericPoints projects, which also includes the following file to test out the generic Point class.

GenericPoints.cs

//----------------------------------------------

// GenericPoints.cs (c) 2006 by Charles Petzold //----------------------------------------------

using System;

class GenericPoints

{

static void Main()

{

// Points based on integers Point<int> pti1 = new Point<int>();

Point<int> pti2 = new Point<int>(5, 3);

Console.WriteLine(pti1.DistanceTo(pti2));

Console.WriteLine(pts1.DistanceTo(pts2));

}

}

The program creates two objects of type Point<int>, two objects of type Point<double>, and—amazingly enough—two objects of type

Point<string>. Yes, the String class also implements the IConvertible interface, and includes a method named ToDouble that undoubtedly calls Double.Parse. You can also declare objects of type Point<DateTime> because DateTime implements IConvertible as well. But Point<Object> won‘t work.

Where generics had the biggest impact in the .NET Framework is with the System.Collections namespace. With .NET 2.0, that namespace has been largely superseded by the System.Collection.Generic namespace, which includes generic versions of Queue, Stack, Dictionary, SortedList, and List (which is the generic version of ArrayList). These versions provide type safety that the non-generic versions do not, and are now preferred for most applications.

For example, if you need to maintain a collection of DateTime objects, and you can‘t use an array because the number you‘ll eventually need cannot be determined, you can use a generic List class:

List<DateTime> lst = new List<DateTime>();

All the methods such as Add will require that the parameter be of type DateTime, and the indexer is also of type DateTime.

As generic classes such as Dictionary demonstrate, it is possible to have multiple types in a generic class definition:

public class Dictionary<TKey, TValue>

Dictionary implements many interfaces, including IDictionary<TKey, TValue>.

Chapter 28. Nullable Types

Classes are reference types and structures are value types. An instance of any class can take on a null value, but an instance of a structure cannot.

For many applications, this distinction (and the resultant limitation) works just fine. But sometimes it would be nice to have just a little bit more information to accompany our value types.

For example, suppose our database application calls a method named

Fish to fish something out of a database. The item can‘t be found, so the

Fish method returns null. The null value basically means ―it‘s not there‖ or ―I can‘t find it.‖ This scheme works fine if the Fish method is searching for an instance of a class. But suppose the Fish method is looking for an instance of a value type, perhaps a DateTime satisfying particular criteria. The Fish method can‘t return null because DateTime is a structure. The best it can do is return some pre-defined DateTime value that represents the case where ―it‘s not there,‖ perhaps DateTime.MinValue or DateTime.MaxValue.

Another example: You‘re accessing some XML where a Count attribute is normally set to an integer. However, the Count attribute is optional, and its absence means that the Count is ―not applicable‖ for this particular case. How do you store the value of Count in your program? You can‘t just make it an int because you‘re not taking account of the ―not applicable‖ case. You might create a bool named CountIsApplicable, but it would be even nicer having the ―not applicable‖ case somehow stored in the same variable as the Count itself.

This is the rationale behind ―nullable‖ types, which were implemented in

.NET 2.0. Any value type—int, bool, DateTime, or any structure that you define—can be made into a ―nullable,‖ and here‘s where it gets bit confusing: When a value type is made into a nullable, it actually doesn’t mean that the object can have a null value. It only seems to have that capability when you‘re coding in C#. In actuality, the value type is merely associated with a bool that indicates if the value is present or if ―it‘s not there.‖ Syntactically, the ―it‘s not there‖ case is treated in C# as a null.

This will all become more evident as we probe deeper into nullable types.

Nullable types have already been put to use: In the Windows

Presentation Foundation, the IsChecked property of the CheckBox control is a nullable bool, which means that it can be true, false, or null. The null value indicates the ―indeterminate‖ state for a tri-state CheckBox.