Video: Master Covariance and Contravariance in C# 4.0

Alfie:

Very nice explanation of two of the most important concepts that are neglected in C# 4.0 – You have truly solidify my understanding.

Originally posted on the pluralsight blog:

C# 4.0 adds loads of new features to excite and empower developers everywhere.  In this video excerpt from Oliver Sturm’s course C# 4.0 New Features you’ll see how to use the covariance and contravariance features to allow inheritance in generics.  In the full course Oliver also covers topics like optional parameters, the dynamic keyword, and new compiler options.

View original 143 more words

About these ads
Visual Studio 2010 RC – Cool New Features

Visual Studio 2010 RC – Cool New Features


I have been using Visual Studio 2010 Release Candidate and there are few cool things that I am pleasantly surprised about. I have list a few off the top of my head. See my list below – with pictures.

 


Sequence Diagram Generation
I find this to be a life saver. I don’t know about you but as a developer I want to dive right into code after I finish designing. There are times I have to sequence diagrams and this usually comes before you start coding. Now, with the sequence diagram generator in Visual Studio 2010, I can write code then simply generate. This not only saves you time but also lets you better understand your branches in your code that can lead to code complexity or cyclomatic complexity.

Here is the Code that we will work with in this post.

class Animal {
       public virtual void Description() { Console.WriteLine("Lives on earth"); }
    }

    class Bird : Animal {
        public override void Description() { Console.WriteLine("have feathers and a beak"); }
    }

    class Lion : Animal {
        public override void Description()
        {
            Console.WriteLine("roars and have large teeth");
        }
    }

    class Park
    {
        static void Main(string[] args)
        {
            List animalsInPark = new List();
            ShowDescriptions(animalsInPark);
        }

        static void ShowDescriptions(List animals)
        {
            animals.ForEach(animal => animal.Description());
        }
    }

Now right click on ShowDescriptions() and click generate sequence diagram. You should see this dialog.

And wallah – your very own Visual Studio 2010 crafted sequence diagram. I have to admit, I am really starting to like these diagrams

.

Code Window Zoom
Visual Studio 2010 allows you to zoom in and out just as in Internet Explorer. All you have to do is press Ctrl and use your mouse wheel or your equivalent mouse pad scroll to zoom in and out. This may not be so exciting but when it comes to giving presentations, this will make all our lives easier when it comes to changing font size. The beauty about zooming is that the font is crisp and smooth due to the fact that Visual Studio 2010 is built with WPF. Below is an image of me zooming in on the Animal class.

Code Generation
Most of us who use Visual Studio 2008 love the generate method feature. If you don’t know what this is, here is your intro. If you  write a method name and it doesn’t exists, you can right click on the method and tell visual studio to generate the stub and it will do it. No questions ask.

Visual Studio 2010 has taken this further and now you can even do classes. See below for demonstration.



Highlighted Reference
If you select a reference or even click on it, Visual Studio 2010 highlights all of the places it is used in your code.

Navigate To
Pressing Ctrl comma (,) brings up a dialog window that allows you to look for Methods, properties, classes, etc within your solution. It is case insensitive and it searches via partial name.

Click on any of the items found will take you to the line within the file where it is located.

Box Selection
This is one feature that I still have not found a suitable use for. This feature allows you to hold Ctrl + Alt and use either your mouse or arrow keys to select a rectangular area. If you now start typing, you will simultaneously be typing on all lines that you selected. If you happen to find a useful case for it, please let me know.

One thing I forgot to mention is that adding references to a project also seems faster. These are only some of the new features in Visual Studio 2010. Hope you find them as exciting as I do. Now go code!

Snowy Night in NYC

Its one of those nights where all I want to do is watch TV. I wont be publishing any code tonight. But just to let you know, this weekend there is a Software Engineer 101 Webcast this weekend (Feb 27)? If not and you want to add something extra to your arsenal the sign up here.  A sample from the overview is below which is from the Microsoft site in the link. See you there, now go code!

Overview
“This is a one-day, FREE event focused on core skills that modern developers need to have to be successful today.  This isn’t about learning the basics of Silverlight, WPF, or, rather, this conference will help you understand how to build software that is better designed, more maintainable, and more testable. “

Code Bytes #1 – PLINQ Basics

PLINQ /Parallel LINQ is part of the TPL (Task Parallel Library) and it makes your life easier when it comes to multi-core processor programming which is totally different from multithreading which allows more than one thread per process and you have no idea if they will be equally distributed across CPU cores. To use PLINQ your objects have to be in memory. This means you can’t use AsParallel on LINQ to SQL until you bring all your query results over to the local machine. When it comes to running your code in parallel the key to remember is that the AsParallel method is you friend. Every result that gets returned after your first call to AsParallel is always a ParallelQuery object. You can get more theory here. Now go code!

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace OliverCode.CodeBytes
{
    class ParallelLinqCB
    {
        static void Main(string[] args)
        {
            Action action = (int itemFromList) => Console.Write(itemFromList + ",");
            var lst = Enumerable.Range(1, 10);

             //PLINQ will decide on the number of processors to use in this run up to 64 threads (if you have that much)
             lst.AsParallel().Select(i => i * i).ForAll(action);
            Console.WriteLine();
            //My machine has 4 cores but i only need it to use up to 2 cores so I use the WithDegreeOfParallelism to restrict it
            //Or I could have use all 4 with the statement WithDegreeOfParallelism(4) hereby not letting PLINQ choose for me
            lst.AsParallel().WithDegreeOfParallelism(2).ForAll(action);

            Console.Read();
        }
    }
}

Cropped diagram courtesy of MSDN PFX (Parallel Programming Framework)
Code Bytes 1 - PLINQ

Code Bytes Series Intro

Code Bytes Series Intro

Today while on the F train home from work, I was thinking about how nice it would be to have these short series of code segments called Code Bytes (as Sound Bytes) that get straight to the point with little or no explanation. Yes there will be gaps in your learning if you are new to the topic or technology in the post. But 90% of the time when I stumble upon or search for code samples online, I already know something about what i am looking for. Plus I think this will stimulate more comments and conversation amoung this blog’s users.

Please share your thoughts and check back soon for the first in the series of CB (Code Bytes).