Following SQL query gives list of all the table names and their column names in a Firebird database.

SELECT Relations.RDB$RELATION_NAME "Table Name", Fields.RDB$FIELD_NAME "Column Name" FROM RDB$RELATION_FIELDS Fields
JOIN RDB$RELATIONS Relations ON
Fields.RDB$RELATION_NAME = Relations.RDB$RELATION_NAME
WHERE
(Relations.RDB$SYSTEM_FLAG IS NULL OR Relations.RDB$SYSTEM_FLAG = 0)
AND
(Relations.RDB$VIEW_BLR IS NULL)
ORDER BY 1;

As noted before, RDB$System_Flag is used to filter out user tables as against system tables and RDB$View_BLR is used to filter Views.

Following SQL query gives you all the user define stored procedures in a Firebird database.

SELECT rdb$Procedure_name as "Procedure Name" FROM rdb$procedures
WHERE rdb$system_flag IS NULL OR rdb$system_flag = 0;

Following SQL query will give you names of all the user defined tables in a Firebird database.

SELECT rdb$relation_name AS "Table Name"
FROM rdb$relations
WHERE rdb$view_blr IS NULL AND (rdb$system_flag IS NULL OR rdb$system_flag = 0);

rdb$system_flag of 0 or NULL identifies a user table or view and rdb$view_blr being NULL identifies that it is a TABLE.

Following simple batch file can be used to build a solution in Visual Studio 2010. Here I use devenv.exe to build the solution from command line so that we get the same behavior as if building from IDE. Save below given batch script into a .bat file, update the solution file path and you are all set to build.

echo off

call "C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\vcvars32.bat"
devenv "C:\SampleWinApplication\SampleWinApplication.sln" /build

pause

vcvars32.bat sets up environment for Visual Studio Tools. Note that this same batch file is called when you invoke Visual Studio command prompt (Start->Programs->Microsoft Visual Studio 2010->Visual Studio Tools—>Visual Studio Command Prompt (2010). This is important to correctly invoke devenv from command line.

When you are loading third party assemblies in your application through reflection and you want to set any enum type property of any class, the situation is trickier than it appears at first. As against setting property of primitive type or any normal class type, enum type properties are not straight forward because you cannot use Activator.CreateInstance or any such APIs to create an enum instance to be set.

Assuming that the property to be set is a static property of a class, following sample method will do the job for you. Method is mostly self-explanatory.

private void SetEnumValue(Assembly theirAssembly, string fullyQualifiedClassName, 
                          string propertyName, string fullyQualifiedEnumName, 
                          int newValue)
{
    //Get Type of the class which contains property to be set
    Type externalType = theirAssembly.GetType(fullyQualifiedClassName);

    // Get Type of the enum in their assembly
    Type theirEnumType = theirAssembly.GetType(fullyQualifiedEnumName);

    // Get PropertyInfo that is to be set.
    PropertyInfo enumTypePropertyInfo = externalType.GetProperty(propertyName);

    // Derive new value to be set, ensure that newValue is valid for their enum type
    object newValueToSet = Enum.ToObject(theirEnumType, newValue);

    // Assuming that Property to be set is an static property, following will update its value
    enumTypePropertyInfo.SetValue(null, newValueToSet, null);
}

In case, the property to be set is an instance property you can update this method to pass the instance in the last line rather than null as the first argument of PropertyInfo.SetValue.

I got this error recently when i was trying to copy a large file (~8GB) to my external USB hard drive. This did not make any sense to me as i had 120+ GB available free space on my hard disk.

I spent some time and it turns out i am not able to copy file because my hard disk was formatted with FAT32 format. FAT32 has 4GB file size limit and this is why i was not able copy this large file. So the solution is to convert your FAT32 to NTFS format. I already had lot of data on my hard disk so formatting with NTFS was not an option. Luckily, i found that Windows gives us  a **convert **command to convert FAT32 drives to NTFS while keeping all your data intact. You can use following command on the DOS prompt.

convert  /FS:NTFS /X

Here is the drive (for example, F:) that you want to convert to NTFS. In my case, i got another error that it found some error on the drive and suggested to run CHKDSK. I ran CHKDSK as follows and then re-ran **Convert **command as given above and everything worked like a charm.

chkdsk  /F /X

Here is the drive (for example F:) that you want to CHKDSK.

• This is one more thread synchronization technique where you decorate a method with a particular attribute. We use attribute MethodImplAttribute with option of MethodImplOptions.Synchronized to make the whole method thread safe.
• MethodImplAttribute is in System.Runtime.CompilerServices namespace.
• This attribute option ensures that the method can be executed by only one thread at a time.
• Note that this class lies under CompilerServices namespace. So when you compile your app, compiler inserts **lock **statements around the body of the method to make the whole method thread safe. For the instance method it uses **lock(this) **and for the static methods it uses **lock(typeof(classname)). **Because of this, the use of this approach for thread synchronization is discouraged. Note that it is usually not a good practice to use **lock **on publicly visible objects/types. This is because somebody else might, in the future, use the same object/type to lock some other code segment, thus decreasing concurrency and increasing the chance of deadlock.

Following code snippet shows the use of MethodImplAttribute to synchronize two threads. We have a DataStore class which is accessed by two threads to store data. In the AddData method of DataStore, we simulate a delay in data processing by using Thread.Sleep. Here if we remove the MethodImplAttribute from the AddData method, you will randomly get System.ArgumentException. Following is the sample application:

using System;
using System.Threading;
using System.Reflection;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;
using System.Collections.Generic;

namespace ConsoleApplication1
{
    class DataStore
    {
        private Dictionary dataCollection = new Dictionary();
        private const int StoreLimit = 100000;

        [MethodImplAttribute(MethodImplOptions.Synchronized)]
        public void AddData(string data)
        {
            if (!dataCollection.ContainsKey(data) && dataCollection.Count < StoreLimit)
            {
                Thread.Sleep(1000); // simulate some delay for data processing
                dataCollection.Add(data, data);

            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            (new Thread(ReceiveDataFromServer1)).Start();
            (new Thread(ReceiveDataFromServer2)).Start();
        }

        private static Random rand = new Random();
        private static DataStore store = new DataStore();
        private static void ReceiveDataFromServer1()
        {
            while (true)
            {
                string data = rand.Next(10, 20).ToString();
                store.AddData(data);
                Console.WriteLine("First thread data - " + data);
            }
        }

        private static void ReceiveDataFromServer2()
        {
            while (true)
            {
                string data = rand.Next(10, 20).ToString();
                store.AddData(data);
                Console.WriteLine("Second thread data - " + data);
            }
        }
    }
}

• Semaphore is another class based (derives from) on WaitHandle. Other classes that are based on WaitHandle and i have discussed them in my previous posts are AutoResetEvent, ManualResetEvent and Mutex. Semaphore is used to control number of threads that can access a shared resource concurrently. Threads enter the Semaphore by calling WaitOne method and release the Semaphore by calling Release method. Semaphore is initialized by specifying the number of concurrent threads that it should allow. The count on Semaphore is decremented each time a thread enters the Semaphore and incremented each time a thread releases the Semaphore. When the count is zero, subsequent calls block until other threads release the Semaphore. When all threads release the Semaphore, the count is maximum value specified when the Semaphore was created. There is no guaranteed order in which blocked thread enter the Semaphore. A thread can enter Semaphore multiple times by calling WaitOne method repeatedly. But each of the WaitOne calls must be matched with corresponding Release call. There is also an overload of Release that takes an integer specifying number of entries to be release. If the count on the Semaphore is full (no thread is entered), and a thread calls Release on that Semaphore, SemaphoreFullException is thrown. Semaphore are of two types: local Semaphores and named system Semaphores. Named system Semaphores are visible throughout the operating system and can be used to synchronize the activities of processes. You can create multiple semaphores that represent the same named system semaphore and you can use OpenExisting method to open an existing named system semaphore.

Now, below i am going to give an example for use of Semaphore. We use semaphore in the following console application to allow for only two simultaneous instances of this application. Following is the code snippet:

using System;
using System.Threading;
using System.Reflection;
using System.Diagnostics;
using System.IO;

namespace ConsoleApplication1
{
    class Program
    {
        const string ApplicationID = "B45CFE7E-8E19-4a83-8782-859E006AD576";
        static void Main(string[] args)
        {
            Semaphore semaphore = null;
            string appName = Path.GetFileName(Process.GetCurrentProcess().MainModule.FileName);
            try
            {
                semaphore = Semaphore.OpenExisting(ApplicationID);
            }
            catch(WaitHandleCannotBeOpenedException)
            {
                semaphore = new Semaphore(2, 2, ApplicationID);
            }

            if (semaphore.WaitOne(0))
            {
                Console.WriteLine(string.Format("{0} is running", appName));
                Console.WriteLine("Press enter to exit.");
                Console.ReadLine();
                semaphore.Release();
            }
            else
            {
                Console.WriteLine(string.Format("Two Instances of {0} are already running.",appName));
                Console.WriteLine("Press enter to exit.");
                Console.ReadLine();
            }
        }
    }
}

This might not be the best scenario in which Semaphore should be used, but by this example i just want to show the concepts behind Semaphore and its potential use.

• If you haven’t read ReaderWriterLock, i would suggest read that first at http://www.sanjaysingh.net/2010/11/thread-synchronization-techniques_9866.html
• This class was introduced in .NET framework 3.5. This is similar to ReaderWriterLock but it has simplified rules for recursive locks and for upgrading and downgrading lock state and this avoids many cases of potential deadlocks.
• Microsoft recommends it for all future development.
• By default, new instances of ReaderWriterLockSlim are created with LockRecursionPolicy.NoRecusrion and therefore do not allow recursive lock calls. Contrast this with ReaderWriterLock which defaults to allowing recursive locks making your code more prone to deadlocks. For example, if the current thread entered read mode and it makes another call to acquire read lock, LockRecursionException is thrown. But remember that ReaderWriterLockSlim can also be instantiated to allow for recursive locks, and in that case this call will be allowed.
• A thread can enter lock in three modes -  read mode, write mode and upgradable read mode.
• Regardless of the recursion policy, only one thread can be in write mode at any given time. When one thread is in write mode, no other thread can enter the lock in any mode.
• Only one thread can be in upgradable mode at any given time.
• Any number of threads can be in read mode.

Below, i will give the same BookStore example explained in the above link using ReaderWriterLockSlim class. Behavior of the class remains same. Note the difference of use.

public class Book
{
    public string Title { get; private set; }
    public string Publisher { get; private set; }
    public string Author { get; private set; }
    public uint PublishYear { get; private set; }

    public Book(string title, string publisher, string author, uint publishYear)
    {
        this.Title = title;
        this.Publisher = publisher;
        this.Author = author;
        this.PublishYear = publishYear;
    }
}

public class BookStore
{
    private List Books = new List();
    private ReaderWriterLockSlim BooksLock = new ReaderWriterLockSlim();

    public BookStore()
    {
        // Populate Books
    }

    public void AddBook(Book newBook)
    {
        if (this.BooksLock.TryEnterWriteLock(2000))
        {
            try
            {
                this.Books.Add(newBook);
                Console.WriteLine("Book Added");
            }
            finally
            {
                this.BooksLock.ExitWriteLock();
            }
        }
    }

    public Book GetBook(string title, string author)
    {
        Book requiredBook = null;

        if (this.BooksLock.TryEnterReadLock(2000))
        {
            try
            {
                foreach (Book currBook in this.Books)
                {
                    if (currBook.Title.Equals(title) && currBook.Author.Equals(author))
                    {
                        requiredBook = currBook;
                        break;
                    }
                }
            }
            finally
            {
                this.BooksLock.ExitReadLock();
            }
        }
        return requiredBook;
    }

    public int GetBooksCount()
    {
        int count = 0;

        if (this.BooksLock.TryEnterReadLock(2000))
        {
            try
            {
                count = this.Books.Count;
            }
            finally
            {
                this.BooksLock.ExitReadLock();
            }
        }
        return count;
    }
}

• ReaderWriterLock class defines a lock that supports single writer and multiple readers. This is used to synchronize access to a resource. In situations where resource is changed infrequently, a ReaderWriterLock provides better throughput than normal locks like Monitor. A thread can hold a reader lock or a writer lock but not both. Every call to acquire a lock increases the lock count. So you have to call release lock as many times as you call acquire lock. Readers and Writers are queued separately. When a thread releases a writer lock, all threads waiting in the reader queue are granted reader locks. When all of those reader locks have been released, the next thread waiting in the writer queue, if any, is granted the writer lock, and so on. When a thread in the writer queue is waiting for active readers locks to be released, threads requesting new reader locks accumulate in the reader queue. This helps protect writers against indefinite blockage by readers. Most methods for acquiring locks on ReaderWriterLock accept time-out values. Use time-out to avoid deadlocks in your application.

Below, i will show the use of ReaderWriterLock class. We have a BookStore class and a Book class. BookStore class maintains a collection of Books. ReaderWriterLock makes perfect sense here because in BookStore write operation is less frequent than read operation (You get new books less frequently than number of customers that you have to cater to).

public class Book
{
    public string Title { get; private set; }
    public string Publisher { get; private set; }
    public string Author { get; private set; }
    public uint PublishYear { get; private set; }

    public Book(string title, string publisher, string author, uint publishYear)
    {
        this.Title = title;
        this.Publisher = publisher;
        this.Author = author;
        this.PublishYear = publishYear;
    }
}

public class BookStore
{
    private List Books = new List();
    private ReaderWriterLock BooksLock = new ReaderWriterLock();

    public BookStore()
    {
        // Populate Books
    }

    public void AddBook(Book newBook)
    {
        this.BooksLock.AcquireWriterLock(2000);
        try
        {
            this.Books.Add(newBook);
        }
        finally
        {
            this.BooksLock.ReleaseWriterLock();
        }
    }

    public Book GetBook(string title, string author)
    {
        Book requiredBook = null;
        this.BooksLock.AcquireReaderLock(2000);
        try
        {
            foreach (Book currBook in this.Books)
            {
                if (currBook.Title.Equals(title) && currBook.Author.Equals(author))
                {
                    requiredBook = currBook;
                    break;
                }
            }
        }
        finally
        {
            this.BooksLock.ReleaseReaderLock();
        }
        return requiredBook;
    }

    public int GetBooksCount()
    {
        int count = 0;
        this.BooksLock.AcquireReaderLock(2000);
        try
        {
            count = this.Books.Count;
        }
        finally
        {
            this.BooksLock.ReleaseReaderLock();
        }
        return count;
    }
}

AddBook method acquires writer lock and GetBook and GetBookCount method acquires reader lock. Note that we release lock in the finally block to ensure that lock is released whatever the case be.