Better way to update a record using Entity Framework

Question

I am looking for a more better way to update a record using Entity Framework.

Below is what I am using now, where playerFromModel is data fetched from View.

public bool UpdatePlayer(PlayerEntity playerFromModel)
{
    bool updateSuccessfull = false;

    using (var context = new PlayerEntities())
    {
        var player = context.Player.Where(m => m.emailAddress == playerFromModel.EmailAddress).FirstOrDefault();

        if (player != null)
        {
            player.emailAddress = playerFromModel.EmailAddress;
            player.first_name = playerFromModel.FirstName;
            player.last_name = playerFromModel.LastName;
            player.alt_email_id1 = playerFromModel.AlternateEmailAddress;
            player.street = playerFromModel.Street;
            player.city = playerFromModel.City;
            player.state = playerFromModel.State;
            player.zip = playerFromModel.Zip;
            player.country_code = playerFromModel.CountryCode;
            player.phone1 = playerFromModel.Phone;

            try
            {
                context.SaveChanges();
                updateSuccessfull = true;
            }
            catch
            {
                updateSuccessfull = false;
            }
        }
    }

    return updateSuccessfull;
}

As you can see I have to manually map each of the fields and the same approach I have followed everywhere.

I was thinking that there definitely has to be a better way to do this.

Please guide me on this. Thanks.

Use some mapping library, like automapper: http://automapper.codeplex.com/ — MiBu, Sep 27 '12 at 07:36
@MiBu Yes I am using AutoMapper and using that I am mapping my Viewmodel PlayerViewModel defined in my MVC model folder to PlayerEntities defined in my Repository Proj — Yasser Shaikh, Sep 27 '12 at 08:53
Can you please add sample class(player) from all tiers, so I can understand it better?! — MiBu, Sep 27 '12 at 10:53
Just as a random comment, you can change this line `var player = context.Player.Where(m => m.emailAddress == playerFromModel.EmailAddress).FirstOrDefault();` to `var player = context.Player.FirstOrDefault(m => m.emailAddress == playerFromModel.EmailAddress);`. No need to do `.Where(...).FirstOrDefault()` since `FirstOrDefault` has an overload that takes in a lambda expression. — Gromer, Sep 27 '12 at 23:36
@Gromer thats nice, never knew you could do it that way. Thanks ! — Yasser Shaikh, Sep 28 '12 at 04:50

score 5 · Accepted Answer · edited May 23 '17 at 11:47

You can just use TryUpdateModel. e.g.

    bool updateSuccessfull = false;
    using (var context = new PlayerEntities())
    {
        var player = context.Player.Where(m => m.emailAddress == playerFromModel.EmailAddress).FirstOrDefault();

        if (player != null)
        {
             //Beware this will try to map anything it can. This can be dangerous
            if(TryUpdateModel(player)){
            try
            {
                context.SaveChanges();
                updateSuccessfull = true;
            }
            catch
            {
                updateSuccessfull = false;
            }
         }
        }
    }
    return updateSuccessfull;
}

I wouldn't though see here Real example of TryUpdateModel, ASP .NET MVC 3.

You could use Automapper or something similar as MiBu said. Create a ViewModel link is here of the Player and then map from that to the entity

//Get a PlayerUpdate ViewModel     

       using (var context = new PlayerEntities())
    {
   // fetch the domain model that we want to update - BTW I'd use a repository pattern but that is another debate
        var player = context.Player.Where(m => m.emailAddress == playerFromModel.EmailAddress).FirstOrDefault();

        if (player != null)
        {

        // Use AutoMapper to update only the properties of this domain model
        // that are also part of the view model and leave the other properties unchanged
        AutoMapper.Map<UpdatePlayerViewModel , PlayerEntity>(viewModel, player);

           try
            {
                context.SaveChanges();
                updateSuccessfull = true;
            }
            catch
            {
                updateSuccessfull = false;
            }
    }

However I am of the opinion that updating entity properties is a significant thing and shouldn't be done automatically. Others feel the same. Jimmy Bogard who created AutoMapper doesn't seem to believe it needs two way mapping (However he says that is partly as they built AutoMapper for their requirement) Similar answer here on Stackoverflow saying do it yourself.

It depends on the complexity of your application but I would look at using the command pattern to send a message to an appropriate handler containing your properties and have the handler update them. If it was successful we do one thing if it wasn't we do another. Same pattern is described in MVC in Action. See similar (here is the link)[http://www.paulstovell.com/clean-aspnet-mvc-controllers] and here is the second link

Better way to update a record using Entity Framework

1 Answers1

Linked