Expect everything to change...

Challenge

var dbContext = new MyDBDataContext();
var userDetails = dbContext.Users.FirstOrDefault(userId => userId.UserId == id);
var user = new LearningMVC.Models.User();
if (userDetails != null)
{
    user.UserId = userDetails.UserId;
    user.FirstName = userDetails.FirstName;
    user.LastName = userDetails.LastName;
    user.Address = userDetails.Address;
    user.PhoneNo = userDetails.PhoneNo;
    user.EMail = userDetails.EMail;
    user.Company = userDetails.Company;
    user.Designation = userDetails.Designation;
}
return View(user);

Auto Mapper

Example

public ActionResult Index()
{
    var dbContext = new MyDBDataContext();
    var userList = from user in dbContext.Users select user;
    var users = new List();
    if (userList.Any())
    {
        foreach (var user in userList)
        {
            users.Add(new LearningMVC.Models.User()
                {
                    UserId = user.UserId, 
                    Address = user.Address, 
                    Company = user.Company, 
                    FirstName = user.FirstName,
                    LastName = user.LastName,
                    Designation = user.Designation,
                    EMail = user.EMail, 
                    PhoneNo = user.PhoneNo
                });
        }
    }
  
    return View(users);
}

Mapper.CreateMap();

LearningMVC.Models.User userModel = Mapper.Map(user);
users.Add(userModel);

public ActionResult Index()
{
    Mapper.CreateMap();
    var dbContext = new MyDBDataContext();
    var userList = from user in dbContext.Users select user;
    var users = new List();
    if (userList.Any())
    {
        foreach (var user in userList)
        {
            LearningMVC.Models.User userModel = 
              Mapper.Map(user);
            users.Add(userModel);
        }
    }
    return View(users);
}

Mapper.CreateMap().ForMember(emp => emp.Fullname,
map => map.MapFrom(p => p.FirstName + " " + p.LastName));

Using Traditional Approach

[HttpPost]
public ActionResult CalculateSimpleInterestResult()
{
    decimal principle = Convert.ToDecimal(Request["txtAmount"].ToString());
    decimal rate = Convert.ToDecimal(Request["txtRate"].ToString());
    int time = Convert.ToInt32(Request["txtYear"].ToString());

    decimal simpleInteresrt = (principle*time*rate)/100;

    StringBuilder sbInterest = new StringBuilder();
    sbInterest.Append("Interest : " + simpleInteresrt);
    return Content(sbInterest.ToString());
}

Using the FormCollection Object

[HttpPost]
public ActionResult CalculateSimpleInterestResult(FormCollection form)
{
    decimal principle = Convert.ToDecimal(form["txtAmount"].ToString());
    decimal rate = Convert.ToDecimal(form["txtRate"].ToString());
    int time = Convert.ToInt32(form["txtYear"].ToString());

    decimal simpleInteresrt = (principle*time*rate)/100;

    StringBuilder sbInterest = new StringBuilder();
    sbInterest.Append("Interest : " + simpleInteresrt);
    return Content(sbInterest.ToString());
}

Using the Parameters

[HttpPost]
public ActionResult CalculateSimpleInterestResult(string txtAmount, string txtRate, string txtYear)
{
    decimal principle = Convert.ToDecimal(txtAmount);
    decimal rate = Convert.ToDecimal(txtRate);
    int time = Convert.ToInt32(txtYear);

    decimal simpleInteresrt = (principle*time*rate)/100;

    StringBuilder sbInterest = new StringBuilder();
    sbInterest.Append("Interest : " + simpleInteresrt);
    return Content(sbInterest.ToString());
}

Strongly typed model binding to view

namespace CalculateSimpleInterest.Models
{
    public class SimpleInterestModel
    {
        public decimal Amount { get; set; }
        public decimal Rate { get; set; }
        public int Year { get; set; }
    }
}

[HttpPost]
public ActionResult CalculateSimpleInterestResult(SimpleInterestModel model)
{
    decimal simpleInteresrt = (model.Amount*model.Year*model.Rate)/100;

    StringBuilder sbInterest = new StringBuilder();
    sbInterest.Append("Interest : " + simpleInteresrt);
    return Content(sbInterest.ToString());
}

Introducing the Keywords

public async Task DoSomethingAsync()
{
  // In the Real World, we would actually do something...
  // For this example, we're just going to (asynchronously) wait 100ms.
  await Task.Delay(100);
}

Return Types

public async Task CalculateAnswer()
{
  await Task.Delay(100); // (Probably should be longer...)

  // Return a type of "int", not "Task"
  return 42;
}

// ASP.NET example
protected async void MyButton_Click(object sender, EventArgs e)
{
  // Since we asynchronously wait, the ASP.NET thread is not blocked by the file download.
  // This allows the thread to handle other requests while we're waiting.
  await DownloadFileAsync(...);

  // Since we resume on the ASP.NET context, we can access the current request.
  // We may actually be on another *thread*, but we have the same ASP.NET request context.
  Response.Write("File downloaded!");
}

private async Task DownloadFileAsync(string fileName)
{
  // Use HttpClient or whatever to download the file contents.
  var fileContents = await DownloadFileContentsAsync(fileName).ConfigureAwait(false);

  // Note that because of the ConfigureAwait(false), we are not on the original context here.
  // Instead, we're running on the thread pool.

  // Write the file contents out to a disk file.
  await WriteToDiskAsync(fileName, fileContents).ConfigureAwait(false);

  // The second call to ConfigureAwait(false) is not *required*, but it is Good Practice.
}

// WinForms example (it works exactly the same for WPF).
private async void DownloadFileButton_Click(object sender, EventArgs e)
{
  // Since we asynchronously wait, the UI thread is not blocked by the file download.
  await DownloadFileAsync(fileNameTextBox.Text);

  // Since we resume on the UI context, we can directly access UI elements.
  resultTextBox.Text = "File downloaded!";
}

public async Task DoOperationsConcurrentlyAsync()
{
  Task[] tasks = new Task[3];
  tasks[0] = DoOperation0Async();
  tasks[1] = DoOperation1Async();
  tasks[2] = DoOperation2Async();

  // At this point, all three tasks are running at the same time.

  // Now, we await them all.
  await Task.WhenAll(tasks);
}

public async Task GetFirstToRespondAsync()
{
  // Call two web services; take the first response.
  Task[] tasks = new[] { WebService1Async(), WebService2Async() };

  // Await for the first one to respond.
  Task firstTask = await Task.WhenAny(tasks);

  // Return the result.
  return await firstTask;
}

Background

Sample Scenario

Technique #1 - Using Pure Object Oriented (OO) programming concepts.

Publisher

public interface IPublisher
{
	// Registers a new subscriber on the list of subscribers it has to 
    // notify whenever WeatherData has changed
    void RegisterSubscriber(ISubscriber subscriber);

    // Removes a registered subscriber from the publisher's notification list
    void RemoveSubscriber(ISubscriber subscriber);

    // This method actually invokes a method on the subscriber object to
    // notify that some new WeatherData is available
    void NotifySubscribers();
}

public class WeatherDataProvider : IPublisher
{
    List ListOfSubscribers;
    WeatherData data;
    public WeatherDataProvider()
    {
        ListOfSubscribers = new List();
    }
    public void RegisterSubscriber(ISubscriber subscriber)
    {
        ListOfSubscribers.Add(subscriber);
    }

    public void RemoveSubscriber(ISubscriber subscriber)
    {
        ListOfSubscribers.Remove(subscriber);
    }

    public void NotifySubscribers()
    {
        foreach (var sub in ListOfSubscribers)
        {
            sub.Update(data);
        }
    }

    private void MeasurementsChanged()
    {
        NotifySubscribers();
    }
    public void SetMeasurements(float temp, float humid, float pres)
    {
        data = new WeatherData(temp, humid, pres);           
        MeasurementsChanged();
    }
}

Subscriber

public interface ISubscriber
{
    void Update(WeatherData data);
}

public class CurrentConditionsDisplay : ISubscriber
{
    WeatherData data;
    IPublisher weatherData;

    public CurrentConditionsDisplay(IPublisher weatherDataProvider)
    {
        weatherData = weatherDataProvider;
        weatherData.RegisterSubscriber(this);
    }

    public void Display()
    {
        Console.WriteLine("Current Conditions : Temp = {0}Deg | Humidity = {1}% | Pressure = {2}bar", data.Temperature, data.Humidity, data.Pressure);
    }
   
    public void Update(WeatherData data)
    {
        this.data = data;
        Display();
    }
}

Technique #3 - Using IObservable and IObserver.

public class WeatherDataProvider : IObservable
    {
        List> observers;

        public WeatherDataProvider()
        {
            observers = new List>();
        }

        public IDisposable Subscribe(IObserver observer)
        {
            if (!observers.Contains(observer))
            {
                observers.Add(observer);
            }
            return new UnSubscriber(observers, observer);
        }

        private class UnSubscriber : IDisposable
        {
            private List> lstObservers;
            private IObserver observer;

            public UnSubscriber(List> ObserversCollection, IObserver observer)
            {
                this.lstObservers = ObserversCollection;
                this.observer = observer;
            }

            public void Dispose()
            {
                if (this.observer != null)
                {
                    lstObservers.Remove(this.observer);
                }
            }
        }

        private void MeasurementsChanged(float temp, float humid, float pres)
        {
            foreach (var obs in observers)
            {
                obs.OnNext(new WeatherData(temp, humid, pres));
            }
        }

        public void SetMeasurements(float temp, float humid, float pres)
        {
            MeasurementsChanged(temp, humid, pres);
        }
    }

public class CurrentConditionsDisplay : IObserver
{
    WeatherData data;
    private IDisposable unsubscriber;

    public CurrentConditionsDisplay()
    {

    }
    public CurrentConditionsDisplay(IObservable provider)
    {
        unsubscriber = provider.Subscribe(this);
    }
    public void Display()
    {
        Console.WriteLine("Current Conditions : Temp = {0}Deg | 
                            Humidity = {1}% | Pressure = {2}bar", 
                            data.Temperature, data.Humidity, data.Pressure);
    }

    public void Subscribe(IObservable provider)
    {
        if (unsubscriber == null)
        {
            unsubscriber = provider.Subscribe(this);
        }
    }

    public void Unsubscribe()
    {
        unsubscriber.Dispose();
    }

    // Pass the observer a T object that has current data, changed data, or fresh data.
    public void OnNext(WeatherData value)
    {
        this.data = value;
        Display();
    }

    // Notify the observer that some error condition has occurred
    public void OnError(Exception error)
    {
        Console.WriteLine("Some error has occurred..");
    }

    // Notify the observer that it has finished sending notifications
    public void OnCompleted()
    {
        Console.WriteLine("Additional temperature data will not be transmitted.");
    }
}