jump to navigation

Yet Another VS2010 Overview June 18, 2010

Posted by codinglifestyle in ASP.NET, C#, Parallelism, Visual Studio 2010.
add a comment

Today I attended a mediocre presentation by Paul Fallen which looked stellar compared to the atrocious overview put on at the Galway VS2010 Launch Event.  Paul had the look of a man who had seen these slides many times and glossed over them at speed.  In fairness, he was using the same presentation deck I’ve seen since TechEd 2008.  I think we had all seen several flavours of this overview by this time, so nobody seemed to mind.  Below are the few snippets of information to add to the smorgasbord of other snippets I’ve gleaned from other talks of this nature.

Please click here for more comprehensive posts earlier on VS2010.

Here is the VS2010 Training Kit which was used in the demos.

  • Common Language Runtime
    • Latest version is CLR 4 (to go with .NET 4).
    • Previous version of CLR 2 encompassed .NET 2, 3, 3.5, 3.5SP1
    • Implications
      • App pool .NET Framework version
      • Incompatibilities running CLR frameworks side by side within same process
        • Think 3 COM objects accessing Outlook all using CLR1, 2, and 4
  • Managed Extensibility Framework (MEF)
    • Library in .NET that enables greater reuse of applications and components
  • VS2010 & C# 4.0
    • IDE
      • WPF editor – Ctrl + mouse wheel to zoom.  Handy for presentations
        • Box select (like command prompt selection)
      • Breakpoint labelling, import/export, Intellitrace (covered below)
      • Code navigation improvements (Ctrl + , and Ctrl + – for back)
      • Call Hierarchy
        • Allows you to visualize all calls to and from a selected method, property, or constructor
      • Improved Intellisense
        • Greatly improved javascript intellisense
        • Support for camel case
        • Can toggle (Ctrl + Space) between suggestive and consume first mode (handy for TDD)
      • Test run record, fast forward
      • Better multi-monitor support, docking enhancements
      • Tracking requirements and tasks as work items
    • Better control over ClientID
    • Routing moved out from MVP to general ASP.NET
    • Optional and named parameters
    • Improved website publishing, ClickOnce (see prev. posts)
  • Parallelism
    • Pillars
      • Task Parallel Library (TPL)
        • He didn’t touch at all on the new task concept
      • Parallel LINQ (PLINQ)
        • These are the extension methods to LINQ to turn query operators in to parallel operations.
          • var matches = from person in people.AsParallel()
          •               where person.FirstName == “Bob”
          •               select person;
      • System.Threading significant updates
      • Coordination Data Structures (CDS)
        • Lightweight and scalable thread-safe data structures and synchronization primitives
    • Toolset
      • Debugger: record and visualize threads
      • Visualizer: View multiple stacks
      • IntelliTrace – new capability to record execution, play it backwards and forwards, even email it to another engineer and have them reproduce the problem on their box
    • Other
      • Eventual depreciation of ThreadPool as higher level abstractions layer atop toolkit?
      • Unified cancellation using cancellation token
  • Dynamic Language Runtime (DLR)
    • New feature in CLR 4
    • Major new feature in C# 4 is dynamic type
      • What Linq was to C# 3.5
    • Adds shared dynamic type system, standard hosting model and support to make it easy to generate fast dynamic code
    • Big boost working with COM: type equivalence, embedded interop, managed marshalling
  • Windows Communication Framework (WCF)
    • Service discovery
      • Easier to discover endpoints
      • Imagine an IM chat program or devices that come and go
    • REST support via WCF WebHttp Services
      • Available in the code gallery templates
  •  

    PlaySound: A Better Way to Play Wav Files in C# April 30, 2010

    Posted by codinglifestyle in C#, CodeProject, Uncategorized.
    Tags: , , , , ,
    1 comment so far

    The other day I was whipping up a fun utility which played some wav files.  I was giving this to people who’s desktop us Windows Server 2008 so using the Windows Media Player COM object wasn’t an option and SoundPlayer didn’t seem to work with any of the wav files I had for some reason.

    Back in my C++ days I used to do this all the time with winmm.dll’s PlaySound (and have a piece of freeware which uses this to a great extent).

    Well, once again as a C# programmer I am saved by pinvoke!

    public static class Wav

    {

    [DllImport(“winmm.dll”, SetLastError = true)]

    static extern bool PlaySound(string pszSound, UIntPtr hmod, uint fdwSound);

    [Flags]

    public enum SoundFlags

    {

    /// <summary>play synchronously (default)</summary>

    SND_SYNC = 0x0000,

    /// <summary>play asynchronously</summary>

    SND_ASYNC = 0x0001,

    /// <summary>silence (!default) if sound not found</summary>

    SND_NODEFAULT = 0x0002,

    /// <summary>pszSound points to a memory file</summary>

    SND_MEMORY = 0x0004,

    /// <summary>loop the sound until next sndPlaySound</summary>

    SND_LOOP = 0x0008,

    /// <summary>don’t stop any currently playing sound</summary>

    SND_NOSTOP = 0x0010,

    /// <summary>Stop Playing Wave</summary>

    SND_PURGE = 0x40,

    /// <summary>don’t wait if the driver is busy</summary>

    SND_NOWAIT = 0x00002000,

    /// <summary>name is a registry alias</summary>

    SND_ALIAS = 0x00010000,

    /// <summary>alias is a predefined id</summary>

    SND_ALIAS_ID = 0x00110000,

    /// <summary>name is file name</summary>

    SND_FILENAME = 0x00020000,

    /// <summary>name is resource name or atom</summary>

    SND_RESOURCE = 0x00040004

    }

    public static void Play(string strFileName)

    {

    PlaySound(strFileName, UIntPtr.Zero, (uint)(SoundFlags.SND_FILENAME | SoundFlags.SND_ASYNC));

    }

    }

    Example:

    FileInfo fi = new FileInfo(sFile);

    Wav.Play(fi.FullName);

    A day with The Gu! MVC 2, VS2010 and ASP.NET v4.0 September 29, 2009

    Posted by codinglifestyle in ASP.NET, C#, jQuery, linq, Visual Studio 2010.
    Tags: , , ,
    2 comments

    Yesterday I went to Dublin to attend a talk by Scott Guthrie. I knew from reputation Scott was a good speaker so it was great to see him in action. I think most of the Microsoft development world is familiar with Scott’s blog. I’ve exchanged emails with him in the past and he has always done a great job following up. He is a very down to earth guy, very at ease at the podium, and very comfortable the material.

    We started the talk with a beginner’s look at MVC 2 and then looked at .NET v4 and VS 2010. Some of this information was a recap of TechEd (see my earlier post), but there was plenty of new information which I’ll recap here.

    MVC 2

    Scott’s talk was about some of the improvements of the next version of MVC which will be baked in to VS2010. But thankfully, he covered the whole concept in a very demonstration-oriented way. He built upon each concept in a way that left me with a good grasp of the basics.

    First, he reiterated that webforms is not going away. MVC is just an alternative presentation layer built upon the same core .NET libraries we know and love. Because there is no designer, no .NET controls, and no code behind (as such) you are much more in control of the generated HTML.

    What MVC offers is that control, URL mapping, js integration, and testability. If you’ve ever worked on a messy web app and wished for more structure MVC may be for you. It offers a clean separation of your data layer (model), your html (view), and your business logic (controller).

    Right, enough of this verbose carrying-on, time for bullet points!

    · MVC 1 was an extra for VS2008 built on ASP.NET v3.5. MVC2 will be baked in to VS2010 and built on ASP.NET v4.0. It will be backwards compatible with MVC1 apps so upgrades should be a snap.

    · Controller

    o URL Mapping – this is not just a cool feature but fundamental to MVC

    § http://localhost/galway maps to a controller class called galway

    · .index is the default action method

    § http://localhost/galway/hooker maps to an action method inside controller Galway

    § http://localhost/galway/hooker/beer maps to the action method hooker and passes the string parameter “beer”. Note this is an alternative to query string parameters.

    · These parameters can be strongly typed to string, int, even classes

    § Routing rules go in to gloal.asax.cs

    · Operates like an HTTPHandler but is baked in to ASP.NET

    · Order routing rules as you see fit. One falls through to another and ultimately to a default

    · Can use regular expressions and constraints in your rules

    o We can start playing with a controller without a View or Model and directly return some html from controller (think webservice)

    o Controller action methods can return an action result type to return a View, redirect, etc.

    o To communicate with View we can

    § store information in a ViewData[“key”] dictionary to pass to View

    § store information in a Model and pass this class to View

    o Action Filters decorator attributes can be specified on the controller class or an action method to specify which roles / authorization required to use

    o Tip: Use a service layer to keep direct data layer queries out of controller

    · View

    o Offers separation of UI from business logic and just renders the UI

    o Remember, no designer or ASP.NET controls. Just you, html, and <%inline code%>.

    o HTML. Helper with many built-in templates to generate common controls like checkboxes and textboxes with validation

    § Create your own View templates to have custom scaffolding like a table for a DB list

    o Html.EditorFor gives Linq type intellisense to meaning we aren’t binding to a “string” in our model

    § Smart in that Booleans render as checkboxes, etc.

    § EditorTemplates can be used to custom render anything can be shared across entire site or used for just one View

    o Html.DisplayFor gives read-only view of data

    · Model

    o A data entity with logic.

    § Can be LinetoSQL, ADO.NET, your own entity class, whatever

    o Can decorate properties with attributes to specify common validators

    § Required, range, etc.

    § Very powerful, dynamic, should greatly ease pain of validating form data

    § Automatically adds a CSS class you can customize to get a red background, whatever

    § Can have server and client side validation

    · Client side requires an extra js plug-in but worked seamlessly in demo

    · Unit testing is crucial component of MVC and a test project is automatically created for you with every MVC website

    o Use AAA method

    § Arrange

    · Create a controller

    § Act

    · Get the result of (controller.Index(0) as ViewResult)

    § Assert

    · Assert if result.IsNotNull

    o Dependency injection

    § In the constructor pass DB service layer or fake data. Use an interface for flexibility.

    VS2010 & .NET v4.0

    · Beta 2 out shortly

    · IDE improvements

    o Ctrl-, – quick nav via types

    o Highlight all references

    o Tip: Download CodeRush Xpress for these features in VS2008)

    · Better intellisense support

    o camel case (i.e. DB matches DataBind)

    o Matching (i.e. bind matches DataBind)

    o Consume first mode for TDD (test driven development)

    § Ctrl + Alt + Space to toggle

    o Much improved javascript support

    § XML documentation (place under function()) for better intellisense for your own libraries

    · Debug History and dumping a crash covered again (see previous post)

    · .NET 4 is a new CLR unlike 3.0 and 3.5

    o In IIS you will see v4.0 as a selectable framework

    · Upgrading to VS2010 hopefully just changes solution file (like VS2005 > VS2008) so painless enough to upgrade

    · Multi-target support from .NET v2.0 on up

    · Lots of project templates including a new online template gallery (web starter kits?)

    · Controls to have ClientIDMode property

    o Static – is what it is. Call it “bob” and you are guaranteed to get document.getElementByid(“bob”)

    o Predictable – new default… no more ctrl001_ prefixing

    o Auto – current

    o Inherit

    · CSS rendering support

    o Big upgrades including alternatives to tables for .NET controls

    · ViewState – off by default. Force developers to think when we really need it.

    · URL routing like MVC for WebForms (connotical)

    · SEO (Search Engine Optimization)

    o Page.Description and Page.Keywords to generate <meta> tags

    § Idea: Place in master page, tie-in to DB, allow client to change as required

    o New SEO plug-in for II7 will crawl site and indentify issues that reduce search relevancy

    § Can increase search traffic 30-40%

    · ScriptManager support CDN allowing you to specify URL for AJAX and jQuery direct from http://ajax.microsoft.com. Will actually phantom redirect to very local source but browser histories across many site will use standard Microsoft url meaning high probability of being cached

    · New controls

    o QueryExtender search control – search a grid

    o Chart control

    · Validation like MVC for GridView, FormView, ListView

    o Auto reflect on class for validation decorator attributes and dynamically render validators with client and server-side validation

    · Output/object cache providers (aka customizable I’m sure)

    · Pre-start application

    o Keep your application up, cached, and ready vs. IIS default behavior which shuts down when not in use

    · Performance monitoring

    · <%: Html encoded string %>

    · Deployment (see previous post)

     

    Well that wraps it up.  Please see my earlier post from Tech-Ed and download my PowerPoint presentation which covers a lot of the upcoming features in VS2010.

    Composite Controls: Dude, where’s my data? June 25, 2009

    Posted by codinglifestyle in ASP.NET, C#, CodeProject.
    Tags: , , , , , , , , ,
    3 comments

    I started my .NET career writing WebParts for SharePoint 2003.  You would think this would make me a bit of a server control expert, as WebParts are essentially gussied up server controls.  Yet, I’ve officially wasted 2 days on an age old composite control problem which typically involves these kinds of google searches:

    • server control postback missing data
    • postback server control child control missing
    • composite control event not firing
    • webcontrol createchildcontrol postback control
    • viewstate webcontrol data missing empty blank

    Sound familiar?  I understand your pain and hope I can help.  Composite controls can be tricky, if they aren’t set up just right even the most basic example won’t work properly.

    First, keep in mind there are two types of custom controls developers typically write.  There are user controls (.ascx) and server controls (.cs).   We will focus on a server control.  One gotcha for a composite control is using the right base class*.  We want to use the CompositeControl base class, not WebControl or Control.  This will tell ASP.NET to ensure the IDs of our child controls are unique (via INamingContainer).  This is simple but very important, in order for ASP.NET to wire up events and serialize ViewState the ID of a control needs to be identical at all times.  So only assign a literal string to your child control and let .NET worry about making it unique.

    Now there are two cases to consider, the first is where our composite server control creates a static set of controls.  This is a straightforward case, because we can create the controls at any time.  The most important function in a server control is CreateChildControls().   This is where you can create and assign your controls to member variables.  We can have properties and get and set values straight to our member controls.   In every property just call EnsureChildControls() in each get and set.

    private TextBox _TextBox;

    [Bindable(true), Category(“TextBoxEx”), DefaultValue(“”), Localizable(true)]

    public string Text

    {

    get

    {

    EnsureChildControls();

    return _TextBox.Text;

    }

    set

    {

    EnsureChildControls();

    _TextBox.Text = value;

    }

    }

     

    protected override void CreateChildControls()

    {

    _TextBox = new TextBox();

    _TextBox.ID = “_Text”;

     

    Controls.Add(_TextBox);

    }

     

    In reality we may have properties or logic which determine which controls are created or how our control behaves.  This is a complicated scenario, because we cannot create the controls before the logic has been initialized (otherwise our logic will not know which controls to dynamically create)!  In this case, we want our control’s own properties independent of the child controls and we’ll store this information in ViewState, not a control.  We want to avoid calling EnsureChildControls() and delay calling CreateChildControls() prematurely.  This allows the control to be initialized first so that when CreateChildControls() is called our logic will know which controls to create.  First let’s see how to store a property in ViewState.

     

    private const string STR_CreateTextBox       = “CreateTextBox”;

    public bool CreateTextBox

    {

    get

    {

    if (ViewState[STR_CreateTextBox] == null)

    return false;

    else return (bool)ViewState[STR_CreateTextBox];

    }

    set

    {

    ViewState[STR_CreateTextBox] = value;

    }

    }

    If you were wondering if ViewState was the right place to store properties the answer is maybe.  For a bound property it is overkill as it will be set back to its original value every postback.  In that case we simply need a property with a backing store (or in C# 3.0+ a simple get; set; will do).  But when our logic needs to be stored ViewState is the place to persist it.  Just remember that the dynamically created controls don’t need ViewState of their own so we’ll be sure to turn that off when we create them.  The right place to create and add our dynamic controls is in CreateChildControls().  Let’s create a TextBox based on some logic stored in the composite control’s ViewState.

    protected override void CreateChildControls()

    {

    if (CreateTextBox)

    {

    _TextBox = new TextBox();

    _TextBox.ID = “_Text”;

    _TextBox.EnableViewState = false;

    _TextBox.TextChanged += new EventHandler(Text_TextChanged);

    Controls.Add(_TextBox);

    }

    }

    void Text_TextChanged(object sender, EventArgs e)

    {

    string sText = ((TextBox)sender).Text;

    }

    Lets take a look at what we’re doing here.  We are dynamically creating our TextBox control in CreateChildControls().  We are setting the ID to a literal string, ASP.NET will make sure our name is unique because we inherit from CompositeControl.  We are setting EnableViewState to false because, as discussed, our composite control is already taking care of ViewState.  We are adding an event as an example as this is the right place to setup any events you might need.

    Now here is the interesting bit:  How do we get the user’s value back from a dynamic TextBox?  Take another look at the property Text above and note that the getter calls CreateChildControls().  This will ensure our textbox is recreated and the form will syncronize the user’s form data back in to the textbox.  We could also capture the value using the TextBox’s text changed event to do some processing or whatever.  With this event, when we postback, our Text_TextChanged event will fire before a OK button’s click event on the page due its place in the control hierarchy.  This allows our event to manipulate the TextBox’s text value before our OK button’s click event occurs.

    I’ll just note that you may be reading some advice on forum’s to override OnInit.  Contrary to that advice, CreateChildControls() is the right place to dynamically create your controls and events.  OnPreRender() is a great place for initialization as it is called after all properties are set.  And, of course, Render() gives you complete control on how your control will be drawn.

    * Now I have to mention Repeater.  Repeater may cause a lot of pain with your server controls.  You may see your control working properly outside a repeater and suddenly all go pearshaped when used with one.  After a lot of trial and error I discovered this had to do with the ID assigned to the dynamic controls.  We know ASP.NET depends on the ID being identical at all points for events and serialization with the form and viewstate to take place.    Sad to say when our composite control is inside a Repeater we can not trust our IDs to .NET.  So we do not want to inherit from CompositeControl or INamingContainer.  Instead, assign a unique id yourself.  Being that it is a repeater, this can not be a literal string because no 2 controls can have the same ID.  Instead try _TextBox.ID = this.ID + “_Text”;

    So although there are several points and gotchas to consider, think about using a custom control to lend some OO design to your UI.  Be sure to unit test on a simple website to make development of the control easier.  Good luck!

    Code Snippets – List of C# snippets in VS2008 May 6, 2009

    Posted by codinglifestyle in C#, CodeProject, Visual Studio, Visual Studio 2010.
    Tags: , , ,
    add a comment

    In VS2010 we are told to expect a lot more code snippets.  To be honest, I don’t use them much but watching the demo I told myself it was time to give them another look.  Sometimes I get a great feeling of productivity in hammering out for loop templates and properties and tell myself who needs snippets?  But there is a lot of power there, and its going even further in VS2010.

    My problems is I can never remember which code snippets are there.  I occassionaly see them in Intellisense, but there is so much there it’s hard to pick them out.  More than once I’ve carefully gone through the intellisense list trying to pound the useful ones in to my brain.

    I decided to do a quick search for a list of code snippets in VS2008 for C#.  Surely I can’t be the first who just wants a simple list, right?  I came across Francesco’s blog who posted the code to iterate through your snippets and output them.  A quick change to update it for VS2008, C#, and to output a comma delimited line per snippet, then a paste in to Word, and Convert Text to Table (by comma) and voila!

    List of Code Snippets in VS2008 for C#

    #if Code snippet for #if
    #region Code snippet for #region
    attribute Code snippet for attribute using recommended pattern
    checked Code snippet for checked block
    class Code snippet for class
    ctor Code snippet for constructor
    ~ Code snippet for destructor
    cw Code snippet for Console.WriteLine
    do Code snippet for do…while loop
    else Code snippet for else statement
    enum Code snippet for enum
    equals Code snippet for implementing Equals() according to guidelines
    exception Code snippet for exception
    for Code snippet for ‘for’ loop
    foreach Code snippet for foreach statement
    forr Code snippet for reverse ‘for’ loop
    if Code snippet for if statement
    indexer Code snippet for indexer
    interface Code snippet for interface
    invoke Code snippet for safely invoking an event
    iterator Code snippet for a simple iterator
    iterindex Code snippet for ‘named’ iterator/indexer pair using a nested class
    lock Code snippet for lock statement
    mbox Code snippet for MessageBox.Show
    namespace Code snippet for namespace
    prop Code snippet for an automatically implemented property
    propg Code snippet for an automatically implemented property with a ‘get’ access or and a private ‘set’ accessor
    sim Code snippet for int Main()
    struct Code snippet for struct
    svm Code snippet for ‘void Main’ method
    switch Code snippet for switch statement
    try Code snippet for try catch
    tryf Code snippet for try finally
    unchecked Code snippet for unchecked block
    unsafe Code snippet for unsafe statement
    using Code snippet for using statement
    while Code snippet for while loop

    You can see snippet’s keyword typically matches the operator.  So next time you type for or while or try remember to hit TAB-TAB to expand the snippet.  Next time we’ll look at making your own code snippets.

    Visual Studio 2010 and C# v4.0 Technology Preview Presentation April 29, 2009

    Posted by codinglifestyle in C#, Visual Studio 2010.
    Tags: , , , ,
    1 comment so far

    This is an expansion on my previous post on Tech-Ed 2008 which I attended last November’s in Barcelona.  As a condition for attending I gave a talk to my company, Storm Technology.  I put a good amount of effort to the attached PowerPoint presentation for my talk.  The company has graciously allowed me to distribute it which is great because all the information is relevant and up to date.  If you are giving a similar presentation and/or want a template for a good place to start you are welcome to my slides.

    https://codinglifestyle.files.wordpress.com/2009/04/storm_teched2008.pptx

    Enjoy!

    Cascading Dropdown Lists with jQuery (parent / child select options) March 9, 2009

    Posted by codinglifestyle in ASP.NET, C#, CodeProject, Javascript, jQuery.
    Tags: , , , , , , , ,
    add a comment

     

    Recently I was tasked with merging 3 similar screens in to one.  I took stock of the commonalities and decided a Category and Subcategory dropdown list would suffice.   As you’d expect the contents of the Subcategory dropdown depend on the selected Category.  Obviously I wanted to avoid postbacks so I first looked to the Ajax Control Toolkit’s CascadingDropDown extender to link the parent to the child.  In my case, there were only a dozen subcategories so a webservice seemed like overkill.

    After attending Tech-Ed 2008 and seeing Microsoft throwing its weight behind jQuery I decided to have a look.  So what follows is my first foray in to jQuery and I’m quite pleased with the results.

    First, we define an enum in the codebehind which can be used for bitwise operations.

    public enum Category

    {

    Invoice     = 1,

    Order       = 2,

    Shipment    = 4   //Fourth item would be 8, then 16, 32, …

    }

    Next I wanted to be able to use the enum to specify the Category (only specifying one) and Subcategory items (bitwise OR any combination).

    _DropDownCategory.Items.Add(GenerateListItem(“Orders”, Category.Order, false));

    _DropDownCategory.Items.Add(GenerateListItem(“Invoices”, Category.Invoice, false));

    _DropDownCategory.Items.Add(GenerateListItem(“Shipments”, Category.Shipment, false));

    _DropDownSubcategory.Items.Add(GenerateListItem(“Purchase Orders”, Category.Invoice | Category.Order | Category.Shipment, false));

    _DropDownSubcategory.Items.Add(GenerateListItem(“Quote Number”, Category.Order, false));

    _DropDownSubcategory.Items.Add(GenerateListItem(“Customer Project Number”, Category.Shipment, true));

    The enum was converted to a number and added as a custom attribute to the new list item in GenerateListItem():

    li.Attributes.Add(“Category”, ((int)eCat).ToString());

    Enter jQuery, first we’re going to need to keep a copy of all the available Subcategory items.  Each time we change the Category we will be showing a subset of this array which we must keep separate in memory.

    var optSubCat = null;

    $(function() {

    //Make a copy in memory of all the subcat options

    optSubCat = $(“#_DropDownSubcategory”).children().clone();

    //Default subcat to “Orders”

    ddSubcategoryUpdate(2);

    });

    Then we need an event to fire when the Category is changed.

    $(function() {

    $(“#_DropDownCategory”)

    .bind(“change”, function(event) {

    var eCat = this[this.selectedIndex].attributes(“Category”).value;

    ddSubcategoryUpdate(eCat);

    });

    });

    Note how jQuery allows us to wire up DOM events after the fact to our .NET controls.  Here we add an onchange event dynamically rather than injecting this via the codebehind which forces us to put javascript code in the wrong place.  All we’re doing is pulling the value of the enum from the selected Category and then passing it to a function which will update the Subcategory items.

    function ddSubcategoryUpdate(eCat) {

    //Remove all items from drop down

    $(“#_DropDownSubcategory”).children().remove();

    //For each subcat item: test if it belongs in eCat, if so add it

    $(optSubCat).each(function() {

    if (($(this).attr(“Category”) & eCat) > 0) {

    $(“#_DropDownSubcategory”).append($(this).clone()[0]);

    }

    });

    }

    And finally, in the if statement we see we test each Subcategory item previously saved in memory to see if it matches the enum value of the Category.

    What we’ve ended up with is a very powerful yet simple mechanism for cascading dropdowns using enums in our codebehind.  It’s easier to wire up than what the Ajax Control Toolkit provides, its all script so the UI looks good, and while this could have been done in straight javascript it demonstrates the power and simplicity of the jQuery library.

    Tech-ed 2008 November 17, 2008

    Posted by codinglifestyle in ASP.NET, C#, IIS, jQuery, Parallelism, Security, SharePoint, Visual Studio 2010.
    Tags: , , , , , , , , , , , , , , , , ,
    3 comments

    Last week I had the opportunity to attend TechEd 2008.  I have compiled a set of notes from the keynote and sessions I attended below.  Most of the information presented at these conferences is not really instructive for addressing today’s problems but talks about future problems and the technologies we will use to address them.  There are some interesting technologies coming down the pipe in the not so distant future and these notes may provide you with enough information to google more information about the topics which interest you.

     

    I skipped a lot of older information about the VS2008 release, C# v3.0, and Linq which can all be found here.

     

    Keynote

    ·         Testing Activity Center application

    o   Pillar: No more no-repro

    o   Generate test cases that tester can click off

    o   Bug recording including video, call stack, system information

    o   Generate a bug integrated in to Team System

    §  Can start up debugger and reproduce tester’s scenario

    §  Captures line of code, call stack, everything

    ·         Code buffering

    o   Method shows history of changes (graphically too)

    o   Integrates SCC versions in to IDE

    ·         MVC design pattern

    o   Model                   =              data

    o   View                     =              web page / UI

    o   Controller             =              logic

    ·         SharePoint Integration

    o   Server explorer includes lists, ect

    o   Webpart template automatically contains ascx control for design support

    o   SharePoint LINQ

    o   List Event wizard

    §  Auto-generate XML for site def??

    ·         Performance Profiler

    o   Pillar: Leverage multi-core systems

    o   See which method is taking time and core utilization

    §  Graphically shows core usage including drill down

    ·         Will help with concurrency, deadlock debugging, ect

    VS2008 Service Pack 1 Overview

    ·         ADO.NET Entity Framework release

    o   Very similar to Linq To SQL

    o   Generate data model

    §  conceptual model static (actual db) model

    o   Data Services

    §  Data centric abstraction over web services (WFC)

    §  Exposes and takes IQueryable so datasets very easy to work with in a LINQ like way

    §  Routing lets URI act like a Linq query

    ·         http://Root/my.svc/Customers/35/FirstName

    o   Dynamic Data

    §  Given a data model will create aspx accessibility to defined objects

    ·         Security: all objects off by default but can dynamically access entire data model

    ·         Allow CRUD access via ASPX templates applied to all objects

    o   CRUD = create, read, update, delete

    o   Can create individual page for certain object

    o   Can customize template to affect all objects

    ·         Ajax / other enhancements

    o   Ajax

    §  History Points

    ·         Addresses problem that users lose ability to hit back button

    §  Script combining

    ·         To improve performance allows to dynamically combine js libraries

    o   Improves javascript intellisense

    o   Improves web designer performance (bugs/regressions addressed)

    C# v4.0

    ·         History

    o   V1 – Managed Code big emphasis

    o   V2 – Generics; finished the language

    o   V3 – LINQ

    ·         Pillars

    o   Declarative programming: we are moving from “what?” to “how?”

    §  LINQ is an example of this

    o   Concurrency: Some of the parallelism extensions we will be getting

    o   Co-Evolution: VB and C# will more closely evolve together vs. Features hitting languages at different times

    o   Static vs. Dynamic Languages: aren’t necessarily a dichotomy

    §  Static: C++, C#, VB – anything compiles

    §  Dynamic: IronRuby, IronPython, Javascript

    ·         New keyword: dynamic

    o   Call any method of a dynamic object and the compiler won’t complain

    §  No intellisense possible

    §  Will call during runtime

    §  i.e.

    ·         dynamic calc = GetCalculator();

    ·         calc.Add(10,20);   //We know nothing about calc object

    §  Lots of power to  be explored here

    o   Optional Parameters

    §  Like in C++ (and apparently VB)

    §  Named parameters

    ·         Can also skip optional parameters

    ·         Public StreamReader OpenTextFile(string sFile, bool bReadOnly = true, int nBufferSize = 1024);

    ·         sr = OpenTextFile(“foo.txt”, buffersize:4096);

    o   COM Interoperability

    §  No more “ref dummy”!

    ·         Will get: doc.SaveAs(“Test.docx”);  //Winword saveas

    ·         Versus:   doc.SaveAs(“Test.docx”, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy, ref dummy);

    §  Automatic dynamic mapping so less unnecessary casting

    §  Interop type embedding

    ·         No more bringing in PIA

    o   Safe Co and Contra-variance

    o   Compiler as a service

    §  Compiler black box opened up to be used and extended

    §  In example created a command window with C#> prompt

    ·         Was able to define variables, functions, ect like in IronPython

    Ajax v4.0

    ·         Introduction

    o   Web app definition

    §  Web site is a static collection of pages (such a BBC news)

    §  Web application is something which replaces a traditional windows app

    o    Traditional Server-Side ASP.NET vs. AJAX

    §  Pros

    ·         Safe: Guaranteed browser compatibility

    ·         Powerful: All the power of a .NET language in code-behind

    §  Cons

    ·         Response: User must wait for postback

    ·         Performance: All page content rendered for each interaction

    ·         Update Panels: Use Wisely

    o   An update panel uses sneaky postbacks so while it looks better it is still as bad as traditional server side asp.net

    o   Don’t wrap an entire page in an update panel

    §  Wrap the smallest region required

    §  Use triggers to set what controls will fire a sneaky postback

    o   Turn ViewState OFF

    §  Down the line this will not be on by default

    §  We often send a lot of unnecessary information over the wire in ViewState

    ·         Ajax Calls (Services)

    o   Consider using an Ajax control to update data as needed

    o   Calling a web service from javascript is not considered dangerous or bad practice

    o   Example

    §  Have a datagrid with postback bound to a dropdown list.  Instead of a postback on ddlist use Ajax call

    ·         Instead of a datagrid use a straight html table

    ·         Via script we make a call to the web service

    ·         Use stringbuilder to format return to build up new rows

    §  Kinda horrible!  Too much mixing of mark-up and script

    ·         Client Side Controls

    o   Clean way of separating Ajax related script from the web page

    o   Allows you to bind to Ajax calls in a template way

    o   Example

    §  From above we now separate js in to a client side control which is now cleanly referenced on our web page

    ·         Declarative Client Side Controls

    o   “X” in XML stands for extensible; but not often extended!

    o   Use XML to bring in namespaces like System and DataView

    o   Can define a datagrid purely in html by adding attributes to the

    tag in a table

    ·         Fail over

    o   Problem with Ajax is not it is not always supported for reasons of accessibility, search engines, or disabled javascript (mobile devices)

    o   Does require double implementation of Ajax and traditional solution but it is an option when needed

    ·         New features in SP1

    o   Back button support!

    §  As of VS2008 SP1 Ajax now has back button support

    §  ScriptManager property EnableHistory=true and onNavigate event

    §  AddHistoryPoint(key,value);

    §  AddHistoryPoint(key,value,“Text seen in back button history instead of url”)

    §  Process

    ·         Enable history and add event

    ·         When page event fires store value (index, ect) with AddHistoryPoint() in provided history cache

    ·         Use history event to set page back up with value retrieved from HistoryEventArgs

    o   Example: set a form to display an item from the last selected index

    o   Script Combining

    §  Combine scripts for better performance

    ·         Example showed initial 15sec down to 3

    §  Must tell ScriptManager all libraries and it will combine/compress them in to one server call

    §  Must explicitly tell which scripts to use – even separate AJAX libraries

    ·         ScriptReferenceProfiler

    o   Free webcontrols which will tell you all the libraries a page uses to make the above less painful

    ·         Factoids

    o   Ajax initiative started to address Outlook Web Access (OWA); a good example of a web application

    o   Script Manager is just a way to make sure the page includes the Ajax javascript libraries

    §  Ajax script commands prefixed with $

    ·         $get(“my id”) looks to be handy

    §  Can dynamically add event handlers in javascript using Ajax js library

    ·         $addHandler($get(“dropdownlist1”), “change”, myFunc);

    ·         Cool “must have” tools

    o   Fiddler (www.fiddler2.com)

    §  Shows response time, requests/responses, statistics

    §  Tip: must place a dot in uri for Fiddler to capture localhost

    ·         http://localhost./default.aspx

    o   Firebug – Firefox extension

     

    Visual Studio Tips & Tricks

    ·         Ppt slides: http://code.msdn.microsoft.com/karenliuteched08

    ·         A lot more keyboard shortcuts: http://blogs.msdn.com/karenliu/

    ·         MS and partnered with DevExpress which is offering CodeRush Express for free

    o   Required for a lot of the shortcuts and refactoring shown

    ·         Editing

    o   Tools>Options>Editors>C#>Formatting>Set Other Spacing Options>Ignore Spaces

    o   Keyboard tricks

    §  Ctrl M,O               Toggle collapse all

    §  Ctrl M,M              Expand region

    §  F12                         Go to definition

    §  Shift F12              Final all references

    §  Ctrl Shift F8        Jump up Go to definition stack

    §  Ctrl [ or ]              Jump between brackets

    §  Ctrl Alt = or –      Smart Select

    §  Ctrl .                      See smart tag (Implement a missing function, add using statements)

    §   

    o   Snippets

    §  Lots of boilerplate goodies are there.  Really need to start using them

    ·         Ctor

    §  Lots more smart HTML snippets coming

    ·         Debugging

    o   Step OVER properties (r-click at breakpoint to check option)

    o   Step into Specific – list of all functions down the chain you can jump to step in to

    o   Tools

    §  Tinyget – mini stress test

    §  Adphang – get memory dump of w3wp

    §  Windbg – open dump

    ·         Loadby SOS mscorwks

    o   Need sos.dll for windbg to interpret stack

    ·         Deployment

    o   Web.config transform for release, uat, ect

    o   Powerful web deployment publishing options

    §  Http, ftp, fpse

    §  Msdeploypublish

    ·         New MS protocol for host supporting includes database, iis settings, access control lists (ACL), ect

    ·         Free test account at http://labs.discountasp.net/msdeploy

    ·         Other

    o   www.VisualStudioGallery.com  – IDE extensions gallery

    §  PowerCommands for VS08

    o   VS2008 SDK application

    §  Samples tab

    ·         Click to open sample straight in VS ready to go

    Silverlight v2 101

    ·         XAML

    o   A subset of WPF

    o   Read-only designer view

    §  Must edit  XAML by hand

    §  Proper designer on the way

    o   Can at least drag XAML text templates for many controls

    ·         Silverlight Controls

    o   Greatly extended in Silverlight v2

    §  Visit: www.silverlight.net for a demo

    §  Most of what you’d expect in ASP.NET is available in Silverlight

    o   Of Note

    §  StackPanel

    ·         Previously on Canvas available requiring static x,y position designation

    ·         Operates like a panel with z-order

    ·         Security

    o   Lives in a sandbox which can’t be extended for security reasons

    o   There are ways to safe access local (isolated) storage, have a file dialog, sockets, cross domain access

    ·         Nifty

    o   Can easily stream media content with one line of XAML

    o   Can easily spin any element

    Parallelism

    ·         Introduction

    o   Sequential performance has plateaued

    o   When we have 30 cores this may lead to dumber cores where we have a situation that today’s software runs slower on tomorrow’s hardware

    o   Need  to start thinking about parallelism

    §  Understand goals vs. usage

    §  Measure existing performance.  VS2010 has tools to do this

    §  Tuning Performance

    ·         Typically we start with sequential programming and add parallelism later

    ·         VS2010 has Profiler tool for tuning performance

    §  Identify opportunities for parallelism

    §  Use realistic datasets from the outset; not only on site with the customer

    §  Parallelize only when necessary, but PLAN for it as it does introduce race conditions, non-determinism, timing issues, and a slew of other potential bugs

    §  Once code is written for parallelism it can scale to any size automatically without any code changes

    ·         New technologies to help

    o   Parallel API

    §  Task

    ·         Like a thread but more optimal with a richer API

    o   Has a value for threads which must return a value

    §  Accessing the value automatically the same as Thread.Join or Task.Wait

    §  ThreadPool

    ·         Just pass a delegate and let Microsoft worry about the hardware and how to best allocate and spawn threads

    ·         The ideal number of threads = number of cores

    §  TimingBlock class makes it easy to test performance

    ·         No more: (end time – start time) / 1000

    §  Decorate code w/ measurement blocks which appear in Profiler

    o   Parallel Extensions

    §  First class citizen in VS2010 (SDK today?)

    §  Parallel.For and Parallel.ForEach

    ·         Still need to use critical sections around shared resources inside loop

    ·         Tip: Best practice is to parallelize the outer for loop only

    ·         Automatically adds measurement blocks to profiler to see results

    §  Parallel.Invoke

    §  Parallel extended IEnumerable to perform queries much faster

    ·         var q = from n in arr.AsParallel() where IsPrime(n) select n;

    §  Task group

    ·         i.e.  For a quick sort instead of using a recursive algorithm use task groups to leverage parallelism with little change to code

    o   Debugging – Parallel Stacks

    §  Richer API to display tasks or threads and view a holistic mapping of their execution

    o   Tools

    §  Performance Wizard

    ·         CPU sampling, timing, ect

    §  Profiler

    ·         Thread Blocking Analysis

    o   Shows each thread’s parallel execution revealing race conditions affecting performance

    §  Displays information about critical sections in tooltip

    §  Can show dependencies for resources/locks across threads

    jQuery

    ·         Ships in future VS but available now

    ·         Will not be changed by Microsoft but will be supported so we can use it with customers requiring support

    ·         VS intellisense available from jquery.com

    ·         Selectors

    1.       $(“:text”)             tag          Select all text boxes

    2.       $(.required)       class      Select any element with this class tag

    3.       $(“#name”)        id            Select with this ID

    ·         Animations

    1.       $(…).Show()

    2.       $(…).Hide()

    3.       $(…).slideDown()

    4.       $(…).slideUp()

    5.       $(…).fadeIn()

    6.       $(…).fadeOut

    7.       Massive open source libraries with hundreds more

    §  Plugins.jquery.com

    MVC 101

    ·         MVC

    o   Controller (input) pushes to model and view

    o   View (UI)

    o   Model (logic)

    ·         An alternative, not replacement, to traditional web forms

    ·         Easier to test

    o   No dependencies on request/response or viewstate as this everything is explicit and therefore testable

    ·         No server side controls (or designer support), postbacks, or events.

    o   Think back to classic ASP

    o   What is all this by-hand crap?  XAML (WPF and Silverlight) is only notepad as well

    ·         Action, instead of event, fires not in View but in the Controller. 

    o   The View, aka aspx page, has no code behind.

    ·         In Controller can define a action and use wizard to create it’s view (web page)

    ·         ViewUserControl is a collection of html and inline asp which is reusable

    IIS v7

    ·         Modules

    o   ASP.NET managed HttpModules can be plugged in directly to IIS v7

    §  No more unmanaged ISAPI filters

    o   Modules can be managed within IIS v7 Manager

    o   Configuration for modules can be exposed through manager

    §  Customer WinForm configuration can also be exposed

    ·         Config

    o   No more meta-base

    §  All settings exists in central applicationHost.config – similar to a web.config

    ·         C:\windows\system32\inetsrv\config\schema

    §  Can share IIS config for farm scenario

    o   www.iis.net contains a configuration pack which allows you to show the config file within the IIS manager

    Security

    ·         Concept of Security Development Lifecycle (SDL)

    ·         Threat Modelling – package available for formalized  security reviews

    o   Talks about prioritizing risks

    ·         Multi-Pass Review Model

    o   1 – Run fuzz and code analysis tools

    o   2 – Look for ‘patterns’ in riskier code

    o   3 – Deep review of riskiest code

    ·         Golden rule: What does the bad guy control?

    o   What if he controls x & j (resources obtained from user, port, pipeline, compromised file system or database)

    §  Char [] f = new char[3];

    §  f[3] = 0;                                 bug

    §  f[x] = 0;                                 can write a null to anywhere in memory

    §  f[x] = y;                                 can write anything anywhere in memory

    ·         Accepted encryption

    o   AES and SHAXXX only

    o   Everything else is banned!  So long TripleDES

    ·         Do not use:  try { } catch (Exception ex) { }

    o   Hides bugs and security flaws

    o   Catch only exceptions we can handle

    IE v8

    ·         Debug tools included out of the box

    o   Hit F12

    §  Debug javascript

    §  Solve style issues

    ·         Compatibility – new rendering engine following widely-accepted standard

    o   Get prepared for our apps look and feel to break

    o   www.msdn.com/iecompat

    o   Set meta-tag to tell IE8 to continue to render using v7 engine

    ·         Accelerators

    o   Can develop own accelerators which can highlight a name and pass to a website as a parameter.  Employee staff directory, for example.

    Cool Stuff

    ·         Ctrl-,

    o   Quick search feature in 2010

    ·         Ctrl-.

    o   Refactoring: infers using statement.  Generate a new method as your developing

    ·         Web.config

    o   Release version compiles debug/standard web.config and turns off debug, hardens security, replaces config and connection strings

    o   Part of the installer

    Other Stuff

    ·         Ribbon support in VS2008 Feature Pack

    ·         Vista Bridge

    o   Wrapper to get access to Vista controls and features

    o   TaskDialog and CommandLinks

    §  Standard now so will be seen in Win v7

    §  Backwards compatible, just extra messages to standard native button

    o   Restart/Recovery API

    §  Get notified of a reboot

    §  Register delegate called in separate thread when app crashes/reboots

    §  OS will run app with a command line argument you catch to load saved info

    o   Power Management

    §  Get notified about all power related info, low battery, ect

    Biz Stuff

    ·         StepUp Program

    o   Allows customers to upgrade current SKU

    §  i.e. VS Pro to Team Foundation Server

    §  30% discount until June 2009

    XML Serializing between WebService proxy classes and Entity classes July 8, 2008

    Posted by codinglifestyle in ASP.NET, C#.
    Tags: , , , , ,
    1 comment so far
    If you are looking at this page I would suggest you ask yourself the following questions:
    • Is the architecture of my software broken?  Why am a referencing a class on either side of a webservice?
    • Are web services really necessary in this situation?
    My answers are yes, it is broken, and yes, there is an egrigious use of web services throughout.  Unfortunately, this product is many years old and I have to do what the customer asks.  So here I have an entity class which is not a simple container for data.  It contains additional methods and logic.  This entity is populated by the database and then forked over by webservices.  However, the UI layer also needs access to the additional methods and logic in the entity.  The WSDL generated proxy class does not contain these methods or logic; just a simple representation of the public properties of the class with straight gets and sets.  
     
    The challenge then, is to serialize the web service proxy class back to the entity class.  Once this is done, I will have access to the additional methods and logic I need.  We can do this by using what web services use, XML serialization.  Its a fast way of getting our data from the proxy class back to XML.  Then deserialize the XML back to the entity class.
     
            ///
            /// Serialize the data from an object of Type_A to a new object of Type_B
            ///
            ///The Type_A object containing the data to serialize
            ///The Type_B to be created and deserialized with the Type_A object
            ///An object of Type_B
            static object SerializeObjects(object oSource, Type tDestination)
            {
                XmlNoNamespaceWriter xw = null;
                Object oDestination = null;
     
                try
                {
                    //Prepare to convert XML entity to XmlNoNamespaceWriter
                    MemoryStream ms = new MemoryStream();
                    xw = new XmlNoNamespaceWriter(ms, Encoding.UTF8);
                    XmlSerializer xsA = new XmlSerializer((oSource.GetType()));
     
                    //Serialize web service xml data to xml stream
                    xsA.Serialize(xw, oSource);
     
                    //Deserialize stream to entity actual
                    XmlSerializer xsB = new XmlSerializer(tDestination);
                    xw.BaseStream.Position = 0;
                    oDestination = (WSEntityTest.Entity)xsB.Deserialize(xw.BaseStream);
                }
                catch
                { }
                finally
                {
                    //Close the stream
                    if (xw != null)
                        xw.Close();
                }
     
                return oDestination;
            }
     
    So what we are doing is using a memory stream and XmlTextWriter to contain the XML.  The XmlSerializer serializes the proxy class to the stream.  If you wanted to look at the resulting XML, you could use an XmlDocument to load the stream and take a look.  If we do that, we will notice a small problem.  Every child element will contain a namespace attribute (xmlns). This will throw a spanner in the works when deserializing the data to our entity class. Basically what the namespace is telling the XmlSerializer is the data doesn’t belong in our entity class so it will skip it. It’s just doing its job because technically we shouldn’t be serializing data from the class of type A to a class of type B. However, this is exactly what we need to do. To work around this, I looked high and low for a simple way of turning off the namespace (in .NET v2.0).  Nothing simple turned up, hence the use of XmlNoNamespaceWriter which is derived from XmlTextWriter.   The implementation of this class is shown below:
     
        public class XmlNoNamespaceWriter : System.Xml.XmlTextWriter
        {
            bool m_bSkipAttribute = true;
     
            public XmlNoNamespaceWriter(System.IO.Stream writer, System.Text.Encoding encoding) : base(writer, encoding)
            {
            }
     
            public override void WriteStartElement(string sPrefix, string sLocalName, string sNS)
            {
                base.WriteStartElement(null, sLocalName, null);
            }
     
     
            public override void WriteStartAttribute(string sPrefix, string sLocalName, string sNS)
            {
                //If the sPrefix or localname are “xmlns”, don’t write it.
                if (sPrefix.CompareTo(“xmlns”) == 0 || sLocalName.CompareTo(“xmlns”)==0)
                {
                    m_bSkipAttribute = true;               
                }
                else
                {
                    base.WriteStartAttribute(null, sLocalName, null);
                }
            }
     
            public override void WriteString(string sText)
            {
                //If we are writing an attribute, the sText for the xmlns
                //or xmlns:sPrefix declaration would occur here. Skip
                //it if this is the case.
                if(!m_bSkipAttribute)
                {
                    base.WriteString(sText);
                }
            }
     
            public override void WriteEndAttribute()
            {
                //If we skipped the WriteStartAttribute call, we have to
                //skip the WriteEndAttribute call as well or else the XmlWriter
                //will have an invalid state.
                if(!m_bSkipAttribute)
                {
                    base.WriteEndAttribute();
                }
                //reset the boolean for the next attribute.
                m_bSkipAttribute = false;
            }
     
     
            public override void WriteQualifiedName(string sLocalName, string sNS)
            {
                //Always write the qualified name using only the
                //localname.
                base.WriteQualifiedName(sLocalName,null);
            }
        }
     
    I found this class here, and modified it slightly to use a stream rather than a file. So now we get past our namespace issue and the serializer won’t be confused by the namespaces. Now all we need is a second XmlSerializer created with our entity type.  This will deserialize the stream in to a new instance of our entity class.  The usage of the method is shown below:
     
    //Retreive the WebService proxy class
    localhost.Service1 svc       = new Client.localhost.Service1();
    localhost.Entity xmlEntity   = svc.HelloWorld(); 
     
    //Serialize the proxy class to a new entity class
    Entity entity = (Entity) Program.SerializeObjects(xmlEntity, typeof(Entity));
     

    Visual Studio 2008 JumpStart December 18, 2007

    Posted by codinglifestyle in ASP.NET, C#, Javascript, jQuery, linq.
    Tags: , , , , , , , , , , ,
    add a comment

    Yesterday I attended the Visual Studio 2008 Jumpstart at Microsoft in Dublin.  This was a one-day course, presented by David Ryan, introducing some of the new features in C# 3.0 and VS2008.

     

    I approach every release with excitement and trepidation.  There are some fantastic new features like JavaScript debugging, nested MasterPages, improved IDE for both coding and web design, and multi-target runtime support.  With multi-targeting support we can use VS2008 to continue to code or support .NET 2.  If you open a VS2005 project, you will be prompted to upgrade your project even if you continue to use .NET 2.  I asked was there any risk associated with this for those who need to continue to support .NET 2 and was told only the SLN file is changed.  So theoretically, there is no reason to keep VS2005 installed!  Do you believe it??  If only we could get rid of VS2003 as well.

     

    Now, the reason I also approach each release with trepidation is because you know there is going to be some big, new, ghastly feature which will be force-feed to us like geese in a pâté factory.  This time that feature in LINQ.  Open wide because there is a big push behind LINQ and you’ll notice a using System.Linq statement in every new class (which is a real pain if you change target framework back to .NET 2).  But first, let’s review some of the changes made to C#:

     

    • Anonymous types
      • var dt = DateTime.Today;
      • Anything can be assigned to a var, but once it’s assigned its strongly typed and that type can’t be changed.  So I can’t reuse local variable dt and assign string “Hello” like I could with object.
    • Automatic Properties
      • This:

          private int m_nID;

             public int ID

             {

                 get

                 {

                     return m_nID;

                 }

                 set

                 {

                     m_nID = value;

                 }

             }

     

    •  
      • becomes this:

    public int ID { get; set; }

     

    •  
      • The problem is in practice I prefer to use the private variables in code leaving properties for external access only.  Many times the get/set is doing something interesting, like reading the value from a cache or performing some complex operation.  We don’t necessarily want/need this code to execute every time it is accessed from within the class so I use the private variable.  Automatic Properties has us using the public property directly everywhere in the class.  So, personally, this will cause inconsistency in my coding style.
      • You can also specify the get as public but keep the set to just be accessible from within the class like this:

    public int ID { get; private set; }

     

    • Object initalizers
      • Ever have to instantiate your own class and have to initialize it with a dozen properties?  Do you add 13 lines of code or go overload the constructor?  Now you don’t have to, imagine a simple Person class with 3 properties:

    Person person = new Person { FirstName=“Chris”, LastName=“Green”, Age=33 };

     

    •  
      • Only initialize what you properties you want:

    Person person2 = new Person { FirstName = “Chris”, LastName = “Green” };

     

    • Collection initalizers

    List<Person> people = new List<Person>

             {

    new Person { FirstName = “Chris”, LastName = “Green”, Age = 33 },

    new Person { FirstName = “Bill”, LastName = “Bob”, Age = 46 },

    new Person { FirstName = “Foo”, LastName = “Bar”, Age = 26 }

             };

     

    • Extension methods
      • This is a way of adding new inherent functionality to existing classes.  The objective is to add a new method to the DateTime type called LastDay() which will return the last day of the given date’s month.

    public static class DateTimeUtils

    {

            public static int LastDay (this DateTime dt)

            {

                return DateTime.DaysInMonth(dt.Year, dt.Month);

            }

    }

     

    •  
      • Notice the this before the first parameter argument.  This tells the compiler that this is an extension method for the DateTime type.  We can now use this method as if it was built in to the DateTime class:
        • int nLastDay = dt.LastDay();
    • Lambda expressions
      • Too lazy or couldn’t be arsed to write a small 2 line function?  This is for you:

    Func<string, bool> CheckName = sName => sName == “Bob”;

    bool bBob = CheckName(person.FirstName);

    Func<int, int> Square = x => x * x;

    int nSquare = Square(5);

     

    The fact is there’s an ulterior reason var, Lamda expressions, and many of above additions have been added to C# 3.0.  C# had been bent in order to accommodate LINQ.  LINQ allows you to perform queries on objects, DataSets, XML, and databases.  It’s interesting in that it offers an independent layer of abstraction for performing these types of operations.  This has actually occurred to me before when looking at data layers chock full of embedded SQL not being particularly ideal.  LINQ offers a generic and powerful alternative.  Let’s take a look at a simple example based on the people collection from above:

     

    var matches = from person in people

                  where person.FirstName == “Bob”

                  select person;

     

    The first thing that caught my attention was the select was last.  One reason they likely did this was to force us to state what we were querying first (the from clause) so that Intellisense could kick-in for the rest of the expression.  Notice person.FirstName was fully supported by Intellisense so the Person class was automatically inferred from the people collection.

     

    You can create objects on-the-go from your expression.  For example:

     

    var matches = from employee in people

                  where employee.FirstName == “Bob”

                  select new Person(employee.FirstName, employee.LastName);

     

     

    Notice how var is inherently handy here (but bad practice for nearly everything else) as our LINQ expression returns System.Collections.Generic.IEnumerable.  Lambda expressions as well play a key part in LINQ:

     

    var matchesBob = people.Select(CheckName => CheckName.LastName == “Bob”);

     

    matchesBob.ToArray()

    {bool[3]}

        [0]: false

        [1]: true

        [2]: false

     

    var matchesInitials = people.Select(ChopName => ChopName.FirstName.Remove(1) + ChopName.LastName.Remove(1));

     

    matchesInitials.ToArray()

    {string[3]}

        [0]: “CG”

        [1]: “BB”

        [2]: “FB”

     

    There is so much more to LINQ that I won’t attempt to cover any more.  Rest assured you will hear much more about LINQ in the months to come (fatten up those livers).  One thing is obvious, C# took a heavy hit in order to support it.  Let’s hope it’s worth it as every release we lean more and more towards VB.  A colleague recently remarked, “C# is all VB under the covers anyhow”.  He might be right.

     

    Some other interesting new additions:

    • XElement – for anyone who has programmatically built XML before you will appreciate this quicker alternative
    • ASP.NET ListView – the singular new control this release.  Its basically a Repeater but with design-time support
    • Script Manager Proxy – typically the Ajax ScriptManager will be placed in the MasterPage.  When the content page needs to access the ScriptManager a ScriptManagerProxy can be used to get around the restriction of only one ScriptManager allowed per page.
    • Javascript enhancements – built-in libraries which extend string, add StringBuilder, and a number of other enhancements to make writing JavaScript more .NET-like
    • CLR Add-In Framework: essentially a pattern for loading modules (only from a specified directory) vs. using reflection, iterating classes for a specified type, and using the activator to instantiate the object
    • Transparent Intellisense: In VS2005 Intellisense went in to hyperdrive and our tab keys have never been the same.  However, I often found myself cursing it as it often got in the way.  So when VS is being too helpful and you can’t see what you’re doing press CTRL rather than ESC to turn Intellisense transparent.
    • Right-click the code and you will see an Organize Using menu below Refactor.  Here is a feature I’ve often dreamed of: Remove Unused Usings.  Pinch me!  Also, if you right-click the interface in a class’s definition (public class MyClass : Interface) there is an Implement interface option.   Last, if you are coding away and using a class before adding a using statement use ALT-Shift-F10 to automatically resolve the class and add the using statement to your file.
    • Improved support for debugging multithreaded applications
    • SQL Database Publishing Wizard is now integrated in the VS
    • Did I mention JavaScript debugging??!

     

    You may notice I’ve omitted a few big topics.  I didn’t mention Ajax because that’s old news now.  However, there are new versions of the Ajax Control Toolkit and web deployment projects for VS2008.

     

    I also didn’t mention Silverlight although I may find some interesting applications for it in the future.  For example, if you really hate writing JavaScript you could use Silverlight’s built-in mini CLR to write C# code which executes in the browser.  Oh, I hear it does some UI stuff too.

     

    References: ScottGu 19-11-2007, ScottGu 13-03-2007, ScottGu 08-03-2007, C# 3.0 In a Nutshell, Pro ASP.NET 3.5 in C# 2008, and CodeProject.