This technique allows you to make your web sites faster and provide an easier (and better user experience).

Get the source code by clicking here.

After reviewing the needed calculations, my main issue was the NPV (Net Present Value); although I am familiar with the formula and applications of NPV, I was not sure of the exact implementation in Excel.

So, I jumped to Google to see if there was any implementations and found the Excel Financial Functions for .Net: “… a .NET library that provides the full set of financial functions from Excel.”.

Great! BUT. The library is actually implemented in F# and only the source code is provided, no compiled version…. No problem, since all .Net languages compile into IL (Intermediate Language), all I needed to do was to compile the F# project and then reference it on my C# one.

After I add ed the Financial.dll reference to my project (compiled version included in the provided source code), I am ready to use it on my code, however, note that the following reference is required:

using

System.Numeric;

With the reference in place, I can now use the NPV function as follow:

Comparing the signature of the NPV function on Financial.dll to excel, we can see they are virtually the same:

And even though I have shown mainly the NPV usage, this library contains implementation pretty much all financial functions in Excel (Complete List).

There you have it; if you ever have a project where you need to use Excel functions, you can refer t the Excel Financial Functions for .Net library; you can use the compiled library provided on this example, but I recommend reviewing the library page regularly to check for updates.

Hope this helps!

So this solution is practically unchanged compared to the original, however I did I introduced 2 improvements (which could also apply to the aspx version).

1. I realized after I did my original post that I was able to get data on the handler function from the ajax form; so I am no longer looking into the response div for my data (which was kind of a hack). Instead I am now using it properly by receiving the data directly.
2. I use a JsonStandardResponse, which I have been using in my projects succesfully and make things a bit easier. (See my previous post: Json Standard Responses for your Ajax Calls). So the controller action was changed to return JsonResult instead of a regular ActionResult with Content.

[HttpPost]
public JsonResult Edit(CarModel model) {
if (ModelState.IsValid)
{
CarModel car = CarRepository.GetCars().Where(c => c.Id == model.Id).FirstOrDefault();
car.Name = model.Name;
car.Description = model.Description;
return Json(JsonResponseFactory.SuccessResponse(car),JsonRequestBehavior.DenyGet);
}
else {
return Json(JsonResponseFactory.ErrorResponse("Please review your form"), 
            JsonRequestBehavior.DenyGet);
}
}

Notice that if the ModelState is valid I proceed with the change , and regurn a SuccessResponse, which includes the object car (this will get added to the standard json response).

return Json(JsonResponseFactory.SuccessResponse(car),JsonRequestBehavior.DenyGet);

If the state is not valid, we will return a ErrorResponse:

return Json(JsonResponseFactory.ErrorResponse("Please review your form"),
            JsonRequestBehavior.DenyGet);

With the Controller ready,  the UpdateSucces function (which is specified as the OnSuccess handler for the Ajax Form) is now as follow:

function updateSuccess(data) {
 if (data.Success == true) {
 //we update the table's info
 var parent = linkObj.closest("tr");
 parent.find(".carName").html(data.Object.Name);
 parent.find(".carDescription").html(data.Object.Description);
 //now we can close the dialog
 $('#updateDialog').dialog('close');
 //twitter type notification
 $('#commonMessage').html("Update Complete");
 $('#commonMessage').delay(400).slideDown(400).delay(3000).slideUp(400);
 }
 else {
 $("#update-message").html(data.ErrorMessage);
 $("#update-message").show();
 }
}

This, compared to the original implementation is much cleaner, because we get the data in json form directly in the function, and thanks to the JsonStandardResponse, I also get a copy of the updated object.

That is it. Those are the only two updates.

Download the Source Code.

Hope this helps!

— Disclaimer: I do not work for KendoUI (Telerik) and I am not getting anything in return for this entry… I just like the library

Over the past months I have been evaluating the KendoUI library and using it on my pet projects. I really like it, is evolving very fast and has good community around it.

KendoUI Grids are very flexible and can be used in many different ways. In this post I will show how you can get started with KendoUI grids on your ASP.NET MVC Projects., I will show you three different ways I have used them, which include Creating the Grid starting from a basic ASP.NET MVC List Template, Creating the grid over an empty div with a remote data source, and finally, how to create a grid using KendoUI templates.

These walk-troughs will cover most of the basics but are only intended to get you started; I encourage you to go to KendoUI.com and view all other options/configurations/methods available.

Download the Code

Method 1: Grid over Existing HTML

In this example, we start from the MVC List Template and convert it to a fully functional grid with pagination and sorting.

Method 2: Grid over an Empty Div

In this example, we start over an empty div and use a remote data source. We modify our controller to provide the required Json. The result is a grid that allows paging, sorting, grouping and filtering.

Method 3: Grid Using Templates

We start from the MVC Template List, and convert it to a Grid that uses remote data source and is fully functional. This is my prefer method because it provides  simplicity when modifying the grid presentation, and has the power of the remote datasource.

At the begining we use to send our responses as simple strings (true/false) or very customized Json responses. However, for the past year or so we’ve been using Standard Json Responses and it has been working great. I’ve passed this idea to a couple of friends and everyone seems to like it so here it is.

Objective & Advantages

The objective will be to have standard Json Responses to our AJAX calls that we can easily re-use accross our application, independent of what action or what objects we are working with… And by having and standard responses, we can have a standard way to handle them.

Download the Code

The JSON Response Factory

This is what we have been using to generate the Standard Response  (yes, is VERY simple) . By having the factory and reusing it across the application we are basically enforcing the standard:

public class JsonResponseFactory
{
 public static object ErrorResponse(string error) {
 return new { Success = false, ErrorMessage = error };
 }

public static object SuccessResponse() {
 return new { Success = true};
 }

public static object SuccessResponse(object referenceObject)
 {
 return new { Success = true, Object = referenceObject };
 }

}

The main thing to notice is that we are using dynamic objects; we do so (instead of a plain class) so we can easily return only what it is necessary.

Now let’s dig in. It is very simple, but lets pick it apart function by function:

public static object ErrorResponse(string error) {
return new { Success = false, ErrorMessage = error };
}

This function generates an object that has a Success flag, which is set to false (is an error), and an ErrorMessage. We force the error responses to have an error message, although you can chose to do it differently.

public static object SuccessResponse() {
 return new { Success = true};
 }

This is probably the simplest one, but one of the one we use the most. The function generates an object with Success equals to true and that is it. It is used a lot for functions such as “Delete”.

public static object SuccessResponse(object referenceObject)
 {
 return new { Success = true, Object = referenceObject };
 }

Finally there is the function that generates a response with a reference object inside. This function is useful when you need to send an object (Get type of funcitons).

The Controller: Let’s use those cool responses!

So now we know how to build our responses. Here is how you would send it back on your controller – you all probably already know

[HttpPost]
public JsonResult DeleteSuccess(int? id) {
 return Json(JsonResponseFactory.SuccessResponse());
}

[HttpPost]
public JsonResult DeleteError(int? id)
{
 return Json(JsonResponseFactory.ErrorResponse("Some Error... Can't delete!"));
}

[HttpPost]
public JsonResult GetCarSuccess(int? id)
{
 //NOTE: For this example I am using a dynamic object, but the idea is that it could be any object
 var car = new { Name = "Toyota Yaris", Price = "10000", Color = "Red" };
 return Json(JsonResponseFactory.SuccessResponse(car));
}

Now, notice that our functions are returning a JsonResults (I also specified the Verb (HttpPost), you can omit it if you want), but the magic happens here:

return Json(JsonResponseFactory.SuccessResponse(car));

Because “Json” takes any object and converts it into JSon, is basically allowing us to send anything we want back. In this example, we are returning a standard response,with a reference object (‘car’) in it and it will be converted into Json for us… that was easy

On the Client Side! Handle the Response

The server side is ready, now let’s see a sample of how to handle the response on the client side.

$(function () {
   $(".test-link").click(function (e) {
     e.preventDefault;
     $.post("controller/action", function (data) {
        if (data.Success == true) {
           alert("Success");
           if (data.Object != null){
              //here I could call the properties of my object, as below:
              alert(data.Object.Name); //assuming your object has a property name
            }
         }
         else {alert(data.ErrorMessage);}
       });
       return false;
    });
});

This code simulates a click event that posts into our controller using jQuery. Because the response (data) is automatically converted into an jQuery object, you can use it immediately. Notice that I am calling the property names that I assign on the factory such as “Success”, “ErrorMessage” and “Object”.
Inside the data.Object there will be any object that you specified on your server side code, and you can use it accordingly. In the snippet above, we are assuming the object will have a property called “Name”.
That is pretty much it! Simple, but it has saved us a lot of time. You can create your own standards, but the important thing is that it is maintained across your application and that the development team is made aware of it so they can quickly use it on their tasks.

The technique is simple; you dynamically load a partial view into the DIV dialog  . There are a few tricks to wire up the validation, and to identify success over failure. .

Get the source code by clicking here, take a look and let me know what you think.

Update: 

After many requests, I’ve created a Razor version, all interested can read the post here. 

Parser Error Message: The string ‘fb:like:layout’ contains too many device filters. There can be only one.

But first a bit of background: Addthis.com is one of the most popular widgets out there for social sharing. With a few simple clicks you can provide your users with the ability to easily share your content pretty much everywhere.

One of the features they offer is the ability to add the “Facebook Like” button, and for that, their code generator will give a snippet containing  something like this:

<a class="addthis_button_facebook_like" fb:like:layout="button_count"> </a>

What they are doing is passing extra information to their widget on how to display the facebook like button. However, IIS 7.0 seems to get confused by the colons in the attribute name (‘fb:like:layouts) and thows a parser error. Interestingly enough, this only happens when they are two colons in the attribute name; one colon will work (try it).

I did not have time to investigate the root cause of this; however I needed a quick fix, and it basically came to this: Add the property with Javascript!

1. Remove problematic the attribute from the tag, and add an id so you can recognize it later. The tag will then be as follow:

<a class="addthis_button_facebook_like" id="facebookLike"> </a>

2.  Now add some javascript to manually add the property, I am using  jQuery, and it looks like this::

$(function () { $("facebookLike").attr("fb:like:layout","button_count");});

That is it! A simple and fast work around

For reference:

• AddThis.com
• Facebook Social Widgets

Basically all you have to do is place an HTML file on your root folder with the following name: “App_Offline.htm”. Once the file is found, ASP.NET will shut-down the application and stop processing any incoming requests.  Once your down time is over, remove the file (or rename it to something like _App_Offline.htm) and your application will come back to life

Make sure your file should be at least 512 bytes otherwise you will get some IE errors (404 Errors) . The application still won’t process any requests, but the user will see an error. If your page is small and you don’t want to include more information than necessary, the trick is to include some commented code to your file to trick IE into thinking the file is bigger than it is.

Well, that is it. Better late than never I hope it helps people who might have missed this like my self.

In a nut shell, Silicon Halton is a group dedicated to connecting and creating strong and local relationships for hi tech entrepreneurs and leaders in the Halton region.

I have been attending Silicon Halton’s meetings (and un-meetings) for a few months now (http://www.siliconhalton.com/); I am both impressed and encouraged by the groups potential; obviously there is networking and the possibility of making new business connections, but the group also aims to play a role in the Halton business community as a whole… and that is what’s kept me going back!

Meet up #11 – Improving Silicon Halton’s Business Directory

The Topic

On meet up #11, we followed the un-meeting format again: I pitched the topic of Improving the Silicon Halton’s Business Directory. It proved to be a popular one attaining the most votes among all the topics suggested – and I winning me VMware t-shirt in the process J

The Problem

We are a group of IT Business in Halton region; however, there is no easy way for members or external users to find a suitable service provider within the group.

So the problem can be summarized as not having a useful Member Directory. This challenge came to me when one of my projects required some development on Silverlight; my first idea was to locate a member on Silicon Halton that could partner with me to be able to provide a solution. However, I was discouraged to notice that there wasn’t a member directory that could help me with the search.

At the same time, I realized that other members searching for my areas of expertise would have a hard time finding my company or me…

The Discussion

We started the discussion re-iterating the problem: The need for a member directory: this meant that members would have to build a searchable member profile; which we haven’t done .

However, not all the participants felt the pressing need of a business directory; so we quickly turned into proposing ways to utilize the Linked In Group so it would serve the purpose of a business directory.

Some of most relevant suggestions included:

• Post into the boards when looking for certain expertise.
• Create one single Discussion within the group where all the companies can post their profile. The discussion would be searchable, thus addressing the need of members to search for other members’ expertise.
• Create a Company Profile on Linked In, and join with it the Silicon Halton Group.
• Do Job Postings on Linked In that would only apply to a Group.
  Note: I investigated this point, and from the initial Job Post form, it does not seem possible.

Conclusions

These are some of the conclusions reached by the group:

• Linked In could be leveraged to find members by posting into the Discussion forums, improving personal profiles and creating company profiles.
• Company members need more opportunities to present their business to the group; either on LinkedIn or at Meetings, there is a need to know what each other do, so we can find points of collaboration and be able to provide referrals.
• While LinkedIn addresses the problems for Members, any external user/company looking for services will still encounter challenges when looking for specific providers.

—

Thanks to everyone that participated; the creativity and resourcefulness of the members came through but certainly the problem will not go away. Although it might not be a pressing need right now, in the future Silicon Halton should consider a business directory with full profiles to be able to properly showcase and promote their members.

Our Objective

When a user clicks the “Delete” button on a list (or elsewhere), we are going to show a confirmation dialog. If the user confirms, the record will be deleted. If he/she cancels, no action will be taken. In essence, this is what we are trying to do:

Requirements

To implement this solution you will need to have the jQuery and jQueryUI libraries.

Approach

1. Modify the repeater.

We will start by reviewing the code for a strongly-typed view for the “List” content; the repeater part looks like this:

<% foreach (var item in Model) { %>
<tr >
<td><%: item.Name %></td>
<td>
<%: Html.ActionLink(“Edit”, “Edit”, new {  id=item.Id  }) %> |
<%: Html.ActionLink(“Delete”, “Delete”, new { id = item.Id }, new { @class = “delete-link” })%>
</td>
</tr>
<% } %>

This is pretty much what is automatically generated, with the difference that I have added a class to the delete action link (bolded above). These will help me identify the object with jQuery.

The repeater above generates the following HTML:

<tr>
   <td>Item 1td>
   <td>
      <a href="/Brand/Edit/18">Edit</a> |
      <a class="delete-link" href="/Brand/Delete/18">Delete</a>
    </td>
</tr>    

Notice that the Delete link is already pointing to the Controller/Action we want.

2. Add the confirmation message

You will need to add a div tag with the confirmation message to display, simply add this:

<div id="delete-dialog" title="Confirmation">
<p>Are you sure you want to delete this Brand?</p>
</div>		

You can change the title of the confirmation box by changing the “Title” property on the div.

3. Add the jQuery

This jQuery can be added in individual pages, in my case I added it on the Master Page so it would be reusable across many pages.

Let’s go by steps; first we need to override the delete link behaviour. Here is how:

var deleteLinkObj;
// delete Link
$('.delete-link').click(function () {
    deleteLinkObj = $(this);  //for future use
    $('#delete-dialog').dialog('open');
    return false; // prevents the default behaviour

});

The snippet above is basically overriding the default functionality of all objects that have the class “delete-link”. Now, instead of directing to the specific controller/action, it will open a dialog (with ID “delete-dialog” -> the div we added on step 2).

Notice we are storing the clicked object on a variable; this is so the dialog knows which link was the one clicked.

Now we need to initialize the Dialog and its behaviour. Here we go:

$('#delete-dialog').dialog({
  autoOpen: false, width: 400, resizable: false, modal: true, //Dialog options
  buttons: {
     "Continue": function () {
          $.post(deleteLinkObj [0].href, function (data) {  //Post to action
             if (data == '<%= Boolean.TrueString %>') {
                deleteLinkObj.closest("tr").hide('fast'); //Hide Row
                //(optional) Display Confirmation
             }
             else {
                //(optional) Display Error
             }
            });
          $(this).dialog("close");
       },
      "Cancel": function () {
          $(this).dialog("close");
          }
      }
 });

Let’s brake it down to the important parts:

$.post(linkObj[0].href, function (data) {…

What we are doing here is posting into the objects href attribute which is something like /Brand/Delete/18. So we are posting to the Delete action of the Brand controller with an specific ID. The controller as we will see next, will return on the data either True or False, indicating success/failure.

When the post is successful, we now need to remove the item from the list. We do it with this simple line:

linkObj.closest(“tr”).hide(‘fast’);

What we are doing is locating the closes tr parent, and hiding it… Simple! (You’ve got to love jQuery).

4. Prepare the controller

Your page is now ready, but we need to add the logic on the controller action; there is not view related to the delete action, so you only need to implemented the HttpPost action. This is actually very simple, in my case, here is how I do it:

[HttpPost]
        public ActionResult Delete(int id)
        {
            try
            {
                BrandRepostory rep = new BrandRepostory ();
                rep.DeleteById(id);
                return Content(Boolean.TrueString);
            }
            catch
            {//TODO: Log error				
                return Content(Boolean.FalseString);
            }
        }

That is it! This implementation is highly reusable, just remember to:

1. Mark the delete button with the class
2. Add the div for the confirmation message
3. Make sure the javascript code is available for the pages you need.
4. Implement the controller action

Hope this helps.. Get Source Code

UPDATE! Related Post: Editing rows with the jQueryUI Dialog Form and Ajax