But, today we’re seeing a shift where organizations have a need to present customized solutions to the outside world. This can be anything from a fully public website to a site restricted to vendors, dealers or the like. This also means that we have to be able to present designs that hold up well across a wide variety of browsers and look good doing it, even on internal facing web apps. This is especially true as internal users are increasing usage of Apple and Android smartphones and tablets.

CSS Based vs. Table Based Page Layouts

From what I’ve seen, most ASP.NET developers tend to get stuck around 1998 when it comes to laying out a web site. Typically, they’ll use tables, including nested tables, to layout screen elements. Many ASP.NET developers have told me that they have trouble with understanding DIVs and other CSS elements and therefore avoid them.

The most common argument you’ll see against using tables for layout purposes is that tables are intended for displaying tabular data, not laying out the web page. But, the reason to use a CSS based design rather than an old fashioned table layout goes deeper than that.

First of all, using CSS makes it easy to maintain visual and code consistency throughout a site and across other related sites and makes the site more visually appealing, usable and accessible to visitors. One place I often see this is with data entry screens where spacing of entry controls and matching labels can lead to a hodgepodge of layouts that are difficult to modify and maintain. One developer may use many levels of nested tables and in-line styling while another uses a combination of <br>, &nbsp; and transparent gifs to handle spacing. The positioning of each and every screen element is handled differently on each and every page, making the site difficult for developers as well as users.

Next, a good CSS design insures that redesigns and even simple changes can be done more efficiently and less expensively. When things like nested tables and transparent gifs are used to layout pages, it can create a situation where even simple modifications can become time consuming exercises. For example, changing a company logo design or position to meet the latest whims of the marketing department can mean hours, if not days, of tedious work. With a consistent CSS design, you can prevent this kind of headache.

Lastly, using a standard and modern CSS design helps present your site better across multiple browsers as well as improving performance. As more and more visitors show up with Apple iOS and Android based smartphone and tablet devices this aspect becomes more important. Table based sites, especially those that use nested tables, tend to perform poorly on mobile browsers.

So, should you never use tables for web page layouts? While it is something to avoid in general, you may encounter situations where a table layout is the best solution. This is sort of like finding situations where a “GoTo” statement is useful, although a little bit more common. If you must use a table layout, do make sure that you avoid nested tables and using HTML elements or gifs to handle spacing. Instead, use CSS code, such as margins and padding, to handle as much positioning as possible.

Basic CSS Design Rules For ASP.NET Sites

Now, let’s go over a few things that will help you design better ASP.NET web pages.

First of all, I highly recommend building a template site that uses your CSS framework and contains your master pages and empty or stripped down templates of the different types of web pages you’ll be displaying. This prototyping technique works well for both WebForms projects and MVC projects. Having this kind of guideline to follow will greatly help new people coming into your project and help keep all team members on the same ‘page’ so to speak. Things can get really ugly on a site when everyone is doing their own thing rather than following a common user interface standard template.

I also suggest that you use a naming convention for CSS elements. This makes it easier for other people on your team to figure out what element to use in a particular situation. Along with this, I suggest using the ‘id’ rather than ‘class’ attribute for common elements like the page header and footer. This helps identify their unique status on the page and can prevent accidental usage of a style.

Next, avoid inline style attributes as much as possible. There can be special cases when this is necessary but, as much as possible, keep CSS in the CSS file(s). Another thing to avoid using are older HTML styling elements like <font>, <b> and <i>. Instead using spans and CSS styles. This insures visual consistency and maintainability.

Finally, don’t fall into the trap of replacing empty cells and spacer GIFs with spacing divs. (Yes, I’ve made this mistake myself.) Instead using margins and padding to position your screen elements. If you layout your page designs well it’s very unlikely you’ll need to have spacing crutches on your pages.

Common CSS Grid Frameworks

It may seem like quite a task to come up with a style sheet that handles a page layout easily and consistently. There’s a lot that goes into it ranging from properly resetting HTML elements to selecting common sizing and typography to cross-browser compatibility. Fortunately, a lot of this work has been done for you. All you need to do is download the CSS frameworks and plug in your own styling where applicable.

The two systems I’ve used are the 960 Grid System and the Blueprint CSS system. Both are easy to understand and apply to a site. There are also several modifications to them around that you can download for use in custom situations like mobile device sites and floating layouts. Using one of these common CSS grid based systems is perhaps the easiest way to simplify using CSS in your ASP.NET site designs.

By doing a little planning up front and by using a common CSS grid framework you can get away from using antiquated table based layouts and improve the quality of your ASP.NET websites.

First of all, the difference between a non-static and a static class in C# is simply that a static class cannot be instantiated. This means that you don’t use the new keyword to instantiate an instance of the class. Instead, you will access members of the static class by using the class name. Basically, a static class is intended to be a container for a set of methods that only work with supplied parameters and don’t have a need to store or retrieve data that is unique to them. An example of a static class that’s built into the .NET Framework is the System.Math class. It contains methods which perform various mathematical operations.

A static class is like a regular class that only has static members and has a private constructor. If you have a class like this in your design it’s best to make it a static class in order to use the features in the compiler which will insure that instances of the class cannot be created or inherited. By taking this step it will make your code more solid.

Sometimes there is confusion between a static class and a singleton class where only one instance is allowed. The way to separate them is to understand that the static class should not have any internal variables, each method should function independently, like a function library. However, a singleton class may expose internal values as properties and allow the storage and retrieval of these values.

As I mentioned above static classes cannot be instantiated. Instead, the Framework will call the private constructor for the static class prior to the first place the class is referenced in code. This allows you to blend in your function library seamlessly into your program so if you had a static class like this…

public static class MyFunctions
    {
        public static string Test1(string myValue)
        {
            // Code
        }

		public static int Test2(int myValue)
        {
            // Code
        }
    }

…you can call it like so…

MyFunctions.Test1(CurrentValue);

…without having to create an instance of the object using the new keyword (which you can’t do with a static class anyway). Also, a static class will remain in memory for the lifetime of the application domain where it is created.

As you can see in the example above, a static class can only contain static members. The program won’t compile if you don’t remember to mark each of them as static. Also, static classes are sealed, which means that they cannot be inherited and cannot inherit from any class other than System.Object. While a static class cannot have an instance constructor, they can have a private, static, constructor. This routine will be called when the Framework creates the instance of the object.

One thing to bear in mind here is that if your static class requires a lot of extensive initialization it may not be a good candidate for a static class. In my view, these classes are intended for groups of related, but essentially standalone, functions. Having a substantial initialization routine may indicate that the class might work better as a singleton class or as a regular class. Taking this into consideration early on can prevent you from having to recode a static class into something else.

To start with, let’s take a look at what Extension methods are. Extension methods in C# allow you “roll your own” methods into existing types without having to create a new derived type. Extension methods are placed in a static class, but, by using a special syntax, they are called as if though they belonged to the original type. In your C# code calling an extension method looks the same as calling a method defined by the base type.

So, let’s take a look at how your would define a class that held Extension methods. Here’s how I’m starting out my Random Extensions class.

public static class RandomExtensions
{

You don’t have to define the whole class as static. You can define it normally if you want. I’ve just found it better myself to treat these classes just like I would static function classes I’ve done before. I also create a separate class for each method I’m extending instead of doing a ‘grab bag’ of unrelated functions. This helps keep things better organized, something that’s quite important when using extension methods.

Now let’s look at some of my functions.

One thing I like to do is to reseed the randomization on each call. There is, of course, some overhead in doing this but I find the improved level of random results to be worth it. To do this, I create a function called Increment that pushes the random counter a variable distance using the Next method and the current time in milliseconds and seconds. Here’s the function…

public static void Increment(this Random rand)
{
    int value = DateTime.Now.Millisecond + DateTime.Now.Second;
    for (int Counter = 0; Counter <= value; Counter++)
    {
        rand.Next();
    }
}

Notice how the extension method is defined with the ‘this’ followed by the type name and then variable name. This is what tells the .Net framework that this is an extension of the Random type.

One of my long running gripes about the .NET Random type is with the range overload built into the Next method, specifically that the maximum value isn’t inclusive. Therefore, if you do RandomInstance.Next(1,6), like you would to simulate a dice, you would only get values back from 1 to 5. Instead, you would need to use (1,7) to get values from 1 to 6 back. It’s too late for Microsoft to change this behavior since it would break too much existing code. But, if you want, you can use extension methods to change it for you in your code while leaving the default behavior intact. I did my own function that included the given max value in the range. Here’s the function…

public static int Range(this Random rand,int low, int high)
{
    rand.Increment();
    return rand.Next(low, high + 1);
}

Here you’ll see I increment the random value prior to the value between retrieved via the Next method. This gives an extra touch of randomization.

Another useful function I’ve needed from time to time is a way to build a random sequence of integers I can use to access data randomly. For example, if I wanted to select 10 random records from a database table that had an integer primary key, this function would help me to grab a random selection of records. Another use, which I’ll show below, is to help in scrambling the contents of a list.

To create the random sequence, I’m using a Queue generic type. This allows me to automatically remove used number from the list and thus makes it easier to manage. Here’s the function…

public static Queue SequenceQueue(this Random rand, int max)
{
    Queue ReturnValue = new Queue();
    while (ReturnValue.Count <= max)
    {
        int Result = rand.Range(0, max);
        if (!ReturnValue.Contains(Result))
        {
            ReturnValue.Enqueue(Result);
        }
    }
    return ReturnValue;
}

As you can see, I use my Range method to load in values to the Queue.

I also have a related method called Sequence that returns a generic List instance rather than a Queue. This is useful when you want to use a random sequence in a LINQ query. Here’s an example of this technique working with a LINQ-to-SQL datasource…

Random Rnd = new Random();
TestDataContext TestData = new TestDataContext();
int MaxTest = (from items in TestData.TestItems select items.ID).Max();
List RandomIDs = Rnd.Sequence(1,MaxTest,10);
List ItemList = (from item in
                 TestData.TestItems.Where(item => RandomIDs.Contains(item.ID))
                 select item).ToList();

My last Random extension method, Scramble, scrambles up the contents of a generic list. One place a routine like this could be used is in a card game, where the members of the original list were the card objects.

public static List Scramble(this Random rand,List inputList) where T : IComparable
{
    List ReturnList = new List();
    Queue RandomQueue = rand.SequenceQueue(inputList.Count-1);
    while (RandomQueue.Count != 0)
    {
        ReturnList.Add(inputList[RandomQueue.Dequeue()]);
    }
    return ReturnList;
}

You can download my full RandomExtensions class here. In addition to the methods shown above, it also contains some additional overloads that I’ve found useful.

That wraps up this example of an extension to the Random type. Let me know if you see any problems with it or if you have any questions or thoughts about it by leaving a comment below.

There are two types in C#, class and struct, and the .NET Framework deals with them in different ways.

Structs are the value type. In addition to defined structs this also includes primitive value types like bool, int, and char. When a Struct, or value type, instance is created a single memory space is allocated to store the value. When the framework is dealing with a value type it deals directly with the memory location. This is quite efficient for simple data such as numbers and single characters.

Classes are the reference type. Unlike structs, memory for classes is accessed indirectly through pointers. Each instance points to a different section of memory. This allows a greater degree of flexibility while incurring a performance cost. Fortunately in C#, unlike C++, we don’t have to worry about managing pointers to our data, the runtime handles it for us.

When we consider strings in C# it can get confusing since, although they’re a reference type, they behave somewhat like a value type too. For example, we can use the equal sign to set the value of a string from another string just like we do for integers. This is different than how we set the value of a new object we’ve defined in our code or, for that matter, other classes in the Framework. However, behind the scenes, the .NET Framework is allocating memory for separate instances for each string for us.

This ‘shorthand’ can cause you to think that a string is a value type and not a reference type. That’s why we have to be careful in order to avoid performance sapping operations like looping string concatenations. Each iteration of such a loop causes new instances to be created in a different memory area. As the string builds, considerable resources are used to construct the string over and over again. That’s why using StringBuilder is preferred in this situation since it doesn’t allocate a new string for each concatenation operation.

I hope this answers the question, “Is a C# String a Value Type or a Reference Type?” for you.

In C#, there are several different kinds of casting you can use depending upon the situation.

The first type of casting we’ll look at is the standard C++ and Java syntax style casting. C#, being akin to these languages, uses this same syntax.

string MyString = (string)MyObject;

This is sometimes called explicit casting. The casting operation is applied to the full equation to the right. So, in this example, Var1 would not be cast by itself but the entire equation, Var1+Var2 would be.

string MyString = (string)Var1+Var2;

There may also be occasions when you do only want to cast part of an equation chain. In that circumstance, you can use parentheses to indicate the part you wish to cast, as shown here:

string MyString = ((Form)MyObject).Text;

In this example, we’ll be converting the variable MyObject to a Form and then extracting the Text property from the newly cast Form object.

It is important to note that if a particular value cannot be cast as a particular variable type either the program won’t compile or a runtime exception will occur. Which happens depends on if the compiler can detect the problem.

The second type of C# casting is the ‘as’ casting operator. It works just like the explicit casting except that, in the case of a conversion failure, it will cause the value to be set to null rather than throwing an exception. However, it is important to remember that you can only use this kind of casting for reference and nullable variable types and not for non-nullable types like integers. Here’s an example of using the as casting operator.

Object MyObject = new TextBox();
Button MyButton = MyObject as Button;

I hope this has helped go over the basics of casting variables in C# for you.

Interfaces in C#

An interface in C# is simply a template for a class. It’s part of how C# implements polymorphism.  An interface doesn’t contain any code, only definitions of methods, properties, events and indexers. A class that implements an interface will need to define the code used for these items. Here’s a short code snippet of an example C# interface…

public interface IMyItem
{
    int Id { get; set; }

    string Description { get; set; }

    string RunTest(int testNumber);

    event EventHandler TestStatus;

    string this[int index] { get; set;}
}

In this example, the interface includes two properties, a method, an event and an indexer. A class that used this interface would need to provide code for these items. While the code doesn’t have to do anything, it does have to be implemented by the class using the interface.

One powerful thing that you can do with interfaces is that you can have a class that implements more than one interface. One of my favorite usages is to not only implement a program specific interface but to also implement a generic List or Queue.

Abstract Classes in C#

An abstract class in C# is a class that can’t be instantiated and, like an interface, is intended to provide a common class definition that is shared by derived classes. Like an interface, the routines in an abstract class may be methods, properties, indexers and events. Unlike an interface, an abstract class may contain code although it may also have abstract methods that do not have code. Also, an abstract class may define constructors and destructors while an interface does not as well as internal private and protected variables.

Here’s a simple example of a C# abstract class…

public abstract class TestItem
{
    private int _testId;

    public TestItem(int testIdValue)
    {
        _testId = testIdValue;
    }

    public int TestId
    {
        get
        {
            return _testId;
        }
        set
        {
            _testId = value;
        }
    }

    public abstract string Description { get; set; }

    public abstract void RunTest(int i);

    public abstract string this[int index] { get; set; }
}

As you can see above, there is code in the constructor and one of the properties while the rest of the routines are marked with the abstract keyword to indicate that their implementation is left up to the derived subclass. The routines marked as abstract have to be implemented in code by the derived class, they aren’t optional. However, the routines that are implemented in code by the abstract class do not have to be implemented in code by the subclass. However, routines that have code in the abstract class can be overridden if they’re marked with the virtual keyword.

Here’s an example of a class that is derived from the abstract class above…

public class Tester : TestItem
{
    public Tester(int testIdValue) : base(testIdValue) { }

    public override string Description { get; set; }

    public override void RunTest(int i)
    {
        //call test routines
    }

    public override string this[int index]
    {
        get
        {
            // process and return some data
        }
        set
        {
            // process and assign some data
        }
    }
}

Note that we need to use the override keyword to indicate to the Framework that a particular routine is overriding the base abstract class’ routine definition. Also see that the class doesn’t have an implementation of TestId property, it uses the code in the abstract class instead. One tricky part is in our constructor. We have to define a constructor or else the compiler will present this error: “[classname] does not contain a constructor that takes 0 arguments”. To avoid this error, we have to define a constructor and pass the value on to the base class code as seen in the example code above.

Abstract Class vs. Interface in C#

But, when should you use an abstract class instead of an interface and vice versa? Either technique provides a way to have a common definition for a class although interfaces are a form of polymorphism and abstract classes are a form of inheritance, from an OOP perspective. Let’s see what this means in practical terms.

Let’s assume that we’re working on an inventory and invoicing system that has several different user types, such as vendor, dealer, distributor, employee and so forth. As we look at the system, it’s obvious we’ll be handling users will be the same for all users so it makes sense to have a user abstract class that we can derive our classes from for our various types. In this context, an interface probably wouldn’t make sense because there would probably be similar implementation needs across the spectrum of users. So, we might have an abstract base class called User that would have subclasses for each type of user.

Now, let’s assume that in our system we wanted to standardize how programmers working on the project defined common functions such as duplicating records. On a large project, it can get confusing with everybody defining things their own way, so, by using a common interface standard a lot of this confusion can be eliminated. For example, an IDuplicate interface could be used for users, invoices, inventory items and so forth in the project. The actual code might be considerably different but the interface is the same across the board in the project. Also, remember that C# is single inheritance, you can include more than one interface. Therefore, a class could implement an IDuplicate interface as well as other interfaces you might define or ones that you might borrow from the .NET Framework, such as IList.

I hope this has helped you get the differences between abstract classes and interfaces in C# clearer in your mind.

Reference Conversion

A reference conversion is simply converting a variable from one reference type to another. Reference conversions can be either implicit or explicit. This conversion never changes the referential identity of the object which is being converted. This means that although the conversion could change the reference type, the type or value of the referred to object is never changed.

Boxing and Unboxing Conversion

A boxing conversion allows any value type to be converted to the type object or to any interface type that is implemented by the value type. Boxing a value means allocating an object instance and then copying the value to that instance.

Unboxing is an explicit conversion. It converts from the type object to a value type or from an interface type to a value type which implements the interface. Unboxing involves checking the object instance to insure that it is a boxed value of the given value type. The next step in the unboxing operation is copying the value from the instance into the value type variable.

It is important to remember that you should avoid boxing/unboxing operations in cases where you’re needing to do repetitive assignments. By avoiding this overhead you can improve the performance of your program.

The definition of polymorphism is when different types of objects use the method or properties with the same name. Therefore, the programmer doesn’t need to know the exact type of an object while coding the application. The precise behavior of a method or property is determined at run-time. In the context of C# and .NET, this primarily means interfaces. Another form of polymorphism in C# is operator overloading, for example, where the + operator can be used to add numbers or concatenate strings. But, for our discussion here we’ll primarily discuss interfaces.

C# Interfaces

While some other languages use other methods to provide polymorphism, C#’s single-inheritance design makes interfaces the way to accomplish this technique. Remember that unlike an abstract class, an interface only defines the behavior, it doesn’t implement it.

Here’s a simple example of what an interface in C# looks like…

public interface ITestItem
{
    int TestId { get; set; }

    string TestDescription { get; set; }

    string RunTest(int testNumber);
}

In this interface, we’re defining two properties and one method. To implement this interface in a class, we would need to indicate that we’re using the interface and provide an implementation for the routines defined in the interface, as seen here…

public class TestGroup : ITestItem
{
    DateTime _testDateTime;

    public TestGroup()
    {
        //load without a parameter
    }

    public TestGroup(string testinfo)
    {
        //load with a parameter
    }

    public int TestId { get; set; }

    public string TestDescription { get; set; }

    public DateTime TimeStamp
    {
        get{return _testDateTime;}
    }

    public string RunTest(int testNumber)
    {

        //run our tests
        _testDateTime = DateTime.Now;
        return null;
    }
}

To show how polymorphism would work, here’s a different class that implements the same interface but has different code…

public class TestUser : ITestItem
{
    int _userId;

    public TestUser(int UserId)
    {
        _userId = UserId;
        //load with a parameter
    }

    public int TestId
    {
        get{return _userId;}
        set{}
    }

    public string TestDescription { get; set; }

    public string RunTest(int testNumber)
    {
        //do our tests
        return null;
    }
}

Also, in C#, you can only inherit from one base class, including abstract classes, but you can use multiple interfaces as shown in this code snippet that adds a IList interface to our class that’s already using the ITestItem interface we defined…

public class TestUser : ITestItem, IList<string>

C# Polymorphism Confusion

A common bit of confusion when it comes to polymorphism in C# is overloading and overriding. These aren’t the same as polymorphism but are sometimes confused with it. Overloading is when there are multiple definitions, also known as signatures, for the same method name within a class. Overriding occurs when a subclass replaces a parent’s implementation of a method with it’s own code. I’ve seen this used as a trick question in a C# interview so watch out for it, especially if you’re interviewing with someone who’s a stickler of OOP academia.

Anyway, I hope this article has helped you understand more about polymorphism in C#.

First, lets begin with a simple string property that’s accessed via an integer indexer. We’ll assume that there is an array of strings that’s loaded in the class constructor. Here’s what this property looks like…

public string this[int index]
{
    get
   {
        return DataItems[index];
    }
    set
   {
        DataItems[index] = value;
    }
}

As you can see, we use the this keyword to define the indexer. Also notice that we use brackets [] rather than a parenthesis () in the definition. In this case, our indexer is an integer and we’re expecting a string value to be set or returned by the property. But, the nice thing is that it can be overloaded. So, let’s say that I wanted to be able to send in a string value or an integer value. Here’s how it would be coded…

public string this[string key]
{
    get
    {
        return DataItems[GetIndexForKey(key)];
    }
    set
    {
        DataItems[GetIndexForKey(key)] = value;
    }
}

In this example, we’re passing in a string value rather than an integer value to determine the return value. A private routine, GetIndexForKey, looks up the internal index value so that it can be set or returned properly in the underlying data. As you can see, overloading indexers can add a lot of flexibility to your code. The indexer could be called either way as seen in these two example lines of code…

 IndexTest[1] = "This is a Test";

 IndexTest["example"] = "This is a Test";

But, you can take it even further with by having an indexer with multiple parameters. This method is effective for returning individual items within class instances contained within the indexer class or to perform special processing on a the returned value. For example, if you were returning a date as a string value, you could pass in formatting information in addition to the index value, as in this example…

public string this[int index, string formatValue]
{
    get
    {
        return DateItems[index].ToString(formatValue);
    }
}

As in other situations, you will need to make sure that each overloaded indexer has an unique signature.

I hope this article has covered the basics of indexers in C# for you.

To make things even easier, we’ll be setting this up as an extension to IQueryable, the interface that LINQ to SQL is based upon. Remember that as with any extension, you’ll need to define the method as static and use the  ‘this’ keyword. Here’s the code…

public static IQueryable<TSource> Page<TSource>(this IQueryable<TSource> source,
int currentPage, int pageSize)
{
    return source.Skip((currentPage - 1) * pageSize).Take(pageSize);
}

Simple, isn’t it. As you can see, we pass in the current page and the page size. The Skip method is used to skip over records up to our calculated starting point. Then, the Take method is used to retrieve our specified number of records.

However, there is another function that will prove useful. We need a way to get the total number of pages. Here’s the code…

public static int PageCount<TSource>(this IQueryable<TSource> source, int pageSize)
{
    return (int)Math.Ceiling((decimal)source.Count() / (decimal)pageSize);
}

This method returns the number of pages present based on the provide page size. We use the Math.Ceiling method to get the smallest integer that’s greater than or equal to the number of records divided by the page size. Remember when you call this function that you want to use the full dataset and not the page query instance. You can use this value to validate movement within the data, such as with a previous/next button or page number selection, and to provide user feedback, such as Page X of Y displays. If you want, you could extend this even further with another function that provided a list of page numbers.