调用泛型方法c#_C#_Generics_Reflection

调用泛型方法c#

c# generics reflection

调用泛型方法c#,c#,generics,reflection,C#,Generics,Reflection,如何调用泛型方法，我听说了反射，但我认为我做错了，请检查 public static LinkedListNode<T> MergeSortLL<T>(LinkedListNode<T> Head) where T : IComparable<T> { if (Head == null || Head.Next == null) { return Head; }

如何调用泛型方法，我听说了反射，但我认为我做错了，请检查

 public static LinkedListNode<T> MergeSortLL<T>(LinkedListNode<T> Head) where T : IComparable<T>
    {

        if (Head == null || Head.Next == null)
        {
            return Head;
        }
        LinkedListNode<T> middle = GetMiddle<T>(Head);
        LinkedListNode<T> half = middle.Next;
        middle.Next = null;

        return Merge(Head, half);

    }

更新2。 这里有更多信息，我在我的类MergeSort中有什么，以及为什么我使用IComparable

class MergeSort
{

    public static LinkedListNode<T> MergeSortLL<T>(LinkedListNode<T> Head) where T : IComparable<T>
    {

        if (Head == null || Head.Next == null)
        {
            return Head;
        }
        LinkedListNode<T> middle = GetMiddle<T>(Head);
        LinkedListNode<T> half = middle.Next;
        middle.Next = null;

        return Merge(Head, Head, half);

    }

    public static LinkedListNode<T> Merge<T>(LinkedListNode<T> Head, LinkedListNode<T> Left, LinkedListNode<T> Right) where T : IComparable<T>
    {

        LinkedListNode<T> mHead = Head;
        LinkedListNode<T> curr = mHead;

        while (Left != null && Right != null)
        {
            if (Left.Value.CompareTo(Right.Value) <= 0)
            {
                curr.Next = Left;
                Left = Left.Next;
            }
            else
            {
                curr.Next = Right;
                Right = Right.Next;
            }
            curr = curr.Next;
        }
        curr.Next = (Left == null) ? Right : Left;

        return mHead.Next;
    }

    public static LinkedListNode<T> GetMiddle<T>(LinkedListNode<T> Head) where T : IComparable<T>
    {
        if (Head == null)
        {
            return Head;
        }

        LinkedListNode<T> slow, fast;
        slow = fast = Head;
        while (fast.Next != null && fast.Next.Next != null)
        {
            slow = slow.Next; fast = fast.Next.Next;
        }
        return slow;
    }

}

类合并排序
{
公共静态LinkedListNode合并SORTLL（LinkedListNode头），其中T:IComparable
{
if（Head==null | | Head.Next==null）
{
回流头；
}
LinkedListNode middle=GetMiddle（头部）；
LinkedListNode一半=中间。下一步；
middle.Next=null；
返回合并（头、头、半）；
}
公共静态LinkedListNode合并（LinkedListNode头，LinkedListNode左，LinkedListNode右），其中T:IComparable
{
LinkedListNode mHead=头；
LinkedListNode curr=mHead；
while（左！=null和右！=null）
{
如果（Left.Value.CompareTo（Right.Value）查看您留下的评论和遇到的问题。在我看来，您的意图是将LinkedList传递给此方法，因此它应该是：
public static LinkedListNode<T> MergeSortLL<T>(LinkedList<T> Head) where T : IComparable<T>

您还对genereic类型T设置了一个泛型约束，确保您使用的任何类型都继承自IComparable
，大声说出来听起来有点奇怪，但似乎是正确的。
查看您留下的注释和遇到的问题。在我看来，您的意图是通过e LinkedList指向此方法，因此应为：
public static LinkedListNode<T> MergeSortLL<T>(LinkedList<T> Head) where T : IComparable<T>

您还对genereic类型T设置了一个泛型约束，确保您使用的任何类型都继承自IComparable
，当大声说出时听起来有点奇怪，但似乎是正确的。
如果您有LinkedList
只需传递它的头部（通过First
属性）并将推断出类型
var list = new LinkedList<int>();
var head = list.First; 
var sorted = MergeSort.MergeSortLL(head);

如果您有一个LinkedList
，只需将它的头（通过First
属性）传递给该方法，就会推断出类型
var list = new LinkedList<int>();
var head = list.First; 
var sorted = MergeSort.MergeSortLL(head);

您可以查看stackoverflow Justvar result=MergeSort.MergeSorLL（headNodeOfrinkedList）中的帖子
泛型将是推断泛型，反射不能很好地混合。如果你不知道类型，你就不能在编译时对输出做任何事情。如果你知道，那么就不需要使用反射，只需按照@juharr的建议调用它。你可以在stackoverflow justvar result=MergeSort.MergeSorLL中查看帖子（HeadNodeOfLinkedList）
泛型将是推断泛型，反射不能很好地混合。如果你不知道类型，你就不能在编译时对输出做任何事情。如果你知道，那么就没有必要使用反射，只需按照@juharr的建议调用它。我认为MergeSort
是包含该方法的类，而不一定是包含该方法的类型从他调用该方法的方式来看，我相信我会思考我所做的事情。然而，我更倾向于同意你的观点……从OP中完全可以看出。我是基于typeof（MergeSort.GetMethod（“mergesortl”）
是的，MergeSort是类，我输入了MergeSort.mergesortl（Head）；
出现错误，无法从“task.LinkedListNode”转换为“task.LinkedListNode”
@vitali您需要像下面这样传递LinkedList
的头

。或者将方法更改为采用

链接列表

而不是

链接列表节点

。我认为

合并排序

是包含该方法的类，而不一定是泛型链接列表中包含的类型。从他调用该方法的方式来看，我相信我会思考我所做的事情。然而，我更喜欢ned同意你的观点…从OP中完全可以看出，我是基于

typeof（MergeSort）.GetMethod（“MergeSortLL”）

是的，MergeSort是类，我输入了

MergeSort.MergeSortLL（Head）

并出现错误，

无法从“task.LinkedListNode”转换为“task.LinkedListNode”

@vitaly您需要像这样传递

LinkedList

的头

MergeSort.mergesortl（list.First）

。或者将方法更改为采用

LinkedList

，而不是

LinkedListNode

。

var list = new LinkedList<int>();
var head = list.First; 
var sorted = MergeSort.MergeSortLL(head);

var sorted = head.MergeSortLL();