C# 将对象类型转换为C类#

问题：我试图将对象类型类型强制转换回根类
我从一个通用的双链表开始，我可以添加值，但不能检索它们

class CarPart
{
    public long PartNumber;
    public string PartName;
    public double UnitPrice;
}

class DoublyLinkedList
{
    private class DoublyLinkedListNode
    {
        private object element;
        private DoublyLinkedListNode next;
        private DoublyLinkedListNode previous;

        public DoublyLinkedListNode(object element)
        {
            this.element = element;
            this.next = null;
            this.previous = null;
        }

        public DoublyLinkedListNode(object element, DoublyLinkedListNode prevNode)
        {
            this.element = element;
            this.previous = prevNode;
            prevNode.next = this;
        }

        public object Element
        {
            get { return this.element; }
            set { this.element = value; }
        }

        public DoublyLinkedListNode Next
        {
            get { return this.next; }
            set { this.next = value; }
        }

        public DoublyLinkedListNode Previous
        {
            get { return this.previous; }
            set { this.previous = value; }
        }
    }

    private DoublyLinkedListNode head;
    private DoublyLinkedListNode tail;
    private int count;

    public DoublyLinkedList()
    {
        this.head = null;
        this.tail = null;
        this.count = 0;
    }

    public int Count
    {
        get { return this.count; }
    }

    public object this[int index]
    {
        get
        {
            if (index >= count || index < 0)
            {
                throw new ArgumentOutOfRangeException("Out of range!");
            }
            DoublyLinkedListNode currentNode = this.head;
            for (int i = 0; i < index; i++)
            {
                currentNode = currentNode.Next;
            }
            return currentNode.Element;
        }
        set
        {
            if (index >= count || index < 0)
            {
                throw new ArgumentOutOfRangeException("Out of range!");
            }
            DoublyLinkedListNode currentNode = this.head;
            for (int i = 0; i < index; i++)
            {
                currentNode = currentNode.Next;
            }
            currentNode.Element = value;
        }
    }
    public void Add(object item)
    {
        if (this.head == null)
        {
            this.head = new DoublyLinkedListNode(item);
            this.tail = this.head;
        }
        else
        {
            DoublyLinkedListNode newItem = new DoublyLinkedListNode(item, tail);
            this.tail = newItem;
        }
        count++;
    }

    public void Insert(object item, int index)
    {
        count++;
        if (index >= count || index < 0)
        {
            throw new ArgumentOutOfRangeException("Out of range!");
        }
        DoublyLinkedListNode newItem = new DoublyLinkedListNode(item);
        int currentIndex = 0;
        DoublyLinkedListNode currentItem = this.head;
        DoublyLinkedListNode prevItem = null;
        while (currentIndex < index)
        {
            prevItem = currentItem;
            currentItem = currentItem.Next;
            currentIndex++;
        }
        if (index == 0)
        {
            newItem.Previous = this.head.Previous;
            newItem.Next = this.head;
            this.head.Previous = newItem;
            this.head = newItem;
        }
        else if (index == count - 1)
        {
            newItem.Previous = this.tail;
            this.tail.Next = newItem;
            newItem = this.tail;
        }
        else
        {
            newItem.Next = prevItem.Next;
            prevItem.Next = newItem;
            newItem.Previous = currentItem.Previous;
            currentItem.Previous = newItem;
        }
    }
    public void Remove(object item)
    {
        int currentIndex = 0;
        DoublyLinkedListNode currentItem = this.head;
        DoublyLinkedListNode prevItem = null;
        while (currentItem != null)
        {
            if ((currentItem.Element != null &&
                currentItem.Element.Equals(item)) ||
                (currentItem.Element == null) && (item == null))
            {
                break;
            }
            prevItem = currentItem;
            currentItem = currentItem.Next;
            currentIndex++;
        }
        if (currentItem != null)
        {
            count--;
            if (count == 0)
            {
                this.head = null;
            }
            else if (prevItem == null)
            {
                this.head = currentItem.Next;
                this.head.Previous = null;
            }
            else if (currentItem == tail)
            {
                currentItem.Previous.Next = null;
                this.tail = currentItem.Previous;
            }
            else
            {
                currentItem.Previous.Next = currentItem.Next;
                currentItem.Next.Previous = currentItem.Previous;
            }
        }
    }
    public void RemoveAt(int index)
    {
        if (index >= this.count || index < 0)
        {
            throw new ArgumentOutOfRangeException("Out of range!");
        }

        int currentIndex = 0;
        DoublyLinkedListNode currentItem = this.head;
        DoublyLinkedListNode prevItem = null;
        while (currentIndex < index)
        {
            prevItem = currentItem;
            currentItem = currentItem.Next;
            currentIndex++;
        }
        if (this.count == 0)
        {
            this.head = null;
        }
        else if (prevItem == null)
        {
            this.head = currentItem.Next;
            this.head.Previous = null;
        }
        else if (index == count - 1)
        {
            prevItem.Next = currentItem.Next;
            tail = prevItem;
            currentItem = null;
        }
        else
        {
            prevItem.Next = currentItem.Next;
            currentItem.Next.Previous = prevItem;
        }
        count--;
    }
    public int indexOf(object item)
    {
        int index = 0;
        DoublyLinkedListNode currentItem = this.head;
        while (currentItem != null)
        {
            if (((currentItem.Element != null) && (item == currentItem.Element)) ||
                ((currentItem.Element == null) && (item == null)))
            {
                return index;
            }
            index++;
            currentItem = currentItem.Next;
        }
        return -1;
    }
    public bool Contains(object element)
    {
        int index = indexOf(element);
        bool contains = (index != -1);
        return contains;
    }

    public void Clear()
    {
        this.head = null;
        this.tail = null;
        this.count = 0;
    }

    public object First()
    {
        if (this.count < 0)
        {
            throw new ArgumentOutOfRangeException("Out of range!");
        }
        else
            return this.head.Element;
    }

    public object Retrieve(int Position)
    {
        DoublyLinkedListNode current = this.head;

        for (int i = 0; i < Position && current != null; i++)
            current = current.Next;
        return current;
    }
}

class Program
{
    static void Main(string[] args)
    {

        DoublyLinkedList Parts = new DoublyLinkedList();
        object element;
        CarPart Part;
        CarPart PartToFind;

        Part = new CarPart();
        Part.PartNumber = 9743;
        Part.PartName = "Air Filter";
        Part.UnitPrice = 8.75;
        Parts.Add(Part);

        Part = new CarPart();
        Part.PartNumber = 27487;
        Part.PartName = "Clutch Disk";
        Part.UnitPrice = 47.15;
        Parts.Add(Part);

        Part = new CarPart();
        Part.PartNumber = 87873;
        Part.PartName = "Brake Disk";
        Part.UnitPrice = 35.15;
        Parts.Add(Part);

        Part = new CarPart();
        Part.PartNumber = 27644;
        Part.PartName = "A/C Filter Drier";
        Part.UnitPrice = 55.55;
        Parts.Add(Part);

        Console.WriteLine(" -=- Store Inventory -=-");
        Console.WriteLine("Number of Parts: {0}", Parts.Count);

        object item = (object)Parts;

        for (int i = 0; i < Parts.Count; i++)
        {
            // CarPart part = (CarPart)Parts.Retrieve(i);
            element = Parts.Retrieve(i);

            if (element != null)
            {
                // FAILS HERE AFTER RETRIEVING THE ELEMENT
                CarPart part = (CarPart)element;

                Console.WriteLine("\nCar Part Information");
                Console.WriteLine("Part #:      {0}", part.PartNumber);
                Console.WriteLine("Description: {0}", part.PartName);
                Console.WriteLine("Unit Price:  {0:C}", part.UnitPrice);
            }
        }
    }
}

类CarPart
{
公共长零件号；
公共字符串部分名；
公开双单价；
}
类双链接列表
{
私有类DoublyLinkedListNode
{
私有对象元素；
私有双链接列表节点next；
私有双链接列表节点先前；
公共双链接列表节点（对象元素）
{
this.element=元素；
this.next=null；
this.previous=null；
}
公共DoublyLinkedListNode（对象元素，DoublyLinkedListNode prevNode）
{
this.element=元素；
this.previous=prevNode；
prevNode.next=this；
}
公共对象元素
{
获取{返回this.element；}
设置{this.element=value；}
}
公共双链接列表节点下一步
{
获取{返回this.next；}
设置{this.next=value；}
}
公共双链接列表节点上一个
{
获取{返回this.previous；}
设置{this.previous=value；}
}
}
私有双链接列表节点头；
私有双链接列表节点尾部；
私人整数计数；
公共双链接列表（）
{
this.head=null；
this.tail=null；
此值为0.count；
}
公共整数计数
{
获取{返回this.count；}
}
公共对象此[int索引]
{
得到
{
如果（索引>=计数| |索引<0）
{
抛出新ArgumentOutOfRangeException（“超出范围！”）；
}
DoublyLinkedListNode currentNode=this.head；
对于（int i=0；i=计数| |索引<0）
{
抛出新ArgumentOutOfRangeException（“超出范围！”）；
}
DoublyLinkedListNode currentNode=this.head；
对于（int i=0；i=计数| |索引<0）
{
抛出新ArgumentOutOfRangeException（“超出范围！”）；
}
DoublyLinkedListNode newItem=新的DoublyLinkedListNode（项）；
int currentIndex=0；
DoublyLinkedListNode currentItem=this.head；
DoublyLinkedListNode PreviItem=null；
while（当前索引<索引）
{
PreviItem=currentItem；
currentItem=currentItem.Next；
currentIndex++；
}
如果（索引==0）
{
newItem.Previous=this.head.Previous；
newItem.Next=this.head；
this.head.Previous=newItem；
this.head=newItem；
}
else if（索引==计数-1）
{
newItem.Previous=this.tail；
this.tail.Next=newItem；
newItem=this.tail；
}
其他的
{
newItem.Next=previitem.Next；
previitem.Next=newItem；
newItem.Previous=当前项.Previous；
currentItem.Previous=新项目；
}
}
公共作废删除（对象项）
{
int currentIndex=0；
DoublyLinkedListNode currentItem=this.head；
DoublyLinkedListNode PreviItem=null；
while（currentItem！=null）
{
如果（（currentItem.Element！=null&&
currentItem.Element.Equals（项目））||
（currentItem.Element==null）和&（item==null））
{
打破
}
PreviItem=currentItem；
currentItem=currentItem.Next；
currentIndex++；
}
如果（currentItem！=null）
{
计数--；
如果（计数=0）
{
this.head=null；
}
else if（previitem==null）
{
this.head=currentItem.Next；
this.head.Previous=null；
}
else if（currentItem==尾部）
{
currentItem.Previous.Next=null；
this.tail=currentItem.Previous；
}
其他的
{
currentItem.Previous.Next=currentItem.Next；
currentItem.Next.Previous=currentItem.Previous；
}
}
}
公共无效删除（整数索引）
{
如果（索引>=this.count | |索引<0）
{
抛出新ArgumentOutOfRangeException（“超出范围！”）；
}
int currentIndex=0；
DoublyLinkedListNode currentItem=this.head；
DoublyLinkedListNode PreviItem=null；
while（当前索引<索引）
{
PreviItem=currentItem；
currentItem=currentItem.Next；
currentIndex++；
}
如果（this.count==0）
{
this.head=null；
}
else if（previitem==null）
{
this.head=currentItem.Next；
this.head.Previous=null；
}
else if（索引==计数-1）
{
PreviItem.Next=当前项目.Next；
尾=前一项；
咖喱
return current;

return current.element;