Programming Tutorial On The Way

Use Boolean Variables For CheckBox Values

kar — Tue, 02 Sep 2008 15:58:36 +0000

Visual Basic specifies a Boolean’s default values as zero for False and -1 for True. You may save and set the value of a check box, based on the absolute value of a Boolean variable, as these correspond to the intrinsic constants vbUnchecked and vbChecked:

Dim bBool as Boolean

bBool = True

'//If bBool = 0 the checkbox will be

'//unchecked, if it is anything else it will

'//be checked.

Check1.Value = Abs(bBool)

Display Horizontal Scrollbar in ListBox

kar — Tue, 02 Sep 2008 15:02:44 +0000

Unlike the Windows 95 common controls, the standard list box doesn’t have a horizontal scrollbar when list items are too wide to fit within the list box. Fortunately, it’s not hard to direct a listbox control to display a horizontal scrollbar. Add this code to a form’s Load event. It fills a list box with 100 long strings and calls SetHScroll to show a horizontal scrollbar in the list box:

Private Sub Form_Load()
	Dim i As Integer
	For i = 1 To 100
		List1.AddItem CStr(i) & _
			" bottle(s) of beer on the wall."
	Next i
	SetHScroll Me, List1, List1.List(0)
End Sub

Add this code, which includes the required API declarations and the SetHScroll routine, to a BAS module. The SetHScroll routine uses the SendMessage API function to send the LB_SETHORIZONTALEXTENT message to a list box. The last argument is an item from the list, preferably one of the longest items. SetHScroll determines the string’s width in pixels and passes this value to the list box along with the LB_SETHORIZONTALEXTENT message. The list box sets its horizontal extent to this value, and if it is wider than the list-box control, the list box displays a horizontal scrollbar:

#If Win32 Then
Declare Function SendMessage Lib "user32" _
	Alias "SendMessageA" ( _
	ByVal hwnd As Long, ByVal wMsg As Long, _
	ByVal wParam As Long, lParam As Long) As Long
#Else
Declare Function SendMessage Lib "user32" _
	Alias “SendMessageA” ( _
	ByVal hwnd As Integer, ByVal wMsg As Integer, _
	ByVal wParam As Integer, lParam As Long) As Long
#End If
'Define constant for message to list-box control
Const LB_SETHORIZONTALEXTENT = &H194
Public Sub SetHScroll(Frm As Form, Ctrl As _
	Control, strText As String)
	Dim nScaleMode As Integer
	Dim nTextWidth As Integer
	'Scale in pixels for window message
	nScaleMode = Frm.ScaleMode
	Frm.ScaleMode = 3
	'Get the width, in pixels, of the text string
	nTextWidth = Frm.TextWidth(strText)
	'Send a message to the list box
	SendMessage Ctrl.hwnd, _
		LB_SETHORIZONTALEXTENT, nTextWidth, 0
	'Restore previous scale mode
	Frm.ScaleMode = nScaleMode
End Sub

Get the True Member of An Option Array

kar — Mon, 01 Sep 2008 16:47:40 +0000

Setting an element in an array of option buttons to True is easy. Click on the option button, or use this code:

OptionArray(ThisOne) = True

ThisOne is the Index of the member you want to be selected. Getting the True member of an option array is not so simple. Because you need to perform this kind of task in almost any reasonably complex program, adding this function to your code library or generic module simplifies the task. You don’t need to know the array size in advance:

Function OptionTrueIs(OptionArrayName As _
	Variant) As Integer
	' Returns the index of the True
	' member of an option array
	Dim Ctl as Control
	For Each Ctl in OptionArrayName
		If Ctl.Value = True Then
			OptionTruels = Ctl.Index
			Exit For
		End If
	Next
End Function

You can use the routine to set a Public variable from a Properties sheet using this format:

SomePublicVariable = OptionTrueIs(SomeOptionArray())

Or use this code to save a program variable between runs:

SaveSetting("MyApp", "OptionSettings", _
	"OptionKey", OptionTrueIs(SomeOptionArray())

Load the routine using this code:

SomeOptionArray(GetSetting("MyApp", "", _
	"OptionSettings", "OptionKey",0))=True

Or you can load the routine using this code:

SomePublicVariable = GetSetting("MyApp", "", _
	"OptionSettings", "OptionKey",0)

Use this code to control a Select Case structure:

Select Case OptionTrueIs(SomeOptionArray())
	Case 0:
	' This code will execute if element 0
	' of SomeOptionArray() is selected.
End Select

Use this code to test a condition:

If OptionTrueIs(SomeOptionArray()) = SomeValue Then
	' This code will execute if element
	' SomeValue of SomeOptionArray() is
	' selected.
End If

Determine Which Option Buttons Have Been Selected

kar — Mon, 01 Sep 2008 16:38:09 +0000

When attempting to determine which option buttons a user has selected from an array of option buttons, use this code instead of using an inefficient If-Then construct:

intSelectedItem = Option(0).Value * O - _
    Option(1).Value*1 - Option(2).Value * 2

If you have more than a few items, put this code in a loop:

intSelectedItems = 0
For iCount = 0 to N
  'N = total number of option boxes minus one
  intSelectedItem = - _
  Option(iCount).Value * iCount
Next

intSelectedItem is the index of the option button that the user selected.

The stylish digital photo frame

kar — Fri, 29 Feb 2008 18:39:34 +0000

I am already has a digital camera, and now I am looking for digital photo frame. Well, I think many people have known this frame or maybe you already has one at your home. I like this frame because it’s more convenient and it looks beautiful at my home and my office. Beside that, it’s an ideal gift for any occasion. Whether celebrating a wedding, birthday party or any happy event, it’s the perfect present as well as a fantastic way to display and remember the occasion. The slideshow function of the frame as it is like having an endless number of pictures at once. And I finally get my digital photo frame at Digitalframez.com.au.

They provide digital photo frame with unique and visually striking method for displaying your most treasured digital photos. With the digital photo frame you can play movie and audio files over and over again, all beautifully displayed inside your digital frame. All the frame that offer by them are high quality and easy to use. They give you the detail information of each frame includes the price, feature and the size. And now they have the special promotion, where you can get the free 256MB SD memory card with every 10 inch frame order. With the digital photo frame, now my home looks more fashionable and stylish. So I think you should get one too. You can visit the Digitalframez.com.au to know more information about this frame.

Waiting for All Threads in theThread Pool to Finish

kar — Fri, 15 Feb 2008 14:16:54 +0000

For threads that are manually created via the Thread class, you can call the Join method to wait for a thread to finish. This works well when you need to wait for all threads to finish processing before an application terminates. Unfortunately, the thread pool threads do not have a Join method. You need to make sure that all threads in the thread pool have finished processing before another thread terminates or your application’s main thread terminates.

Use a combination of the ThreadPool methods — GetMaxThreads and GetAvailableThreads — to determine when the ThreadPool is finished processing the requests.

This approach is a bit coarse; since the CLR does not allow access to the thread objects being created, the best we can do is to see when the ThreadPool no longer has requests queued. If this approach is not sufficient for your needs, you could implement your own thread pool, but be careful of the many pitfalls that await you because thread pools are not easy to get right in all cases. Some of the issues are having too many or too few threads to service requests, determining initial levels of threads in the pool, and deadlocking threads.

public static void Main()
{
    for (int i=0; i < 25; i++)
    {
        // have to wait or threadpool never gives out threads to requests
        Thread.Sleep(50);
        // queue thread request
        ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc), i);
    }
    // have to wait here or the background threads in the thread
    // pool would not run before the main thread exits.
    Console.WriteLine("Main Thread waiting to complete...");
    bool working = true;
    int workerThreads = 0;
    int completionPortThreads = 0;
    int maxWorkerThreads = 0;
    int maxCompletionPortThreads = 0;
    // get max threads in the pool
    ThreadPool.GetMaxThreads(out maxWorkerThreads,out maxCompletionPortThreads);
    while(working)
    {
        // get available threads
        ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
        if (workerThreads == maxWorkerThreads)
        {
            // allow to quit
            working = false;
        }
        else
        {
            // sleep before checking again
            Thread.Sleep(500);
        }
    }
    Console.WriteLine("Main Thread completing...");
}
static void ThreadProc(Object stateInfo)
{
    //show we did something with this thread...
    Console.WriteLine("Thread {0} running...", stateInfo);
    Thread.Sleep(1000);
}

Synchronizing the Reading and Writing of a Resource Efficiently

kar — Thu, 14 Feb 2008 16:14:58 +0000

Synchronizing the Reading and Writing of a Resource Efficiently

When you have a resource that is shared by multiple threads, you need to provide exclusive access to this resource when a thread is writing to it. However, you do not want the overhead of providing exclusive access to this resource when multiple threads are only reading from it. You want to allow one thread to access a shared resource only if it is writing to it, but you also want to allow multiple threads to read from this resource. While multiple threads can read from a resource, a write operation cannot occur while any thread is reading from this resource.

Example below uses the ReaderWriterLock class from the System.Threading. The ReaderWriterLock is optimized for scenarios where you have data that changes infrequently but needs protection for those times when it is updated in a multithreading scenario. To illustrate, the GradeBoard class represents a board where an instructor will post the grades students received from a class. Many students can read the grade board, but only the instructor can post a grade (write) to the grade board. Students will not, however, be able to read from the board while the instructor is updating it.

class GradeBoard
{
    // make a static ReaderWriterLock to allow all student threads to check
    // grades and the instructor thread to post grades
    static ReaderWriterLock readerWriter = new ReaderWriterLock();

    // the grade to be posted
    static char studentsGrade = ' ';

    static void Main()
    {
        // create students
        Thread[] students = new Thread[5];
        for (int i=0; i < students.Length; i++)
        {
            students[i] = new Thread(new ThreadStart(StudentThreadProc));
            students[i].Name = "Student " + i.ToString();
            // start the student looking for a grade
            students[i].Start();
        }

        // make those students "wait" for their grades by pausing the instructor
        Thread.Sleep(5000);

        // create instructor to post grade
        Thread instructor = new Thread(new ThreadStart(InstructorThreadProc));
        instructor.Name = "Instructor";
        // start instructor
        instructor.Start();

        // wait for instructor to finish
        instructor.Join();

        // wait for students to get grades
        for (int i=0;i < students.Length;i++)
        {
            students[i].Join();
        }
    }

    static char ReadGrade()
    {
        // wait ten seconds for the read lock
        readerWriter.AcquireReaderLock(10000);
        try
        {
            // now we can read safely
            return studentsGrade;
        }
        finally
        {
            // Ensure that the lock is released.
            readerWriter.ReleaseReaderLock();
        }
    }

    static void PostGrade(char grade)
    {
        // wait ten seconds for the write lock
        readerWriter.AcquireWriterLock(10000);
        try
        {
            // now we can post the grade safely
            studentsGrade = grade;
            Console.WriteLine("Posting Grade...");
        }
        finally
        {
            // Ensure that the lock is released.
            readerWriter.ReleaseWriterLock();
        }
    }

    static void StudentThreadProc()
    {
        bool isGradeFound = false;
        char grade = ' ';
        while(!isGradeFound)
        {
            grade = ReadGrade();
            if(grade != ' ')
            {
                isGradeFound = true;
                Console.WriteLine("Student Found Grade...");
            }
            else // check back later
                Thread.Sleep(1000);
        }
    }

    static void InstructorThreadProc()
    {
        // everyone likes an easy grader
        PostGrade('A');
    }
}

In the example, the ReaderWriterLock protects access to the grade resource of the GradeBoard class. Lots of students can be continually reading their grades using the ReadGrade method, but once the instructor attempts to post the grades using the PostGrade method, the grade resource is locked so that no one but the instructor can access it. The instructor updates the grades and releases the lock, and the pending student read requests are allowed to resume. All students continue to read the grade board, check to see if the grades have been posted, and then wait before making another request. Once the grades are posted, each student finds it, and the thread for that student terminates.

The Main method calls Join on the instructor and student threads to wait until those threads finish before continuing and ending. If it did not do this, the program could potentially end before the threads finish. It protects against a ThreadInterruptedException, as the Join calls could potentially throw this if the thread aborts. The threads are named using the Name property to ease debugging.

Determining Whether a Request for a Pooled Thread Will Be Queued

kar — Wed, 13 Feb 2008 17:05:57 +0000

The ThreadPool is a great way to perform background tasks without having to manage all aspects of the thread yourself. It can be handy to know when the ThreadPool itself is going to become a bottleneck to your application, and the GetAvailableThreads method can help you. However, you might want to check your application design if you are consistently using this many threads as you might be losing performance due to contention or context switching. Queuing up work when the ThreadPoolM is full simply queues it up for execution once one of the threads comes free; the request isn’t lost, just postponed.

In this example, your application will be creating many threads from the thread pool. When creating a thread from this pool, you want to be informed as to whether a thread in the pool is available or if none are available, and the request for a new thread will have to be queued. Basically, you want to know whether a thread is available for immediate use from the thread pool. Use the ThreadPool.GetAvailableThreads method to get the number of worker threads currently available in the ThreadPool to determine whether you should queue another request to launch another thread via ThreadPool.QueueUserWorkItem or take an alternate action. The Main method calls a method (SpawnManyThreads) to spawn lots of threads to do work in the ThreadPool, then waits for a bit to simulate processing.

public class TestThreads
{
    public static void Main()
    {
        SpawnManyThreads();
        // have to wait here or the background threads in the thread
        // pool would not run before the main thread exits.
        Console.WriteLine("Main Thread waiting to complete...");
        Thread.Sleep(2000);
        Console.WriteLine("Main Thread completing...");
    }
...
}

The SpawnManyThreads method launches threads and pauses between each launch to allow the ThreadPool to register the request and act upon it. The isThreadAvailable method is called with the parameter set to true to determine whether there is a worker thread available for use in the ThreadPool:

public static bool SpawnManyThreads()
{
    try
    {
        for (int i=0; i<500; i++)
        {
            // have to wait or threadpool never gives out threads to
            // requests
            Thread.Sleep(100);
            // check to see if worker threads are available in the pool
            if(true == isThreadAvailable(true))
            {
                // launch thread if queue isn't full
                Console.WriteLine("Worker Thread was available...");
                ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadProc), i);
            }
            else
                Console.WriteLine("Worker Thread was NOT available...");
        }
    }
    catch (Exception e)
    {
        Console.WriteLine(e.ToString());
        return false;
    }
    return true;
}

The isThreadAvailable method calls ThreadPool.GetAvailableThreads to determine whether the ThreadPool has any available worker threads left. If you pass false as the checkWorkerThreads parameter, it also sees whether there are any completion port threads available. The GetAvailableThreads method compares the current number of threads allocated from the pool against the maximum ThreadPool threads. The worker thread maximum is 25 per CPU, and the completion port thread maximum is 1,000 total, regardless of CPUs on v1.1 of the CLR.

public static bool isThreadAvailable(bool checkWorkerThreads)
{
    int workerThreads = 0;
    int completionPortThreads = 0;
    // get available threads
    ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);

    // indicate how many work threads are available
    Console.WriteLine("{0} worker threads available in thread pool.",
                            workerThreads);

    if (checkWorkerThreads)
    {
        if(workerThreads > 0)
            return true;
    }
    else // check completion port threads
    {
        if (completionPortThreads > 0)
            return true;
    }
    return false;
}

This is a simple method to call in a threaded fashion:

...
static void ThreadProc(Object stateInfo)
    {
        // show we did something with this thread
        Console.WriteLine("Thread {0} running...",stateInfo);
        Thread.Sleep(1000);
    }
}

Configuring a Timer

kar — Tue, 12 Feb 2008 16:16:02 +0000

When using a System.Threading.Timers.Timer class, here are a few scenarios you may encounter:

You want to use a timer to call a timer callback method at a fixed time after the timer object has been created. Once this callback method has been called the first time, you want to call this same callback method at a specified interval (this interval might be different from the time interval between the creation of the timer and the first time the timer callback method is called).
You want to use a timer to call a timer callback method immediately upon creation of the System.Threading.Timer object, after which the callback method is called at a specified interval.
You want to use a timer to call a timer callback method one time only.
You have been using a System.Threading.Timer object and need to change the intervals at which its timer callback method is called.

There are two types of Timer classes in .NET Framework, one from System.Threading and another one from System.Windows.Forms. The former timer is enough to serve the earlier scenarios, but if you are doing UI work and want to use timers, you should investigate the System.Windows.Forms.Timer class. If you are doing server work, you might also want to look at System.Threading.Timers.Timer as well. Both of these classes add events for when the timers are disposed and when the timer “ticks”; they also add properties that expose the settings. Here we look at the Timer class of System.Threading.Timers sample codes.

To fire a System.Threading.Timer after an initial delay, and then at a specified period after that, use the System.Threading.Timer constructor to set up different times for the initial and following callbacks:

using System;
using System.Threading;

public class TestTimers
{
    public static int count = 0;
    public static Timer timerRef = null;

    public static void Main()
    {
        TimerCallback callback = new TimerCallback(TimerMethod);

        // Create a timer that waits one half second, then invokes
        // the callback every second thereafter.
        Timer timer = new Timer(callback, null,500, 1000);

        // store a reference to this timer so the callback can use it
        timerRef = timer;

        // The main thread does nothing until the timer is disposed.
        while (timerRef != null)
            Thread.Sleep(0);
        Console.WriteLine("Timer example done.");
    }

    static void TimerMethod(Object state)
    {
        count++;
        if(count == 5)
        {
            timerRef.Dispose();
            timerRef = null;
        }
    }
}

The previous method showed how to fire the callback after 500 milliseconds. To fire the initial callback immediately, change the value to zero:

// Create a timer that doesn't wait, then invokes
// the callback every second thereafter.
Timer timer = new Timer(callback, null,0, 1000);

To have the timer call the callback only once, change the constructor to pass Timeout.Infinite for the callback interval. You also have to change the current scheme that waits for five callbacks before disposing of the timer to do it the first time. If you didn’t do this, the program would hang since the Main function is still waiting for the timer to have Dispose called, but the fifth callback will never trigger the Dispose call:

        // Create a timer that waits for half a second, then is disposed
        Timer timer = new Timer(callback, null, 500, Timeout.Infinite);

// Also change this...to
    static void TimerMethod(Object state)
    {
            timerRef.Dispose( );
            timerRef = null;
    }

To change the interval of a running System.Threading.Timer, call the Change method specifying the delay before the next callback and the new callback interval, like this:

static void TimerMethod(Object state)
{
    count++;
    if(count == 5)
    {
        timerRef.Change(1000,2000);
    }
    if(count == 10)
    {
        timerRef.Dispose();
        timerRef = null;
    }
}

This code now checks for the fifth callback and changes the interval from one second to two seconds. The sixth callback will happen one second after, and then callbacks through ten will happen two seconds apart.

Encrypting/Decrypting a String

kar — Mon, 11 Feb 2008 14:28:40 +0000

Encrypting the string will prevent users from being able to read and decipher the information. If you have a string you want to be able to encrypt and decrypt — perhaps a password or software key — which will be stored in some form accessible by users, such as in a file, the registry, or even a field, that may be open to attack from malicious code. The sample code in this article, CryptoString class, contains two static methods to encrypt and decrypt a string and two static properties to retrieve the generated key and inititialization vector (IV—a random number used as a starting point to encrypt data) after encryption has occurred.

This class uses the Rijndael algorithm to encrypt and decrypt a string. This algorithm is found in the System.Security.Cryptography.RijndaelManaged class. This algorithm requires a secret key and an initialization vector; both are byte arrays. A random secret key can be generated for you by calling the GenerateKey method on the RijndaelManaged class. This method accepts no parameters and returns void. The generated key is placed in the Key property of the RijndaelManaged class. The GenerateIV method generates a random initialization vector and places this vector in the IV property of the RijndaelManaged class.

using System;
using System.Security.Cryptography;

public sealed class CryptoString
{
    private CryptoString() {}

    private static byte[] savedKey = null;
    private static byte[] savedIV = null;

    public static byte[] Key
    {
        get { return savedKey; }
        set { savedKey = value; }
    }

    public static byte[] IV
    {
        get { return savedIV; }
        set { savedIV = value; }
    }

    private static void RdGenerateSecretKey(RijndaelManaged rdProvider)
    {
        if (savedKey == null)
        {
            rdProvider.KeySize = 256;
            rdProvider.GenerateKey();
            savedKey = rdProvider.Key;
        }
    }

    private static void RdGenerateSecretInitVector(RijndaelManaged rdProvider)
    {
        if (savedIV == null)
        {
            rdProvider.GenerateIV();
            savedIV = rdProvider.IV;
        }
    }

    public static string Encrypt(string originalStr)
    {
        // Encode data string to be stored in memory
        byte[] originalStrAsBytes = Encoding.ASCII.GetBytes(originalStr);
        byte[] originalBytes = {};

        // Create MemoryStream to contain output
        MemoryStream memStream = new MemoryStream(originalStrAsBytes.Length);

        RijndaelManaged rijndael = new RijndaelManaged();

        // Generate and save secret key and init vector
        RdGenerateSecretKey(rijndael);
        RdGenerateSecretInitVector(rijndael);

        if (savedKey == null || savedIV == null)
        {
            throw (new NullReferenceException(
                    "savedKey and savedIV must be non-null."));
        }

        // Create encryptor, and stream objects
        ICryptoTransform rdTransform = rijndael.CreateEncryptor((byte[])savedKey.
                            Clone( ),(byte[])savedIV.Clone());
        CryptoStream cryptoStream = new CryptoStream(memStream, rdTransform,
                            CryptoStreamMode.Write);

        // Write encrypted data to the MemoryStream
        cryptoStream.Write(originalStrAsBytes, 0, originalStrAsBytes.Length);
        cryptoStream.FlushFinalBlock();
        originalBytes = memStream.ToArray();

        // Release all resources
        memStream.Close();
        cryptoStream.Close();
        rdTransform.Dispose();
        rijndael.Clear();

        // Convert encrypted string
        string encryptedStr = Convert.ToBase64String(originalBytes);
        return (encryptedStr);
    }

    public static string Decrypt(string encryptedStr)
    {
        // Unconvert encrypted string
        byte[] encryptedStrAsBytes = Convert.FromBase64String(encryptedStr);
        byte[] initialText = new Byte[encryptedStrAsBytes.Length];

        RijndaelManaged rijndael = new RijndaelManaged();
        MemoryStream memStream = new MemoryStream(encryptedStrAsBytes);

        if (savedKey == null || savedIV == null)
        {
            throw (new NullReferenceException(
                    "savedKey and savedIV must be non-null."));
        }

        // Create decryptor, and stream objects
        ICryptoTransform rdTransform = rijndael.CreateDecryptor((byte[])savedKey.
                            Clone(),(byte[])savedIV.Clone());
        CryptoStream cryptoStream = new CryptoStream(memStream, rdTransform,
                            CryptoStreamMode.Read);

        // Read in decrypted string as a byte[]
        cryptoStream.Read(initialText, 0, initialText.Length);

        // Release all resources
        memStream.Close();
        cryptoStream.Close();
        rdTransform.Dispose();
        rijndael.Clear();

        // Convert byte[] to string
        string decryptedStr = Encoding.ASCII.GetString(initialText);
        return (decryptedStr);
    }
}

The byte array values in the Key and IV properties must be stored for later use and not modified. This is due to the nature of private-key encryption classes, such as RijndaelManaged. The Key and IV values must be used by both the encryption and decryption routines to successfully encrypt and decrypt data.

The SavedKey and SavedIV private static fields contain the secret key and initialization vector, respectively. The secret key is used by the encryption and decryption methods to encrypt and decrypt data. This key must be used by both the encryption and decryption methods in order to successfully encrypt and then decrypt the data. This is why there are public properties for these values, so they can be stored somewhere secure for later use. This means that any strings encrypted by this object must be decrypted by this object. The initialization vector is used to prevent anyone from attempting to decipher the secret key.

There are two methods in the CryptoString class, RdGenerateSecretKey and RdGenerateSecretInitVector, that are used to generate a secret key and initialization vector, when none exist. The RdGenerateSecretKey method generates the secret key, which is placed in the SavedKey field. Likewise, the RdGenerateSecretInitVector generates the initialization vector, which is placed in the SavedIV field. There is only one key and one IV generated for this class. This enables the encryption and decryption routines to have access to the same key and IV information at all times.

The Encrypt and Decrypt methods of the CryptoString class do the actual work of encrypting and decrypting a string, respectively. The Encrypt method accepts a string that you want to encrypt and returns an encrypted string. The following code calls this method and passes in a string to be encrypted:

string encryptedString = CryptoString.Encrypt("MyPassword");
Console.WriteLine("encryptedString: " + encryptedString);
// get the key and IV used so you can decrypt it later
byte[] key = CryptoString.Key;
byte[] IV = CryptoString.IV;

Once the string is encrypted, the key and IV are stored for later decryption. This method displays:

encryptedString: Ah4vkmVKpwMYRT97Q8cVgQ==

The following code sets the key and IV used to encrypt the string, then calls the Decrypt method to decrypt the previously encrypted string:

CryptoString.Key = key;
CryptoString.IV = IV;
string decryptedString = CryptoString.Decrypt(encryptedString);
Console.WriteLine("decryptedString: " + decryptedString);

This method displays:

decryptedString: MyPassword

There does not seem to be any problems with using escape sequences such as \r, \n, \r\n, or \t in the string to be encrypted. In addition, using a quoted string literal, with or without escaped characters, works without a problem:

@"MyPassword"