Often we write lot of extension methods which helps us in consolidating logic and performing operations on objects in a easy way. In this tutorial I m going to narrate on how to implement IEnumerable<T> on extension methods which helps us in extending our extension method on every object which implements IEnumerable implementation say Arrays, Lists, Custom object etc. So we get wide coverage of different objects on which we can use our extension method.

Also in this tutorial, I have used Func<T,TResult> Delegate, using which I passed a Lambda function as a parameter to our extension method. With this we get flexibility to use lambda expression so that we can achieve anonymous methods and clean code.

Lets first get started by creating a Domain Model –

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExtensionsDemo
{
    class Question
    {
        public int QuestionId { get; set; }
        public string QuestionTitle { get; set; }
        public string QuestionText { get; set; }
        public List<string> QuestionTags { get; set; }
    }
}

Now lets create an implementation(wrapper) for our Question Class – QuestionsBag, which will list out all questions. We are going to use our extension method on top of an instance of this object. This class implements IEnumerable<Question> interface.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;

namespace ExtensionsDemo
{
    class QuestionsBag : IEnumerable<Question>
    {
        public List<Question> Questions { get; set; }

        public IEnumerator<Question> GetEnumerator()
        {
            return Questions.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}

Create Extensions Class for writing a Search extension for our QuestionsBag.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ExtensionsDemo
{
    static class Extensions
    {
        public static IEnumerable<Question> Search(this QuestionsBag bag, Func<Question, bool> searchCriteria)
        {
            foreach (Question _question in bag)
            {
                if (searchCriteria(_question))
                    yield return _question;
            }
        }
    }
}

Now the implementation would be as follows –

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ExtensionsDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            QuestionsBag bag = new QuestionsBag();
            bag.Questions = new List<Question>();

            bag.Questions.Add(
                new Question
                {
                    QuestionId = 1,
                    QuestionTitle = "What is ASP.Net MVC?",
                    QuestionText = "ASP.Net MVC",
                    QuestionTags = new List<string>{ "MVC", "Web" }
                });

            bag.Questions.Add(
                new Question
                {
                    QuestionId = 2,
                    QuestionTitle = "What is SQL Server?",
                    QuestionText = "SQL Server",
                    QuestionTags = new List<string> { "SQL", "DB" }
                });

            bag.Questions.Add(
                new Question
                {
                    QuestionId = 3,
                    QuestionTitle = "What is WCF?",
                    QuestionText = "WCF",
                    QuestionTags = new List<string> { "WCF", "Services" }
                });

            bag.Questions.Add(
                new Question
                {
                    QuestionId = 4,
                    QuestionTitle = "What is ASP.Net?",
                    QuestionText = "ASP.Net",
                    QuestionTags = new List<string> { "ASP.Net", "Web" }
                });

            IEnumerable<Question> result = bag.Search(p => p.QuestionTags.Contains("Web") && p.QuestionTitle.Contains("What"));

            Console.WriteLine("Total question found - " + result.Count().ToString());
            foreach (Question _question in result)
            {
                Console.WriteLine(_question.QuestionTitle);
            }

            Console.ReadLine();
        }
    }
}

When you run the above code, you should be able to search all questions which got “Web” tag associated with it and also which contains “What” keyword in Question’s Title.

When the same program executed to search questions with tag “Web” and which contains “WCF” in question title, it will give you 0 results as no question supports the search criteria.

In this short tutorial, I am going to show how to validate a Dropdownlist in MVC3 using Razor Syntax.

Our Model Class –

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ComponentModel.DataAnnotations;
using System.Web.Mvc;

namespace DropdownListValidation.Models
{
    public class DropdownListModel
    {

        [Required( ErrorMessage = "Selection is a MUST" )]
        public string SelectedItem { get; set; }

        private List<string> _items;
        public List<string> Items
        {
            get
            {
                _items = new List<string>();
                _items.Add("One");
                _items.Add("Two");
                _items.Add("Three");
                return _items;
            }
        }
    }
}

Our Controller Class –

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using DropdownListValidation.Models;

namespace DropdownListValidation.Controllers
{
    public class HomeController : Controller
    {
        //Render Action
        [HttpGet]
        public ViewResult Index()
        {
            DropdownListModel model = new DropdownListModel();
            return View(model);
        }

        //Process Action
        [HttpPost]
        public ViewResult Index(DropdownListModel model)
        {
            //TODO: Validate using if(ModelState.IsValid) and process information
            return View(model);
        }
    }
}

Our View –

@model DropdownListValidation.Models.DropdownListModel

@{
    Layout = null;
}

<!DOCTYPE html>
<link rel="stylesheet" href="@Href("~/Content/Site.css")" type="text/css" />

<html>
<head>
    <title>Index</title>
</head>
<body>
    <div>
        <!--Render the DropDownListmodel -->
        @using (Html.BeginForm())
        {
            <p>@Html.ValidationSummary()</p>
            <p>Select an Item : @Html.DropDownListFor(x => x.SelectedItem, new SelectList(Model.Items), "--Choose any Item--" )</p>
            <input type="submit" value="Submit" />
        }

        <!-- Display Selected Item -->
         @if (!String.IsNullOrWhiteSpace(Model.SelectedItem))
         {
              <span>Selected Item : @Model.SelectedItem</span>
         }

    </div>
</body>
</html>

When you click on submit button, without selecting any value from Dropdownlist –

When we select an item and click on submit button –

This small blog post is out to answer some of the common questions which I do see most often – “Differences between ASP.Net and ASP.Net MVC”, “Why ASP.Net MVC?” etc. Out of my experience I am listing out some of the important points around MVC in conjunction with ASP.Net Webforms.

With no doubt, I can assure you guys that ASP.Net Webforms served (and still serving) us in solving many complicated business problems through its huge and intensive components (especially .Net Framework Components). At this junction we need to remember that this extensive capability of ASP.Net is built on top of hiding Webs Statelessness and Html (which is not known very well at the time of ASP.Net’s birth), which unfortunately cost performance in some typical areas as listed below –

1. ViewState – On the first hand please read about ViewState in Dave Reed’s Post. This mechanism of maintaining state across Postbacks make the page size hefty and results in poor user experience with lot of data transferring in and out between client and server.

2. Limited control on Html – Its very hard to get control on Html being generated by ASP.Net Server control. Any developer/UI Designer working with CodeBehind and VS designer can easily understand my former statement. Because of this sporadic Html, its even hard to incorporate JavaScript client side effects/validations.

3. Testability – Automated UI Testing is a hard process for testers, due to ever changing IDs of Html and improper layouts rendered. Also Unit testing is a complicated task to Developers due to ASP.Net tightly coupled CodeBehind and its Markup.

4. Page Life Cycle – Every Request in ASP.Net needs to go through a structure life cycle which is complicated to achieve for many custom behaviors. Sometimes because of this cycle, we have to do something which are not best practices.

5. Code Separation – With CodeBehind model, we can achieve code separation between different UI and Business logic, but not up to the mark. It is hard to get separation to its maximum bar.

6. Leaky Abstraction – ASP.Net hides a lot of things, especially HTTP communication and Html from developers which can be crucial risks for custom behaviors. Some times we might end up without the knowledge of what’s going on with the process and might end up in reverse engineering the the problem to get to its root.

Above mentioned are some of the common areas where we might start falling apart with Webforms, but the beauty of ASP.Net comes with its maturity from 2002. Microsoft continuously making ASP.Net Webforms evolving and a simple example would be its ASP.Net 4.5 with Async Handlers and Modules.

Now lets start with ASP.Net MVC, with evolving Web technologies and especially Web 2.0 which mostly focused on REST – resource based utilization and Agile methodologies, Microsoft announced about its MVC in 2007 ALT.NET Conference. MVC Framework is built based on MVC Pattern which solves most of above mentioned Webforms problems by itself. Following are some of the best things MVC Framework offers on the front end –

1. No ViewState – MVC goes inline with web statelessness and eliminates ViewState to store Server Control states. It is also oriented towards resource driven like REST and it works mostly on actions rather than complete life cycle (you so a specific request and you get specific response). With MVC we have mush more better control on every Request we make to server.

2. Testability – With its natural componentization from MVC Pattern, MVC readily support good amount of Unit Testing. MVC generates clean Html which supports most of UI Automated Test tools.

3.  User Friendly URLs – MVC generated search engine friendly and user intuitive URLs, which can be easily remembered and shared across Web.

4. More control on Html – Default HtmlHelpers in MVC help to generate cleaner Html. Html generated would shoe greater flexibility with JavaScript/JQuery and their plugin integrations.

5. Extensibility – MVC has greater flexibility to extend/replace components on which it is built on, for example View Engines you can opt for traditional ASP.Net View Engine or use Razor or any other view engines available. We can also write our own view engines too. MVC also incorporates major ASP.Net and .Net Frameworks APIs like Membership Providers, Roles etc.. which saves lot of time to ASP.Net Developers in writing code they are familiar with.

Last but not least, the main point of this blog post is not to exaggerate which technology is superior than the other. End of the day every technology has to make some trade offs, it is really very hard to conclude which is better. It all depends on how we use a particular technology to solve a business problem. Looking at these technologies (Webforms and MVC) and working closely with them, I saw both the frameworks solved wonderful problems in an elegant approach. Always use a right technology for a right business problem.

The script should run every 15 minutes

Thanks in advance

this simple program has two errors
previouspage.findcontrol() does not exist in current context
selecteddate.toshortdate();

Thanks in Advance,

Suresh Kumar G

PLEASE SUGGEST or mail me please at sumit.burnwal@gmail.com …

Regards,

Sumit K. Burnwal

I have a doubt in the password security + MVC application topic.
If we look at the code the password is passing as plain text over the channel. If we want to implement a internet website using MVC, i think this approach of implementation is not satisfactory as hackers can use a tool which block the site prior gets posted completely when userid/password entered and steal the credentials and release to get posted.
Kindly let me know how can we say this approach is secure one.

*For Security purpose, I am removing all the contact details mentioned by User in this post*

I wrote a post – Being a Microsoft MVP exactly one year back, and now time has yet arrived to narrate a similar post, but a year older and wiser post.

Earlier this week I was re-awarded with Microsoft MVP 2012 by Microsoft Corporation. I thank Microsoft Corporation and many MSFT’s, who are consistently monitoring and managing many online communities to make sure right technology reach right people at right times for right problems. There are many great Microsoft Full Timers with whom I had long conversations over years and shared many technical perspectives, I may not be able to name each and everyone of them, but I thank all of them for their encouragement to me throughout.

Last year was a pretty busy year for me. I already narrated some of my experiences through a post – Happy New Year 2012 – My Life in 2011. Because of my personal and professional commitments (and in fact strong commitments) I was not able to consistently support online community. Its been a hard year for me to manage lot of bits and pieces associated to me, I hope I managed everything with some if’s and but’s, end of the day I hope everyone is happy for being associated with me.

I thank my Family, Mentors, Teachers, Friends, Well Wishers and Colleagues for being a wonderful part in my last years accomplishment. I have had a lot of positive influences on me directly or indirectly by many people in 2011, so now it’s my part to share this award with everybody.

I thank my Readers and members of different Online Communities (in which I was associated) for sharing such great experiences of them. I made many friends online, with whom I had not only technical problem solving techniques but also many other things like Analytical Perspectives, Diversified thought process etc., were discussed and analyzed. I thank all of them from bottom of my heart for being such kind to me.

This year 2012 is going to be a well excited year to me. I have many interesting challenges on my plate right now. The biggest challenge is obviously my personal time allotment/management and prioritization. I am working on it right now, in fact I already laid out a comfortable, easy and convenient plan which gives me ample time to spend on this blog or in any online communities. I am planning to stay more focused on this Blog – change its theme, put up more interesting stuff weekly, concentrate more on thought provoking posts rather than providing technical solutions. At the same time, I want to concentrate on Technical communities, where we can find many real world challenges and where people are more excited to talk. I also planned for some certifications from Microsoft, may be not right away immediately but may be in the third quarter.

Lastly, It’s been always a pleasure to think about all the people whom I mentioned above. I thank everyone once again. See you guys soon in one more post.

Regards,

Rami.