DependencyAnalysis is a software testing tool for architectural constraints.
Who are you?
You are a software developer. You feel a special interest in test driven development, clean code and software architecture.
What do you want?
What you can see in your every day work, is the code quality level of classes in your IDE. Automated tests can be accessed, approved and extended right away.
There are hurdles when surveying the software at the architectural level. It requires a tool first. There are quite some available. Now you have chosen for example CoolArchitecture2000 as the weapon of choice. It has a lot of features. But it has a drawback. Anytime you want to check something has changed to the architecture, you have to start that tool.
What is wrong?
We developers are the Montgomery Scotts of our software project. Our place is the machine deck (the IDE). If we had to use the turbolifts to the bridge several times a day to see the results of our work, how long will this process last until we skip the bridge visit?
Who do you think is responsible for keeping a software architecture in shape?
1. The software architect?
Well the architect designs dependencies, has an overview of the whole project and bears a vision of the future structure. He suggests technologies to use. Often, he is not the one, who makes daily commits and actively changes the projects structure.
2.Can a dedicated developer be the guardian of architecture?
This will work for a prolonged time. Once he goes on holiday, no one else will invest the effort required to perform the task of keeping everything in shape. His team mates are not familiar with this task.
3. The answer must be every developer of the team is responsible.
More or less each team member has an insight at the meta-level of the project he is contributing. This is the source where the check-ins come from. And this is the only instance that can actually influence a growing sofware project.
- Highlight all adjacent edges when selecting node in architecture graph
- Option to hide transitive edges
- Serialize InstructionCache; create metrics report in Addin process instead of AnalysisHost
- Improve routing of edges, especially vertical Arrangement
- Busy indicator during analysis in addin
- Cheat sheet
- Basic touch gestures
- Metric to count references between two elements
- Selection mode to hide nodes in architecture graph
- Visibility of Events is now determined by analyzing the "add_" accessor
- Catch blocks create references to the exception type
- Do not crash when analyzing a module that references a different version of DependencyAnalysis
- By serializing the InstructionCache enable all tests when running as Addin. It was possible only running the standalone analyzer before.
- fix a NullReferenceException in XamlReader
- Depending on systems theme, the results of tests are hardly readable (fixed with 0.9.8.1)
- Types might be accidently marked generated, when they contain generated inner types (fixed with 0.9.8.1)
- Addin for MonoDevelop (Xamarin Studio, Playstation Mobile Studio etc.)
- Addin supports Visual Studio 2013
- Run Addin as standalone application
- Halstead metric
- Check for common rules in Addin
Display dependencies as graph (architecture graph)
Enhance visual appearance of architecture graph
Layered graph arrangement
Analyze XAML resource dictionaries.
Routing of edges in automatically arraged graph
Analyze inheritance for all types not only those inside the project
StackOverflowException on layer assignment in some graph types
generated functional members like 'Boolean<FormatDisplayText>b__d(Double)' collapse with their parent member, for example 'FormatDisplayText'
Create a SharpDevelop Addin
Liskov Substitution Principle
Provide MSTest template project
Provide NUnit template project
Provide xUnit template project
Windows Installer XML setup for Addins has been cancelled
During analysis ignore assemblies that cannot be loaded, instead of crash
Analyze references to types that have no full name (yes they exist)
Create a Visual Studio 2010 Addin
Harmonize visuals for Addin
Principle: Law of Demeter
Store preferences for Addin per solution
Drill down in proximity graph
Scroll to zoom in graph uses wrong coordinates
Omit dummy members that represent type references in graphs
Version 0.9.4 (Delayed by two weeks due to flood water in parts of Germany)
Create Visual Studio 2012 Addin for ad-hoc analysis of your project
Display metrics in a grid
Adequate performing serialization between Addin (Visual Studio process) and AnalysisHost process
Display dependencies as graph (proximity graph)
Create a logo for the project
improve performance of code duplication analysis
Constructors of anonymous types no longer hide constructors of the declaring type during "build dependencies" phase
Type descriptors were added multiple times to SubmoduleDescriptor.Types collection, same instance foreach inner anonymous type. Now ignored when already present.
Metric Relational Cohesion correctly selects references within module
Add predefined where-clauses for code of your project
Elevate Setup class to the standard initialization for DependencyAnalysis
Provide a standard ruleset for members that should be refactored
Create XML reports
Code duplication report
Code smell report
Provide example XSLT files for XML reports
DescriptorBuilder fills Name value of MemberDescriptor
Basic code duplication analysis as "Don't Repeat Yourself" principle.
New method Verifier.VerifyDoesNotReferTo that reports forbidden accessors, which is more verbose than Assert.IsFalse(Verifier.RefersTo(..));
Instability returns 1 instead of infinity for object without any afferences and efferences
Add Verification of design principles.
Support "Acyclic Dependency Principle".
Support "Depend on Stable Principle".
Consolidate the API.
Document the API contracts.
Enter Beta stage.
CilReader reads correct operand for branching instruction with short value
return, continue and break do not count towards nesting depth
Build dependency model
Allow tests on dependencies
Qualify "A refers to B"
This package has no dependencies.