你如何编写一个可以应用于任意深度列表的函数？我将给出两个我尝试用 C# 编写的函数类型的示例。
示例 1：depth()可用于任何列表的方法：
int depth<T>(this List<T> x) {
if (/*x[0] is a List<of something>*/) { return x[0].depth + 1; }
else { return 1; }
}
示例 2：implode()可以在任意深度的字符串列表上使用的方法：
List<List<string>> first = /* ("a","b"),("x","y","z") */
List<string> second = /* "a","b","c" */
first.implode() /* returns a string: "(a,b),(x,y,z)" */
second.implode() /* returns a string: "a,b,c" */
但我不知道如何制作这样一个适用于 C# 中任意深度列表的函数。
您在这里有两个问题；尝试在每个帖子中只问一个问题。您可以像这样计算深度函数：
static int Depth(Type type)
{
int depth = 0;
for(
Type current = type;
current.IsGenericType && current.GetGenericTypeDefinition() == typeof(List<>) ;
current = current.GetGenericArguments()[0] )
{
depth += 1;
}
return depth;
}
static int Depth<T>(this List<T> x)
// x is unused; you could eliminate it entirely.
{
return Depth(typeof(List<T>));
}
您可以轻松地制作一个通用方法来降低集合（或集合）。我已经包含了示例Depth和Implode方法。另请注意，Depth未使用该方法的参数（Eric 在他的回答中也提到过）。您可以轻松地从方法的签名中省略参数Depth并传递default(List<TElement>)给Descend方法。
/// <summary>
/// Extension methods for lists (or lists of lists)
/// </summary>
public static class ListExtensions
{
/// <summary>
/// Cache the generic method definition for <see cref="Descend{TElement, TResult}"/>
/// </summary>
private static readonly MethodInfo DescendMethod = new Func<List<object>, Func<object, object>, Func<IEnumerable<object>,object>, object>(Descend).Method.GetGenericMethodDefinition();
/// <summary>
/// Descends a potentially nested set of enumerables
/// </summary>
/// <typeparam name="TElement">The current enumerable type</typeparam>
/// <typeparam name="TResult">The type of the result of the calling method</typeparam>
/// <param name="set">The set of elements to work on</param>
/// <param name="compute">The computation to perform on a single element</param>
/// <param name="aggregate">The computation to perform on a collection of results from computations on single elements</param>
/// <returns>The result of the aggregation of all the results from all levels of the set</returns>
private static TResult Descend<TElement, TResult>(this List<TElement> set, Func<object, TResult> compute, Func<IEnumerable<TResult>, TResult> aggregate)
{
var elementType = typeof(TElement);
if (elementType.IsGenericType && typeof(List<>) == elementType.GetGenericTypeDefinition())
{
var method = DescendMethod.MakeGenericMethod(elementType.GetGenericArguments()[0], typeof(TResult));
if (ReferenceEquals(set, null))
{
return aggregate(new[] { (TResult)method.Invoke(null, new object[] { default(TElement), compute, aggregate }) });
}
var results = set.Select(item => (TResult)method.Invoke(null, new object[] { item, compute, aggregate })).ToList();
if (results.Count == 0)
{
return aggregate(new[] { (TResult)method.Invoke(null, new object[] { default(TElement), compute, aggregate }) });
}
return aggregate(results);
}
return aggregate((set ?? new List<TElement>()).OfType<object>().Select(compute));
}
/// <summary>
/// Walks down a set (possibly of sets) to determine its depth
/// </summary>
/// <typeparam name="TElement">The type of elements found in the top level set</typeparam>
/// <param name="set">The set to walk down</param>
/// <returns>The depth of the set</returns>
public static int Depth<TElement>(this List<TElement> set)
{
return set.Descend(x => 0, x => x.FirstOrDefault() + 1);
}
/// <summary>
/// Walks down a set (possibly of sets) to determine its depth
/// </summary>
/// <typeparam name="TElement">The type of elements found in the top level set</typeparam>
/// <returns>The depth of the set</returns>
public static int Depth<TElement>()
{
return Descend(default(List<TElement>), x => 0, x => x.FirstOrDefault() + 1);
}
/// <summary>
/// Creates a string representation of a set (possibly of sets)
/// </summary>
/// <typeparam name="TElement">The type of elements found in the top level set</typeparam>
/// <param name="set">The set to create the string representation of</param>
/// <returns>A string representation of the set</returns>
public static string Implode<TElement>(this List<TElement> set)
{
var result = set.Descend(x => x != null
? x.ToString()
: null,
x =>
{
var elements = x.Where(y => !ReferenceEquals(y, null)).ToList();
if (elements.Count == 0)
{
return null;
}
return "(" + String.Join(",", elements) + ")";
});
if (result != null && result.Length > 2)
{
return result.Substring(1, result.Length - 2);
}
return result;
}
}
class Program
{
private static void Main()
{
var tmp2 = new List<List<List<List<string>>>>();
var tmp = new List<List<List<string>>>
{
new List<List<string>>
{
new List<string>
{
"1",
"2",
"3"
},
new List<string>
{
"4"
}
},
new List<List<string>>
{
new List<string>
{
"5",
"6",
"7"
}
}
};
Console.WriteLine(ListExtensions.Depth<List<List<List<List<string>>>>>());
Console.WriteLine(tmp2.Depth());
Console.WriteLine(tmp2.Implode());
Console.WriteLine(tmp.Depth());
Console.WriteLine(tmp.Implode());
Console.ReadLine();
}