ASP.NET Weblogs

Daily tech links for .net and related technologies - Feb 10-12, 2010

SanjeevAgarwal — Wed, 10 Feb 2010 06:58:00 GMT

Daily tech links for .net and related technologies - Feb 10-12, 2010 Web Development 'Unobtrusive' asynchronous Form in ASP.NET MVC - Tomasz Peczek ASP.NET MVC security checklist Multi-tenancy in ASP.NET MVC - Views - Rob Ashton Default Values in ASP.NET MVC Action Parameters - David Hayden Quick Tips About ASP.NET MVC – UI Helpers and Templates - Nuno Silva Quick Tips About ASP.NET MVC – Editor Templates - Nuno Silva ASP.NET MVC Quick Tips – Pass data to your master page -Nuno Silva ASP.NET MVC...(read more)

Architect 3 : Building Data Access Layer Using Microsoft Enterprise Library 4.1

StanleyGu — Wed, 10 Feb 2010 01:52:00 GMT

You have a Customer table with three fields: ID, LastName and FirstName. You are building a data access layer to retrieve all the records from the Customer table and return the result as a collection of Customer objects. You want implement it using Microsoft Enterprise Library.

1. In your Data Access Layer project, add references to the following Microsoft Enterprise Library DLLs:

Microsoft.Practices.EnterpriseLibrary.Data.dll

Microsoft.Practices.EnterpriseLibrary.Common.dll

Microsoft.Practices.ObjectBuilder2.dll

2. At App.config or Web.config, add the following dataConfiguration section:

3. At App.config or Web.config, add the following connectionString:

4. At the Data Entity Layer, create a entity class Customer:

5. At the Data Access Layer, create a class CustomerDAL and make sure put the following using statements:

6. Create a method GetCustomers in the CustomerDAL class with the following implementation:

Most interesting from SharePoint 2010 Virtual Ignite Training: 2nd Day

Jevgeni Borozna — Tue, 09 Feb 2010 15:53:05 GMT

9 feb 2010: Virtual SharePoint 2010 Ignite Training for Developer

Notes:

Intellisense when editing Wiki-pages and other type of pages and inserting some page property. (When writing “[["…)
4 default Master Pages:

v4.master (default for SP 2010)
minimal.master
simple.master (For error pages or login pages. Not customizable, but pages can be replaced)
default.master (Old-style master page, as in SP 2007. Without ribbon and other new things. For supporting SP 2007 projects when migrating them)

New Rich Text Editor supports XHTML (source is a valid XHTML)
User Custom Action can be scoped to list / site / site-collection
Multiple forms per type (many New, Display or Edit or other type of forms per List or Library). On of them must be set as default form for each type (New, Display, etc)
Inline adding / editing items in a list (adding / editing items directly from List View, without opening New or Edit form)
Rows conditional formatting in list view
New properties on SPQuery:

SPQuery.Join
SPQuery.ProjectedFields

Use SPLinq instead of CAML to join lists (Building-time error vs runtime error)
Microsoft SharePoint Foundation 4.0 lists can now support 50M items
Unique columns must be indexed (automatically configured)
List Item Validation (Rule with formula. In SharePoint 2007 was possible to validate fields only)
Silverlight Client Object Model

The web part can contain custom properties that are sent to Silverlight via the InitParameter property
The XAP file can be deployed to LAYOUTS and loaded at run time
The Silverlight application can then make use of the Client OM

ECMAScript Client Object Model

ECMAScript Client OM is easily added to SharePoint ASPX page - reference:

_layouts/sp.js

SPMetal utility generates Entities for all site things (Lists, fields, etc) for using them with SharePoint Linq

Visual Studio 2010 RC is out

Jeev — Tue, 09 Feb 2010 13:35:00 GMT

Visual Studio Release Candidate is out. See the post from Scott Guthrie. If you are interested in finding out what are the changes from VS 2008 or .NET 3.5; I strongly suggest that you check out this series of blog posts

Another post from Mike Taulty listing out what is new

Visual Studio 2010 RC is available

DigiMortal — Tue, 09 Feb 2010 09:30:00 GMT

VS2010 RC is out now and available for MSDN users since now. Other guys have to wait until tomorrow when VS2010 RC is made publically available. Reading first news I discovered that most important thing is hardly improved performance of VS2010 RC IDE. All your feedback is welcome to VS2010 RC Connect site.

To find out more follow these links:

Before installing RC you must uninstall all previous versions of VS2010 and .NET Framework 4.0. It seems like another long nights of hacking and discovering new stuff are waiting for us. :)

Visual Studio 2010 RC released for MSDN Subscriber

vik20000in — Tue, 09 Feb 2010 03:46:00 GMT

Hi,

Today Microsoft has released Visual Studio 2010 (VS 2010) RC for MSDN Subscriber. It will be available for the General people on RC on 10th February.

If you are an MSDN subscriber you can go ahead and download the bits right now from the link below.

http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx

The early feedback on Twitter seems very good already about the performance. Do check it out.

Update:Support for Silverlight 4 with the VS 2010 RC will show up with next public SL4 drop (and so is not yet enabled with today's bits). Do not upgrade if you are working on Silverlight 4 right now. Wait till the new bits are out.

Vikram

Solution 5 : Implementing Optional Parameters in T-SQL Stored Procedures

StanleyGu — Tue, 09 Feb 2010 02:46:00 GMT

You have a stored procedure GetCustomers with two parameters: LastName, FirstName. The stored procedure returns all the records matching the values of the parameters. You want the parameters be optional, which means skipping the parameter if you do not pass a value.

T-SQL does not provide optional parameters, but you can implement one.

1. You have original stored procedure

2. Add =null at your parameter declaration of the stored procedure

3. Add IS NULL at your WHERE clause

4. Now you have optional parameters in the stored procedure

5. Call the stored procedure from your data access layer C# code (FirstName is optional)

Tip 10 : Returning the first part of a string with delimiter

StanleyGu — Tue, 09 Feb 2010 01:45:00 GMT

You have a string delimited by underscore such as 1stPart_2ndPart_3rdPart and want to return the first part of the string only.

C# Implementation of using Split function:

T-SQL implementation of using SUBSTRING and CHARINDEX functions:

ASP.NET MVC Complex Object ModelMetaData Issue

kazimanzurrashid — Mon, 08 Feb 2010 23:06:28 GMT

One of the exciting feature of ASP.NET MVC is(?) auto generating the view of the model with DisplayForModel/EditorForModel statement, it gives a nice extension point for the application developers to customize the view. But in the latest release (MVC2 RC2), it looks like the feature is no longer available. No, those methods are still available, but they are not working the same way as they were doing in the earlier versions. In rc2, if your model has any complex object, it will not render it . I know some of you like myself thought, one of the major changes in rc2 is the Input Validation vs. Model Validation in ASP.NET MVC and rest of it is bug fixing and some improvements. I did check the release note doc, where it is mentioned as

Templated helpers such as Html.EditorFor and Html.DisplayFor show only simple properties by default. If you need to show complex properties, you can create a custom template to show any set of properties.

Check the last line, it says to show the complex properties we have to create a custom template. But interestingly enough it does not work. Let me show you a very simple example, lets say that we have product and category class like the following:

public class Category
{
    public int Id { get; set; }

    public string Name { get; set; }
}

public class Product
{
    public int Id { get; set; }

    public string Name { get; set; }

    public decimal Price { get; set; }

    [UIHint("CategoryTemplate")]
    public Category Category { get; set; }
}

Check that we are using a custom template (CategoryTemplate) to show the category property.

And in the Controller:

public ActionResult Index()
{
    return View(new Product
                 {
                     Id = 1,
                     Name = "Product 1",
                     Price = 10.0m,
                     Category = new Category { Id = 2, Name = "Category 2" }
                 });
}

And in the View we want to render the product:

<%@ Page Language="C#" MasterPageFile="~/Views/Shared/Site.Master" Inherits="System.Web.Mvc.ViewPage<ComplexObject.Models.Product>" %>
<asp:Content ID="Content1" ContentPlaceHolderID="TitleContent" runat="server">
    Home Page
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="MainContent" runat="server">
    <p>
        <%= Html.DisplayForModel() %>
    </p>
    <p>
        To learn more about ASP.NET MVC visit <a href="http://asp.net/mvc" title="ASP.NET MVC Website">http://asp.net/mvc</a>.
    </p>
</asp:Content>

But when the view is rendered, there is no category:

I posted this issue in the Gu’s RC2 announcement post as well as in the CodePlex, but the answer that I got is somewhat confusing. I do not think this is a right decision to hide the complex object in the default implementation, I never hard anybody is having some issues with this features and I do not think it is the right time for this change as the MVC2 is in in RC, anyway feature is broken and needs to be resolved in the first place.

So, till there is a fix, what is the workaround? Lets write some Haacky code. First, lets see where the ASP.NET MVC take the decision to show/hide the model property. If you open the DefaultDisplayTemplates.cs and DefaultEditorTemplates.cs under the Html folder of the ASP.NET MVC Source code, you will find both of it has a method called ShouldShow.

private static bool ShouldShow(ModelMetadata metadata, TemplateInfo templateInfo)
{
    return
        metadata.ShowForEdit
        && metadata.ModelType != typeof (EntityState)
        && !metadata.IsComplexType
        && !templateInfo.Visited(metadata);
}

The only problematic checking is the IsComplexType which in turns check whether the type can be converted from the string type :

public virtual bool IsComplexType
{
    get { return !(TypeDescriptor.GetConverter(ModelType).CanConvertFrom(typeof (string))); }
}

So the workaround is either we override the ModelMetadata which is somewhat an overkill or we can create a TypeConverter for the complex object for which we have custom template to fool the ASP.NET MVC Framework. In this case it is the Category. So lets write a converter.

public class CategoryConverter : TypeConverter
{
    public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
    {
        return sourceType == typeof(string) ? true : base.CanConvertFrom(context, sourceType);
    }
}

Now, decorate the Category with this converter:

[TypeConverter(typeof(CategoryConverter))]
public class Category
{
    public int Id { get; set; }

    public string Name { get; set; }
}

when you run the project you will find the category is shown like the following:

And that’s it. You can download the complete code from the following link.

Source Code: ComplexObject.zip

IL perversions: throwing and catching strings

DigiMortal — Mon, 08 Feb 2010 22:30:00 GMT

Inspired by Mohamed Mahmoud’s blog posting How to: Create Interfaces with Static Methods via IL? I wrote another sick example on IL (Intermediate Language) to show you how different is the world behind compilers. Tonight I have enough of exceptions, I want to throw some strings! Let’s do it!

Throwing exception in IL

As a first thing take a look at the following code written in IL. In short this code defines class with two methods. Run() is entry point and it is run automatically when compiled assembly is executed from command line. ThrowSomething() is method that throws exception. This exception is caught and program terminates without any errors. I borrowed this code from Vijay Mukhi’s IL book, Chapter 10 “Exception Handling”.

.assembly StringMess {}
.class private auto ansi Program extends [mscorlib]System.Object
{
    .method public hidebysig static void Run() il managed
    {
        .entrypoint
        .locals (class [mscorlib]System.Exception V_0)
        .try
        {
            call    void Program::ThrowSomething()
            ldstr   "Bye"
            call    void [mscorlib]System.Console::WriteLine       
                    (class System.String)
            leave.s IL_001e
        }
        catch [mscorlib]System.Exception
        {
            stloc.0
            ldstr   "Exception was thrown!"
            call    void [mscorlib]System.Console::WriteLine       
                    (class System.String)
            leave.s IL_001e
        }
 
        IL_001e: ldstr "Finish"
        call     void [mscorlib]System.Console::WriteLine       
                 (class System.String)
        ret
    }
 
    .method public hidebysig static void ThrowSomething()       
        il managed
    {
        newobj instance void [mscorlib]System.Exception::.ctor()
        throw
    }
}

Everybody who is familiar with C# should be able to understand this code at least in some parts. Now let’s see what is the output of this method. As image on right shows it is nothing special. We threw exception, it was handled and program terminated normally. Just like we expected.

Let’s throw some strings now

Now let’s modify this code so it should do something we expect to end up with error. I add one more catch clause. This additional catch catches String. To test it I will do exactly what this catch expects – I will throw out the String. Here is the code.

.assembly StringMess {}
.class private auto ansi Program extends [mscorlib]System.Object
{
    .method public hidebysig static void Run() il managed
    {
        .entrypoint
        .locals (class [mscorlib]System.Exception V_0)
        .try
        {
            call    void Program::ThrowSomething()
            ldstr   "Bye"
            call    void [mscorlib]System.Console::WriteLine      
                    (class System.String)
            leave.s IL_001e
        }
        catch [mscorlib]System.Exception
        {
            stloc.0
            ldstr   "Exception was thrown!"
            call    void [mscorlib]System.Console::WriteLine      
                    (class System.String)
            leave.s IL_001e
        }
        // 
        // CATCH STRING
        //
        catch System.String
        {
            stloc.0
            ldstr    "String was thrown"
            call    void [mscorlib]System.Console::WriteLine      
                    (class System.String)
            leave.s IL_001e
        }
 
        IL_001e: ldstr "Finish"
        call     void [mscorlib]System.Console::WriteLine      
                      (class System.String)
        ret
    }
 
    .method public hidebysig static void ThrowSomething()       
        il managed
    {
        //newobj instance void [mscorlib]System.Exception::.ctor()
        //
        // THROW STRING
        //
        ldsfld     string [mscorlib]System.String::Empty        
        throw
    }
}

We can expect that this code doesn’t compile, but it does. As a next thing we may expect that running this code some runtime error occurs, but no, there is no runtime error. We can expect that exception handling lands in catch for Exception… we can expect many things but the result is here.

I bet at least half of readers expected something else but yes, we just threw string and we also caught it. But why C# and VB.NET give us errors when we try to compile code like this? Well, it is a compiler level limitation. It is not related to CLR as we just saw.

Playing with Visual Studio

Let’s play now with Visual Studio. I created console application, compiled previous example as DLL and referenced it from my console application. I want to know what happens when string is thrown and caught. Does it affect compiler somehow?

using System;
 
namespace ConsoleExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            StringMess.Program.Run();
            Console.ReadLine();
            Console.ReadLine(); 
        }
    }
}

Well, it does not. Let’s try to call ThrowSomething() method now. Maybe something interesting happens.

using System;
 
namespace ConsoleExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            StringMess.Program.ThrowSomething();
            Console.ReadLine();
        }
    }
}

Okay, now something happens. Our application is not able to handle the situation and it throws RuntimeWrappedException.

RuntimeWrappedException is located under System.Runtime.CompilerServices namespace and as documentation sais it is here to maintain compatibility between languages. The common language runtime (CLR) wraps objects that do not derive from Exception in a RuntimeWrappedException object. This is why we got exception and not completely crashed application.

TIP! If you want to find out more about IL there is very good book I can suggest: Expert .NET 2.0 IL Assembler by Serge Lidin. I have read this book and also the idea of this posting is taken from this book. If you are interested in my other postings about IL and compiling results then please take a look at Behind the Compiler category.

Okay, it’s couple of minutes over midnight here and it is time to throw some real strings, I guess. Good night!