Но вы зря волнуетесь по этому поводу, Visual Studio содержит эффективный инструмент под названием Javascript Memory Analysis, который помогает обнаружить утечки памяти.

Рекомендации по применению инструмента Javascript Memory Analysis

Этот инструмент запускается из меню Debug (Отладка) в Visual Studio:

После запуска инструмента, запустится и ваше приложение, на экране вы увидите следующее:

В первой области окна в режиме реального времени отображается объем памяти, используемой приложением:

Ниже присутствует кнопка Take Heap Snapshot (Создание мгновенного снимка кучи), используемая для создания мгновенного снимка «кучи» (элемент управления также показывает размер «кучи» и количество активных объектов):

По щелчку на размере «кучи» выводится более подробная информация:

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

На примере моего приложения, я вижу, что объект UrzaGatherer удерживает около 60 МБ памяти (так и должно быть, поскольку в нем хранится огромный список карт):

Это представление также позволяет вывести на экран:

• список типов, отсортированный по количеству вхождений;
• список корневых объектов (с точки зрения сборщика мусора);
• список объектов DOM, отсортированный по объему удерживаемой памяти;
• список объектов WinRT, отсортированный по объему удерживаемой памяти.

Эти представления помогут вам обнаружить случаи нецелесообразного использования памяти.

Сравнение моментальных снимков

После каждого нажатия кнопки Take Heap Snapshot (Создание мгновенного снимка кучи) система генерирует новый дамп «кучи» с целью последующего анализа. Кроме того, каждый новый снимок позволяет оценить динамику изменения размера «кучи» и количества объектов.

Это основной инструмент поиска утечек памяти.

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

Сравнив два моментальных снимка, я обнаружил, что размер «кучи» увеличился на 6,12 МБ, кроме того, были созданы 53 000 объектов, которые не были в дальнейшем удалены. 

Щелкнув значение, показывающее изменение размера «кучи» (+6,12 МБ), вы можете получить более подробную информацию о различиях между двумя моментальными снимками:

Представление Dominators (Доминаторы) показывает, что новые объекты не были удалены после того, как мы вернулись на домашнюю страницу. Это представление поможет вам обнаружить ненужные объекты.

В моем случае подозрительной кажется первая строка. Щелкнув ее правой кнопкой мыши, я могу перейти к представлению Root (Корень), чтобы увидеть, какая функция хранит эти объекты:

Как видите, объект удерживается функцией ImportFromTappedOut.

Эта глобальная функция в моем коде принимает функцию в качестве параметра:

ImportFromTappedOut = function (deckName, custom) {

Параметр custom эта функция использует для вызова специализированного пользовательского кода. Главная проблема связана с тем, что ImportFromTappedOut — глобальная функция, и она хранит весь код, к которому обращается функция, в параметре custom. В этом случае моя анонимная функция ссылается на большое количество локальных объектов DOM:

Tools.ImportFromTappedOut("test", function () { var select = document.querySelector("#addToDeck"); 
 var count = document.querySelector("#addToDeckCount").value; 
 listView.selection.getItems().then(function (items) { appBar.hide(); 
 appBar.sticky = false; listView.selection.clear();

…code continue…

Эту проблему мне помог обнаружить рассматриваемый инструмент:

Решение простое: достаточно вызвать importFromTappedOut с нулевой функцией, когда я закрываю страницу, чтобы сборщик мусора удалил все сохраненные объекты (в этом случае освободится 1,25 МБ).

Я настоятельно рекомендую вам использовать этот инструмент для выявления и предотвращения утечек памяти. Несмотря на свою простоту, он очень эффективен.

Подробнее о рассматриваемом инструменте

Следующие статьи также могут быть вам полезны:

• JavaScript memory analysis for Windows Store apps in Visual Studio 2012
• Optimizing JavaScript Windows 8 application: Using the Visual Studio performance analysis tool (profiler)
• How to cook a Windows 8 application with HTML5/Javascript/CSS3
• Unleash the power of HTML 5 Canvas for gaming
• [Французский]https://www.microsoft.com/france/mstechdays/programmes/2013/fiche-session.aspx?ID=f721312a-cc92-4599-8795-cfe07d5c0bb4

Варианты применения инструмента IntelliTrace:

1. Во время отладки в VS нажатием клавиши F5.
2. В Test Manager (доступен как адаптер диагностических данных — Data Diagnostic Adapter).
3. При запуске из любого места (использование автономного сборщика данных).

Описание «режимов работы» IntelliTrace

В IntelliTrace реализовано два стандартных режима с широкими возможностями: Events Only (Только события) и Events and Call Information (События и сведения о вызовах). Режим Events Only — упрощенный, он позволяет регистрировать «события», которые происходят во время выполнения вашей программы. Эти события представляют собой заслуживающие интереса «происшествия», например вызовы ASP.NET или ADO.NET, а также исключения. Группа разработки продукта постаралась записать события, которые помогут понять, как ваш код работает, и проследить длинные цепочки «причин и следствий».

Режим Events and Call Information — расширенный режим отладки, при котором помимо сведений, относящихся к режиму Events Only, регистрируются также вызовы методов (включая входящие и исходящие аргументы). Для подлежащих сбору данных установлены некоторые ограничения, иначе размер журналов будет просто огромным, даже больше, чем с настройками по умолчанию.

Использование клавиши F5 при работе с IntelliTrace

Этот вариант подходит для использования в процессе разработки кода. Это означает, что можно отлаживать приложение, перемещаясь вперед и назад в сеансе отладки, при этом нет необходимости останавливать приложение или добавлять точки останова. Активировать отладчик можно в настройках IntelliTrace: Tools -> Options (Сервис -> Параметры). Предусмотрено два режима:

После активации (в данном случае я включил режим Events and Call Information) отладчик готов к использованию. Понажимайте кнопки в своем приложении и щелкните ссылку Break All (Приостановить все) в VS в окне IntelliTrace:

(Я отлаживаю свое приложение Calculator. Нажимаю Break All (Приостановить все) и открывают журнал IntelliTrace.)

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

Предположим, что нечто странное произошло, когда я нажал «=», перемножая два числа. Перезапускать приложение нет необходимости, я могу просто нажать кнопку «=» после «*» (из записи в журнале видно, что я нажал 3 х 6 =). Я могу нажать это событие и «перемотать» до интересующего меня момента.

Сейчас я могу нажать Calls View (Представление вызовов) и приступить к просмотру журнала с этой точки.

Дважды щелкните вызов btnEqual_Click для перехода к этому моменту выполнения. Вы увидите глифы IntelliTrace во внутреннем поле окна исходного кода:

Если навести указатель мыши на значки, система выдаст подсказку. Функции появляются в следующем порядке:

· return to calling method

· step back

· step into

· step over

· return to Live Debugging

(Небольшая подсказка: при нажатии кнопки return to Live Debugging (Возврат к динамической отладке) внизу, вы перейдете к текущей точке отладчика, и для повторного запуска приложения следует опять нажать клавишу F5.)

Если вы нажмете F11, текущий указатель переместится вперед. Нажав эту кнопку дважды, я перешел к точке, где в программе стоит оператор Switch:

Обратите внимание: мне не придется гадать, какой именно оператор Case был выбран, достаточно посмотреть запись в журнале. Я также поставил метки для обработчиков наведения и убирания курсора мыши для val1 и val2, вы можете увидеть эти значения. Не все значения отслеживаются, но в данном случае это исходящие или входящие примитивы метода, поэтому IntelliTrace успешно регистрирует их значения.

Я опять нажму клавишу F11, чтобы войти в метод Multiply(), а затем еще раз, чтобы перейти к следующему событию:

Я перешел к закрывающейся фигурной скобке метода Multiply. В окне Autos показаны параметры val1 и val2 и их значения (3 и 6, соответственно), а также значение, возвращаемое методом (9).

Вуаля! 3–4 клика, и мы нашли ошибку в своей программе. И нам даже не пришлось задавать точку останова!

Фильтрация событий

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

Например, в выпадающем списке All Categories (Все категории) я могу выбрать фильтр, чтобы отображались только исключения:

Поиск строки

Также рекомендую использовать функцию поиска строки (Search For this line) или метода (Search For This Method). Вы подозреваете, что метод был выполнен во время отладки, но читать весь журнал нет времени? Никаких проблем! Щелкните правой кнопкой мыши строку (или метод) и выберите Search For This Line/Method in IntelliTrace (Поиск для этой строки/метода в IntelliTrace).

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

Я щелкну по значку стрелки сразу после слова Multiply, чтобы перейти к первому вызову этого метода в журнале и начать процесс «отладки» с этого места.

В следующей статье я расскажу вам, как запускать IntelliTrace из любого места.

Удачной отладки!

В пакет обновления Visual Studio 2012 Update 1, который вышел в ноябре 2012 года, была включена новая функция под названием Code Map (Карта кода), она доступна пользователям версии Ultimate edition. Эта функция позволяет визуализировать взаимосвязи в коде. В основе карты кода лежит концепция, понять которую вам поможет этот короткий видеоролик.

Начиная с версии, включенной в пакет обновления Visual Studio 2012 Update 2, функция Code Map включает расширенные возможности, теперь взаимосвязи в коде можно визуализировать в ходе отладки. Ниже представлен код для Windows Phone — при нажатии кнопки веб-службе отправляется запрос на получение данных о численности населения Пакистана. После получения результата на экран выводится подтверждающее сообщение для пользователя. Однако в ходе тестирования мы обнаружили, что сообщение с подтверждением выводится до фактического получения ответа на запрос, поэтому мы приступаем к отладке кода с использованием инструмента Code Map.

Карта кода: инструкция по применению?

Сейчас мы познакомимся с функцией отладки инструмента Code Map (Карта кода). Создайте точку останова для обработчика нажатия кнопки. Как только точка останова сработает, перейдите в окно карты кода, выполнив одно из следующих действий:

-       Нажмите кнопку Code Map (Карта кода) на панели инструментов.

 -       Выберите пункт Show Call Stack on Code Map (Показать стек вызовов на карте кода) из меню Debug (Отладка).

-       Нажмите Ctrl + Shift +`.

На экране вы увидите примерно следующее:

Красная рамка означает, что для этого узла в данный момент выполняется отладка. Давайте проанализируем первый метод. Нажав F11, вы можете вывести на экран содержимое метода DataRetrieved(), в окне Code Map будет показано текущее состояние отладки, для соответствующего метода будет создан новый узел. Обратите внимание, что узел для DataRetrieved () в данный момент выделен желтым маркером. Это позволяет вам отслеживать свои стеки вызовов и взаимосвязь методов.

Code Map предоставляет широкие возможности для отладки, например, нажав Summary (элемент TextBlock) внутри метода и выбрав Find All References on Code Map (Найти все ссылки на карте кода), вы можете вывести на экран все элементы, на которые ссылается это поле. Например, вы без лишних усилий можете определить, какие методы в коде работают с конкретным полем; это очень удобно, особенно для сложных сценариев отладки.

Можно продолжить отладку и перейти к следующему методу обработчика нажатия на кнопку — RequestPopulation(). Если вы пропустите этот метод, нажав F10, то на карте кода он не появится. Это предотвращает загромождение карты кода, на ней будут только те элементы, которые вас интересуют.

Давайте перейдем к последнему методу в этом вызове — ShowConfirmationMesssage(). Узел для этого метода станет активным, а узел для DataRequest() поменяет цвет на серый, это означает, что узел больше не является активным в контексте отладки.

Наконец, если мы откроем этот метод, вернемся к обработчику нажатия кнопки Button 1 и продолжим отладку путем нажатия F10, то мы перейдем к событию DownloadStringCompleted, которое представляет собой асинхронный вызов из метода RequestPopulation(). Обратите внимание, что на карте кода это ветвь от узла External Code (Внешний код), поскольку вызов перехватывается библиотеками классов ядра (класс System.Net.WebClient) в Windows Phone.

Наведите указатель мыши на событие wc_DownloadStringcompleted(), и вы увидите соответствующую подпись кода в подсказке.

Функции анализа кода в Code Map

Наконец, мы обнаружили проблему в коде. Вызов веб-службы является асинхронным, поэтому приложение не будет ждать ответа и сразу покажет сообщение с подтверждением. Эту информацию мы должны передать нашему разработчику. Инструмент Code Map, в частности, помогает анализировать код. Щелкните правой кнопкой событие wc_DownloadStringCompleted и выберите Add Comment (Добавить комментарий).

После добавления комментария вы можете просто переместиться наверх и выбрать подходящий метод для предоставления общего доступа.

Также доступны другие полезные функции, например функция Flag for Follow Up (Отметка к дальнейшим действиям) позволяет выбрать цвет и выделить фрагмент кода, который требует вашего внимания, но не в рамках текущего сеанса отладки.

Анализ указателей

Для удобства читателя приводится краткий обзор указателей, аналоги которых присутствуют на карте кода.

Если две предыдущие статьи вы еще не читали, то можете сделать это прямо сейчас. Приступайте к этой статье, когда у вас будет готово приложение.

Если вам легче воспринимать визуальную информацию, то посмотрите видеоролики для части 1 и 2 на нашем канале Channel 9! Вам понадобится менее получаса, чтобы с нуля создать приложение, реалистично имитирующее игру в кости!

Заключительные шаги Windows RT

Современные устройства с Windows RT оборудованы графической картой с поддержкой D3D_FEATURE_LEVEL_9_1, а инструменты Visual Studio Graphics генерируют шейдеры для графических карт с поддержкой D3D_FEATURE_LEVEL_10_0 и выше, поэтому для того, чтобы приложение можно было запускать на устройствах с Windows RT, необходимо создать шейдеры поддерживаемой версии.

Откройте сетку Die (Die.fbx) и щелкните куб. В окне Properties (Свойства) найдите свойство Effect (Эффект). Нажмите кнопку «+» слева от этого свойства и выберите значение Advanced (Расширенные). Наконец, нажмите кнопку «…», чтобы открыть исходный код шейдера для эффекта Phong (метод Фонга).

В окне конструктора шейдеров Visual Studio Shader Designer вы увидите шейдер, который по умочанию применяется к этой сетке в Visual Studio. Конструктор шейдеров позволяет создавать сложные визуальные эффекты, при этом вам не придется изучать новый язык программирования. Подробнее о конструкторе шейдеров написано в документации и обзоре на сайте MSDN.

Мы экспортируем этот шейдер в HLSL для того, чтобы перекомпилировать его для видеокарт типа Direct3D Feature Level 9. Starter Kit попытается автоматически найти поддерживаемый шейдер с тем же именем, если оригинал не поддерживается данным устройством.

Для экспорта этого шейдера переходим к последнему значку на панели инструментов: (Advanced) -> Export -> Export as… ((Расширенные) -> Экспортировать -> Экспортировать как...), вводим имя Phong.hlsl и сохраняем файл в папку Assets (см. рисунок ниже). Необходимо добавить этот файл в проект: щелкните правой кнопкой мыши папку Assets, нажмите Solution Explorer -> Add -> Existing item (Обозреватель решений -> Добавить -> Существующий элемент) и выберите только что экспортированный файл.

Наконец, мы должны сообщить компилятору HLSL, что этот файл относится к типу Pixel Shader (Шейдер пикселей). Для этого в обозревателе решений Solution Explorer щелкните правой кнопкой мыши файл Phong.hlsl и выберите Properties (Свойства). На странице свойств проверьте, чтобы в раскрывающемся списке Configuration (Конфигурация) был выбран пункт All Configurations (Все конфигурации), а в раскрывающемся списке Platform (Платформа) — All Platforms (Все платформы). Таким образом, все вносимые нами изменения применяются ко всем версиям нашего приложения.

Затем на странице HLSL Compiler (Компилятор HLSL) задайте свойству Shader Type (Тип шейдера) значение Pixel Shader (/ps) [Шейдер пикселей (/ps)]. Кроме того, должна быть включена оптимизация, т. е. свойству Disable optimizations (Отключить оптимизацию) должно быть задано значение No (Нет). Эти настройки показаны на рисунке ниже:

На этом этапе мы подготовили приложение для запуска на устройствах под управлением Windows RT. Теперь вы можете установить это приложение на своем устройстве с помощью инструментов удаленной отладки Visual Studio Remote Debugging Tools.

Прежде чем опубликовать версию приложения для Windows RT, необходимо убедиться в том, что и портретный режим, и режим Snap View работают корректно. В этом случае мы просто удалили следующую строку из метода CreateWindowSizeDependentResource() в классе Game.cpp, чтобы камера не меняла ориентацию при переключении режима представления:

void Game::CreateWindowSizeDependentResources()
 {
 GameBase::CreateWindowSizeDependentResources();
 
 // (фрагмент) инициализировать камеру...
 if (aspectRatio < 1.0f)
 {
 ///
 /// портретный режим или режим snap view
 ///
 m_graphics.GetCamera().SetUpVector(XMFLOAT3(1.0f, 0.0f, 0.0f)); 
 fovAngleY = 120.0f * XM_PI / 180.0f;
 }
 // (фрагмент) источники света...
 }

Приложение в его текущем состоянии можно загрузить с сайта CodePlex (см. прямую ссылку ниже).

Портирование приложения на Windows Phone

Проект Starter Kit with support for Windows Phone позволяет беспрепятственно портировать это приложение на Windows Phone 8. Теперь необходимо загрузить пакет Starter Kit, заменить классы Game.cpp и Game.h на те, которые вы создали для этого приложения, добавить все свои активы (в данном случае: Die.fbx, DieTexture.png и Phong.hlsl), а также внести изменения в код XAML для вызова метода RollDie(), когда пользователь касается сенсорного экрана. Краткие пошаговые инструкции:

1. На вашем компьютере должен быть установлен пакет Windows Phone 8 SDK.
2. Загрузите пакет Visual Studio 3D Starter Kit with support for Windows Phone и откройте его в Visual Studio.
3. В проекте StarterKitPhoneComponent: удалите папку Shared/Animation и все содержимое из папки Shared/Assets.
4. Замените файлы Game.cpp и Game.h на созданные вами ранее.
5. Скопируйте все активы вашей игры в папку Shared/Assets проекта StarterKitPhoneComponent: Die.fbx, DieTexture.png и Phong.hlsl.
6. На странице свойств файла Phong.hlsl проверьте, чтобы в раскрывающемся списке Configuration (Конфигурация) был выбран пункт All Configurations (Все конфигурации), а в раскрывающемся списке Platform (Платформа) — All Platforms (Все платформы). Затем на странице HLSL Compiler (Компилятор HLSL) задайте свойству Shader Type (Тип шейдера) значение Pixel Shader (/ps) [Шейдер пикселей (/ps)] и установите для свойства Disable optimizations (Отключить оптимизацию) значение No (Нет).
7. Удалите неиспользуемые методы из класса Direct3DBackground.cpp/.h: ToggleHitEffect() и ChangeMaterialColor().
8. В классе Direct3DBackground.cpp добавьте следующий код в метод OnPointerReleased():

   void Direct3DBackground::OnPointerReleased(DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)

   {

     m_renderer->RollDie();

   }

9. Из MainPage.xaml удалите весь код XAML, относящийся к счетчикам и панели приложения.
10. Из MainPage.xaml.cs удалите все неиспользуемые поля и методы.

Готово! Теперь это приложение можно запустить в эмуляторе Windows Phone или на устройстве с Windows Phone 8. Вы можете отрегулировать положение камеры и поле зрения, чтобы на экране телефона кубик выглядел крупнее.

Итоговую версию проекта можно загрузить с сайта CodePlex (см. прямую ссылку ниже).

Планы на будущее

Это приложение готово к размещению в Магазине Windows, но есть много дополнительных шагов, которые помогли бы сделать его лучше. Например:

• Замена логотипа, иконок плитки и заставки в соответствии с темой приложения.
• Создание красивого фона и, возможно, стола, на который пользователь будет бросать кости.
• Добавление теней, отражения и других реалистичных визуальных эффектов.
• Можно сделать кубик настраиваемым, полупрозрачным, с закругленными краями.
• Обеспечение поддержки более чем одного кубика или кубиков с разным количеством граней.
• Добавление реалистичных подпрыгиваний и вращений с учетом силы броска, обнаружение столкновений.
• Сохранение информации о состоянии кубика, когда работа приложения приостанавливается и возобновляется.
• Ведение истории результатов предыдущих бросков.
• Обеспечение поддержки датчика, чтобы пользователь мог бросать кости путем встряхивания устройства.
• Звуковое сопровождение броска костей.
• Возможности приложения Dice Roller можно использовать для создания настольной игры или симулятора казино...

Подведем итоги

Эта серия статей познакомила вас с процессом создания 3D-приложения для Windows 8, Windows RT и Windows Phone с использованием пакета Visual Studio 3D Starter Kit. Вся логика и активы приложения являются кроссплатформенными. Также вы узнали об инструментах Visual Studio Graphics и поняли, что создание 3D-приложения — не такая уж сложная задача, вы можете приступать к ней без глубоких знаний в области трехмерного моделирования, математики и HLSL, постепенно изучая новые понятия.

Мы будем рады услышать отзывы об этом пошаговом руководстве, пакете Visual Studio 3D Starter Kit, а также узнать, с какими возможностями Visual Studio, предназначенными для работы с графикой, вы хотели бы познакомиться в будущем. Оставляйте нам свои комментарии!

Как заставить кубик крутиться

Чтобы заставить любой объект в графическом приложении двигаться, необходимо:

1. Определить какое-либо состояние (например, с помощью логического флага), чтобы указать, что должна быть запущена анимация. Также на этом этапе можно сохранить сведения об исходном положении и продолжительности анимации, если это необходимо.
2. В методе Update, который вызывается для каждого кадра перед рендерингом, обрабатывается положение/вращение/масштабирование объекта (с точки зрения 3D-модели, мы говорим о преобразованиях); следует вычислить разницу во времени между началом анимации и выводом на экран текущего кадра. Когда анимация завершается, необходимо надлежащим образом обновить состояние, чтобы остановить анимацию.
3. В методе Render преобразования должны применяться к каждому объекту надлежащим образом.

Мы добавим новый метод RollDie(), который установит состояние и сохранит время запуска. Этот метод будет использоваться для вычисления результата каждого броска кубика, но пока мы просто запустим анимацию — вращение кубика и показ цифр от 1 до 6.

Чтобы создать эту анимацию, нам понадобится набор переменных для отслеживания преобразований куба, а также времени анимации. Мы создадим одну переменную типа Boolean для отслеживания выполнения анимации, одну переменную типа Float для хранения времени анимации и три вектора для хранения начального, конечного и текущего вращений куба. Векторы типа XMFLOAT3 будут хранить вращения Yaw, Pitch и Roll (см. рисунок ниже).

Давайте создадим эти поля и метод RollDie(). Добавьте следующий код в класс Game.h:

ref class Game sealed : public GameBase
 {
 // (фрагмент) объявление других классов...
 
 Platform::String^ OnHitObject(int x, int y);
 void RollDie(); 
 private:
 std::vector<VSD3DStarter::Mesh*> m_meshModels;
 bool m_isAnimationRunning;
 float m_animationTime;
 DirectX::XMFLOAT3 m_initialRotation;
 DirectX::XMFLOAT3 m_currentRotation;
 DirectX::XMFLOAT3 m_targetRotation;
 };

Давайте создадим анимацию, начнем с метода RollDie(). Добавьте следующий код в класс Game.cpp:

void Game::RollDie()
{
    m_initialRotation = m_currentRotation;
    m_targetRotation = XMFLOAT3(0.0f, XM_PI, 0.0f); // always rotate to 6

    m_animationTime = 0.0f;
    m_isAnimationRunning = true;
}

RollDie() запустит анимацию путем задания значения True для переменной m_isAnimationRunning. Нам необходимо добавить код в метод Update() для поворота куба в каждом кадре. Добавьте следующий код в метод Update(): 

void Game::Update(float timeTotal, float timeDelta)
 {
 if (m_isAnimationRunning)
 {
 m_animationTime += timeDelta;
 
 static const float animationDuration = 0.5f;
 float animationProgress = std::min<float>(m_animationTime / animationDuration, 1.0f);
 
 XMVECTOR initial = XMLoadFloat3(&m_initialRotation);
 XMVECTOR target = XMLoadFloat3(&m_targetRotation);
 
 XMVECTOR current = initial + animationProgress * (target - initial);
 XMStoreFloat3(&m_currentRotation, current);
 
 if (animationProgress >= 1.0f)
 m_isAnimationRunning = false;
 }
 }

Описание кода:

1. Анимация должна запускаться только в том случае, когда установлен флаг m_isAnimationRunning.
2. Сначала вычисляется значение переменных calculate m_animationTime (время от начала анимации 0–0,5 секунды) и m_animationProgress (процент завершения анимации 0–1). Обратите внимание, «1.0» означает, что анимация завершена.
3. Загрузите исходный и целевой векторы вращения в XMVECTORs, это позволяет ускорить расчеты благодаря макроопределениям CPU.
4. Расчеты линейным способом по формуле:

текущий = исходный + прогресс * (целевой – исходный)

1. Вычисленное значение сохраняется обратно в m_currentRotation.
2. Проверка выполнения анимации и ее остановка в случае необходимости.

На следующем шаге анимации вычисленное вращение используется в методе Render для поворота куба. Для этого измените следующую строку кода в методе Render():

void Game::Render()
 {
 GameBase::Render();
 
 // (фрагмент) очистить...
 
 XMMATRIX transform = XMMatrixRotationRollPitchYawFromVector(XMLoadFloat3(&m_currentRotation));
 
 for (UINT i = 0; i < m_meshModels.size(); i++)
 {
 m_meshModels[i]->Render(m_graphics, transform);
 }
 
 // (фрагмент) MSAA...
 }

Метод, который мы вызываем, получает объект XMVECTOR, содержащий значения переменных для разворота, уклона и поворота относительно вертикальной оси. Этот метод возвращает матрицу вращения, которая соответствует комбинированному преобразованию. Для наших целей также подходит метод XMMatrixRotationRollPitchYaw, который обрабатывает параметры разворота, уклона и поворота относительно вертикальной оси по отдельности. Кроме того, вы можете вычислить каждый компонент с помощью отдельного метода, а затем самостоятельно перемножить результаты. Полный перечень методов, используемых для создания матриц преобразования, представлен на сайте MSDN.

Все, что нам необходимо сделать,— вызвать метод RollDie(). Мы будем вызывать его каждый раз, когда пользователь касается или щелкает по экрану. Добавьте следующий код в файл DirectXPage.xaml.cpp (в метод DirectXPage::OnTapped):

void DirectXPage::OnTapped(Platform::Object^ sender, TappedRoutedEventArgs^ e)
 {
 m_renderer->RollDie();
 }

Если вы запустите приложение сейчас, то после щелчка или касания экрана в любом месте кубик будет вращаться, показывая цифры от 1 до 6!

Логика приложения: генератор случайных чисел

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

Сначала генератор rand() нужно инициализировать с помощью некоторого начального значения. Если мы не инициализируем генератор или инициализируем его с использованием фиксированного значения, то последовательность генерируемых чисел будет неизменна при каждом запуске приложения, а нам это не подходит. Мы будем инициализировать генератор случайных чисел с использованием текущего времени CPU. Добавьте следующий код в метод Game::Initialize():

void Game::Initialize()
 {
 Mesh::LoadFromFile(m_graphics, L"die.cmo", L"", L"", m_meshModels);
 
 srand ((unsigned int) time(NULL));
 }

Также следует подключить библиотеку <time.h> для метода Game.cpp, чтобы функция time() была доступна:

#include "pch.h"
 #include "Game.h"
 #include <DirectXMath.h>
 #include <DirectXColors.h>
 #include <algorithm>
 #include <time.h>

После инициализации мы можем воспользоваться функцией rand() в методе RollDie(), чтобы получить цифру, которая выпадет, когда пользователь бросит кости. Мы также должны правильно задать целевые вращения кубика при каждом броске. Для этого измените строку, в которой задается значение переменной m_targetRotation. Окончательный вариант метода RollDie():

void Game::RollDie()
 {
 m_initialRotation = m_currentRotation;
 
 int currentRoll = rand() % 6 + 1;
 switch (currentRoll)
 {
 case 1:
 m_targetRotation = XMFLOAT3(0.0f, 0.0f, 0.0f);
 break;
 case 2:
 m_targetRotation = XMFLOAT3(0.0f, XM_PIDIV2, 0.0f);
 break;
 case 3:
 m_targetRotation = XMFLOAT3(XM_PIDIV2, 0.0f, 0.0f);
 break;
 case 4:
 m_targetRotation = XMFLOAT3(-1.0f * XM_PIDIV2, 0.0f, 0.0f);
 break;
 case 5:
 m_targetRotation = XMFLOAT3(0.0f, -1.0f * XM_PIDIV2, 0.0f);
 break;
 case 6:
 m_targetRotation = XMFLOAT3(0.0f, XM_PI, 0.0f);
 break;
 }
 
 m_animationTime = 0.0f;
 m_isAnimationRunning = true;
 }

Запустите приложение. Вот наш анимированный кубик! Бросьте кости, коснувшись экрана в любом месте. Можете перейти в режим Snap View.

Как заставить кубик прыгать

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

Чтобы запрограммировать «прыжки», мы добавим еще одну переменную в нашу анимацию — вертикальную координату (Y). Значение этой переменной будет изменяться после того, как кости будут брошены (в методе Update()), мы также внесем изменения в метод Render(), чтобы применить трансляцию к кубу. Сначала нужно добавить переменную трансляции в Game.h:

ref class Game sealed : public GameBase
 {
 // (фрагмент) объявление других классов...
 
 private:
 std::vector<VSD3DStarter::Mesh*> m_meshModels;
 bool m_isAnimationRunning;
 float m_animationTime;
 DirectX::XMFLOAT3 m_initialRotation;
 DirectX::XMFLOAT3 m_currentRotation;
 DirectX::XMFLOAT3 m_targetRotation;
 float m_currentTranslationY;
 };

Чтобы переменная изменялась с течением времени (метод Update()):

void Game::Update(float timeTotal, float timeDelta)
 {
 if (m_isAnimationRunning)
 {
 // (фрагмент)
 
 XMVECTOR current = initial + animationProgress * (target - initial);
 XMStoreFloat3(&m_currentRotation, current);
 
 const float maxHeight = 2.0f;
 m_currentTranslationY = 4.0f * maxHeight * animationProgress * (1 - animationProgress);
 
 if (animationProgress >= 1.0f)
 m_isAnimationRunning = false;
 }
 }

Те, кто помнит курс математики старших классов, узнали уравнение параболы с полюсами в точках 0 и 1 и вершиной в точке 0,5 (MaxHeight). Наш кубик будет достаточно реалистично подпрыгивать. График этой функции можно увидеть здесь: WolframAlpha.

На заключительном этапе мы воспользуемся расчетной трансляцией для преобразования куба в процессе рендеринга. Добавьте следующий код в метод Render:

v

oid Game::Render()
 {
 // (фрагмент) очистить...
 
 m_d3dContext->ClearDepthStencilView( /* (фрагмент) */ );
 
 XMMATRIX transform = XMMatrixRotationRollPitchYawFromVector(XMLoadFloat3(&m_currentRotation));
 transform *= XMMatrixTranslation(0.0f, m_currentTranslationY, 0.0f);
 
 for (UINT i = 0; i < m_meshModels.size(); i++)
 {
 m_meshModels[i]->Render(m_graphics, transform);
 }
 
 // (фрагмент) MSAA...
 }

Запустите приложение и щелкните по экрану. Вы увидите, что кубик после броска реалистично подпрыгивает. Наконец, чтобы анимация выглядела еще более реалистичной, добавим случайные вращения по обеим осям при каждом броске кубика. Для этого внесем изменения в метод RollDie() и добавим случайные повороты в целевое вращение:

void Game::RollDie()
 {
 // (фрагмент) инициализация, бросок и переключение(currentRoll)
 
 XMVECTOR target = XMLoadFloat3(&m_targetRotation);
 XMVECTOR current = XMLoadFloat3(&m_currentRotation);
 
 // учет текущего вращения
 target += XMVectorFloor(current / XM_2PI) * XM_2PI;
 
 // -1, 0 или 1 дополнительный оборот
 XMVECTOR randomVector = XMLoadFloat3(&XMFLOAT3(rand() % 3 - 1.0f, rand() % 3 - 1.0f, rand() % 3 - 1.0f));
 target += randomVector * XM_2PI;
 
 XMStoreFloat3(&m_targetRotation, target);
 
 m_animationTime = 0.0f;
 m_isAnimationRunning = true;
 }

Этот код вносит два изменения в целевое вращение:

1. Указывается общее количество полных оборотов, совершенных до настоящего момента в рамках целевого вращения, в результате чего каждый поворот будет выполняться относительно предыдущего поворота, а не исходного положения кубика.
2. Добавляется -1, 0 и 1 полный оборот к целевому относительному вращению. Для этого мы создаем вектор на основе трех значений, выбранных случайно из ряда -1, 0 и 1, и умножаем полученную величину на 2 * PI (полный оборот в радианах).

Также обратите внимание на то, что мы используем XMVECTORs еще раз для ускорения расчета, это также позволяет использовать только одну формулу вместо трех (если бы компоненты х, у, z вычислялись по отдельности).

Мы расширили функционал своего приложения. Конечно, с таким приложением работать намного интереснее, чем с классическим генератором случайных чисел. Эту версию приложения можно загрузить с сайта CodePlex (прямая ссылка представлена на плитке ниже).

Осталось всего несколько шагов, и наше приложение будет работать на устройствах с Windows RT и Windows Phone. Эти шаги мы рассмотрим в третьей и последней статье блога из этой серии. Следите за обновлениями!

Несколько недель назад мы анонсировали серию статей, в которых будет показан весь процесс разработки приложения с использованием пакета Visual Studio 3D Starter Kit. Представляем вашему вниманию первую статью из этой серии. В серии статей мы рассмотрим процесс разработки приложения, пользователь которого сможет касанием или щелчком бросать трехмерные шестигранные кубики для игры в кости. Брошенный кубик будет подпрыгивать и вращаться в воздухе. Это приложение будет также запускаться в режиме Snap View в Windows 8, и пользователи смогут бросать кости, не прерывая работу в других приложениях. Мы также продемонстрируем, как сделать это приложение совместимым с устройствами на базе Windows RT, а также портировать его на Windows Phone.

В первой статье мы рассмотрим процесс создания приложения до этапа вывода кубика на экран и наложения текстуры. Мы также изучим возможности инструментов Visual Studio Graphics, которые доступны, начиная с версии Visual Studio Professional и выше. Но даже если у вас только Visual Studio Express 2012 для Windows 8, вы все равно сможете работать с этим пошаговым руководством.

Самые большие сложности у начинающих разработчиков Direct3D возникают из-за необходимости изучения большого количества новых понятий, например они должны научиться кодировать шейдеры HLSL и конвертировать сетки в форматы, подходящие для использования в режиме выполнения. Visual Studio содержит большое количество инструментов, упрощающих этот процесс, они помогут вам сконцентрироваться на логике приложения, вместо того чтобы изучать эти новые понятия. Когда вы будете готовы, вы сможете реализовать дополнительные функции в своем приложении, и при этом не придется начинать все сначала. В статьях из этой серии присутствует ряд ссылок на дополнительную документацию по DirectX, которую мы сами используем. Вы можете изучить эти материалы самостоятельно и узнать подробнее о DirectX и программировании графики.

Итак, настало время перейти от слов к делу!

Демонстрационное приложение Dice Roller, имитирующие бросание игральных костей

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

Ну конечно! Мы можем сделать кубик трехмерным! При этом мы не будем использовать какие-либо дополнительные инструменты, только Visual Studio 2012 Professional. Приступим!

Начинаем с чистого листа

Сначала необходимо загрузить и открыть пакет Visual Studio 3D Starter Kit. Ссылка для загрузки: https://aka.ms/vs3dkit. Мы также подготовили специальную версию пакета Starter Kit (только для Магазина Windows) для этого руководства. Сначала у вас будет совершенно пустой экран, без трехмерных моделей. Таким образом, мы научимся создавать собственные активы. Загрузить эту версию можно с сайта CodePlex, (прямая ссылка представлена на плитке ниже). Вы также поймете, как удалить все содержимое из Starter Kit.

Примечание для пользователей Visual Studio Express. Активы, используемые в этом проекте, можно загрузить, нажав плитку ниже. Просто добавляйте их в свой проект на соответствующих этапах.

После запуска этого приложения вы увидите заставку Starter Kit с чайником, а затем — пустой серый экран. Не волнуйтесь, мы скоро его заполним…

Создание и отображение сетки

Сначала мы создадим единственную сетку, которую мы будем использовать в этом приложении,— трехмерный куб для костей. Для этого в окне обозревателя решений Visual Studio Solution Explorer правой кнопкой мыши щелкните папку Shared/Assets (Общие/Активы) в проекте StarterKit и выберите Add -> New item… -> Graphics -> 3D Scene (.fbx) (Добавить -> Новый элемент… -> Графика -> 3D-сцена (.fbx)). Давайте назовем сцену Die.fbx. На следующем рисунке показано окно редактора сетки Visual Studio Mesh Editor:

Чтобы добавить куб, откройте панель элементов и дважды щелкните Cube. Вы можете также добавить некоторые другие простые формы, например цилиндры и чайники, и даже выполнить некоторые операции по редактированию (поворот, масштабирование и трансляция 3D-модели).

Чтобы вывести куб на экран, в нашу игру необходимо добавить код для загрузки и рендеринга сетки. В Starter Kit присутствует класс Game (Game.cpp/Game.h), который содержит логику рендеринга для нашей игры, именно сюда этот код должен быть добавлен.

Для начала загрузим сетку из файла при инициализации приложения. Добавьте следующий код в метод Game::Initialize(): 

void Game::Initialize()
 {
 Mesh::LoadFromFile(m_graphics, L"die.cmo", L"", L"", m_meshModels); 
 }

Этот код использует класс Mesh из проекта Starter Kit для загрузки модели Die из файла в вектор m_meshModels.

• Первый параметр, m_graphics, содержит экземпляр класса Graphics, в который сгруппированы все полезные объекты DirectX.
• Второй параметр — это имя файла. Файл имеет расширение .cmo, поскольку в ходе построения все активы преобразуются в более простой формат, оптимальный для режима выполнения. Откомпилированные сетки хранятся в файлах в формате CMO (Compiled Mesh Object), для шейдеров используется стандартный компилятор FX, который создает файлы в формате CSO (Compiled Shader Object), изображения (PNG, JPG и т. д.) будут преобразованы в оптимизированный для среды выполнения формат DDS (DirectDraw Surface).
• Третий и четвертый параметры содержат относительные пути к шейдерам (файлам CSO) и текстурам (файлам DDS), которые используются в этой сетке. Чаще всего подходят значения по умолчанию.
• Последний параметр — это ссылка на вектор std::vector класса Meshes, где должны храниться загруженные сетки.

Далее необходимо выполнить рендеринг куба в каждом кадре. Добавьте следующий код в метод Game::Render():

void Game::Render()
 {
 GameBase::Render();
 
 // clear
 m_d3dContext->OMSetRenderTargets(
 1,
 m_d3dRenderTargetView.GetAddressOf(),
 m_d3dDepthStencilView.Get()
 );
 
 m_d3dContext->ClearRenderTargetView(
 m_d3dRenderTargetView.Get(),
 DirectX::Colors::DarkSlateGray
 );
 
 m_d3dContext->ClearDepthStencilView(
 m_d3dDepthStencilView.Get(),
 D3D11_CLEAR_DEPTH,
 1.0f,
 0
 );
 
 XMMATRIX transform = XMMatrixIdentity(); 
 for (UINT i = 0; i < m_meshModels.size(); i++)
 {
 m_meshModels[i]->Render(m_graphics, transform);
 } 
 
 //
 // only enable MSAA if the device has enough power
 //
 if (m_d3dFeatureLevel >= D3D_FEATURE_LEVEL_10_0)
 {
 // (... MSAA code ...)
 }
 }

Этот код вызывает метод Render для каждой сетки, чтобы вывести сетку на экран. Матрица преобразования содержит преобразования (масштабирование, транслирование, вращение и т. д.), которые мы будет применять к каждой сетке. В нашем случае применяется матрица Identity, которая выполняет рендеринг объекта без каких-либо визуальных изменений.

Если вы запустите приложение прямо сейчас, то увидите куб посередине экрана:

Вам не кажется, что кубик маловат? Давайте приблизим камеру. Добавьте следующую строку в метод Game::CreateWindowSizeDependentResources(): 

m_graphics.GetCamera().SetPosition(XMFLOAT3(0.0f, 2.0f, -6.0f));

Этот метод вызывается каждый раз, когда изменяются размеры окна (например, при изменении разрешения или в режиме Snap View), поэтому здесь удобно задавать и изменять свойства камеры. Строка, в которую мы внесли изменения, устанавливает положение камеры, кроме того, можно отрегулировать поле зрения (fovAngleY в коде проекта StarterKit), тогда объекты визуально будут больше или меньше, а положение камеры не изменится.

Добавление текстуры

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

На рисунке ниже показана предлагаемая текстура. Текстуру можно загрузить отсюда.

Сначала необходимо скопировать файл в папку Assets. Вернитесь в Visual Studio, щелкните правой кнопкой мыши папку Assets, нажмите Add -> Existing item (Добавить -> Существующий элемент) и выберите изображение.

Наконец, нужно применить текстуру к кубу. Откройте сетку Die (Die.fbx) и щелкните куб. В окне инструмента Properties (сочетание клавиш: Alt+Enter) найдите свойство Texture1. Нажмите кнопку «…», чтобы выбрать изображение и применить его к кубу.

Если вы запустите приложение снова, вы увидите куб с цифрами в соответствующей позиции.

Приложение в его текущем состоянии можно загрузить с сайта CodePlex (прямая ссылка представлена на плитке ниже).

В нашей следующей статье мы расскажем, как добавить код анимации и сделать так, чтобы кубик можно было бросать! До встречи!

Dice Roller Assets.zip

Наши клиенты часто говорили о необходимости клонирования планов тестирования в процессе работы со спринтами или выпусками. Функциональность для клонирования наборов тестов с использованием командной строки (tcm.exe) уже была реализована в Visual Studio 2012, в пакете обновления VS Update 1 эти возможности были усовершенствованы, а после установки пакета VS Update 2 доступ к ним стал возможен через пользовательский интерфейс MTM.

Чтобы воспользоваться этой функцией, я открою страницу настройки свойств плана тестирования: Testing Center -> Plan -> Properties (Центр тестирования -> План -> Свойства), затем нажму кнопку Clone (Клонировать).

Предположим, я хочу клонировать план тестирования текущего спринта (sprint 1) и в дальнейшем использовать его для следующего спринта (sprint 2). Я нажимаю Clone (Клонировать), и на экране появляется диалоговое окно:

Я могу выбрать наборы для клонирования в области Clone from (Клонировать из). Если наборы не выбраны, будет создан пустой план тестирования со свойствами, аналогичными свойствам для нового плана тестирования.

Выбрав узел, вы выберете все его дочерние узлы, и, соответственно, сняв выделение с основного узла, вы отмените выбор всех дочерних. Я выбрал для клонирования все наборы, кроме Regression tests (Регрессивные тесты).

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

Для целевого плана тестирования следует указать имя, путь области и путь итерации в разделе Clone to (Клонировать в). Все тестовые случаи, которые подлежат клонированию в рамках этой операции, будут использовать те же пути области и пути итерации.

Заполнив все поля, я нажму кнопку Clone (Клонировать). Система приступит к клонированию плана тестирования, и я смогу отслеживать выполнение этой операции.

 Когда процесс завершится, статус изменится на Succeeded (Успешно выполнено), и на экране появится подробная информация для клонов, которые были созданы: продолжительность процесса, дата и время начала и завершения, общее количество тестовых случаев, общих шагов и требований и т. д.

Я могу выбрать в диалоговом окне новый план тестирования, а затем подключиться к нему. Все свойства, наборы тестов, тестовые случаи и требования плана тестирования sprint 1 были добавлены, как и было запланировано.

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

Для доступа к этой функции также предназначен пункт меню Clone (Клонировать) в Test Plan Manager: Testing Center -> Organize -> Test Plan Manager (Центр тестирования -> Упорядочить -> Диспетчер планов тестирования). Также можно щелкнуть правой кнопкой мыши корневой узел: Testing Center -> Plan -> Contents (Центр тестирования -> План -> Содержимое) и выбрать Clone (Клонировать).

Надеюсь, эти функциональные возможности помогут вам эффективнее управлять тестовыми случаями. Также вы можете ознакомиться с рекомендациями на странице MSDN или с руководством Test Release Management Guidance (Руководство по управлению тестовыми выпусками).

Сейчас я расскажу вам, как ваше приложение может воспользоваться возможностями службы расположения для предоставления пользователям информации с учетом их местоположения, которое определяется по IP-адресу, параметрам сети Wi-Fi или данным GPS. После определения местоположения вы можете предоставить эту информацию пользователю с помощью Bing Maps SDK.

Получение сведений о расположении

Пространство имен Windows.Devices.Geolocation используется для получения сведений о вашем местоположении. На выбор метода определения местоположения пользователя (GPS, Wi-Fi или IP-адрес) влияют два основных фактора:

1. Уровень требуемой точности. Оптимальный уровень точности для вашего приложения.
2. Доступность данных о местоположении. Не во все устройства встроен модуль GPS, кроме того, сеть Wi-Fi может быть недоступна, когда запрашиваются сведения о местоположении.

Требуемая точность

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

• GPS — модуль GPS обеспечивает максимальную точность, погрешность обычно составляет не более 10 метров. Однако если модуль GPS необходимо «разбудить», чтобы получить данные со спутников и провести их триангуляцию, то приложение выдаст сведения о расположении не ранее, чем через 1–2 минуты. Как только модуль GPS установит связь со спутниками, он будет быстрее определять местоположение. Разумеется, чем дольше GPS используется, тем больше энергии потребляет. Чтобы получить данные от модуля GPS, необходимо свойству Geolocator.DesiredAccuracy задать значение High.
• Wi-Fi — соединение Wi-Fi позволяет определять местоположение с точностью до 300–500 метров. При наличии подключения по Wi-Fi, данные о местоположении можно получить быстрее, чем при использовании модуля GPS, которому сначала требуется установить связь со спутниками. Установите для свойства DesiredAccuracy значение Default, если хотите получать сведения о расположении с учетом параметров соединения Wi-Fi.
• IP — IP-адрес позволяет определять местоположение с точностью до 1 км. При наличии сетевого подключения данные о местоположении можно получить быстрее, чем при использовании модуля GPS, которому сначала требуется установить связь со спутниками. Установите также для свойства DesiredAccuracy значение Default, если хотите получать сведения о расположении с учетом IP-адреса. Служба расположений старается вычислить местоположение максимально точно; достигнутая точность указывается в свойстве Geocoordinate.Accuracy.

К вопросу определения требуемой точности следует подходить со всей тщательностью. От этого зависит производительность вашего приложения и энергопотребление устройства. Например, если ваше приложение рассылает пользователям прогноз погоды, вам обычно не нужна точность на уровне GPS. Также не забудьте указать точность своих данных с помощью радиуса ошибки, рассчитанного с учетом точности возвращаемых данных. Код C# для задания требуемой точности:

C#

Geolocator geolocator = new Geolocator();
geolocator.DesiredAccuracy = Windows.Devices.Geolocation.PositionAccuracy.High;
 

Вне зависимости от требуемой точности, вызов для определения местоположения будет следующим:

C#

Geoposition pos = await geolocator.GetGeopositionAsync().AsTask(token);

Следующий код JavaScript который создает экземпляр класса Geolocator, задает требуемую точность, а затем получает сведения о текущем местоположении. Обратите внимание на то, что переменная promise представляет собой объект WinJS.Promise, вам понадобиться метод done для получения данных с использованием вызова getGeopositionAsync.

JavaScript

 var geolocator = Windows.Devices.Geolocation.Geolocator();
 geolocator.desiredAccuracy =
 Windows.Devices.Geolocation.PositionAccuracy.high;
 
 // Get the geoposition, capturing the request in a 'promise' object.
 var promise = geolocator.getGeopositionAsync();

Не забывайте о том, что когда вы задаете желаемую точность на уровне High, вы не можете быть уверены в том, что устройство пользователя сможет такую точность обеспечить. На ПК может отсутствовать модуль GPS или он может быть отключен, устройство может быть не подключено к сети Wi-Fi и т. д. Вы всегда должны быть готовы корректно обработать данные с низкой точностью. Как именно вы будете это делать, зависит от функциональных возможностей вашего приложения. Достаточно ли полученные данные точны, чтобы приложение могло продолжить свою работу? Можете ли вы запросить данные с точностью на уровне GPS? Для получения дополнительной информации см. Guidelines for location-aware apps.

Приложение Bing Maps

Bing Maps — хороший пример приложения, которое адаптируется к точности полученных данных о местоположении. На настольном ПК, который обычно не оборудован модулем GPS или Wi-Fi, оно определяет местоположение с учетом IP-адреса, при этом на экран выводится регион, в котором находится пользователь. На ноутбуке со встроенным модулем беспроводной связи приложение использует Wi-Fi, чтобы получить более точные сведения о местоположении и вывести на экран более детализированную информацию. Если пользователь хочет получить еще более точные сведения, то система отображает радиус ошибки. На устройствах, оборудованных модулем GPS, приложение Bing Maps получает максимально точные данные и выводит на экран соответствующие сведения о местоположении.

Приложение Bing Weather

Как уже упоминалось, приложениям, подобным Bing Weather, достаточно данных о регионе. Поэтому в приложении можно указать, что ему подходят данные с низкой точностью, и быстро получить сведения о местоположении. С точки зрения пользователя, быстродействие приложения повышается. Другие примеры приложений, которым, возможно, потребуются только данные о регионе: инструменты поиска радиостанций, сервисы рассылки информации о предложениях местных магазинов или местные новостные каналы.

Отображение сведений о местоположении с помощью Bing Maps SDK

Получив сведения о местоположении с помощью вызова GetGeopositionAsync, вы можете отобразить эту точку на карте.

• Для начала Geoposition необходимо преобразовать в Location, чтобы приложение Bing Maps могло работать с этой информацией. Сделать это позволяет следующий код:

C#

Location location = new Location(pos.Coordinate.Latitude, pos.Coordinate.Longitude);

JavaScript:

promise.done(
 function (pos) {
 // Get the coordinates of the current location.
 var coord = pos.coordinate,
 location = new Microsoft.Maps.Location(coord.latitude, coord.longitude);
 
 },
 function (err) {
 // Handle the error.
 });

• Затем местоположение выводится на экран в приложении Bing Maps. Пакет Bing Maps SDK можно загрузить отсюда. Вам также понадобится ключ для Bing Maps. Чтобы его получить, зарегистрируйтесь на портале Bing Maps и следуйте инструкциям: Getting a Bing Maps Key. В процессе регистрации ознакомьтесь с ограничениями для ключа каждого типа и выберите подходящий ключ для своего приложения. 
  Добавьте элемент управления Bing Maps в свой конструктор и укажите ключ в учетных данных.

<Page
 xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:local="using:SimpleMapping"
 xmlns:d="https://schemas.microsoft.com/expression/blend/2008"
 xmlns:mc="https://schemas.openxmlformats.org/markup-compatibility/2006"
 xmlns:Maps="using:Bing.Maps"
 x:Class="SimpleMapping.MainPage"
 mc:Ignorable="d">
 
 <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
 <Maps:Map x:Name="Map" Margin="0,120,0,0" Credentials="Insert Your Bing Maps Key Here"/>
 </Grid>
 </Page>

• Следующий фрагмент вы можете включить в код страницы в своем приложении, где отображается карта. Здесь настраивается масштаб карты и отображается местоположение. Подробнее о масштабе описано в статье How to display your location on a Bing Map.

C#

double zoomLevel = 13.0f;
 
Map.SetView(location, zoomLevel);

Добавить элемент управления Bing Maps в ваше приложение с использованием JavaScript и HTML немного сложнее. Добавьте следующий тег <script> в код HTML своего приложения:

<script type="text/javascript" 
 src="ms-appx:///Bing.Maps.JavaScript//js/veapicore.js">
 /script>

Затем нужно создать тег <div> с картой и задать атрибут ID, чтобы вы могли получить к нему доступ.

<div id=’map-div’></div>

Наконец, вы должны инициализировать элемент управления карты для своей HTML-страницы. Для этого используется следующий код JavaScript:

// Load the Microsoft.Maps.Map module and then call getMap when the 
 // module has loaded.
 function initMap() {
 Microsoft.Maps.loadModule('Microsoft.Maps.Map', 
 { 
 callback: getMap, 
 culture: "en", 
 homeRegion: "US" 
 });
 }
 
 // Get the div to contain the map from the interface of the app.
 function getMap() {
 
 // Create a new instance of the Map class, passing in the app ID.
 var map = new Microsoft.Maps.Map(
 document.getElementById(mapDivId), 
 { credentials: “Insert your credentials here” });
 
 // Set the initial zoom level and type of map.
 map.setView({
 mapTypeId: Microsoft.Maps.MapTypeId.road,
 zoom: 3
 });
 }

• Кроме того, любое приложение, использующее сведения о расположении, должно учитывать установленные пользователем разрешения, которые могут измениться в любой момент. Приложение Weather использует данные о местоположении, чтобы вывести на экран актуальный прогноз погоды. Но пользователь всегда может зайти в настройки и отключить функцию определения местоположения, и ваше приложение должно учитывать такую возможность. В этом случае приложение Weather должно вывести на экран соответствующее предупреждение, например: «Ваше местоположение не может быть определено. Необходимо разрешить приложению Weather определять ваше местоположение». Рекомендации по поводу работы с пользовательскими настройками при определении местоположения см. в документе Guidelines for location-aware apps (Руководство по разработке приложений, учитывающих географическое положение).  

Функции определения географического положения и использования Bing Maps SDK подробнее рассматриваются в видео, руководствах и примере кода. Там вы найдете пошаговые инструкции для асинхронного получения сведений о расположении с последующей визуализацией этой информации с помощью Bing Maps SDK. Вы узнаете, как активировать функцию определения местоположения, асинхронно получить соответствующие сведения, вывести требуемый участок карты и настроить значок местоположения с учетом точности полученных данных. Дополнительная информация также представлена на странице Bing Maps for Windows Store Apps (Bing Maps и приложения для Магазина Windows).

Упаковка

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

Автор: Росс Хейзе (Ross Heise), старший разработчик контента, Windows Developer Content

Выражаю особую благодарность Джону Кею (Jon Kay) и Эрику Шмидту (Eric Schmidt) за помощь в подготовке этой статьи.

Как сделать нативное приложение более быстрым

Традиционные компиляторы работают с оптимизацией на основе статических исходных файлов. Они анализируют текст исходного файла, но не принимают в расчет данные, вводимые пользователями, о которых просто невозможно знать из кода. Рассмотрим этот псевдокод:


При работе с функцией whichBranchIsTaken компилятор не знает, как часто параметр «a» будет меньше параметра «b», и сколько раз будет применено условие «if» (т. е. компилятор не может предсказывать ветвления). При работе с функциями девиртуализации и switchCaseExpansion компилятор знает недостаточно о значениях *p и i, что делает невозможным оптимизацию девиртуализации и расширений параметров. Эти проблемы проявятся еще ярче, если мы подставим данный фрагмент кода в разные модули (например, разные объектные файлы), поскольку функции традиционной компиляции не могут быть оптимизированы для работы в пределах исходных модулей.
Базовая модель компилятора и компоновщика не так уж и плоха, но в ней недостает двух основных возможностей для оптимизации. Во-первых, в ней не используется информация, которую можно было бы получить на основе анализа всех исходных файлов (традиционные компиляторы оптимизируют только отдельные объектные файлы). Во-вторых, в ней не проводится оптимизация на базе ожидаемой или профильной реакции приложения. Первый недостаток может быть исправлен с помощью переключателя компилятора (/GL) или переключателя компоновщика (/LTCG), выполняющего полную оптимизацию программы и необходимого для профильной оптимизации приложения. После того, как оптимизация полной программы включена, вы можете применять профильную оптимизацию. Остановимся на ней подробнее.
PGO – это процесс оптимизации компилятора в среде выполнения, применяющий данные профиля, собранные в ходе выполнения важных или требующих высокой производительности пользовательских сценариев, с целью оптимизации приложения. Профильная оптимизация обладает рядом преимуществ по сравнению с традиционной статической оптимизацией, поскольку она принимает в расчет, как будет себя вести приложение в рабочей среде. Благодаря этому оптимизатор может осуществлять оптимизацию по скорости (для частых пользовательских сценариев) или оптимизацию по размеру (для редких сценариев). В результате код становится более лаконичным, что, в конечном счете, повышает производительность приложения.



В настоящее время PGO может применяться только на классических приложениях для настольных компьютеров и поддерживается на платформах x86 и х64. PGO представляет собой процесс, состоящий из трех этапов, как это показано на рисунке выше.

• Первый этап обычно называют фазой инструментирования. В ходе этой фазы идет сборка приложения с заданным набором флагов компиляции. В процессе сборки внутренний компилятор добавляет в созданный код пробные инструкции (зонды), которые используются для записи данных обучения, необходимых на следующем этапе. Всего добавляется три типа зондов (входа в функцию, перехода и значений). Зонд входа в функцию измеряет, как часто запрашивалась та или иная функция. Зонд перехода позволяет узнать, сколько раз была достигнута та или иная ветвь кода. Таким образом в ходе фазы обучения компилятор получает информацию о том, как часто «a > b» в фрагменте кода whichBranchisTaken в заданном сценарии обучения. Зонд значений позволяет получить данные для построения гистограммы значений. Например, зонд значений, добавленный в фрагмент кода switchCaseExpansion, позволит получить данные для построения гистограммы значений для переменной индекса switch case i. Получив в ходе обучения информацию о том, какие значения будет принимать переменная «i», компилятор сможет провести оптимизацию для наиболее частых значений, а также таких функций как switchCaseExpansion. Таким образом, по окончании фазы у нас будет инструментированная версия приложения (с зондами) и пустой файл базы данных (.pgd), в которую будет заноситься информация, полученная в ходе следующей фазы.
• Фаза обучения . В ходе этой фазы пользователь запускает инструментированную версию приложения и проигрывает стандартные пользовательские сценарии, требующие высокой производительности. На выходе мы имеем файлы .pgc, содержащие информацию, связанную с различными пользовательскими сценариями. В процессе обучения информация проходит через зонды, добавленные в ходе первой фазы. На выходе мы получаем pgc-файлы appname!# (где appname соответствует названию приложения, а # — единице плюс числу pgc-файлов appname!# в выходном каталоге построения).
• Последняя фаза PGO — оптимизация. В ходе этой фазы создается оптимизированная версия приложения. Помимо этого, информация из pgc-файлов, полученная в ходе фазы обучения, вносится в фоновом режиме в базу данных (файл .pgd), созданную в ходе инструментирования. Внутренний компилятор затем использует эту базу данных для последующей оптимизации кода и построения еще более совершенной версии приложения.

Пользователи PGO зачастую ошибочно считают, что все три фазы (инструментирование, обучение и оптимизация) должны проводиться каждый раз при построении проекта. На самом деле, первые две фазы могут быть исключены при построении последующих версий, а код при этом может претерпевать значительные изменения по сравнению с версией, полученной после фазы обучения приложения. В больших коллективах один разработчик может отвечать за проведение PGO и поддержку базы данных обучения (.pgd) в репозитории исходного кода. Другие разработчики могут синхронизировать свои репозитарии кода с этой базой и использовать файлы обучения для построения PGO-оптимизированных версий приложений. После определенного количества перекомпиляций приложение будет окончательно оптимизировано.

Применение профильной оптимизации

Теперь, когда мы знаем немного больше о профильной оптимизации, рассмотрим ее применение на конкретном примере. Профильную оптимизацию приложения можно осуществлять с помощью Visual Studio или командной строки разработчика. Ниже рассмотрен пример работы в Visual Studio с приложением под условным названием «Nbody Simulation». Если вы хотите узнать больше о PGO в командной строке, обратитесь к этим статьям. Для начала работы загрузите решение в Visual Studio и выберите конфигурацию построения для работы (т.е. «Release»).



Как было упомянуто выше, PGO состоит из трех этапов: инструментирования, обучения и оптимизации. Для создания инструментированной версии приложения, нажмите правой кнопкой мыши по названию проекта («NBodyGravityCPU») и выберите раздел «Instrument» в меню «Profile Guided Optimization».



В Visual Studio будет построена инструментированная версия приложения. После этого можно переходить к фазе обучения. Запустите инструментированную версию приложения. Для этого зайдите в меню «Profile Guided Optimization» и выберите «Run Instrumented/Optimized Application». В нашем случае приложение выполняется с максимально большим телом кода (15360), т. к. будет реализован стабильный пользовательский сценарий, требующий высокой производительности. После того как два основных показателя производительности приложения — FPS (кадров в секунду) и GFlop – примут устойчивые значения, вы можете закрыть приложение. На этом фаза обучения будет завершена, а полученные данные будут сохранены в файле .pgc. По умолчанию файл .pgc будет включен в вашу конфигурацию построения, т.е. каталог «Release». Например, в результате этого обучения создается файл NBodyGravityCPU!1.pgc.



NBody Simulation представляет собой очень простое приложение, созданное исключительно для иллюстрации процесса PGO. В действительности может существовать множество вариантов сценариев обучения приложений. В частности, можно производить обучение в несколько этапов, разделенных по времени. Для записи таких сценариев обучения лучше всего использовать команду pgosweep в командной строке разработчика после того, как инструментированная версия уже создана (напр., в Visual Studio).



В ходе последней фазы PGO создается оптимизированная версия приложения. В меню «Profile Guided Optimization» выберите «Optimize». Будет создана оптимизированная версия приложения. В выходном журнале PGO-построения вы увидите обобщенную информацию о проведенной операции.
Как было сказано выше, информация из файлов .pgc, полученная в ходе фазы обучения, включается в базу данных .pgd, которая затем используется матрицей оптимизации внутреннего компилятора. В большинстве случаев (за исключением небольших быстрых приложений) критерий оптимизации скорость/размер определяется соотношением динамических инструкций для определенной функции. Функции с большим числом инструкций (т. н. «горячие») оптимизируются на скорость, а с малым количеством инструкций (т. н. «холодные») – на размер.
Это практически все, что вам необходимо для того чтобы начать профильную оптимизацию в ваших приложениях. Попробуйте применить PGO для своих приложений и оцените результаты! И обязательно загляните в блог Инструменты для разработчика, возможно вы найдете там еще какие либо интересные решения! 
Автор поста — Анкит Астхана (Ankit Asthana) — руководитель программы по внутреннему компилятору Microsoft Visual С++.

Брайан уже рассказал о присоединении к списку SharePoint и моделировании его объектов в приложении LightSwitch с поддержкой SharePoint. Однако это еще не все — вы можете выполнить присоединение к локальному сайту SharePoint в любом приложении LightSwitch, указав имя пользователя и пароль или же выступив в роли пользователя приложения LightSwitch. Имя пользователя и пароль нужны для ограничения доступа к списку, чтобы им могло пользоваться только ваше приложение LightSwitch.

Включив поддержку SharePoint в вашем приложении LightSwitch, вы тем самым указываете LightSwitch, что приложение должно быть развернуто на SharePoint и что оно может работать с ресурсами SharePoint. Поддержка включается в SharePoint на странице Properties (Свойства):

Если указать сайт Office 365 в качестве целевого, то можно делать присоединение к спискам на сайте Office 365, однако для этого нужно будет разрешить LightSwitch выбор идентификационной информации пользователя. В среде выполнения этим пользователем будет тот, кто запустил приложение в SharePoint. Как правило, в ходе отладки вы запускаете приложения с вашей личной или тестовой учетной записью. Поэтому если при попытке присоединения к списку в Office 365 появляется сообщение об ошибке с текстом наподобие «[…] does not appear to be a valid site. SharePoint 2010 (or later) with an installation of WCF Data Services is required» («сайт […] недействителен. Требуется SharePoint 2010 или более поздняя версия с установленными службами WCF Data Services»), причины, скорее всего, будут следующие: отключена поддержка SharePoint, отключен автоматический выбор идентификационной информации или же вы пытаетесь сделать присоединение к другому сайту, который не указан в свойствах SharePoint. Если вы разворачиваете приложение на конкретном сайте Office 365, то он является единственным сайтом Office 365, к которому можно делать присоединение в LightSwitch.

Итак, каковы же преимущества использования списков SharePoint в качестве объектов? Теперь можно обращаться с данными списка точно так же, как с любым другим источником данных LightSwitch, включая использование собственного программного кода для обработки сохранения данных. Давайте возьмем пример Брайана и внесем в него кое-какие изменения после добавления списка покупателей к сайту. В компанию может позвонить клиент, с которым уже общался один из наших агентов по продажам. Нам нужна возможность перенаправления вызова к тому же самому агенту, поскольку он в курсе текущей ситуации с клиентом и ему будет проще выстроить разговор. Давайте слегка изменим этот список. Щелкните заголовок приложения Customers (Клиенты), затем нажмите Edit this list (Правка списка):

Нажмите на символ плюса, чтобы добавить столбец, затем выберите Date or Time (Дата или время):

Назовите этот столбец Last Contact Date (Дата последнего контакта). Затем добавьте еще один столбец, в этот раз он будет иметь тип String (Строка) и имя Last Contact Person (Последнее контактное лицо). Ваш список должен выглядеть так:

Затем выберите Stop editing this list (Прекратить правку списка). Вернитесь в LightSwitch, и если сайт SharePoint уже добавлен вами в качестве источника данных, щелкните его правой кнопкой мыши и выберите Update Datasource (Обновить источник данных).

Затем просто нажмите Finish (Готово). После этого вы можете открыть объект Customer (Клиент) и увидите новые поля.

Пока мы находимся в этом окне, самое время присвоить общему свойству Customer значение FirstName (Имя), если вы еще не сделали этого. В результате LightSwitch будет отображать имя клиента в общем представлении, которое используется по умолчанию при открытии нового окна. Чтобы изменить представление, сначала нажмите кнопку «Клиент».

Раз уж мы отслеживаем звонки наших клиентов, давайте составим таблицу для этого. Моя выглядит примерно так.

Вот, я создал новую таблицу с именем CustomerCall, а затем добавил отношение, которое связало ее со списком Customer (Клиент).

Затем я добавил несколько дополнительных полей. Type (Тип) — это список выбора с параметрами Refund (Возмещение), Purchase (Покупка), Quote (Предложение с расценками) и Other (Другое).

Я также добавил поле ContactPerson для хранения сведений о сотруднике, который общался с клиентом, и поле Notes (Примечания) для хранения общих сведений. Придумаем простой интерфейс для этого окна, оставив окно Browse (Просмотр) для отображения данных CustomerCalls и добавив кнопку AddAndEditNew для перехода к диалоговому окну AddEditCustomerCall.

Ничего нового для вас здесь нет, но давайте снова откроем объект CustomerCall и напишем пару строк кода. Нажмите кнопку с раскрывающимся списком Write Code (Написать код) в верхней части средства Data Designer и выберите метод Inserting (Вставка).

Затем можно добавить следующий код:

(C#)

partial void CustomerCalls_Inserting(CustomerCall entity) 
{ 
  entity.Customer.LastContactDate = DateTime.Now; 
  entity.Customer.LastContactPerson = entity.ContactPerson; 
  ServerApplicationContext.Current.DataWorkspace.SharePoint_SiteData.SaveChanges(); 
}

(Visual Basic)

Private Sub CustomerCalls_Inserting(entity As CustomerCall)
 entity.Customer.LastContactDate = DateTime.Now
 entity.Customer.LastContactPerson = entity.ContactPerson
 ServerApplicationContext.Current.DataWorkspace.SharePoint_SiteData.SaveChanges()
End Sub

Обратите внимание, что выделенную часть необходимо изменить так, чтобы она совпадала с именами ваших источников данных.

Теперь можно нажать F5 для сборки проекта и ввести сведения о первом звонке клиента.

Затем, если вернуться обратно к списку Customer (Клиент), можно увидеть примерно следующее.

Пример весьма прост, однако приятно видеть, что со списками SharePoint можно работать почти так же как с любыми другими типами объектов LightSwitch. Чуть позже мы продолжим работу с этими списками.

Действие над списками при помощи CSOM

Предположим, вы всегда выбираете сложный путь. Если вам необходимо управление всеми аспектами взаимодействия LightSwitch с SharePoint, можно использовать SharePoint Client-Side Object Model (CSOM, модель объекта SharePoint на стороне клиента). Один из возможных сценариев ее использования — разработка приложения LightSwitch с поддержкой SharePoint. В этом случае вы сможете добавлять списки SharePoint к вашим проектам, однако LightSwitch не сможет подключиться к ним, поскольку эти списки не существуют до момента установки приложения на сайте SharePoint.

Возвращаясь к доработке приложения Брайана, мы видим, что у этого приложения уже есть окна Browse (Просмотр) и Edit Customer (Правка сведений о клиенте). Сведения о клиенте конфиденциальны, поэтому мы не будем проводить аудит вносимых в них изменений. Давайте добавим список в наш проект SharePoint для сбора этих сведений.

Возможно, предлагаемый способ окажется для вас неудобным. Списки, которые вы добавляете в проект SharePoint, принадлежат веб-приложению. Это значит, что они создаются в момент установки приложения LightSwitch и удаляются при удалении приложения, что приводит к потере всех данных. Для списка Customers (Клиенты) действует другой механизм работы, поскольку этот список относится к веб-узлу и не связан с конкретным приложением. В сети MSDN есть дополнительные сведения о веб-узлах, веб-приложениях и компонентах SharePoint в SharePoint 2013.

Однако это лишь пример, нас сейчас не волнует вечное хранение этих данных. Перейдите к представлению файла в обозревателе проектов, щелкните правой кнопкой мыши ваш проект SharePoint и выберите Add –> New Item (Добавить –> Новый элемент).

Здесь по умолчанию необходимо выбрать List (Список); назовите его AuditEntry и нажмите Add (Добавить). В следующем окне LightSwitch попросит выбрать тип списка. Журнал аудита не входит в типы по умолчанию, поэтому оставьте значение Default (Custom List) (По умолчанию (Настраиваемый список)), и мы настроим его самостоятельно.

Теперь нужно разработать столбцы списка. В него следует добавить числовое поле для параметра Customer ID (Идентификатор клиента), который указывает на изменяемые нами сведения о клиенте, текстовое поле с именем пользователя, вносящего изменения, поле с датой внесения изменений и текстовое поле с описанием выполненного действия.

Если вы попытаетесь обновить источник данных SharePoint прямо сейчас, то не увидите этого списка. Причина состоит в том, что это список не существует на сайте до тех пор, пока проект не будет собран нажатием клавиши F5 или не будет развернут из опубликованного пакета приложения SharePoint. Однако работать с CSOM можно и без этого! Откройте объект Customer (Клиент) и напишите код для метода обновления.

Заполните ваш класс SharePoint_SiteDataService (имя может быть любым) следующим образом:

(C#)

using Microsoft.SharePoint.Client;

public partial class SharePoint_SiteDataService 
{ 
  partial void Customers_Updating(Customer entity) 
  { 
    LogAuditEntry(entity, "Обновить"); 
  }

  partial void Customers_Deleting(Customer entity) 
  { 
    LogAuditEntry(entity, "Удалить"); 
  }

  private void LogAuditEntry(Customer entity, string actionDescription) 
  { 
    using (ClientContext ctx = Application.SharePoint.GetAppWebClientContext()) 
    { 
      Web web = ctx.Web; 
      ListCollection lists = web.Lists; 
      List auditLog = lists.GetByTitle("Запись аудита"); 
      ListItemCreationInformation ci = new ListItemCreationInformation(); 
      ListItem auditEntry = auditLog.AddItem(ci); 
      auditEntry["Название"] = "Запись аудита"; 
      auditEntry["ИД клиента 1"] = entity.Id; 
      auditEntry["Пользователь1"] = Application.User.FullName; 
      auditEntry["Дата1"] = DateTime.Now; 
      auditEntry["Действие"] = actionDescription; 
      auditEntry.Update(); 
      ctx.ExecuteQuery(); 
    } 
  } 
}

(Visual Basic)

Imports Microsoft.SharePoint.Client


Public Class SharePoint_SiteDataService
 Private Sub Customers_Updating(entity As Customer)
 LogAuditEntry(entity, "Обновить")
 End Sub

 Private Sub Customers_Deleting(entity As Customer)
 LogAuditEntry(entity, "Удалить")
 End Sub

 Private Sub LogAuditEntry(entity As Customer, actionDescription As String)
 Using ctx As ClientContext = Application.SharePoint.GetAppWebClientContext()
 Dim web As Web = ctx.Web
 Dim lists As ListCollection = Web.Lists
 Dim auditLog As List = lists.GetByTitle("Запись аудита")
 Dim ci As New ListItemCreationInformation()
 Dim auditEntry As ListItem = auditLog.AddItem(ci)
 

 auditEntry("Название") = "Запись аудита"
 auditEntry("ИД клиента1") = entity.Id
 auditEntry("Пользователь1") = Application.User.FullName
 auditEntry("Дата 1") = DateTime.Now
 auditEntry("Действие") = actionDescription
 
 auditEntry.Update()
 ctx.ExecuteQuery()
 End Using
 End Sub
End Class

Теперь снова соберите проект нажатием клавиши F5 и внесите изменения в сведения о клиенте, которые будут записаны в список, добавленный к проекту. Когда вы нажали F5, LightSwitch развернул ваш проект на SharePoint, а также создал элементы, добавленные вами в проект SharePoint. Итак, где же находится этот список? Возьмите URL-адрес вашего сайта SharePoint, включая имя коллекции сайтов разработчика (при наличии), затем добавьте к нему имя вашего приложения и строку “/Lists/AuditEntry”. Вот моя строка: https://example.sharepoint.com/sites/Developer/ListAttachDemo/Lists/AuditEntry. Результат будет выглядеть так.

Теперь мы можем использовать списки, которые не привязаны к LightSwitch. Вы также могли заметить, что мною нарушено единообразие имен столбцов для записи со списком (User1 и просто Action). На этом стоит остановиться подробнее, ведь даже я не сразу понял причину этого явления. SharePoint иногда отображает не совсем верное имя столбца в конструкторе списков и на веб-сайте. Если в качестве имени столбца указать строку, которую SharePoint сочтет именем типа или иным зарезервированным словом, то для снятия неоднозначности к этой строке будет добавлено число. Как же узнать настоящее имя столбца? Я использую следующий код:

(C#)

using (ClientContext ctx = Application.SharePoint.GetAppWebClientContext()) 
{ 
  Web web = ctx.Web; 
  ListCollection lists = web.Lists; 
  List auditLog = lists.GetByTitle("AuditEntry"); 
  ctx.Load(auditLog.Fields); 
  ctx.ExecuteQuery(); 
}

(Visual Basic)

Using ctx As ClientContext = Application.SharePoint.GetAppWebClientContext()
 Dim web As Web = ctx.Web
 Dim lists As ListCollection = Web.Lists
 Dim auditLog As List = lists.GetByTitle("AuditEntry")

 ctx.Load(auditLog.Fields)
 ctx.ExecuteQuery()
End Using

После этого кода можно поставить точку останова и посмотреть содержимое поля auditLog.Fields, чтобы увидеть настоящие имена столбцов SharePoint. Это первый прием, которым я воспользуюсь в случае возникновения ошибки наподобие Column <ColumnName> does not exist. It may have been deleted by another user (Столбец <ColumnName> не существует. Он мог быть удален другим пользователем).

С помощью CSOM можно делать множество интересных вещей, некоторые из них приведены на справочной странице MSDN. Например, при помощи CSOM можно добавлять и изменять списки, решать задачи администрирования сайта, передавать документы на сайт, управлять группами и пользователями. Если вас интересует какая-то отдельная тема, напишите мне, и я подумаю над тем, чтобы черкнуть о ней пару строк.