internal DkmEvaluationResult FormatResult(string name, string fullName, DkmClrValue value, DkmClrType declaredType = null, bool[] declaredTypeInfo = null, DkmInspectionContext inspectionContext = null)
{
DkmEvaluationResult evaluationResult = null;
var workList = new DkmWorkList();
_resultProvider.GetResult(
value,
workList,
declaredType: declaredType ?? value.Type,
customTypeInfo: DynamicFlagsCustomTypeInfo.Create(declaredTypeInfo).GetCustomTypeInfo(),
inspectionContext: inspectionContext ?? DefaultInspectionContext,
formatSpecifiers: Formatter.NoFormatSpecifiers,
resultName: name,
resultFullName: null,
completionRoutine: asyncResult => evaluationResult = asyncResult.Result);
workList.Execute();
return(evaluationResult);
}
private string GetValueStringForCharacter(DkmClrValue value, DkmInspectionContext inspectionContext, ObjectDisplayOptions options)
{
Debug.Assert(value.Type.GetLmrType().IsCharacter());
if (UsesHexadecimalNumbers(inspectionContext))
{
options |= ObjectDisplayOptions.UseHexadecimalNumbers;
}
// check if HostObjectValue is null, since any of these types might actually be a synthetic value as well.
if (value.HostObjectValue == null)
{
return(_hostValueNotFoundString);
}
var charTemp = FormatLiteral((char)value.HostObjectValue, options);
Debug.Assert(charTemp != null);
return(charTemp);
}
internal override void GetRows(
ResultProvider resultProvider,
ArrayBuilder <EvalResult> rows,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value,
int startIndex,
int count,
bool visitAll,
ref int index)
{
if (InRange(startIndex, count, index))
{
rows.Add(CreateResultsViewRow(inspectionContext, parent, resultProvider.FullNameProvider));
}
index++;
}
internal override void GetRows(
ResultProvider resultProvider,
ArrayBuilder <DkmEvaluationResult> rows,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value,
int startIndex,
int count,
bool visitAll,
ref int index)
{
if (InRange(startIndex, count, index))
{
rows.Add(GetRow(resultProvider, inspectionContext, value, _elementType, parent));
}
index++;
}
internal DkmClrValue CreateDkmClrValue(
object value,
DkmClrType type,
string alias = null,
DkmEvaluationResultFlags evalFlags = DkmEvaluationResultFlags.None,
DkmClrValueFlags valueFlags = DkmClrValueFlags.None,
ulong nativeComPointer = 0)
{
return(new DkmClrValue(
value,
DkmClrValue.GetHostObjectValue(type.GetLmrType(), value),
type,
alias,
_formatter,
evalFlags,
valueFlags,
nativeComPointer: nativeComPointer));
}
internal static string GetExceptionMessage(
this DkmClrValue value,
DkmInspectionContext inspectionContext,
string fullNameWithoutFormatSpecifiers
)
{
var typeName = inspectionContext.GetTypeName(
value.Type,
null,
Formatter.NoFormatSpecifiers
);
return(string.Format(
Resources.ExceptionThrown,
fullNameWithoutFormatSpecifiers,
typeName
));
}
private EvalResult CreateResultsViewRow(
DkmInspectionContext inspectionContext,
string name,
string fullName,
ReadOnlyCollection <string> formatSpecifiers,
TypeAndCustomInfo declaredTypeAndInfo,
DkmClrValue value,
bool includeResultsFormatSpecifier,
IDkmClrFullNameProvider fullNameProvider
)
{
if (includeResultsFormatSpecifier)
{
formatSpecifiers = Formatter.AddFormatSpecifier(
formatSpecifiers,
ResultsFormatSpecifier
);
}
var childFullNamePrefix = fullNameProvider.GetClrObjectCreationExpression(
inspectionContext,
_proxyValue.Type,
customTypeInfo: null,
arguments: new[] { fullName }
);
return(new EvalResult(
ExpansionKind.Default,
name,
typeDeclaringMemberAndInfo: default(TypeAndCustomInfo),
declaredTypeAndInfo: declaredTypeAndInfo,
useDebuggerDisplay: false,
value: value,
displayValue: null,
expansion: new IndirectExpansion(_proxyValue, _proxyMembers),
childShouldParenthesize: false,
fullName: fullName,
childFullNamePrefixOpt: childFullNamePrefix,
formatSpecifiers: formatSpecifiers,
category: DkmEvaluationResultCategory.Method,
flags: DkmEvaluationResultFlags.ReadOnly,
editableValue: null,
inspectionContext: inspectionContext
));
}
internal override void GetRows(
ResultProvider resultProvider,
ArrayBuilder <EvalResult> rows,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value,
int startIndex,
int count,
bool visitAll,
ref int index)
{
var memberValue = value.GetMemberValue(_member, inspectionContext);
var isDynamicDebugViewEmptyException = memberValue.Type.GetLmrType().IsDynamicDebugViewEmptyException();
if (isDynamicDebugViewEmptyException || memberValue.IsError())
{
if (InRange(startIndex, count, index))
{
if (isDynamicDebugViewEmptyException)
{
var emptyMember = memberValue.Type.GetMemberByName("Empty");
memberValue = memberValue.GetMemberValue(emptyMember, inspectionContext);
}
var row = new EvalResult(Resources.ErrorName, (string)memberValue.HostObjectValue, inspectionContext);
rows.Add(row);
}
index++;
}
else
{
var other = MemberExpansion.CreateMemberDataItem(
resultProvider,
inspectionContext,
_member,
memberValue,
parent,
_customTypeInfoMap,
ExpansionFlags.IncludeBaseMembers | ExpansionFlags.IncludeResultsView,
supportsFavorites: false);
var expansion = other.Expansion;
expansion?.GetRows(resultProvider, rows, inspectionContext, other.ToDataItem(), other.Value, startIndex, count, visitAll, ref index);
}
}
internal override void GetRows(
ResultProvider resultProvider,
ArrayBuilder <DkmEvaluationResult> rows,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value,
int startIndex,
int count,
bool visitAll,
ref int index)
{
if (InRange(startIndex, count, index))
{
var evalResult = CreateEvaluationResult(Resources.ResultsView, parent, resultProvider.Formatter);
rows.Add(evalResult);
}
index++;
}
internal DkmClrValue CreateDkmClrValue(
object value,
Type type = null,
string alias = null,
DkmEvaluationResultFlags evalFlags = DkmEvaluationResultFlags.None,
DkmClrValueFlags valueFlags = DkmClrValueFlags.None)
{
if (type == null)
{
type = value.GetType();
}
return(new DkmClrValue(
value,
DkmClrValue.GetHostObjectValue((TypeImpl)type, value),
new DkmClrType((TypeImpl)type),
alias,
evalFlags,
valueFlags));
}
private static EvalResultDataItem GetMemberRow(
ResultProvider resultProvider,
DkmInspectionContext inspectionContext,
DkmClrValue value,
MemberAndDeclarationInfo member,
EvalResultDataItem parent,
DynamicFlagsMap dynamicFlagsMap)
{
var memberValue = GetMemberValue(value, member, inspectionContext);
return(CreateMemberDataItem(
resultProvider,
inspectionContext,
member,
memberValue,
parent,
dynamicFlagsMap,
ExpansionFlags.All));
}
private string TryFormatValue(DkmClrValue value, DkmInspectionContext inspectionContext)
{
if (value.ValueFlags.HasFlag(DkmClrValueFlags.Error))
{
// Error message. Just show the error.
return(value.HostObjectValue as string);
}
Type lmrType = value.Type.GetLmrType();
if (lmrType.IsEnum)
{
return(value.GetValueString(inspectionContext, null));
}
XSharpType xType = Utility.GetXSharpTypeForLmrType(lmrType);
if (xType == XSharpType.Invalid)
{
// We don't know how to format this value
return(null);
}
uint radix = inspectionContext.Radix;
object hostObjectValue = value.HostObjectValue;
if (hostObjectValue != null)
{
// If the value can be marshalled into the debugger process, HostObjectValue is the
// equivalent value in the debugger process.
switch (System.Type.GetTypeCode(hostObjectValue.GetType()))
{
case TypeCode.Int32:
return(FormatInteger((int)hostObjectValue, radix));
case TypeCode.Boolean:
return((bool)hostObjectValue ? "TRUE" : "FALSE");
case TypeCode.String:
return(FormatString(hostObjectValue.ToString(), inspectionContext.EvaluationFlags));
}
}
return(null);
}
private static EvalResult GetMemberRow(
ResultProvider resultProvider,
DkmInspectionContext inspectionContext,
DkmClrValue value,
MemberAndDeclarationInfo member,
EvalResultDataItem parent,
CustomTypeInfoTypeArgumentMap customTypeInfoMap)
{
var memberValue = value.GetMemberValue(member, inspectionContext);
return(CreateMemberDataItem(
resultProvider,
inspectionContext,
member,
memberValue,
parent,
customTypeInfoMap,
ExpansionFlags.All));
}
internal static void GetTupleFieldValues(this DkmClrValue tuple, int cardinality, ArrayBuilder <string> values, DkmInspectionContext inspectionContext)
{
while (true)
{
int n = Math.Min(cardinality, TupleFieldRestPosition - 1);
for (int i = 0; i < n; i++)
{
var value = GetFieldValue(tuple, TupleFieldItemNamePrefix + (i + 1), inspectionContext);
var str = value.GetValueString(inspectionContext, Formatter.NoFormatSpecifiers);
values.Add(str);
}
cardinality -= n;
if (cardinality == 0)
{
return;
}
tuple = GetFieldValue(tuple, TupleFieldRestName, inspectionContext);
}
}
internal static DynamicViewExpansion CreateExpansion(
DkmInspectionContext inspectionContext,
DkmClrValue value,
ResultProvider resultProvider
)
{
if (value.IsError() || value.IsNull || value.HasExceptionThrown())
{
return(null);
}
var type = value.Type.GetLmrType();
if (!(type.IsComObject() || type.IsIDynamicMetaObjectProvider()))
{
return(null);
}
var proxyValue = value.InstantiateDynamicViewProxy(inspectionContext);
Debug.Assert(
(proxyValue == null) ||
(
!proxyValue.IsNull &&
!proxyValue.IsError() &&
!proxyValue.HasExceptionThrown()
)
);
// InstantiateDynamicViewProxy may return null (if required assembly is missing, for instance).
if (proxyValue == null)
{
return(null);
}
// Expansion is based on the 'DynamicMetaObjectProviderDebugView.Items' property.
var proxyType = proxyValue.Type;
var itemsMemberExpansion = RootHiddenExpansion.CreateExpansion(
proxyType.GetMemberByName("Items"),
CustomTypeInfoTypeArgumentMap.Create(new TypeAndCustomInfo(proxyType))
);
return(new DynamicViewExpansion(proxyValue, itemsMemberExpansion));
}
public EvalResult(
ExpansionKind kind,
string name,
TypeAndCustomInfo typeDeclaringMemberAndInfo,
TypeAndCustomInfo declaredTypeAndInfo,
bool useDebuggerDisplay,
DkmClrValue value,
string displayValue,
Expansion expansion,
bool childShouldParenthesize,
string fullName,
string childFullNamePrefixOpt,
ReadOnlyCollection <string> formatSpecifiers,
DkmEvaluationResultCategory category,
DkmEvaluationResultFlags flags,
string editableValue,
DkmInspectionContext inspectionContext,
string displayName = null,
string displayType = null)
{
Debug.Assert(name != null);
Debug.Assert(formatSpecifiers != null);
Debug.Assert((flags & DkmEvaluationResultFlags.Expandable) == 0);
this.Kind = kind;
this.Name = name;
this.TypeDeclaringMemberAndInfo = typeDeclaringMemberAndInfo;
this.DeclaredTypeAndInfo = declaredTypeAndInfo;
this.UseDebuggerDisplay = useDebuggerDisplay;
this.Value = value;
this.DisplayValue = displayValue;
this.ChildShouldParenthesize = childShouldParenthesize;
this.FullNameWithoutFormatSpecifiers = fullName;
this.ChildFullNamePrefix = childFullNamePrefixOpt;
this.FormatSpecifiers = formatSpecifiers;
this.Category = category;
this.EditableValue = editableValue;
this.Flags = flags | GetFlags(value, inspectionContext) | ((expansion == null) ? DkmEvaluationResultFlags.None : DkmEvaluationResultFlags.Expandable);
this.Expansion = expansion;
this.InspectionContext = inspectionContext;
this.DisplayName = displayName;
this.DisplayType = displayType;
}
public EvalResultDataItem(
string name,
TypeAndCustomInfo declaredTypeAndInfo,
DkmClrValue value,
Expansion expansion,
bool childShouldParenthesize,
string fullNameWithoutFormatSpecifiers,
string childFullNamePrefixOpt,
ReadOnlyCollection <string> formatSpecifiers)
{
this.Name = name;
this.DeclaredTypeAndInfo = declaredTypeAndInfo;
this.Value = value;
this.ChildShouldParenthesize = childShouldParenthesize;
this.FullNameWithoutFormatSpecifiers = fullNameWithoutFormatSpecifiers;
this.ChildFullNamePrefix = childFullNamePrefixOpt;
this.FormatSpecifiers = formatSpecifiers;
this.Expansion = expansion;
}
private static EvalResultDataItem CreateMemberDataItem(
ResultProvider resultProvider,
DkmInspectionContext inspectionContext,
MemberAndDeclarationInfo member,
DkmClrValue memberValue,
EvalResultDataItem parent,
DynamicFlagsMap dynamicFlagsMap,
ExpansionFlags flags)
{
var declaredType = member.Type;
var declaredTypeInfo = dynamicFlagsMap.SubstituteDynamicFlags(member.OriginalDefinitionType, new DynamicFlagsCustomTypeInfo(member.TypeInfo)).GetCustomTypeInfo();
string memberName;
// Considering, we're not handling the case of a member inherited from a generic base type.
var typeDeclaringMember = member.GetExplicitlyImplementedInterface(out memberName) ?? member.DeclaringType;
var typeDeclaringMemberInfo = typeDeclaringMember.IsInterface
? dynamicFlagsMap.SubstituteDynamicFlags(typeDeclaringMember.GetInterfaceListEntry(member.DeclaringType), originalDynamicFlags: default(DynamicFlagsCustomTypeInfo)).GetCustomTypeInfo()
: null;
var formatter = resultProvider.Formatter;
memberName = formatter.GetIdentifierEscapingPotentialKeywords(memberName);
var fullName = MakeFullName(
formatter,
memberName,
new TypeAndCustomInfo(typeDeclaringMember, typeDeclaringMemberInfo), // Note: Won't include DynamicAttribute.
member.RequiresExplicitCast,
member.IsStatic,
parent);
return(resultProvider.CreateDataItem(
inspectionContext,
memberName,
typeDeclaringMemberAndInfo: (member.IncludeTypeInMemberName || typeDeclaringMember.IsInterface) ? new TypeAndCustomInfo(typeDeclaringMember, typeDeclaringMemberInfo) : default(TypeAndCustomInfo), // Note: Won't include DynamicAttribute.
declaredTypeAndInfo: new TypeAndCustomInfo(declaredType, declaredTypeInfo),
value: memberValue,
parent: parent,
expansionFlags: flags,
childShouldParenthesize: false,
fullName: fullName,
formatSpecifiers: Formatter.NoFormatSpecifiers,
category: DkmEvaluationResultCategory.Other,
flags: memberValue.EvalFlags,
evalFlags: DkmEvaluationFlags.None));
}
private string GetUnderlyingStringImpl(DkmClrValue value, DkmInspectionContext inspectionContext)
{
Debug.Assert(!value.IsError());
if (value.IsNull)
{
return(null);
}
var lmrType = value.Type.GetLmrType();
if (lmrType.IsEnum || lmrType.IsArray || lmrType.IsPointer)
{
return(null);
}
if (lmrType.IsNullable())
{
var nullableValue = value.GetNullableValue(inspectionContext);
return(nullableValue != null?GetUnderlyingStringImpl(nullableValue, inspectionContext) : null);
}
if (lmrType.IsString())
{
return((string)value.HostObjectValue);
}
else if (!IsPredefinedType(lmrType))
{
// Check for special cased non-primitives that have underlying strings
if (lmrType.IsType("System.Data.SqlTypes", "SqlString"))
{
var fieldValue = value.GetFieldValue(InternalWellKnownMemberNames.SqlStringValue, inspectionContext);
return(fieldValue.HostObjectValue as string);
}
else if (lmrType.IsOrInheritsFrom("System.Xml.Linq", "XNode"))
{
return(value.EvaluateToString(inspectionContext));
}
}
return(null);
}
private static ResultsViewExpansion CreateExpansion(DkmClrValue value, DkmClrType enumerableType, Formatter formatter)
{
var proxyValue = value.InstantiateResultsViewProxy(enumerableType);
// InstantiateResultsViewProxy may return null
// (if assembly is missing for instance).
if (proxyValue == null)
{
return(null);
}
var proxyMembers = MemberExpansion.CreateExpansion(
proxyValue.Type.GetLmrType(),
proxyValue,
ExpansionFlags.None,
TypeHelpers.IsPublic,
formatter);
return(new ResultsViewExpansion(proxyValue, proxyMembers));
}
internal override void GetRows(
ResultProvider resultProvider,
ArrayBuilder <EvalResult> rows,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value,
int startIndex,
int count,
bool visitAll,
ref int index)
{
foreach (var expansion in _expansions)
{
expansion.GetRows(resultProvider, rows, inspectionContext, parent, value, startIndex, count, visitAll, ref index);
if (!visitAll && (index >= startIndex + count))
{
return;
}
}
}
internal override void GetRows(
ResultProvider resultProvider,
ArrayBuilder <EvalResult> rows,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value,
int startIndex,
int count,
bool visitAll,
ref int index)
{
_proxyItem?.Expansion.GetRows(resultProvider, rows, inspectionContext, _proxyItem.ToDataItem(), _proxyItem.Value, startIndex, count, visitAll, ref index);
if (InRange(startIndex, count, index))
{
rows.Add(this.CreateRawViewRow(resultProvider, inspectionContext));
}
index++;
}
private DkmEvaluationResult GetRow(ResultProvider resultProvider, DkmClrValue value, int index, EvalResultDataItem parent)
{
var inspectionContext = value.InspectionContext;
var appDomain = value.Type.AppDomain;
var typeParameter = _typeParameters[index];
var typeArgument = _typeArguments[index];
var type = DkmClrType.Create(appDomain, typeArgument);
var name = typeParameter.Name;
var dataItem = new EvalResultDataItem(
name,
typeDeclaringMember: null,
declaredType: typeArgument,
value: null,
expansion: null,
childShouldParenthesize: false,
fullName: null,
childFullNamePrefixOpt: null,
formatSpecifiers: Formatter.NoFormatSpecifiers,
category: DkmEvaluationResultCategory.Data,
flags: DkmEvaluationResultFlags.ReadOnly,
editableValue: null);
var typeName = inspectionContext.GetTypeName(DkmClrType.Create(appDomain, typeArgument));
return(DkmSuccessEvaluationResult.Create(
inspectionContext,
value.StackFrame,
name,
dataItem.FullName,
dataItem.Flags,
Value: typeName,
EditableValue: null,
Type: typeName,
Category: dataItem.Category,
Access: value.Access,
StorageType: value.StorageType,
TypeModifierFlags: value.TypeModifierFlags,
Address: value.Address,
CustomUIVisualizers: null,
ExternalModules: null,
DataItem: dataItem));
}
private static EvalResultDataItem CreateMemberDataItem(
ResultProvider resultProvider,
DkmInspectionContext inspectionContext,
MemberAndDeclarationInfo member,
DkmClrValue memberValue,
EvalResultDataItem parent,
ExpansionFlags flags)
{
var formatter = resultProvider.Formatter;
string memberName;
var typeDeclaringMember = member.GetExplicitlyImplementedInterface(out memberName) ?? member.DeclaringType;
memberName = formatter.GetIdentifierEscapingPotentialKeywords(memberName);
// If the value is actually an exception that was thrown, we can't expect it to
// have any relation to the declared type of the value. Therefore, we will
// pretend that the exception type was the declared type for the purposes
// of creating the full name and expansion.
var declaredType = memberValue.EvalFlags.Includes(DkmEvaluationResultFlags.ExceptionThrown) ? memberValue.Type.GetLmrType() : member.Type;
var fullName = MakeFullName(
formatter,
memberName,
typeDeclaringMember,
member.RequiresExplicitCast,
member.IsStatic,
parent);
return(resultProvider.CreateDataItem(
inspectionContext,
memberName,
typeDeclaringMember: (member.IncludeTypeInMemberName || typeDeclaringMember.IsInterface) ? typeDeclaringMember : null,
declaredType: declaredType,
value: memberValue,
parent: parent,
expansionFlags: flags,
childShouldParenthesize: false,
fullName: fullName,
formatSpecifiers: Formatter.NoFormatSpecifiers,
category: DkmEvaluationResultCategory.Other,
flags: memberValue.EvalFlags,
evalFlags: DkmEvaluationFlags.None));
}
private EvalResult GetRow(
DkmInspectionContext inspectionContext,
DkmClrValue value,
int index,
EvalResultDataItem parent
)
{
var typeParameter = _typeParameters[index];
var typeArgument = _typeArguments[index];
var typeArgumentInfo = _customTypeInfoMap.SubstituteCustomTypeInfo(
typeParameter,
customInfo: null
);
var formatSpecifiers = Formatter.NoFormatSpecifiers;
return(new EvalResult(
ExpansionKind.TypeVariable,
typeParameter.Name,
typeDeclaringMemberAndInfo: default(TypeAndCustomInfo),
declaredTypeAndInfo: new TypeAndCustomInfo(
DkmClrType.Create(value.Type.AppDomain, typeArgument),
typeArgumentInfo
),
useDebuggerDisplay: parent != null,
value: value,
displayValue: inspectionContext.GetTypeName(
DkmClrType.Create(value.Type.AppDomain, typeArgument),
typeArgumentInfo,
formatSpecifiers
),
expansion: null,
childShouldParenthesize: false,
fullName: null,
childFullNamePrefixOpt: null,
formatSpecifiers: formatSpecifiers,
category: DkmEvaluationResultCategory.Data,
flags: DkmEvaluationResultFlags.ReadOnly,
editableValue: null,
inspectionContext: inspectionContext
));
}
private EvalResult CreateRawViewRow(
ResultProvider resultProvider,
DkmInspectionContext inspectionContext,
EvalResultDataItem parent,
DkmClrValue value
)
{
var displayName = Resources.RawView;
var displayValue = value.GetValueString(
inspectionContext,
Formatter.NoFormatSpecifiers
);
var displayType = ResultProvider.GetTypeName(
inspectionContext,
value,
_typeAndInfo.ClrType,
_typeAndInfo.Info,
isPointerDereference: false
);
var expansion = new TupleExpansion(_typeAndInfo, _cardinality, useRawView: true);
return new EvalResult(
ExpansionKind.Explicit,
displayName,
default(TypeAndCustomInfo),
_typeAndInfo,
useDebuggerDisplay: false,
value: value,
displayValue: displayValue,
expansion: expansion,
childShouldParenthesize: parent.ChildShouldParenthesize,
fullName: parent.FullNameWithoutFormatSpecifiers,
childFullNamePrefixOpt: parent.ChildFullNamePrefix,
formatSpecifiers: Formatter.AddFormatSpecifier(parent.FormatSpecifiers, "raw"),
category: DkmEvaluationResultCategory.Data,
flags: DkmEvaluationResultFlags.ReadOnly,
editableValue: null,
inspectionContext: inspectionContext,
displayName: displayName,
displayType: displayType
);
}
internal string FormatPrimitive(DkmClrValue value, ObjectDisplayOptions options)
{
Debug.Assert(value != null);
object obj;
if (value.Type.GetLmrType().IsDateTime())
{
DkmClrValue dateDataValue = value.GetFieldValue(DateTimeUtilities.DateTimeDateDataFieldName);
Debug.Assert(dateDataValue.HostObjectValue != null);
obj = DateTimeUtilities.ToDateTime((ulong)dateDataValue.HostObjectValue);
}
else
{
Debug.Assert(value.HostObjectValue != null);
obj = value.HostObjectValue;
}
return(FormatPrimitiveObject(obj, options));
}
internal static TupleExpansion CreateExpansion(
DkmInspectionContext inspectionContext,
TypeAndCustomInfo declaredTypeAndInfo,
DkmClrValue value,
int cardinality
)
{
if (value.IsNull)
{
// No expansion.
return null;
}
bool useRawView =
(inspectionContext.EvaluationFlags & DkmEvaluationFlags.ShowValueRaw) != 0;
return new TupleExpansion(
new TypeAndCustomInfo(value.Type, declaredTypeAndInfo.Info),
cardinality,
useRawView
);
}
private string FormatPrimitive(DkmClrValue value, ObjectDisplayOptions options, DkmInspectionContext inspectionContext)
{
Debug.Assert(value != null);
object obj;
if (value.Type.GetLmrType().IsDateTime())
{
DkmClrValue dateDataValue = value.GetPropertyValue("Ticks", inspectionContext);
Debug.Assert(dateDataValue.HostObjectValue != null);
obj = new DateTime((long)dateDataValue.HostObjectValue);
}
else
{
Debug.Assert(value.HostObjectValue != null);
obj = value.HostObjectValue;
}
return(FormatPrimitiveObject(obj, options));
}
/// <summary>
/// Generate a Results Only row if the value is a synthesized
/// value declared as IEnumerable or IEnumerable<T>.
/// </summary>
internal static EvalResult CreateResultsOnlyRowIfSynthesizedEnumerable(
DkmInspectionContext inspectionContext,
string name,
string fullName,
ReadOnlyCollection <string> formatSpecifiers,
DkmClrType declaredType,
DkmClrCustomTypeInfo declaredTypeInfo,
DkmClrValue value,
ResultProvider resultProvider)
{
if ((value.ValueFlags & DkmClrValueFlags.Synthetic) == 0)
{
return(null);
}
// Must be declared as IEnumerable or IEnumerable<T>, not a derived type.
var enumerableType = GetEnumerableType(value, declaredType, requireExactInterface: true);
if (enumerableType == null)
{
return(null);
}
var expansion = CreateExpansion(inspectionContext, value, enumerableType, resultProvider);
if (expansion == null)
{
return(null);
}
return(expansion.CreateResultsViewRow(
inspectionContext,
name,
fullName,
formatSpecifiers,
new TypeAndCustomInfo(declaredType, declaredTypeInfo),
value,
includeResultsFormatSpecifier: false,
fullNameProvider: resultProvider.FullNameProvider));
}
