it’s off course iidgenerator <Id> and GetIdGenerator <Tentity >

public abstract class TestEntityBuilder where TEntity : Entity

{
public TEntity Build()
{
var entity = CreateEntityWithDefaultProperties();
entity.Id = GetIdGeneratorFor(entity).GenerateId();

return entity;

}

private IIdGenerator GetIdGeneratorFor (TEntity entity) where TEntity : Entity

{
if (type == typeof(int))
{
return new IntIdGenerator() as IdGenerator;
}
…

However, in general terms what you’re doing is just plain nasty. You could make the get generator method abstract and have subclasses for int and guid, or take the generator as a constructor dependency. In production code I’d probably favour the latter (NH anyone?) but the convenience of the former is likely to be a win for testing code.

And I’ve no particular objection to using dynamic, it just feels like overkill.

i wouldn’t say that it’s wrong… i think most of us can agree by now (given the success of weakly typed languages over the past couple of years) that weak typing can’t be as bad as we were always told it was

and yeah, it is possible (apparently) to return the specific type in this situation… but even then it just feels so cumbersome to do so. You’re basically paying lip service to the compiler and that is truly the only reason why you’d use that cast.

// marker interface
public interface IKey {}

public struct IntKey : IKey {…}

public struct GuidKey : IKey {…}

Now you can be generic on IKey.

If you want to be relaxed about it, you can provide implicit conversion operators to go to/from the underlying types. But if you keep things strict, you can do stuff like make your keys immutable.

Not simple to introduce to an existing app, though.

Why do you prefer the dynamic version though? I would even say it’s utterly useless here

huh… i could’ve sworn we’ve tried that, but you’re right… that works

though i still prefer the dynamic version :p

private static readonly IDictionary<Type, object>
fIdGenerators = InitializeIdGenerators();

private static IDictionary<Type, object> InitializeIdGenerators()
{
var generators = new Dictionary<Type, object>();
generators.Add(typeof(int), new IntIdGenerator());
generators.Add(typeof(Guid), new GuidIdGenerator());
return generators;
}

private static IIdGenerator<TId> GetIdGenerator()
{
object generator;
return fIdGenerators.TryGetValue(typeof(TId), out generator)
? generator as IIdGenerator<TId>
: null;
}

there is no IIdGenerator type… and AFAIK, you can’t cast it explicitly to a generic instance of IIdGenerator of the correct type (either long or guid)

so your code wouldn’t compile either

@Adam

yeah you could… but this class was meant to be used during testing so maybe IOC is a bit over the top then

Second, the error message gives a tip of how you can solve it: you can cast it explicitely, like this:

private static IIdGenerator<TId> GetIdGenerator()
{
return typeof(TId) == typeof(int)
? new IntIdGenerator() as IIdGenerator
: new GuidIdGenerator() as IIdGenerator;
}