public void Reflect(TestCaseAssembly testCase)
{
ObservableCollection <Message> messages = CoreData.Instance.Messages;
// Do the reflection
NRAssembly nrAssembly;
IFilter filter = new StatisticFilter(new ReflectAllFilter());
try
{
Reflector reflector = new Reflector();
nrAssembly = reflector.Reflect(testCase.FullPath, ref filter);
}
catch (Exception ex)
{
messages.Add(new Message {
MessageText = "Reflection failed with the following exception: " + ex.Message, Severity = MessageSeverity.Error
});
testCase.State = TestCaseState.ReflectionFailed;
return;
}
messages.Add(new Message {
MessageText = "Reflection successful.", Severity = MessageSeverity.Info
});
// Create relationships
RelationshipCreator relationshipCreator = new RelationshipCreator();
NRRelationships nrRelationships = relationshipCreator.CreateRelationships(nrAssembly);
// Save the results
testCase.CurrentResult = new NReflectResult(nrAssembly, nrRelationships);
}
/// <summary>
/// Compiles and reflects a single <see cref="TestCase"/>.
/// </summary>
/// <param name="testCase">The <see cref="TestCase"/> to run.</param>
public void CompileAndReflect(TestCaseCSharp testCase)
{
ObservableCollection <Message> messages = CoreData.Instance.Messages;
messages.Add(new Message {
MessageText = "Compilation of test case '" + testCase.Name + "' started.", Severity = MessageSeverity.Info
});
// Compile the code
CompilerResults compilerResults = Compile(new[] { testCase.Code });
List <Message> compileMessages = ToMessages(compilerResults.Errors, testCase.Name);
compileMessages.ForEach(messages.Add);
if (compileMessages.Count > 0)
{
messages.Add(new Message {
MessageText = "Compilation failed. Aboarding.", Severity = MessageSeverity.Error
});
testCase.State = TestCaseState.CompilationFailed;
return;
}
messages.Add(new Message {
MessageText = "Compilation successful.", Severity = MessageSeverity.Info
});
// Do the reflection
NRAssembly nrAssembly;
IFilter filter = new StatisticFilter(new ReflectAllFilter());
try
{
Reflector reflector = new Reflector();
nrAssembly = reflector.Reflect(compilerResults.CompiledAssembly, ref filter);
}
catch (Exception ex)
{
messages.Add(new Message {
MessageText = "Reflection failed with the following exception: " + ex.Message, Severity = MessageSeverity.Error
});
testCase.State = TestCaseState.ReflectionFailed;
return;
}
messages.Add(new Message {
MessageText = "Reflection successful.", Severity = MessageSeverity.Info
});
// Create relationships
RelationshipCreator relationshipCreator = new RelationshipCreator();
NRRelationships nrRelationships = relationshipCreator.CreateRelationships(nrAssembly);
// Save the results
testCase.CurrentResult = new NReflectResult(nrAssembly, nrRelationships);
}
private void AddRelationships(NRAssembly nrAssembly)
{
if (!settings.CreateRelationships)
{
return;
}
RelationshipCreator relationshipCreator = new RelationshipCreator();
NRRelationships nrRelationships = relationshipCreator.CreateRelationships(nrAssembly, settings.CreateNestings,
settings.CreateGeneralizations,
settings.CreateRealizations,
settings.CreateAssociations);
AddRelationships(nrRelationships);
}
/// <summary>
/// Adds the relationships from <paramref name="nrRelationships"/> to the
/// diagram.
/// </summary>
/// <param name="nrRelationships">The relationships to add.</param>
private void AddRelationships(NRRelationships nrRelationships)
{
foreach (NRNesting nrNesting in nrRelationships.Nestings)
{
INestable parentType = types[nrNesting.ParentType] as INestable;
INestableChild innerType = types[nrNesting.InnerType];
if (parentType != null && innerType != null)
{
diagram.AddNesting(parentType, innerType);
}
}
foreach (NRGeneralization nrGeneralization in nrRelationships.Generalizations)
{
CompositeType derivedType = types[nrGeneralization.DerivedType] as CompositeType;
CompositeType baseType = types[nrGeneralization.BaseType] as CompositeType;
if (derivedType != null && baseType != null)
{
diagram.AddGeneralization(derivedType, baseType);
}
}
foreach (NRRealization nrRealization in nrRelationships.Realizations)
{
CompositeType implementingType = types[nrRealization.ImplementingType] as CompositeType;
InterfaceType interfaceType = types[nrRealization.BaseType] as InterfaceType;
if (implementingType != null && interfaceType != null)
{
diagram.AddRealization(implementingType, interfaceType);
}
}
foreach (NRAssociation nrAssociation in nrRelationships.Associations)
{
TypeBase first = types[nrAssociation.StartType];
TypeBase second = types[nrAssociation.EndType];
if (first != null && second != null)
{
AssociationRelationship associationRelationship = diagram.AddAssociation(first, second);
associationRelationship.EndMultiplicity = nrAssociation.EndMultiplicity;
associationRelationship.StartMultiplicity = nrAssociation.StartMultiplicity;
associationRelationship.EndRole = nrAssociation.EndRole;
associationRelationship.StartRole = nrAssociation.StartRole;
}
}
}
/// <summary>
/// Adds the relationships from <paramref name="nrRelationships" /> to the
/// diagram.
/// </summary>
/// <param name="nrRelationships">The relationships to add.</param>
private void AddRelationships(NRRelationships nrRelationships)
{
foreach (var nrNesting in nrRelationships.Nestings)
{
var parentType = types[nrNesting.ParentType] as CompositeType;
var innerType = types[nrNesting.InnerType];
if (parentType != null && innerType != null)
{
diagram.AddNesting(parentType, innerType);
}
}
foreach (var nrGeneralization in nrRelationships.Generalizations)
{
var derivedType = types[nrGeneralization.DerivedType] as CompositeType;
var baseType = types[nrGeneralization.BaseType] as CompositeType;
if (derivedType != null && baseType != null)
{
diagram.AddGeneralization(derivedType, baseType);
}
}
foreach (var nrRealization in nrRelationships.Realizations)
{
var implementingType = types[nrRealization.ImplementingType] as CompositeType;
var interfaceType = types[nrRealization.BaseType] as InterfaceType;
if (implementingType != null && interfaceType != null)
{
diagram.AddRealization(implementingType, interfaceType);
}
}
foreach (var nrAssociation in nrRelationships.Associations)
{
var first = types[nrAssociation.StartType];
var second = types[nrAssociation.EndType];
if (first != null && second != null)
{
var associationRelationship = diagram.AddAssociation(first, second);
associationRelationship.EndMultiplicity = nrAssociation.EndMultiplicity;
associationRelationship.StartMultiplicity = nrAssociation.StartMultiplicity;
associationRelationship.EndRole = nrAssociation.EndRole;
associationRelationship.StartRole = nrAssociation.StartRole;
}
}
}
// ========================================================================
// Properties
#region === Properties
#endregion
// ========================================================================
// Methods
#region === Methods
/// <summary>
/// The main entry point of this class. Imports the assembly which is given
/// as the parameter.
/// </summary>
/// <param name="fileName">The file name and path of the assembly to import.</param>
/// <returns><c>True</c>, if the import was successful.</returns>
public bool ImportAssembly(string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
MessageBox.Show(Strings.Error_NoAssembly, Strings.Error_MessageBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
try
{
diagram.Name = Path.GetFileName(fileName);
diagram.RedrawSuspended = true;
IncludeFilter includeFilter = new IncludeFilter();
includeFilter.Rules.AddRange(settings.FilterRules);
IFilter filter = includeFilter;
if (!settings.UseAsWhiteList)
{
filter = new InvertFilter(includeFilter);
}
NClassImportFilter nClassImportFilter = new NClassImportFilter(filter);
Reflector reflector = new Reflector();
filter = nClassImportFilter;
NRAssembly nrAssembly = reflector.Reflect(fileName, ref filter);
nClassImportFilter = (NClassImportFilter)filter;
AddInterfaces(nrAssembly.Interfaces);
AddClasses(nrAssembly.Classes);
AddStrcts(nrAssembly.Structs);
AddDelegates(nrAssembly.Delegates);
AddEnums(nrAssembly.Enums);
ArrangeTypes();
RelationshipCreator relationshipCreator = new RelationshipCreator();
NRRelationships nrRelationships = relationshipCreator.CreateRelationships(nrAssembly, settings.CreateNestings,
settings.CreateGeneralizations,
settings.CreateRealizations,
settings.CreateAssociations);
AddRelationships(nrRelationships);
if (nClassImportFilter.UnsafeTypesPresent)
{
MessageBox.Show(null, Strings.UnsafeTypesPresent, Strings.WarningTitle, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
catch (ReflectionTypeLoadException)
{
MessageBox.Show(Strings.Error_MissingReferencedAssemblies, Strings.Error_MessageBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
catch (FileLoadException)
{
MessageBox.Show(Strings.Error_MissingReferencedAssemblies, Strings.Error_MessageBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
catch (BadImageFormatException)
{
MessageBox.Show(Strings.Error_BadImageFormat, Strings.Error_MessageBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
catch (Exception ex)
{
MessageBox.Show(String.Format(Strings.Error_GeneralException, ex), Strings.Error_MessageBoxTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
finally
{
diagram.RedrawSuspended = false;
}
return(true);
}
/// <summary>
/// Initializes a new instance of <see cref="NReflectResult"/>.
/// </summary>
/// <param name="nrAssembly">The assembly of the result.</param>
/// <param name="nrRelationships">The relationships of the result.</param>
public NReflectResult(NRAssembly nrAssembly, NRRelationships nrRelationships)
{
NRAssembly = nrAssembly;
NRRelationships = nrRelationships;
}
/// <summary>
/// Adds the relationships from <paramref name="nrRelationships"/> to the
/// diagram.
/// </summary>
/// <param name="nrRelationships">The relationships to add.</param>
private void AddRelationships(NRRelationships nrRelationships)
{
foreach(NRNesting nrNesting in nrRelationships.Nestings)
{
CompositeType parentType = types[nrNesting.ParentType] as CompositeType;
TypeBase innerType = types[nrNesting.InnerType];
if(parentType != null && innerType != null)
{
diagram.AddNesting(parentType, innerType);
}
}
foreach(NRGeneralization nrGeneralization in nrRelationships.Generalizations)
{
CompositeType derivedType = types[nrGeneralization.DerivedType] as CompositeType;
CompositeType baseType = types[nrGeneralization.BaseType] as CompositeType;
if(derivedType != null && baseType != null)
{
diagram.AddGeneralization(derivedType, baseType);
}
}
foreach (NRRealization nrRealization in nrRelationships.Realizations)
{
CompositeType implementingType = types[nrRealization.ImplementingType] as CompositeType;
InterfaceType interfaceType = types[nrRealization.BaseType] as InterfaceType;
if (implementingType != null && interfaceType != null)
{
diagram.AddRealization(implementingType, interfaceType);
}
}
foreach (NRAssociation nrAssociation in nrRelationships.Associations)
{
TypeBase first = types[nrAssociation.StartType];
TypeBase second = types[nrAssociation.EndType];
if (first != null && second != null)
{
AssociationRelationship associationRelationship = diagram.AddAssociation(first, second);
associationRelationship.EndMultiplicity = nrAssociation.EndMultiplicity;
associationRelationship.StartMultiplicity = nrAssociation.StartMultiplicity;
associationRelationship.EndRole = nrAssociation.EndRole;
associationRelationship.StartRole = nrAssociation.StartRole;
}
}
}
/// <summary>
/// The main method of the program.
/// </summary>
/// <param name="args">The arguments supplied at the console.</param>
static void Main(string[] args)
{
string fileName = null;
foreach (string s in args)
{
if (s.StartsWith("-"))
{
foreach (char c in s.Substring(1))
{
switch (c)
{
case 'a':
assembly = true;
break;
case 'm':
modules = true;
break;
case 'r':
relations = true;
break;
case 's':
statistic = true;
break;
default:
PrintUsage();
return;
}
}
}
else
{
if (fileName != null)
{
PrintUsage();
return;
}
fileName = s;
}
}
if (fileName == null)
{
PrintUsage();
return;
}
Console.WriteLine("Will now reflect " + fileName);
// Create the filter
ReflectAllFilter allFilter = new ReflectAllFilter();
IncludeFilter includeFilter = new IncludeFilter();
includeFilter.Rules.Add(new FilterRule(FilterModifiers.AllModifiers, FilterElements.Class));
includeFilter.Rules.Add(new FilterRule(FilterModifiers.AllModifiers, FilterElements.Field));
includeFilter.Rules.Add(new FilterRule(FilterModifiers.AllModifiers, FilterElements.Attribute));
StatisticFilter statisticFilter = new StatisticFilter(allFilter);
// Do the reflection
NRAssembly nrAssembly;
IFilter filter = statisticFilter;
try
{
Reflector reflector = new Reflector();
nrAssembly = reflector.Reflect(fileName, ref filter);
}
catch (Exception ex)
{
Console.WriteLine("Exception while reflecting: " + ex.Message);
return;
}
// Output of the results
IVisitor visitor = new PrintTreeVisitor();
// IVisitor visitor = new CSharpVisitor();
// IVisitor visitor = new PrintVisitor();
if (assembly)
{
nrAssembly.Accept(visitor);
Console.WriteLine();
}
if (modules)
{
foreach (NRModule nrModule in nrAssembly.Modules)
{
nrModule.Accept(visitor);
}
Console.WriteLine();
}
if (relations)
{
RelationshipCreator relationshipCreator = new RelationshipCreator();
NRRelationships nrRelationships = relationshipCreator.CreateRelationships(nrAssembly);
Console.WriteLine("Nesting relationships:");
foreach (NRNesting nrNestingRelationship in nrRelationships.Nestings)
{
Console.WriteLine(nrNestingRelationship);
}
Console.WriteLine();
Console.WriteLine("Generalization relationships:");
foreach (NRGeneralization nrGeneralizationRelationship in nrRelationships.Generalizations)
{
Console.WriteLine(nrGeneralizationRelationship);
}
Console.WriteLine();
Console.WriteLine("Realization relationships:");
foreach (NRRealization nrRealizationRelationship in nrRelationships.Realizations)
{
Console.WriteLine(nrRealizationRelationship);
}
Console.WriteLine();
Console.WriteLine("Association relationships:");
foreach (NRAssociation nrAssociationRelationship in nrRelationships.Associations)
{
Console.WriteLine(nrAssociationRelationship);
}
Console.WriteLine();
}
if (statistic)
{
statisticFilter = (StatisticFilter)filter;
Console.WriteLine();
Console.WriteLine("Statistic:");
Console.WriteLine("Classes : {0}/{1}", statisticFilter.ReflectedClasses, statisticFilter.ReflectedClasses + statisticFilter.IgnoredClasses);
Console.WriteLine("Interfaces : {0}/{1}", statisticFilter.ReflectedInterfaces, statisticFilter.ReflectedInterfaces + statisticFilter.IgnoredInterfaces);
Console.WriteLine("Structures : {0}/{1}", statisticFilter.ReflectedStructures, statisticFilter.ReflectedStructures + statisticFilter.IgnoredStructures);
Console.WriteLine("Delegates : {0}/{1}", statisticFilter.ReflectedDelegates, statisticFilter.ReflectedDelegates + statisticFilter.IgnoredDelegates);
Console.WriteLine("Enums : {0}/{1}", statisticFilter.ReflectedEnums, statisticFilter.ReflectedEnums + statisticFilter.IgnoredEnums);
Console.WriteLine("EnumValues : {0}/{1}", statisticFilter.ReflectedEnumValues, statisticFilter.ReflectedEnumValues + statisticFilter.IgnoredEnumValues);
Console.WriteLine("Constructors: {0}/{1}", statisticFilter.ReflectedConstructors, statisticFilter.ReflectedConstructors + statisticFilter.IgnoredConstructors);
Console.WriteLine("Methods : {0}/{1}", statisticFilter.ReflectedMethods, statisticFilter.ReflectedMethods + statisticFilter.IgnoredMethods);
Console.WriteLine("Fields : {0}/{1}", statisticFilter.ReflectedFields, statisticFilter.ReflectedFields + statisticFilter.IgnoredFields);
Console.WriteLine("Properties : {0}/{1}", statisticFilter.ReflectedProperties, statisticFilter.ReflectedProperties + statisticFilter.IgnoredProperties);
Console.WriteLine("Events : {0}/{1}", statisticFilter.ReflectedEvents, statisticFilter.ReflectedEvents + statisticFilter.IgnoredEvents);
Console.WriteLine("Operators : {0}/{1}", statisticFilter.ReflectedOperators, statisticFilter.ReflectedOperators + statisticFilter.IgnoredOperators);
Console.WriteLine("Attributes : {0}/{1}", statisticFilter.ReflectedAttributes, statisticFilter.ReflectedAttributes + statisticFilter.IgnoredAttributes);
Console.WriteLine("Modules : {0}/{1}", statisticFilter.ReflectedModules, statisticFilter.ReflectedModules + statisticFilter.IgnoredModules);
}
Console.WriteLine("Press any key to exit...");
Console.ReadKey(true);
}
