A partial view in ASP.NET MVC3 needs to be refreshed on every particular interval.

Let us take a typical ASP.NET MVC3 application. In the HomeController, there is a action called “Quote” which displays funny software quote for every new request like below:

public class HomeController : Controller
{
	public static string[] quotes = {
		"The first 90% of the code accounts for the first 90% of the development time. The remaining 10% of the code accounts for the other 90% of the development time",
		"In order to understand recursion, one must first understand recursion",
		"I have always wished for my computer to be as easy to use as my telephone; my wish has come true because I can no longer figure out how to use my telephone.",
		"The gap between theory and practice is not as wide in theory as it is in practice.",
		"Nine people can’t make a baby in a month"
	};

	// other actions

	public ActionResult Quote()
	{
		var r = new Random();
		var rv = r.Next(0, 4);
		ViewBag.Quote = quotes[rv];
		return PartialView("_Quote");
	}
}

The partial view “_Quote.cshtml” has nothing other than the code below

<h3>@ViewBag.Quote</h3>

This whole thing needs to be refreshed without any user interaction on every 10 seconds

Solution

Use setInterval() at client side and set up OutputCacheAttribute on the respective action. The duration should be same on both side.

In the corresponding script of this view, place the below JavaScript:

// jQuery used

setInterval("$('#quote').load('/home/quote')", 10000); // every 10 sec

In the main view, create a div with id “quote” like:

In the action method set the OutputCacheAttribute like:

[OutputCache(NoStore=true, Location = OutputCacheLocation.Client, Duration = 10)] // every 10 sec
public ActionResult Quote()
{
...
}

CodeProject

public class FruitModel...
        public string Name { get; set; }
        public bool IsFresh { get; set; }
        public bool IsPacked { get; set; }
		public decimal UnitPrice { get; set; }

The UI for this scenario is shown below:

Leave the top and bottom “Lorem ipsum” text, these are just gap fillers.  The user can change the “IsFresh” and “IsPacked” settings of the fruits and the unit prices.

Challenge

This post addresses the following simple problems when using ASP.NET MVC3:

• Sending back collection of data to a MVC action
• Also send back additional parameter(s) to the same MVC action
• Sending back read-only data
• By Ajax

Solution

public ActionResult Index()...
	List<FruitModel> collection = new List<FruitModel>()
	{
		new FruitModel {Name = "Apple", IsFresh=true, IsPacked=false, UnitPrice = 10M},
		new FruitModel {Name = "Orange", IsFresh=false, IsPacked=false, UnitPrice = 5M},
		new FruitModel {Name = "Strawberry", IsFresh=true, IsPacked=true, UnitPrice = 15M}
	};
	ViewBag.NetAmount = IncludeTax(collection.Sum(fm => fm.UnitPrice));
	ViewBag.ShopId = Guid.NewGuid();
	return View(collection);

</div>
<div>
<pre><h2>Welcome to Fruit Shop</h2>
<div>Lorem ipsum... </div>
<div>
	@Html.Partial("_Fruit", (List<MvcApplication1.Models.FruitModel>)Model)
</div>
<div id="netAmountDiv" name="netAmountDiv" style="color:Blue">
	Net Amount: @ViewBag.NetAmount
</div>
<div>Lorem ipsum...</div>

Simply passing the Model in @Html.Partial(…) will throw the error “‘System.Web.Mvc.HtmlHelper<dynamic>’ has no applicable method named ‘Partial’ but appears to have an extension method by that name. Extension methods cannot be dynamically dispatched. Consider casting the dynamic arguments or calling the extension method without the extension method syntax.”.  So, cast it to appropriate type, here List<MvcApplication1.Models.FruitModel>.

</div>
<div>
<pre>@model List<MvcApplication1.Models.FruitModel>

@using (Ajax.BeginForm(new AjaxOptions
        {
            HttpMethod = "Post",
            UpdateTargetId = "netAmountDiv"
        }
))
{

<table>
    <tr>
        <th>
            Name
        </th>
        <th>
            IsFresh
        </th>
        <th>
            IsPacked
        </th>
        <th>Unit Price</th>
    </tr>

@for (int i = 0; i < Model.Count; i++)
{
    <tr>
        <td>
            @Html.DisplayFor(modelItem => Model[i].Name)
            @Html.HiddenFor(modelItem => Model[i].Name)
        </td>
        <td>
            @Html.EditorFor(modelItem => Model[i].IsFresh)
        </td>
        <td>
            @Html.EditorFor(modelItem => Model[i].IsPacked)
        </td>
        <td>
            @Html.EditorFor(modelItem => Model[i].UnitPrice)
        </td>
    </tr>
}

</table>
        <input type="hidden" id="shopId" name="shopId" value="@ViewBag.ShopId" />
        <div>
		    <input name="submitFruit" type="submit" value="Change" />
	    </div>
}

</div>
<div>
<pre><td>
	Apple
	<input name="[0].Name" type="hidden" value="Apple" />
</td>
<td>
	<input checked="checked" class="check-box" data-val="true" data-val-required="The IsFresh field is required." name="[0].IsFresh" type="checkbox" value="true" /><input name="[0].IsFresh" type="hidden" value="false" />
</td>
<td>
	<input class="check-box" data-val="true" data-val-required="The IsPacked field is required." name="[0].IsPacked" type="checkbox" value="true" /><input name="[0].IsPacked" type="hidden" value="false" />
</td>
<td>
	<input class="text-box single-line" data-val="true" data-val-number="The field UnitPrice must be a number." data-val-required="The UnitPrice field is required." name="[0].UnitPrice" type="text" value="10.00" />
</td></pre>
</div>
<div>

submitFruit=Change&[0].Name=Apple&[0].IsFresh=true&[0].IsFresh=false&[0].IsPacked=false&
[0].UnitPrice=10.00&[1].Name=Orange&[1].IsFresh=false&[1].IsPacked=true&[1].IsPacked=false&
[1].UnitPrice=5.00&[2].Name=Strawberry&[2].IsFresh=true&[2].IsFresh=false&[2].IsPacked=true&
[2].IsPacked=false&[2].UnitPrice=25&shopId=c9517c6b-c911-4a28-9a0a-3e47ccb60bd8&X-Requested-With=XMLHttpRequest

• Used List<T> for @model instead of IEnumerable<T>, hence I can use Count property.
• Used for i = 0…List<T>.Count instead of foreach.

</div>
<div>
<pre>[HttpPost]
public ActionResult Index(Guid shopId, List<FruitModel> collection)...
	decimal addlTax = 0M;
	if (collection.Any(fm => fm.UnitPrice > 200)) addlTax += 2M;
	return Content("Net Amount: " + IncludeTax(collection.Sum(fm => fm.UnitPrice) + addlTax).ToString());</pre>
</div>
<div>

CodeProject

In theory, theory and practical are the same.  In practice, they are not

We have to compromise “persistence agnostic domain model” principle.  This is happened even with popular frameworks ActiveRecord (Rails) and Entity Framework (.NET) too.  I skip the compromise part as of now.

In Azure, you have two choices to persist objects.  One is table storage and another one is SQL Azure.  Typically, Web 2.0 applications use mixed approach like frequently used read-only data on NOSQL and source of truth is on relational data stores (CQRS).  This would be recommended when your application is running on Cloud, because every byte is billable and metered.  In this article, I brief the concerns when you are choosing Table Storage as source of truth.   Would Azure Table Storage be a good choice for domain object repository?  Though this is not the time to say “Azure Table Storage for domain object-repository should be highly recommended, partially or completely avoided” kind of opinions, but I can share some of the experiences with Azure Table Storage.

Due to high performance, Azure axes some NOSQL features those are typically available in other NOSQL products.  This seems like to get the ambitious mileage advertised for a bike, bike companies said you should drive on such a road, wheather and load conditions.

I have used the famous Customer-Order domain model in this post as shown in below figure.

The actual classes are:

public class Customer
{
public int Id { get; set; }
public string Name { get; set; }
public string City { get; set; }

List<Order> GetOrders(criteria)...
}

public class Product
{
public int Id { get; set; }
public string Name { get; set; }
public double UnitPrice { get; set; }
}

public class Order
{
public int Id { get; set; }
public DateTime QuotedAt { get; set; }
public int Status { get; set; }
public int CustomerId { get; set; }
public List<OrderLine> OrderLines;

public double CalculatePrice()...
}

public class OrderLine
{
public int Id { get; set; }
public Product ProductId { get; set; }
public double Quantity { get; set; }
public int OrderId { get; set; }

public double CalculatePrice()...
}

Is Key-Value Data Store Enough?

Key-Value based data stores are the actual starting point of NOSQL revolution, later Document based data store has been widely adopted for object persistence.  Document data store has the capability to persist an object (complex data type) against a key, however Key-Value data store can persist only scalar values.  This means that the Key-Value’s entity model is very much like relational representation (primary key – foreign key and link table), instead in Document data store, we have the choice to embed object into another object.  In the above example, Customer’s Order object can be embedded within Customer, and OrderLine and Product would be by reference. However, Azure Table Storage is just Key-Value data store.  You still have to provide meta-data for referential integrity.

Am I smart enough on “Partition Key” decision?

Physical location of a table in Azure (and all other NOSQL data stores too) is based on Partition Key (In Mongo DB, Sharding Key) selection.  You can get the “indexing” like faster query result only when you give partition key and row key.  Hence, the partition key selection is one of the architectural decision for a cloud application.  How smart you are to choose the right partition key is matter here!  In the Customer-Order, we can simply choose the following as partition key for the respective tables:

• Customer – first letter of Name in upper case
• Product – first letter of Name in upper case
• Order – again use the partition key of the customer, since Order is always made by a customer.
• OrderLine – either use Order table partition key or Product table partition key.  If we choose Order table, the OrderLine table partition will use Customer table partition key.

The below figure depicts how these tables would be distributed in a data center with four nodes.

Now the concerns are:

Is table partitioning happening always or based on capacity? Typically, NOSQL data stores (like Mongo) starts “sharding” when running out of drive capacity in the current machine. It seems very optimal way.  However, there is no clear picture on Azure table storage’s sharding.

Data store is even smarter than me when sharding.  In Mongo DB, it only asks table object property or properties as as “Sharding” key.  Based on the load, these data stores scales out data across servers.  The sharding algorithm intelligently split the entities between the available servers based on the values in the provided “Sharding” key.  However, Azure asks the exacts value in the partition key and it groups entities those have same value.  Azure does not give the internals of how does partitioning happens.  Will it scale-out on all the nodes in the data center? or limit to some numbers?  No clear pictures though.

What will happen if entities with same partition key on the single table server run out storage capacity? Do not have a clear picutre.  Some papers mentioned that table server is the abstraction and called as “access layer”, which in turns has “persistent storage layer” which contain scalable storage drives. The capacity of the drives will be increased based on the current capacity of the storage for a table server.

Interestingly, I found a reply in one of the Azure forum for a similar question (but quoted couple of years before):

Since, based on the size of data we don’t know how many actuals table servers will be created for a table.  Assume, a business which needs more Orders for a limited Products and small Customers should have largely scaled out Order and OrderLine table.  But, here these two tables are restricted by small Customer table.  A web 2.0 company may need more products and customers which linearly have very large Order and OrderLines.  If this scaled out on large number of table servers, co-location between OrderLine and Product should be important as well for Customer-Order association.  If  Azure table storage scale-out algorithm does the partitioning based on the knowledge of that table only, then unnecessary network latency will be introduced.

Is ADO.NET Data Service Serializer enough for the business?

Enumeration are very common in domain models.  However, ADO.NET data service serializer does not serialize it.  Either we need to remove enumerated properties or to write custom serializer.

Final Words

So, you can either teach me your knowings of the abvoe concerns or stack your concerns up in this post.
CodeProject

Environment

I believed that Windows Virtual PC could be the only choice to install Win8DevPrew.  However, it throws “This 64-bit application couldn’t load because your PC doesn’t have a 64-bit processor” error message during the setup.  Later, I came to know from Adrian’s ZDNet blog post (http://snip.udooz.net/p8pUX1) that Virtual Box is the only and best choice.  He explained the various settings you should do before installing Windows 8 on Virtual Box.

Note that allocate at least 25 GB for VDI, 2 GB RAM and 30 MB for Video RAM in the Virtual Box settings.

Installing

The installation overall took 30 minutes, here some screen shots:

Post to the installation, you have to create an user account as shown in the below figure.

Starting Windows

After completing the installation, Windows 8 takes 19 seconds to load. You will see a full-screen wallpaper as shown below.

You get a feel of using Mobile operating system.  You have to drag this screen to see the login screen as like below.

So, “touch” is the main user input medium for Windows 8, though mouse and keyboard are available.  After the successful login, you will see the “Metro” styled start screen.

By tapping the “Computer” tile (in the above figure – not shown), you can see the classic explorer window and start menu as well, but again, tiles are the main interface to access all the features in Metro style.

Ok….Let me explore more before writing more about Windows 8.
CodeProject

An Azure web role consists of two logical parts in the assembly, one is RoleEntryPoint implementation and another one is your actual web application.  Your typical Azure web role has:

• Web role lifecycle code (RoleEntry – OnStart, OnRun and OnStop) and Service model (csdef and cscfg)
• Web application code and web configuration (web.config)

In HWC, both Web role and web application logical artifacts are resided in a single process (WaWebHost.exe) as shown in figure 1. In the new full IIS capability feature, web role artifacts are loaded into a process called WaIISHost.exe.  The web application code as usual in w3wp.exe.  This is shown in figure 2.

This creates some culture changes in the approach previously we did.  I have experimented only on DevFabric and yet to test on Azure.  Probably, I’ll update later.  The changes are:

• Process with different accounts.  WaIISHost and w3wp are now running in two different account privileges.  Generally, WaIISHost runs in higher privilege and this would cause some code in your web application which was previously enjoyed this high privilege benefit.  For example, you can create or access an machine level environment variable from your web application in HWC mode.  In Full IIS, this makes exception.
• Global Configuration Setting Publisher.  In HWC, it is enough to initialize global configuration setting publisher once in RoleEntryPoint.OnStart().  However, now in two different process, you have to again set the publisher either in your framework start up or Application_Start(), otherwise it throws an exception with message “SetConfigurationSettingPublisher needs to be called before FromConfigurationSetting can be used”.  Instead of held up with two different initialization, CloudStorageAccount.Parse() is quite simple and elegant.  It just want the connection string detail as a string which can be provided by RoleEnvironment.GetConfigurationSettingValue(…).  This is safer too.
• Application_End will not be encountered.  In Full IIS, Application_End() will never be called when you stop the debugging as like you normally did in HWC.
• Static variables in RoleEntryPoint is not accessible from your web application.  Since, these two applications are running in two different process, sharing objects through static variable is not possible in Full IIS.  Instead, try to use machine level environment variable or local resource.

CodeProject

Once you specify the scenario in your application (i.e. appropriate URLs), a number of virtual clients from various client machines  will visit the URL with appropriate request data.  Like other performance tools, the following players are involved in a performance testing:

• Server – machines on which your web application components are running
• Client – A virtual client on a machine which acts as end-user to visit the URL
• Controller – This coordinates a test among the virtual clients on various machines.  It also capture and collate the performance counters from appropriate servers.

I’ve created a small ASP.NET MVC3 application with following actions:
* http://localhost/myapp/load/create – to insert a simple “comment” field  value into the database (using POST data COMMENT =  “<value>”)
* http://localhost/myapp/load – to lists all comments

WCAT uses Windows Scripting and you can use JavaScript syntax to define the scenario for your test.  Below is a sample scenario in a file scenario.ubr:

scenario
 {
 name    = "IIS Home Page";

warmup      = 30;
 duration    = 50;

default
 {
 // send keep-alive header
 setheader
 {
 name    = "Connection";
 value   = "keep-alive";
 }

// set the host header
 setheader
 {
 name    = "Host";
 value   = server();
 }

// HTTP1.1 request
 version     = HTTP11;

// keep the connection alive after the request
 close       = ka;
 }

//
 // This script is made for IIS7
 //
 transaction
 {
 id = "My App Load Test";
 weight = 1;

request
 {
 url = "/myapp/load/create";
 verb = POST;
 postdata = "Comment=Tested";
 statuscode= 200;
 }

request
 {
 url         = "/MyBooks/load";
 statuscode  = 200;
 }

close
 {
 method      = reset;
 }
 }
 }

A scenario file normally contains warmup time (ramp up), test duration, cooldown time (ramp down).  The default section enables you to specify default HTTP headers for the test.  The transaction section is used to specify the actual business scenarios.  The weight property is used to set the priority of this transaction.  The request section is used to specify individual page request in the transaction.  A “request” contains

• URL of the page
• Optionally the HTTP verb (default GET).  In case of posting data, you have to specify the POST as verb.
• POSTDATA for POST
• Status code which is normally 200, but for some cases you may need to specify 300 or 302 for moving request

The other test details like servers and client machine names,  number of virtual clients, performance counters can be specified to WCAT through another script file called “setting file”.  Below is a sample setting file named “setting.ubr”:

settings
 {
 clientfile     = "scenario.ubr";
 server         = "localhost";
 clients        = 2;
 virtualclients = 10;

counters
 {
 interval = 10;

counter = "Processor(_Total)\\% Processor Time";
 counter = "Processor(_Total)\\% Privileged Time";
 counter = "Processor(_Total)\\% User Time";
 counter = "Processor(_Total)\\Interrupts/sec";

counter = "Memory\\Available KBytes";

counter = "Process(w3wp)\\Working Set";

counter = "System\\Context Switches/sec";
 counter = "System\\System Calls/sec";

counter = "Web Service(_Total)\\Bytes Received/sec" ;
 counter = "Web Service(_Total)\\Bytes Sent/sec" ;
 counter = "Web Service(_Total)\\Connection Attempts/sec" ;
 counter = "Web Service(_Total)\\Get Requests/sec" ;
 }

// other settings
 }

A setting file usually contains the following:

• The scenario file the clients need to execute
• Server machines
• Number of physical client machines for this test
• Number of virtual clients for this test
• Performance counters
• Registry settings

Note that you can use any file extension for scenario and setting files.  I have followed the convention”ubr” is used in WCAT sample.

Initial Setup

1. Download the tool from http://snip.udooz.net/wcat63.   It has x64 version also.
2. Add the installed folder path into system PATH.

This setup has following three exeutables and one Windows script file along with documentation and samples folders:

• wcctl.exe – controller
• wcclient.exe – client
• wcutil.exe – small utility to view a brief report of a test
• wcat.wsf – used to update, terminate and run wcclient on various client machines.

Initially, you need to update WCAT setup on all client machines by

 wcat.wsf –terminate –update –clients {comma separated list of WCAT client machines}

Steps for the Testing

To perform a test, you need a machine for “controller”, one or more machines for “clients” and the server machines.  You can do the testing even within a single machine by specifying “localhost”.

1. Once you prepare the scenario and setting files, create a folder  in the controller machine for your test and copy these files on to it.
2. Open the command prompt as Administrator.
3. Run wcctl -t scenario.ubr -f settings.ubr -x on the controller machine.  The output will be like

4. Run wcclient.exe on all client machines.

After the test run, the output in the controller command prompt would be like

After all the test run completed, result will be stored in log.xml file in the controller’s  machine current directory.  WCAT has a XSLT “report.xsl” to transform this XML into readable in its installed folder.  Copy the file into log.xml.  Open the log.xml in the browser to see the output.  A part of log.xml file is

<?xml version='1.0'?>
 <?xml-stylesheet type='text/xsl' href='report.xsl'?>
 <report name="wcat" version="6.4.0" level="1" top="100">
 <section name="header" key="90000">
 ...

<item>
 <data name="counter" >\Processor(_Total)\% Processor Time</data>
 <data name="avg" >1.82</data>
 <data name="min" >1.82</data>
 <data name="max" >1.82</data>
 <data name="delta" >0.00</data>
 <item>
 <data name="time" >0.00</data>
 <data name="current" >1.82</data>
 </item>
 </item>
 <item>
 <data name="counter" >\Process(w3wp)\Private Bytes</data>
 <data name="avg" >98455552.00</data>
 <data name="min" >98455552.00</data>
 <data name="max" >98455552.00</data>
 <data name="delta" >0.00</data>
 <item>
 <data name="time" >0.00</data>
 <data name="current" >98455552.00</data>
 </item>
 </item>
 </table>

...
 </report>

Final Words

WCAT might not help to test an entire application which normally has so many user interaction which are not simply captured by single POST request.  However, it would help to perform load testing on every atomic part of your application or to perform technology evaluation as part of prototype engineering.
CodeProject

URL: http://wiki.sharpdevelop.net/ilspy.ashx

• Facebook account (of course you should be the one in the 10% of world population )
• A Facebook application (which could be in sandbox mode), so you should have App ID, App Secret and Callback URL
• A Rails application in your local machine and the Facebook app pointed to this as http://localhost:3000 (default port for Mongrel or WEBrick)

Installing Koala

Install Koala gem from https://github.com/arsduo/koala by using sudo gem install koala –pre

Configuring Koala

Create facebook.yml in /config with the following content

# config/facebook.yml
development:
 app_id: 184xxxxxxxxxxxx
 secret_key: 80xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 callback_url: http://localhost:3000/
test:
 ...
production:
 ...

Add the following in config/environment.rb

# config/environment.rb
# in Rails::Initializer.run do |config|
config.action_controller.allow_forgery_protection = false
config.gem "koala"

The first line enables Facebook callback to your server.  The following line adds koala gem into this application.

Create koala.rb in /config/initializers with the following content

# config/initializers/koala.rb

module Facebook
 CONFIG = YAML.load_file(Rails.root + "/config/facebook.yml")[Rails.env]
 APP_ID = CONFIG['app_id']
 SECRET = CONFIG['secret_key']
 CALLBACK_URL = CONFIG['callback_url']
end

Koala::Facebook::OAuth.class_eval do
 def initialize_with_default_settings(*args)
 case args.size
 when 0, 1
 raise "application id and/or secret are not specified in the config" unless Facebook::APP_ID && Facebook::SECRET
 initialize_without_default_settings(Facebook::APP_ID.to_s, Facebook::SECRET.to_s, Facebook::CALLBACK_URL.to_s)
 when 2, 3
 initialize_without_default_settings(*args)
 end
 end

 alias_method_chain :initialize, :default_settings
end

The above code loads the Facebook.yml settings into Facebook, so you can access AppID, AppSecret and CallbackURL anywhere in your application in an unified way.  The following OAuth extension method is taken from Koala guidance to simplify the instantiation of OAuth.new.

Controller Part

In ApplicationController, add the following

#app/controller/application.rb

# protect_from_forgery

before_filter :parse_facebook_cookies
def parse_facebook_cookies
 @facebook_cookies = Koala::Facebook::OAuth.new.get_user_info_from_cookie(cookies)
end

Note that protect_from_forgery has been commented.  The following instructions, let this application load OAuth details from cookies for getting Facebook access token.

Your Login Page

Add the following on your login page layout, in this case /app/views/layout/login.html.erb

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en"
 xml:fb="http://www.facebook.com/2008/fbml">
<head>
 <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
 <title>Udooz Sample</title>
 <script type="text/javascript" src="http://connect.facebook.net/en_US/all.js"></script>
</head>
<body>

<p style="color: green"><%= flash[:notice] %></p>
<div id="fb-root"></div>

<script type="text/javascript">
 FB.init({
 appId  : '<%= Facebook::APP_ID %>',
 status : true, // check login status
 cookie : true, // enable cookies to allow the server to access the session
 xfbml  : true  // parse XFBML
 });

 FB.login(function(response) {
 if (response.session) {
 location.href = '/home'
 } else {
 // user cancelled login
 }
});
</script>
<h1>udooz</h1>
</body>
</html>

In this example, I’ve used Facebook JavaScript SDK for login screen.  To use this, I’ve include FBML scheme in <html> as xml:fb=”http://www.facebook.com/2008/fbml” followed by referring Facebook SDK script file.

You Home Page

In your home page, add the following things.

In app/controllers/HomeController.rb

class HomeController < ApplicationController
  def index
    graph = Koala::Facebook::GraphAPI.new(@facebook_cookies["access_token"])
    @likes = graph.get_connections("me", "likes")
  end
end

In the above code, new Graph instance has been created.  By using this, I’ve invoked the currently logged in user’s likes.

In app/views/home.html.erb

<table border="0">
 <% if @likes %>
 <% for like in @likes %>
 <tr>
 <td><b><%=h like["name"]%> </b></td>
 </tr>
 <tr>
 <td><%=h like["category"] %></td>
 </tr>
 <tr>
 <td>&ndash;</td>
 </tr>
 <% end %>
 <% end %>
</table>

Now, run your application.  Hope it would be easy.
CodeProject

In the STS’s configuration file, it is mentioned in <message> element. 

 

<system.serviceModel>
  <services>
   <service name="Udooz.SecurityTokenService" behaviorConfiguration="stsBehavior">
    <endpoint contract="Udooz.ISecurityTokenService" binding="wsHttpBinding" bindingConfiguration="stsBinding"/>
   </service>
  </services> 

<bindings>
   <wsHttpBinding>
    <binding name="stsBinding">
     <security mode="Message">
      <message clientCredentialType="UserName" />
     </security>
    </binding>
   </wsHttpBinding>
  </bindings> 

The STS service contract is declared in Udooz.ISecurityTokenService and implementation is resided in Udooz.SecurityTokenService. 

The message security mode is specified in <binding>..<wsHttpBinding>..<binding name=”stsBinding”>…<security>.  

This is specified in the <serviceBehaviors> section named “stsBehavior”. 

 

<behaviors>
   <serviceBehaviors>
    <behavior name="stsBehavior">           
     <serviceCredentials>
                 <userNameAuthentication
              userNamePasswordValidationMode="Custom"
              customUserNamePasswordValidatorType="UdoozCommonLib.STSUsernamePasswordValidator, UdoozCommonLib"/>
            <serviceCertificate findValue="WCFServerKey" x509FindType="FindBySubjectName" storeLocation="LocalMachine" storeName="My" />           
     </serviceCredentials>
    </behavior>
   </serviceBehaviors>
  </behaviors 

The username-password authentication is done by UdoozCommonLib.STSUsernamePasswordValidator class in UdoozCommonLib assembly. 

To be continued…
CodeProject