Welcome!

Microsoft Cloud Authors: Nick Basinger, Kevin Benedict, Pat Romanski, Liz McMillan, Lori MacVittie

Related Topics: Microsoft Cloud

Microsoft Cloud: Article

Dealing With The C# 2.0 Genericity

Leverage generics for flexible code, the forthcoming .NET 2.0 Framework will introduce new important features

The forthcoming .NET 2.0 Framework will introduce new important features. One of those features is genericity. Genericity is not really a new concept. It has been included in some previous languages as ADA, C++, Eiffel, and in the mathematical model of abstract data types (ADT). However, the C# 2.0 notation for genericity (see the first entry in the References section), the integration of genericity in the .NET type system, the efficient implementation of genericity in the CLR-JIT process, and the new generic features included in the reflection mechanism will strengthen .NET programmers' output.

Genericity in .NET rests on the same basic reasons for which .NET promotes strongly typed languages:

  • Readability: Explicit declarations tell readers about the intended meaning of the code
  • Reliability: Thanks to explicit type declarations, a compiler can easily detect inconsistencies and erroneous operations
  • Efficiency: By knowing the types early, a compiler will be able to generate a more efficient code
The first section of this article starts by presenting arrays, the humble and anonymous generic construction embedded in C# and many programming languages. The second section explains how a limited form of generic types can be currently implemented in C#, based on the object type. In the third section the main characteristics and benefits of genericity in C# 2.0 are illustrated, including the notion of constrained genericity. An additional section explains how we can interact between generics and non-generics. Finally, we present an interesting example about simulation of multiple inheritance with genericity.

Arrays: The Implicit Generic Construction Embedded in .NET
Perhaps because arrays are predefined in C# and embedded in the CLR, when using them programmers don't realize that they are dealing with a truly an efficient generic construction.

When you write a declaration like int[] a you are instantiating a generic container, known as an array of items of type int. Any type T can be used to define an array through the notation T[]. A set of common properties and functionalities implicitly applies to arrays no matter what type T is:

  • All array objects are created with the notation new T[k] where k must be a positive expression that defines the numbers of items in the array.
  • An int property Length applies to every array (no matter the type T) to return the number of items of the array. Items are numbered from 0 to Length-1.
  • All items of an array of type T[] have the same type T. Items of a value type T are initialized as such value type (zero for numeric types, false for bool type, and so on) and items of a reference type T are initialized to null.
    1.  For an array T[] a, a[i] acts as a variable of type T denoting the item at position i. When using in the right side, a[i] returns an item of type T, and when using in a left side, a[i]=x; x must be of type T.
Unfortunately, before C# 2.0, programmers could not define a custom parameterized type based on a type T.

Genericity Based on the "Wild card type" Object
Today C# programmers who want to define a stack type of int objects must write the code in Listing 1a. If they wish to define a stack of objects of a type Person they could write the code in Listing 1b (for simplicity, this is only a rough implementation of a stack). Note that both classes Stackofint and StackofPerson have similar codes. They differ only in the type they are based on (int or Person). We can avoid that replication by defining a sole Stack type based on the root type object (see Listing 2).

Here object acts like a wild card type. Since every type in .NET inherits from the base object type, and thanks to the boxing and unboxing features of .NET, programmers can seamless push either a reference object or a value object into a stack. Note that the parameter of Push is of type object, then some calls like s.Push(3) or s.Push(new Person(...)) are correct, because any type conforms to object.

The approach above has the benefit of no code replication, but it has the following flaws:

  • It is not possible to enforce the kind of data to be placed in the stack. As the following code snippet shows, we could create a stack and push an assortment of objects on it.

    Stack s = new Stack(10);
    s.Push(new Date(10,10,2000);
    s.Push(new Person(...));
    s.Push(100);

  • Boxing and unboxing operations that apply when pushing and retrieving objects of value types can be particularly onerous.
  • Because the compiler only knows that objects in the stack have the general type object, when we retrieve the objects from the stack we must cast them to the real type they have:

    int k = (int) s.Pop();
    Person p = (Person) s.Pop();

However casting has a run-time cost, and even worse, it is an error-prone approach because it is possible to write a wrong cast.

It would be significant if we could have the safety and efficiency of specific type definitions (as shown in Listing 1), and, at the same time, we could avoid code replication. Both benefits could be achieved with the forthcoming genericity of C# 2.0.

Genericity in C# 2.0
In C# 2.0 the aforementioned definition of Stack could be best obtained by using the generic notation shown in Listing 3.

Here Stack<T> denotes a generic type and T denotes a type parameter of this generic type. Instantiating this type parameter with an actual type will result in a type of specific stack:

Stack<Person> persons = new Stack<Person>(10);.

Now persons has the type Stack<Per-son>. This has the following benefits:

  • All operations defined in Stack<T> are applied to Stack<Person> without programming duplication
  • Compiler can accept the following code without doing casting:

    Person harry = new Person(...);
    persons.Push(harry);
    Person p = persons.Pop();

  • In an attempt to push on persons, an object of a type not conforming to Person will result in a compilation error:

    persons.Push(23); //Error because 23 is not of type Person

    It is possible to push on the stack persons an object of a subtype of Person. If the class Employee inherits from Person, then the following code is correct:

    persons.Push(new Employee(...));

A type parameter can be used as an instantiation parameter of another generic type. Note that in the Stack<T> definition, the parameter T is used to instantiate the internal array T[] items. It means that when we write Stack<Person>, its instance variable items will be of type Person[].

Furthermore, generic instantiation can be done recursively. For example, a three-dimensional list can be defined as follows:

List<List<List<string>>> stringCube =
new List<List<List<string>>>(5);

Multiple Type Parameters
A generic type can have any number of type parameters. For example, in the generic dictionary type

class Dictionary<TKey, TValue> {...}

TKey must be instantiated with the type that we want to use as the type of the key (the object to search in the dictionary), and TValue must be instantiated as the type of the object associated with the key. Some examples are:

Dictionary<string, string> englishSpanish = new Dictionary<string, string>();
Dictionary<string, long> phoneList = new Dictionary<string, long>();
Dictionary<string, Person> contactList = new Dictionary<string, Person>();

More Stories By Miguel Katrib

Miguel Katrib is a PhD and a professor in the Computer Science Department at the University of Havana. He is also the head of the WEBOO group dedicated to Web and object-oriented technologies. Miguel is also a scientific advisor in .NET for the software enterprise CARE Technologies, Denia, Spain.

More Stories By Mario del Valle

Mario del Valle is working toward his MS at the Computer Science Department at the University of Havana, and is a software developer at the WEBOO group dedicated to Web and object-oriented technologies.

Comments (1)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.


IoT & Smart Cities Stories
If a machine can invent, does this mean the end of the patent system as we know it? The patent system, both in the US and Europe, allows companies to protect their inventions and helps foster innovation. However, Artificial Intelligence (AI) could be set to disrupt the patent system as we know it. This talk will examine how AI may change the patent landscape in the years to come. Furthermore, ways in which companies can best protect their AI related inventions will be examined from both a US and...
Enterprises have taken advantage of IoT to achieve important revenue and cost advantages. What is less apparent is how incumbent enterprises operating at scale have, following success with IoT, built analytic, operations management and software development capabilities - ranging from autonomous vehicles to manageable robotics installations. They have embraced these capabilities as if they were Silicon Valley startups.
Dynatrace is an application performance management software company with products for the information technology departments and digital business owners of medium and large businesses. Building the Future of Monitoring with Artificial Intelligence. Today we can collect lots and lots of performance data. We build beautiful dashboards and even have fancy query languages to access and transform the data. Still performance data is a secret language only a couple of people understand. The more busine...
Chris Matthieu is the President & CEO of Computes, inc. He brings 30 years of experience in development and launches of disruptive technologies to create new market opportunities as well as enhance enterprise product portfolios with emerging technologies. His most recent venture was Octoblu, a cross-protocol Internet of Things (IoT) mesh network platform, acquired by Citrix. Prior to co-founding Octoblu, Chris was founder of Nodester, an open-source Node.JS PaaS which was acquired by AppFog and ...
The deluge of IoT sensor data collected from connected devices and the powerful AI required to make that data actionable are giving rise to a hybrid ecosystem in which cloud, on-prem and edge processes become interweaved. Attendees will learn how emerging composable infrastructure solutions deliver the adaptive architecture needed to manage this new data reality. Machine learning algorithms can better anticipate data storms and automate resources to support surges, including fully scalable GPU-c...
Cloud-enabled transformation has evolved from cost saving measure to business innovation strategy -- one that combines the cloud with cognitive capabilities to drive market disruption. Learn how you can achieve the insight and agility you need to gain a competitive advantage. Industry-acclaimed CTO and cloud expert, Shankar Kalyana presents. Only the most exceptional IBMers are appointed with the rare distinction of IBM Fellow, the highest technical honor in the company. Shankar has also receive...
Bill Schmarzo, author of "Big Data: Understanding How Data Powers Big Business" and "Big Data MBA: Driving Business Strategies with Data Science," is responsible for setting the strategy and defining the Big Data service offerings and capabilities for EMC Global Services Big Data Practice. As the CTO for the Big Data Practice, he is responsible for working with organizations to help them identify where and how to start their big data journeys. He's written several white papers, is an avid blogge...
The standardization of container runtimes and images has sparked the creation of an almost overwhelming number of new open source projects that build on and otherwise work with these specifications. Of course, there's Kubernetes, which orchestrates and manages collections of containers. It was one of the first and best-known examples of projects that make containers truly useful for production use. However, more recently, the container ecosystem has truly exploded. A service mesh like Istio addr...
Business professionals no longer wonder if they'll migrate to the cloud; it's now a matter of when. The cloud environment has proved to be a major force in transitioning to an agile business model that enables quick decisions and fast implementation that solidify customer relationships. And when the cloud is combined with the power of cognitive computing, it drives innovation and transformation that achieves astounding competitive advantage.
Whenever a new technology hits the high points of hype, everyone starts talking about it like it will solve all their business problems. Blockchain is one of those technologies. According to Gartner's latest report on the hype cycle of emerging technologies, blockchain has just passed the peak of their hype cycle curve. If you read the news articles about it, one would think it has taken over the technology world. No disruptive technology is without its challenges and potential impediments t...