private static void Main(string[] args)
{
var generic_processor = new GenericProcessor <Derived>();
var polymorphic_processor = new PolymorphicProcessor();
Stopwatch sw = new Stopwatch();
int N = 100000000;
var derived = new Derived();
sw.Start();
for (int i = 0; i < N; ++i)
{
polymorphic_processor.process(derived);
}
sw.Stop();
Console.WriteLine(
"Sum =" + polymorphic_processor.Sum + " Poly performance = " + sw.ElapsedMilliseconds + " millisec");
sw.Restart();
sw.Start();
for (int i = 0; i < N; ++i)
{
generic_processor.process(derived);
}
sw.Stop();
Console.WriteLine(
"Sum =" + generic_processor.Sum + " Generic performance = " + sw.ElapsedMilliseconds + " millisec");
Console.Read();
}
public void LoadMap(List <TClass> entities, IQueryable <TClass> query)
{
var entityPool = new EntityPool();
var deDupe = GenericProcessor.ProcessEntities(entityPool, query.GetDataContext <IDataContext>(), entities);
entities.Clear();
entities.AddRange(deDupe);
foreach (var propertyAccessor in Properties.OrderBy(x => x.PropertyName))
{
if (propertyAccessor is PropertyAccessor <TClass> accessorImpl)
{
accessorImpl.Load(entityPool, entities, query);
}
else if (typeof(TClass).IsAssignableFrom(propertyAccessor.DeclaringType))
{
dynamic dynamicAccessor = propertyAccessor;
LoadForInheritedType(entityPool, dynamicAccessor, entities, query);
}
else
{
throw new PropertyAccessorNotFoundException($"PropertyAccessor<{typeof(TClass).Name}> not found");
}
}
}
public void Test_ExecutesEachExecutorsIfDetectorReturnsTrue()
{
detector.Setup(d => d.Find()).Returns(true);
var processor = new GenericProcessor(detector.Object, configAppender.Object, assemMover.Object);
processor.Execute();
configAppender.Verify(c => c.Execute(), Times.Once);
assemMover.Verify(a => a.Move(), Times.Once);
}
public void Test_DoesNothingIfDetectorReturnsFalse()
{
detector.Setup(d => d.Find()).Returns(false);
var processor = new GenericProcessor(detector.Object, configAppender.Object, assemMover.Object);
processor.Execute();
configAppender.Verify(c => c.Execute(), Times.Never);
assemMover.Verify(a => a.Move(), Times.Never);
}
/// <summary>
/// Loads an Assembly ang gets its Name
/// </summary>
/// <param name="a">Assembly to load</param>
/// <returns>Generic Processor component</returns>
private static GenericProcessor LoadProcessorAssembly(Assembly a)
{
GenericProcessor retValue = null;
foreach (Type type in a.GetTypes())
{
if (type.IsPublic) // Ruft einen Wert ab, der angibt, ob der Type als öffentlich deklariert ist.
{
if (!type.IsAbstract) //nur Assemblys verwenden die nicht Abstrakt sind
{
// Sucht die Schnittstelle mit dem angegebenen Namen.
Type typeInterface = type.GetInterface(Type.GetType("GenericHandler.GenericProcessor").ToString(), true);
//Make sure the interface we want to use actually exists
if (typeInterface != null)
{
object activedInstance = Activator.CreateInstance(type);
if (activedInstance != null)
{
GenericProcessor script = (GenericProcessor)activedInstance;
retValue = script;
if (Processors == null)
{
Processors = new List <GenericProcessor>();
}
Processors.Add(retValue);
Console.WriteLine("Loaded Processor: {0}", retValue);
}
}
typeInterface = null;
}
}
}
a = null;
return(retValue);
}
