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

Visual Studio 2010

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

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

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

Чтобы использовать возможности 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 обеспечивают дополнительные функциональные возможности для этих типов. Для получения дополнительных сведений об этих расширениях см. следующие разделы.

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

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

  • MyScript.js (розница).

  • MyScript.Debug.js (отладка).

Любая веб-страница 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> 
Bb386453.alert_note(ru-ru,VS.100).gifПримечание.

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

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

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

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

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

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

    Bb386453.alert_note(ru-ru,VS.100).gifПримечание.

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

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

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

Показ: