Question

I have a method in my project that repeats over and over:

public PAC PAC_GetByCodiPac(string codiPac)

{

var sel = _gam.PAC.Where(pac => pac.CODI_PAC == codiPac);

            if (sel.Count() > 0)
                return sel.First();
            return null;
        }

The table PAC means (patient), so I have these methods for all the tables I have.
How can I make a generic method for this?
Thanks in advance.

Answer 1

If you want a generic method that lets you specify any table and any predicate for records from that table then you can’t really get any better than the built-in Where<T>(...) and (as others have already pointed out) the FirstOrDefault<T>(...) extension methods.

Your code would then look like so:

var result = _gam.PAC.Where(pac => pac.CODI_PAC == codiPac).FirstOrDefault();
// OR
var result = _gam.PAC.FirstOrDefault(pac => pac.CODI_PAC == codiPac);

The best you could get then, writing your own generic method, would be this:

public T FirstOrDefault<T>(IQueryable<T> source,
    Expression<Func<T, bool>> predicate)
{
    return source.Where(predicate).FirstOrDefault();
    // OR
    // return source.FirstOrDefault(predicate);
}

And that is really just redundant. Especially when your calling code would be actually longer using the helper method:

var result = FirstOrDefault(_gam.PAC, pac => pac.CODI_PAC == codiPac);
// versus
var result = _gam.PAC.FirstOrDefault(pac => pac.CODI_PAC == codiPac);

And even worse, your code is no longer using a fluent, composable syntax. This just makes readability and maintenance more difficult.

If you stick with using the IQueryable<T> extension methods then you can do composition like this:

var result = _gam.PAC
        .Where(pac => pac.CODI_PAC == codiPac)
        .Where(pac => pac.SomeOtherProperty == someOtherValue)
        .FirstOrDefault();
// OR

var result = (from pac in _gam.PAC
              where pac.CODI_PAC == codiPac
              where pac.SomeOtherProperty == someOtherValue
              select pac).FirstOrDefault();

One very important thing to note here is that the predicate parameter in the IQueryable<T>.Where<T>(...) extension method is of type Expression<Func<T, bool>>. This allows the IQueryable<T> provider to construct the native SQL (or other native provider query) at the very last moment before returning a result.

Not using Expression<Func<T, bool>> means that your query would be the equivalent of this:

var result =
    _gam.PAC
        .ToArray()
        .Where(pac => pac.CODI_PAC == codiPac)
        .FirstOrDefault();

And that would mean the query will load every record from the “PAC” table into memory before selecting the first filtered result and throwing out the rest of the results.

The bottom-line is that by making a generic helper method you are rewriting existing framework code and you open yourself to performance and maintenance issues while also reducing code readability.

I hope this helps.