Наследование системы .Threading.Thread

Ответ 1

Я не думаю, что любое наследование может привести к более читаемому коду, чем это:

Thread myThread = new Thread(() =>
{
    //Do what you want...
});
myThread.Start();

Ответ 2

Относительно того, почему кто-то захочет сделать это: многие языки (например, Java) и/или API потоков (например, Qt) позволяют разработчикам внедрять потоки путем наследования из базового класса "поток", а затем перегружать метод, который реализует процедуру потока.

Используя эту модель в Qt, я нахожу ее очень удобной - вместо того, чтобы потоки нацелили какую-то функцию или метод, что часто приводит к странному и/или запутанному коду, весь поток содержится внутри объекта.

Вот пример кода с использованием Qt API:

class MyThread : public QThread
{
    Q_OBJECT

protected:
    void run();
};

void MyThread::run()
{
    ...something I need threaded...
}

QThread - это базовый класс потоковой передачи Qt. Чтобы использовать MyThread, создайте экземпляр объекта потока и вызовите QThread:: start(). Код, который появляется в выполнении выполнения(), будет выполняться в отдельном потоке.

Что-то приятное в этом, я думаю, это позволяет вам действительно содержать все, что требуется потоку внутри одного объекта, и (по моему опыту), это создает очень согласованную объектную модель. Я не думаю, что это отвечает всем требованиям, но я был немного удивлен тем, что у С# нет такой базовой модели потоковой передачи, если честно.

Я определенно не покупаю, что класс С# Thread запечатан из-за сложности ядра; если Qt может предоставить кросс-платформенную библиотеку потоков, которая позволяет наследовать QThread, я не вижу реальной причины, по которой MSFT не может предоставить такую ​​же возможность в классе потоков в С#.

Ответ 3

Нет, класс Thread sealed. Обоснованием этого решения является то, что он представляет собой такую ​​сложную и низкоуровневую оболочку вокруг объекта ядра, с которой вам не следует возиться.

Один вопрос для вас, почему вы хотите переопределить метод Start? Чего вы пытаетесь достичь?

Ответ 4

using System.Threading;

namespace NGrubb.Threading {

    public abstract class BaseThread {
        private Thread m_thread;

        public BaseThread() {
            m_thread = new Thread( Run );
        }

        public void Start() {
            m_thread.Start();
        }

        protected abstract void Run();
    }
}

Ответ 5

Не уверен, почему вы можете это сделать (или это даже должно сделать это, если это было возможно), но есть способ обойти тот факт, что класс Thread sealed - с использованием методов расширения. Более технически это просто добавляет перегрузку в группу методов Start (а не переопределяет), но это может быть полезно в вашем контексте.

Что-то вроде этого может быть то, что вы хотите:

public static void Start(this Thread thread, int foo)
{
    // Your code here.

    thread.Start();
}

Затем вы можете просто называть это следующим:

var thread = new Thread();
thread.Start(123);

Ответ 6

Класс Thread запечатан, но здесь хороший сайт для изучения тем. Кроме того, взгляните на поток Stackoverflow здесь: Ссылка на многопоточность?

Ответ 7

Нет...

Класс Thread герметизирован...

[ComVisibleAttribute(true)]
[ClassInterfaceAttribute(ClassInterfaceType.None)]
public sealed class Thread : CriticalFinalizerObject, 
    _Thread

Спасибо

Ответ 8

Нет, это закрытый класс, который означает, что вы не можете наследовать его.

Ответ 9

Я также использую одну и ту же логику в Java-приложениях, и имеет смысл связывать поток с объектом, который затем отделяет начало нового процесса от его родителя. Аналогично, очень разочарованный С# не поддерживает этот подход. Dave P