Microsoft announced in early May that version 2.0 of its Windows Azure SDK for .NET was finally available to all. The SDK brings with it a number of new features that are sure to delight those who host .NET Web sites on the Azure platform.

You should check out the full blog post for more details as Microsoft’s Scott Guthrie explains all of the new features in full detail.

As for availability, you can grab the Windows Azure SDK 2.0 for .NET over at the Windows Azure .NET Developer Center. It’s also open source so you can poke and prod your way through the code over at GitHub.

Micrososft recently released ASP.NET and Web Tools 2012.2 to the general coding public. The release contains new templates and tooling ASP.NET Web Forms, ASP.NET MVC, ASP.NET Web API and the rest of the ASP.NET family. Microsoft put together a little video to go over what’s in the latest release:

If you don’t like watching informative videos, here’s a quick rundown of the new features in this latest release. First, Web Forms got a a new FriendlyURL package that adds the following benefits:

The ASP.NET Web API gets the following three new features:

ASP.NET MVC gets a few new templates and the following three features:

As for Web Tools, here’s some of the highlights that you’ll see in practice in the above video:

You can grab this latest release of ASP.NET and any future release over at the official Web site.

Microsoft blogger, Mike Brind, recently posted a pretty extensive tutorial on his blog that goes into how developers will want to use SignalR in building ASP.NET Web pages with WebMatrix. First things first, however, he explains what SignalR is and what the new library can to accomplish:

The web works on a Request-Response model. Browsers and other user agents make requests and web server provide a response to that request.The response is sent to the delivery address provided in the request by the user agent. And that is the natural order of things on the Web – servers can’t make responses without a request. For the most part, this is not an issue, but if you want to display real-time updates on your web page, you have needed to resort to techniques like repeatedly polling the server using AJAX to see if any changes had been made to data. Alternatively, you could use Comet technology, which keeps a persistent connection open between the server and the client. HTML5 introduced two new techniques – Server Sent Events and WebSockets. SignalR is a user-friendly wrapper around all these technologies that makes it a lot easier to create applications that require the real-time display of data. SignalR utilises HTML5 Web Sockets API where it is available, and falls back onto other technologies where they are not – Server Sent Events, Forever Frames or Long Polling, the last two of which are Comet techniques.

Brind suggests that any interested developer obtain the prerelease version of SignalR via Visual Studio. He suggests using the Package Manager Console and installing it via the Install-Package Microsoft.AspNet.SignalR -Pre command.

From there, Brind explains the basics of SignalR including how you set up an application that uses the library. He says that an application is powered by a hub, which holds some similarities with a Controller in ASP.NET MVC. Those familiar with that should have little to no problem adopting SignalR into their own applications.

For the rest of the post, Brind gets into the nitty gritty of the code required to implement SignalR into your ASP.NET Web pages. His first example shows how to create a Chat window on a Web page using SignalR. The second example is a little more complicated as he combines SignalR with Knockout to create a simple product listing page where users can view details about individual products.

You can check out both of Brind’s examples at his GitHub page, and get refreshed on all the latest changes to SignalR at the official Web site.

In late October, Microsoft finally unveiled its roadmap for proposed updates and additions to ASP.NET and Web Tools 2012.2. There’s a number of new features that developers can look forward to, but Microsoft warns that these additions are only in the planning stage now and may not see the light of day for some time.

First up is SignalR, a new addition to the ASP.NET family. Microsoft says that it adds “real-time functionality to web applications using WebSockets and other down-level transports.” The first release of SignalR will add item templates and hubs to an ASP.NET application and integrate with both ASP.NET MVC and ASP.NET Web API. You can find out more at the SignalR GitHub directory.

Speaking of Web API, Microsoft will be extending to add “richer OData functionality, expand support for Windows Store Apps and enable simple tracing and monitoring.” To be more specific, the following features will be added in the future:

MVC is also receiving a number of new additions in the future. These updates are intended to help developers build ASP.NET applications that ‘feature Azure, Single Page Applications, real time updates using SignalR and Facebook integration.” The proposed updates include:

On a final note, Microsoft is looking to add an ASP.NET membership system. Microsoft says the new system would “provide first class support for modern methods of authentication (such as OpenAuth/OpenID), as well as local username and password.” The new system will also allow developers to “easily change the underlying storage mechanism to SQL server, Azure Table or any other store of choice.”

Once again, it’s important to note that these plans are not set in stone, and can change. Microsoft welcomes any developer input at its ASP.NET UserVoice site to help determine the future of the development platform. You can help contribute to the future of ASP.NET here as Microsoft made it open source back in March. You can also download the latest Fall 2012 ASP.NET update preview here.

OrcsWeb announced that ASP.NET 4.5 is now available across all platforms – cloud and dedicated. They worked closely with Microsoft throughout the beta stage to make sure their .NET 4.5 support was perfect. Users can expect new features, increased performance and control, and other benefits with the latest release of .NET.

“ASP.NET 4.5 is the most exciting release of the .NET framework yet. Microsoft has made significant performance improvements in both application startup and memory utilization that customers will recognize immediately,” according to Jeff Graves, Director of Technology. “Security improvements help web developers easily protect their application from malicious users with unobtrusive validation and the baked-in AntiXSS library. Asynchronous HTTP calls are much easier to manage with the new await command. The best part is that OrcsWeb clients can take full advantage of these features today, across all of our platforms.”

Here are the key improvements that users will find built into .NET 4.5:

It should be noted that all new OrcsWeb clients will receive .NET 4.5 by default. All existing Windows cloud server or dedicated server clients can either install the upgrade themselves, or contact OrcsWeb for a professional installation. You can find more information on installing .NET 4.5 yourself here.

Scott Hanselman, a Microsoft employee, announced Tuesday that Microsoft is making ASP.NEt MVC 4, ASP.NET Web API and ASP.NET Web Pages v2 all open source under the Apache 2.0 license. These technologies have been open source for a while now, but they weren’t “really” open source. What this means is that the team didn’t take contributions from the development community, now they are.

The open source movement will allow developers to directly submit fixes and unit tests to Microsoft. They list the things that outside developers can now take part in:

Find a bug? Send a unit test or fix.
Think our coverage isn’t sufficient? Submit a unit test.
Got a feature idea? Get involved more deeply with the developers and help write it.

When you submit a fix, the developers will test it against their current standards. They’re keeping this process transparent as developers will be able to see Microsoft’s “developers’ checkins to the product out in the open.”

All this doesn’t mean that Microsoft is going to reduce support for ASP.NET. In fact, they claim to have more developers working on these programs more than ever before. The open source movement just makes it easier for developers to collaborate on these programs.

ASP.NET Web Forms are not open source, however, and Microsoft has a valid reason for that. Web Forms is part of System.Web.dll which the Windows Server OS relies upon. It can’t be replaced as easily with newer versions.

If you want to get to work right now, the source code is now available at codeplex. For more information on this open source initiative, check out Microsoft’s page for it.

Pull it out If you instead pulled the CustomGridView.cs file out of the control library and stuck it into the App_Code folder and customized it directly, you would gain multiple things. • Easier debugging • Less code needed to customize the custom GridView • Reduce the overhead of the referenced dll file This approach is only beneficial if the control doesn’t make use of other classes in the assembly, such as interfaces, base classes and helper classes.

Repository The way I like to keep my self-contained classes is in a code repository, which basically are some folders on my hard drive. Whenever I need one of the classes, I simple copy it into the project and customize it if it needs to be. It’s the same kind of plug ‘n play functionality of the dll files, but in a much smaller scale. This gives me the freedom to select a variety of different functionality out-of-the-box and still keep my project clean from unnecessary dll files. That makes them smaller, more transparent and easier to maintain. Class libraries Sometimes it does make sense to build a class library instead of the loose files. However, there are rules to when this is beneficial. The rules are the ones I code by. It’s better to build a class library when: • The classes in the library are dependant of each other • The library has characteristics of a component • The library has to be distributed separately I might have missed some other rules, but this is basically it. The point is that not all types of classes belong in a library and it’s a good idea to identify them as early as possible to avoid extra work down the line.

Comments

Add to Del.icio.us | Digg | Reddit | Furl

Bookmark WebProNews:

The first thing we do is to check if the query string exists in the first place before we start using it. It could look like this:

if (Request.QueryString["id"] != null)
{
  // Do something with the querystring
}

The only problem with the above check to see if the query string is null, is that we don’t take into consideration if the query string is filled or not.

That could lead to unhandled exceptions in the code. Instead we should check for query strings like this:

if (!String.IsNullOrEmpty(Request.QueryString["id"]))
{
  // Do something with the querystring
}

Then there is the data type of the query string.

Our code might need an integer of 5 digits to get the right information from the database, so if we pass it a string we could end up with a data type mismatch exception.

So we do the check again more thoroughly:

if (!String.IsNullOrEmpty(Request.QueryString["id"]) && Request.QueryString["id"].Length == 5)
{
  // Do something with the querystring
}

Now we know that we get a query string suitable for further processing.

You can then do more precise data type checks using the TryParse method of most value types or by some other logic.

Comments

Tag:

Add to Del.icio.us | Digg | Reddit | Furl

Bookmark WebProNews:

Mads Kristensen currently works as a Senior Developer at Traceworks located
in Copenhagen, Denmark. Mads graduated from Copenhagen Technical Academy with a multimedia degree in
2003, but has been a professional developer since 2000. His main focus is on ASP.NET but is responsible for Winforms, Windows- and
web services in his daily work as well. A true .NET developer with great passion for the simple solution.

http://www.madskristensen.dk/

All they really provide is the user agent string which provide very little information about the visitors platform, and that’s about it. If they also provided screen resolution and available browser window real estate, it would start being useful for other scenarios than we are used to.

Then I started thinking about a way to provide ASP.NET web applications with data retrieved from the browser without interfering with the browsing experience. I found that the only way to get client information from JavaScript transferred to server-side variables is to do redirection, but that is not acceptable. Well, at least I thought. It is actually possible to do redirections without the browser registers it in its history so the back button would act as nothing happened.

This means that it should be possible to retrieve the information in a way that is totally transparent to the visitor. In other words, the website appear to act 100% as usual. If you don’t believe me, read on and I’ll tell you how it’s done.

If it is using JavaScript to gather the information it also means that all information you can possibly retrieve from JavaScript can be transferred to the server. In this version I’ve implemented the properties you can see in the image above. It is very easy to add more. The code comments tells how.

How it works

To do the trick we need an HttpModule and HttpHandler. The module’s job is to expose the client-side variables to the ASP.NET code while the HttpHandler fills them with data from the browser.

At every request to an .aspx page the module checks if the variables have been set for the requesting visitor. If the page is the first one the visitor hits, the module write a small JavaScript to the tag that collects the information we need and does a silent redirection to the HttpHandler. The handler registers the information sent from the JavaScript and stores it in session variables. Afterwards it redirects back to the original requested page without the visitor noticing any redirection has taken place.

Before you think it sounds too complex, let me assure you that it is very simple. Not only is it simple, it is also plug ‘n play so you can easily implement it into any existing web application – no code required. I’ve tested it in IE 7, Firefox 2 and Opera 9 all on Windows and it works perfectly. This might be the coolest thing I’ve ever developed.

Implementation

Download the ClientStats.cs below and put it in the App_Code folder of your website. Then add the following lines to the web.config’s <system.web> section:

<httpModules>

</httpHandlers>

That is all there is needed to gain access to the properties of the ClientStats module.

Download

ClientStats.zip (1,85 KB)

Comments

Tag:

Reddit | Furl

Bookmark WebProNews:

Mads Kristensen currently works as a Senior Developer at Traceworks located
in Copenhagen, Denmark. Mads graduated from Copenhagen Technical Academy with a multimedia degree in
2003, but has been a professional developer since 2000. His main focus is on ASP.NET but is responsible for Winforms, Windows- and
web services in his daily work as well. A true .NET developer with great passion for the simple solution.

http://www.madskristensen.dk/

One of the biggest issues with the DataGrid was the lack of standard compliance and accessibility. This has been fixed in the new GridView along with a lot of other things as well.

When setting the property UseAccessibleHeader = true, it replaces the <td> elements of the header row with the correct <th> which means table header. It also adds the scope property of these header elements making them more accessible.

For some strange reason, there is no property for setting the <thead>, <tbody> and <tfoot> elements which are more important from an accessibility point of view. There is however an easy way of adding these elements in C# and VB.NET.

Let’s add a simple GridView to our page like this:

<asp:GridView runat="server" ID="gvFlowers" />

To add the extra elements, we need this simple method in the code-behind:

private void MakeAccessible(GridView grid)
{
   if (grid.Rows.Count > 0)
   {
   //This replaces <td> with <th> and adds the scope attribute
   grid.UseAccessibleHeader = true;

   //This adds the <tfoot> element. Remove if you don't have a footer row
   grid.FooterRow.TableSection = TableRowSection.TableFooter;
   }
}

Then we just call the method from the Page_Load event like this:

protected void Page_Load(object sender, EventArgs e)
{
  //Add data to the GridView
...

  MakeAccessible(gvFlowers);
}

And this is the actual HTML that is generated:

<table cellspacing="0" rules="all" border="1" id="gvFlowers" style="border-collapse:collapse;">
      <thead>
       <tr>
        <th scope="col">Name</th><th scope="col">Height</th><th scope="col">Width</th>
       </tr>
      </thead><tbody>
       <tr>
        <td>tulip.jpg</td><td>30</td><td>420</td>
       </tr><tr>
        <td>daisy.jpg</td><td>32</td><td>481</td>
       </tr><tr>
        <td>rose.jpg</td><td>54</td><td>530</td>
       </tr>
      </tbody><tfoot>

      </tfoot>
</table>

It is not apparent that you have to dig into the header and footer rows and add a TableSection. This should be done automatically or at least be easy to set through a property at design time. I think it is an obvious mistake, but luckily for us, it is easy to fix if you know where to look.

Comments

Tag:

Reddit | Furl

Bookmark WebProNews:

Mads Kristensen currently works as a Senior Developer at Traceworks located
in Copenhagen, Denmark. Mads graduated from Copenhagen Technical Academy with a multimedia degree in
2003, but has been a professional developer since 2000. His main focus is on ASP.NET but is responsible for Winforms, Windows- and
web services in his daily work as well. A true .NET developer with great passion for the simple solution.

http://www.madskristensen.dk/