View without Controller Action in MVC

In this quick post you will learn how a view can be rendered without its native Controller
Action method.

Why we need this?

Let’s look at the image.

In above image, you can see for each view we have matching controller action. Each of
these actions contains a single line of code. In fact, each of these actions contains
exactly the same line of code. And this is completely a needless work. Even imagine
what you will do when you have hundreds or thousands of views. Will you create
hundreds or thousands of controller actions? Off course not, then how can we fix it?

In MVC Framework, controller class includes a method HandleUnknownAction() that
executes whenever we attempt to invoke an action (or when we request a view which
has no matching action method) on a controller that does not exist.

Now we are taking the advantage of the HandleUnknownAction() method to render views
even when a corresponding controller method does not exist.

In above image you can see we don’t have Post5.cshtml, so when I tried to access the
Post5.cshtml view, it pops following error.

Exception Generated

To fix this issue, we can use simple try-catch block and redirect the user on

PageNotFound view, here’s how.

I Hope this will Help you to Learn.

Continue Reading →

What is Model and ViewModel in MVC Pattern?

Model and ViewModel are two things we always hear in MVC. And in this post I am

going to show you the differences between them.

Let’s begin with its common definition.

What is Model or Domain Model?

Actually, the word 'model' has hundreds of meaning in software development, but
here we gone talk about 'model' in MVC design pattern. I would define model as an
object that we use to send information to the database, to perform business
calculations, to render view. In other word, 'model' represent the domain of
the application helps us in saving, creating, updating and deleting records. Usually
we put all our model classes in Model folder.

What is ViewModel?

ViewModel in MVC design pattern is very similar to 'model'. The major difference
between 'Model' and ‘ViewModel’ is that we use ViewModel only in rendering views.
We put all our ViewModel classes in ‘ViewModels’ named folder, we create this folder.

Understand it with example

Let's assume, we want to implement a view page that will have three textboxes for
Username, Password and Re-enter Password. To achieve this we could design a
'Model' as given below:

    public class Login

    {

        public String Username { get; set; }

        public String Password { get; set; }

        public String RePassword { get; set; }

    }

For sake of view this model works fine. But this is actually a wrong approach because
we are trying to overcrowd the database. I can't see any use of 'RePassword'
property in database.

Now, if we take the advantage of ViewModel, we can safeguard the database from
overcrowding with fields. Here’s how, design following ‘Model’ which will be our
Domain Model:-

    //this will represent domain of the application

    public class Login

    {

        public String Username { get; set; }

        public String Password { get; set; }

    }

And then following 'ViewModel':-

    //this will help in rendering great views

    public class LoginViewModel

    {

        public String Username { get; set; }

        public String Password { get; set; }

        public String RePassword { get; set; }

    }

Now, when adding view, pick the ViewModel class to get the strongly-typed benefits.

Now the question is how do we transform the Model or Domain Model from the
‘ViewModel’? Let’s learn it.

Transforming Model from ViewModel

There are various ways to do this. In the form POST action we can create a new
object of type Login model and then assign the properties one by one and leave the
unwanted properties.

[HttpPost]

public ActionResult Login(LoginViewModel viewModel)

{

    //validate the ViewModel

    //transforming Model (Domain Model) which is Login from ViewModel which is
        LoginViewModel

    var login = new Login()

    {

        Username = viewModel.Username,

        Password = viewModel.Password

    };

    //save the login var

    return View();

}

In above code, after validating the ViewModel I’m transforming the Model or Domain
Model. So, by using this way you can stop overcrowding database with
unwanted fields.

I Hope this will help you to understand the use of Model and ViewModel.

Continue Reading →

Delegates - C Sharp

A delegate is a type safe function pointer.That is, they hold reference(Pointer) to a function. 

The signature of the delegate must match the signature of the function, the delegate points to, otherwise you get a compiler error. This is the reason delegates are called as type safe function pointers.

A Delegate is similar to a class. You can create an instance of it, and when you do so, you pass in the function name as a parameter to the delegate constructor, and it is to this function the delegate will point to.

Declaration:
A delegate is declared by using the keyword delegate, otherwise it resembles a method declaration.

delegate int delegateAdd(int x, int y);

Instantiation:

To create a delegate instance, we need to assign a method (which has same signature as delegate) to delegate.

        static int add(int a, int b)

        { 

          return a + b; 

        }

        //create delegate instance

        delegateAdd objAdd = new delegateAdd(Add);

        //short hand for above statement

        delegateAdd objAdd = Add;

Invocation:

     // Invoke delegate to call method

     int result = objAdd.Invoke(3, 6);

     //short hand for above statement

     int result = objAdd(3, 6); 

Invoking a delegate is like as invoking a regular method.

Complete Code is:

class Program

{

        delegate int delegateAdd(int x, int y);

        static int add(int a, int b)

        { return a + b; }

        static void Main(string[] args)

        {

           // Program p = new Program();

           //delegateAdd _del = p.add;

            delegateAdd _del = add;

            int result = _del.Invoke(3, 6);

            Console.Write(result);

            Console.Read();

        }

}

Output will be : 9

Type of Delegate

Delegates are one of two types:

1. Singlecast Delegate
2. Multicast Delegate

Singlecast DelegateA Singlecast delegate is derived from the System.Delegate class. It can contain a reference for one method at a time. In the above example the delegate uses a Singlecast delegate.

Multicast DelegateA Multicast delegate is derived from the System.MulticastDelegate class. It can contain references for multiple methods. For understanding multicast delegates you can consider the real-life example: of a Coffee vending machine.

A Coffee vending machine has three containers for Milk, Coffee, and Tea. If you press the Tea button then there will two containers, Milk and Tea that work together. And if you press the button for Coffee then the Milk and Coffee containers will work. So if you want to call multiple functions then you can use a multicast delegate.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Anonymous

{

    class Class1    {

        public delegate void Vender();

        public static void Milk()

        {

            Console.Write("Milk + ");

        }

        public static void Tea()

        {

            Console.Write("Tea = Tea ");

        }

        public static void Coffee()

        {

            Console.Write("Coffee = Coffee ");

        }

        static void Main()

        {

            Vender vender = new Vender(Milk);

            Console.WriteLine("\t\tPress 1 For Tea\n\t\t Press 2 For Coffee");

            int Opt = Convert.ToInt32(Console.ReadLine());

            switch (Opt)

            {

                case 1:

                    vender += Tea;

                    break;

                case 2:

                    vender += Coffee;

                    break;

                default:

                    Console.WriteLine("Invalid Option !");

                    Environment.Exit(0);

                    break;

            }

            vender();

            Console.ReadKey();

        }

    }

}

In the above program I just created the three functions, Tea, Coffee and Milk. When one is pressed there will be two functions, called Milk and Tea. If the user chooses both then again the two functions, Milk and Coffee are called. Since Milk is common to both situations I just pass Milk in the Delegate parameter. And the delegate understands "+" and "+=" for adding references of functions and "-" and "-=" for removing function references, so depending on the option used I just add a function reference with the same Delegate object vendor. And invoke the delegate vendor.

Remember, multicasting of delegate should have a return type of Void otherwise it will throw a runtime exception.

Anonymous Method In C# 1.0 you can use a delegate and pass a function reference with an initializing delegate with a function name, but C# 2.0 introduced anonymous functions.

Creating an anonymous method as an inline block of code to be passed as a delegate parameter can be done as you see in the following: 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Anonymous

{

    class Class1    {

        public delegate void Del();

        static void Main(string[] args)

        {

            Del obj = delegate() {

                Console.WriteLine( "Class1.fun");

            };

            obj();

        }

    }

}

Use of an anonymous function can reduce the lines of code. So, here in the program above you can see I just passed a block of code for a delegate parameter inside of creating a function anywhere else and passing the function name. The anonymous function uses the delegate keyword while delegate initialization writes a block of code. You can also pass a parameter for an anonymous function as follows:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Anonymous

{

    class Class1    {

        public delegate void Del( string Mesg);

        static void Main(string[] args)

        {

            Del obj = delegate(string Mesg) {

                Console.WriteLine(Mesg);

            };

            obj("Class1.fun");

        }

    }

}

Note:
You cannot use goto, break and continue statements inside the anonymous method block if the targat is outside an anonymous block.

Difference between Delegate and Event

Continue Reading →

RANK() and DENSE_RANK() - SQL Server

 The RANK() function in SQL Server returns the position of a value within the partition of a result set, with gaps in the ranking where there are ties.

The DENSE_RANK() function in SQL Server returns the position of a value within the partition of a result set, leaving no gaps in the ranking where there are ties.

These functions also enumerate rows as ROW_NUMBER() function, but a somewhat different way. Difference is that the rows, that have the same values in column on which you are ordering, receive the same number (rank). For example, the values (ordered in ascending)

will have such numbers:

The question arises as from what numbers will continue numbering if, say, in a sequence of numbers will appear on 7 and so on? There are two variants:

1) number 4, because it is the following number in sequence;

2) number 6, because next line will be the sixth.

This "ambiguity" has led to the appearance of two functions instead of one - RANK and DENSE_RANK, the first of which will continue the numbering from 6 and the second (dense) - with 4.

Let's consider some examples. We begin from showing the differences in the behavior of functions RANK and ROW_NUMBER:

Execute

SELECT *, ROW_NUMBER() OVER(ORDER BY type) num,

RANK() OVER(ORDER BY type) rnk    FROM Printer;

Here the values of compared functions are outputs in two last columns with row ordering in column ‘type’:

code	model	color	type	price	num	rnk
2	1433	y	Jet	270.00	1	1
3	1434	y	Jet	290.00	2	1
1	1276	n	Laser	400.00	3	3
6	1288	n	Laser	400.00	4	3
4	1401	n	Matrix	150.00	5	5
5	1408	n	Matrix	270.00	6	5

As expected ROW_NUMBER enumerates entire set of rows returned by the query. RANK function work on the second of the above variant, i.e. the line number will be the following number after rows with an identical rank.

Now compare the "dense" and "nondense" rank: 

  Execute

SELECT *, RANK() OVER(ORDER BY type) rnk, DENSE_RANK() OVER(ORDER BY type) rnk_dense FROM Printer;

It should also draw attention to the order in which output rows of the result set. Because SELECT statement in our example does not have ORDER BY clause and same ordering by column ‘type’ is used to rank calculating, then the result is displayed in the same manner. In order to optimize if you don’t need any other ordering the result set; use this fact in order not to perform additional sorting, which decrease the performance of the query.

As well as for ROW_NUMBER function, PARTITION BY can be used in OVER clause, it divides the entire set of rows returned by the query to groups to which then the appropriate function is applied.

The query

SELECT *, RANK() OVER(PARTITION BY type ORDER BY price) rnk FROM Printer;

allows the ranking of models by prices in ascending order in each group defined by printer type:

code model color type price rnk 2 1433 y Jet 270.00 1 3 1434 y Jet 290.00 2 1 1276 n Laser 400.00 1 6 1288 n Laser 400.00 1 4 1401 n Matrix 150.00 1 5 1408 n Matrix 270.00 2

And here so it is possible to select the cheapest models from each category:

SELECT model, color, type, price FROM ( SELECT *, RANK() OVER(PARTITION BY type ORDER BY price) rnk FROM Printer) Ranked_models WHERE rnk = 1;

model	color	type	price
1433	y	Jet	270.00
1276	n	Laser	400.00
1288	n	Laser	400.00
1401	n	Matrix	150.00

The query could be shorter, if the RANK function could be used in a WHERE clause, since own value of the rank we do not need. However, it is forbidden (as for other ranking functions), at least in SQL Server.

Finally, consider another example.

Example. Find makers who produce more than 2 models of PC.

This task has a solution through the traditional aggregate functions

SELECT maker FROM Product

      WHERE type = 'PC'

      GROUP BY maker

      HAVING COUNT(*) > 2;

However, this task can be solved by using the RANK function. The idea is as follows: to rank the models of each maker's on a unique key and to select only those manufacturers, whose products reach the rank 3:

      SELECT maker

      FROM (

      SELECT maker, RANK() OVER(PARTITION BY maker ORDER BY model) rnk

      FROM Product

      WHERE type = 'PC') Ranked_makers

      WHERE rnk = 3;

Both in one, and in another case, of course, we get the same result:

Once again: in last case, ordering must be performed on unique column combination, because, otherwise, it can be exists over 3 models but rank under 3 (for example 1, 2, 2, …). In our case, this condition is satisfied, because ordering is performed by the column ‘model’, which is the primary key in table Product.

By the way, the execution plans of these queries show the same cost of most costly operations - a table scan and sort (which in first case, there is an implicit, and called by the grouping operation).

Continue Reading →