Создание пользовательского клиента сценария с помощью библиотеки Microsoft AJAX

Статья
10/22/2014

Обновлен: Ноябрь 2007

Возможности AJAX в ASP.NET позволяют создать клиентский сценарий и интегрировать в приложения ASP.NET. Это включает систему типов для ECMAScript (JavaScript) и расширяет существующие объекты ECMAScript (JavaScript) для придания им всего богатства классов .NET Framework. ASP.NET также включает элемент управления ScriptManager для управления этими библиотеками сценариев и любых сценариев в приложении.

В этом разделе содержатся следующие подразделы:

Сценарии
Использование системы типов.
Использование расширения для базовых типов JavaScript.
Интеграция клиентского сценария в веб-приложения ASP.NET.

Сценарии

Чтобы использовать возможности Microsoft AJAX (библиотека), выполните следующее:

Добавьте объектно ориентированные возможности в код JavaScript, чтобы увеличить повторное использование кода, сопровождаемость и гибкость.
Используйте отражение для проверки структуры и компонентов клиентского сценария во время выполнения.
Используйте перечисления для предоставления читабельной альтернативы представления целых чисел.
Используйте расширения к базовым типам JavaScript, чтобы сократить время разработки для задач типичных сценариев.
Используйте расширения отладки и функции трассировки для быстрой и более информативной отладки, чем с традиционными методами отладки JavaScript.

Использование системы типов

Microsoft AJAX (библиотека) добавляет систему типов и расширения для объектов JavaScript, чтобы реализовать часто используемые объектно-ориентированные функции, аналогичные средствам платформы .NET Framework. Они позволяют составлять приложения ASP.NET с поддержкой AJAX структурированным способом, что упрощает последующую поддержку приложений, добавление новых функций и обеспечение многоуровневой функциональности. Расширения Microsoft AJAX (библиотека) добавляют следующие возможности в JavaScript.

Классы.
Пространства имен.
Наследование.
Интерфейсы.
Перечисления.
Отражение.

Библиотека также предоставляет вспомогательные функции для строк и массивов.

Классы, члены и пространства имен

Microsoft AJAX (библиотека) включает базовые классы, объекты и компоненты, производные от них. Вместе эти классы позволяют использовать модель объектно ориентированного программирования для написания клиентского сценария.

Класс Тип добавляет такие объектно ориентированные возможности, как пространство имен, классы и наследование при программировании на JavaScript. Любой объект JavaScript, зарегистрированный с помощью класса Type, автоматически имеет доступ к этой функции. В следующем примере показано использование класса Type для создания и регистрации пространства имен и классов в файле javascript:

Type.registerNamespace("Demo");

Demo.Person = function(firstName, lastName, emailAddress) {
    this._firstName = firstName;
    this._lastName = lastName;
    this._emailAddress = emailAddress;
}

Demo.Person.prototype = {

    getFirstName: function() {
        return this._firstName;
    },

    getLastName: function() {
        return this._lastName;
    },

    getName: function() {
        return this._firstName + ' ' + this._lastName;
    },

    dispose: function() {
        alert('bye ' + this.getName());
    }
}
Demo.Person.registerClass('Demo.Person', null, Sys.IDisposable);

// Notify ScriptManager that this is the end of the script.
if (typeof(Sys) !== 'undefined') Sys.Application.notifyScriptLoaded();

Классы могут содержать 4 типа членов: поля, свойства, методы и события. Поля и свойства являются парами "имя/значение", описывающими характеристики экземпляра класса. Поля состоят из простых типов, и доступ осуществляется напрямую, как в следующем примере:

myClassInstance.name="Fred"

Свойства могут представлять любой примитив или ссылочный тип. Можно получать доступ к значениям свойств с помощью методов get и set. В Microsoft AJAX (библиотека) методы доступа get и set являются функциями, которые в соответствии с соглашением используют префикс "get_" или "Set_" в имени функции. Например, чтобы получить или задать значение для свойства, например cancel, следует вызвать метод get_cancel или set_cancel соответственно.

Microsoft AJAX (библиотека) инициирует события в ответ на действия, происходящие во время жизненного цикла AJAX клиентского приложения. Microsoft AJAX (библиотека) также обеспечивает стандартный способ для создания пользовательских событий для клиентских компонентов AJAX. Дополнительные сведения см. в разделах Создание пользовательских клиентских событий и События жизненного цикла клиента AJAX.

Microsoft AJAX (библиотека) обеспечивает способ регистрации пространств имен, позволяя группировать их по общим функциональным возможностям. В следующем примере демонстрируется добавление класса Personк пространству имен Demo с помощью методов Type.registerNamespace и .registerClass.

Чтобы включить функциональные возможности AJAX для веб-страницы ASP.NET, необходимо добавить на страницу элемент управления ScriptManager. При отображении страницы соответствующий сценарий ссылки на библиотеки клиентских сценариев AJAX создается автоматически. В следующем примере показана страница с элементом управления ScriptManager.

<asp:ScriptManager runat="server" ID="scriptManager" />

В следующем примере демонстрируется регистрация пространства имен, создание класса и затем регистрация класса.

Type.registerNamespace("Demo");

Demo.Person = function(firstName, lastName, emailAddress) {
    this._firstName = firstName;
    this._lastName = lastName;
    this._emailAddress = emailAddress;
}

Demo.Person.prototype = {

    getFirstName: function() {
        return this._firstName;
    },

    getLastName: function() {
        return this._lastName;
    },

    getName: function() {
        return this._firstName + ' ' + this._lastName;
    },

    dispose: function() {
        alert('bye ' + this.getName());
    }
}
Demo.Person.registerClass('Demo.Person', null, Sys.IDisposable);

// Notify ScriptManager that this is the end of the script.
if (typeof(Sys) !== 'undefined') Sys.Application.notifyScriptLoaded();

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Namespace</title>
</head>

<body>
    <form id="Main" runat="server">
        <asp:ScriptManager runat="server" ID="scriptManager" />
    </form>

    <div>
        <p>This example creates an instance of the Person class 
            and puts it in the "Demo" namespace.</p>

        <input id="Button1" value="Create Demo.Person" 
            type="button" onclick="return OnButton1Click()" />

    </div>

    <script type="text/javascript" src="Namespace.js"></script>
    <script type="text/javascript" language="JavaScript">

    function OnButton1Click() 
    {
        var testPerson = new Demo.Person(  
            'John', 'Smith', 'john.smith@example.com');
        alert(testPerson.getFirstName() + " " +    
            testPerson.getLastName() );

        return false;
    }
    </script>
</body>
</html>

Модификаторы доступа

Большинство объектно ориентированных языков программирования включают концепцию модификаторов доступа, которая позволяет указать, в каком контексте класс или член доступен, например, извне программы, из внутренних классов в одном и том же пространстве имен, или только внутри блока конкретных кодов. Отсутствуют модификаторы доступа в сценарии JavaScript. Однако Microsoft AJAX (библиотека) соответствует соглашению, что члены с именами, которые начинаются со знака подчеркивания ("_"), рассматриваются как частные и не доступны вне класса, они являются его частью.

Наследование

Наследование является способностью извлечения одного класса из другого класса. Производный класс автоматически наследует все поля, свойства, методы и события из базового класса. Производный класс может добавлять новые члены или переопределять существующие члены базового класса для изменения их функциональности.

В следующем примере содержится два класса, определенных в скрипте: Person и Employee, где Employee производный от Person. Оба класса иллюстрируют использование частного поля, и оба имеют открытые свойства и методы. Кроме того, Employee переопределяет реализацию toString класса Person и использует функциональность базового класса.

Type.registerNamespace("Demo");

Demo.Person = function(firstName, lastName, emailAddress) {
    this._firstName = firstName;
    this._lastName = lastName;
    this._emailAddress = emailAddress;
}

Demo.Person.prototype = {
    getFirstName: function() {
        return this._firstName;
    },

    getLastName: function() {
        return this._lastName;
    },

    getEmailAddress: function() {
        return this._emailAddress;
    },
    setEmailAddress: function(emailAddress) {
        this._emailAddress = emailAddress;
    },

    getName: function() {
        return this._firstName + ' ' + this._lastName;
    },

    dispose: function() {
        alert('bye ' + this.getName());
    },

    sendMail: function() {
        var emailAddress = this.getEmailAddress();

        if (emailAddress.indexOf('@') < 0) {
            emailAddress = emailAddress + '@example.com';
        }
        alert('Sending mail to ' + emailAddress + ' ...');
    },

    toString: function() {
        return this.getName() + ' (' + this.getEmailAddress() + ')';
    }
}

Demo.Person.registerClass('Demo.Person', null, Sys.IDisposable);
Demo.Employee = function(firstName, lastName, emailAddress, team, title) {
    Demo.Employee.initializeBase(this, [firstName, lastName, emailAddress]);

    this._team = team;
    this._title = title;
}

Demo.Employee.prototype = {

    getTeam: function() {
        return this._team;
    },
    setTeam: function(team) {
        this._team = team;
    },

    getTitle: function() {
        return this._title;
    },
    setTitle: function(title) {
        this._title = title;
    },
    toString: function() {
        return Demo.Employee.callBaseMethod(this, 'toString') + '\r\n' + this.getTitle() + '\r\n' + this.getTeam();
    }
}
Demo.Employee.registerClass('Demo.Employee', Demo.Person);

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Inheritance</title>
</head>

<body>
    <form id="Main" runat="server">
        <asp:ScriptManager runat="server" ID="scriptManager" />
    <script type="text/javascript" src="Inheritance.js"></script>
    </form>

    <h2>Inheritance</h2>
    <p />

    <div>
        This file contains two classes defined in script: Person and Employee, where
        Employee derives from Person.
        <p />

        Each class has private fields, and public properties and methods. In addition,
        Employee overrides the toString implementation, and in doing so, it uses the
        base class functionality.
        <p />

        This example puts the Person class in the "Demo" namespace.
        <p />
    </div>


    <div>
        <ul>
            <li><a href="#" onclick="return OnTestNewClick()">Object Creation</a></li>
            <li><a href="#" onclick="return OnTestDisposeClick()">Object Dispose</a></li>
            <li><a href="#" onclick="return OnTestPrivatePropertyClick()">Public vs. Private Properties</a></li>
            <li><a href="#" onclick="return OnTestInstanceMethodClick()">Instance Methods</a></li>
            <li><a href="#" onclick="return OnTestOverrideMethodClick()">Overriden Methods</a></li>
            <li><a href="#" onclick="return OnTestInstanceOfClick()">Instance Of Check</a></li>
        </ul>
    </div>

    <script type="text/javascript" language="JavaScript">

    function GetTestPerson() 
    {
        return new Demo.Person('Jane', 'Doe', 'jane.doe@example.com');
    }

    function GetTestEmployee() 
    {
        return new Demo.Employee('John', 'Doe', 'john.doe@example.com', 'Platform', 'Programmer');
    }

    function OnTestNewClick() {
        var aPerson = GetTestPerson();

        alert(aPerson.getFirstName());
        alert(aPerson);
        alert(Object.getType(aPerson).getName());

        var testPerson = GetTestPerson();
        alert(testPerson.getFirstName());
        alert(testPerson);

        return false;
    }

    function OnTestDisposeClick() {
        var aPerson = GetTestEmployee();
        alert(aPerson.getFirstName());
        aPerson.dispose();
    }

    function OnTestPrivatePropertyClick() {
        var aPerson = GetTestEmployee();
        alert('aPerson._firstName = ' + aPerson._firstName);
        alert('aPersona.getFirstName() = ' + aPerson.getFirstName());

        return false;
    }

    function OnTestInstanceMethodClick() {
        var aPerson = GetTestEmployee();
        aPerson.sendMail('Hello', 'This is a test mail.');

        return false;
    }

    function OnTestOverrideMethodClick() {
        var testPerson = GetTestEmployee();
        alert(testPerson);

        return false;
    }

    function OnTestInstanceOfClick() {
        var aPerson = GetTestEmployee();
        if (Demo.Employee.isInstanceOfType(aPerson)) {
            alert(aPerson.getName() + ' is an Employee instance.\r\nTitle property: ' + aPerson.getTitle());
        }

        return false;
    }

    </script>
</body>
</html>

Интерфейсы

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

В следующем примере определяется базовый класс Tree и интерфейс IFruitTree. Apple и Banana, два производных класса, реализуют интерфейс IFruitTree, но не класс Pine. Любой класс, реализующий интерфейс IFruitTree, гарантирует, что метод bearFruit является членом этого класса.

Type.registerNamespace("Demo.Trees");

Demo.Trees.IFruitTree = function() {}
Demo.Trees.IFruitTree.Prototype = {
    bearFruit: function(){}
}
Demo.Trees.IFruitTree.registerInterface('Demo.Trees.IFruitTree');


Demo.Trees.Tree = function(name) {
    this._name = name;
}
Demo.Trees.Tree.prototype = {
    returnName: function() {
        return this._name;
    },

    toStringCustom: function() {
        return this.returnName();
    },

    makeLeaves: function() {}
}
Demo.Trees.Tree.registerClass('Demo.Trees.Tree');


Demo.Trees.FruitTree = function(name, description) {
    Demo.Trees.FruitTree.initializeBase(this, [name]);
    this._description = description;
}
Demo.Trees.FruitTree.prototype.bearFruit = function() {
        return this._description;
}
Demo.Trees.FruitTree.registerClass('Demo.Trees.FruitTree', Demo.Trees.Tree, Demo.Trees.IFruitTree);

Demo.Trees.Apple = function() {
    Demo.Trees.Apple.initializeBase(this, ['Apple', 'red and crunchy']);
}
Demo.Trees.Apple.prototype = {
    makeLeaves: function() {
        alert('Medium-sized and desiduous');
    },
    toStringCustom: function() {
        return 'FruitTree ' + Demo.Trees.Apple.callBaseMethod(this, 'toStringCustom');
    }
}
Demo.Trees.Apple.registerClass('Demo.Trees.Apple', Demo.Trees.FruitTree);

Demo.Trees.GreenApple = function() {
    Demo.Trees.GreenApple.initializeBase(this);
    // You must set the _description feild after initializeBase
    // or you will get the base value.
    this._description = 'green and sour';
}
Demo.Trees.GreenApple.prototype.toStringCustom = function() {
    return Demo.Trees.GreenApple.callBaseMethod(this, 'toStringCustom') + ' ... its GreenApple!';
}
Demo.Trees.GreenApple.registerClass('Demo.Trees.GreenApple', Demo.Trees.Apple);


Demo.Trees.Banana = function(description) {
    Demo.Trees.Banana.initializeBase(this, ['Banana', 'yellow and squishy']);
}
Demo.Trees.Banana.prototype.makeLeaves = function() {
    alert('Big and green');
}
Demo.Trees.Banana.registerClass('Demo.Trees.Banana', Demo.Trees.FruitTree);



Demo.Trees.Pine = function() {
    Demo.Trees.Pine.initializeBase(this, ['Pine']);
}
Demo.Trees.Pine.prototype.makeLeaves = function() {
    alert('Needles in clusters');
}
Demo.Trees.Pine.registerClass('Demo.Trees.Pine', Demo.Trees.Tree);

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Interface</title>
</head>

<body>
    <form id="Main" runat="server">
        <asp:ScriptManager runat="server" ID="scriptManager" />
    </form>

    <h2>Interface</h2>
    <p />

    <div>
        This file contains a Tree base class, and an IFruitTree interface.
        Apple and Banana, two derived classes implement that interface, whereas,
        Pine does not implement that interface.
        <p />
    </div>

    <script type="text/javascript" src="Interface.js"></script>

    <div>
        <ul>
                <li><a href="#" onclick="return OnTestNewClick()">Object Creation</a></li>
                <li><a href="#" onclick="return OnTestImplementsClick()">Implements Check</a></li>
                <li><a href="#" onclick="return OnTestInterfaceMethodClick()">Call interface method</a></li>
        </ul>
    </div>

    <script type="text/javascript" language="JavaScript">

    function OnTestNewClick() {
        var apple = new Demo.Trees.Apple('Apple');
        alert(apple.returnName());
        apple.makeLeaves();

        return false;
    }

    function OnTestImplementsClick() {
        var apple = new Demo.Trees.Apple();
        if (Demo.Trees.IFruitTree.isImplementedBy(apple)) {
            alert('Apple implements IFruitTree');
        }
        else {
            alert('Apple does not implement IFruitTree');
        }

        var pine = new Demo.Trees.Pine();
        if (Demo.Trees.IFruitTree.isImplementedBy(pine)) {
            alert('Pine implements IFruitTree');
        }
        else {
            alert('Pine does not implement IFruitTree');
        }

        return false;
    }

    function OnTestInterfaceMethodClick() {
        var apple = new Demo.Trees.Apple();
        ProcessTree(apple);

        var pine = new Demo.Trees.Pine();
        ProcessTree(pine);

        var banana = new Demo.Trees.Banana();
        ProcessTree(banana);

        var g = new Demo.Trees.GreenApple();
        ProcessTree(g);

        return false;
    }

    function ProcessTree(tree) {
        alert('Current Tree ' + tree.returnName());
        alert(tree.toStringCustom());
        if (Demo.Trees.IFruitTree.isImplementedBy(tree)) {
            alert(tree.returnName() + ' implements IFruitTree; Fruit is ' + tree.bearFruit());
        }
    }
    </script>
</body>
</html>

Перечисления

Перечисление представляет собой класс, содержащий набор именованных целочисленных констант. Доступ к значениям осуществляется, как и к свойствам, это показано в следующем примере:

myObject.color = myColorEnum.red

Перечисления представляют читабельную альтернативу представления целых чисел. Дополнительные сведения о перечислении в Microsoft AJAX (библиотека) см. в разделе Метод Type.registerEnum (ASP.NET AJAX).

В следующем примере определяется перечисление именованных цветов, представляющих шестнадцатеричные значения:

Type.registerNamespace("Demo");

// Define an enumeration type and register it.
Demo.Color = function(){};
Demo.Color.prototype = 
{
    Red:    0xFF0000,
    Blue:   0x0000FF,
    Green:  0x00FF00,
    White:  0xFFFFFF 
}
Demo.Color.registerEnum("Demo.Color");

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Enumeration</title>
</head>

<body>
    <form id="Main" runat="server">
        <asp:ScriptManager runat="server" ID="scriptManager" />
    </form>

    <div>
        <p>This example creates an Enumeration of colors
            and applies them to page background.</p>

        <select id="ColorPicker" 
            onchange="ChangeColor(options[selectedIndex].value)">
            <option value="Red" label="Red" />
            <option value="Blue" label="Blue" />
            <option value="Green" label="Green" />
            <option value="White" label="White" />
        </select>

    </div>

    <script type="text/javascript" src="Enumeration.js"></script>
    <script type="text/javascript" language="JavaScript">

    function ChangeColor(value) 
    {
         document.body.bgColor = eval("Demo.Color." + value + ";");
    }

    </script>

</body>
</html>

Отражение

Отражение является возможностью для проверки структуры и компонентов программы во время выполнения. API-интерфейсы, которые реализуют отражение, являются расширением класса Type. Эти методы позволяют собирать сведения об объекте, например что он и откуда наследует, реализует ли он определенный интерфейс, и является ли он экземпляром определенного класса.

В следующем примере отражение API-интерфейсы для проверки GreenApple класса из предыдущего примера интерфейса:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Reflection</title>
</head>

<body>
    <form id="Main" runat="server">
        <asp:ScriptManager runat="server" ID="scriptManager" />
    </form>

    <div>
        <p>This example tests the Demo.Trees.GreenApple class 
            against various reflection APIs.</p>

        <input id="Button1" value="Check Type" 
            type="button" onclick="return OnButton1Click()" />
        <input id="Button2" value="Check Inheritance" 
            type="button" onclick="return OnButton2Click()" />
        <input id="Button3" value="Check Interface" 
            type="button" onclick="return OnButton3Click()" />

    </div>

    <script type="text/javascript" src="Interface.js"></script>
    <script type="text/javascript" language="JavaScript">

    var g = new Demo.Trees.GreenApple();
    var gt = Demo.Trees.GreenApple;
    var a = new Array(
        Demo.Trees.Apple, 
        Demo.Trees.Tree, 
        Demo.Trees.Pine,
        Demo.Trees.IFruitTree,
        Sys.IContainer);

    function OnButton1Click() 
    {
        for (var i = 0; i < a.length; i ++)
        {
            if (a[i].isInstanceOfType(g))
            {
                alert(gt.getName() + " is a " + a[i].getName() + ".");
            }
            else alert(gt.getName() + " is not a " + a[i].getName() + ".");
        }
    }

    function OnButton2Click() 
    {
        for (var i = 0; i < a.length; i ++)
        {
            if (gt.inheritsFrom(a[i]))
            {
                alert(gt.getName() + " inherits from " + a[i].getName() + ".");
            }
            else alert(gt.getName() + " does not inherit from " + a[i].getName() + ".");
        }
    }

    function OnButton3Click() 
    {
        for (var i = 0; i < a.length; i ++)
        {
            if (Type.isInterface(a[i]))
            {
                if (gt.implementsInterface(a[i]))
                {
                    alert(gt.getName() + " implements the " + a[i].getName() + " interface.");
                }
                else alert(gt.getName() + " does not implement the " + a[i].getName() + " interface.");
            }
            else alert(a[i].getName() + " is not an interface.");
        }
    }
    </script>
</body>
</html>

Использование расширения для базовых типов JavaScript

Расширения базовых типов JavaScript обеспечивают дополнительные функциональные возможности для этих типов. Для получения дополнительных сведений об этих расширениях см. следующие разделы.

Класс Sys.Debug предоставляет расширенные возможности отладки. Дополнительные сведения содержатся в разделе Общие сведения об отладке и трассировке приложений AJAX и в общих сведениях о классе Sys.Debug.

При создании компонентов на основе Microsoft AJAX (библиотека) можно осуществлять отладку и выпускать версии файлов сценариев, которые автоматически управляются с помощью элемента управления ScriptManager. Можно определить отладочную версию файлов сценариев, включив ".debug" как часть имени файла сценария. Например, следующие имена файлов сценариев идентифицируют розницы и отладки версии файла:

MyScript.js (розница).
MyScript.Debug.js (отладка).

Интеграция клиентского сценария в веб-приложения ASP.NET

Любая веб-страница ASP.NET может получить доступ к файлу сценария, обратившись к его в блоку <script>, как в следующем примере:

<script type="text/javascript" src="MyScript.js"></script>

Тем не менее сценарий, вызванный таким образом, не может участвовать в отрисовке частичных страниц или получить доступ к некоторым компонентам Microsoft AJAX (библиотека). Чтобы создать сценарий файлов, доступных для отрисовки частичных страниц в приложении AJAX, включенном в веб-сценарий, сценарий должен быть зарегистрирован с помощью элемента управления ScriptManager на странице. Чтобы зарегистрировать файл сценария, создайте объект ScriptReference, указывающий на файл вопроса, и добавьте в коллекцию Scripts. В следующем примере показано, как сделать это в разметке:

<asp:ScriptManager ID="SMgr" runat="server">
  <Scripts>
    <asp:ScriptReference path="MyScript.js" />
  </Scripts>
</asp:ScriptManager>

Для файлов сценариев для правильной обработки элементом управления ScriptManager каждый файл должен включать вызов метода Sys.Application.notifyScriptLoaded в конце файла. Этот вызов уведомляет приложения, что файл завершил загрузку. В следующем примере показан код для этой цели:

if (typeof(Sys) !== 'undefined') Sys.Application.notifyScriptLoaded();

Можно также внедрить файлы JS в качестве ресурсов в сборке управляемого кода. (Это можно сделать, если создан элемент управления сервера ASP.NET с возможностями AJAX, реализованными в клиентском сценарии.) Если сценарий внедрен в сборку, нет необходимости включать инструкцию уведомления в сценарии. Кроме того, нет необходимости задать атрибут path в сценарии ссылке. Тем не менее необходимо указать имя сборки без расширения имени файла, как показано в следующем примере:

<asp:ScriptManager ID="SMgr" runat="server">
  <Scripts>
    <asp:ScriptReference 
        Name="MyScript.js" Assembly="MyScriptAssembly"/>
  </Scripts>
</asp:ScriptManager>

Примечание.
Этот сценарий не является общим для разработчиков страниц, так как большинство элементов управления с библиотеками внедренных сценариев ссылается для внутренних целей. Дополнительные сведения см. в разделе Пошаговое руководство. Внедрение в сборку файла JavaScript в качестве ресурса.

Этот сценарий не является общим для разработчиков страниц, так как большинство элементов управления с библиотеками внедренных сценариев ссылается для внутренних целей. Дополнительные сведения см. в разделе Пошаговое руководство. Внедрение в сборку файла JavaScript в качестве ресурса.

Можно также зарегистрировать сценарии программным путем, создав ссылки сценария в коде и добавив их к коллекции Scripts. Дополнительные сведения см. в разделе Динамическое присваивание ссылок на сценарии.

Можно зарегистрировать сценарии, которые необходимы для обновления частичных страниц с помощью регистрации методов элемента управления ScriptManager. Можно использовать эти методы в следующих случаях:

Чтобы создать клиентский сценарий в коде, постройте блок сценария в виде строки и передайте его методу RegisterClientScriptBlock.
Чтобы добавить автономные файлы сценария, не имеющие зависимостей от Microsoft AJAX (библиотека), используйте метод RegisterClientScriptInclude.

Чтобы добавить файлы сценариев, внедренные в сборке, используйте метод RegisterClientScriptInclude.

Примечание.
Сценарии, которые зарегистрированы с помощью этих методов, не имеют поддержки локализации.

Полный список сценариев регистраций методов и их использование смотрите в разделе ScriptManager.

Любые блоки сценариев или встроенный сценарий являются регистрационными и должны находиться внутри элемента <form> страницы. В противном случае сценарий не зарегистрирован с элементом управления ScriptManager и не может получить доступ к функциональности ASP.NET AJAX. Дополнительные сведения см. в разделе Метод Sys.Application.initialize.

См. также

Поделиться через