public static string GetMemberTypesString(DynamicallyAccessedMemberTypes memberTypes)
{
Debug.Assert(memberTypes != DynamicallyAccessedMemberTypes.None);
if (memberTypes == DynamicallyAccessedMemberTypes.All)
{
return($"'{nameof (DynamicallyAccessedMemberTypes)}.{nameof (DynamicallyAccessedMemberTypes.All)}'");
}
var memberTypesList = AllDynamicallyAccessedMemberTypes
.Where(damt => (memberTypes & damt) == damt && damt != DynamicallyAccessedMemberTypes.None)
.ToList();
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicConstructors))
{
memberTypesList.Remove(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor);
}
return(string.Join(", ", memberTypesList.Select(mt => {
string mtName = mt == DynamicallyAccessedMemberTypesOverlay.Interfaces
? nameof(DynamicallyAccessedMemberTypesOverlay.Interfaces)
: mt.ToString();
return $"'{nameof (DynamicallyAccessedMemberTypes)}.{mtName}'";
})));
}
public static DynamicallyAccessedMemberTypes GetMissingMemberTypes(DynamicallyAccessedMemberTypes requiredMemberTypes, DynamicallyAccessedMemberTypes availableMemberTypes)
{
if (availableMemberTypes.HasFlag(requiredMemberTypes))
{
return(DynamicallyAccessedMemberTypes.None);
}
if (requiredMemberTypes == DynamicallyAccessedMemberTypes.All)
{
return(DynamicallyAccessedMemberTypes.All);
}
var missingMemberTypes = requiredMemberTypes & ~availableMemberTypes;
// PublicConstructors is a special case since its value is 3 - so PublicParameterlessConstructor (1) | _PublicConstructor_WithMoreThanOneParameter_ (2)
// The above bit logic only works for value with single bit set.
if (requiredMemberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicConstructors) &&
!availableMemberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicConstructors))
{
missingMemberTypes |= DynamicallyAccessedMemberTypes.PublicConstructors;
}
return(missingMemberTypes);
}
// Returns the members of the type bound by memberTypes. For MemberTypes.All, this returns a single null result.
// This sentinel value allows callers to handle the case where MemberTypes.All conceptually binds to the entire type
// including all recursive nested members.
public static IEnumerable <IMemberDefinition> GetDynamicallyAccessedMembers(this TypeDefinition typeDefinition, DynamicallyAccessedMemberTypes memberTypes)
{
if (memberTypes == DynamicallyAccessedMemberTypes.All)
{
yield return(null);
yield break;
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicConstructors))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicConstructors))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: m => m.IsPublic && m.Parameters.Count == 0))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicMethods))
{
foreach (var m in typeDefinition.GetMethodsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(m);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicMethods))
{
foreach (var m in typeDefinition.GetMethodsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(m);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicFields))
{
foreach (var f in typeDefinition.GetFieldsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(f);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicFields))
{
foreach (var f in typeDefinition.GetFieldsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(f);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicNestedTypes))
{
foreach (var t in typeDefinition.GetNestedTypesOnType(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(t);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicNestedTypes))
{
foreach (var t in typeDefinition.GetNestedTypesOnType(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(t);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicProperties))
{
foreach (var p in typeDefinition.GetPropertiesOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(p);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicProperties))
{
foreach (var p in typeDefinition.GetPropertiesOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(p);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicEvents))
{
foreach (var e in typeDefinition.GetEventsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(e);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicEvents))
{
foreach (var e in typeDefinition.GetEventsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(e);
}
}
}
// Returns the members of the type bound by memberTypes. For DynamicallyAccessedMemberTypes.All, this returns all members of the type and its
// nested types, including interface implementations, plus the same or any base types or implemented interfaces.
// DynamicallyAccessedMemberTypes.PublicNestedTypes and NonPublicNestedTypes do the same for members of the selected nested types.
public static IEnumerable <IMetadataTokenProvider> GetDynamicallyAccessedMembers(this TypeDefinition typeDefinition, LinkContext context, DynamicallyAccessedMemberTypes memberTypes, bool declaredOnly = false)
{
if (memberTypes == DynamicallyAccessedMemberTypes.None)
{
yield break;
}
if (memberTypes == DynamicallyAccessedMemberTypes.All)
{
var members = new List <IMetadataTokenProvider> ();
typeDefinition.GetAllOnType(context, declaredOnly, members);
foreach (var m in members)
{
yield return(m);
}
yield break;
}
var declaredOnlyFlags = declaredOnly ? BindingFlags.DeclaredOnly : BindingFlags.Default;
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicConstructors))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicConstructors))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: m => m.IsPublic && m.Parameters.Count == 0))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicMethods))
{
foreach (var m in typeDefinition.GetMethodsOnTypeHierarchy(context, filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(m);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicMethods))
{
foreach (var m in typeDefinition.GetMethodsOnTypeHierarchy(context, filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(m);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicFields))
{
foreach (var f in typeDefinition.GetFieldsOnTypeHierarchy(context, filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(f);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicFields))
{
foreach (var f in typeDefinition.GetFieldsOnTypeHierarchy(context, filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(f);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicNestedTypes))
{
foreach (var nested in typeDefinition.GetNestedTypesOnType(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(nested);
var members = new List <IMetadataTokenProvider> ();
nested.GetAllOnType(context, declaredOnly: false, members);
foreach (var m in members)
{
yield return(m);
}
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicNestedTypes))
{
foreach (var nested in typeDefinition.GetNestedTypesOnType(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(nested);
var members = new List <IMetadataTokenProvider> ();
nested.GetAllOnType(context, declaredOnly: false, members);
foreach (var m in members)
{
yield return(m);
}
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicProperties))
{
foreach (var p in typeDefinition.GetPropertiesOnTypeHierarchy(context, filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(p);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicProperties))
{
foreach (var p in typeDefinition.GetPropertiesOnTypeHierarchy(context, filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(p);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicEvents))
{
foreach (var e in typeDefinition.GetEventsOnTypeHierarchy(context, filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(e);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicEvents))
{
foreach (var e in typeDefinition.GetEventsOnTypeHierarchy(context, filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(e);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypesOverlay.Interfaces))
{
foreach (var i in typeDefinition.GetAllInterfaceImplementations(context, declaredOnly))
{
yield return(i);
}
}
}
private static bool AreCompatible(DynamicallyAccessedMemberTypes serviceDynamicallyAccessedMembers, DynamicallyAccessedMemberTypes implementationDynamicallyAccessedMembers)
{
// The DynamicallyAccessedMemberTypes don't need to exactly match.
// The service type needs to preserve a superset of the members required by the implementation type.
return(serviceDynamicallyAccessedMembers.HasFlag(implementationDynamicallyAccessedMembers));
}
// Returns the members of the type bound by memberTypes. For DynamicallyAccessedMemberTypes.All, this returns all members of the type and its
// nested types, including interface implementations, plus the same or any base types or implemented interfaces.
// DynamicallyAccessedMemberTypes.PublicNestedTypes and NonPublicNestedTypes do the same for members of the selected nested types.
public static IEnumerable <ISymbol> GetDynamicallyAccessedMembers(this ITypeSymbol typeDefinition, DynamicallyAccessedMemberTypes memberTypes, bool declaredOnly = false)
{
if (memberTypes == DynamicallyAccessedMemberTypes.None)
{
yield break;
}
if (memberTypes == DynamicallyAccessedMemberTypes.All)
{
var members = new List <ISymbol> ();
typeDefinition.GetAllOnType(declaredOnly, members);
foreach (var m in members)
{
yield return(m);
}
yield break;
}
var declaredOnlyFlags = declaredOnly ? BindingFlags.DeclaredOnly : BindingFlags.Default;
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicConstructors))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicConstructors))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: m => (m.DeclaredAccessibility == Accessibility.Public) && m.Parameters.Length == 0))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicMethods))
{
foreach (var m in typeDefinition.GetMethodsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(m);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicMethods))
{
foreach (var m in typeDefinition.GetMethodsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(m);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicFields))
{
foreach (var f in typeDefinition.GetFieldsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(f);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicFields))
{
foreach (var f in typeDefinition.GetFieldsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(f);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicNestedTypes))
{
foreach (var nested in typeDefinition.GetNestedTypesOnType(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(nested);
var members = new List <ISymbol> ();
nested.GetAllOnType(declaredOnly: false, members);
foreach (var m in members)
{
yield return(m);
}
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicNestedTypes))
{
foreach (var nested in typeDefinition.GetNestedTypesOnType(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(nested);
var members = new List <ISymbol> ();
nested.GetAllOnType(declaredOnly: false, members);
foreach (var m in members)
{
yield return(m);
}
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicProperties))
{
foreach (var p in typeDefinition.GetPropertiesOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(p);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicProperties))
{
foreach (var p in typeDefinition.GetPropertiesOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(p);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicEvents))
{
foreach (var e in typeDefinition.GetEventsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(e);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicEvents))
{
foreach (var e in typeDefinition.GetEventsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(e);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.Interfaces))
{
foreach (var i in typeDefinition.GetAllInterfaceImplementations(declaredOnly))
{
yield return(i);
}
}
}
// Returns the members of the type bound by memberTypes. For DynamicallyAccessedMemberTypes.All, this returns all members of the type and its
// nested types, including interface implementations, plus the same or any base types or implemented interfaces.
// DynamicallyAccessedMemberTypes.PublicNestedTypes and NonPublicNestedTypes do the same for members of the selected nested types.
public static IEnumerable <TypeSystemEntity> GetDynamicallyAccessedMembers(this TypeDesc typeDefinition, DynamicallyAccessedMemberTypes memberTypes, bool declaredOnly = false)
{
if (memberTypes == DynamicallyAccessedMemberTypes.None)
{
yield break;
}
if (memberTypes == DynamicallyAccessedMemberTypes.All)
{
var members = new List <TypeSystemEntity>();
typeDefinition.GetAllOnType(declaredOnly, members);
foreach (var m in members)
{
yield return(m);
}
yield break;
}
var declaredOnlyFlags = declaredOnly ? BindingFlags.DeclaredOnly : BindingFlags.Default;
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicConstructors))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicConstructors))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor))
{
foreach (var c in typeDefinition.GetConstructorsOnType(filter: m => m.IsPublic() && m.Signature.Length == 0))
{
yield return(c);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicMethods))
{
foreach (var m in typeDefinition.GetMethodsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(m);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicMethods))
{
foreach (var m in typeDefinition.GetMethodsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(m);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicFields))
{
foreach (var f in typeDefinition.GetFieldsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(f);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicFields))
{
foreach (var f in typeDefinition.GetFieldsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(f);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicNestedTypes))
{
foreach (var t in typeDefinition.GetNestedTypesOnType(filter: null, bindingFlags: BindingFlags.NonPublic))
{
yield return(t);
var members = new List <TypeSystemEntity>();
t.GetAllOnType(declaredOnly: false, members);
foreach (var m in members)
{
yield return(m);
}
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicNestedTypes))
{
foreach (var t in typeDefinition.GetNestedTypesOnType(filter: null, bindingFlags: BindingFlags.Public))
{
yield return(t);
var members = new List <TypeSystemEntity>();
t.GetAllOnType(declaredOnly: false, members);
foreach (var m in members)
{
yield return(m);
}
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicProperties))
{
foreach (var p in typeDefinition.GetPropertiesOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(p);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicProperties))
{
foreach (var p in typeDefinition.GetPropertiesOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(p);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicEvents))
{
foreach (var e in typeDefinition.GetEventsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.NonPublic | declaredOnlyFlags))
{
yield return(e);
}
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicEvents))
{
foreach (var e in typeDefinition.GetEventsOnTypeHierarchy(filter: null, bindingFlags: BindingFlags.Public | declaredOnlyFlags))
{
yield return(e);
}
}
}
internal static string GetDynamicallyAccessedMemberTypesDescription(DynamicallyAccessedMemberTypes memberTypes)
{
if (memberTypes == DynamicallyAccessedMemberTypes.All)
{
return(DynamicallyAccessedMemberTypes.All.ToString());
}
var results = new List <DynamicallyAccessedMemberTypes> ();
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicConstructors))
{
results.Add(DynamicallyAccessedMemberTypes.NonPublicConstructors);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicConstructors))
{
results.Add(DynamicallyAccessedMemberTypes.PublicConstructors);
}
else if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor))
{
results.Add(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicMethods))
{
results.Add(DynamicallyAccessedMemberTypes.NonPublicMethods);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicMethods))
{
results.Add(DynamicallyAccessedMemberTypes.PublicMethods);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicProperties))
{
results.Add(DynamicallyAccessedMemberTypes.NonPublicProperties);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicProperties))
{
results.Add(DynamicallyAccessedMemberTypes.PublicProperties);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicFields))
{
results.Add(DynamicallyAccessedMemberTypes.NonPublicFields);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicFields))
{
results.Add(DynamicallyAccessedMemberTypes.PublicFields);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicEvents))
{
results.Add(DynamicallyAccessedMemberTypes.NonPublicEvents);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicEvents))
{
results.Add(DynamicallyAccessedMemberTypes.PublicEvents);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.NonPublicNestedTypes))
{
results.Add(DynamicallyAccessedMemberTypes.NonPublicNestedTypes);
}
if (memberTypes.HasFlag(DynamicallyAccessedMemberTypes.PublicNestedTypes))
{
results.Add(DynamicallyAccessedMemberTypes.PublicNestedTypes);
}
if (results.Count == 0)
{
return(DynamicallyAccessedMemberTypes.None.ToString());
}
return(string.Join(" | ", results.Select(r => r.ToString())));
}
