/// <summary>
/// Retrieves the list of types available in the assemblies found by the <see cref="AssemblyFinder"/> specified in the constructor.
/// </summary>
/// <param name="baseType">The base type to match. Can be null.</param>
/// <param name="excludeGlobalTypes">Indicates whether types from all referenced assemblies should be checked.</param>
/// <returns>
/// A collection of types that match the criteria specified by baseType and excludeGlobalTypes.
/// </returns>
public ICollection GetTypes(Type baseType, bool excludeGlobalTypes)
{
var nonNullBaseType = baseType ?? typeof(object);
if (nonNullBaseType.IsSealed) // ValueTypes are also sealed
{
return new[] { nonNullBaseType }
}
;
if (!excludeGlobalTypes && AssemblyTypeCache.IsGacAssembly(nonNullBaseType.Assembly))
{
return(_globalTypesCache.GetOrAdd(
nonNullBaseType,
key =>
{
s_log.Value.DebugFormat("Discovering types derived from '{0}', including GAC...", key);
using (StopwatchScope.CreateScope(
s_log.Value,
LogLevel.Info,
string.Format("Discovered types derived from '{0}', including GAC. Time taken: {{elapsed}}", key)))
{
return GetTypesFromAllAssemblies(key, false).ToList().AsReadOnly();
}
}));
}
var baseTypeCache = _baseTypeCache.Value;
Assertion.IsTrue(_baseTypeCache.IsValueCreated);
return(baseTypeCache.GetTypes(nonNullBaseType));
}
public void Resume_AfterDispose()
{
var scope = StopwatchScope.CreateScope((context, s) => { });
scope.Dispose();
scope.Resume();
}
// The MixinConfiguration is passed to Execute in order to be able to call PrepareOutputDirectory before analyzing the configuration (and potentially
// locking old generated files).
public void Execute(MixinConfiguration configuration)
{
ArgumentUtility.CheckNotNull("configuration", configuration);
using (StopwatchScope.CreateScope(s_log, LogLevel.Info, "Time needed to mix and save all types: {elapsed}."))
{
_errors.Clear();
_processedTypes.Clear();
_finishedTypes.Clear();
_generatedFiles = new string[0].AsReadOnly();
s_log.InfoFormat("The base directory is '{0}'.", AppDomain.CurrentDomain.BaseDirectory);
var pipeline = MixerPipelineFactory.CreatePipeline(AssemblyOutputDirectory);
var mixedTypes = MixedTypeFinder.FindMixedTypes(configuration).ToArray();
s_log.Info("Generating types...");
using (configuration.EnterScope())
{
foreach (var mixedType in mixedTypes)
{
Generate(mixedType, pipeline);
}
}
s_log.Info("Saving assemblies...");
Save(pipeline);
}
s_log.InfoFormat("Successfully generated concrete types for {0} target classes.", _finishedTypes.Count);
}
protected StopwatchScope CreateStopwatchScopeForQueryExecution(string queryName)
{
return(StopwatchScope.CreateScope(
s_log,
LogLevel.Debug,
"Fetched " + queryName + " into " + GetType().Name + ". Time taken: {elapsed:ms}ms"));
}
private static void TestComplexLinqQuery()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope("Complex query took {elapsed:ms} ms"))
{
var result = from acl in QueryFactory.CreateLinqQuery <StatefulAccessControlList>()
from sc in acl.GetStateCombinationsForQuery()
from usage in sc.GetStateUsagesForQuery().DefaultIfEmpty()
from propertyReference in acl.GetClassForQuery().GetStatePropertyReferencesForQuery().DefaultIfEmpty()
select new
{
Class = acl.GetClassForQuery().ID,
Acl = acl.ID.GetHandle <StatefulAccessControlList>(),
HasState = propertyReference != null,
StatePropertyID = propertyReference.StateProperty.ID.Value,
StatePropertyClassID = propertyReference.StateProperty.ID.ClassID,
StatePropertyName = propertyReference.StateProperty.Name,
StateValue = usage.StateDefinition.Name
};
result.Count();
}
}
}
public AccessType[] GetAccessTypes(IDomainObjectHandle <AccessControlList> aclHandle, SecurityToken token)
{
ArgumentUtility.CheckNotNull("aclHandle", aclHandle);
ArgumentUtility.CheckNotNull("token", token);
using (SecurityFreeSection.Activate())
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope(
s_log,
LogLevel.Info,
string.Format(
"Evaluated access types of ACL '{0}' for principal '{1}'. Time taken: {{elapsed:ms}}ms",
aclHandle.ObjectID,
token.Principal.User != null ? token.Principal.User.ObjectID.ToString() : "<unknown>")))
{
LoadAccessTypeDefinitions();
var acl = LoadAccessControlList(aclHandle);
var accessInformation = acl.GetAccessTypes(token);
return(Array.ConvertAll(accessInformation.AllowedAccessTypes, ConvertToAccessType));
}
}
}
}
private StopwatchScope CreateStopwatchScopeForQueryParsing(string queryName)
{
return(StopwatchScope.CreateScope(
s_log,
LogLevel.Debug,
"Parsed query for " + GetType().Name + "." + queryName + "(). Time taken: {elapsed:ms}ms"));
}
public static BaseTypeCache Create(IEnumerable <Type> types)
{
ArgumentUtility.CheckNotNull("types", types);
s_log.Value.DebugFormat("Beginning to build BaseTypeCache...");
using (StopwatchScope.CreateScope(s_log.Value, LogLevel.Debug, string.Format("Built BaseTypeCache. Time taken: {{elapsed}}")))
{
// Note: there is no meassurable impact when switching this code to parallel execution.
var classes = new List <KeyValuePair <Type, Type> >();
var interfaces = new List <KeyValuePair <Type, Type> >();
foreach (var type in types)
{
classes.AddRange(
type.CreateSequence(t => t.BaseType)
.Where(t => !t.IsInterface)
.Select(baseType => new KeyValuePair <Type, Type> (baseType, type)));
interfaces.AddRange(
type.GetInterfaces()
.Select(interfaceType => new KeyValuePair <Type, Type> (interfaceType, type)));
if (type.IsInterface)
{
interfaces.Add(new KeyValuePair <Type, Type> (type, type));
}
}
var classCache = classes.ToLookup(kvp => kvp.Key, kvp => kvp.Value, MemberInfoEqualityComparer <Type> .Instance);
var interfaceCache = interfaces.ToLookup(kvp => kvp.Key, kvp => kvp.Value, MemberInfoEqualityComparer <Type> .Instance);
return(new BaseTypeCache(classCache, interfaceCache));
}
}
public void New()
{
var args = new object[]
{
new TestConstructorInjectionWithOneParameter(null),
new TestConstructorInjectionWithOneParameter(null),
new TestConcreteImplementationAttributeType()
};
Func <object> factory = () => new TestConstructorInjectionWithThreeParameters(
(ITestConstructorInjectionWithOneParameter)args[0],
(ITestConstructorInjectionWithOneParameter)args[1],
(ITestSingletonConcreteImplementationAttributeType)args[2]);
int acc = 0;
using (StopwatchScope.CreateScope("New: elapsed: {elapsed}"))
{
for (int i = 0; i < 1000000; ++i)
{
var instance = factory();
acc ^= instance.GetHashCode();
}
}
Console.WriteLine(acc);
}
public void Checkpoint_AfterDispose()
{
var scope = StopwatchScope.CreateScope((context, s) => { });
scope.Dispose();
scope.Checkpoint("");
}
public void Checkpoint()
{
var times = new List <Tuple <string, TimeSpan, TimeSpan> > ();
using (var scope = StopwatchScope.CreateScope((context, s) => times.Add(Tuple.Create(context, s.ElapsedTotal, s.ElapsedSinceLastCheckpoint))))
{
Wait(TimeSpan.FromMilliseconds(5.0));
scope.Checkpoint("One");
Wait(TimeSpan.FromMilliseconds(5.0));
scope.Checkpoint("Two");
Wait(TimeSpan.FromMilliseconds(5.0));
}
Assert.That(times.Count, Is.EqualTo(3));
Assert.That(times[0].Item1, Is.EqualTo("One"));
Assert.That(times[0].Item2, Is.GreaterThan(TimeSpan.FromMilliseconds(5.0))); // total
Assert.That(times[0].Item3, Is.GreaterThan(TimeSpan.FromMilliseconds(5.0))); // since last checkpoint
Assert.That(times[1].Item1, Is.EqualTo("Two"));
Assert.That(times[1].Item2, Is.GreaterThan(times[0].Item2 + TimeSpan.FromMilliseconds(5.0))); // total
Assert.That(times[1].Item3, Is.GreaterThan(TimeSpan.FromMilliseconds(5.0))); // since last checkpoint
Assert.That(times[1].Item3, Is.LessThan(times[1].Item2));
Assert.That(times[2].Item1, Is.EqualTo("end"));
Assert.That(times[2].Item2, Is.GreaterThan(times[1].Item2 + TimeSpan.FromMilliseconds(5.0))); // total
Assert.That(times[2].Item3, Is.GreaterThan(TimeSpan.FromMilliseconds(5.0))); // since last checkpoint
Assert.That(times[2].Item3, Is.LessThan(times[2].Item2));
}
public void LinqExpression()
{
var args = new object[]
{
new TestConstructorInjectionWithOneParameter(null),
new TestConstructorInjectionWithOneParameter(null),
new TestConcreteImplementationAttributeType()
};
var ctorInfo = typeof(TestConstructorInjectionWithThreeParameters).GetConstructors()[0];
var ctorArgExpressions = ctorInfo.GetParameters().Select(p => (Expression)Expression.Constant(args[p.Position]));
Expression <Func <object> > factoryExpression = Expression.Lambda <Func <object> > (Expression.New(ctorInfo, ctorArgExpressions));
Func <object> factory = factoryExpression.Compile();
int acc = 0;
using (StopwatchScope.CreateScope("Built factory: elapsed: {elapsed}"))
{
for (int i = 0; i < 1000000; ++i)
{
var instance = factory();
acc ^= instance.GetHashCode();
}
}
Console.WriteLine(acc);
}
private static MixinConfiguration BuildMasterConfiguration()
{
s_log.Info("Building mixin master configuration...");
using (StopwatchScope.CreateScope(s_log, LogLevel.Info, "Time needed to build mixin master configuration: {elapsed}."))
{
return(DeclarativeConfigurationBuilder.BuildDefaultConfiguration());
}
}
private static void ExecuteFirstLinqQuery()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope("Executing first Linq query took {elapsed:ms} ms."))
QueryFactory.CreateLinqQuery <Position>().ToList();
}
}
private static void InitializeLinq()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope("Initializing Linq took {elapsed:ms} ms."))
QueryFactory.CreateLinqQuery <Tenant>();
}
}
public void CreateScope_Log()
{
var logMock = MockRepository.GenerateMock <ILog> ();
var scope = StopwatchScope.CreateScope(logMock, LogLevel.Error, "{context}#{elapsed}#{elapsed:ms}#{elapsedCP}#{elapsedCP:ms}");
Wait(TimeSpan.FromMilliseconds(1.0));
scope.Pause();
var firstElapsed = scope.ElapsedTotal;
var firstElapsedCP = scope.ElapsedSinceLastCheckpoint;
scope.Checkpoint("one");
scope.Resume();
Wait(TimeSpan.FromMilliseconds(1.0));
scope.Pause();
var secondElapsed = scope.ElapsedTotal;
var secondElapsedCP = scope.ElapsedSinceLastCheckpoint;
scope.Dispose();
var expectedFirstArgs = new[] {
"one",
firstElapsed.ToString(),
firstElapsed.TotalMilliseconds.ToString(),
firstElapsedCP.ToString(),
firstElapsedCP.TotalMilliseconds.ToString()
};
logMock.AssertWasCalled(
mock =>
mock.LogFormat(
Arg.Is(LogLevel.Error),
Arg <int> .Is.Null,
Arg <Exception> .Is.Null,
Arg.Is("{0}#{1}#{2}#{3}#{4}"),
Arg <object[]> .List.Equal(expectedFirstArgs)));
var expectedSecondArgs = new[] {
"end",
secondElapsed.ToString(),
secondElapsed.TotalMilliseconds.ToString(),
secondElapsedCP.ToString(),
secondElapsedCP.TotalMilliseconds.ToString()
};
logMock.AssertWasCalled(
mock => mock.LogFormat(
Arg.Is(LogLevel.Error),
Arg <int> .Is.Null,
Arg <Exception> .Is.Null,
Arg.Is("{0}#{1}#{2}#{3}#{4}"),
Arg <object[]> .List.Equal(expectedSecondArgs)));
}
private static void TestSimpleLinqQueryWithCustomProjection()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope("Simple Linq query with custom projection took {elapsed:ms} ms"))
{
QueryFactory.CreateLinqQuery <Tenant>().Select(p => new { Value = p.ID, Key = p.UniqueIdentifier }).ToList();
}
}
}
public void Pause()
{
var scope = StopwatchScope.CreateScope((context, s) => { });
scope.Pause();
var elapsedBefore = scope.ElapsedTotal;
Wait(TimeSpan.FromMilliseconds(5.0));
Assert.That(scope.ElapsedTotal, Is.EqualTo(elapsedBefore));
}
private void LoadAccessTypeDefinitions()
{
using (StopwatchScope.CreateScope(s_log, LogLevel.Debug, "Fetched access types for AccessResolver. Time taken: {elapsed:ms}ms"))
{
s_queryCache.ExecuteCollectionQuery <AccessTypeDefinition> (
ClientTransaction.Current,
MethodInfo.GetCurrentMethod().Name,
accessTypes => accessTypes);
}
}
private static void TestSimpleLinqQuery()
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope("Simple Linq query took {elapsed:ms} ms"))
{
QueryFactory.CreateLinqQuery <Position>().ToList();
}
}
}
private ICollection <RootAssembly> FindRootAssemblies()
{
s_log.Value.Debug("Finding root assemblies...");
using (StopwatchScope.CreateScope(s_log.Value, LogLevel.Debug, "Time spent for finding and loading root assemblies: {elapsed}."))
{
return(_rootAssemblyFinder.FindRootAssemblies()
.LogAndReturnItems(s_log.Value, LogLevel.Debug, count => string.Format("Found {0} root assemblies.", count))
.ToList());
}
}
private void WriteDocumentToIndex(object doc, RavenIndexWriter indexWriter, Analyzer analyzer, Stopwatch convertToLuceneDocumentDuration, Stopwatch addDocumentDutation)
{
string reduceKeyAsString;
using (StopwatchScope.For(convertToLuceneDocumentDuration))
{
float boost;
try
{
var fields = GetFields(doc, out boost);
reduceKeyAsString = ExtractReduceKey(ViewGenerator, doc);
reduceKeyField.SetValue(reduceKeyAsString);
reduceValueField.SetValue(ToJsonDocument(doc).ToString(Formatting.None));
luceneDoc.GetFields().Clear();
luceneDoc.Boost = boost;
luceneDoc.Add(reduceKeyField);
luceneDoc.Add(reduceValueField);
foreach (var field in fields)
{
luceneDoc.Add(field);
}
}
catch (Exception e)
{
Context.AddError(indexId,
parent.PublicName,
TryGetDocKey(doc),
e,
"Reduce"
);
logIndexing.WarnException("Could not get fields to during reduce for " + parent.PublicName, e);
return;
}
}
batchers.ApplyAndIgnoreAllErrors(
exception =>
{
logIndexing.WarnException(
string.Format("Error when executed OnIndexEntryCreated trigger for index '{0}', key: '{1}'",
indexId, reduceKeyAsString),
exception);
Context.AddError(indexId, parent.PublicName, reduceKeyAsString, exception, "OnIndexEntryCreated Trigger");
},
trigger => trigger.OnIndexEntryCreated(reduceKeyAsString, luceneDoc));
parent.LogIndexedDocument(reduceKeyAsString, luceneDoc);
using (StopwatchScope.For(addDocumentDutation))
{
parent.AddDocumentToIndex(indexWriter, luceneDoc, analyzer);
}
}
public void Dispose_AfterDispose()
{
int counter = 0;
var scope = StopwatchScope.CreateScope((context, s) => ++ counter);
scope.Dispose();
Assert.That(counter, Is.EqualTo(1));
scope.Dispose();
Assert.That(counter, Is.EqualTo(1));
}
private BaseTypeCache CreateBaseTypeCache()
{
s_log.Value.DebugFormat("Creating cache for all types in application directory...");
using (StopwatchScope.CreateScope(
s_log.Value,
LogLevel.Info,
"Created cache for all types in application directory. Time taken: {elapsed}"))
{
return(BaseTypeCache.Create(GetTypesFromAllAssemblies(null, true)));
}
}
private User GetUser(string userName)
{
using (StopwatchScope.CreateScope(
s_log,
LogLevel.Info,
"Refreshed data in CachedUser for user '" + userName + "'. Time taken: {elapsed:ms}ms"))
{
var clientTransaction = ClientTransaction.CreateRootTransaction();
return(LoadUser(clientTransaction, userName));
}
}
public static TargetClassDefinition CreateWithoutValidation(ClassContext context)
{
ArgumentUtility.CheckNotNull("context", context);
s_log.DebugFormat("Creating an unvalidated class definition for: {0}.", context);
using (StopwatchScope.CreateScope(s_log, LogLevel.Debug, "Time needed to create class definition: {elapsed}."))
{
return(CreateInternal(context));
}
}
public RelationDefinition[] GetRelationDefinitions(IDictionary <Type, ClassDefinition> classDefinitions)
{
ArgumentUtility.CheckNotNull("classDefinitions", classDefinitions);
s_log.InfoFormat("Reflecting relation definitions of {0} class definitions...", classDefinitions.Count);
using (StopwatchScope.CreateScope(s_log, LogLevel.Info, "Time needed to reflect relation definitions: {elapsed}."))
{
var relationDefinitions = MappingObjectFactory.CreateRelationDefinitionCollection(classDefinitions);
return(relationDefinitions
.LogAndReturnValue(s_log, LogLevel.Info, result => string.Format("Generated {0} relation definitions.", result.Length)));
}
}
public void CreateScope_Console()
{
var oldOut = Console.Out;
var writerMock = MockRepository.GenerateMock <TextWriter> ();
Console.SetOut(writerMock);
try
{
var scope = StopwatchScope.CreateScope("{context}#{elapsed}#{elapsed:ms}#{elapsedCP}#{elapsedCP:ms}");
Wait(TimeSpan.FromMilliseconds(1.0));
scope.Pause();
var firstElapsed = scope.ElapsedTotal;
var firstElapsedCP = scope.ElapsedSinceLastCheckpoint;
scope.Checkpoint("one");
scope.Resume();
Wait(TimeSpan.FromMilliseconds(1.0));
scope.Pause();
var secondElapsed = scope.ElapsedTotal;
var secondElapsedCP = scope.ElapsedSinceLastCheckpoint;
scope.Dispose();
var expectedFirstArgs = new[]
{
"one",
firstElapsed.ToString(),
firstElapsed.TotalMilliseconds.ToString(),
firstElapsedCP.ToString(),
firstElapsedCP.TotalMilliseconds.ToString()
};
writerMock.AssertWasCalled(mock => mock.WriteLine(Arg.Is("{0}#{1}#{2}#{3}#{4}"), Arg <object[]> .List.Equal(expectedFirstArgs)));
var expectedSecondArgs = new[]
{
"end",
secondElapsed.ToString(),
secondElapsed.TotalMilliseconds.ToString(),
secondElapsedCP.ToString(),
secondElapsedCP.TotalMilliseconds.ToString()
};
writerMock.AssertWasCalled(mock => mock.WriteLine(Arg.Is("{0}#{1}#{2}#{3}#{4}"), Arg <object[]> .List.Equal(expectedSecondArgs)));
}
finally
{
Console.SetOut(oldOut);
}
}
public void ElapsedSinceLastCheckpoint_AfterScopeDisposed()
{
var scope = StopwatchScope.CreateScope((context, s) => { });
scope.Checkpoint("test");
Wait(TimeSpan.FromMilliseconds(1.0));
Assert.That(scope.ElapsedSinceLastCheckpoint, Is.GreaterThan(TimeSpan.Zero));
scope.Dispose();
Assert.That(scope.ElapsedSinceLastCheckpoint, Is.EqualTo(TimeSpan.Zero));
}
public void RecordDuration_DurationRecorded()
{
StopwatchScope subject = new StopwatchScope();
using (subject.RecordDuration)
{
//Yield
Thread.Sleep(0);
}
Assert.Greater(subject.Value.ElapsedTicks, 0);
}
public ClassDefinition[] GetClassDefinitions()
{
s_log.Info("Reflecting class definitions...");
using (StopwatchScope.CreateScope(s_log, LogLevel.Info, "Time needed to reflect class definitions: {elapsed}."))
{
var types = GetDomainObjectTypesSorted();
var classDefinitions = MappingObjectFactory.CreateClassDefinitionCollection(types);
return(classDefinitions
.LogAndReturnValue(s_log, LogLevel.Info, result => string.Format("Generated {0} class definitions.", result.Length)));
}
}
