c # запутался в наследовании базового класса

Question

Я не совсем понимаю, как именно классы наследуют методы друг от друга.Я уже понимаю наследование от базовых классов, но есть определенный код из примера, который я не понимаю.Он включает в себя поиск в двоичном дереве, и я не смог найти ресурсов, которые бы лучше объясняли, как наследуется код.

Моя цель - понять его, чтобы я мог использовать его для поиска в связанном списке.

Если кто-нибудь может отослать меня к какой-либо соответствующей литературе, которая объясняет эту конкретную область, я был бы признателен.

Я выделил раздел кода, который я до сих пор не понимаю, как он наследуется.Вначале публикуется определенный раздел:

public Company Read(string bezeichnung)
{
    return stri.Search(new Company() { Bezeichnung = bezeichnung });
}

Вся программа:

using System;
using System.IO;
using System.Text;
using System.Net;

namespace CompanySearch
{
    class Program
    {
        static void Main(string[] args)
        {
            StreamReader r = new StreamReader(@"C:\Users\chris\Desktop\algo\fuckit\unternehmen.csv", Encoding.Default);
            Companies stri2 = new Companies(r);
            while (true)
            {
                Console.Write("Unternehmensbezeichnung eingeben: ");
                string name = Console.ReadLine();
                if (string.IsNullOrEmpty(name))
                    break;
                //Company konk = stri2.Read(name);
                Company konk = new Company();
                konk = stri2.Read(name);
                if (konk == null)
                    Console.WriteLine("Unternehmen nicht gefunden!");
                else
                    Console.WriteLine(konk + "\n");
            }
        }
    }

    public class Companies
    {
        private BinaryTree<Company> stri = new BinaryTree<Company>();
        public Companies(StreamReader rp)
        {
            // Spaltenüberschriften auslesen
            //var tokens = rp.ReadLine().Split(new char[] { ';' });
            //if (tokens.Length != 3)
            //    throw new ArgumentException("More than 3 columns in company file");
            string line;
            while ((line = rp.ReadLine()) != null)
            {
                var tokens = line.Split(new char[]{';'});
                //tokens = line.Split(new char[] { ';' });
                stri.Add(new Company()
                {Bezeichnung = tokens[0], Branche = tokens[1], Ort = tokens[2]});
            }

            rp.Close();
        }

        public Company Read(string bezeichnung)
        {
            return stri.Search(new Company()
            {Bezeichnung = bezeichnung});
        }
    }

    public class Company : IComparable<Company>
    {
        public string Bezeichnung
        {
            get;
            set;
        }

        public string Branche
        {
            get;
            set;
        }

        public string Ort
        {
            get;
            set;
        }

        public int CompareTo(Company other)
        {
            return Bezeichnung.CompareTo(other.Bezeichnung);
        }

        public override string ToString()
        {
            return string.Format("Bezeichnung: {0}\tBranche: {1}\tOrt: {2}", Bezeichnung, Branche, Ort);
        }
    }

    public enum TraverseModeEnum
    {
        PreOrder,
        PostOrder,
        InOrder,
        ReverseInOrder
    }

    public class BinaryTree<T>
        where T : IComparable<T>
    {
        private sealed class Node<TNode>
            where TNode : IComparable<TNode> // TNode muss IComparable implementieren
        {
            public TNode Item
            {
                get;
                set;
            }

            public Node<TNode> Left
            {
                get;
                set;
            }

            public Node<TNode> Right
            {
                get;
                set;
            }

            public int CompareTo(TNode other)
            {
                return Item.CompareTo(other);
            }
        }

        private Node<T> root;
        public int Count
        {
            get;
            private set;
        }

        public TraverseModeEnum TraverseMode
        {
            get;
            set;
        }

        public BinaryTree()
        {
            TraverseMode = TraverseModeEnum.PreOrder;
        }

        public void Add(T item)
        {
            if (root == null)
                root = new Node<T>()
                {Item = item};
            else
                addTo(root, item);
            Count++;
        }

        public void AddRange(T[] items)
        {
            foreach (var item in items)
                Add(item);
        }

        private void addTo(Node<T> node, T item)
        {
            if (item.CompareTo(node.Item) < 0)
            {
                if (node.Left == null)
                    node.Left = new Node<T>()
                    {Item = item};
                else
                    addTo(node.Left, item);
            }
            else
            {
                if (node.Right == null)
                    node.Right = new Node<T>()
                    {Item = item};
                else
                    addTo(node.Right, item);
            }
        }

        public bool Contains(T item)
        {
            Node<T> node = root;
            while (node != null)
            {
                int c = node.Item.CompareTo(item);
                if (c == 0)
                    return true;
                if (c > 0)
                    node = node.Left;
                else
                    node = node.Right;
            }

            return false;
        }

        public T Search(T item)
        {
            Node<T> node = root;
            while (node != null)
            {
                int c = node.Item.CompareTo(item);
                if (c == 0)
                    return node.Item;
                if (c > 0)
                    node = node.Left;
                else
                    node = node.Right;
            }

            return default (T);
        }

        public void Clear()
        {
            root = null;
            Count = 0;
        }

        public override string ToString()
        {
            string s = "";
            int level = 0;
            traverse(root, level, ref s);
            return s;
        }

        private void traverse(Node<T> node, int level, ref string s)
        {
            if (node == null)
                return;
            bool reverse = TraverseMode == TraverseModeEnum.ReverseInOrder;
            if (TraverseMode == TraverseModeEnum.PreOrder)
                s += "".PadLeft(level, ' ') + node.Item.ToString() + "\n";
            traverse(reverse ? node.Right : node.Left, level + 2, ref s);
            if (TraverseMode == TraverseModeEnum.InOrder || TraverseMode == TraverseModeEnum.ReverseInOrder)
                s += "".PadLeft(level, ' ') + node.Item.ToString() + "\n";
            traverse(reverse ? node.Left : node.Right, level + 2, ref s);
            if (TraverseMode == TraverseModeEnum.PostOrder)
                s += "".PadLeft(level, ' ') + node.Item.ToString() + "\n";
        }
    }
}

Answer 1

Класс BinaryTree<T>, указанный в коде, требует, чтобы T должен реализовывать IComparable<T>.Многие классы со списком элементов предъявляют аналогичные требования.Если тип реализует IComparable<T>, это означает, что два экземпляра класса можно сравнивать друг с другом с помощью метода ComparetTo( T t1, T t2 ).Этот метод возвращает указание того, что T больше , меньше или равно другого.Поймите, что больше, меньше или равно полностью зависит от типа, который реализует интерфейс.Он в основном используется для сортировки или иного размещения объектов в дереве, списке или другой структуре на основе сравнения.

Реализация интерфейса выглядит как наследование классов.Синтаксис тот же ... но это больше похоже на контракт, поскольку у интерфейса нет кода для наследования.Если вы создаете класс, который выглядит следующим образом:

class MyClass: IComparable<MyClass>
{
  //--> stuff
}

... тогда вы обязаны иметь публично видимый метод с подписью:

int CompareTo( MyClass a, MyClass b )
{
   //--> look at the two instances and make a determination...
}

Метод может использовать любойхарактеристики класса, чтобы определить, что делает a больше, меньше или равно b ... и, таким образом, контролировать, как оно будет размещено в структуре.

Класс может наследовать только от одного другого класса ... но он может реализовывать столько интерфейсов, сколько ему нужно.Это то, что, я думаю, выглядит как множественное наследование.

Answer 2

а.В вашем коде нет реального наследования.Только реализация стандартного интерфейса IComparable<T>.Реализация интерфейса иногда называется наследованием, но это не одно и то же.В этом случае это заставляет Company реализовать метод CompareTo().

б.Код, о котором у вас есть вопрос, просто создает временный объект.Вы можете переписать его так, чтобы его было легче понять:

//return stri.Search(new Company() { Bezeichnung = bezeichnung });
var tempCompany = new Company() { Bezeichnung = bezeichnung };
return stri.Search(tempCompany);