Develop Reference

Register a generic Validator using FluentValidation and Autofac

I have a generic class that handles different entities the same manner. I'm trying to implement a Validator in this generic class, the Validator type should change depending on the generic type. For example if the type is Person, the PersonValidator should get initialized. How is this possible using FluentValidation and Autofac? I've tried it using a generic BaseValidator but I cannot seem to register it correctly so the PersonValidator doesn't get called.
Generic class
var validator = new BaseValidator<TEntity>(); // TEntity = Person
await validator.ValidateAndThrowAsync(person);
BaseValidator
public class BaseValidator<TEntity> : AbstractValidator<TEntity>
{
}
PersonValidator
public class PersonValidator : BaseValidator<Person>
{
public PersonValidator()
{
RuleFor(x => x.Name).NotEmpty();
}
}
Autofac registrations that I've tried
builder.RegisterGeneric(typeof(BaseValidator<>)).As(typeof(IValidator<>)).InstancePerDependency();
builder.RegisterType<BaseValidator<Person>().As(typeof(IValidator<Person>)).InstancePerDependency();
builder.RegisterType<PersonValidator>().As(typeof(IValidator<Person>)).InstancePerDependency();
builder.RegisterType<PersonValidator>().As(typeof(BaseValidator<Person>)).InstancePerDependency();

You can't use var validator = new BaseValidator<TEntity>(); You have to inject an IValidator<Person> in your ctor (or IValidator<T>).

Generics with runtime Types

I am using Moq and want to mock an interface which inherits from ICloneable. I am using Newtonsoft.Json to serialise and deserialise my object to a cloned instance.
The interface:
public interface ITestInterface : ICloneable
{
int Number { get; set; }
string Text { get; set; }
string MethodCallResult { get; set; }
void CallMe();
}
I am trying to use generics to convert the object but I cannot know the actual runtime type of the proxy which Moq will provide.
Using the debugger through the following method I can see that the runtime type is a proxy but the type of the generic 'T' is the interface, ITestInterface, which cannot be serialised. How can I use the real runtime type with generics to serialize/deserialize these objects? I would just pass the type as a parameter but I do not know it at compile time.
private object CreateClone<T>(T item)
where T : class
{
var realRuntimeType = item.GetType(); //is a proxy created by Moq inheriting from the interface
var itemAsSerializedString = JsonConvert.SerializeObject( item );
return JsonConvert.DeserializeObject<T>( itemAsSerializedString ); //wont work, tries to instantiate interface
}
Usage (note that the generic parameter is inferred, not explicit):
var mock = new Mock<ITestInterface>();
mock.Setup(m => m.Clone()).Returns(CreateClone(mock.Object));
Exception:
Newtonsoft.Json.JsonSerializationException : Could not create an instance of type Processus.Tests.ITestInterface. Type is an interface or abstract class and cannot be instantiated.

Repository Pattern with Generic interface and DI in EF

i have this existing code
public interface IRepository<T>
{
void Create(T obj);
T Retrieve(string key);
}
public class ItemRepository : IRepository<Item>
{
public void Create(Item obj)
{
//codes
}
public Item Retrieve(string key)
{
//codes
}
}
i would like to create a General class repository where i have to inject a type of IRepository to the constructor then use its own implementation of the methods. i already have an existing code but it is currently wrong
public class Repository
{
IRepository<T> action = null;
public Repository(IRepository<T> concreteImplementation)
{
this.action = concreteImplementation;
}
public void Create(T obj)
{
action.Create(obj);
}
}
the classes are from EF. if there is no work around for this what will be the best approach?

If I understand you correctly you want a single repository which can create or retrieve an object of any type by delegating to a type specific repository implementation?
How do you imagine this working? you defined this Repository class, but you have to create a concrete implementation of the actual repository in order to use it, and then still have to create an instance of Repository anyway. Why not just use the generic implementation you have to create anyway?
And what about your Retrieve method? How will this look in your Repository class? Will you just return Object? or will you make your method generic?
Anyway to answer your question, you could do this I suppose:
public class Repository
{
IRepository action = null;
public Repository(IRepository concreteImplementation)
{
this.action = concreteImplementation;
}
public void Create<T>(T obj)
{
action.Create(obj);
}
}
but you have to introduce a non generic interface as well, as you can't require an interface with a generic parameter in the constructor without specifying the generic type on the class.
public interface IRepository
{
void Create(object obj);
object Retrieve(string key);
}
Or possibly you could pass in the type into the Create method instead of having a generic parameter:
public class Repository
{
IRepository action = null;
public Repository(IRepository concreteImplementation, Type respositoryType)
{
this.action = concreteImplementation;
expectedType=repositoryType;
}
public void Create(Type type, Object obj)
{
if(type==expected && obj.GetType()==type)
{
action.Create(obj);
}
}
}
but both of these are terrible ideas. Just use the generics and create a repository per type, it'll be best in the long run

I think you might just be missing the definition of T in the context of the general repository class.
Try adding <T> to the it like this:
public class Repository<T>
{
...
}

Why can't I use generics with CreateCriteria in NHibernate?

In my Base repo I have this code which works fine:
abstract class BaseRepo <T> : IRepo <T>
{
private ISession _session;
public Entity GetById<Entity>(int Id)
{
return _session.Get<Entity>(Id);
}
// other methods
}
I want to add another method to return all rows for an object (entity). I want to do something like:
public IList<Entity> GetAll<Entity>()
{
return _session.CreateCriteria<Entity>().List<Entity>;
}
but I get an error saying:
The type 'Entity' must be a reference type in order to use it as parameter 'T' in the generic type or method 'NHibernate.ISession.CreateCriteria<T>()'
Here's my DAL design for reference: Should I use generics to simplify my DAL?

CreateCriteria method requires you to use reference types - add constraint on your DAL method:
public IList<Entity> GetAll<Entity>()
where Entity : class
{
return _session.CreateCriteria<Entity>().List<Entity>();
}
This naturally implies that any Entity type you pass to this method must be a reference type.
I also suggest naming your generic type parameter TEntity - Entity alone is a bit confusing (as it's perfectly fine name for say, entity base class).

Partial trust: How to instantiate a generic type without a generic type argument

I'm creating a reusable library for Silverlight. The library contains an internal generic type and I need to create a new instance of this generic type, but I at one point I don't have a generic type argument available, only a System.Type object that represents the generic argument. I tried to create an instance using reflection, but this fails, because this class is internal and Silverlight effectively runs in partial trust.
Here is what I tried so far:
private INonGenericInterface CreateInstance(Type type)
{
// Activator.CreateInstance fails
var instance = Activator.CreateInstance(
typeof(InternalGenericType<>).MakeGenericType(type));
// Invoking the default constructor of that type fails.
var producer = typeof(InternalGenericType<>)
.MakeGenericType(type)
.GetConstructor(new Type[0])
.Invoke(null);
return (INonGenericInterface)producer;
}
This is my internal type. Nothing fancy:
internal class InternalGenericType<T> : INonGenericInterface
where T : class
{
public InternalGenericType()
{
}
}
I even tried abusing the Nullable<T> struct as a factory for creating a factory that could produce my internal type. However, default Nullable<T> get converted to null references:
internal static class InternalGenericTypeFactory
{
public static INonGenericInterface Create(Type serviceType)
{
var nullType = typeof(Nullable<>).MakeGenericType(
typeof(Factory<>).MakeGenericType(serviceType));
// Activator succesfully creates the instance, but .NET
// automatically converts default Nullable<T>s to null.
object nullInstance = Activator.CreateInstance(nullType);
var getValueMethod =
nullType.GetMethod("GetValueOrDefault", new Type[0]);
// Invoke fails, because nullInstance is a null ref.
var factory = getValueMethod.Invoke(nullInstance, null);
return ((IFactory)factory).CreateInstance();
}
internal interface IFactory
{
INonGenericInterface CreateInstance();
}
internal struct Factory<T> : IFactory where T : class
{
public INonGenericInterface CreateInstance()
{
return new InternalGenericType<T>();
}
}
}
As you can imagine, I don't want to make this type public, because it would pollute my API. I'm currently out of ideas. What are my options? What can I do to create this internal type?

Third alternative is to support some sort of factory pattern which will contain a method to instanciate internal type. And you can expose factory or make factory type public.
public class TypeFactory
{
public static object Create<T>()
{
return new MyInternalType<T>();
}
}
You can leave class as internal and you can invoke TypeFactory's method via reflection.
public object CreateType(System.Type type)
{
Type typeFactory = typeof(TypeFactory);
MethodInfo m = typeFactory.GetMethod("Create").MakeGenericMethod(type);
return m.Invoke(null, null);
}
I think your TypeFactory should be public, it can not be internal.

You have two choices:
Make the type public
Avoid using reflection to do this, use generics instead.
If the safeguards were possible to avoid just because you didn't like them, there wouldn't be a need to have them at all.