Форум программистов [Powered by Invision Power Board]

Код


    public class Model 
    {
        public string ModelName { get; set; }

        public Model Clone()
        {
            // корректная реализация клонирования
            return new Model();
        }
    }

    /// <summary>
    /// Делегат описывающий событие завершения загрузки
    /// </summary>
    /// <param name="model"></param>
    public delegate void LoadCompleteCallback(Model model);

    
    /// <summary>
    /// Класс, описывающий одну загрузку
    /// </summary>
    class LoadTask
    {
        /// <summary>
        /// Ссылка на загруженную модель
        /// </summary>
        public Model Model { get; set; }
        /// <summary>
        /// Путь к файлу модели
        /// </summary>
        public string FileName { get; set; }
        /// <summary>
        /// Ссылка на метод, который вызывается по окончании загрузки модели
        /// </summary>
        public LoadCompleteCallback CompleteCallback { get; set; }
    }

    /// <summary>
    /// Асинхронный загрузчик моделей
    /// </summary>
    public class AsyncLoader
    {
        Thread _thread;
        Queue<LoadTask> _queue = new Queue<LoadTask>();

        /// <summary>
        /// Protected конструктор, т.к. класс является Singleton
        /// </summary>
        protected AsyncLoader()
        {
            _thread = new Thread(_ThreadMethod);
            _thread.IsBackground = true;
            _thread.Start();
        }

        static AsyncLoader _inst = null;
        /// <summary>
        /// Ссылка на единственный инстанс
        /// </summary>
        public static AsyncLoader Instance
        {
            get
            {
                if (_inst == null)
                    _inst = new AsyncLoader();

                return _inst;
            }
        }

        Model _loadingPleaseWait;

        Model _GetLoadingPleaseWaitModel(string modelName)
        {
            if (_loadingPleaseWait == null)
                _loadingPleaseWait = new Model();

            Model newModel = _loadingPleaseWait.Clone();
            newModel.ModelName = "Loading Model " + modelName;

            return newModel;
        }

        /// <summary>
        /// Асинхронно загружает модель
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="callback"></param>
        /// <returns></returns>
        public Model BeginLoad(string fileName, LoadCompleteCallback callback)
        {
            lock (_queue) 
                // блокируем доступ к _queue, чтобы избежать одновременного доступа 
                // к нему из разных потоков
            {
                // добавляем в очередь новый таск на загрузку модели
                _queue.Enqueue(new LoadTask() { FileName = fileName, CompleteCallback = callback });
            }

            // возвращаем заглушку "please wait"
            return _GetLoadingPleaseWaitModel(fileName);
        }

        Model _DoLoad(string fileName)
        {
            // тут выполняется код по загрузке модели
            Model model = new Model() { ModelName = fileName };

            return model;
        }

        /// <summary>
        /// Метод, работающий в отдельном потоке и обрабатывающий очередь загрузки моделей
        /// </summary>
        void _ThreadMethod()
        {
            while (true)
            {
                if (_queue.Count > 0)
                {
                    LoadTask task = null;
                    
                    lock (_queue)
                        // блокируем доступ к _queue, чтобы избежать одновременного доступа 
                        // к нему из разных потоков
                        // т.к. этот код выполняется в параллельном потоке, может произойти одновременное
                        // добавление к очереди из метода BeginLoad
                    {
                        task = _queue.Dequeue();
                    }

                    // вызываем собственно код загрузки модели
                    task.Model = _DoLoad(task.FileName);

                    // вызываем коллбэк, чтобы уведобить основной поток о завершении 
                    // загрузки
                    if (task.CompleteCallback != null)
                        task.CompleteCallback(task.Model);
                }
                else
                    // это коряво очень, но для примера подойдет.
                    // если нет задач на загрузку, говорим потоку "Спать", чтобы не загружать
                    // процессор пустой работой.
                    // правильный вариант -- использовать ManualResetEvent для сигнализции потоку
                    // о появлении нового файла на загрузку
                    Thread.Sleep(300); 
            }
        }
    }

Код


    static class Program
    {
        static void Main()
        {
            Dictionary<string, Model> loadedModels = new Dictionary<string, Model>();

            // для простоты примера используем анонимный метод
            LoadCompleteCallback callback = new LoadCompleteCallback(delegate(Model model)
                {
                    Console.WriteLine("Модель " + model.ModelName + " загружена");
                    lock (loadedModels)
                    {
                        // заменяем заглушку модели на ее загруженную копию
                        loadedModels[model.ModelName] = model;
                    }
                });

            for (int i = 0; i < 100; i++)
            {
                string modelName = "model" + i.ToString() + ".mdl";
                
                lock (loadedModels)
                {
                    // кладем в словарь модель-заглушку
                    // она будет заменена, когда вызовется callback-метод
                    loadedModels.Add(modelName, AsyncLoader.Instance.BeginLoad(modelName, callback));
                }
            }

            Console.ReadLine();
        }
    }