private void FormatDictionaryMembers(
CommonObjectFormatter.Builder result,
IDictionary dict)
{
result.AppendGroupOpening();
int num = 0;
try
{
IDictionaryEnumerator enumerator = dict.GetEnumerator();
using (enumerator as IDisposable)
{
while (enumerator.MoveNext())
{
DictionaryEntry entry = enumerator.Entry;
result.AppendCollectionItemSeparator(num == 0);
result.AppendGroupOpening();
result.AppendCollectionItemSeparator(true);
this.FormatObjectRecursive(result, entry.Key, false);
result.AppendCollectionItemSeparator(false);
this.FormatObjectRecursive(result, entry.Value, false);
result.AppendGroupClosing();
++num;
}
}
}
catch (Exception ex)
{
result.AppendCollectionItemSeparator(num == 0);
this.FormatException(result, ex);
result.Append(' ');
}
result.AppendGroupClosing();
}
public bool Append(CommonObjectFormatter.Builder result, string separator)
{
result.Append(this.GetDisplayName(), 0, int.MaxValue);
result.Append(separator, 0, int.MaxValue);
result.Append(this.Value, 0, int.MaxValue);
return(true);
}
private void FormatMembers(
CommonObjectFormatter.Builder result,
object obj)
{
RuntimeHelpers.EnsureSufficientExecutionStack();
result.Append(' ');
if (!this.VisitedObjects.Add(obj))
{
result.AppendInfiniteRecursionMarker();
}
else
{
bool flag = false;
if (obj is IDictionary dict)
{
this.FormatDictionaryMembers(result, dict);
flag = true;
}
else if (obj is IEnumerable sequence)
{
this.FormatSequenceMembers(result, sequence);
flag = true;
}
if (!flag)
{
this.FormatObjectMembers(result, obj);
}
this.VisitedObjects.Remove(obj);
}
}
private void FormatArray(CommonObjectFormatter.Builder result, Array array)
{
this.FormatCollectionHeader(result, array);
if (array.Rank > 1)
{
this.FormatMultidimensionalArrayElements(result, array);
}
else
{
result.Append(' ');
this.FormatSequenceMembers(result, array);
}
}
private void FormatKeyValuePair(CommonObjectFormatter.Builder result, object obj)
{
System.Reflection.TypeInfo typeInfo = IntrospectionExtensions.GetTypeInfo(obj.GetType());
object obj1 = typeInfo.GetDeclaredProperty("Key").GetValue(obj, Array.Empty <object>());
object obj2 = typeInfo.GetDeclaredProperty("Value").GetValue(obj, Array.Empty <object>());
result.AppendGroupOpening();
result.AppendCollectionItemSeparator(true);
this.FormatObjectRecursive(result, obj1, false);
result.AppendCollectionItemSeparator(false);
this.FormatObjectRecursive(result, obj2, false);
result.AppendGroupClosing();
}
private void ObjectToString(CommonObjectFormatter.Builder result, object obj)
{
try
{
string str = obj.ToString();
result.Append('[');
result.Append(str, 0, int.MaxValue);
result.Append(']');
}
catch (Exception ex)
{
this.FormatException(result, ex);
}
}
private void FormatMultidimensionalArrayElements(
CommonObjectFormatter.Builder result,
Array array)
{
if (array.Length == 0)
{
result.AppendCollectionItemSeparator(true);
result.AppendGroupOpening();
result.AppendGroupClosing();
}
else
{
int[] numArray = new int[array.Rank];
for (int dimension = array.Rank - 1; dimension >= 0; --dimension)
{
numArray[dimension] = array.GetLowerBound(dimension);
}
int num1 = 0;
int num2 = 0;
while (true)
{
int dimension1 = numArray.Length - 1;
while (numArray[dimension1] > array.GetUpperBound(dimension1))
{
numArray[dimension1] = array.GetLowerBound(dimension1);
result.AppendGroupClosing();
--num1;
--dimension1;
if (dimension1 < 0)
{
return;
}
++numArray[dimension1];
}
result.AppendCollectionItemSeparator(num2 == 0);
for (int dimension2 = numArray.Length - 1; dimension2 >= 0 && numArray[dimension2] == array.GetLowerBound(dimension2); --dimension2)
{
result.AppendGroupOpening();
++num1;
result.AppendCollectionItemSeparator(true);
}
this.FormatObjectRecursive(result, array.GetValue(numArray), false);
++numArray[numArray.Length - 1];
++num2;
}
}
}
public bool AppendAsCollectionEntry(CommonObjectFormatter.Builder result)
{
if (this.HasKeyName())
{
result.AppendGroupOpening();
result.AppendCollectionItemSeparator(true);
result.Append(this.Name, 1, this.Name.Length - 2);
result.AppendCollectionItemSeparator(false);
result.Append(this.Value, 0, int.MaxValue);
result.AppendGroupClosing();
}
else
{
result.Append(this.Value, 0, int.MaxValue);
}
return(true);
}
private void FormatCollectionHeader(
CommonObjectFormatter.Builder result,
ICollection collection)
{
if (collection is Array arrayOpt)
{
result.Append(this._formatter.TypeNameFormatter.FormatArrayTypeName(arrayOpt.GetType(), arrayOpt), 0, int.MaxValue);
}
else
{
result.Append(this._formatter.TypeNameFormatter.FormatTypeName(collection.GetType()), 0, int.MaxValue);
try
{
result.Append('(');
result.Append(collection.Count.ToString(), 0, int.MaxValue);
result.Append(')');
}
catch (Exception ex)
{
}
}
}
private void FormatSequenceMembers(
CommonObjectFormatter.Builder result,
IEnumerable sequence)
{
result.AppendGroupOpening();
int num = 0;
try
{
foreach (object obj in sequence)
{
result.AppendCollectionItemSeparator(num == 0);
this.FormatObjectRecursive(result, obj, false);
++num;
}
}
catch (Exception ex)
{
result.AppendCollectionItemSeparator(num == 0);
this.FormatException(result, ex);
result.Append(" ...", 0, int.MaxValue);
}
result.AppendGroupClosing();
}
private void FormatObjectMembers(
CommonObjectFormatter.Builder result,
object obj)
{
List <CommonObjectFormatter.Visitor.FormattedMember> result1 = new List <CommonObjectFormatter.Visitor.FormattedMember>();
this.FormatObjectMembersRecursive(result1, obj);
bool flag = CommonObjectFormatter.Visitor.UseCollectionFormat(result1, IntrospectionExtensions.GetTypeInfo(obj.GetType()));
result.AppendGroupOpening();
for (int index = 0; index < result1.Count; ++index)
{
result.AppendCollectionItemSeparator(index == 0);
if (flag)
{
result1[index].AppendAsCollectionEntry(result);
}
else
{
result1[index].Append(result, "=");
}
}
result.AppendGroupClosing();
}
private void FormatException(CommonObjectFormatter.Builder result, Exception exception)
{
result.Append("!<", 0, int.MaxValue);
result.Append(this._formatter.TypeNameFormatter.FormatTypeName(((object)exception).GetType()), 0, int.MaxValue);
result.Append('>');
}
private CommonObjectFormatter.Builder FormatObjectRecursive(
CommonObjectFormatter.Builder result,
object obj,
bool isRoot)
{
string str = this._formatter.PrimitiveFormatter.FormatPrimitive(obj, this._primitiveOptions);
if (str != null)
{
result.Append(str, 0, int.MaxValue);
return(result);
}
Type type = obj.GetType();
System.Reflection.TypeInfo typeInfo = IntrospectionExtensions.GetTypeInfo(type);
if (typeInfo.IsGenericType && typeInfo.GetGenericTypeDefinition() == (object)typeof(KeyValuePair <,>))
{
if (isRoot)
{
result.Append(this._formatter.TypeNameFormatter.FormatTypeName(type), 0, int.MaxValue);
result.Append(' ');
}
this.FormatKeyValuePair(result, obj);
return(result);
}
if (typeInfo.IsArray)
{
if (this.VisitedObjects.Add(obj))
{
this.FormatArray(result, (Array)obj);
this.VisitedObjects.Remove(obj);
}
else
{
result.AppendInfiniteRecursionMarker();
}
return(result);
}
bool flag = false;
ICollection collection = null;
if (obj is ICollection)
{
collection = (ICollection)obj;
this.FormatCollectionHeader(result, collection);
}
else if (ObjectFormatterHelpers.HasOverriddenToString(typeInfo))
{
this.ObjectToString(result, obj);
flag = true;
}
else
{
result.Append(this._formatter.TypeNameFormatter.FormatTypeName(type), 0, int.MaxValue);
}
if (!flag)
{
this.FormatMembers(result, obj);
}
return(result);
}
