Techie .Net Stuff

My traveling talk begins with CODODN!

Dave Redding — Wed, 23 Apr 2008 02:23:36 GMT

The C# variety Show began on Thursday with my trip to GLUG.net in Lansing, (this is a great group of guys and gals, and if your free, I highly recommend you to attend, they even have a user group in Flint now!) and didn't stop until yesterday when I got home from CODODN.

At about 6:30 on Friday, Mr. McWherter shows up at my house and the road trip begins. After about 4.5 hours, stopping only for necessities we arrive in Wilmington Ohio around. After checking in at the hotel adjoined to the conference center we started twittering to find out if anyone else had made it down yet, and got no love. Now...for those of you who have never visited Wilmington, this picture should illustrate what it's like...

Right...almost the middle of nowhere...However the Roberts Conference Center is conveniently located between the 3 major user groups in the area: Cincinnati, Dayton and Columbus.

Unfortunately, I didn't get the opportunity to visit any of the sessions because I had to polish up the demos for my presentation. I did however get to hang with some of the best speakers around in the speakers lounge. It was great to be surrounded by folk who knew what they were doing and were able to throw this newbie speaker some great hints (Like, write your demos before you show up to the conference). Also, with three user groups involved I was able to meet A lot of great folks. All in all, the venue was a perfect fit for the conference.

I had just finished up my Demos when it was my turn to present. At first, there were only a handful of people in the room, but within a span of just a few minutes, there were people standing in the back. I was nervous as hell, but managed to get through the presentation, even with my funky new presentation mouse constantly wanting to zoom in on everything (Kudos to Mr. Prince for the presenter mouse). I had a lot of good questions throughout the presentation and most of the folk seemed to respond well to the "bite-sized-pieces-of-information" format. I even managed to get a few laughs out of my crude since of humor. One of the best pieces of feedback I received was that my talk was "..Like the man show meets the Nerd show"...so maybe "Girls on trampolines" isn't to racy for my talk after all :)

After my presentation, I had the chance to hang out with Josh Holmes and Joe O'Brian where we talked about presentation styles and they regaled presenting war stories (I especially like how Joe was trying to make a point and almost fell of the stage...priceless!). After the final presentations let out, we all ventured into the main ballroom for the swag give away. Some folks walked away with great gear, including licenses to Infragistics controls, Refactor and a host of other fantastic developer tools.

Once the conference was declared closed, most of us headed over to Max and Erma's, which was attached to the hotel/conference center. Due to a mis-communication, the restaurant had no idea that we were coming. Eventually we wound up with a party of 30, which the Hostess' and wait staff handled very elegantly. The service was top notch, however, most of us never received our appetizers (those of us back in the restaurant..there were quite a few of us still in the bar). So dinner went GREAT and the food was fantastic (Loved my heartattack-on-a-bun-pulling-over-in-Toledo-on-the-way- back-to-blow-up-a-restroom burger...thanks Mr. Hawley and Mr. Prince).

After things quieted down at the dinner table, about half (if not more) of us ventured up the Mr. Blankenburgs room for a little poker party. things got off to a great start, at my table was Dave Smith, Sarah Dutkiewicz, Matt Casto, James Bender, Monish (Mo) Nagisetty, Phil (Can't remember your last name chief) and Dan Rigsby. I had never had a chance to sit and hang out with most of these guys so it was great, drinking Sam Adams (even though Blankenburg got Miller and Coors just to f with me) and talking a combination of smack and tech.

A couple of hours later, we combined tables where it was Me (I made it woot!), Dave, Phil, Jeff Blankenburg, Jeff McWherter Kevin (blanking on your last name to bud) Cory Haines, and I think Darrell Hawley (I had a bit of whisky in me by this point so I'm a little fuzzy on the details). I ended up going out on the second hand where I called Kevin, thought he was bluffing...but he ended up having a flush and taking me out. Was a great game and I walked away with "Extreme programming adventures in c#" as a consolation prize. I do remember that at one point, Amanda Laucher Took all my chips while I was ordering Pizza and made them all pink...I immediately grabbed one of Dave Smiths chip racks and exchanged it for the pink one. The night continued on in due form with lots of great tech talk and a whole lot of drunk humor. Mad props go out to Blankenburg and the rest of the MS guys that made this happen. It was a great way to end a fantastic conference.

The Next morning, those of us who had survived the night of poker ventured down to Max and Ermas once again for a fantastic breakfast. Shortly thereafter, we all headed back home.

This was my first overnight stay for a conference and I enjoyed every last minute of it. A perfect way to bring many people who are passionate about what they do together. I had the opportunity to meet and talk with a fantastic group of professionals who are dedicated to the community. I can't wait till the Western Michigan day of .net where we can all meet up again. After that, who knows, maybe the Cleveland Day of .net? or even the upcoming Lansing Day of .net!

Watashi no "IL Code" seksu desu

Dave Redding — Mon, 31 Mar 2008 15:52:29 GMT

So, I may not be entirely up on my un-couth Japanese sayings, but one thing is for sure, IL code, to the average developer (Read: Me) might as well be written in the same Romaji thats in the title. That is, it's hard to make heads or tails of, and since you most likely never, or only rarely look at it, you get very little opportunity to actually study it. I've been the same way for the past few years, acknowledging that IL exists, and just like that ugly friend, I don't actually acknowledge there being a relationship between "It" and I in public.

That all changed for me last Friday when my buddy Joshua Haynes dropped me a note abut my "Unloved Operators" Tech in 5 minutes post . He was interested enough in how the ?? operator stacks up against the if(x==null) else structure that, he compiled an example and then sent me the IL code, looking for my opinion.

So I was stuck. I could not admit defeat because of my ignorance of IL. So I leapt into action, quickly throwing out all the TLA's I could in an attempt to undermine my friends intelligence. He quickly blocked, pivoted and swatted away my attack. Before he could completely recover I attempted the Clinton-Dodge-the-issue move I had learned from CNN, but Joshuah quickly saw through funny analogy's and interesting tangents and held his ground firmly, so....I gave in and made a trip to the ~~oracle~~ Google. Come to find out, it can be difficult to research an answer, as compared to just pulling out of god knows where. But I think that I figured out how do answer Josh's imposing "What do you think?" question. below is the code and the IL that he sent me.

Person myself = null;
Person myFriend = new Person("Johhny", "Cash");
Person newFriend = myself ?? myFriend;
Console.WriteLine("The new Friend likes: {0}", newFriend.FullName());

if (myself != null)
   newFriend = myself;
else
   newFriend = myFriend;
Console.WriteLine("The new Friend likes: {0}", newFriend.FullName());

IL_0012: stloc.1
IL_0013: ldloc.0
IL_0014: dup
IL_0015: brtrue.s   IL_0019
IL_0017: pop
IL_0018: ldloc.1
IL_0019: stloc.2
IL_001a: ldstr      "The new Friend likes: {0}"
IL_001f: ldloc.2
IL_0020: callvirt   instance string Test.Person::FullName()
IL_0025: call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)
IL_002a: nop
IL_002b: ldloc.0
IL_002c: ldnull
IL_002d: ceq
IL_002f: stloc.3
IL_0030: ldloc.3
IL_0031: brtrue.s   IL_0037
IL_0033: ldloc.0
IL_0034: stloc.2
IL_0035: br.s       IL_0039
IL_0037: ldloc.1
IL_0038: stloc.2
IL_0039: ldstr      "The new Friend likes: {0}"
IL_003e: ldloc.2
IL_003f: callvirt   instance string Test.Person::FullName()
IL_0044: call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)
The top is the ?? test and below is if statements. What do you think?

So, starting from the top, I began to investigate what each call was.

The first thing i needed to figure out was, what was the "IL_xxx" marker? simple, line numbers, easy enough. Next up, what does this mean:

brtrue.s IL_0037

a little googling and i found that "br" means "Branch" so "brtrue" must mean "True branch from a decision" (the .s seems to indicate Short form, or something of that nature). So combine that with a line number and we have a basic go-to statement of

IF True GoTo: IL_0037

Ok, so that tackles the low hanging fruit. The next thing on the list was these

stloc.x
ldloc.x

To google for these, i had to rack my brain for a bit. I discovered that there is an OpCodes object that lives in the system.refelction.emit namespace. And surprisingly enough, it has codes that match what I'm seeing the the IL. So I quickly discovered the following entries.

Stloc_0 Pops the current value from the top of the evaluation stack and stores it in a the local variable list at index 0.

Ldloc_0 Loads the local variable at index 0 onto the evaluation stack.

Alright, so basically, both of these commands manipulate the Stack (more on "The stack vs The Heap" in another post). For now, lets just call the Stack = Fast memory but limited The Heap =Slow Memory, but massive. Think of the stack as a tower of single bricks. Each brick represents a single amount of data. When you "Pop" an item of the stack you grab the top most item and remove it (in our case, we also "Pop" from an indexed item), when you Push (again, in our situation "Load into"CEQ Compares) your putting something.

There were a few other things to check out before I could move on. For instance, what does ldnull and ceq do?

Ldnull Pushes a null reference (type O) onto the evaluation stack.

Ceq Compares two values. If they are equal, the integer value 1 (int32) is pushed onto the evaluation stack; otherwise 0 (int32) is pushed onto the evaluation stack.

Ok, simple enough. LdNull puts a Null Reference Type onto my stack, and Ceq checks for equality. This will become important later on.

Ok, so I'm armed with some basic implements of the trade, time to start interpreting. The second section seems a bit more straight forward, so lets start there.

IL_002a: nop
                    means no-operation, do nothing, waste time, etc...
IL_002b: ldloc.0
                    Load into a local var whatever is in location 0 on the stack (object "MySelf")
IL_002c: ldnull
                    Load a reference to a value on the heap, into my stack...
IL_002d: ceq
                    Compare the last two values to each other and stuff them into the stack (if x == null)
IL_002f: stloc.3
                     Pop item at index 3 of the stack and into the local variable
IL_0030: ldloc.3
                    Load the value stored in index 3 of the stack to the local variable stack (the result of ceq)
IL_0031: brtrue.s   IL_0037
                    if that value is 1, skip to line 37
IL_0033: ldloc.0
                    Load the value stored at index 0 of variables into the stack (remember, the person "MySelf")
IL_0034: stloc.2
                    Pop the item at index 0 of the stack into the local variables (what we just loaded);
IL_0035: br.s       IL_0039
                    Branches us directly to line 39. do not pass go, do not collect $200
IL_0037: ldloc.1
                    in our else statement, Load item at index 1 into the stack (remember, make x = y if null , essentially)
IL_0038: stloc.2
                    pop off item 2 from the stack into the local variable (the actual variable getting assigned)
IL_0039: ldstr      "The new Friend likes: {0}"
                     load this string into the stack
IL_003e: ldloc.2
                     load variable 2 into the stack (the "NewFriend" object)
IL_003f: callvirt   instance string Test.Person::FullName()
                     call the following method and load it's value
IL_0044: call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)
                      call this method, which has full access to the stack, so were passing it, in this order, the string "The New Friend Likes:{0}" and then stack item[1] which = the return of Test.Person.FullName property.

Well, that was quite a bit. So the simple rundown is....it does exactly what our code tells it to. Interesting to note though, is were newing up an object of type "Null" and doing an object comparison between it and "Myself". This isn't bad, but it's a tad slow. You also have to load up every property and variable to see if they do actually equate. Find in most situations, but like in the previous post, if you make a comparison of Type B to Null from Type A, when Type B Has references Type A doesn't, your going to error out...because your loading values in Type B, that Type A is ignorant of....GetItGotItGood.

Ok, so we've seen what the commands do, lets take the short route examining how the ?? works in IL.

IL_0012: stloc.1
IL_0013: ldloc.0
IL_0014: dup
                    Duplicate the item on top of the stack and pushes the duplicate into the stack
IL_0015: brtrue.s   IL_0019
                    If the values are the same (if the value of the object is empty like the first register) jump to 19
IL_0017: pop
                    Else pop the first item off the stack and get rid of it
IL_0018: ldloc.1
IL_0019: stloc.2
IL_001a: ldstr      "The new Friend likes: {0}"
IL_001f: ldloc.2
IL_0020: callvirt   instance string Test.Person::FullName()
IL_0025: call       void [mscorlib]System.Console::WriteLine(string,
                                                                object)

First off, we have obviously fewer instructions. Secondly, and most important, notice that were not doing any object comparisons or loading any objects from the heap. so the breakdown after examining the two IL statements is this

If(x == Null) is like saying (If object x is the same as object Null)
and
x??y is like saying (If object x is as empty as Brittney Spears head)

So in short, ?? is faster, and easier to evaluate because were only comparing it to an empty value in the stack, not a reference type. Obviously the speed gain is minuscule, but it's still there.

Ok, so IL probably will only help you gain geek cred and debug issues that you'd rather not be debugging. But understanding IL code is worth serious geek cred, and helps you prove (or dis-prove) your theories on how your .net code works. And hey, chicks dig the serious geek ;)

Tech in 5 Minutes: Nifty C# operators that don't get much love

Dave Redding — Tue, 11 Mar 2008 16:31:43 GMT

In my travels around .Net land, I've come to know, love and exploit several denizens of the tribe of C#. Some of these have already been written about, such as Yield return and the => operator. But more recently, I've had the opportunity to educate some fellow travelers on two of the most useful, but least used operator. Those being the Comparison Operator (?:) and the Null Coalescing Operator (??).

Lets start our adventure by watching the Comparison Operator in it's natural environment. If you watch closely, it'll show you it's syntax...

bool statement ? true : false

Due to it's nature, this operator is sometimes called the Ternary operator. The reason being is that it takes 3 operands. In normal use, here is what it looks like:

CurrentBeer.Empty==True ? CurrentBeer = Wife.GetMebeer() : Me.TakeDrink(CurrentBeer);
(this can be shortened further by taking out the ==True, since .Empty is most likely a bool property)
CurrentBeer.Empty?CurrentBeer=Wife.GetMeBeer():Me.TakeDrink(CurrentBeer);

You can see how this replaces the overly verbose syntax of :

If(CurrentBeer.Empty)
CurrentBeer = Wife.GetMeBeer();
else
Me.TakeDrink(CurrentBeer);

Syntax sugar? Maybe. But it's definitely useful as a quick way to get things done. Elegant, Efficient and Desirable, three features my first girlfriend was lacking in.

But wait! Theres more! Just send me three easy payments of $29.95!

So now, lets check out the ?? operator.

The ?? operator has saved me boat loads of finger_impact_on_keyboard stress ever since the advent of C# 2.0. It's easiest to think of this operator working similar to the comparison operator above. Lets lift it's skirt real quick and have a peek at how it functions

x = ValueThatMightBeNull ?? DifferentValue;

Ok, much like the first time you played doctor, things might be confusing, but it's really simple. Basically the ?? will evaluate whether or not the thing to the left of it is null, if it is, it will evaluate and return the thing on the right. Lets just see it in action, it's easier that way...<Dear "Usually offended by my posts": Please Insert vulgar joke of your choice here>

//This is how my wife found me
Mate SuitableMate = Mate.Get(GoodLooking)??
                                      Mate.Get(AverageLooking)??
                                      Mate.Get(DoesntHaveAnAssForAFace)??
                                      Mate.Get(AtleastHeHasAJob)??
                                      Mate.Get(Dave)

If your confused, let me lighten things up for you hear. Each A = B??C statement is the equivalent of saying

If(B != null)
A = B;
else
A = C;

So when we string them together like that, it's just like saying If = null else if = null else if = null etc etc etc... So, obviously, based on our previous statement, everything up to Mate.Get(Dave) must have returned null if my wife wound up with me. I do have a job now though....so I wonder if i still would have made the cut.

There is one more benefit of using the ?? operator that I actually stumbled across. Take this code as an example:

public class DataObject
{
public NullableObject a = 1... etc
}

public class BO
{
public NullableObject Stinks= 0;

public static implicit operator BO(DataObject e)
{
return new DataObject{Stinks= e.a};
}
}

now...later on in the UI of the app (which should NOT have ANY reference to the DataObject class) if we write this code:

If(MyBo==null){Console.WriteLine("WOO HOO, You have no BO!!");}

..were going to get a compiler error. The reason being, as far as I understand (hopefully commenter's can expand on this) is that when you compile that statement, the compiler is doing type checking against the objects used in the class your checking for null in. In other words it checks to see if anything is returning null from within the class. Now, since the operator takes a type of DataObject, the complier expect you to have a reference to that class...if you don't, then *Poof* no compile.

Now, to get around this, we can write...

SomeoneElsesBo = MyBo??(MyBo = new BO());

....And the compiler is happy.

Hell, we can even put these two operators together, check this out:

Mate SuitableMate;
Step Next_Step_In_Life = ((SuitableMate = Mate.Get(GoodLooking)??
                                                                                Mate.Get(AverageLooking)??
                                                                                Mate.Get(DoesntHaveAnAssForAFace)??
                                                                                Mate.Get(AtleastHeHasAJob)??
                                                                                Mate.Get(Dave)) == Dave?SobQuietly():null)??(Step)PartyItUpWOOT();

I'll leave you with this. The best places I've found to use the ?? operator is in returning data base fields where the value might be null, here is a quick example and the best way I've found to implement the ?? solution

//First i check to see if the value from the db is DBNull.value
//Dr = DataReader
//Do = Data Object with nullable Types

DO.ValX == DBNull.Value?null:(Int32?)dr[0]
//If you don't get the ? reference after the Int32, no worries, It's a nullable type, and I'll post about it soon.

The reason I do this, is so I can keep the actual DB value in my DataObject, which is supposed to be a true reflection of my data. Later on, in the actual business object, where I don't accept Nullable types I can say this.

BO.ActualValX = DO.ValX??-1;

And Bada-Bing, I'm good to go. Later on, i can pass either -1 or even null back into the DB and repeat this cycle when retrieving my data, it works, and i don't have any logic, other than conversions from DBNull, in my Data Object class.

Microsoft announces Open Protocol Specfication

Dave Redding — Thu, 21 Feb 2008 19:15:06 GMT

The link explains it all

http://msdn2.microsoft.com/en-us/library/cc203350.aspx

As a developer, you now have full access to the information about Open Application Programming Interfaces (APIs) and Open Protocols. All Windows client operating system API documentation is now available on this MSDN website.

Wow!!!

Good Times

Dave Redding — Tue, 15 Jan 2008 18:04:02 GMT

Well, that time of the year has come and gone again. By that I mean Code mash.

I didn’t get a chance to make it to codemash this year, but waking up to find 76 twitterings on my phone (Over half were most likely Dwitters -Drunken Twittering-) is a clear indication that it was both a fun and exciting time for all who attended.

In other news, apparently my blog posts (the most recent one about the '=>' specifically) was the issue of some conversations at code mash. And in the process I managed to offend a few of my friends. Hence you will notice it's no longer published. I took it down as soon as I found out that it had offended a friend; that’s not something I’d ever intentionally do.

I’m still grappling with the "Do I take out the bits that offended my friend and republish it, damn the common idea of a non offensive/vulgar blog post, don't conform, be my own man" or, do I suck it up, go more vanilla. The post itself has had almost 900 unique web views, and an extra 230 subscriber views, my most popular post yet, I can't imagine all those people were deeply offended by what I had to say. So I guess what it comes down to is, should I conform and not risk offending a contingent of people to entertain another, or should I just say "Damn the torpedoes, full speed ahead!!” Honestly, it's a rhetorical question, since I’m going to do whatever in the hell I want anyway, but it does feel good to write it down.

A friend once said that to enjoy blogging you have to do it for yourself and no one else, but since I’m even asking these questions, am I really blogging for myself?

That being said, I have a PG rated Tech in 5 min about extension methods Then I think we’re going to get into exception handling.

Till next time.

Extension Methods

Dave Redding — Tue, 18 Dec 2007 16:59:33 GMT

My friend J. Chapman has a great demonstration of how extension methods can help to further de-couple UI elements from BL. Good stuff. I like the approach. This is a good post that i would say to you "Hand out to all the hethens who preach heresy against the church of C#"!!

Tech in 5 minutes: Overloading Operators is Nifty!

Dave Redding — Mon, 05 Nov 2007 18:36:33 GMT

Welcome back to our newest installment of Tech in 5 minutes. Today were going to discuss the age old question that every modern family has to confront:

Excellent point...however, not today, I meant this one.

Special Huggings...yeah in my world that means:

Kid k = mom + dad;

OR Kid k = (mom + alcohol) + (dad+ alcohol)

So now I will be your doctor of love and teach you to make kids. Not only that, but we can illustrate all the major aspects of life via operator overloading, Like The first job, The first Beer Bong, Getting 80% notes on Guitar Hero 2, How to make Peanut Butter-Saltine-Jalapeno pepper snacks, And of course...Puberty (If that rant doesn't seed the search engines, I don't know what will). Hell! we can even calculate the chances of toast falling on the carpet butter side down, and give it a score on the triple half gainer it does on the way down.

Lets get started with the whoopie:

            Man stud = new Man();
            Woman chick = new Woman();
            Alcohol a = new Alcohol();

            Whoopie whoopie = null;
            while (whoopie == null && !stud.IsPassedOut)
            {
                if (stud.studlyness > chick.standards)
                {
                    whoopie = stud + chick;
                    Kid k = (Kid)whoopie;
                    if (k != null)
                    {
                        stud.studlyness.Huavos = 0;
                    }
                }

                    stud += new Beer();
                    chick += new Daquiri();
            }

Pretty accurate eh? So how does it work? Simple. Operators are just basically methods with a single character (Read: Lazy Developer) name. They give us that convenient syntax, but there really is no fundamental difference between

Whoopie whoopie = stud + chick;

And

Whoopie whoopie = stud.Addchick(chick);

Alright, enough alredy, here is how you'd overload that Binary operator:

public static Whoopie operator +(Stud s, Chick c)

//since the + operator shouldn't (but does, remember it is basically JUST a static method)
//care about order of values to be operated on go ahead and overload the reverse method signature

public static Whoopie operator +(Chick c, Stud s);

Now, you can stick either of these methods in either the Chick or Stud class, or one in each. if you try to do both, you'll wind up with an ambiguous reference, since the operator won't know which classes method to call. This is handy since it's a compiler error instead of catching it at runtime. I mean, how embarrasing would it be for Your app to say "Cannot add Man and Woman". It would probably bring up questions about your *ahem* preferences. And if you worked with the same guys I do, you'd hide under your desk,behind the computer. On the flipside, you'd learn how to write code without a monitor. But I digress.

Ok so we can make whoopie, But how do we know to make whoopie? Well simple. The studs studlyness hast to exceed the woman's *Standards*. But, since that will most likely NEVER happen off the bat, you have to get some Alcohol involved. so lets check out the '+=' which actually ends up just being a Binary + operator (Meaning it takes 2 parameters) the '=' part of the operator means we Have to return the same type that were operating on. so this:

stud += new Beer();

can be read as:

stud is = to stud + a new beer in him();

GET THIS MAN A BEER!!!

which ever one gets the point across to you.

we overload this one just like we did with Whoopie:

public static Stud operator +(Stud s, Alcohol a);
{
    s.Studlyness ++; //Same rules as the +=
    return s;
}
public static Stud operator +(Alcohol a, Stud s){return s+a;}

public static Woman operator +(Woman w, Alcohol a)
{
    w.Standards --;
    return w;
}
public static Woman operator +(Alcohol a, Woman w){return w+a;}

In my code, I overloaded these operators in the Alcohol class, It really doesn't matter where you do it, so long as you do it in one of the classes being operated on.

So, standards are lowering, "Confidence" is growing, so how do we know when enough is enough? Well, one of two things have to happen, the guy passes out from drinking to much liquid courage, or they finally his Studlyness surpasses her standards and they find a quite spot in the back of someone's car and act like teenage rabbits on spring break. So, it's easy to check for passed out-y-ness, but what about checking to see if the liquor is working and through a thick set of beer goggles "He could be the one...". Well, we simply check. overloading the '>' operator is just like overloading the '+' operator, with the caveat that, when you overload an operator like '>' or '<=' you HAVE to have the complementing '<' and '=>'. this makes sense right? You cant have a > without a <, that would be fricking crazy!! I mean, it's almost like a 'WT' without the trailing 'F'. The overload looks almost identical to the one for the '+' except you HAVE to return bool (it is a boolean operator afterall).

public static bool operator >(Studlyness studfactor, Standards impossabledream)
{
            //I'm reading on functional programming so i'm TOTALLY in the mood to use
            //these logical operators instead of a standard if/else statement.
            //the & is a logical AND. Meaning that Both sides of the operator have to
            //evaluate to true. to return true (True,True = true, True,False = False, False,False = false)
            return (studfactor.StudFactor > impossabledream.reqStudFactor) & (studfactor.IncomeFactor > impossabledream.reqIncomeFactor);

}
public static bool operator >(Standards impossabledream, Studlyness studfactor){return studfactor>impossabledream;}

then just do the same for the '<' operator:

public static bool operator <(Studlyness studlyness, Standards standard)
{
            //Same as above, this is the Logical OR operator, this retuns true if either
            //side of the operator is true
            //so True, False = True, True,True = true, False,False = false;
            return (studlyness.StudFactor < standard.reqStudFactor) | (studlyness.IncomeFactor < standard.reqIncomeFactor);
}

public static bool operator >(Standards standards, Studlyness studlyness){return studlyness<standards;}

Ok...so now that our beloved, drunk couple can make Whoopie, we need to see what the outcome is. Quite simply, we need to see if the guy is going to loose his Huavos. So, lets just cast. Overloading the implicit casting operator is similar to overloading the other operators. The difference is that this is a Urinary operator (Meaning it only takes one parameter) and either the return type or the parameter have to match the enclosing type (IE if your overloading the casting operator inside the whoopie class either the parameter or the return value have to be of type whoopie). You also have to state that this is an Implicit operator:

    public class Whoopie
    {
        public static implicit operator Kid(Whoopie e)
        {
            Random TimeForKid = new Random();
            int i = TimeForKid.Next(0, 100);
            if (i >= 50)
                return new Kid();
            else
                return null;
        }

}

As you can see, the "Operator" is essentially the return type. Now, I did something here that you may not want to do without implementing a tryCast() method that may return null. But for the sake so simplicity (read: Lazy Developer) I didn't.

That's all there is to making whoopie. I suggest you check out the MSDN Article on operators to see what's available to override and what's not. If you would like my source code let me know. I have a little console app that I wrote to demonstrate all that stuff up there.

So, now that your well equipped for both the developer world, and the real world. Why not stop by our next AADND meeting at the SRT world headquarters in Ann Arbor and give me your feedback face to face. If anything you'll get some valuable FREE training in ASP.Net Caching from the one and only Steven Smith of AspAlliance.com fame and fortune.

Join me for the next time when we discuss how to make Beer Bongs out of bits of a garden hose and F# or something else equally as interesting.

Macs being targeted by virus's ... no way

Dave Redding — Thu, 01 Nov 2007 18:47:53 GMT

This might come off a little mean but....

HA HA! All you pretentious mac Zealots out there!

This is aimed at all those people who said "Go to apples home page and type 'Windows' in the search bar! Haha, so true so true, Mac's don't get viruses because [Insert why mac pcs are better than windows based pc's]"

This means one thing: Apple's day has finally come and Apple users are
going to get hit hard. All those unpatched vulnerabilities from years past
are going to bite them in the behind.

I can sum it up in one sentence: OS X is the new Windows 98. Investing in
security ONLY as a last resort losses money, but everyone has to learn it
for themselves.

Now as one buddy pointed out,

"I don't see how you get from trojan-horse-media-codec to "OS X is the new Windows 98"

I think the answer to that is, much in the same way of Windows 98, it's a new OS, that a lot of people have taken in and enjoyed, but it's also new , and fairly pervasive. Which means, of course, it's going to be a target for a lot of nasty maliciousness

Ok...so I'm sure I'm going to get lambasted for this post ... but it was worth it. Fire away

New Code to Live... BOO!

Dave Redding — Wed, 31 Oct 2007 20:37:37 GMT

Buddy Jay Wren has an interview on Josh Holmes Channel 9 show "Code to Live". Jay is being interviewed about "BOO: The wrist friendly language for the CLI". When you get a chance, check it out. Josh also has a great challenge and that is "...each of you to investigate a new language..." and I couldn't agree more.

So, Get out there and CODE!

One month to the day...

Dave Redding — Mon, 26 Feb 2007 15:33:00 GMT

And I have'nt made a post? In all honesty, the trip to Japan really knocked the wind out of me. So now it's pressing deadlines and fenagling conference calls. I'm also in the process of learning some Japanese. Its an interesting language, and as a developer, I thik it is constructed in a logical way thats easy to break down. Easier in some ways than English, and harder in others.

I'm looking at doing another tech in 5 min soon, but i want to get your feeback first. I'm kicking around these ideas for the next one, let me know which you guys would prefer.

1.Reflection
2.Workflow Foundation (An Overview)
3.Multithreading
4.WPF (An Overview)

How many of your guys are all geared up for the Nextel Cup season? Anyone watch the Daytona 500? it was an AMAZING race, so expect my next tech in 5 min to relate ;)

I've also got some great news about Day of Dot Net. We've got the gears turning on the conference and it'll be comming very soon. We are getting some great speakers lined up, including several Ineta guys, some excellent local talent and perhaps a special guest speaker or two. In addition, we will be giving away tons of swag. Recently i just read that last year we gave away around $40,000 worth of the stuff and this year were looking to top that!

So there you have it. Alot of fantastic stuff comming up in the near future, and an excellent way to kick off spring.

Don't forget to drop a comment to let me know what you'd like to see in the next Tech in 5 min.

Dave.