Category Archives: C#

I was looking through some code the other day and ran across something that looked remotely familiar.  It was the null coalescing (??) operator.  I had read about this operator, but never used it.  It was introduced with the .NET 2.0 Framework.

The null coalescing operator basically checks to see if a value is null and if so returns an alternate value.  Below is a simple example.

View the C# code sample [HERE] 

Results

–

Related Content

• C# Conditional Operator ( ?: ) and Null-Coalescing Operator ( ?? ) – David Hayden
• The C# ?? null coalescing operator (and using it with LINQ) – Scott Guthrie
• ?? operator (C#) – DotNet Tip of the Day

–

“I am learning all the time.  The tombstone will be my diploma.” -Eartha Kitt

The GZipStream class is a part of the System.IO.Compression namespace. This class is used for the compression of data. Before the .NET 2.0 Framework, the only choice we had for compression were third party tools.

–

Common Methods (Full List)

• BeginRead – Begins an asynchronous read operation.
• BeginWrite – Begins an asynchronous write operation.
• Close – Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream.
• EndRead – Waits for the pending asynchronous read to complete.
• EndWrite – Handles the end of an asynchronous write operation.
• Read – Reads a number of decompressed bytes into the specified byte array.
• Write – Writes compressed bytes to the underlying stream from the specified byte array.

–

Below is a simple C# console application that takes an input file, compresses it and creates a compressed zip file.

View the C# code sample [HERE]

–

The command-line illustration below shows the application at work.

• If no argument is provided, the usage syntax is echoed to the screen
• If the argument provided cannot be located, error is echoed to the screen
• If correct argument is provided, the file is compressed and a new file is created

The result (compressed) file created.

View the compressed file in a Zip application.

–

The GZipStream class is not as feature-rich as the third-party tools, but it is a convenient way to compress data.

–

Related Content

• Using GZipStream for Compression in .NET
• How to: Compress Files
• Compression Application Sample

–

Happy programming…

A Delegate is a type that points to a method. Once a Delegate references a method, it behaves just like that method. This means it can be used like a method which includes parameters and return values. Unlike C++ function pointers, delegates are object-oriented, type safe, and secure.

Some Aspects of Delegates

Similar to C++ function pointers, but are type safe
Can be used to define callback methods
Multiple methods can be called on a single event
Methods are allowed to be passed as parameters

–

Delegate syntax

public delegate void Del(string message);

–

Source Code Example (C#)

Source Code Example (VBNET)

–

Result

–

Related Content
Delegates and Events in C# / .NET
C# Delegates Explained
The dark side of C# Delegates

–

Happy Programming.

In a previous post, I outlined the process of creating a DataSet graphically using the Visual Studio Data Set Designer. In this post, however, I am going to go through how to create a Date Set from scratch in code. Sometimes it takes doing something from scratch to learn more about the namespaces and classes.

The System.Data namespace provides access to the ADO.NET architecture. It contains several classes that are used to build and interact with data sets.

DataSet
DataTable
DataRow
DataColumn

The below example is simple, but it shows the classes in action.

C# Program Listing

using System;
using System.Data;

namespace CrtDataSet
{
    class Program
    {
        static void Main(string[] args)
        {
            //-- Instantiate the data set and table
            DataSet SongDS = new DataSet();
            DataTable songTable = SongDS.Tables.Add();

            //-- Add columns to the data table
            songTable.Columns.Add("ID", typeof(int));
            songTable.Columns.Add("Band", typeof(string));
            songTable.Columns.Add("Song", typeof(string));

            //-- Add rows to the data table
            songTable.Rows.Add(1, "Breaking Benjamin", "Diary of Jane");
            songTable.Rows.Add(2, "Three Days Grace", "Pain");
            songTable.Rows.Add(3, "Seether", "Fake It");
            songTable.Rows.Add(4, "Finger Eleven", "Paralyzer");
            songTable.Rows.Add(5, "Three Doors Down", "Citizen Soldier");

            //-- Cycle thru the data table printing the values to the screen
            foreach (DataTable table in SongDS.Tables)
            {
                foreach (DataRow row in table.Rows)
                {
                    Console.WriteLine(row["Band"] + " ~ " + row["Song"]);
                }
            }
        }
    }
}

C# Listing on GitHub

DataSet/DataTable in Debug Mode

Result to Console

–

In a future post, I will be exploring other classes of the System.Data namespace.

I have often had the need to programmatically copy files from one location to another. In C#, the System.IO namespace contains the classes needed to deal with file and directory operations.

In the below example, I use the following classes & methods:

Directory
.GetFiles – Returns the names of files in a specified directory.

File
.Exists – Determines whether the specified file exists.
.Copy – Copies an existing file to a new file.
.Delete – Deletes the specified file.

The illustration below shows the source files that are being copied.

–

C# Code Sample

using System;

using System.IO;

namespace FileCopy

{

  class Tester

  {

    public void Run()

    {

      //-- Setup directories and files

      string sourceDirectory = @"c:\temp\source\";

      string logFile = @sourceDirectory + "CopyTest.log";

      string targetDirectory = @"C:\temp2\target\";

      string[] dirs = Directory.GetFiles(sourceDirectory, "*.xls");

      int numOfFiles = dirs.Length;   //Gets the number of files in the directory

      if (numOfFiles > 0)

      {

        //-- Create/Open log file

        StreamWriter sw = new StreamWriter(logFile);

        sw.WriteLine("Source Directory: {0}", sourceDirectory);

        sw.WriteLine("Target Directory: {0}", targetDirectory);

        sw.WriteLine("");

        //-- Cycle thru the files copying to target then delete

        foreach (string fullFileName in dirs)

        {

          string cpyFileName = Path.GetFileName(fullFileName);

          //-- Set the copy from/copy to parameters

          string sourceFile = sourceDirectory + cpyFileName;

          string targetFile = targetDirectory + cpyFileName;

          //-- Call the copy method

          CopyFiles(sw, sourceFile, targetFile);

        }

        sw.WriteLine("");

        sw.WriteLine("Process Complete");

        sw.Close();

      }

    }

    void CopyFiles(StreamWriter sw2, string src, string tgt)

    {

      //-- Copy the source file to the target locations

      File.Copy(src, tgt);

      sw2.WriteLine("Copied " + src + " to " + tgt);

      //-- Delete the source file after making sure it was copied successfully

      if (File.Exists(tgt))

      {

        File.Delete(src);

        sw2.WriteLine("Deleted " + src);

      }

    }

    static void Main(string[] args)

    {

      //-- Create new instance of the tester class and execute the Run method

      Tester t = new Tester();

      t.Run();

    }

  }

}

--

–

The program also creates a log file and writes to it providing an audit trail.

–

Related Content
4GuysFromRolla.com : ASP FAQS : System.IO Namespace Classes

–

This post is to demonstrate a basic process of scanning directories recursively for files with a specified extension (ie *.txt or *.jpg).

The Directory class in the System.IO namespace is used to accomplish most of the task. The Directory class contains many useful methods. The two methods used are GetDirectories and GetFiles.

GetDirectories – retrieves the names of subdirectories in the specified directory.
GetFiles – retrieves the names of the files in a specified directories.

–

C# PROGRAM

using System;

using System.IO;

namespace DirTest

{

  class RecursiveSearch

  {

     static void Main()

     {

        //-- Request top-level directory path

        Console.WriteLine("Enter the top-level directory path to search in");

        string dir2search = Console.ReadLine();

        //-- Request the file extension

        Console.WriteLine("Enter the file extension to search for");

        string ext = "*." + Console.ReadLine();

        Console.WriteLine("");

        Console.WriteLine("<<-- Recursive File Listing for {0} in {1} -->>",ext.ToUpper(), dir2search.ToUpper());

        //-- Call method to recursivly search the directory

        DirSearch(dir2search, ext);

     }

     static void DirSearch(string dir2Search1, string ext1)

     {

        //-- If the directory input does not exist, an exception is thrown

        try

        {

            //-- Cycle through directories

            foreach (string d in Directory.GetDirectories(dir2Search1))

            {

                //-- Cycle through files in directory

                foreach (string f in Directory.GetFiles(d, ext1))

                {

                   Console.WriteLine(f);

                }

                //-- Search next directory

                DirSearch(d, ext1);

            }

        }

        catch (System.Exception ex)

        {

            Console.WriteLine(ex.Message);

        }

    }

  }

}

–

RESULTS

Invalid path entered

–

There are several possible uses for a recursive file search. One that pops into my head would be to search a hard drive for illegal file types or limit the amount of a file type (such as audio or video files).

.