Manipulating Strings in C#
- Preparing Your Machine to Work with Strings
- Working with Strings
- Initializing Strings
- Comparing Strings
- Concatenating Strings
- Finding the String Length
- Comparing and Concatenating Strings in the Sample Application
- Creating Strings from Characters
- Using Escape Characters
- Using Literal Strings
- Accessing the String's Characters
- Finding a Substring within a String
- Extracting Part of the String
- Splitting a String
- Joining a String
- Uppercasing and Lowercasing
- Formatting Strings
- Finishing the Sample Application
- Representing Objects as Strings
- Allocating Strings with StringBuilder
This chapter is from the book
This chapter is from the book
This chapter is from the book
Most applications require the use of strings in one way or another. Strings are required for building SQL statements when accessing a database, for example. Knowing how to manipulate strings is useful in analyzing requests from Web clients and in constructing a response for the client.
Strings are reference types. You've been learning about reference types little by little in each chapter. The category of reference types includes types you define with the class keyword. As you may recall, you have to create an object before you can use a variable of the type. For example:
Account acct = new Account();
Before you create an object, the variable holds the value of null. The same rule holds true for strings. String variables when declared are equal to null. However, what makes strings interesting is that they also have characteristics of value types (integers, longs, Booleans, etc., for example). C# lets you allocate a string object without using the new operator, like this:
string sqlAuthors = "SELECT * FROM AUTHORS";
The above code creates a new string object. Other characteristics include the way that you can use the == and the != operators for comparing two string objects.
So what is a string? Internally you can think of a string as an array of characters. When you create a string object, in essence two objects are being created in one. The first object is an instance of the string class. The string class has members that describe the physical attributes of the string, such as the length of the string. The second object that gets created is a buffer to hold the characters of the string. The buffer is just a chunk of memory where the characters of the string are stored. The string variable you declare will point to the outer string object, which in turn points to the buffer of characters.
What makes string types really interesting is that in .NET strings are immutable—the contents of the buffer can't be changed. Languages like C# enable you to treat your string variable as a changeable type. For example, they let you append another string to the string in your variable. However, this is an illusion provided by the compiler. In reality, when you change the contents of your string, the compiler asks the .NET runtime to create a brand-new string object.
String objects consume memory, and if you're not careful, you can end up consuming too much memory. At some point that memory needs to be reclaimed. The .NET framework uses a mechanism known as garbage collection to reclaim the memory.
At the end of this chapter you will learn about StringBuilder, which lets you create a changeable string—a single buffer of characters that can be modified. When you're done modifying the StringBuilder buffer, you can ask StringBuilder to produce a single string object from the result. Using StringBuilder will help you minimize the number of string objects that need to be created, and this will in turn decrease the number of garbage collections that need to occur to delete those objects from memory.
Preparing Your Machine to Work with Strings
Like in all other chapters, the best way to learn about the topic at hand is to create a small project in which you can try new things. For this chapter, however, you may be getting more than you've bargained for. We are going to write a little database application. You don't need a commercially available database like SQL Server or even Access. All the database examples in this book will use MySQL. MySQL is a free, open-source, relational database. It doesn't have all the flashy administration tools that SQL Server has, but it is a very powerful database and it's free!
To talk to MySQL from C# you need to use a .NET database provider. One such tool is a tool called dbProvider by eInfoDesigns, Inc. dbProvider isn't free, but eInfoDesigns offers a scaled-down version of the tool for free. Because a lot of you probably don't have MySQL and dbProvider installed I've divided the instructions for writing the sample application into two topics "Preparing your machine to work with strings" (this one) and "Working with strings" (the next one).
To prepare your machine to run the database samples:
First download MySQL. The company that produces MySQL is called MySQL AB and their URL is www.mysql.com. The download section for the latest version as of the time of this writing is at: http://www.mysql.com/downloads/mysql-3.23.html (Figure 4.1).
Figure 4.1. You can download the latest version of MySQL from the MySQLWeb site.Once you download the file mysql-3.23.51-win.zip, unzip its contents to a temporary directory.
Run setup.exe to install MySQL and follow the instructions (Figure 4.2).
Figure 4.2. This looks familiar! Just change the title and you have the setup program of your choice.After installing MySQL, install dbProvider. You can get dbProvider from the download section for this book at www.peachpit.com. The file is called dbProvider-Personal-1-5.msi. Doubleclick this file to install the dbProvider (Figure 4.3).
Figure 4.3. The setup program for dbProvider looks a little different from the standard setup programs. However, I have faith that readers will be able to successfully click the Next button.After installing dbProvider, run the file createdb.cmd, which is a script I wrote to create the database for the sample applications. It is also available in the download section in Peachpit's Web site. To run it, double-click on the file from Windows Explorer.
)
Figure 4.1)
Figure 4.2)
Figure 4.3Tips
Although the sample code will use MySQL for a database backend, the techniques used for database programming are identical to those used for accessing SQL Server or Oracle, for example.
The samples in this chapter will use ADO.NET to talk to the database. ADO.NET is a library of functions that Microsoft ships with the .NET framework for accessing databases. For you to access a database through ADO.NET, the vendor of the database has to write what is called a data provider. You may have heard of other technologies for accessing databases such as ODBC or OLE DB. ADO.NET data providers have the same goals as ODBC and OLE DB providers— to use the same functions to access any type of database. MySQL doesn't have any native ADO.NET providers as of the writing of this book, which is why we need a third-party tool like dbProvider.