Статический метод для класса XMLLoader, как вернуть данные XML после функции Event.COMPLETE?

Вы не хотите идти по всем статическим маршрутам. Это беспорядок, усложняет вещи без необходимости, его трудно поддерживать, и что, если вы хотите загрузить два XML-файла одновременно? (подсказка: нельзя).

Вам лучше создать обычный класс, который делает то, что вы хотите (загрузить xml и отправить событие или вызвать функцию с результатами). Затем вы можете добавить более простой интерфейс для своего вызывающего кода; если это статическая функция, которая будет использоваться как однострочная, пусть будет так. Эту функцию можно рассматривать как своего рода фабрику, которая инициирует создание экземпляра класса, а также инициирует операцию загрузки, устанавливает обратный вызов результата, все за один шаг (с точки зрения вызывающей стороны).

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

package
{
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.IOErrorEvent;
    import flash.events.SecurityErrorEvent;
    import flash.net.URLLoader;
    import flash.net.URLRequest;
    import flash.utils.Dictionary;

    public class XMLLoader extends EventDispatcher
    {
        private var _loader:URLLoader;
        private var _data:XML;
        private var _callback:Function;

        private static var _map:Dictionary = new Dictionary();

        public function XMLLoader(callback:Function = null)
        {
            _data = null;
            _callback = callback;
            _loader = new URLLoader();
            _loader.addEventListener(IOErrorEvent.IO_ERROR,handleError);
            _loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR,handleError);
            _loader.addEventListener(Event.COMPLETE,handleComplete);
        }

        public function load(request:URLRequest):void {
            _loader.load(request);  
        }

        private function dispatchError():void {
            cleanUp();  
            dispatchEvent(new Event(Event.COMPLETE));
            if(_callback is Function) {
                _callback(null);
            }
        }

        private function dispatchSuccess():void {
            cleanUp();  
            dispatchEvent(new Event(Event.COMPLETE));
            if(_callback is Function) {
                _callback(_data);
            }
        }

        private function handleError(e:Event):void {
            dispatchError();
        }

        private function handleComplete(e:Event):void {
            var success:Boolean = false;
            try {
                _data = new XML(e.target.data);
                success = true;
            } catch(err:TypeError) {
                success = false;
            } finally {
                if(success) {
                    dispatchSuccess();
                } else {
                    dispatchError();
                }
            }
        }

        public function get data():XML {
            return _data;
        }

        private function cleanUp():void {
            if(_loader) {
                _loader.removeEventListener(IOErrorEvent.IO_ERROR,handleError);
                _loader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,handleError);
                _loader.removeEventListener(Event.COMPLETE,handleComplete);
            }
            if(_map[this]) {
                delete _map[this];
            }
        }

        public static function loadXml(url:String,callback:Function):XMLLoader {
            var loader:XMLLoader = new XMLLoader(callback);
            loader.load(new URLRequest(url));
            //  pin down the instance just to be safe; I've seen loaders being collected...
            _map[loader] = true;
            return loader;
        }

    }
}

Использовать:

    private function handleResult(data:XML):void {
        if(data) {
            trace(data);
        } else {
            trace("failed");
        }
    }


    private function test():void {
        XMLLoader.loadXml("your.xml",handleResult);
    }

В качестве альтернативы вы можете переключиться на использование методов экземпляра, если вам нужна большая гибкость:

    private function test():void {
        var loader:XMLLoader = new XMLLoader(handleResult);
        loader.load(new URLRequest("your.xml"));        
    }

Этот пример реализации можно использовать с обратным вызовом или событиями. Для простоты я просто определяю одну функцию обратного вызова; вы можете сказать, успешно ли прошла операция загрузки, проверив полученные данные; ноль означает, что это не удалось. Кроме того, я отправляю событие Event.COMPLETE, чтобы сообщить, что загрузчик завершил загрузку (даже если она не удалась); опять же, вы можете узнать, не удалось это или удалось, проверив свойство данных. Вы можете использовать настраиваемые события, если хотите, и/или определить обратный вызов ошибки, но я думаю, что вам нужен максимально простой интерфейс, поэтому я думаю, что этого должно быть достаточно.

Вы слишком многого требуете от системы, вспышка для этого не предназначена. Нельзя (и не нужно) вешать всю систему только для того, чтобы дождаться одного результата. Написание на flex/flash требует использования обработчиков завершения, потому что в некоторых случаях, таких как этот, просто невозможно обойти это. Если бы вы делали что-то таким образом, кадры никогда не перемещались бы вперед, и все в программе останавливалось бы до тех пор, пока вещь не возвращалась бы, создавая очень недовольный пользовательский опыт, который ощущался бы как «зависание» или «сбой».

С технической стороны, если бы вы абсолютно решительно настаивали на этом, то вам пришлось бы (1) найти способ добавить задержку в этот цикл if-null и (2) изменить его на while( _data != null ){ /* wait a while */ }, но я действительно не рекомендую идти по этому пути. В частности, вам нужно быть осторожным при вызове функции внутри себя. В вашем случае _waitForData просит _waitForData попросить _waitForData попросить _waitForData попросить... и т. д., пока не достигнет произвольного предела и не остановится. Это называется бесконечная рекурсия.

Решение. Вам нужно структурировать свою программу так, чтобы она прекращала делать то, что делала, когда ей нужно что-то загрузить, и продолжала делать то, что нужно, когда вызывается обработчик завершения.

Обновлять:

Решение 2. Напишите класс, который обрабатывает всю необходимую загрузку XML. Вы можете предварительно заполнить данные в начале программы, если знаете, что может быть запрошено. Затем, когда вам понадобится больше, попросите класс добавить еще. Затем, если он уже загружен, он может просто вернуть его немедленно. Если его нет, он вернет null, извлечет его в фоновом режиме и вызовет обработчик, когда это будет сделано. Таким образом, код, вызывающий его, может, по крайней мере, немедленно попытаться сделать что-то с XML, но, в конце концов, ему всегда придется обрабатывать случай, когда он не загружен.