Using derived type for recursive tree method

I have a class BinaryTree<T> that looks like this:

 class BinaryTree<T> 
        where T : IComparable
    {
        protected BinaryTree<T>? _left;
        protected BinaryTree<T>? _right;
        protected BinaryTree<T>? _root;
        protected T _value;

        public T Value
        {
            get { return _value; }
            set { _value = value; }
        }

        public BinaryTree<T>? Left
        {
            get { return _left; }
            set { _left = value; }
        }

        public BinaryTree<T>? Right
        {
            get { return _right; }
            set { _right = value; }
        }

        public BinaryTree<T>? Root
        {
            get { return _root; }
            set { _root = value; }
        }
      
        public BinaryTree() { }

        public BinaryTree(T value, BinaryTree<T>? left = null, BinaryTree<T>? right = null, BinaryTree<T>? root = null)
        { ... }
        public List<T> PreOrder()
        { ... }

        public List<T> InOrder()
        { ... }

        public List<T> PostOrder()
        { ... }
    }

And a dervied class BinarySearchTree that implements the Search method:

class BinarySearchTree : BinaryTree<int>
    {
        public BinarySearchTree() : base() { } 

        public Boolean Search(int value)
        {
            if (Value.CompareTo(value) == 0) return true;
            if ((Left is not null) && (Value.CompareTo(value) > 0)) { return Left.Search(value); }
            else if ((Right is not null) && (Value.CompareTo(value) > 0)) { return Right.Search(value); }
            else { return false; }
        }
    }

Left.Search (and analagously Right) won't work because Left isn't of type BinarySearchTree, but rather BinaryTree<int>. I know that you can solve this by overriding _left, _right, Left and Right in BinaryTree, but that seems redundant since the new code isn't doing anything functionally different. I also know that we could just move Search to BinaryTree in this case, but that isn't the point; in the case of more complicated methods that I only want to have in a derived class it seems like this kind of functionality should be available somewhere.

My initial idea was to try to set the type of _left and _right in the base class to whatever the derived class would be. It doesn't seem like that's possible though; I can get the type as string using GetType() but I can't define a property with that type.

First of all, you should probably use composition instead of inheritance, i.e. make BinaryTree<int> a field or property of BinarySearchTree. Composition tend to make code easier to use and reason about since you don't have to worry about complex inheritance hierarchies.

class BinarySearchTree 
{
    private BinaryTree<int> root;
}

You can then make your search method take a node as input parameter, commonly using an private method for recursion, and a public method that uses the root:

class BinarySearchTree 
{
    private BinaryTree<int> root;
    public Boolean Search(int value) => Search(root, value);
    private Boolean Search(BinaryTree<int> node, int value)
    {
        ...
    }
}

However, there are some things other things I would consider fixing.

Recursive techniques have some problems. If the tree is poorly balanced it can lean to stack overflows. I would recommend thinking about using a iterative technique instead. That should be fairly simple for a binary search method.

Use a IComparer<T> parameter instead of IComparable restriction, and an overload that uses Comparer<T>.Default if the user does not specifically give you one. This is a good compromise between flexibility and ease of use, and is the pattern most of the framework uses.

Use a functional approach rather than a class based approach. That tend to make the code easier to reuse, since you are not tied to a specific tree type. A signature might for example look something like this:

public static bool BinarySearch<T>(T current, T value, Func<T, (T? Left, T? Right)> selector, IComparer<T> comparer)

If you are handling large trees of primitive types, it is often more useful to describe the tree using an array. Objects have some overhead, and if you have a very large amount of ints, that overhead will dominiate. Sometimes, using arrays and indexes to that array can be a better solution when dealing with lots of data, a typical example would be something like a heap.