One of the features that was included with C#/VB.NET is the idea of name-spaces, which are not necessarily a requirement to write object-oriented code, however do a a great job of creating a hierarchical class structure and generally keeping your classes, methods, enumerations, etc in non-spaghetti-code state.

What is a namespace?

A namespace can best be described as a collection of classes and enumerations.

An Example

Typically, you would want to put classes and enums together in a namespace that are related. For example, if you were considering making some C# code to represent the organization structure of a library, you might have a namespace for the library as a whole, then have sub-namespaces for different aspects of the library, such as the materials that can be rented out in a library, the library’s staff members, and its facilities.

Here’s what a hierarchical structure of namespaces might look like in a Library in C#

You’ll notice that name spaces can be hierarchically organized and that name spaces can contain both classes and enumerations. They can also hold delegates, interfaces and structs. They cannot directly include methods, which must be contained within a class.

Referencing a Class in a Namespace

If you were to create the class that we just made above and put it into a C# application (most likely in the app_code folder), this is how you would create some of the classes above:

AdministrationBuilding -  Library.Facilities.AdministrationBuilding thisBuilding = new Library.Facilities.AdministrationBuilding();

Journal – Library.Materials.Periodicals.Journal thisJournal = new Library.Materials.Periodicals.Journal();

BookType - Library.Materials.BookType thisType = new Library.Materials.BookType();

Making Good use of the Using Declaration

If you plan to make use of a namespace a lot on a particular form, web-form, or any other C#/VB file, you can import the namespace directly on the page much in the way that you might import one of the inherited namespaces under the “System” class.

When doing development, if you wanted to create a DataTable object, you would probably want to add “using System.Data;” to the top of your page so that you can reference the variable type by just using “DataTable ThisTable” rather than “System.Data.DataTable ThisTable”.

You can also do this with your own namespaces.

Here’s how you would import the “periodicals” namespace in C# –   using Library.Materials.Periodicals;

Here’s how you would import the “periodicals” namespace in VB.NET — Imports Library.Materials.Periodicals

Now, instead of creating a journal like we did above, we could simply write “Journal thisJournal = new Journal();” to create a new object of type Journal.

Here are a few other good resources on Namespaces:

• Creating and using Namespaces in VB.NET and C# (VB.NET Heaven)
• Using Namespaces (MSDN)
• Namespaces in C# (C Sharp Help)

The first is with a traditional string concatenation, which would look something like this:

string MyString = String.Empty;
MyString = “Hello ” + “World”;

The second way, is using the StringBuilder library, which would look something like this:

StringBuilder MyString = new StringBuilder();
MyString.Append(“Hello “);
MyString.Append(“World”);

These two sets of code do basically the same thing, but is it preferable to use one over the other? It turns out, that the StringBuilder class is much, much more efficient when dealing with large sets of strings. For short strings, with fewer than five concatenations, chances are you’ll be better off with traditional string concatenation because you don’t have to instantiate a copy of the StringBuilder library, but for situations that you want to do a lot of string manipulation, you definitely want to use the StringBuilder library.

Here’s a synthetic test using C# and ASP.NET comparing the two:

        Trace.IsEnabled = true;

        StringBuilder StBuilder = new StringBuilder();
        Trace.Write(“String Builder Append Begin”);
        for (int x = 0; x < 10000; x++)
        {
            StBuilder.Append(“Testing123″);
        }
        Trace.Write(“String Builder Complete”);

        string stString = String.Empty;
        Trace.Write(“String Concatenation Beginning”);
        for (int x = 0; x < 10000; x++)
        {
            stString += “Testing123″;
        }
        Trace.Write(“String Concatenation Complete”);

The test concatenated the string 10,000 times. Although it’s a synthetic test, it shows that the StringBuilder class is substantially more efficient than the string class for concatenation. The string class concatenated the text in 5.292587 seconds. The StringBuilder class performed the same task in just 0.006142 seconds. In other words, the StringBuilder was over 850 times faster at concatenating the string than the string class was.

Now that’s a performance benefit!

By default, ASP.NET will add the following references to your page:

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;
using System.Data.SqlClient;

In a library that I was using, I was able to pair those down to these five libraries:

using System;
using System.Web;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;

After removing the un-necessary libraries, the page load time decreased by nearly half of a second. If you were to do this with all of your libraries and pages, chances are you could see a pretty significant performance increase.

As I write this article, It’s about 75 degrees and Sunny outside. When I should be going out on a bike ride, instead I’ve opted to play with Twitterizer (an ASP.NET Twitter Library). Twitterizer is an ASP.NET library that lets you interact with the Twitter API using easy to use objects and methods. It will work with any of the .NET variants (C#, VB, J#, Windows Forms, ASP.NET, WPF, etc). I added the functionality into the 360 Web Content Management System and I thought I’d share with you how I did it.

Here’s how to retrieve twitter feeds in ASP.NET

(1) Get a copy of the Twitterizer Library

First, you’ll need to get a copy of the Twitterizer Library from Google’s Codebase. The download is pretty small and contains only the application library (DLL) you need. Create a new website in ASP.NET and extract the twitterizer library to the /bin/ folder so that you can use it.  Once you have it placed in your /bin/ folder, add a “using” reference to the library in the header of your page.

using Twitterizer.Framework;

(2) Create a “Twitter” object and Retrieve Your Status Updates.

The library contains a few different objects that you can create. A “Twitter” object is the most generic object that you can create. Creating an instance of this object using your username and password gives you all the functionality you would normally have in Twitter, but instead of using the Twitter web interface, you’re using C# or Visual Basic. First, we’ll need to instantiate the object, and then get a collection of status updates from your account.

Twitter thisUser = new Twitter(“UserNameHere”, “PasswordHere”);
TwitterStatusCollection thisCollection = thisUser.Status.UserTimeline();

(3) Loop Through Your Status Updates and Generate Some HTML

The “TwitterStatusCollection” object type is a list of “TwitterStatus” objects, so you can use a foreach loop and go through your most recent status updates. You’ll notice in the code below that I also do some basic work with the time of the status update to generate a hyperlink to the page of the status, similar to what Twitter does.

string TwitterCode = “”;
foreach (TwitterStatus thisStatus in thisCollection)
{

TimeSpan thisSpan = new TimeSpan();
thisSpan = DateTime.Now.Subtract(thisStatus.Created);

string TimeBetween = “”;
if (thisSpan.Days > 0) { TimeBetween = thisSpan.Days.ToString() + ” days ago”; }
else if (thisSpan.Hours > 0) { TimeBetween = thisSpan.Days.ToString() + ” hours ago”;}
else if (thisSpan.Minutes > 0) { TimeBetween = thisSpan.Days.ToString() + ” minutes ago”;}
else if (thisSpan.Seconds > 0) { TimeBetween = thisSpan.Days.ToString() + ” seconds ago”;}

TwitterCode += “<div class=’TwitterStatus’>” + thisStatus.Text + ” <a href=’http://twitter.com/” + thisStatus.TwitterUser.UserName + “/status/” + thisStatus.ID + “‘>” + TimeBetween + “</a></div>”;
}
(4) Display Your Tweets

You now have a string with your most recent twitter status updates that you can display on the page using a simple Response.Write() or you can display it in a label. You can see a variation of this code running on the “Twitter” page for the 360 Web Content Management System.

You can also download a copy of my sample code.

Here’s how to implement the ASP.NET Color Picker Control

(1) Download the library and add it to your project

First, download the library from the ASP.NET Color Picker Control website. Make sure to download the latest binary release from the website. Currently that version is ASP.NET Color Picker v.1.4.10423.1 Binary. Once you get the zip file, it will contain a library that you should extract to the /bin/ folder of your website.

(2) Register the library on your page

ASP.NET provides a set of standard controls that you can add to a page that start with the “ASP” prefix, such as “<ASP:TextBox runat=”server” id=”txtBox” />. Any custom controls will have their own prefix that you specify by registering the library on the page. It’s another line of code that you add to the top of the page next to your page definition. It should look something like this:

<%@ Register Assembly=”Karpach.WebControls” Namespace=”Karpach.WebControls” TagPrefix=”cc1″ %>

(3) Add the control to your page

Now that you have the library referenced, you can add the control to your page and make use of it.  For the purpose of this demo, I’m going to set the AutoPostBack property to true and run a function whenever the color is changed. This will show us the color that we picked inside of a label (also shown below) after we select a new color.

<cc1:ColorPicker ID=”colorBackgroundColor” runat=”server” AutoPostBack=”true” OnColorChanged=”chngColor” />
<br /><br />
<asp:Label ID=”lblResults” runat=”server” Text=”"></asp:Label>

(4) Create Your C# Function

After we choose a color, we have to do something with it. With the ColorPicker control above, I’m using the OnColorChanged property to call the “chngColor” function, which in C# will look something like this. This will also demonstrate how to programmatically read the color chosen with the .Color property of the ASP.NET Color Picker Control

protected void chngColor(object sender, EventArgs e)
{
lblResults.Text = “<div style=’background-color:#” + colorBackgroundColor.Color.Replace(“#”, “”) + “;height:50px;width:80px;text-align:center;padding-top:35px;’>Sample Text</div>”;
}

(5) Success

So far, we’ve added the library to our project, registered the library on the page, added the control to the page, and done something with the color chosen by the user. Your page should look something like this:

You can download my sample program here.

Exception Details: System.FormatException: The specified string is not in the form required for an e-mail address.

Ouch. To remedy this issue, I added a check to make sure the email address was valid before it attempted to send the message. In the code below, I’m making use of the System.Text.RegularExpressions library that comes with the .NET framework. The code below is written in C# but the code will be very similar in Visual Basic. It will also work in ASP.NET, WPF or plain old windows forms.

Here’s a C# function that will determine whether or not an email address is valid:

public static bool IsValidEmail(string strEmailAddress)
{
if (strEmailAddress == null)
{
return false;
}
else
{
return System.Text.RegularExpressions.Regex.IsMatch(strEmailAddress, @"^[-a-zA-Z0-9][-.a-zA-Z0-9]*@[-.a-zA-Z0-9]+(\.[-.a-zA-Z0-9]+)*\.(com|edu|info|gov|int|mil|net|org|biz|name|museum|coop|aero|pro|[a-zA-Z]{2})$", RegexOptions.IgnorePatternWhitespace);
}
}


I also made some modifications to the system on the front-end, so when a user registered from then on, that it would validate that they have entered an email address and that the email address matched the format of an email address using a RequiredFieldValidator and a RegularExpressionValidator.<–>

Today, we’re going to encrypt a string with SHA-2, specifically the SHA-512 derivation of SHA-2, which should hypothetically be more secure than SHA-1 because it has a longer message digest than SHA-1. The example code I’m going to show off today also uses a “salt“, whereas the previous function I showed off didn’t. This will make your hashed-passwords more immume to dictionary attacts because not only would the hacker have to develop a hash for every commonly known password, but as well as every commonly known password multiplied by the nearly infinite number of possible salts.

Here’s the function:

    public static string CreateSHAHash(string Password, string Salt)
    {
        System.Security.Cryptography.SHA512Managed HashTool = new System.Security.Cryptography.SHA512Managed();
        Byte[] PasswordAsByte = System.Text.Encoding.UTF8.GetBytes(string.Concat(Password, Salt));
        Byte[] EncryptedBytes = HashTool.ComputeHash(PasswordAsByte);
        HashTool.Clear();
        return Convert.ToBase64String(EncryptedBytes);
    }

How it works:

This method makes use of the System.Security.Cryptography class. It combines your password and the salt that you provide and  turns it into a byte-array. It runs those bytes through the has computation function provided by the class and returns an 88-bit string of the message-digest/hash that’s created.

The source code to check a user’s credentials in Active Directory using C# or Visual Basic is actually fairly minimal. This works with both ASP.NET and with Windows Forms  (or WPF for that matter) if you’re building a desktop application.

Here’s how to do it:

(1) Reference the appropriate library

You’ll need to make use of the System.DirectoryServices library that comes with Visual Studio. You can add this to your ASP.NET code-behind page or your C# class for your Windows forms like this.

using System.DirectoryServices;

(2) Create An Authentication Function.

Here’s a basic function that will check a user’s permissions on a given domain. Essentially, it will try to create an Active Directory entry using the provided credentials, and it can successfully create a valid entry, we know that the user is authenticated. Otherwise, it’ll return false.

public bool AuthenticateActiveDirectory(string Domain, string UserName, string Password)
{
try
{
DirectoryEntry entry = new DirectoryEntry(“LDAP://” + Domain, UserName, Password);
object nativeObject = entry.NativeObject;
return true;
}
catch (DirectoryServicesCOMException) { return false; }
}

That’s really all there is to it. Microsoft has an extensive aritcle on MSDN that covers active directory authentication in .NET that you might want to check out as well.

ASP.NET does a particularly good job of offering the ability to resize photos. The System.Drawing library that comes with .NET allows you to resize photos extremely well with just a few lines of code, and place it in the format that you’d like.

Here’s how to resize photos in the .NET Framework:

(1) Reference the appropriate libraries.

The example code below will be in C#, but it will work basically the same way for Visual Basic or J#. You’ll need to reference the System.IO library to read and write the files, as well as the System.Drawing library and the System.Drawing.Imaging library. To do this, simply add the following lines to the top of your code-behind page.

using System.IO;
using System.Drawing;
using System.Drawing.Imaging;

(2) Load the OriginalImage

The following three lines of code will take an existing image that you can set programmatically, say if you want to connect it to a photo gallery module in a database, and create a bitmap/image object that you can use to resize the image:

string UploadPath = Server.MapPath(“/images/”);
string FileName = “OriginalImage.PNG”;
Bitmap OriginalBM = new Bitmap(UploadPath + FileName);

(3) Determine The New Size

Typically you’ll want to keep the aspect ratio the same, but you can set them statically if you’d like.  Here’s some code that will create two variables for the height and the width. We set the width statically based on what we’d like to use, then the height is based on the aspect ratio of the original image so that the image is not stretched.Finally, we’ll create a “Size” object that will be used for the resizing

float AspectRatio = (float)OriginalBM.Size.Width / (float)OriginalBM.Size.Height;
int NewWidth = 800;
int newHeight = NewWidth / AspectRatio;
Size newSize = new Size(NewWidth, newHeight);

(4) Resize and Save the Photo

Once you have a new “Size” object created, we can create a new Bitmap/image object with the new size that we specify and save it in the format of image that we’d like. In this case, I’m saving it as a Jpeg file, but you can also save it as a PNG, GIF, or Bitmap file if you’d like.

Bitmap ResizedBM = new Bitmap(OriginalBM, newSize);
string newfilepath = UploadPath + “resized_” + FileName.Replace(@”\”, @”");
ResizedBM.Save(newfilepath, ImageFormat.Jpeg);

Here’s how to export data from a GridView in ASP.NET:

(1) Create a Grid View

First, we’ll need a GridView control on the page that we can load our report or table into.

<asp:GridView ID=”GridView1″ runat=”server”></asp:GridView>

(2) Disable Event Validation

Because we will be creating a fresh HTTP response, ASP.NET’s event validator will likely run into an error. Specifically, the message you would receive is “Invalid postback or callback argument.” In order to get around this, we need to disable event validation for the page that is used to export to excel. To do that, add the following tag to the top of your .ASPX page:

<%@Page EnableEventValidation=”true” %>

(3) Add data to your GridView

At this point, you’ve got everything you need done on the HTML side of things, and it’s time to write some C# (or VB or J#) if you prefer. The first thing we need to do in our server-side code is to add data to the gridview. In the code below, I’m using a function from the database utilities library mentioned earlier this month to get the data and return it as a DataTable. You’re more than welcome to use whatever data-access code you would like to pull the resultset you would like to get from the database. This code will most likely end up in your Page_Load() function.

DataTable dtResults= SQLSelect(“Select * from Users”);
GridView1.DataSource = dtResults;
GridView1.DataBind();

(4) Building your export-to-excel function

You’ll need about 10 lines of code to make the actual export happen. Essentially, it creates a new HTTP response, re-renders the gridview and puts it in a downloadable XLS format. You can either put this in your Page_Load() function or in the event handle for a button if you would like to preview the gridview before exporting it.

Here’s the export code:

Response.Clear();
Response.ContentType = “application/ms-excel”;
Response.Charset = “”;
Page.EnableViewState = false;
Response.AddHeader(“Content-Disposition”, “inline;filename=report.xls”);

System.IO.StringWriter tw = new System.IO.StringWriter();
System.Web.UI.HtmlTextWriter hw = new System.Web.UI.HtmlTextWriter(tw);

GridView1.RenderControl(hw);

Response.Write(tw.ToString());
Response.End();

(5) Override the VerifyRenderingInServerForm Method

Add this function to your C# class for the page to prevent a rendering error:

public override void VerifyRenderingInServerForm(System.Web.UI.Control control)
{
//confirms that an HtmlForm control is rendered for the
//specified ASP.NET server control at run time.
}

(6) You’re done!

That’s really all it takes. If you’d like a good example file, you can download one from ASPAlliance.

Other Resources:

You might also be interested in reading these articles about exporting files to excel:

• How to Export Data to Excel from an ASP.NET Application + Avoid the File Format Differ Prompt (MSDN Blogs)
• CodeSnip: Exporting GridView to Excel (CodeSnip)
• ASP.Net 2.0: Export GridView to Excel (C-Sharp Corner)