Extracting the current value of an instance variable while walking an Expression

Extracting the current value of an instance variable while walking an Expression - c#

I am currently trying to write some code which turns C# Expressions into text.
To do this, I need to not only walk through the Expression tree, but also evaluate just a little part of it - in order to get the current value of a local variable.
I am finding very hard to put into words, so here is the pseudo-code instead. The missing part is in the first method:
public class Program
{
private static void DumpExpression(Expression expression)
{
// how do I dump out here some text like:
// set T2 = Perform "ExternalCalc" on input.T1
// I can easily get to:
// set T2 = Perform "Invoke" on input.T1
// but how can I substitute Invoke with the runtime value "ExternalCalc"?
}
static void Main(string[] args)
{
var myEvaluator = new Evaluator() {Name = "ExternalCalc"};
Expression<Func<Input, Output>> myExpression = (input) => new Output() {T2 = myEvaluator.Invoke(input.T1)};
DumpExpression(myExpression);
}
}
class Evaluator
{
public string Name { get; set; }
public string Invoke(string input)
{
throw new NotImplementedException("Never intended to be implemented");
}
}
class Input
{
public string T1 { get; set; }
}
class Output
{
public string T2 { get; set; }
}
I have started investigating this using code like:
foreach (MemberAssignment memberAssignment in body.Bindings)
{
Console.WriteLine("assign to {0}", memberAssignment.Member);
Console.WriteLine("assign to {0}", memberAssignment.BindingType);
Console.WriteLine("assign to {0}", memberAssignment.Expression);
var expression = memberAssignment.Expression;
if (expression is MethodCallExpression)
{
var methodCall = expression as MethodCallExpression;
Console.WriteLine("METHOD CALL: " + methodCall.Method.Name);
Console.WriteLine("METHOD CALL: " + expression.Type.Name);
var target = methodCall.Object;
// ?
}
}
but once I get to that MethodCallExpression level then I am feeling a bit lost about how to parse it and to then get the actual instance.
Any pointers/suggestions on how to do this very much appreciated.

Parsing expression trees is... complex and time-consuming. Here's a very incomplete version that just-about handles your example. In particular, note that we need to:
hard-code to Evaluator, since "ExternalCalc" is not part of the expression
manually evaluate some of the tree
Output:
a new Output set T2 to: call ExternalCalc on get myEvaluator from capture-context with input = get T1 from #input
Code:
private static void DumpExpression(Expression expression)
{
var sb = new StringBuilder();
Walk(expression, sb);
string s = sb.ToString();
}
static object Evaluate(Expression expr)
{
switch (expr.NodeType)
{
case ExpressionType.Constant:
return ((ConstantExpression)expr).Value;
case ExpressionType.MemberAccess:
var me = (MemberExpression)expr;
object target = Evaluate(me.Expression);
switch (me.Member.MemberType)
{
case System.Reflection.MemberTypes.Field:
return ((FieldInfo)me.Member).GetValue(target);
case System.Reflection.MemberTypes.Property:
return ((PropertyInfo)me.Member).GetValue(target, null);
default:
throw new NotSupportedException(me.Member.MemberType.ToString());
}
default:
throw new NotSupportedException(expr.NodeType.ToString());
}
}
static void Walk(Expression expr, StringBuilder output)
{
switch (expr.NodeType)
{
case ExpressionType.New:
var ne = (NewExpression)expr;
var ctor = ne.Constructor;
output.Append(" a new ").Append(ctor.DeclaringType.Name);
if(ne.Arguments != null && ne.Arguments.Count != 0)
{
var parameters = ctor.GetParameters();
for(int i = 0 ;i < ne.Arguments.Count ; i++)
{
output.Append(i == 0 ? " with " : ", ")
.Append(parameters[i].Name).Append(" =");
Walk(ne.Arguments[i], output);
}
}
break;
case ExpressionType.Lambda:
Walk(((LambdaExpression)expr).Body, output);
break;
case ExpressionType.Call:
var mce = (MethodCallExpression)expr;
if (mce.Method.DeclaringType == typeof(Evaluator))
{
object target = Evaluate(mce.Object);
output.Append(" call ").Append(((Evaluator)target).Name);
}
else
{
output.Append(" call ").Append(mce.Method.Name);
}
if (mce.Object != null)
{
output.Append(" on");
Walk(mce.Object, output);
}
if (mce.Arguments != null && mce.Arguments.Count != 0)
{
var parameters = mce.Method.GetParameters();
for (int i = 0; i < mce.Arguments.Count; i++)
{
output.Append(i == 0 ? " with " : ", ")
.Append(parameters[i].Name).Append(" =");
Walk(mce.Arguments[i], output);
}
}
break;
case ExpressionType.MemberInit:
var mei = (MemberInitExpression)expr;
Walk(mei.NewExpression, output);
foreach (var member in mei.Bindings)
{
switch(member.BindingType) {
case MemberBindingType.Assignment:
output.Append(" set ").Append(member.Member.Name)
.Append(" to:");
Walk(((MemberAssignment)member).Expression, output);
break;
default:
throw new NotSupportedException(member.BindingType.ToString());
}
}
break;
case ExpressionType.Constant:
var ce = (ConstantExpression)expr;
if (Attribute.IsDefined(ce.Type, typeof(CompilerGeneratedAttribute)))
{
output.Append(" capture-context");
}
else
{
output.Append(" ").Append(((ConstantExpression)expr).Value);
}
break;
case ExpressionType.MemberAccess:
var me = (MemberExpression)expr;
output.Append(" get ").Append(me.Member.Name).Append(" from");
if (me.Expression == null)
{ // static
output.Append(me.Member.DeclaringType.Name);
}
else
{
Walk(me.Expression, output);
}
break;
case ExpressionType.Parameter:
var pe = (ParameterExpression)expr;
output.Append(" #").Append(pe.Name);
break;
default:
throw new NotSupportedException(expr.NodeType.ToString());
}
}

If I understand correctly, you're wondering how to get properties from the instance of the object the method in your example was being called on. As Marc mentions in his answer, expression trees are complex and time consuming to work with, this addresses specifically your example (and likely nothing else).
private static void DumpExpression(Expression expression)
{
var lambda = expression as LambdaExpression;
if(lambda != null)
{
DumpExpression(lambda.Body);
return;
}
var init = expression as MemberInitExpression;
if(init != null)
{
foreach(var binding in init.Bindings)
{
var assignment = (MemberAssignment) binding;
DumpExpression(assignment.Expression);
return;
}
}
var methodCallExpression = expression as MethodCallExpression;
if(methodCallExpression != null)
{
//Create a func that retrieves the real value of the object the method call
// is being evaluated on and get the Name property from it
var objectGetExpression = Expression.Lambda<Func<Evaluator>>(methodCallExpression.Object);
var objectGetFunc = objectGetExpression.Compile();
Console.WriteLine(objectGetFunc().Name);
return;
}
}

Related

Getting fields and properties' names, types and values recursively in C#

I am trying to recursively iterate over one root class to grab it's values and build a tree structure for visualization.
For this I have a class that can be initialized with an object
public Item(object genericObject, int depth = 0) {
this.depth = depth;
this.Name = genericObject.GetType().Name;
this.Type = genericObject.GetType().ToString();
this.Value = genericObject;
this.subItems = new List<Item>();
foreach (MemberInfo member in Item.GetType().GetMembers())
{
if (member.MemberType != MemberTypes.Method && member.MemberType != MemberTypes.Constructor)
subItems.Add(new Item(member,genericObject, depth + 1));
}
}
and another constructor for recursion
public Item(MemberInfo member,object parentobj, int depth = 0)
{
if (member.MemberType == MemberTypes.Property)
{
this.FieldName = ((PropertyInfo)member).Name;
this.FieldType = ((PropertyInfo)member).PropertyType.ToString();
this.fieldValue = ((PropertyInfo)member).GetValue(parentobj);
}
else
{
this.FieldName = ((FieldInfo)member).Name;
this.FieldType = ((FieldInfo)member).GetValue(parentobj).GetType().Name;
this.fieldValue = ((FieldInfo)member).GetValue(parentobj);
}
switch (member)
{
case PropertyInfo propertyInfo:
case FieldInfo fieldinfo:
bool found = false;
foreach (string typename in browsethroughtheseTypes)
{
if (this.FieldType.ToLower().Contains(typename)) found = true;
}
if (found)
{
this.subItems = new List<Displayable>();
foreach (MemberInfo mem in member.GetType().GetMembers())
{
if (mem.GetType().IsClass)
this.subItems.Add(new Item(mem, depth + 1));
}
}
break;
default:
break;
}
}
For testing I only added list to browsethroughthesetypes
After recursion takes place in the second constructor all I'm seeing is the internal types.
Is there a proper way to achieve this using reflection?

common pattern, Here so I am trying to simplify it to reduce duplication

All of these if conditions in the below method have similar pattern,
Any ideas to come up with a common method to reduce the duplication in this method?
public override Func<JObject, dynamic, string> version => (jobject, parameters) =>
{
bool hasValidObject = false;
if (jobject["Version1"] != null)
{
_radio.Version1 = new VersionInfo(jobject["Version1"].Value<string>());
hasValidObject = true;
}
if (jobject["Version2"] != null)
{
_radio.Version2 = new VersionInfo(jobject["Version2"].Value<string>());
hasValidObject = true;
}
if (jobject["Version3"] != null)
{
_radio.Version3 = new VersionInfo(jobject["Version3"].Value<string>());
hasValidObject = true;
}
if (jobject["Version4"] != null)
{
_radio.Version4 = new VersionInfo(jobject["Version4"].Value<string>());
hasValidObject = true;
}
if (jobject["Version6"] != null)
{
_radio.Version6 = new VersionInfo(jobject["Version6"].Value<string>());
hasValidObject = true;
}
if (hasValidObject)
{
return GenerateSuccess();
}
return GenerateUnsuccessful( try again.");
};

One way is to use reflection and a loop
public override Func version => (jobject, parameters) =>
{
bool hasValidObject = false;
for (int i = 1; i<7;i++)
{
hasValidObject = this.SetVersionInfo(i) || hasValidObject;
}
if (hasValidObject)
{
return GenerateSuccess();
}
return GenerateUnsuccessful( "try again.");
};
private bool SetVersionInfo(int i)
{
if (jobject["Version" + i] == null) return false;
_radio.GetType().GetProperty(propName)
.SetValue(_radio, new VersionInfo(jobject["Version" + i].Value<string>()));
return true;
}
Another way would be to create a Dictionary<int,VersionInfo> Versions in your _radio class and then a you don't need the reflection:
private bool SetVersionInfo(int i)
{
if (jobject["Version" + i] == null) return false;
_radio.Versions[i] = new VersionInfo(jobject["Version" + i].Value<string>());
return true;
}

Another alternative can be with a switch statement:
public override Func<JObject, dynamic, string> version => (jobject, parameters) =>
{
bool hasValidObject = false;
foreach (char n in "12346")
{
var jObj = jobject["Version" + n];
if (jObj != null)
{
var versionInfo = new VersionInfo(jObj.Value<string>());
switch (n)
{
case '1': _radio.Version1 = versionInfo; break;
case '2': _radio.Version2 = versionInfo; break;
case '3': _radio.Version3 = versionInfo; break;
case '4': _radio.Version4 = versionInfo; break;
case '6': _radio.Version6 = versionInfo; break;
}
hasValidObject = true;
}
}
return hasValidObject ? GenerateSuccess() : GenerateUnsuccessful(" try again.");
};
or a more advanced version with array of delegates .. because I like vertical space :] (also not tested):
public override Func<JObject, dynamic, string> version => (jobject, parameters) =>
{
Func<VersionInfo, VersionInfo>[] a = { null, _radio.Version1 = v,
v => _radio.Version2 = v, v => _radio.Version3 = v,
v => _radio.Version4 = v, null, v => _radio.Version6 = v };
var q = from n in new[] { 1, 2, 3, 4, 6 }
let j = jobject["Version" + n] where j != null
select a[n](new VersionInfo(j.Value<string>()));
return q.Count() > 0 ? GenerateSuccess() : GenerateUnsuccessful(" try again.");
};

if jobject is of Dictionary type, you can run on it using
foreach(string version in jobject.keys)
{
if(jobject[version]!=null){
//do something
}
}
the problem is with the radio, but if it your class, you can use an array of versions in the class instead of so many, and access to them with a counter that you will use to count the loop's number

Custom linked list c# for practice - not sure why my insertion is't working

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication1
{
class Program
{
class node
{
public int data;
public node next;
public node(int value)
{
next = null;
data = value;
}
public void addFront(node head, int value)
{
var tempNode = new node(value);
tempNode.next = head;
head = tempNode;
}
public void addBack(node head, int value)
{
var insertNode = new node(value);
var traverseNode = head;
while (traverseNode != null)
{
if (traverseNode.next == null)
{
traverseNode.next = insertNode;
insertNode.data = value;
}
traverseNode = traverseNode.next;
}
}
public void printList(node head)
{
var counter = 0;
var traverseNode = head;
while (traverseNode != null)
{
Console.WriteLine("LL item {0}: {1}", counter, traverseNode.data);
traverseNode = traverseNode.next;
counter++;
}
}
public int deleteFront(node head)
{
//Don't need to delete the memory because the garbage collector handles that in c# (at least by my understanding). If this were C, I'd have to use free, and in C++ I'd use keyword Delete
var returnValue = head.data;
head = head.next;
return returnValue;
}
public int deleteBack(node head)
{
node traverseNode = head;
node traverseNodeTrailer = head;
if (traverseNode == null)
{
return 0;
}
while (traverseNode != null)
{
if (traverseNode.next == null)
{
traverseNodeTrailer.next = null;
break;
}
traverseNodeTrailer = traverseNode;
traverseNode = traverseNode.next;
}
return traverseNode.data;
}
public void deleteMiddle(node middleNode)
{
var traverseNode = middleNode;
while (traverseNode != null)
{
if (traverseNode.next.next == null)
{
traverseNode.data = traverseNode.next.data;
traverseNode.next = null;
break;
}
traverseNode.data = traverseNode.next.data;
traverseNode = traverseNode.next;
}
}
public node search(node head, int value)
{
var traverseNode = head;
while (traverseNode != null)
{
if (traverseNode.data == value)
return traverseNode;
traverseNode = traverseNode.next;
}
return null;//failed to find the value in the linked list
}
}
static void Main(string[] args)
{
Int32 userMenuInput = 0;
var running = true;
int userNodeInput = 0;
node head = null;
while (running)
{
Console.WriteLine("Enter a number depending on the operation you would like to perform.");
Console.WriteLine("1 - Insert node of specified value; 2 - Delete a node and return the value; 3 - Search for a node with a specified value; 4 - Print the list values. *All other values exit");
userMenuInput = Convert.ToInt32(Console.ReadLine());//get user input for what they want to do
switch (userMenuInput)
{
case 1:
Console.WriteLine("Enter a number you'd like to insert into the linked list.");
userNodeInput = Convert.ToInt32(Console.ReadLine());//get user input for value to insert
if (head == null)
{
head = new node(userNodeInput);
break;
}
head.addFront(head, userNodeInput);
break;
case 2:
if (head == null)
{
Console.WriteLine("The list is empty - cannot delete.");
break;
}
userNodeInput = head.deleteFront(head);
Console.WriteLine("{0} is the value that was deleted from the front of the list.", userNodeInput);
break;
case 3:
Console.WriteLine("What is the value you'd like to search for in the list?");
userNodeInput = Convert.ToInt32(Console.ReadLine());
if (head == null)
{
//do nothing
}
else if (head.search(head, userNodeInput) != null)
{
Console.WriteLine("That value was found");
break;
}
Console.WriteLine("That value was not found.");
break;
case 4:
if (head == null)
{
Console.WriteLine("The list has nothing to print.");
break;
}
head.printList(head);
break;
default:
running = false;
break;
}
}
}
}
}
DISCLAIMER: I'm very new to c# - just been using it for the past week or so. I will appreciate any optimization hints you have, but for now, I'm just trying to get this running.
So, this is correctly inserting 1 element, but nothing more. It is finding the element if it is in the first link. The delete doesn't seem to be working at all. It doesn't throw any errors but it also doesn't delete the first link. Note: A few of my functions in there are unused so far so don't worry about mentioning that - I'm aware.
Thanks everyone!

You can use ref if you want to modify argument passed to addFront method:
public void addFront(ref node head, int value)
{
var tempNode = new node(value);
tempNode.next = head;
head = tempNode;
}
.
head.addFront(ref head, userNodeInput);

How to identify unused classes in C# project

I've a C# big solution that contains different projects. It contains also a batch with a Main static method.
I have to identify and remove all the classes that can't be used starting from this method.
Which is the best way to do that?
I'm using Microsoft Visual Studio Professional 2015
Thanks!

There are no tools which can do this completely, because
System.Reflection and System.CodeDom exist - Is it possible to dynamically compile and execute C# code fragments?
New C# code can be generated at run-time, which uses otherwise-unused classes.
No tools can predict what that new C# code is (apart from the humans who wrote the code)
Dependency Injection libraries (which use System.Reflection behind the scenes) can call "unused" classes. This happens frequently with MVC Controller classes.
Razor Views can use classes. These are not compiled by default. Instead, they will crash at runtime if a class is missing.
Assuming no-one is using System.Reflection, you could do it by hand.
For each class:
Select it in Visual Studio, right-click then "Find All References"
If none found, comment the class out /* */
Rebuild all (including Razor views). If no errors found, then the class is unused.

It might be worth downloading and starting the free trial of resharper. By using the "Solution-Wide Analysis" feature, you will be able to quickly find code that is not used anywhere in the solution. Plus there are loads of other cool features too!

You can try by right click and check the references. It is possible for methods, classes and properties as well . But it won't show if the class, method or property referenced in presentation layer

The below code can be used with the FxCopCmd.exe command line executable. FxCopCmd.exe comes part of the default Visual Studio installation. First you have to setup a new project and compile the code into a DLL.
In Visual Studio, create a new Class Library project. Pick a name like FxCopDemo. It must target .NET Framework 4 or newer. During compilation, a warning message will be displayed about the build. The warning message can be fixed by changing Properties > Build > Platform target to x86.
In the project, add references to:
FxCopSdk.dll
Microsoft.Cci.dll
Depending on your Visual Studio version, the DLLs are located in a folder such as:
C:\Program Files (x86)\Microsoft Visual Studio 11.0\Team Tools\Static Analysis Tools\FxCop\ or
C:\Program Files\Microsoft Visual Studio 9.0\Team Tools\Static Analysis Tools\FxCop\Rules\
Make sure to do a Debug build so that the program database (PDB) files are generated. The PDB files will supply FxCop with the debugging information it needs output the line numbers from the source code.
Copy and paste this XML into a file named UnusedCodeXml.xml and add it to the project as an existing item.
<?xml version="1.0" encoding="utf-8"?>
<Rules FriendlyName="">
<Rule TypeName="UnusedClassesRule" Category="UnusedCode" CheckId="UC0001">
<Name>A class or class cluster is not referenced by the main code.</Name>
<Description>
A class is included as part of an executable, or class library, but that code is not used.
</Description>
<Url></Url>
<Resolution Name="Orphan">The class '{0}' is not referenced by any other classes.</Resolution>
<Resolution Name="Cluster">The class '{0}' is only referenced by classes in an isolated cluster.</Resolution>
<MessageLevel Certainty="95">Warning</MessageLevel>
<Email></Email>
<FixCategories>NonBreaking</FixCategories>
<Owner></Owner>
</Rule>
</Rules>
Important: After adding the XML rule file to the project. Then right-click on the item, goto Properties, and change the Build Action to Embedded Resource.
Note: The C# code is just a little too long to fit in this post together, so the code is posted below. Copy and paste the C# code in my other answer into a file named UnusedClassesRule.cs. Add the file to the project. Compiling the project should create a file called C:\Projects\FxCopDemo\bin\Debug\FxCopDemo.dll.
Now open a Command Prompt window, and go to the directory that contains the FxCopCmd.exe executable. FxCopCmd.exe seems a little finicky with the order the arguments are passed in. It seems like /d: has to be specified last when used.
Case 1) Analyze a single executable, i.e. MyProgram.exe. The command line for that would be:
FxCopCmd "/f:C:\Projects\MyProgram\bin\Debug\MyProgram.exe" /r:C:\Projects\FxCopDemo\bin\Debug\FxCopDemo.dll /out:c:\temp\refs.csv /q /c
/f: is the path to the exe to analyze
/r: is the path to the rule dll
/out: optional. saves the output to the specified file
/q means quiet
/c optional. Outputs the results to the console.
/v optional. Verbose. If specified, a list of all references each class has will be included in the output.
Case 2) You have a project that compiles into a DLL and an EXE. In this case, copy the files MyProgram.exe, MyProgram.Core.dll, and PBD files into a separate subfolder, e.g. \bin\Debug\fxcop\. The /f: argument will point to the subfolder.
FxCopCmd /f:C:\Projects\MyProgram\bin\Debug\fxcop\ /r:C:\Projects\FxCopDemo\bin\Debug\FxCopDemo.dll /out:c:\temp\refs.csv /q /c /d:"C:\Projects\MyProgram\bin\Debug\"
In this case, an extra /d: argument is required. It points to the main Debug folder, which will probably contain third party DLLs that you don't want to include in the analysis, but are required by FxCop.
Here is a screenshot of the sample output. It outputs any classes that aren't referred to by other classes, as well as it detects classes that are disconnected from the rest of the code.
Finally, the following document is helpful to troubleshoot any issues with FxCop:
https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.466.282&rep=rep1&type=pdf

Here is the code for the UnusedClassesRule.cs class:
using Microsoft.FxCop.Sdk;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace FxCopDemo {
[Flags]
public enum CodeLocation {
StaticInitializer = 4096,
ConstructorParameter = 1,
ConstructorBody = 2,
//---
MethodParameter = 4,
MethodBody = 8,
MethodReturnType = 16,
StaticMethodBody = 2048,
MethodDef = 8192,
ClassDef = 16384,
//---
PropertyReturnType = 32,
PropertyGetterBody = 64,
PropertySetterBody = 128,
//---
EventDelegate = 256,
//---
MemberVariable = 512,
StaticVariable = 1024
}
public class RefItem {
///<summary>All the locations in the source code where the full name is referenced.</summary>
public CodeLocation Locations = (CodeLocation) 0;
///<summary>The full name of the class, struct, or enum.</summary>
public readonly String FullName;
///<summary>The total number of times the FullName is referenced by the ClassTypes.</summary>
public int Count;
public RefItem(String fullName) {
this.FullName = fullName;
}
}
// for each custom class, maintain a collection of all types that the class references
public class Class2 : IComparable<Class2> {
///<summary>List of other class types that have a direct reference to this class. This list is populated at the very end.</summary>
public List<Class2> Nbors = new List<Class2>();
///<summary>The full name of this class, struct, or enum type.</summary>
public readonly String FullName;
///<summary>If this class is a nested class, the DeclaringType is the full name of the immediate host.</summary>
public readonly String DeclaringType;
///<summary>The full name of the immediate parent.</summary>
public readonly String BaseType;
///<summary>True if this class contains the Main(...) entry point method.</summary>
public readonly bool IsEntryPoint;
///<summary>The type of node, typically Class, Interface, DelegateNode, EnumNode. Used for reporting purposes.</summary>
public readonly NodeType NodeType;
private Dictionary<String, RefItem> dict = new Dictionary<String, RefItem>();
public Class2(String fullName, bool isEntryPoint, String declaringType, String baseType, NodeType nodeType) {
this.FullName = fullName;
this.IsEntryPoint = isEntryPoint;
this.DeclaringType = declaringType;
this.BaseType = baseType;
this.NodeType = nodeType;
}
///<summary>
///Adds a reference to a class that this class directly references.
///<param name="fullName">The full name of the class that this class references.</param>
///<param name="loc">The location in the code where the reference occurs. CodeLocation is a [Flags] enum, so multiple locations can exist.</param>
///</summary>
public void Add(String fullName, CodeLocation loc) {
// variables passed with 'ref' or 'out' as method parameters have an '#' as the last character of the fullName
fullName = fullName.TrimEnd('#');
lock(dict) {
RefItem ri = null;
if (!dict.TryGetValue(fullName, out ri)) {
ri = new RefItem(fullName);
dict[fullName] = ri;
}
ri.Locations = (ri.Locations | loc);
ri.Count++;
}
}
public RefItem GetRef(String fullName) {
RefItem ri = null;
dict.TryGetValue(fullName, out ri);
return ri;
}
public List<RefItem> GetRefs() {
return dict.Values.OrderBy(r => r.FullName).ToList();
}
public override String ToString() {
return FullName;
}
public int CompareTo(Class2 other) {
return String.Compare(this.FullName, other.FullName);
}
}
/*
For each type node, detect all other types it references.
Then for each node, determine the other nodes that point to it.
Report:
1. Any nodes that aren't pointed to, and
2. Any groups of nodes that are not connected to the main entry point.
Limitations:
1. Seems like when an enum is cast to a int value, the original enum type is not recoverable
e.g: int x = (int) MyEnum.SomeValue; // seems like the compiler replaces the MyEnum.SomeValue reference with the literal value
This means that some enums may be reported as unused, but they are actually used.
2. Unreachable code is reported as unused. Not sure how to access unreachable code using the FxCop api.
3. Does not account for reflection that uses hard coded string names.
The following are too granular and are not reported in this rule:
1. Methods (instance or static) that are never called.
2. Variables (properties or fields, instance or static) in classes not used.
3. Variables in method arguments not used.
*/
public class UnusedClassesRule : BaseIntrospectionRule {
private static Dictionary<String, Class2> dictTypes = new Dictionary<String, Class2>();
// The multi-threads in FxCop make it hard to debug. The messages are grouped by thread when debugging of this rule is needed.
private static Dictionary<int, StringBuilder> dictOutput = new Dictionary<int, StringBuilder>();
private Class2 currentC2 = null;
private CodeLocation currentLoc = (CodeLocation) 0;
private Member currentMember = null;
private bool writeCheckMemberError = true;
private bool writeVisitExpressionError = true;
public UnusedClassesRule() : base("UnusedClassesRule", "FxCopDemo.UnusedCodeXml", typeof(UnusedClassesRule).Assembly) {
}
public override TargetVisibilities TargetVisibility {
get {
return TargetVisibilities.All;
}
}
// Note: BeforeAnalysis() and AfterAnalysis() are called multiple times, one for each rule instance.
// According to a forum post on MSDN, one rule instance is created for each CPU core.
//public override void BeforeAnalysis() {
//base.BeforeAnalysis();
//MethodCollection list = CallGraph.CallersFor((Method) null);
//}
public override void AfterAnalysis() {
base.AfterAnalysis();
lock(dictTypes) {
if (dictTypes.Count == 0)
return;
try {
FinalAnalysis();
} catch (Exception ex) {
writeCheckMemberError = false;
Write("Error: " + ex.GetType().FullName + ": " + ex.Message, null, true);
Write(ex.StackTrace, null, true);
}
dictTypes.Clear();
}
}
public override ProblemCollection Check(Member member) {
try {
CheckInternal(member);
} catch (Exception ex) {
if (writeCheckMemberError) {
writeCheckMemberError = false;
Write("Error: " + ex.GetType().FullName + ": " + ex.Message);
Write(ex.StackTrace);
}
}
return this.Problems;
}
private ProblemCollection CheckInternal(Member member) {
Class2 ct = currentC2;
AttributeNodeCollection attribs = member.Attributes;
for (int i = 0; i < attribs.Count; i++) {
AttributeNode a = attribs[i];
Add(ct, a.Type, CodeLocation.MethodDef);
}
if (member is Method) {
currentMember = member;
var m = (Method) member;
if (m.ReturnType != FrameworkTypes.Void)
Add(ct, m.ReturnType, CodeLocation.MethodReturnType);
if (m.NodeType == NodeType.InstanceInitializer)
currentLoc = CodeLocation.ConstructorBody;
else if (m.NodeType == NodeType.StaticInitializer)
currentLoc = CodeLocation.StaticInitializer;
else
currentLoc = (m.IsStatic ? CodeLocation.StaticMethodBody : CodeLocation.MethodBody);
for (int i = 0; i < m.Parameters.Count; i++) {
Parameter p = m.Parameters[i];
TypeNode ty = p.Type;
Add(ct, ty, CodeLocation.MethodParameter);
}
// the DeclaringType is needed when an extension method is called
Add(ct, m.DeclaringType, currentLoc);
VisitMethod(m);
//VisitBlock(m.Body);
//VisitStatements(m.Body.Statements);
}
else if (member is PropertyNode) {
var pn = (PropertyNode) member;
if (pn.Setter != null) {
currentMember = member;
currentLoc = CodeLocation.PropertySetterBody;
VisitStatements(pn.Setter.Body.Statements);
}
if (pn.Getter != null) {
Add(ct, pn.Getter.ReturnType, CodeLocation.PropertyReturnType);
currentMember = member;
currentLoc = CodeLocation.PropertyGetterBody;
VisitStatements(pn.Getter.Body.Statements);
}
}
else if (member is Field) {
var f = (Field) member;
var loc = (f.IsStatic ? CodeLocation.StaticVariable : CodeLocation.MemberVariable);
Add(ct, f.Type, loc);
}
else if (member is EventNode) {
var evt = (EventNode) member;
Add(ct, evt.HandlerType, CodeLocation.EventDelegate);
}
else {
Write("UNKNOWN CHECK MEMBER: " + member.GetType().FullName + " full name: " + member.FullName);
}
return this.Problems;
}
private static void Add(Class2 ct, TypeNode ty, CodeLocation loc) {
// Given a TypeNode, it may have to be drilled down into determine it's actual type
// It's also possible that a single TypeNode results in multiple references. For example,
// public class MyList<T> { ... }
// public static void Foo<U>(MyList<U> list) where U : Bar {}
// which should result in adding namespace.MyList, and namespace.Bar
Stack<TypeNode> stack = new Stack<TypeNode>();
stack.Push(ty);
while (stack.Count > 0) {
ty = stack.Pop();
if (ty == null)
continue;
if (ty.IsGeneric) {
// otherwise Nullable`1 shows up in the list of references
if (ty.Template != null && ty.Template != FrameworkTypes.GenericNullable)
ct.Add(ty.Template.FullName, loc);
if (ty.TemplateArguments != null) {
foreach (TypeNode ta in ty.TemplateArguments)
stack.Push(ta);
}
if (ty.TemplateParameters != null) {
foreach (TypeNode tp in ty.TemplateParameters)
stack.Push(tp);
}
}
else if (ty.IsTemplateParameter) {
// this is the case when a constraint is placed on a generic type, e.g. public static void Foo<T>(U input) where U : Bar { ... }
// ty.FullName will be something like "parameter.T"
// The BaseType == "Bar". If no constraint is specified, then BaseType == "System.Object".
// The reason it's pushed on the stack is because it could be a constraint like where : U : MyList<Bar> { ... }
stack.Push(ty.BaseType);
}
else if (ty is ArrayType) {
ArrayType ty2 = (ArrayType) ty;
TypeNode ty3 = ty2.ElementType;
ct.Add(ty3.FullName, loc);
}
else {
ct.Add(ty.FullName, loc);
}
}
}
public override void VisitExpression(Expression exp) {
try {
VisitExpressionInternal(exp);
} catch (Exception ex) {
if (writeVisitExpressionError) {
writeVisitExpressionError = false; // only record the first error
Write("Error: " + ex.GetType().FullName + ": " + ex.Message, null, true);
Write(ex.StackTrace);
}
}
}
private void VisitExpressionInternal(Expression exp) {
if (exp == null)
return;
Stack<Expression> stack = new Stack<Expression>();
stack.Push(exp);
while (stack.Count > 0) {
exp = stack.Pop();
if (exp == null)
continue;
if (exp is NaryExpression) {
// this handles Construct, ConstructArray, MethodCall, Indexer
var ne = (NaryExpression) exp;
foreach (Expression e in ne.Operands) {
stack.Push(e); // the actual arguments
}
}
TypeNode ty = exp.Type;
bool alert = false;
if (exp is Variable || exp is Local) { // Note: Local extends Variable
Add(currentC2, ty, currentLoc);
//Write("VARIABLE NAME: " + ((Variable) exp).Name.Name + " " + exp);
}
else if (exp is Literal) {
var lit = (Literal) exp;
Add(currentC2, ty, currentLoc);
Object val = lit.Value;
if (val is TypeNode)
Add(currentC2, (TypeNode) val, currentLoc);
else if (val != null) {
// val == null when there is an assignment like, MyClass c = null;
Type ty2 = val.GetType();
bool isKnown = (ty2.IsPrimitive || ty2 == typeof(String));
if (isKnown) {
currentC2.Add(ty2.FullName, currentLoc);
}
else {
Write("val.GetType(): " + ty2.FullName);
alert = true;
}
}
//if (val is EnumNode) {
// var en = (EnumNode) val;
// en.UnderlyingType; // this is the primitive type that the Enum extends, typically int32
//}
}
else if (exp is MethodCall) {
var mc = (MethodCall) exp;
stack.Push(mc.Callee);
}
else if (exp is Construct) {
Add(currentC2, ty, currentLoc);
var c = (Construct) exp;
stack.Push(c.Constructor); // c.Constuctor is MemberBinding
}
else if (exp is Indexer) {
var ix = (Indexer) exp;
Add(currentC2, ix.ElementType, currentLoc);
stack.Push(ix.Object);
}
else if (exp is AddressDereference) {
var ad = (AddressDereference) exp; // nullable type
TypeNode ty2 = ad.Type;
Add(currentC2, ty2, currentLoc);
stack.Push(ad.Address);
}
else if (exp is MemberBinding) {
var mb = (MemberBinding) exp;
stack.Push(mb.TargetObject);
if (mb.BoundMember is Method) { // Note: InstanceInitializer is a Method
var m = (Method) mb.BoundMember;
Add(currentC2, m.DeclaringType, currentLoc);
CodeLocation loc = (mb.BoundMember is InstanceInitializer ? CodeLocation.ConstructorParameter : currentLoc);
for (int i = 0; i < m.Parameters.Count; i++) {
Parameter p = m.Parameters[i];
TypeNode ty2 = p.Type;
Add(currentC2, ty2, loc);
}
}
else if (mb.BoundMember is Field) {
// this occurs for a class level static variable
var f = (Field) mb.BoundMember;
var loc = (f.IsStatic ? CodeLocation.StaticVariable : CodeLocation.MemberVariable);
Add(currentC2, f.Type, loc);
Add(currentC2, f.DeclaringType, loc);
}
//else if (mb.BoundMember is PropertyNode) { // can this happen?
//}
else {
alert = true;
}
}
else if (exp is ConstructArray) {
var ca = (ConstructArray) exp;
Add(currentC2, ca.ElementType, currentLoc);
}
else if (exp is UnaryExpression) {
// e.g. a method call
var ue = (UnaryExpression) exp;
stack.Push(ue.Operand);
}
else if (exp is BinaryExpression) {
var be = (BinaryExpression) exp;
stack.Push(be.Operand1);
stack.Push(be.Operand2);
}
else if (exp is TernaryExpression) {
var te = (TernaryExpression) exp;
stack.Push(te.Operand1);
stack.Push(te.Operand2);
stack.Push(te.Operand3);
}
else if (exp is NamedArgument) {
var na = (NamedArgument) exp;
stack.Push(na.Value);
}
else {
NodeType nt = exp.NodeType;
bool ignore = (nt == NodeType.Pop || nt == NodeType.Dup);
alert = !ignore;
}
if (alert)
Write("x x " + currentC2.FullName + " " + currentMember.FullName + " " + exp.ToString() + " NodeType:" + exp.NodeType + " Type:" + exp.Type);
}
}
public override ProblemCollection Check(ModuleNode module) {
//Write("Check_ModuleNode: " + module.Name);
return this.Problems;
}
public override ProblemCollection Check(Parameter parameter) {
//Write("Check_Parameter: " + parameter.Name);
return this.Problems;
}
public override ProblemCollection Check(Resource resource) {
//Write("Check_Resource: " + resource.Name);
return this.Problems;
}
public override ProblemCollection Check(TypeNode type) {
//Write("Check_TypeNode: " + type.FullName + " declaring type: " + (type.DeclaringType == null ? "null" : type.DeclaringType.FullName) + " " + type.Interfaces);
currentC2 = GetClass2(type.FullName, type);
base.Check(type);
AttributeNodeCollection attribs = type.Attributes;
//Write("attributs.COunt: " + attribs.Count);
for (int i = 0; i < attribs.Count; i++) {
AttributeNode a = attribs[i];
//Write("a.Type: " + a.Type);
Add(currentC2, a.Type, CodeLocation.ClassDef);
}
InterfaceCollection iList = type.Interfaces;
for (int i = 0; i < iList.Count; i++) {
InterfaceNode n = iList[i];
Add(currentC2, n, CodeLocation.ClassDef);
}
return this.Problems;
}
private static Class2 GetClass2(String fullName, TypeNode ty) {
lock(dictTypes) {
Class2 ct = null;
if (!dictTypes.TryGetValue(fullName, out ct)) {
AssemblyNode a = ty.ContainingAssembly();
bool isEntryPoint = false;
Method ep = a.EntryPoint;
if (ep != null)
isEntryPoint = (String.Compare(fullName, ep.DeclaringType.FullName) == 0);
TypeNode dt = ty.DeclaringType;
TypeNode bt = ty.BaseType;
String dt_ = (dt == null ? "" : dt.FullName);
String bt_ = (bt == null ? "" : bt.FullName);
//Write("type: " + ty.FullName + " nt:" + ty.NodeType + " dt:" + dt_ + " bt:" + bt_);
ct = new Class2(fullName, isEntryPoint, dt_, bt_, ty.NodeType);
dictTypes[fullName] = ct;
}
return ct;
}
}
public override ProblemCollection Check(String namespaceName, TypeNodeCollection types) {
//Write("Check_namespaceName_types: " + namespaceName + ", " + types.Count);
return this.Problems;
}
protected override String GetLocalizedString(String name, params Object[] arguments) {
String s = base.GetLocalizedString(name, arguments);
//Write("GetLocalizedString: " + name);
return s;
}
protected override Resolution GetNamedResolution(String name, params Object[] arguments) {
Resolution r = base.GetNamedResolution(name, arguments);
//Write("GetNamedResolution: " + name);
return r;
}
private static void Write(String message, StreamWriter sw = null, bool console = false) {
if (dictOutput == null) {
if (console)
Console.WriteLine(message);
if (sw != null)
sw.WriteLine(message);
return;
}
lock(dictOutput) {
int id = System.Threading.Thread.CurrentThread.ManagedThreadId;
StringBuilder sb = null;
if (!dictOutput.TryGetValue(id, out sb)) {
sb = new StringBuilder();
dictOutput[id] = sb;
}
sb.AppendLine(message);
}
}
// chops off "Node" at the end, e.g: EnumNode > Node, DelegateNode > Delegate
private static String GetName(NodeType nt) {
String s = nt.ToString();
if (s.EndsWith("Node"))
s = s.Substring(0, s.Length - 4);
return s;
}
private static void FinalAnalysis() {
foreach (KeyValuePair<int, StringBuilder> pair in dictOutput) {
Console.WriteLine();
Console.WriteLine("Thread Id: " + pair.Key);
Console.Write(pair.Value);
}
dictOutput = null;
bool writeRefs = false;
bool console = false;
String outputFilename = null;
StreamWriter sw2 = null;
String[] args = Environment.GetCommandLineArgs(); // look at the args to determine what to output
foreach (String arg in args) {
if (arg.StartsWith("/out:")) {
outputFilename = arg.Substring(5);
String folder = Path.GetDirectoryName(outputFilename);
if (!Directory.Exists(folder))
Directory.CreateDirectory(folder);
System.Threading.Thread.Sleep(2000);
sw2 = new StreamWriter(new FileStream(outputFilename, FileMode.Create, FileAccess.Write));
}
else if (arg == "/c" || arg == "/console")
console = true;
else if (arg == "/v" || arg == "/verbose")
writeRefs = true;
}
Write("", sw2, console);
List<Class2> ctList = dictTypes.Values.OrderBy(t => t.FullName).ToList();
Hashtable htCluster = new Hashtable();
Hashtable ht = new Hashtable();
foreach (Class2 ct in ctList)
ht[ct.FullName] = ct;
foreach (Class2 ct in ctList) {
if (ct.DeclaringType.Length == 0) {
List<Class2> list = new List<Class2>();
list.Add(ct);
htCluster[ct] = list;
}
}
foreach (Class2 ct in ctList) {
if (ct.DeclaringType.Length == 0)
continue;
var ct2 = ct;
while (ct2.DeclaringType.Length > 0)
ct2 = (Class2) ht[ct2.DeclaringType];
List<Class2> list = (List<Class2>) htCluster[ct2];
ct2 = ct;
while (ct2.DeclaringType.Length > 0) {
list.Add(ct2);
ct2 = (Class2) ht[ct2.DeclaringType];
}
htCluster[ct] = list;
}
if (writeRefs) {
Write("ClassName,RefersTo,Locations", sw2, console);
foreach (Class2 ct in ctList) {
List<RefItem> refList = ct.GetRefs();
foreach (RefItem ri in refList)
Write(ct.FullName + "," + ri.FullName + "," + ri.Locations.ToString().Replace(',', ' '), sw2, console);
}
}
// if a nested class points to a parent class, don't count that as a reference
// if the only reference to class A is the construtor body of class B and class B extends class A, then don't count that as a reference
int n = ctList.Count;
for (int i = 0; i < n; i++) {
// check for other classes (ct2) that refer to ct
for (int j = 0; j < n; j++) {
if (i == j)
continue;
Class2 ct = ctList[i];
Class2 ct2 = ctList[j];
bool isNested = false;
String dt = ct2.DeclaringType;
while (dt.Length > 0) {
var p = (Class2) ht[dt];
if (p == ct) {
isNested = true;
break;
}
dt = p.DeclaringType;
}
if (isNested) {
//Write("Skipping: " + ct2.FullName + " because it is a nested class of: " + ct.FullName);
continue;
}
RefItem ri = ct2.GetRef(ct.FullName);
if (ri == null)
continue; // no references exist
if (ri.Locations == CodeLocation.ConstructorBody) {
bool isDescendant = false;
// ConstructorBody is the only location typically because of the implicit "base()" call.
// Check if ct2 is a descendant class of ct. If so, don't count the reference.
String bt = ct2.BaseType;
while (bt.Length > 0) {
var p = (Class2) ht[bt];
if (p == null)
break;
if (p == ct) {
isDescendant = true;
break;
}
bt = p.BaseType;
}
if (isDescendant)
continue; // skip, does not count as a reference
}
var list1 = (List<Class2>) htCluster[ct];
var list2 = (List<Class2>) htCluster[ct2];
if (list1 != list2) {
// group the nodes as part of the same cluster
List<Class2> list3 = new List<Class2>();
list3.AddRange(list1);
list3.AddRange(list2);
foreach (Class2 c2 in list3)
htCluster[c2] = list3;
//Write("Merged: [" + String.Join(", ", list1.Select(t => t.FullName)) + "] and [" + String.Join(", ", list2.Select(t => t.FullName)) + "]", sw2, console);
}
while (ct != null) {
if (ct2 != ct)
ct.Nbors.Add(ct2);
//Console.WriteLine(ct.FullName + ".Nbors.Add(" + ct2.FullName + ")");
ct = (Class2) ht[ct.DeclaringType];
}
}
}
// for each type that has a non-ConstructorBody reference, the ancestor types are counted as references.
// for example, if there were 5 classes A to E, where each one extends the one before it, i.e: A < B < C < D < E
// Suppose only class C is referenced somewhere in the code, then classes A & B are considered to be used,
// but classes D & E are considered unused.
foreach (Class2 ct in ctList) {
if (ct.Nbors.Count == 0)
continue;
Class2 ct2 = ct;
String bt = ct2.BaseType;
while (bt.Length > 0) {
var p = (Class2) ht[bt];
if (p == null)
break;
if (p.Nbors.Count == 0)
p.Nbors.Add(ct2);
bt = p.BaseType;
ct2 = p;
}
}
List<List<Class2>> clusters = htCluster.Values.Cast<List<Class2>>().Distinct().ToList();
List<List<Class2>> clusters2 = new List<List<Class2>>();
foreach (List<Class2> list in clusters) {
if (list.FirstOrDefault(t => t.IsEntryPoint) != null)
continue; // the cluster that contains the Main() method is not reported as an isolated cluster
// a cluster must have two or more non-related, non-nested classes
var list2 = list.Where(t => t.DeclaringType.Length == 0).ToList();
if (list2.Count > 1)
clusters2.Add(list2);
}
if (clusters2.Count > 0) {
Write(clusters2.Count + " isolated code clusters detected:", sw2, console);
for (int i = 0; i < clusters2.Count; i++) {
List<Class2> list = clusters2[i];
list.Sort();
Write("Cluster " + (i+1) + " has " + list.Count + " classes:", sw2, console);
for (int j = 0; j < list.Count; j++) {
Write(" " + (j+1) + ". " + list[j].FullName + " (" + GetName(list[j].NodeType) + ")", sw2, console);
}
Write("", sw2, console);
}
}
// the class that contains the entry point is not reported as unused
// Don't report anonymous classes (classes that have "<>" in the name)
List<Class2> ctUnused = ctList.Where(t => t.Nbors.Count == 0 && t.FullName.IndexOf("<>") < 0 && !t.IsEntryPoint).ToList();
if (ctUnused.Count > 0) {
// group by NodeType
Dictionary<NodeType, List<Class2>> dict = new Dictionary<NodeType, List<Class2>>();
foreach (Class2 ct in ctUnused) {
Class2 ct2 = ct;
bool include = true;
while (ct2.DeclaringType.Length > 0) {
var dt = (Class2) ht[ct2.DeclaringType];
if (dt.Nbors.Count == 0) {
// don't report a nested class if a parent class will be reported
include = false;
break;
}
ct2 = dt;
}
if (!include)
continue;
List<Class2> list = null;
if (!dict.TryGetValue(ct.NodeType, out list)) {
list = new List<Class2>();
dict[ct.NodeType] = list;
}
list.Add(ct);
}
List<NodeType> types = dict.Keys.ToList();
types.Sort();
foreach (NodeType key in types) {
String keyName = GetName(key);
List<Class2> list = dict[key];
Write("", sw2, console);
if (list.Count > 1)
Write("The following " + list.Count + " " + keyName + "s are not used by other code:", sw2, console);
else
Write("The following " + keyName + " is not used by other code:", sw2, console);
for (int i = 0; i < list.Count; i++) {
Write((i + 1) + ": " + list[i].FullName, sw2, console);
}
}
}
if (sw2 != null) {
sw2.Flush();
sw2.Dispose();
}
}
}
}

As per my understanding of the question , you are opting to find classes that cannot be reached from main method that is in the batch.
As per the layout of the solution, all the classes can be reached from the main method project by adding references and by making use of the using keyword.External references to other solution projects can be done by adding dll and then importing the namespace.
And if you want to perform clean up and remove unused classed from your solutions, you need to carefully check direct and indirect references of the classes.
Think the above answers your question, please mark as answer if you are satisfied.

Try reading the .sln file. It will contain references to all the projects used.
For each project used, open the .csproj file. All files under compile are used for project building. You can safely remove other files assuming you have one class per file.

How could I refactor this into more manageable code?

Is this code even complex enough to deserve a higher level of abstraction?
public static JsonStructure Parse(string jsonText)
{
var result = default(JsonStructure);
var structureStack = new Stack<JsonStructure>();
var keyStack = new Stack<string>();
var current = default(JsonStructure);
var currentState = ParserState.Begin;
var key = default(string);
var value = default(object);
foreach (var token in Lexer.Tokenize(jsonText))
{
switch (currentState)
{
case ParserState.Begin:
switch (token.Type)
{
case TokenType.BeginObject:
currentState = ParserState.Name;
current = result = new JsonObject();
break;
case TokenType.BeginArray:
currentState = ParserState.Value;
current = result = new JsonArray();
break;
default:
throw new JsonException(token, currentState);
}
break;
case ParserState.Name:
switch (token.Type)
{
case TokenType.String:
currentState = ParserState.NameSeparator;
key = (string)token.Value;
break;
default:
throw new JsonException(token, currentState);
}
break;
case ParserState.NameSeparator:
switch (token.Type)
{
case TokenType.NameSeparator:
currentState = ParserState.Value;
break;
default:
throw new JsonException(token, currentState);
}
break;
case ParserState.Value:
switch (token.Type)
{
case TokenType.Number:
case TokenType.String:
case TokenType.True:
case TokenType.False:
case TokenType.Null:
currentState = ParserState.ValueSeparator;
value = token.Value;
break;
case TokenType.BeginObject:
structureStack.Push(current);
keyStack.Push(key);
currentState = ParserState.Name;
current = new JsonObject();
break;
case TokenType.BeginArray:
structureStack.Push(current);
currentState = ParserState.Value;
current = new JsonArray();
break;
default:
throw new JsonException(token, currentState);
}
break;
case ParserState.ValueSeparator:
var jsonObject = (current as JsonObject);
var jsonArray = (current as JsonArray);
if (jsonObject != null)
{
jsonObject.Add(key, value);
currentState = ParserState.Name;
}
if (jsonArray != null)
{
jsonArray.Add(value);
currentState = ParserState.Value;
}
switch (token.Type)
{
case TokenType.EndObject:
case TokenType.EndArray:
currentState = ParserState.End;
break;
case TokenType.ValueSeparator:
break;
default:
throw new JsonException(token, currentState);
}
break;
case ParserState.End:
switch (token.Type)
{
case TokenType.EndObject:
case TokenType.EndArray:
case TokenType.ValueSeparator:
var previous = structureStack.Pop();
var previousJsonObject = (previous as JsonObject);
var previousJsonArray = (previous as JsonArray);
if (previousJsonObject != null)
{
previousJsonObject.Add(keyStack.Pop(), current);
currentState = ParserState.Name;
}
if (previousJsonArray != null)
{
previousJsonArray.Add(current);
currentState = ParserState.Value;
}
if (token.Type != TokenType.ValueSeparator)
{
currentState = ParserState.End;
}
current = previous;
break;
default:
throw new JsonException(token, currentState);
}
break;
default:
break;
}
}
return result;
}

Without looking at it in detail, as you are parsing based on state, could you use the state pattern to break it up and parse each bit in a separate class based on the state?
something like this might be a start, although this is just pseudo code...
public interface IParserState
{
IParserState ParseToken (IToken token);
}
public class BeginState : IParserState
{
private readonly Stack<JsonStructure> m_structureStack;
private readonly Stack<String> m_keyStack;
public BeginState (Stack<JsonStructure> structureStack, Stack<String> keyStack)
{
m_structureStack = structureStack;
m_keyStack = keyStack;
}
public IParserState ParseToken(IToken token)
{
switch (token.Type)
{
case TokenType.OpenBrace:
return new ObjectKeyParserState(m_structureStack,m_keyStack);
case TokenType.OpenBracket:
return new ArrayValueParserState(m_structureStack, m_keyStack);
default:
throw new JsonException (token);
}
}
}
public class ObjectKeyParserState : IParserState
{
private readonly Stack<JsonStructure> m_structureStack;
private readonly Stack<String> m_keyStack;
private readonly JsonObject m_current;
public ObjectKeyParserState (Stack<JsonStructure> structureStack, Stack<String> keyStack)
{
m_current = new JsonObject();
}
public IParserState ParseToken (IToken token)
{
switch (token.Type)
{
case TokenType.StringLiteral:
key = (string)token.Value;
return new ColonSeperatorParserState(m_structureStack, m_keyStack, m_current,key);
default:
throw new JsonException(token);
}
}

The 'conceptual design' in this case is production rules. If you were to design json yourself, would you think in terms of "A pair is a key followed by a colon followed by a value" or would you think in terms like "Colons will do 'a' in this case 'A' and do 'b' in case 'B' and do 'c' in case 'C'"? Look at http://www.json.org/. You'll see the 'conceptual design' stated in terms of production rules.
Since the 'structural design' of your code does not have the form of the 'conceptual design', no amount of refactoring will help. Changing the 'conceptual design' a small amount, would lead a code change that is hard to code and hard to test. You need a rewrite the code in terms of the 'conceptual design'.
// object
// "{" "}"
// "{" members "}"
private static JsonObject ProduceJsonObject(Tokens tokens)
{
var result = new JsonObject();
tokens.Accept( TokenType.OpenBrace );
result.members = ProduceJsonMembers(tokens);
tokens.Accept( TokenType.CloseBrace );
return result;
}
// members
// pair
// pair { "," pair }
private static JsonMembers ProduceJsonMembers(Tokens tokens)
{
var result = new JsonMembers();
result.Add( ProduceJsonPair(tokens) );
while (tokens.LookAhead == TokenTag.Comma)
{
tokens.Accept( TokenType.Comma );
result.Add( ProduceJsonPair(tokens) );
}
return result;
}
//pair
// string ":" value
private static JsonPair ProduceJsonPair(Tokens tokens)
{
var result = new JsonPair();
result.String = tokens.Accept( TokenType.ID );
tokens.Accept( TokenType.Colon );
result.Value = ProduceJsonValue( tokens );
return result;
}
// and so forth

Develop Reference

C# (C-Sharp) is a programming language developed by Microsoft that runs on the .NET Framework.

Extracting the current value of an instance variable while walking an Expression - c#

Related

Getting fields and properties' names, types and values recursively in C#

common pattern, Here so I am trying to simplify it to reduce duplication

Custom linked list c# for practice - not sure why my insertion is't working

How to identify unused classes in C# project

How could I refactor this into more manageable code?

Categories

Resources