var anonymous= function(){
    alert("Test123");
};
anonymous();

Pretty simple, isn’t?

From here you can have more complex prototype (Javascript class mechanism).

function MyClass(val1, val2){
    this.val1 = val1;
    this.val2 = val2;
    this.function1 = function()
    {
        alert(this.val1);
    }
}
//...
var x = new MyClass('Test','Hello');
x.function1();

This example show you that you can have an anonymous function that can be called later like the previous example.

<a href='javascript:MyFunction(1,2,3)'>Click me</a>

To avoid this kind of behavior, which is not very clean, is to simply use the onclick attribut which is dedicated to receive Javascript’s call.

<a href='#' onclick="MyFunction(1,2,3);return false;">Click me</a>

As you can see, the onclick contain also a second Javascript’s statement which indicate the to the browser to not execute the link in the href attribute (the hash tag). This will prevent the browser to scroll up. In fact, you could specify a page to go if something goes wrong with the Javascript or if the user doesn’t have Javascript enable.

<a href='fallbackpage.html' onclick="MyFunction(1,2,3);return false;">Click me</a>

In that case, if Javascript is disable, the user will be redirected to the “fallbackpage.html”.

You can also not systematic use the `return false` and simply use directly the return of your function.

<a href='nextpage.aspx' onclick="return MyFunction(1,2,3);">Click me</a>

In that case, this will call the MyFunction fonction and if the result is false will do nothing with the navigation and if true will move the user to “nextpage.aspx”. This can be interesting in a scenario where you need to have to confirm something with the user or if you need to validate data before moving to the next step.

[HandleError]
public class MyController : Controller
{
}

You can take care of specific error by specifying one or many type of exception that you want to handle. To do, simply add the property ExceptionType at your HandleError level.

[HandleError(ExceptionType = typeof(SqlException))]
public class MyController : Controller
{
}

If you need to handle multiple exception, you will need to use multiple attributes.

[HandleError(ExceptionType = typeof(SqlException))]
[HandleError(ExceptionType = typeof(NullReferenceException))]
public class MyController : Controller
{
}

You can also in HandleError attribute specify what view to display.

[HandleError(ExceptionType = typeof(SqlException), View="SqlView")]
public class MyController : Controller
{
}

If you do not specify any view, the exception will be viewed in the default error page. At first, it will check for Error.aspx in the Views folder associated with the Controller and then go see in the Shared folder.

Now you have the control to display specific exception to a specific view, others errors to the generic error page or to do not use anything and use the default ASP error page (yellow page of death) by setting the customErrors to off in the web.config file.

The class contains many Action method that are overloaded with many parameters. The one that interest us has 4 parameters.

public string Action(string actionName, string controllerName, object routeValues, string protocol)
{
//...
}

The first parameter is the action name to which you want to have the url. The second one is the controller name. This one can be NULL if you use it inside a controller and want to have the url with the same url. If you are inside the action X or the controller Y and you put NULL, you will get a url for the controller Y. The route values doesn’t interest us in this case. You can pass NULL. The last parameter is the protocol. When you provide a procotol, the url returned by the Action method will contain a full absolute url. A trick is to use Request.Url.Scheme which will use the current protocol used by the method that has been called by the controller. That mean that if you are using HTTP that the url formed will have the same protocol, HTTP. Samething if the request would have been done by a HTTPS request, the formed url would contain HTTPS.

We can take a look inside Asp.Net MVC source code and see that the Action method with 4 parameters call GenerateURL with a lot of parameters.

        public string Action(string actionName, string controllerName, object routeValues, string protocol) {
            return GenerateUrl(null /* routeName */, actionName, controllerName, protocol, null /* hostName */, null /* fragment */, new RouteValueDictionary(routeValues), RouteCollection, RequestContext, true /* includeImplicitMvcValues */);
        }

The GenerateUrl method check the protocol and if not NULL will build the absolute URL.

public static string GenerateUrl(string routeName, string actionName, string controllerName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, RouteCollection routeCollection, RequestContext requestContext, bool includeImplicitMvcValues) {
            string url = GenerateUrl(routeName, actionName, controllerName, routeValues, routeCollection, requestContext, includeImplicitMvcValues);

            if (url != null) {
                if (!String.IsNullOrEmpty(fragment)) {
                    url = url + "#" + fragment;
                } 

                if (!String.IsNullOrEmpty(protocol) || !String.IsNullOrEmpty(hostName)) {
                    Uri requestUrl = requestContext.HttpContext.Request.Url;
                    protocol = (!String.IsNullOrEmpty(protocol)) ? protocol : Uri.UriSchemeHttp;
                    hostName = (!String.IsNullOrEmpty(hostName)) ? hostName : requestUrl.Host;

                    string port = String.Empty;
                    string requestProtocol = requestUrl.Scheme;

                    if (String.Equals(protocol, requestProtocol, StringComparison.OrdinalIgnoreCase)) {
                        port = requestUrl.IsDefaultPort ? String.Empty : (":" + Convert.ToString(requestUrl.Port, CultureInfo.InvariantCulture));
                    } 

                    url = protocol + Uri.SchemeDelimiter + hostName + port + url;
                }
            } 

            return url;
        }

So, that mean that if you want to have your action method to get an absolute URL you would need to call:

return Json(new JsonResponse { url = Url.Action("MyActionOfThisController", null, null, Request.Url.Scheme)});

  @Html.Telerik().Grid<YourObjectType>().Editable(e=>e.InsertRowPosition(GridInsertRowPosition.Bottom))

This is a short snippet of code to demonstrate how to add a row at the bottom of a grid with Telerik Grid.

Of course, to the button to add a new row you need to use the ToolBar method to add a command to insert. This is done by adding ToolBar method to the Telerik().Grid().

.ToolBar(c=> c.Insert().ButtonType(GridButtonType.Text))

public class Person
{
    public string Name { get; set; }
}

The example above could display the word “Name” in a localized string, which is not what we want. But, if we use the Display data annotation attribute, it’s possible to localize the property Name.

public class Person
{
    [Display(ResourceType = typeof(ResourceFileTypeHere), Name="NamePropertyKey")]
    public string Name { get; set; }
}

This will search inside the resource specified the key inside the Name attribute. That’s it, you have your property localized.

Here is an example:

public class Person
{
    [Required(ErrorMessage="FirstName is required")]
    public string FirstName { get; set; }
    //...
}

If you want to have the Data Annotation translated in many languages, you should use two others properties that are : ErrorMessageResourceType and ErrorMessageResourceName. This will let you specify the resource type and the resouce name which is the key of inside the resource file.

public class Person
{
    [Required(ErrorMessageResourceType=typeof(MyResourcesNameSpace.ResourcesFile), ErrorMessageResourceName="FirstNameRequiredKey")]
    public string FirstName { get; set; }
    //...
}

This way, you will have your application localized from the Model to the View without any problem.

    public static string MyExtensionFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> property)
	{
		var meta = ModelMetadata.FromLambdaExpression(property, this.HtmlHelper.ViewData);
		string fullPropertyName = HtmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(property));

		//Do what you need to do
	}

The variable fullPropertyNamemeta data contain the value of the property if required.

@Html.MyExtensionFor(x=>x.MyClassProperty1)

With little or no code you can setup Html Helper that is strongly typed. This has the advantage to not write string. This of course is better to reduce the change to write a wrong string but also help the refactoring because all refactoring tools works with property name change.

[AcceptVerbs(HttpVerbs.Get), ImportModelStateFromTempData]
public ActionResult MyAction(ModelObject myObject)
{
    return View();
}

[AcceptVerbs(HttpVerbs.Post), ExportModelStateToTempData]
public ActionResult MyActionSubmit(ModelObject  myObject)
{
   return View();
}

These attributes are not from the .Net framework and you need to have them inside your project by creating them. Once it’s done once, it’s done for the life time of your project.

First, you need to create the attributes. To do, you need to create a class that inherit the class ActionFilterAttribute. Since we are using 2 attributes that share the same information, we will create 3 classes. The first one will contain the sharing key for the session and the two others will be for the Import and Export.

public abstract class ModelStateTempDataTransfer : ActionFilterAttribute
{
    protected static readonly string Key = typeof(ModelStateTempDataTransfer).FullName;
}

Then, the class to export. Here you can add more custom code for your project. This version will all the ModelState only if this one contain errors.

public class ExportModelStateToTempData : ModelStateTempDataTransfer
{
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        //Only export when ModelState is not valid
        if (!filterContext.Controller.ViewData.ModelState.IsValid)
        {
            //Export if we are redirecting
            if ((filterContext.Result is RedirectResult) || (filterContext.Result is RedirectToRouteResult))
            {
                filterContext.Controller.TempData[Key] = filterContext.Controller.ViewData.ModelState;
            }
        }

        base.OnActionExecuted(filterContext);
    }
}

The last class will import the ModelState. In fact, it will merge the new one with the old one in the session.

public class ImportModelStateFromTempData : ModelStateTempDataTransfer
{
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        ModelStateDictionary modelState = filterContext.Controller.TempData[Key] as ModelStateDictionary;

        if (modelState != null)
        {
            //Only Import if we are viewing
            if (filterContext.Result is ViewResult)
            {
                filterContext.Controller.ViewData.ModelState.Merge(modelState);
            }
            else
            {
                //Otherwise remove it.
                filterContext.Controller.TempData.Remove(Key);
            }
        }

        base.OnActionExecuted(filterContext);
    }
}

As you can see, we do not use the session directly but we store everything into the TempData which use the session but handle the life cycle for us. This mean that it won’t stay for 20 minutes (default value of a session life time). It will stay until the next post back and be there if the request is redirected.

You can see it in the MVC open source project called MVCContrib (slightly modified version of this one). You can also find the source of the code in this blog post at this website.

CREATE TABLE [Tax](
	[ID] [int] IDENTITY(1,1) NOT NULL,
	[Description] [nvarchar](100) NULL,
CONSTRAINT [PK_Parent] PRIMARY KEY CLUSTERED
GO

CREATE TABLE [ParentDetail](
	[ID] [int] IDENTITY(1,1) NOT NULL,
	[Parent_ID] [int] NOT NULL,
CONSTRAINT [PK_ParentDetail] PRIMARY KEY CLUSTERED
GO

ALTER TABLE [ParentDetail]  WITH CHECK ADD  CONSTRAINT [FK_ParentDetail_Parent] FOREIGN KEY([Parent_ID])
REFERENCES [Parent] ([ID])
ON DELETE CASCADE
GO

The problem is that if you are using Entity Framework 4.3 and try to delete a Parent entity, you will end having this error :

An error occurred while saving entities that do not expose foreign key properties for their relationships. The EntityEntries property will return null because a single entity cannot be identified as the source of the exception. Handling of exceptions while saving can be made easier by exposing foreign key properties in your entity types. See the InnerException for details.

The inner exception message will contain something similar to this:

Cannot insert the value NULL into column ‘Parent_ID’, table ‘NutCache.Schema_NutCache.ParentDetail’; column does not allow nulls. UPDATE fails. The statement has been terminated.

So, what does it means? It try to delete the Parent and to set into each ParentDetail the ID NULL because it’s been erased. This is not what we want. In fact, we would like to have all ParentDetail to me removed as well. This is a little bit the reason why we have specify on the SQL to have a cascade.

You can do it manually in your project:

var listDetail = parent.ParentDetails.ToList();
foreach (var ParentDetail in listDetail){
	Database.ParentDetails.Remove(ParentDetail);
}

Database.Parents.Remove(Parent);
Database.SaveChanges();

This will produce multiple amount of SQL statement on the SQL Server. One for each details and 1 for the Parent itself.

But, if you go to your database context and you specify in the OnModelCreating a rule about the cascade it will work as it’s suppose to do.

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
//...
modelBuilder.Entity<Parent>().HasMany(e => e.ParentDetails).WithOptional(s => s.Parent).WillCascadeOnDelete(true);
//...

That’s it! Now you can simply delete the Parent without having to delete manually every children.

Database.Parents.Remove(Parent);
Database.SaveChanges();

On the SQL server side, you can see the database to have the same amount of delete statement executed. So, you do not save on the amount of query but save on the amount of logic to handle on the C# side because you do not have to care to delete every details.

On a special note, you do not need to have the table having a reference with the On Delete Cascade. You can handle the cascade only on the Entity DbContext with OnModelCreating. If you specify it on the Sql Server Database side, this only will enforce the integrity on the database side but won’t be automatically applied on the delete with EF.