如何编写可应用于任意深度列表的函数？我将给出两个我想用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＃中任意深度列表的函数。
答案 0 :(得分：4)
这里有两个问题;试着每个帖子只问一个问题。您可以像这样计算深度函数：
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>));
}
答案 1 :(得分：0)
您可以轻松地创建一个通用方法来下降集合（或集合集）。我已经包含了示例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();
}