Microsoft .NET Support

Visual Studio 2010 - Add Reference Dialog Improvements

2009-11-12T12:40:00.001+05:30

Before going to VS2010 Add Reference Dialog, we shall have look at VS2008 Add reference dialg and its drawbacks.

Add Reference Dialog in VS 2008

The slow performance of the “Add Reference” dialog in previous releases of Visual Studio has been a common complaint that many a developer (including yours truly) has ranted about.

Previous releases of VS opened the “Add Reference” dialog on the “.NET” tab by default – and when that tab was loaded VS would synchronously scan the global assembly cache (GAC) retrieving .NET assembly information. Because the GAC scan was done on the UI thread, it would freeze the IDE until the scan completed – which meant that you couldn’t cancel the operation, even if you didn’t want to use that tab.

Because GAC scans can often take awhile (if you have lots of assemblies installed and/or a slow hard drive), you could end up having to wait a really long time for the dialog to respond.

Add Reference Dialog in VS 2010

The Beta2 release of VS 2010 introduces a few welcome changes to the “Add Reference” dialog behavior that significantly improves its performance.

The first improvement is that the “Add Reference” dialog in continue

Infragistics NetAdvantage Update November 2009

2009-11-10T11:07:00.001+05:30

Killer Apps on the Web! NetAdvantage for Web Client 2009 Vol. 2 Now Available

Want Killer Apps on the Web? Infragistics NetAdvantage for Web Client 2009 Vol. 2 is now available. With new ASP.NET controls like WebHierarchicalDataGrid™, WebMonthCalendar™, WebEditors™ and more, you'll infuse your Web apps with the "Wow-factor!" Plus, the new Silverlight controls for Line of Business - with Drag and Drop Framework, xamWebSlider™, xamWebContextMenu™ and more, allow you to impress your end users like never before. Download the trial version and begin creating Killer Apps today.

Magic, Mind-Controlled Interfaces and What Makes an Experience Architect on Pixel8

In the latest installment of Pixel8, Rick Barraza of Cynergy returns to discuss magic, storytelling, mind control interfaces and even a little development! According to Rick, a true experience design mixes elements you may not automatically attribute to software design. Using these unexpected elements along with the tried-and-true principles of user interface design, usability and information design, help you craft polished experiences.

Get the Power to Create a Killer App

When an electrochemical reaction animated the dormant cells in a powerful egg, Gort was hatched. With special powers and abilities to infuse ordinary applications with UIs that have extreme functionality, complete usability and the "wow-factor", Gort empowers Killer Apps. Hear Gort's story, play a game, and learn how you can create your own Killer Apps at infragistics.com/gort-story.

Party Like It's 1989!

Going to PDC? Make sure you stop by the Infragistics booth (#301) during the Expo Hall Reception on Tuesday, November 17th, and party with us like it's 1989. As part of Infragistics's 20th birthday celebration, we will be serving cake, rockin' out to some killer 80s tunes, and giving party favors to all who stop by. What's more, the first 150 people at the booth during the Expo Hall Reception can hatch a Gort egg for a chance to win great prizes including licenses for NetAdvantage® for .NET and NetAdvantage for Silverlight Data Visualization, NetAdvantage ICONS, or a Microsoft® Zune® digital media player!

Friend Gort on Facebook sm

Since Gort made his public debut, he has really begun to dig the social media scene. If you are on Facebook, make sure you friend him so you can see what he is up to, see some of his recent photos and learn more about the guy who can help you create a Killer App!

Developing ASP.NET MVC Applications in Visual Studio

2009-10-19T12:08:00.001+05:30

When you install the ASP.NET MVC Framework, what the installer really does is the following:

It registers the MVC Framework’s assembly—System.Web.Mvc.dll—in your Global Assembly Cache (GAC), and also puts a copy in \Program Files\Microsoft ASP.NET\ASP.NET MVC 1.0\Assemblies.
It installs various templates under Visual Studio’s \Common7\IDE folder, which is how ASP.NET MVC becomes integrated into Visual Studio. These templates include the following:
- Project templates for creating new ASP.NET MVC web application projects and test projects (in the ProjectTemplates\CSharp\Web\1033 and Test subfolders).
- Item templates for creating controllers, views, partial views, and master pages from the Add Item menu (in the ItemTemplates\CSharp\Web\MVC subfolder).
- T4 code-generating templates for prepopulating controllers and views when you create them through the Add Controller or Add View menus (in the ItemTemplates\CSharp\Web\MVC\CodeTemplates subfolder).

It adds a few script files for registering the .mvc file name extension with IIS, in case you want to use that (in the \Program Files\Microsoft ASP.NET\ASP.NET MVC 1.0\Scripts folder). However, you won’t usually need to use these scripts: you won’t normally want .mvc to appear in your URLs, and, even if you do, you can simply register URL extensions graphically using IIS Manager,

If you wanted, you could edit the Visual Studio templates and see your changes reflected in the IDE. However, the only ones that are really designed for you to edit are the T4 code-generating templates, and rather than editing the global ones held centrally by Visual Studio, it makes more sense to edit project-specific copies that you can store in your source control system. For more details about Visual Studio’s T4 templating engine, and how to use it in an ASP.NET MVC project, see http://tinyurl.com/T4mvc.

The Default MVC Project Structure

When you use Visual Studio to create a brand-new ASP.NET MVC web application project, it gives you an initial set of folders and files matching those shown in Figure 7-1. Some of these items have special roles hard-coded into the MVC Framework (and are subject to predetermined naming conventions), while others are merely suggestions for how to structure your project. These roles and rules are described in Table 7-1.

Figure 7-1: Solution Explorer immediately after creating a new ASP.NET MVC application

Table 7-1: Files and Folders in the Default ASP.NET MVC Web Application Template
Open table as spreadsheet

Folder or File

Intended Purpose

Special Powers and Responsibilities

/App_Data

If you use a file-based database (e.g., a *.mdf file for SQL Server Express Edition, or a *.mdb file for Microsoft Access), this folder is the natural place to put it. It’s safe to put other private data files (e.g., *.xml) here, too, because IIS won’t serve any files from this folder, but you can still access them in your code. Note that you can’t use file-based SQL databases with the full SQL Server editions (i.e., anything other than Express Edition), so in practice, they’re rarely used.

IIS won’t serve its contents to the public. When you have SQL Server Express Edition installed and reference a connection string containing AttachDbFileName=|DataDirectory| MyDatabase.mdf, the system will automatically create and attach a file-based database at /App_Data/MyDatabase.mdf.

/bin

This contains the compiled .NET assembly for your MVC web application, and any other assemblies it references (just like in a traditional ASP.NET WebForms application).

IIS expects to find your DLLs here. During compilation, Visual Studio copies any referenced DLLs to this folder (except ones from the system-wide Global Assembly Cache (GAC).

IIS won’t serve its contents to the public.

/Content

This is a place to put static, publicly servable files (e.g., *.css and images).

None—it’s just a suggestion. You can delete it if you want, but you’ll need somewhere to put images and CSS files, and this is a good place for them.

/Controllers

This holds your controller classes (i.e., classes derived from Controller or implementing IController).

None—it’s just a suggestion. It makes no difference whether you put controllers directly into this folder, into a subfolder of it, or anywhere else in the whole project, because they’re all compiled into the same assembly. You can also put controller classes into other referenced projects or assemblies. You can delete this folder’s initial contents (HomeController and AccountController)—they simply demonstrate how you might get started.

/Models

This is a place to put classes representing your domain model. However, in all but the most trivial of applications, it’s better to put your domain model into a totally separate C# class library project instead. You can then either delete /Models or just use it not for full-fledged domain models but for simple presentation models that exist only to transfer data from controllers to views.

None. Feel free to delete it.

/Scripts

This is another place for statically, publicly servable files, but this one is of course intended for JavaScript code files (*.js). The Microsoft*.js files are required to support ASP.NET MVC’s Ajax.* helpers, and the jquery*.js files are of course needed if you want to use jQuery.

None—you can delete this folder, but if you want to use the Ajax.* helpers, you would then need to reference the Microsoft*.js files at some other location.

/Views

This holds views (usually *.aspx files) and partial views (usually *.ascx files).

By convention, views for the controller class XyzController are found inside /Views/Xyz/. The default view for XyzController’s DoSomething() action method should be placed at /Views/Xyz/DoSomething.aspx (or /Views/Xyz/DoSomething.ascx, if it represents a control rather than an entire page). If you’re not using the initially provided HomeController or AccountController, you can delete the corresponding views.

/Views/Shared

This holds view templates that aren’t associated with a specific controller—for example, master pages (*.Master) and any shared views or partial views.

If the framework can’t find /Views/Xyz/DoSomething.aspx (or .ascx), the next place it will look is /Views/Shared/DoSomething.aspx.

/Views/Web.config

This is not your application’s main web.config file. It just contains a directive instructing the web server not to serve any *.aspx files under /Views (because they should be rendered by a controller, not invoked directly like classic WebForms *.aspx files). This file also contains configuration needed to make the standard ASP.NET ASPX page compiler work properly with ASP.NET MVC view template syntax.

Ensures that your application can compile and run correctly (as described in the previous column).

/Default.aspx

This file isn’t really relevant for an ASP.NET MVC application, but is required for compatibility with IIS 6, which needs to find a “default page” for your site. When Default.aspx executes, it simply transfers control to the routing system.

Don’t delete this; otherwise, your application won’t work in IIS 6 (though it would be fine in IIS 7 in Integrated Pipeline mode).

/Global.asax

This defines the global ASP.NET application object. Its code-behind class (/Global.asax.cs) is the place to register your routing configuration, as well as set up any code to run on application initialization or shutdown, or when unhandled exceptions occur. It works exactly like a classic ASP.NET WebForms Global.asax file.

ASP.NET expects to find a file with this name, but won’t serve it to the public.

/Web.config

This defines your application configuration. You’ll hear more about this important file later in the chapter.

ASP.NET (and IIS 7) expects to find a file with this name, but won’t serve it to the public.

Note

You deploy an MVC application by copying much of this folder structure to your web server. For security reasons, IIS won’t serve files whose full paths contain web.config, bin, App_code, App_GlobalResources, App_LocalResources, App_WebReferences, App_Data, or App_Browsers, because IIS 7’s applicationHost.config file contains <hiddenSegments> nodes hiding them. (IIS 6 won’t serve them either, because it has an ISAPI extension called aspnet_filter.dll that is hard-coded to filter them out.) Similarly, IIS is configured to filter out requests for *.asax, *.ascx, *.sitemap, *.resx, *.mdb, *.mdf, *.ldf, *.csproj, and various others.

Those are the files you get by default when creating a new ASP.NET MVC web application, but there are also other folders and files that, if they exist, can have special meanings to the core ASP.NET platform. These are described in Table 7-2.

Table 7-2: Optional Files and Folders That Have Special Meanings
Open table as spreadsheet

Folder or File

Meaning

/App_GlobalResources

/App_LocalResources

Contain resource files used for localizing WebForms pages.

/App_Browsers

Contains .browser XML files that describe how to identify specific web browsers, and what such browsers are capable of (e.g., whether they support JavaScript).

/App_Themes

Contains WebForms “themes” (including .skin files) that influence how WebForms controls are rendered.

These last few are really part of the core ASP.NET platform, and aren’t necessarily so relevant for ASP.NET MVC applications. For more information about these, consult a dedicated ASP.NET platform reference.

Naming Conventions

As you will have noticed by now, ASP.NET MVC prefers convention over configuration.^[1.] This means, for example, that you don’t have to configure explicit associations between controllers and their views; you simply follow a certain naming convention and it just works. (To be fair, there’s still a lot of configuration you’ll end up doing in web.config, but that has more to do with IIS and the core ASP.NET platform.) Even though the naming conventions have been mentioned previously, let’s clarify by recapping:

Controller classes must have names ending with Controller (e.g., ProductsController). This is hard-coded into DefaultControllerFactory: if you don’t follow the convention, it won’t recognize your class as being a controller, and won’t route any requests to it. Note that if you create your own IControllerFactory you don’t have to follow this convention.
View templates (*.aspx, *.ascx), should go into the folder /Views/controllername. Don’t include the trailing string Controller here—views for ProductsController should go into /Views/Products (not/Views/ProductsController).
The default view for an action method should be named after the action method. For example, the default view for ProductsController’s List action would go at /Views/Products/List.aspx. Alternatively, you can specify a view name (e.g., by returning View("SomeView")), and then the framework will look for /Views/Product/SomeView.aspx.
When the framework can’t find a view called /Views/Products/Xyz.aspx, it will try /Views/Products/Xyz.ascx. If that fails, it tries /Views/Shared/Xyz.aspx and then /Views/Shared/Xyz.ascx. So, you can use /Views/Shared for any views that are shared across multiple controllers.

All of the conventions having to do with view folders and names can be overridden using a custom view engine.

The Initial Application Skeleton

As you can see from Figure 7-1, newborn ASP.NET MVC projects don’t enter the world empty handed. Already built in are controllers called HomeController and AccountController, plus a few associated view templates. Quite a bit of application behavior is already embedded in these files:

HomeController can render a Home page and an About page. These pages are generated using a master page and a soothing blue-themed CSS file.
AccountController allows visitors to register and log on. This uses Forms Authentication with cookies to keep track of whether each visitor is logged in, and it uses the core ASP.NET membership facility to record the list of registered users. The membership facility will try to create a SQL Server Express file-based database on the fly in your /App_Data folder the first time anyone tries to register or log in. This will fail if you don’t have SQL Server Express installed and running.
AccountController also has actions and views that let registered users change their passwords. Again, this uses the ASP.NET membership facility.

The initial application skeleton provides a nice introduction to how ASP.NET MVC applications fit together, and helps people giving demonstrations of the MVC Framework to have something moderately interesting to show as soon as they create a new project.

However, it’s unlikely that you’ll want to keep the default behaviors unless your application really does use the core ASP.NET membership facility to record registered users. You might find that you start most new ASP.NET MVC projects by deleting many of these files.

Debugging MVC Applications and Unit Tests

You can debug an ASP.NET MVC application in exactly the same way you’d debug a traditional ASP.NET WebForms application. Visual Studio 2008’s debugger is essentially the same as its previous incarnations, so if you are already comfortable using it, you can skip over this section.

Launching the Visual Studio Debugger

The easiest way to get a debugger going is simply to press F5 in Visual Studio (or go to Debug Start Debugging). The first time you do this, you’ll be prompted to enable debugging in the Web.config file, as shown in Figure 7-2.

Figure 7-2: Visual Studio’s prompt to enable debugging of WebForms pages

When you select “Modify the Web.config file to enable debugging,” Visual Studio will update the <compilation> node of your Web.config file:

<system.web>
   <compilation debug="true">
   ...
   </compilation>
</system.web>

This means that your ASPX and ASCX templates will be compiled with debugging symbols enabled. It doesn’t actually affect your ability to debug controller and action code, but Visual Studio insists on doing it anyway. There’s a separate setting that affects compilation of your .cs files (e.g., controller and action code) in the Visual Studio GUI itself. This is shown in Figure 7-3. Make sure it’s set to Debug (Visual Studio won’t prompt you about it).

Figure 7-3: To use the debugger, make sure the project is set to compile in Debug mode.

Note

When deploying to a production web server, you should only deploy code compiled in Release mode. Similarly, you should set <compilation debug="false"> in your production site’s Web.config file, too.

Visual Studio will then launch your application with the debugger connected to its built-in development web server, WebDev.WebServer.exe. All you need to do now is set a breakpoint, as described shortly (in the “Using the Debugger” section).

Attaching the Debugger to IIS

If, instead of using Visual Studio’s built-in web server, you’ve got your application running in IIS on your development PC, you can attach the debugger to IIS. In Visual Studio, press Ctrl+Alt+P (or go to Debug “Attach to Process”), and find the worker process named w3wp.exe (for IIS 6 or 7) or aspnet_wp.exe (for IIS 5 or 5.1). This screen is shown in Figure 7-4.

Figure 7-4: Attaching the Visual Studio debugger to the IIS 6/7 worker process

Note

If you can’t find the worker process, perhaps because you’re running IIS 7 or working through a Remote Desktop connection, you’ll need to check the box labeled “Show processes in all sessions.” Also make sure that the worker process is really running by opening your application in a web browser (and then click Refresh back in Visual Studio). On Windows Vista with UAC enabled, you’ll need to run Visual Studio in elevated mode (it will prompt you about this when you click Attach).

Once you’ve selected the IIS process, click Attach.

Attaching the Debugger to a Test Runner (e.g., NUnit GUI)

If you do a lot of unit testing, you’ll find that you run your code through a test runner, such as NUnit GUI, just as much as you run it through a web server. When a test is inexplicably failing (or inexplicably passing), you can attach the debugger to your test runner in exactly the same way that you’d attach it to IIS. Again, make sure your code is compiled in Debug mode, and then use the Attach to Process dialog (Ctrl+Alt+P), finding your test runner in the Available Processes list (see Figure 7-5).

Figure 7-5: Attaching the Visual Studio debugger to NUnit GUI

Notice the Type column showing which processes are running managed code (i.e., .NET code). You can use this as a quick way to identify which process is hosting your code.

Remote Debugging

If you have IIS on other PCs or servers in your Windows domain, and have the relevant debugging permissions set up, you can enter a computer name or IP address in the Qualifier box and debug remotely. If you don’t have a Windows domain, you can change the Transport drop-down to Remote, and then debug across the network (having configured Remote Debugging Monitor on the target machine to allow it).

Using the Debugger

Once Visual Studio’s debugger is attached to a process, you’ll want to interrupt the application’s execution so you can see what it’s doing. So, mark some line of your source code as a breakpoint by right-clicking a line and choosing Breakpoint “Insert breakpoint” (or press F9, or click in the gray area to the left of the line). You’ll see a red circle appear. When the attached process reaches that line of code, the debugger will halt execution, as shown in Figure 7-6.

Figure 7-6: The debugger hitting a breakpoint

The Visual Studio debugger is a powerful tool: you can read and modify the values in variables (by hovering over them or by using the Watch window), manipulate program flow (by dragging the yellow arrow), or execute arbitrary code (by entering it into the Immediate window). You can also read the call stack, the machine code disassembly, the thread list, and other information (by enabling the relevant item in Debug Windows). A full guide to the debugger is off-topic for this book; however, consult a dedicated Visual Studio resource for more information.

Stepping into the .NET Framework Source Code

There’s one little-known debugger feature that, in 2008, suddenly became a lot more useful. If your application calls code in a third-party assembly, you wouldn’t normally be able to step into that assembly’s source code during debugging (because you don’t have its source code). However, if the third party chooses to publish the source code through a symbol server, you can configure Visual Studio to fetch that source code on the fly and step into it during debugging.

Since January 2008, Microsoft has enabled a public symbol server containing source code for most of the .NET Framework libraries. This means you can step into the source code for System.Web.dll and various other core assemblies, which is extremely useful when you have an obscure problem and not even Google can help. This contains more information than the disassembly you might get from Reflector—you get the original source code, with comments (see Figure 7-7).

Figure 7-7: Stepping into Microsoft’s source code for ASP.NET Forms Authentication

To set this up, make sure you have Visual Studio 2008 SP1 installed, and then follow the instructions at referencesource.microsoft.com/serversetup.aspx.

Note

Microsoft has made the ASP.NET MVC Framework’s source code available to download so that you can compile it (and modify it) yourself. However, it has not released the source code to the rest of the .NET Framework libraries in the same way—you can only get that though Microsoft’s symbol server for the purposes of stepping into it while debugging. You can’t download the whole thing, and you can’t modify or compile it yourself.

Stepping into the ASP.NET MVC Source Code

Since you can download the whole ASP.NET MVC Framework source code package, it’s possible to include the System.Web.Mvc source code project in your solution (as if you created it!). This allows you to use Visual Studio’s Go to Declaration command to directly jump any reference in your own source code to the corresponding point in the framework source code, and of course to step into the framework source code when debugging. It can be a huge timesaver when you’re trying to figure out why your application isn’t behaving as expected.

This isn’t too difficult to set up, as long as you know about a few likely problems and how to solve them. The instructions may well change after this book is printed, so I’ve put the guide on my blog at http://tinyurl.com/debugMvc.

^[1.] This tactic (and this phrase) is one of the original famous selling points of Ruby on Rails.

Visual Studio 2010 BUGs, suggestions, Feedback

2009-10-14T16:49:00.002+05:30

BUG1

IDE: VS2010 Beta 1 Team Suite.
Though I pressed on "Save All" either from
1. ToolBox
or
2. File -> Save All.
still * icon is being shown for Project Properties Tab.

Steps to Re-produce the issue.
1. Create WPF User Control Library Project.
1. Open Project Properties
2. Change Assembly Name to some new name.
3.
Press Save All Icon
[BUG]Still shows Start after Project Properties Tab.
or
Press Save All from Menu -> File -> Save All
[BUG]Still shows Start after Project Properties Tab.

BUG2

IDE: VS2010 Beta 1 Team Suite.
[BUG] Properties are not dispplaying in Property Box.
Steps to re-produce
1. Open WPF User Control Project.
3. Open UserControl.xaml
4. Drop any component and select it.
5. Open Solution Explorer.
6. Open Property window.
Now Solution Explorer and Property window both will display Top and Bottom at right side of IDE
7. Now Close Solution Explorer.

[BUG][BUG][BUG] All properties in Property window disappear suddently though the component is selected ( in step4)

infragistics - NetAdvantage for Silverlight Data Visualization 2009 Volume 2!

2009-10-13T11:37:00.001+05:30

High-end, High Performance Web-based Data Visualization Experiences
This second version is focused on improving the mapping control to deliver an unbelievable user experience. We’ve added other features that make this the ultimate package for those of you focused on communicating information clearly and effectively through graphical means such as charts, gauges, timelines and maps.

Flexibility, Power and Usability When Building BI Apps
New enhancements to the xamWebMap allow you and your users to pull information from more places like Microsoft® bing™ maps, CloudMade, and OpenStreetMap into your Silverlight mapping applications. And, we’ve made it possible to pull both GEOMETRY and GEOGRAPHY data types from geo-spatial databases like Microsoft® SQL Server® 2008 using the new SqlShapeReader object. More maps to create more killer apps!

Present Data Clearly and Cleanly
Get controls that simplify the visual representation of large quantities of information in graphical ways. A graph designed to show a lot of information in one place, the new xamWebBulletGraph™ helps you deliver a clear and concise view of key performance indicators in Silverlight dashboards.

The xamWebChart™ has been enhanced to include chart cross hairs which is a graphical display that helps users clearly see the relationship between points on the graph, and their corresponding X- and/or Y-axis values. Each line can be independently styled to have the line style (solid, dashed, dotted, etc.), thickness and color you want.

Quickly Achieve Rich, Advanced Silverlight Data Visualization at a Very Low Price
For only $595, 445 EUR, 385 GB, NetAdvantage for Silverlight Data Visualization is a comprehensive collection of User Interface Controls to Build Rich Dashboards, Visualize Business Data and Empower Decision Makers. You can create high-end BI applications without writing a lot of code.

Buy Now

Contact Infragistics:	(800) 231-8588
In Europe (English Speakers):	+44 (20) 8387 1474
En France (en langue française):	0800 667 307
Für Deutschland (Deutscher Sprecher):	0800 368 6381
In India:	+91 (80) 6785 1111

String =”” vs String.Empty

2009-10-12T12:06:00.001+05:30

Here's a curious program fragment:

object obj = "Int32";
string str1 = "Int32";
string str2 = typeof(int).Name;
Console.WriteLine(obj == str1); // true
Console.WriteLine(str1 == str2); // true
Console.WriteLine(obj == str2); // false !?

Surely if A equals B, and B equals C, then A equals C; that's the transitive property of equality. It appears to have been thoroughly violated here.

Well, first off, though the transitive property is desirable, this is just one of many situations in which equality is intransitive in C#. You shouldn't rely upon transitivity in general, though of course there are many specific cases where it is valid. As an exercise, you might want to see how many other intransitivities you can come up with. Post 'em in the comments; I'd love to see what obscure ones you can come up with. (Incidentally, one of the interview questions I got when applying for this team was to invent a performant algorithm for determining intransitivities in a simplified version of the 'better method' algorithm.) Continue

Gene Expression Programming (GEP) in C# and .NET

2009-10-12T12:03:00.001+05:30

In the past we explored ways of using Genetic Algorithms (GA) to solve problems with a string of numbers that represent numbers. For example, we used genetic algorithms in our MasterMind game as a computer player for solving the hidden color combination where each color was represented by an integer. Gene Expression programming (GEP) is also a subset of Genetic Algorithms, except it uses genomes whose strings of numbers represent symbols. The string of symbols can further represent equations, grammars, or logical mappings. The genome can be mapped to a binary tree that you can walk along the nodes to evaluate the equation. This is an extraordinarily powerful technique because now you are not mapping a GA to hard values, but to general symbols.

Figure 1 - Quadratic Equation represented in a symbolic tree expression

Let's give an example of what we mean. Lets let the value 0 represent the variable a, 1 represent multiplication, and 2 represent +. So the string of numbers below:Continue

Beautiful post on Code Contracts

2009-10-12T12:00:00.001+05:30

Introduction

Code contracts allow one to specify the behavior of an algorithm by explicitly adhering to a well defined contract. Commonly, these contracts are in the form of pre- and post-conditions. Further, one can also specify behavioral contracts for a type in the form of a type invariant. For now you need not worry about how such contracts can be defined (we will discuss that later), however, it is important to understand some of the benefits of using code contracts, these include:

provide high-level behavioral description of an algorithm;
force programmers to be explicit about the behavior of their algorithms;
help catch bugs early.

For many readers code contracts will not be a new concept, most likely you will have seen them before in texts on data structures and algorithms [2]. However, most readers will be new to applying similar concepts to their actual codebase.

In this article we will cover code contracts using Spec#, the code contracts library shipping with .NET 4.0, and finish with a lo ok at VC++ source code annotations. Continue

Innovation/Showcase on Windows 7

2009-10-12T11:57:00.001+05:30

“Windows 7 is what a modern managed desktop should be. It helps us increase productivity, reduce costs, and provide enhanced desktop security”

- Doug Miller, Practice Architect, CDW

Join us at Microsoft’s Windows 7 Innovation Showcase where you can explore how Windows 7 delivers ‘the new efficiency” by growing your business through cost savings, productivity and innovation! Register today to see what Innovation can do for you!

Areas covered include:

· Address top seven business values of Windows 7 that enterprise customers care about

· Take advantage of the advancements in the Windows 7 user experience to make your application more compelling to users

and your users more productive in the tasks they care about

· Dive into the business scenarios and technical details of Multi-Touch and the Sensor and Location API on Windows 7

· Ease of Migrating to Windows 7

City/State	Date	Microsoft Location	Registration Link
Farmington, CT	October 15, 2009	Farmington Directions	Farmington Registration Link
Waltham, MA	October 20, 2009	Waltham Directions	Waltham Registration Link
Reston, VA	October 20, 2009	Reston Directions	Reston Registration Link
New York, NY	October 21, 2009	New York Directions	NY Registration Link
Rochester, NY	October 22, 2009	Rochester Directions	Rochester Registration Link
Alpharetta, GA	October 22, 2009	Alpharetta Directions	Alpharetta Registration Link
Ft Lauderdale, FL	October 26, 2009	Ft Lauderdale Directions	Ft Lauderdale Registration Link
Malvern, PA	October 29, 2009	Malvern Directions	Malvern Registration Link

Windows Mobile development in VS2010

2009-10-12T11:56:00.001+05:30

With the release yesterday of Windows Phone (press release , blog post , training , launch site) and with the upcoming release of Visual Studio 2010 Beta2, we are starting to see the question again: "where is the smart device development support in Visual Studio 2010?".
This question was asked a lot during the VS2010 Beta1 timeframe and the answer remains the same: Mobile Development Tools are now aligned to the mobile platform releases and are hence decoupled from Visual Studio releases, so I personally guess we should see tool support in VS2010 when a new mobile platform is released. For now, stick with VS2008 for device development needs (official statement) and keep an eye on the Windows Mobile Development Center.

Fault Tolerance in Windows Azure

2009-10-12T11:41:00.001+05:30

Ever since we announced Windows Azure there has been speculation about how reliable it will be and how we will insure that your application will continue to operate reliably in the face of changes to your application or the underlying software. Although we did say that we use multiple role instances and update domains to insure that your allocation has no single point of failure it was not until recently that we exposed more of the details of how this will work.

Now we have published the documentation on how this will work here and there is an excellent blog post here that explains the process in more detail.

There is also a new Deployment and Management API documented here which can be used as an alternative to using the portal for many deployment and management operations. But that will have to wait for another blog post.

.NET Rx Framework: Asynchronous Development with LINQ over Events

2009-10-12T11:39:00.001+05:30

Ever looking for a new, generic, way to incorporate asynchronous programming capabilities into your applications? Ever wish you could just write a LINQ query over your application events and just create reaction methods for when an event occurs?

Well now you can with the .NET Rx Framework - which provides a new look at asynchronous programming. It’s really just LINQ over IEnumerable…More

Backup and Restore SQL Server databases programmatically with SMO

2009-10-01T13:39:00.001+05:30

In my last set of tips, I discussed SMO at a basic level. In this tip I am going to provide examples to SQL Server Database Administrators on how to backup and restore SQL Server databases with SMO. I will start with how you can issue different types (Full, Differential and Log) of backups with SMO and how to restore them when required programmatically using SMO.... continue

NetAdvantage® for Win Client 2009 Vol. 2 Released

2009-10-01T11:02:00.001+05:30

This month, Infragistics released NetAdvantage for .NET 2009 Volume 2: Win Client. Comprised of WPF and Windows Forms toolsets, this package includes complete feature sets and in-depth capabilities to arm developers with all the controls and components needed to create powerful user interfaces that deliver the 'WOW-factor' to end users. The new offering promises a high-performance WPF data grid, optimized for millions of rows of data; the ability to export data from WPF Data Presenter to .XLS/.XLSX; a new WinTilePanel™ that allows end users to easily customize their screen; and more. For a complete list of new WPF features, visit www.infragistics.com/wpfwhatsnew. For a complete list of new Windows Forms features, visit www.infragistics.com/wfwhatsnew.

Belgium ReMix and Architect Forum: 10 Years of Framework Design Guidelines

2009-09-30T14:02:00.001+05:30

I had a great time at ReMix and the Architect Forum in Belgium. I had a chance to cover build an application end-to-end with Silverlight 3 and RIA Services which was basically the this application. At the Architect Forum I had a chance to talk in more depth about the general application pattern we are thinking about for RIA applications. I shameless stole some slides from Nikhil Kothari for this one. More

C#: Connect To Oracle Database With No Oracle Client Install Needed (Winform DataGridView Loading Example)

2009-09-30T14:00:00.001+05:30

This article demonstrates in a step by step fashion the easiest, and frankly fastest way to connect to an Oracle database using C#. The goal is to not have to install the huge Oracle Client either on the development machine nor the target machine the code will run on. This example creates a winform and inserts the content into a DataGridView for quick viewing. The code below is base on .Net 3.5.

Steps

Oracle has an Oracle Database Instant Client which is a set of Dlls which can be XCopy installed onto the development and target PC to allow Oracle database access without installing the full Oracle client. In future steps we will include those target Dlls to be copied to the target output folder with the executable. Download the appropriate package and add Dlls to a folder of your choice on the PC.
In Visual Studio create a Winform Project. From the Solution Explorer and within the project create a subfolder named Oracle Dlls.
Add the reference to the project of System.Data.OracleClient to the project..
In Studio again select the folder created in step 2 and select Add->Existing Item,and iInsert all the top level Oracle Dlls from step one into the the directory into the folder; unless for some reason you need previous versions all those dlls at the top level should be fine. More

Sneak Peek: ASP.NET Time Edit Control

2009-09-30T13:57:00.001+05:30

Check out this sneak peek video on the upcoming ASP.NET Time Edit control, the ASPxTimeEdit. The ASPxTimeEdit gives your websites an editor with a slick user interface to edit date and time values. The control looks and behaves a lot like our ASP.NET spin edit control. This is a great for your end users because theyre already familiar with how to use the up or down buttons of the control. And with keyboard support, there are now 3 different ways to edit the values: Type the date and time into...

Did you know that DotNetSlackers also publishes .net articles written by top known .net Authors? We already have over 80 articles in several categories including Silverlight. Take a look: here.

SourceOffSite 4.1 Synchronization Issues with VSS Server

2009-07-28T12:43:00.001+05:30

This post is regarding the problems synchronization/refreshing problems with SourceOffSite version 4.1 to connect to VSS Server.

Problem Description

Sometimes SourceOffSite is not refreshing the version of some files.

ex: Latest version of File1 is 10 chcked in by VSS client. Sourceoffsite shows version 9 as latest though tree has been re-freshed.

so when we use Show Differences it compares local copy with version 9 rather comparing with version 10 as it is latest.

Query1: any hotfix for SourceOffSite 4.1 to resolve this issue?
Query2: is this issue still there in SourceOffSite version 6?

Solution:
We are investigating the issue and try to post the solution soon.

Thanks,
Dutt

ASP.NET Tutorial for Traditional ASP Developers

2009-07-15T19:32:00.002+05:30

All too often, developers spend considerable time working with a single technology. They become deeply immersed in the nuances of building solutions with it, but unable to find time to keep up with other technologies. When they have a chance to look into an alternate technology, it may be well past the 1.0 release. This can make it very difficult to find relevant learning content that is both current and inclusive of previous versions. This course is designed to help ASP developers learn the nuances of building web applications with ASP.NET, without presuming existing knowledge of earlier versions of the technology. Syntax in ASP.NET is compared to its usage in ASP, to guide the developer through similar concepts in ASP.NET. Labs offer the developer a chance to work in hands-on scenarios with ASP.NET. This track should enable ASP developers to quickly learn the relevant core skills of ASP.NET, and provide foundational knowledge to get started down the path of building web applications with Visual Studio.

Level 1: Developing Web Applications – Tooling
In this module, we will discuss the development tools that will help you quickly get started building ASP.NET applications.

Level 2: ASP.NET Syntax for ASP Developers
In this module, we will compare ASP.NET syntax with ASP syntax, so that ASP developers can easily see how to do things in ASP.NET that they are familiar with from an ASP perspective.

Level 3: Programming WebForms
In this module, we’ll introduce the concept of Web Forms, and how you can use them to group controls as you build your web site.

Level 4: Web Configuration
Many web sites benefit from settings that span multiple pages within the site. This module will introduce web configuration files, which are a great way to store this type of information.

Level 5: Programming Web Events
Web events are a way to notify your application when some specific item of interest occurs in your web application. This topic will introduce how you can use web events to make your ASP.NET applications more responsive.

Level 6: State Management
As visitors move through your web application, it often makes sense to track data on the server, so the application can quickly access information to give the user a better experience. This module will discuss various aspects of state management, and optimal times to choose each technique. more

MSDN Flash India - Virtual TechDays is Back!

2009-07-15T19:25:00.001+05:30

As we begin a new fiscal year in Microsoft, I wanted to share with you the key activities that will provide us with an opportunity to interact with you. Every quarter, we will bring to you the 2-day Virtual TechDays readiness-focused event – the first one being planned for the second half of August. Tell us what you would like the Microsoft technology experts to talk about during this event by visiting; www.virtualtechdays.com TODAY.

We will also be launching the next version of Windows very soon – along with a host of other products like Silverlight 3 (July 10, 2009), Expression 3 and Visual Studio 2010, among others. While you can interact with us during the series of product launch focused events, I would urge you to START TRYING the beta versions of the software today and tell us what you think about these next generation of Microsoft technologies.
If you are in an organization which develops software products in the mobile, database and/or web domain, you may find that InnovateOn-India is the one place that offers you everything to help you bring your solution(s) to the market fast. For a free, online, community-based learning opportunity, we are pleased to offer to you the Ramp Up online training platform, where you can avail of extensive training courses across 11 technology tracks.

In addition, we will continue to share with you the latest product updates and technical articles through this fortnightly Newsletter. To ensure that this communiqué provides you with the right set of information, please do write to us on what you think is beneficial to you. We will continue to work with you on an ongoing basis to ensure that the MSDN Flash Newsletter is the single source that you can refer to for any of your Microsoft technology related development needs.

Code Coverage is not enabled for this test run

2009-06-25T17:28:00.001+05:30

Here are the steps to follow if you have problem in checking the "Code Coverage" Results.

Go to the test project in your application.

Open Test-> Edit Test Run Configuration

Go to Code Coverage, and select the dll that have to run for code coverage

This settings should solve the problem.

Code Coverage results are not displayed in “Debug” mode.

Change it to “Release” mode and run the test project. The Code Coverage results should be displayed.

Culture Information in Sting.Compare for Globalisation

2009-06-25T17:07:00.001+05:30

We all know that String.Compare can be used to compare two strings. One of the parameter for this Compare method allows us to compare two string in different culture. String.Compare("eg1", "eg1", true, new System.Globalization.CultureInfo("tr-TR"));

Difference between Build Solution and Rebuild Solution option in VS.Net

2009-06-12T18:46:00.001+05:30

VisualStudio.Net provides us with two options for compiling and creating builds for our application. They are Build Solution and Rebuild Solution options which can be accessed from the Build menu. The differences between these two options are

1. The Build Solution option compiles only those project files and components that have changed since the last build. For example consider that you have two projects Proj1 and Proj2 in your solution MySolution. When you compile the solution using Build Solution option after making some changes to Proj1 only Proj1 will be compiled and built but Proj2 will not be compiled since there are no changes to it.

2. On the other hand the Rebuild Solution option builds all project files and components irrespective of the changes made to them. For example consider that you have two projects Proj1 and Proj2 in your solution MySolution. When you compile the solution using Rebuild Solution option after making some changes to Proj1, both Proj1 and Proj2 will be compiled and built even though there are no changes made to Proj2.

Clean Solution option in Visual Studio to handle unexpected errors in C#.NET applications

2009-06-12T18:44:00.001+05:30

When we encounter unexpected build errors for Post Build and Prebuild commands.

It is always advisable to do the following:

1. Remove..%temp% files

2. Use “Clean Solution”

3. Building the solution starting from the most independent project..to the most dependant project

4. Rebuild the entire solution

Publish articles to Blog using Microsoft Word 2007

2009-06-11T21:22:00.001+05:30

Yes this is true!!! Wondering how? I will walk you through this.

Open word –> File –> New –> Other Documents –> Select “New Blog Post” –> Select “Template”

Select the blog provider

Give the account details.

Here you go...Happy Blogging!

More details at