Learnxpress

HTML 5: Up and Running

Anand Narayanaswamy — Mon, 06 Sep 2010 04:46:55 +0000

If you don’t know about the new features available in HTML 5, now’s the time to find out. The latest version of this markup language is going to significantly change the way you develop web applications, and HTML 5: Up & Running (O’Reilly Media, $29.99 USD) provides your first real look at HTML 5′s new elements and attributes.

Even though work on HTML5 is ongoing, browsers such as Safari, Mozilla, Opera, and Chrome already support many of its features-and browsers for smart phones are even farther ahead, especially iPhone’s MobileSafari browser.

Mark Pilgrim, author and accessibility architect, has been following the development of HTML 5 long before it was called HTML 5. “In the mid-90′s, browser vendors were competing with each other to see who could lock people into their platform,” says Pilgrim. “Now, browser vendors implementing the HTML 5 standard are competing on things like speed and user-friendliness. This book will help programmers develop next-generation web applications.”

Mark Pilgrim adds, “I have a strong interest in open standards, and this is my contribution towards ensuring that the web remain open and available to all I have a strong interest in open standards, and this is my contribution towards ensuring that the web remain open and available to all.”

With HTML 5: Up & Running, you’ll learn how HTML 5 can help you develop applications that:

. Display video directly in the browser, without having to rely on plugins
. Work even when a user is offline, by taking advantage of HTML 5′s persistent storage
. Offer a drawing canvas for dynamically generated 2-D graphics

HTML 5: Up and Running is the most complete and authoritative book you’ll find on the subject. Stay ahead of the curve.

HTML 5: Up and Running
Mark Pilgrim
ISBN: 978-0-596-80602-6
224 pages
Book Price: $29.99 USD
Ebook Price: $23.99 USD

First Guide to MEF and Silverlight (Part–II)

Anand Narayanaswamy — Sat, 04 Sep 2010 05:54:39 +0000

In my previous article “First Guide to MEF & Silverlight (Part–I)” I discussed about MEF with a small simple console application. Hope that was useful to you to understand the basic knowledge of MEF. In this article, I will guide you to create a simple Silverlight application using the MEF. If you are new to MEF, I strongly recommend you to read my previous article to gain knowledge on the basic things of MEF like Importing, Exporting, Catalog, Container etc. Read the complete article and at the end if you have any queries, please let me know. I will try to answer them as soon as possible. Always Appreciate your valuable feedbacks. To start working with the Silverlight & MEF application, you need to setup your development environment. In your development PC, you need the following things already installed: Visual Studio 2010 with .Net Framework 4.0 Silverlight 4.0 Tools for Visual Studio 2010 Once your environment is ready with the above tools, we can start with our next step. First of all, we need to create a Silverlight application project and then we have to add some assembly reference in order to work with the MEF. Hence, follow the following steps to setup your project: Open your Visual Studio 2010 IDE Now go to File –> New –> Project or just press Ctrl + Shift + N to open the “New Project” dialog window. From the left panel expand “Visual C#” and then select “Silverlight”. This will populate the right pane with the Silverlight templates.

In the right pane, select “.Net Framework 4” from the DropDown present at the top of the screen. This is require because, we want to do application programming for the target version i.e. Framework 4. Chose “Silverlight Application” from the right pane and click “OK”. I assumed that, you selected proper location and named your application project properly (in our case, I named it as “MEFWithSilverlightDemo”). Once you click “OK”, it will ask you to create a new Web site. This step is require to host the Silverlight application.

Be sure that, in the above dialog “Silverlight 4” has been selected as the Silverlight version. Once you click “OK” the Visual Studio IDE will start creating your Silverlight project. It will create two project (one is your Silverlight application project and the other is your Silverlight application hosting website).

Once the project created by the IDE, you need to add a reference of the Assembly named “System.ComponentModel.Composition” and a reference of the Assembly named “System.ComponentModel.Composition.Initialization” to your project. To do this, right click on your Silverlight Application project and click “Add Reference”. From the “Add Reference” dialog find the assembly named “System.ComponentModel.Composition” and “System.ComponentModel.Composition.Initialization” to add them to your project.

Once done with all the above steps, your project is ready for the MEF development. Let us first decide what we want to do in our example. We will create a Silverlight application where we will include some UserControls as a Widget. This is for learning purpose and hence don’t go with the UI. So, in our sample application we will create a UserControl and mark it as Exportable. Then we will import the UserControl in our application to add it in the UI. Next we will create another UserControl and mark it as Exportable, so that without any other change in the code, it should add in the main UI. This is just an example to showcase the MEF functionality in Silverlight applications. Let’s jump into the code. First of all, we will create an Interface called IWidget and we will use this interface to build our UserControl. We will just inherit this to the UserControl and while exporting or importing we will use the same interface type. Reason behind this is to make sure only the specified type of control will be marked for MEF. If we have two different types for two different kind of controls, it will be easier for us to manage in the main screen. So, just create a blank interface named IWidget which will look like below: Now, in the MainPage.xaml add an ItemsControl & name it as “widgets”. Wrap the ItemsControl with a StackPanel to hold the items. The XAML file will look as below:

Now it’s time to create a UserControl. Right click on the Silverlight project and add one UserControl & name it as “EmployeeWidget”. We will not design more inside it as it is not require to understand the MEF. To make it properly visible just add one TextBlock with some strings. In our example, I am setting “Employee Widget” as the text string for the TextBlock and also setting a color “Red” to the Grid background. Resize the UserControl to 150 x 150, so that, it will set properly in the screen. Let’s see the below code for detailed layout:

As mentioned above, I resized the control to 150 x 150 and then changed the background color to Red. Added a TextBlock having “Employee Widget” as the value to the TextProperty of the TextBlock with a foreground color of White, so that, it will be visible on top of the Red color. No need to describe more on it. Just check the above xaml and you will get the idea behind it.

Press F7 in the EmployeeWidget.xaml page to open up the code behind file. Inherit the EmployeeWidget class from IWidget. Once done, add the attribute “Export” having the type of IWidget to the class. This will ensure that the class will export for the MEF to Satisfy. Look into the code here:

As our UserControl has been exported for the MEF to satisfy, it’s the time to import it in our MainPage. To do this, open the MainPage.xaml.cs and create a property “Widgets” of IWidget type array. We are using array type to ensure that, we can import many widgets there. So, mark the property with the atrribute “ImportMany” of type IWidget. Once that is done, our code is ready to import the exported class. Now inside your MainPage constructor, iterate through the array and add all the Widgets as the item to the “widgets” items control which we already added in the XAML. Now if you run your application, you will notice that the Widgets array is null. Why? Just think. Oh yea!!! We forgot to satisfy the MEF Initializer to satisfy the property. What to do for that? To satisfy the imports, you need to call “CompositionInitializer.SatisfyImports(this);” just before iterating through the array list. Have a look into the code:

Now, run your application once again and this time you will see the EmployeeWidget added to the UI screen with a text “Employee Widget” having a Red background. Here is the screenshot of the same:

Woho!!! Nice. We didn’t create the object of the UserControl and add it to the ItemsControl. The MEF framework did it for us. Once satisfied, it created the object and imported it to the MainPage.

That’s it. Now we will do one more thing. We will create another UserControl named “CustomerWidget” and follow the same steps mentioned above for exporting the control. This time we will set the text to “Customer Widget” and will set the background color to Green. This will make it easy for us to distinguish between the items. Here is the XAML code of the CustomerWidget usercontrol:

Now open the code behind file of CustomerWidget by pressing F7 in the xaml page and follow the same step as we did for the EmployeeWidget i.e. implement the CustomerWidget from the interface named IWidget and mark the class exportable by setting the Export attribute of the IWidget. Here is the code for your reference:

That’s it. This time we didn’t add/modify anymore code in our MainPage. Just run the application and you will see the CustomerWidget added in the panel along with the control named EmployeeWidget. See the screenshot of the same here:

So, what did we learn here? We learnt that without changing the original code, we can easily import any control with the help of MEF. It is very easy to plug something into our original application without doing any change in the main application. In such case, instead of updating the original application we can easily attach our feature like a plug-in. Hope, this article helped you to understand the basic functionality of MEF with the help of Silverlight. In my next article, I will show you more on MEF with the help of a Console Application. Till then keep learning about MEF & do your small small POCs to learn in depth. Please don’t forget to post your feedbacks and/or suggestions to improve this article. Appreciate your time for reading through this article

View the original article here

Getting elevated privileges on demand using C#

Anand Narayanaswamy — Fri, 03 Sep 2010 10:59:51 +0000

With going on stage Windows Vista and Windows 7 later on and new user security paradigm introduction (UAC), it becomes necessary to support such behavior when elevated privileges are required to perform some portion of code base, i.e. writing to registry, modifying files under system protected folders, etc.

So, in general, there are two ways to implement such behavior:

Embed a manifest info executable to indicate that the application requires elevated privileges from the beginning and can’t be run without gaining administrative rights at all. Here’s an example of such manifest:
Separate the code base into two parts: the first doesn’t require elevated privileges and the second – does, so call one from another. The article covers a case when the calling application is a console with a number of command line arguments: some of them can be run in normal mode and some – only with administrative rights.

Usually the part of the program requires elevated privileges is a settings form which writes to Windows registry when the core functionality – don’t.

Another case – a console application where core functionality requires elevated privileges and some helpers – such as help message displaying – don’t.

Let’s declare the skeleton of such console application.

Entry point method parses input command line arguments and branches the flow control relying on the parse results wrapped into a object:

static void Main(string[] args){ // wrap command line arguments to an object Core.Settings = ApplicationSettingsParser.Parse(args); if (Core.Settings.UsageFlag || (args.Length == 0)) { // run without elevated privileges PrintUsage(); } else if (!Core.Settings.EngageFlag) { // runs with the same arguments plus flag mentioning the main action performing var info = new ProcessStartInfo( Assembly.GetEntryAssembly().Location, String.Join(” “, Enumerable.Concat(args, new[] { “–engage” }))) { Verb = “runas”, // indicates to eleavate privileges }; var process = new Process { EnableRaisingEvents = true, // enable WaitForExit() StartInfo = info }; process.Start(); process.WaitForExit(); // sleep calling process thread until evoked process exit } else if (Core.Settings.EngageFlag) { // do stuff under elevated privilegesConsole.WriteLine(“Elevated privileges gained={0}”, Core.IsElevated); }}

Here’s a method just displaying a sample help message:

private static void PrintUsage(){ Console.WriteLine(“Usage: ElevatedPrivilegesOnDemand.exe –do [--engage] | -?”);}

Parsing method is placed into a dedicated helper:

public static ApplicationSettings Parse(string[] args){ var settings = new ApplicationSettings(); for (int i = 0; i < args.Length; i++) { var param = args[i]; switch (param) { case "-?": { // stop further parsing and return only meaning flag return new ApplicationSettings() { UsageFlag = true }; } case "--do": { settings.DoFlag = true; break; } case "--engage": { settings.EngageFlag = true; break; } } } return settings;}

Which returns a POCO object keeping settings:

class ApplicationSettings{ public ApplicationSettings() { // default settings setup } public bool DoFlag { get; set; } public bool EngageFlag { get; set; } public bool UsageFlag { get; set; }}

Internal singleton setting instance is attached to a pivot class. It also contains an addition helper method to check elevated privileges obtaining:

static class Core{public static bool IsElevated{get{return new WindowsPrincipal(WindowsIdentity.GetCurrent()).IsInRole(WindowsBuiltInRole.Administrator);}}public static ApplicationSettings Settings { get; set; }}

The executing flow is being separated to the two parts: in the first it’s being determined whenever elevated privileges are required relying on command line arguments specified or not. And if yes – an additional parameter is being added and passed to the same application but started with administrative rights and redirected console output.
And in the second, the core functionality is being executed with full privileges gained.

Now there is no needs to run the whole application under elevated privileges mode when it is not necessary.

Unfortunately it seems that it’s not possible to hide child process window and elevate its privileges in the same time:

ProcessStartInfo.Verb will only have an effect if the process is started by ShellExecuteEx() which requires UseShellExecute = true Redirecting I/O and hiding the window can only work if the process is started by CreateProcess() which requires UseShellExecute

I’m investigating this behavior and will update my article as far will find a solution to hide a window of started elevated process.

Reader can find next links to be interesting:

Questions tagged UAC and manifest on Stack Overflow, especially this and related.

28/08/2010 – version 1.0.1 – Initial release.

29/08/2010 – version 1.0.2 – Fix of example source code.

30/08/2010 – version 1.1.3 – Code change and remark addition considering hiding window of process started with elevated previliges.

View the original article here

Programming WCF Services Released

Anand Narayanaswamy — Thu, 02 Sep 2010 06:28:05 +0000

Programming WCF Services, Third Edition is the authoritative, bestselling guide to Microsoft’s unified platform for developing modern service-oriented applications on Windows.

“I’ve included my ServiceModelEx library, a framework of useful utilities, tools, and helper classes that let you simplify and automate many tasks, and extend WCF,” says author, speaker, and Master Architect Juval Löwy.

Löwy revised this edition to include the newest productivity-enhancing features of .NET Framework 4 and the Azure AppFabric Service Bus, as well as the latest WCF ideas and techniques. By teaching you the why and the how of WCF programming, Programming WCF Services will help you master WCF and make you a better software engineer.

This book will help you:

• Learn about WCF architecture and essential building blocks, including key concepts such as reliability and transport sessions

• Use built-in features such as service hosting, instance and concurrency management, transactions, disconnected queued calls, security, and discovery

• Master the Windows Azure AppFabric Service Bus, the most revolutionary piece of the new cloud computing initiative

• Increase your productivity and the quality of your WCF services by taking advantage of relevant design options, tips, and best practices in Löwy’s ServiceModelEx framework

• Discover the rationale behind particular design decisions, and delve into rarely understood aspects of WCF development

Hailed as the definitive treatment of WCF, Programming WCF Services provides unique insight, rather than documentation, to help you learn the topics and skills you need for building WCF-based applications that are maintainable, extensible, and reusable.

Juval Löwy is the principal of IDesign, a company specializing in .NET architecture consulting and advanced training. Juval is Microsoft’s Regional Director for the Silicon Valley, and he participates in the Microsoft internal design reviews for future versions of .NET and related technologies. Juval is one of the world’s top .NET experts and industry leaders—and a Microsoft Software Legend.

Web Server Information using .NET

Anand Narayanaswamy — Thu, 02 Sep 2010 06:21:00 +0000

This article is about a tool which you can use to get information like encoding, cookie details, web server name, server language, their version numbers, etc.

We cannot guarantee as it is possible for the server guys to fake/disable parameters if they wish.

WebClient belongs to System.Net.WebClient. You can find the MSDN page here – http://msdn.microsoft.com/en-us/library/system.net.webclient(VS.80).aspx

WebClient provides common methods for sending data to and receiving data from a resoruce identified by a URI.

This feature is available from .NET Framework version 2.0. I have made use of this feature for building this handy tool.

This is the heart code of this tool which gets data from the server and displays the parameters to a textbox.

WebClient wc = new WebClient();wc.Headers.Add(“user-agent”, “Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)”);wc.OpenRead(site);for (int i = 0; i < wc.ResponseHeaders.Count; i++){ sb.Append((i + 1).ToString() + “. [" + wc.ResponseHeaders.AllKeys[i] + “] => ” + wc.ResponseHeaders[i] + Environment.NewLine + Environment.NewLine);}textBox1.Text = sb.ToString();

WebClient.ResponseHeaders is the property which brings our necessary parameters from the server.

Well, technology enthusiasts, I would say. If somebody is interested to know which website runs on which server/language, then this tool is for them.

Some of my observations with this tool here:

google.com – gws (Google Web Server)codeproject.com – IIS6, ASP.NET 4.0microsoft.com – IIS 7.5/ASP.NET 4.0msdn – IIS 7.5/ASP.NET 2.0php.net – Apache 1.3/PHP 5.2apache.org – Apache 2.3python.org – Apache 2.3/Python 2.5gmail – GSE (Google Search Extension)oracle.com – Oracle Application Serverjava.com – Sun Java System Web Server

View the original article here

Transform Data into Interactive Dashboards with ReportsMaestro

Anand Narayanaswamy — Wed, 01 Sep 2010 05:30:46 +0000

ReportsMaestro has announced the immediate availability of its web report and chart builder. Powerful and flexible, ReportsMaestro makes creating and sharing fully customizable interactive dashboards a mater of a few minutes.

Designed to give your website a competitive advantage through improved data visualization, the ReportsMaestro offers a set of tools for building interactive reports, charts and queries. The software features Web Reports Builder enabling you (or your users, for that matter) to create real-time data-driven reports, generate them based on a table or query, and tailor for the specific needs with the built-in visual style editor.

With ReportsMaestro, no coding is required to convert those huge amounts of data into the interactive, professional-looking charts. The smart solution provides Web Charts Builder with 15+ chart types and styles, from popular pie and bar charts to sophisticated 3D diagrams. It also offers Query Builder to enhance the look of your database joining tables, grouping, sorting and filtering data.

What’s more, the program allows determining access rights for users and give charts and reports private or public status. This option provides authorized users with a handy collaboration tool, while ensuring the necessary data security. ReportsMaestro supports MS Access, MySQL, PostgreSQL, Oracle, Firebird, SQLite and SQL Server, and can be installed on any ASP or PHP-enabled web server.

Pricing and Availability

ReportsMaestro is available in Standard, Gold and Platinum editions valid for 1, 10 and unlimited number of websites respectively. The price for the product starts from $79. Licensed users are entitled to free updates and support via e-mail within 1 year from the date of purchase. Further information on ReportsMaestro is available at the product website.

Links

Program website: http://reportsmaestro.com
Screenshots: http://reportsmaestro.com/screenshots.htm

Avoid Hidden Controls – ASP.NET

Anand Narayanaswamy — Wed, 01 Sep 2010 06:15:35 +0000

Web Application is stateless. To maintain the state of the page we have many solutions like query string, session, hidden controls and more..

Hidden controls are primarily used to keep some kind of key value pairs for the page. To maintain multiple key value pairs, we need to have multiple hidden controls on the page and hidden control name will be used as key. Basically the concept behind the hidden control is sharing the values between server and client.

But sometimes single hidden control will be used for multiple values; it’s not a good way to do because of improper delimited character handling or data type conversions.

I have come up with the solution to maintain the states using a single hidden control and isolate the complication inside this component.

This solution is like an enhancement of ViewState provided by Microsoft. Though it solves the purpose to retain the server side values, it is not possible to manipulate those values in the client side as it’s designed for handling the retaining of server side object.
URL : http://msdn.microsoft.com/en-us/library/system.web.ui.control.viewstate.aspx

ViewState Sample :

public partial class ViewStatePage : System.Web.UI.Page { [Serializable] public class Employee { public string Name; public int Age; } private Employee currentEmployee; protected override void SavePageStateToPersistenceMedium(object state) { ViewState["CurrentEmployee"] = currentEmployee; base.SavePageStateToPersistenceMedium(state); } protected override void OnLoad(EventArgs e) { currentEmployee = ViewState["CurrentEmployee"] as Employee; base.OnLoad(e); }}

To solve this problem, I have created a Web Control in my one of old ASP.NET project called as ExtentedViewState Control. Here I have added some more advanced way to handle this problem.
Basically, this control will hold a collection object which will allow the user to add a key value pair. At the time of rendering of this web control, this will generate a single hidden control and holds the key value pairs as base 64 encoded values.
Once the page is loaded into the browser, this control uses a simple Javascript wrapper to allow the user to manipulate the key value pairs from the client side.
When the user submits the page, this Javascript wrapper will send these updated values as base 64 string to the server. In the server side, it will get parsed and object is built on the server side.

Here I have included a sample project in a more simplified way to avoid the hidden controls.

It contains 3 different files for avoiding the hidden controls, from the server side, I have created a simple object to work like ASP.NET ViewState object – named “CustomViewState.cs”

CustomViewState Class contains the implementation of server side key value pair accessing and manipulations. This object will be added as the property to the parent UI.Page class.
User can access the Key value pairs using the property as like the normal collections.

StateManager.js script file serve the same functionality of CustomViewState Class in Client side.

Step 1: Inherit your asp.net page class from FrameWorkBasePage
Step 2: Add your key/values using CustomViewState property of the current UI.Page.
Step 3: Use StateManager object in from client side to manupulate the key value pairs

public partial class _Default : ApplicationFrameWork.FrameWorkBasePage { protected void Page_Load(object sender, EventArgs e) { if (!IsPostBack) { int intvalue = 10; decimal decvalue = 10; DateTime dtvalue = DateTime.Now; DateTime dvalue = DateTime.Now.Date; bool bvalue = true; CustomViewState.SetValue(“integer”, intvalue); CustomViewState.SetValue(“decvalue”, decvalue); CustomViewState.SetValue(“dtvalue”, dtvalue); CustomViewState.SetValue(“datevalue”, dvalue); CustomViewState.SetValue(“boolean”, bvalue); CustomViewState.SetValue(“strvalue”, “Elayaraja”); } } }

View the original article here

Create RESTful WCF Service API : Step By Step Guide

Anand Narayanaswamy — Tue, 31 Aug 2010 04:39:47 +0000

Windows Communication Foundation (WCF) is an SDK for developing and deploying services on Windows. WCF provides a runtime environment for your services, enabling you to expose CLR types as services, and to consume other services as CLR types. In this article I am going to explain you how to implement restful service API using WCF 4.0 . The Created API returns XML and JSON data using WCF attributes.

What is REST?

Based on Roy Fielding theory “Representational State Transfer (REST), attempts to codify the architectural style and design constraints that make the Web what it is. REST emphasizes things like separation of concerns and layers, statelessness, and caching, which are common in many distributed architectures because of the benefits they provide. These benefits include interoperability, independent evolution, interception, improved scalability, efficiency, and overall performance.”

Actually only the difference is how clients access our service. Normally, a WCF service will use SOAP, but if you build a REST service clients will be accessing your service with a different architectural style (calls, serialization like JSON, etc).

REST uses some common HTTP methods to insert/delete/update/retrive infromation which is below:

a) GET - Requests a specific representation of a resource

b) PUT - Create or update a resource with the supplied representation

c) DELETE - Deletes the specified resource

d) POST - Submits data to be processed by the identified resource

Why and where to use REST?

Few days back i was writing a service which was suppose to access by heterogeneous language/platform/system. It can be used by iPhone, Android, Windows Mobile, .NET web application, JAVA or PHP. Using web service it was bit complex for me to expose it to everyone using uniform system. Then we decided to use REST, which was easily espoused over cloud. This was a great example which shows the capability of SIMPLE RESTful SERVICE :) . Below is some point which will help you to understand why to use the RESTful services.

1) Less overhead (no SOAP envelope to wrap every call in)

2) Less duplication (HTTP already represents operations like DELETE, PUT, GET, etc. that have to otherwise be represented in a SOAP envelope).

3) More standardized – HTTP operations are well understood and operate consistently. Some SOAP implementations can get finicky.

4) More human readable and testable (harder to test SOAP with just a browser).

5) Don’t need to use XML (well you kind of don’t have to for SOAP either but it hardly makes sense since you’re already doing parsing of the envelope).

6) Libraries have made SOAP (kind of) easy. But you are abstracting away a lot of redundancy underneath as I have noted. Yes in theory SOAP can go over other transports so as to avoid riding atop a layer doing similar things, but in reality just about all SOAP work you’ll ever do is over HTTP.

Step by step guide

Generally developer scared to use WCF because lot of confusing configuration. I will try to use minimum configuration so that it will be easier to understand for us. We will develop Restful WCS API in 6 steps. So let’s start now.

STEP:1) First of all launch Visual Studio 2010. Click FILE->NEW->PROJECT. Create new “WCF Service Application“ .

STEP-2) Once you create project, you can see in solution that By Default WCF service and interface file is already created. Delete By default created file as we will create our own interface and WCF service file.

STEP-3) now Right click on solution and create one new WCF service file. I have given name to the service file as “RestServiceImpl.svc”.

STEP-4) As i explained in starting of the article that we will be writing an API which can return data in XML and JSON format, here is the interface for that. In IRestServiceImpl , add following code.

In above code, you can see two different method of IRestService which is XMLData and JSONData. XMLData Returns result in XML whereas JSONData in JSON.

STEP-5) Open the file RestServiceImpl.svc.cs and write following code over there..

STEP-6) Now let’s move to configuration part which is the last one. There will be two basic part of the configurations file which we must have to understand…

>
The part contains information about the End Point. below is the code detail..
A)
This part contains details about service and endpoint behavior.

And that’s it. Our Restful WCF service is ready for test purpose.
Now i launch the application in browser to see the result. I launch this service in IE and my URL is now http://localhost:35798/RestServiceImpl.svc . Now if i use http://localhost:35798/RestServiceImpl.svc/xml/123 URL, i get following response on the browser which an XML format and that was my task to achieve.

Now if i use http://localhost:35798/RestServiceImpl.svc/json/123 URL, i get following response on the browser which an XML format and that was my task to achieve.

Hope the article is useful for community. Comments, suggestions and criticisms are all welcome.

View the original article here

WebService Routing (Soap Router)

Anand Narayanaswamy — Mon, 30 Aug 2010 06:30:16 +0000

This article describes content based web service routing using WSE 3.0. We can use webservice routing for load balancing or to hide internal web service from external world.

A background knowledge of Asp.Net 2.0, C#, WebService & WSE 3.0 is required.

In this sample application, I have three webservice 1) CBRoutingService 2) PremiumService 3) StandardService and client web application.

As per the above figure, client web application will consume CBRoutingService. SoapHeader will have user id stored in it. CBRoutingService will route the request to the StandardService or PremiumService based on the user id. If user id is less than 100 than it will route the request to the StandardService otherwise it will route it to PremiumService. So this is simple routing application which we will build.

Let’s do following steps in vs2005:

1) Create Standard service

2) Create Premium service

3) Create & configure Routing service

4) Create & configure client website

1) Create Standard service:

To create the StandardService as ASP.Net Web Service. Go to File -> New -> Web Site -> ASP.Net Web Service. Give the location as http://localhost/StandardService . Remove default Service.asmx and Service.cs file and add new web service StandardService.asmx. We will add new web method called GetServiceString in StandardService.cs as below.
[SoapHeader("authheader", Direction = SoapHeaderDirection.InOut)] [WebMethod] public string GetServiceString() { return “This is Standard Service Customer”; }

We also have to add AuthHeader class in StandardService.cs for passing user id in the SoapHeader and write SoapHeader attribute above GetServiceString web method.
public class AuthHeader : SoapHeader{ public string UserId;}

2) Create Premium Service:

Create PremiumService by same way, just give the location as http://localhost/PremiumService and web service name as PremiumService.asmx. We also need to change return string in GetServiceString web method of PremiumService.
[WebMethod] public string GetServiceString() { return “This is Premium Service Customer”; }

3) Create and configure Routing Service:
Now we will create routing service by same way with http://localhost/CBRouter as location. Add new web service and give name as CBRoutingService.asmx.

Keep the default setting as it is for now. We will change it latter.

Now we need to have handler which will intercept the request to CBRoutingService. So we need to add class library project for that by right click on solution -> Add -> New Project and select Class Library template. Now add new class called CBRoutingHandler.

Add following reference to your project.

1) Microsoft.Web.Services3

2) System.Web.Service

We have to derived Microsoft.Web.Services3.Messaging.SoapHttpRouter in CBRoutingHandler class and implement ProcessRequestMessage method to intercept the web service request.
using System; using System.Configuration; using System.Xml; using Microsoft.Web.Services3; using Microsoft.Web.Services3.Messaging;/// /// Summary description for CBRoutingHandler/// namespace CBRouter{ public class CBRoutingHandler : Microsoft.Web.Services3.Messaging.SoapHttpRouter { static readonly string PremiumNamespaceUri = “http://schemas.contoso.com/cbr”; static readonly string PremiumHeaderName = “authheader”; Uri premiumServiceUri; Uri standardServiceUri; public CBRoutingHandler() { string premiumServiceUrl = “http://localhost/PremiumService/PremiumService.asmx”; string standardServiceUrl = “http://localhost/StandardService/StandardService.asmx”; if (premiumServiceUrl == null || premiumServiceUrl.Length == 0) { throw new ConfigurationException(“There was no \”Premium Web Service\” entry in the section of the router’s configuration file.”); } this.premiumServiceUri = new Uri(premiumServiceUrl); this.standardServiceUri = new Uri(standardServiceUrl); } protected override Uri ProcessRequestMessage(SoapEnvelope message) { // Look for user id. if (!string.IsNullOrEmpty(message.Header.InnerText)) { if (Convert.ToInt32(message.Header.InnerText) > 100) { return premiumServiceUri; } } return standardServiceUri; } }}

Add CBRoutingHandler project reference in CBRouter web service.

Now you have to enable WSE based routing in CBRoutingService. To do this follow the below steps:

1) In Visual Studio 2005, right-click the CBRouter project and select WSE Settings 3.0.
2) On the General tab, select the checkboxes for the following options:
o Enable this project for Web Services Enhancements.
o Enable Microsoft Web Services Enhancement SOAP Protocol Factory
3)Click OK

Now click on Routing tab. Click Add to add routing handlers and give CBRoutingHandler information as below, type = “CBRouter.CBRoutingHandler, CBRouter” Path=” CBRoutingService.asmx” and Verb=”POST”

You can see the changes in web.config file. It has added httphandlers in web.config.

Now we have to give WSDL to the client so that they can generate the proxy and consume it.

Save wsdl of StandardService or PremiumService as .wsdl file. Open this file in editor and change the url to CBRoutingService url as below:

So now we have .wsdl file but it points to CBRouter.

4) Create and configure client website:

Now create client web site. Here, do not add web reference for StandardService instead create proxy class with wsdl.exe using modified wsdl file.

Open .net command prompt and give following command: Wsdl /out:C:/StandardServiceProxy.cs C:/Standardservice.wsdl

Now add this StandardServiceProxy.cs to your website project.

Add textbox and button on the page. On button click, we will pass the textbox value to web service call.
protected void Button1_Click(object sender, EventArgs e) { try { StandardService standardSer = new StandardService(); AuthHeader auth = new AuthHeader(); auth.UserId = txtUserId.Text; standardSer.AuthHeaderValue = auth; string str = standardSer.GetServiceString(); lbl.Text = str; } catch (Exception ex) { lbl.Text = ex.Message; } }

Now run the website and enter any user id. You will get the response based on user id as below.

Thus you can use WSE to route the web service call to other webservice.

Notes:

If you want to make StandardService & PremiumService as WSE enabled service then you have to apply SoapActor attribute above the service class name.
using Microsoft.Web.Services3.Messaging;/// /// Summary description for StandardService/// /// [SoapActor("*")][WebService(Namespace = "http://tempuri.org/")][WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]public class StandardService : System.Web.Services.WebService{

SoapActor attribute indicates that this web service can handle routed messages, which is not originaly requested to it. ‘*’ means any service can route the messages to this webservice. You can give router service’s url to indicate service will handle routed message from particular url.

View the original article here

ASP.NET MVC – AuthorizeWithExemptionsAttribute

Anand Narayanaswamy — Sun, 29 Aug 2010 12:07:41 +0000

In this article, I’ll provide you with a solution for securing ASP.NET MVC application’s controllers in a way that all the actions are secured except those you define as unsecure (by default, all the actions are unsecure unless you define them as secure).

I encountered a problem in the ASP.NET MVC authorization model, which is built as opt-in. You can secure an action or a controller using the [Authorize] attribute. The problem is that if you want to secure a whole controller and make some actions in that controller as not secured – you can’t.

This article will explain to you how you can secure a whole controller and make some actions as not secured within it.

This project was written in Visual Studio 2010 as an ASP.NET MVC 2 project.

I was looking for a solution to that problem, and couldn’t find a reasonable one. Other solutions suggested to:
Move the unsecured actions to another controller (not secured)Write the AuthorizeCore method to be dependent on the Action’s namesPut the [Authorize] attribute on all the actions except the non-secured actions

In this article, I’ll provide you with my solution to this problem.

To use the code, you’ll need your controllers to put any [CustomAuthorize] attribute which inherits from AuthorizeWithExemptionsAttribute on your controllers. Calling any action on this controller will include an authorization check. If you want to mark an Action as non-secured, just put the [UnsecuredAction] Attribute above it.

The core of this solution is in the [AuthorizeWithExemptions] Attribute in the OnAuthorization method. This method checks if the called Action has the UnsecuredActionAttribute, and if it does, it marks filterContext.HttpContext.SkipAuthorization as true.
public override void OnAuthorization(AuthorizationContext filterContext){ ActionDescriptor action = filterContext.ActionDescriptor; bool IsUnsecured = action.GetCustomAttributes( typeof(UnsecuredActionAttribute), true).Count() > 0; //If doesn’t have UnsecuredActionAttribute – then do the authorization filterContext.HttpContext.SkipAuthorization = IsUnsecured; base.OnAuthorization(filterContext);}

Then, CustomAuthorizeAttribute performs the authorization check only if SkipAuthorization is false.
protected override bool AuthorizeCore(HttpContextBase httpContext){ if (httpContext.SkipAuthorization) { return true; } // Do any authorization logic here return httpContext.Request.QueryString["password"] == “password”;}

* Of course, never provide the password in the QueryString, it was made like that just for the ease of the example.

So now, when you try to invoke the secured controller, you get the HTTP error code 401: Unauthorized.

View the original article here

Authenticate user by roles in asp.net

Anand Narayanaswamy — Sat, 28 Aug 2010 15:15:33 +0000

Forms authentication enables user and password validation for Web applications that do not require Windows authentication. With forms authentication, user information is stored in an external data source, such as a Membership database, or in the configuration file for an application. Once a user is authenticated, forms authentication maintains an authentication ticket in a cookie or in the URL so that an authenticated user does not need to supply credentials with each request.
At my web site, I have a folder “Admin”, which I only want users with administration roles to be able to access them. I simply don’t want to check each user’s right on this folder, just depends on roles. This article is about this approach.
In my case, I don’t care who have logged into my website, if they are not logged in, they can only browse my web site; if they registered and logged in, they can do certain things, like add a fire panel, delete the fire panel they created; if users logged in with administration roles, web site will grant them rights to access files under “admin” folder.
Download the code, unzip it to a folder, create a virtual directory on IIS for it. Root directory contains “login.aspx”,”logout.aspx”,”default.aspx”, and a folder called “admin”, at “admin” there is only one file, “default.aspx”, this is the file I will stop normal user from accessing it.
Forms authentication include several important parts you need to implement.
At my web.config file I set Authentication mode to “Forms”.
At web.config, I create a folder that I want to authenticate user.
Like following: