Passing an entity to use it's fields to update method is ok to do? I have two different ideas on how to handle this Update method in my MVC Model class "DataAccess" And I'm wondering if in the first, I'm handling my class incorrectly or ambiguously, because I'm using members from the same object for two different purposes.

The man Class has 2 relevant members.  ID, which is the primary key of the entity, and Name, which is the description

    public DbResult Update(Man man)
    {
        DbResult dbResult; 

        var query =
            from person in _MyDBEntities.Men
            where person.ManID == man.ManID // Man with ManID is what we're looking for.
            select person;

        try
        {
            foreach (Man m in myQuery)
            {
                m.Name = man.Name; // man.Name is the new name
            }
            dbResult = DbResult.Success("Record updated");
        }
        catch (Exception e)
        {
            dbResult = DbResult.Failed(e.ToString());   
        }
        return dbResult;
    }


And this version of the method, which uses the variables passed in differently.

    public DbResult Update(int idToLookFor, string newName)
    {
        DbResult myResult; 

        var query =
            from person in _MyDBEntities.Men
            where person.ManID == idToLookFor
            select person;

        try
        {
            foreach (Man m in myQuery)
            {
                m.Name = newName;
            }
            dbResult = DbResult.Success("Record updated");
        }
        catch (Exception e)
        {
            dbResult = DbResult.Failed(e.ToString());   
        }
        return dbResult;
    }


is my first method a better or ok approach to the problem?  Because what if I have an update method later on that uses 8 members, and need to create more versions of this function for updating other entities?

## UPDATED ##

Including a new class here: 

public class InputValidation//&lt;T&gt; where T: class
{
    /// &lt;summary&gt;
    /// Delegate that matches the signature of TryParse, method defined for all primitives.
    /// &lt;/summary&gt;
    /// &lt;typeparam name="T"&gt;Output type of This Delegate&lt;/typeparam&gt;
    /// &lt;param name="input"&gt;input for this Delegate to translate to type T&lt;/param&gt;
    /// &lt;param name="output"&gt;The translated variable to return via out parameter&lt;/param&gt;
    /// &lt;returns&gt;Whether the Parse was successful or not, and output as output&lt;/returns&gt;
    public delegate bool TryParse&lt;T&gt;(string input, out T output);
    public bool ValidateInputType&lt;T&gt;(string input, TryParse&lt;T&gt; TypeValidator, out T result)
    {
        return TypeValidator(input, out result);
    }
    public bool ValidateInputRange&lt;T&gt;(ref T result, int lower, int upper)
    {
        // How can I use relational operators like &gt; &lt; = on T? without forcing T result to an int?
        return isValidRange(int.Parse(result.ToString()), lower, upper);
    }
    public bool isValidRange(int item, int lower, int upper)
    {
        return (lower &lt;= item &amp;&amp; item &lt;= upper);
    }
}
The second one seams to me a better approach but you say that the ManID is a primary key, so why are you handling it as a non primary key and using the query result as a sequance?

public DbResult Update(int idToLookFor, string newName)
{
    return Update(_MyDBEntities.Men.Single(p =&gt; p.ManID == idToLookFor), newName);
}

public DbResult Update(Man person, string newName)
{
    try
    {
        person.Name = newName;
        //saving missing?
        return DbResult.Success("Record updated");
    }
    catch (Exception e)
    {
        return DbResult.Failed(e.ToString());
    }
}


And the real saving missing or it's placed to elsewhere so why are you setting here the DbResult?