Dot Net Nerd

Inversion of Control

Desirea Herrera — Sun, 26 Jul 2009 17:04:32 GMT

While I was reading The Art of Unit Testing by Roy Osherove, I found references to topics that required more investigation. Inversion of Control or IoC was one of them. I vaguely remember reading about it somewhere but being a tech trainer of way too many technologies, and now a lab developer (basically quality assurance checking & screnshotting of MOC labs & labs from other companies), I've let some topics slide away in favor of stuff related to my job. It's part of the reason I started writing this blog, to hone my skillsets. And now, on to Inversion of Control:

Inversion of Control is based on the idea of flow control. When you start programming, you learn to write code in classes and methods that control the flow of the program. Your code calls methods that do something and answer back to your code. In Inversion of Control, your central classes wait for the phone call that tells them things they need to know to perform their own activities.

The example onWikipedia shows a serverFacade class that initially takes an object parameter to its respondToRequest method. The object is a request for data. The respondToRequest method then uses a DAO (Data Access Object) to get data via it's getData method and convert the data via the aspect's convertData method after using the businesslayer object to test if that object is valid. Based on the first implementation, the serverFacade object is coupled to the DAO object. In the lab of OOP, coupling is discourage. Since the serverFacade shouldn't know anything about how to convert data, or what to return if the data conversion fails (it is only a facade after all), the second implementation moves all the data conversion and return decisions to the DAO class. This in effect, decouples the two classes.

In Martin Fowler's article Inversion of Control Containers and the Dependency Injection pattern, he uses a simple class that splits out finding all movies to a finder class. Problems arise when his friends want that functionality for their programs. They might want to store movies in a different format or in a database. An interface or abstract class solves this by allowing the new developer to create a new class to pass to the MovieLister class that can find all of the movies in their own way via their own implementation.

The key points to both of these examples is that :

The classes need to have very specific goals. If an activity doesn't correspond to the method or class, it needs to be moved out.
In order to allow for different external dependencies like how the movies are stored and retrieved, create an interface or abstract class. (This idea makes your program easier to fit different situations as needed.)

Based on Fowler's explanation, what we're really talking about is setting up "plugins" for our software. Essentially you now have the ability to plugin any external movie storage into his MovieLister class. Data storage is only one of the types of external or outside dependencies your software could come across. It could also rely on network availability, configurations as well as configuration files or data stored on a network, or outside services.

Fowler asserts that Inversion of Control is a common characteristic of a framework. In Inversion of Control he says:

"A framework embodies some abstract design, with more behavior built in. In order to use it you need to insert your behavior into various places in the framework either by subclassing or by plugging in your own classes. The framework's code then calls your code at these points."

Fowler also thinks Inversion of Control Containers is too generic and renames this to Dependency Injection and further discusses the Server Locator pattern. I highly suggest you read his full article.

Going back to the Wikipedia article, it mentiosn that Inversion of Control is also known as the Hollywood Principle. Basically is the ""Don't call us, we'll call you." concept. IoC takes the integration and configuration of the system out of the application, and performs dependency injection.

July 11 - 17 Twitter Links I Want to Read

Desirea Herrera — Sat, 11 Jul 2009 15:02:02 GMT

Brainstorming Rooms

Desirea Herrera — Wed, 08 Jul 2009 19:45:15 GMT

Wujec talks about 3 parts of the brain and how we get meaning out of imagery, motion, etc. He talked about how the brain visually interrogates what it sees, develops a series of questions and then develops a mental model.

Must See: Clay Shirky: How social media can make history

Desirea Herrera — Wed, 08 Jul 2009 19:20:59 GMT

This is probably the most thought provoking video I've seen in quite a while. Shirky talks about how media is increasingly a result of amatuer or citizen reporters. It's no longer controlled by professionals & government. It talks about China's Great Firewall and how they now have to shut down services to control the amatuer producers.

July 6-10 Twitter Links I want to read.

Desirea Herrera — Tue, 07 Jul 2009 18:18:05 GMT

Unit Testing Review List

Desirea Herrera — Tue, 07 Jul 2009 17:26:18 GMT

Contact-CaptureBait : Capturing Contact Information

Desirea Herrera — Sun, 05 Jul 2009 20:21:24 GMT

User Defined Casts

Desirea Herrera — Sun, 05 Jul 2009 18:17:21 GMT

There are times when you may find yourself writing code to move data from a type you defined to another type either predefined or user defined. Of course we are all aware of polymorphism between derived types. This isn't always possible or practical depending on your intentions. It is particularly hard when you're converting between a primiritive type and a user defined type. The answer to this dilemma is to define your own cast.

Review
As you know, casting is the process of converting one datatype to another. Implicit conversions are automatic and can occur when no data will be lost. Data can be lost when the amount of memory space reserved for the target datatype is less than the memory space used used by the source datatype. Just like trying to pour 2 cups of water into a 1 cup container, data can be lost like the water that spills over. The answer to this dilemma is the explicit conversion where you explicitly acknowledge that the data will be lost and allow it to be lost. These types of casts are available for predefined datatypes. Normally the predefined casts and polymorphism will suffice, but for those times when you find yourself moving data manually between types, user defined casts are the answer.

Syntax
Type conversions for your own datatypes are possible but you must define them yourself. You do this by defining your cast within one of the classes from which you will cast. You will also need to mark your cast operation as either implicit or explicitr. A good rule of thumb is to define your cast as explicit if therre is any risk of an exception or if any of the data in the source type might fail to be transferred to the target type. Casting operators can be written into structs and classes. The syntax is similar to overloading an operator as shown below:

// The person class is an abstract class defining basic person information.
public abstract class Person
{
public string firstName;
public string lastName;
public Person(string first, string last)
{
this.firstName = first;
this.lastName = last;
}
public Person()
{}
}

// The Farrier class inherits from the Person class.
public class Farrier : Person
{
public string expertise;
public Farrier(string first, string last, string expertise):base(first,last)
{
this.expertise = expertise;
}

// Note the explicit conversion operator.
// This does not technically need to be explicit as no data will be lost and no exceptions will occur.
public static explicit operator Veterinarian(Farrier value)
{
string fName = value.firstName;
string lName = value.lastName;
string specialty = value.expertise;
return new Veterinarian(fName, lName, specialty);
}
}

// This is the Veterinarian class that in herits from the Person class.
public class Veterinarian : Person
{
public string specialty;
public Veterinarian(string first, string last, string specialty):base(first,last)
{
this.specialty = specialty;
}

// Note the implicity conversion operator.
public static implicit operator Farrier(Veterinarian value)
{
string fName = value.firstName;
string lName = value.lastName;
string expertise = value.specialty;
return new Farrier(fName, lName, expertise);
}
}

// The Form code.
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

// Using the implicit conversion
private void farrierToVet_Click(object sender, EventArgs e)
{
Farrier a = new Farrier(farrierFName.Text, farrierLName.Text, farrierExpertise.Text);
Veterinarian b = (Veterinarian)a;
veterinarianFName.Text = b.firstName;
veterinarianLName.Text = b.lastName;
veterinarianSpecialty.Text = b.specialty;
}

// Using the explicit conversion.
private void vetTofarrier_Click(object sender, EventArgs e)
{
Veterinarian b = new Veterinarian(veterinarianFName.Text, veterinarianLName.Text, veterinarianSpecialty.Text);
Farrier a = b;
farrierFName.Text = a.firstName;
farrierLName.Text = a.lastName;
farrierExpertise.Text = a.expertise;
}

// Attempting to use polymorphism.
private void polymorphicFarriertoVet_Click(object sender, EventArgs e)
{
Farrier a = new Farrier(farrierFName.Text, farrierLName.Text, farrierExpertise.Text);
Person c = a;
// The following causes compile error:
//Cannot implicitly convert type 'UserDefinedCasts.Person' to 'UserDefinedCasts.Veterinarian'.
//An explicit conversion exists (are you missing a cast?) C:\Documents and Settings\Desirea\My Documents\Visual Studio 2008\Projects\UserDefinedCasts\UserDefinedCasts\Form1.cs 43 30 UserDefinedCasts
//
// Veterinarian b = c;
MessageBox.Show("Conversions would not work even with explicit conversion. Person does not contain a casting operator.",
"Polymorphic Conversion Not Possible",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}

Usage
User defined casts are a good way to reduce code. If you find yourself writing code to move data from one of your datatypes to another, defining your own casts within one of the classes or structs will make the job a lot simpler. It's also a good solution when inheritance won't resolve the issue via polymorphism. You can also decouple classes that while containing similar data do not necessarily need to be tied together as in the case of integers and floats. I'm sure someone has some more suggestions as to how to use user defined casts. Feel free to post them below.

C# Preprocessor Directives

Desirea Herrera — Wed, 15 Apr 2009 03:48:51 GMT

Here’s just a few notes on preprocessor directives.

They’re never terminated by a semi-colon.

They can never be translated to any commands in code

They affect the compilation process

They can prevent compilation of positions of source code. This is great for having 2 release versions of your application. It’s also great for eliminating debug information source code.

# define identifier

This directive tells the compiler that the identifier or symbol exists. It does not define a valid you for that identifier. These symbols work as a true or false designator.

# undef identifier

This directive tells the compiler that the identifier or symbol should cease the existing. Any test for the identifier will result in a false reading.

In either case nothing will happen if the symbol does or does not exist.

#if Identifier

//some code

#endif

This directive combination tells the compiler to conditionally execute the code block between the directives based on the return of the identifier. If the identifier has been defined using the #define directive, the code will execute. If it has not been defined or has been undefined using the #undef directive the code will not execute.

#elif

This directive acts the same way as and else if statement. It fits in with the #if and the #endif directives.

#if Identifier

//some code

#elif otherIdentifier

//some code

#endif

C# Allows you to use comparison operators like && and = =.

#warning #error

These directives cause warning or error messages when the compiler encounters them. The error directive will display any text to the user as if it were a compile error and then stops compilation whereas the warning directive will continue compiling the application.

#region

#endregion

These directives work in conjunction with each other to organize the layout of your code. They don’t affect compilation.

#line

This directive will alter the file name and line number information to output by compiler warnings and error messages. This is most useful when coding in conjunction with some other assembly that might alter the code you type in before sending the line number to the compiler and the line numbers may not match up correctly.

#pragma

This directive will suppress or restore compiler warnings. It can be implemented on class or method levels.

How to Define Your Project

Desirea Herrera — Mon, 06 Apr 2009 00:45:13 GMT

A lot of times I get asked to take a look at an idea for a web site that a friend or colleague not involved with the IT industry has come upon. Most people have no idea what it takes to build a web site or a piece of software. Many times the idea is not very well thought out. A lot of people get caught up in their ideas and don’t consider the exactly how much work it might take to actually build the web site or software. That’s not their fault because they generally don’t know what it takes.

So what does it take to define your idea?

The first step in actually defining your idea would be up to figure out who is going to use your site or software. Software architects actually define these as users. When you talk to a web developer or web designer, they’ll describe an actual person or persona. A persona describes a person based on their experience, their job and their age. This gives the developer a sense of the skill set of the user.

Once you understand who would use the software, you need to understand how they will use the software or web site. By thinking of all the different types of activities the individual user might perform on the web site or software, you can start to understand the scope of your project. Developers might take this information and build up what we call Use Case Scenarios. Use Case Scenarios help us get an overview of the project.

Another thing to take a look at is the data involved. You need to know exactly what pieces of information will be input into the system and output from the system. That information needs to be broken down into a small a piece of data as possible. Someone’s address would be broken down into first name, last name, street address, city, state, and the zip code. It’s very important to identify every piece of data.

Once you understand who will use your web site or software and the data that’s input into and output from the web site or software, you need to think about specific rules. How are the users allowed to put data into your web site or software? What are they allowed to do with the data on the screen? These are your business rules. You may have a few of them or you may have all lot of them.

Something else that will help you define the scope of your project are interfaces. If it’s a web site, what pages will you need? If you know of a web site that is similar, to a look at the pages included on that web site. If it’s a piece of software, look at similar software. Write down a list to pages or key interfaces that you know you will need. Look back at the activities the users will perform. Those activities will help you define what pages you need.

By going through this process, you’ll get a better idea of the scope of your project. Once you know the scope of your project, you’ll understand the estimates supplied by the vendors. A low estimate may mean that the developer doesn’t really understand your project. Lowball figures can also mean poorly built software. Poorly built software Can and does cost you money. When you hire a developer to fix or redevelop the web site or software, they won’t be willing to give you a discount. Giving you a discount means the developer paid for the cost of building it the first time.