generic class for linq / lambda expression

First, you would need to have all of your Entities implement either an interface or an abstract class that contains both the ID and ModStamp properties in it, let's call it Stampable:

public abstract class Stampable 
{
  [Key]
  public int ID { get; set; } 

  [Required]
  public string ModStamp { get; set; }
}

At that point, all you need to do for your method is to have it implement generic typing:

protected internal override string GetModStampInChild<T>(int sid) where T : Stampable
{
    using (var sq = new DbContext())
    {
      return sq.Set<T>.Where(s => s.id == sid)
                      .Select(s => s.modstamp)
                      .SingleOrDefault()
                      .ToModStampString();
    }
}

If I understand you correctly, you need a property Set<T> of DbContext class:

First, create base class of all your entity classes with id and modstamp properties. Then:

protected internal override string GetModStampInChild<T>(int sid) where T : BaseEntity
{
    using (var sq = new DbContext())
    {
        return sq.Set<T>.Where(s => s.id == sid)
                        .Select(s => s.modstamp)
                        .SingleOrDefault()
                        .ToModStampString();
    }
}

But you must use code-first paradigm for this method.

Another option would be add a new Property to your entity class via the partial class feature of c#.

So the entity definition generated might look like this, note I have no idea what the actual DataType of your ModStamp column is:

public partial class Company
{
    public int Id { get; set; }
    public byte[] ModStamp { get; set; }
    public string Name { get; set; }
    public string City { get; set; }
    public string State { get; set; }
}

Note the ModStamp column that you want to convert.

Then add to the Partial.cs file that EF creates code like this, note I have no idea what you actually want to do with the ModStamp value:

public static class ModConverter
{
    public static string ToModStampString(byte[] modStamp)
    {
        return BitConverter.ToString(modStamp);
    }
}

public partial class Company
{
    public string ModStampString 
    {
        get
        {
            return ModConverter.ToModStampString(this.ModStamp);
        }
    }
}

You would then have to manually add a new ModStampString Get Property for every Entity with a ModStamp Column like I did for the Company Entity.

Here is a solution that uses the Set method on the DbContext and expression trees to dynamically query that object.

private Expression<Func<TArg, bool>> CreatePredicate<TArg, TPredicateField>(string fieldName, TPredicateField value)
{
    ParameterExpression parameter = Expression.Parameter(typeof(TArg), "o");

    MemberExpression memberExpression = Expression.Property(parameter, fieldName);

    var condition = Expression.Equal(memberExpression, Expression.Constant(value));
    var lambda = Expression.Lambda<Func<TArg, bool>>(condition, parameter);

    return lambda;
}

private Expression<Func<TArg, TPredicateField>> CreateSelector<TArg, TPredicateField>(string fieldName)
{
    ParameterExpression parameter = Expression.Parameter(typeof(TArg), "o");
    Expression propertyExpr = Expression.Property(parameter, fieldName);

    var lambda = Expression.Lambda<Func<TArg, TPredicateField>>(propertyExpr, parameter);

    return lambda;
}

public TSelectorField GetModStamp<TEntity, TPredicateField, TSelectorField>(TPredicateField id) where TEntity : class
{
    using (var ctx = new OnTheFlyEntities("Data Source=(local);Initial Catalog=AscensionBO;Integrated Security=True;MultipleActiveResultSets=True"))
    {
        var predicate = CreatePredicate<TEntity, TPredicateField>("Id", id);
        var selector = CreateSelector<TEntity, TSelectorField>("ModStamp");

        TSelectorField item = ctx.Set<TEntity>().Where(predicate).Select(selector).SingleOrDefault();

        return item;
    }
}

You can then call it like this:

GetModStamp<Entity2, int, string>(1)

If you were willing to just return the found entity, you could eliminate the TSelectorField and then grab the ModStamp from the item after it is retrieved. That will drop one of the expression tree methods and a generic input on the main method.

As someone else suggested, you could go the interface route and use that example, it will be much simpler.