Блог Сергея Байдачного

Мой блог о технологиях

Archive for the ‘.NET Development’ Category

Язык программирования C# (часть 2)

10 комментариев

Опубликовал вторую часть:

http://www.microsoftvirtualacademy.com/training-courses/csharp_part_2

 

Теперь Маргарите будет задание по публикации еще трех лекций:

— Интеграция с неуправляемым кодом

— Шифрование данных

— Новые возможности в C# 5.0

А то она три недели отдыхала.

 

А я займусь подготовкой к публикации курса по WP 8.1.

Written by Sergiy Baydachnyy

28.08.2014 at 14:46

Опубликовано в .NET Development

Tagged with

UNETA+ — всем сюда!

leave a comment »

Очень удивляет и радует конференция, организуемая сообществом .NET разработчиков в городе Харькове. Им удалось собрать неимоверное количество русскоязычных докладчиков со всего мира. При этом, сюда приедут как уже известные в Украине докладчики (например, Дмитрий Никонов), так и свежие силы в виде Вячеслава Красовского, Владимира Юнева и др.

Очень хорошо знаю, что на такие жесткие технические конференции кого-то из-за рубежа притащить очень тяжело (в отличие от конференций ни о чем, где люди сами себя пиарят). Ведь это те самые люди, которые разрабатывают Azure, SQL Server и расширения для Windows Phone и работы у них много. Их даже в Киев тяжело вывезти, имея связи в Майкрософт.

В общем, идти всем! Регистрация доступна тут http://uneta.ua/.

Written by Sergiy Baydachnyy

01.09.2011 at 08:56

Опубликовано в .NET Development, Microsoft

Tagged with

Зарисовки по JavaScript для .NET разработчиков: Объектно-ориентированное программирование

4 комментария

Немного мыслей

Недавно Виктор Шатохин пообещал много денег за .NET разработчика, знающего JavaScript. Я мысленно стал перебирать всех знакомых разработчиков с хорошим знанием .NET, и пришел к выводу, что они не соответствуют второму критерию (JavaScript). Не любим мы это дело. Язык кажется для нас примитивным и не стоящим внимания настоящего ООП программиста. А если добавить отсутствие хороших редакторов, проблемы с несовместимостью возможностей различных окружений JavaScript и невозможность защитить свою интеллектуальную собственность (ведь Ваш код легко можно скопировать), то тут же хочется плеваться от отвращения.

На самом деле многие тезисы, которые я изложил выше, могут быть и не верны, но именно такое понимание обычно формируется у .NET разработчиков. И это понимание я неоднократно высказывал. А ведь программировать на JavaScript мне практически и не довелось (как и многим из нас). Самое интересное то, что когда я высказывал свое мнение по этому поводу, никто даже не пытался мне сказать что-то противоположное. А на вопрос «кто любит JavaScript» обычно поднималось одна-две руки из зала.

Откуда же берется понимание о «недостойности» JavaScript? Я попробовал проанализировать эту проблему и пришел к выводу, что мнение формируется только на основе того кода, который мы видим на существующих сайтах. Кода, который, может быть и не всегда, написан верно. Я даже возьму на себя смелость заявить, что в большинстве случаев – совсем не верно. Но этот код формирует мнение.

А ведь я уже попадал в такую ловушку, еще во время моей учебы в университете, на факультете была очень популярна среда программирования Delphi. Используя эту среду, приложения мог разрабатывать любой (извините) идиот. Ведь в те далекие времена Visual Studio не предлагал визуальную среду разработки, а .NET Framework еще не существовал. Поэтому Delphi был отличной альтернативой для студентов, не сумевших освоить ООП, но владеющий мышкой. Приложения, которые сдавались, удивляли своей «правильностью». Данные часто хранились прямо в элементах управления, а о каких-то подходах ООП нельзя было и говорить. Естественно, в те далекие времена я писал код на С++, а Delphi вызывала лишь улыбку. Немного позже я узнал, что на Delphi можно писать отличные приложения и имеется множество коммерческих продуктов. Вот только сначала нужно получить знания по продукту, а потом приступать к разработке.

Именно поэтому в JavaScript я решил разобраться более детально, и был сильно удивлен. Так, еще три дня назад, я был уверен в том, что этот язык не заслуживает моего внимания, а сегодня я уверен в противоположном. JavaScript можно использовать для написания серьезных приложений. Другое дело, что для формирования альтернативного мнения мне пришлось прочитать четыре различных книги, посвященных JavaScript. Попутно я обнаружил, что ни одна книга не описывает все возможности языка, а иногда та или иная книга представляет какой-то из шаблонов (не всегда хороший), как единственно возможный. Но, пользуясь тем, что я все же ООП программист, мне удалось понять JavaScript настолько, чтобы сделать вывод: JavaScript – объектно-ориентированный язык программирования.

Мне еще предстоит разобраться с взаимодействием JavaScript с тем или иным окружение, с возможностями различных библиотек, а также определить список того, что из ECMA 5 уже поддерживается в IE9/10 и других браузерах, но это уже технические детали, а ниже я постараюсь изложить свою позицию, которая подтолкнула меня к изучению дополнительного материала по этому языку.

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

Зачем

Прежде чем перейти к ООП возможностям JavaScript давайте ответим на вопрос «Зачем?». Ведь сегодня JavaScript преимущественно используется для клиентских сценариев, где окружением выступает браузер. На самом деле JavaScript не зависит от платформы и не привязан к окружению. Иными словами, окружение «браузер» может заменять любое другое окружение, например «веб-сервер» или «операционная система». И сегодня уже есть множество разработок, позволяющих запускать JavaScript на серверной стороне. В то же время отсутствие привязки JavaScript к определенному производителю средств разработки, делает этот язык практически неуязвимым, ведь стратегия у отдельной компании могут меняться, а, следовательно, меняться и технологии.

Если же говорить о сегодняшних .NET и JavaScript разработчиках, то последних вряд ли можно убедить перейти на .NET, да и хлопотно это (много нового нужно учить). А вот .NET разработчику можно без труда освоить JavaScript, зная идеологию ООП. При этом у .NET разработчика больше шансов использовать «правильный» JavaScript, так как способ мышления давно уже сложился.

Этим я никоим образом не хочу обидеть JavaScript разработчиков и хочу отметить, что некоторые вещи (верстка, подходы при дизайне веб-интерфейсов и др.) .NET разработчикам не под силу. Но при разработке сложных приложений ООП разработчик имеет преимущество. А если к знаниям .NET прибавить и знание JavaScript, то это только повышает стоимость (с точки зрения зарплаты) такого специалиста. Поэтому ответ на вопрос «Зачем?» — больше возможностей, а, следовательно, большая заработная плата. (Если бы я знал такого разработчика, то уже бы смог заработатьJ)

Именно поэтому я решил окунуться в JavaScript и взглянуть на него с позиции .NET разработчика, чтобы попытаться понять, правильно ли я размышляю, так как совсем недавно я был не прав (опять же по моему мнению).

Переменные и функции

Изучая JavaScript я начал вспоминать С++, где вполне уживались классы, объекты этих классов и глобальные функции с переменными. В JavaScript похожая история, так тут имеют место глобальные переменные и функции. Причем код такого типа очень распространен в Веб (по крайней мере, на украинских веб-сайтах). Вот Вам и создание переменной, и определение функции, и вызов функции:

 

   1:  var val1 = "Hello";
   2:   
   3:  function SayHello() {
   4:     alert(val1);
   5:  }
   6:   
   7:  SayHello();

 

Какая гадость.

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

 

   1:  var val1 = "Hello";
   2:   
   3:  function SayHello() {
   4:     alert(window.val1);
   5:     //или
   6:     alert(window["val1"]);
   7:  }
   8:   
   9:  SayHello();

 

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

Но вернемся к переменным, так как правила определения переменных нам понадобятся ниже. Как видно из кода выше, переменные определяются с помощью ключевого слова var. Если Вы определяете переменную внутри функции, то у нее область видимости вся функция, в противном случае это глобальная область видимости. Обращаю Ваше внимание на то, что если Вы что-то определяете без var, то оно попадает в глобальную область. Я не случайно написал «что-то» и «оно», поскольку в данном случае Вы объявили бы не переменную, а свойство – свойство глобального объекта, о чем мы поговорим в следующем блоке.

Нужно обратить внимание на то, что в JavaScript нет области видимости внутри блока, то есть переменную можно использовать внутри всей функции сразу после инициализации, независимо от блоков. Дурацкий пример, но работает:

 

   1:  function SayHello(i) {
   2:   
   3:  if (i>3)
   4:  {
   5:     var sHello="Hello";
   6:  }
   7:  alert(sHello);
   8:  }
   9:   
  10:  SayHello(4);

 

Переменной легко можно присваивать ссылку на функцию и использовать ее в дальнейшем:

 

   1:  var f1 = (function SayHello(i) {
   2:     if (i > 3) {
   3:     var sHello = "Hello";
   4:     }
   5:     alert(sHello);
   6:  });
   7:   
   8:  //или
   9:   
  10:  var f2 = f1;
  11:   
  12:  f1(4);
  13:  f2(5);

 

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

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

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

 

   1:  function generate(initialVal) {
   2:     return (function (mulVal) {
   3:        return initialVal * mulVal;
   4:     });
   5:  }
   6:   
   7:  var res = generate(2);
   8:  alert(res(2)); //4
   9:  alert(res(4)); //8

 

Последний пример немного интереснее? Как Вы видите, мы возвращаем ссылку на вложенную функцию, которая использует параметр, передаваемый родительской функции. Дальше мы рассмотрим еще несколько примеров и все станет ясно.

Рассмотрев несколько примеров с функциями, перейдем к ООП.

Создание объектов и инкапсуляция

Основными понятиями в ООП являются классы и объекты. Так вот, в JavaScript классов нет. Вы конструируете готовые объекты. Сказать, что это не правильно я не могу, так как в жизни именно так все и происходит: «Вы конструируете объект, а иногда прототип, из составных частей». Просто так, по описанию, ничего не происходит. Это только Бог сотворил Землю из хаоса. Видимо он использовал С++. Ну а мы, смертные,…

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

 

   1:  var obj1 = {};
   2:   
   3:  //или
   4:   
   5:  var obj2 = new Object();

 

Далее объект можно наполнить содержимым (функциями и свойствами). Это можно сделать в любой момент времени, расширяя объект по своему усмотрению:

 

   1:  var obj1 = {};
   2:   
   3:  obj1.val1 = "Hello";
   4:   
   5:  obj1.SayHello = (function () { return this.val1; });
   6:   
   7:  alert(obj1.SayHello());

 

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

Добавив свойство или функцию (теперь уже метод) к объекту, их можно удалить в любой момент:

 

   1:  delete obj1.val1;
   2:   
   3:  delete obj1.SayHello;

 

Причем это также логично. Представьте себе, что Вы создали класс «Человек», наклепали конкретные объекты, а потом появилось устройство «мобильный телефон» и Вы хотите его добавить в класс. А ведь уже поздно, поезд уехал. Между прочим завтра, может понадобится убрать свойство «мобильный телефон» и сразу вживить чип в голову (то есть изрядно покопаться в объектах). В С++ Вы можете пытаться сделать универсальный мега-класс, предусматривающий все возможности. Но последнее (предусмотреть) не всегда получается. А в JavaScript раз и готово.

Все это здорово до тех пор, пока у нас создаются разные объекты. А что же делать, если мы решили заселить Землю людьми. Нужно ли нам дублировать код каждый раз? И вот тут на помощь приходят функции. Как я писал выше, функции также представляют собой объекты. Вот пример функции, к которой мы добавили свойство и другую функцию:

 

   1:  function testF() {
   2:   
   3:  }
   4:   
   5:  testF.val1 = "Hello";
   6:   
   7:  testF.SayHello = (function () { return "Hello" });
   8:   
   9:  alert(testF.SayHello());

 

Особенность функции состоит в том, что к ней можно применить оператор new, который позволит создать новый объект по образу и подобию функции. Таким образом получается, что если мы определим функцию Human и наполним ее кодом, добавляющим к новому объекту данные и другие функции (методы), то получим функцию-конструктор. Вот оно, ООП!!! Рассмотрим пример:

 

   1:  function Human(firstName, lastName) {
   2:   
   3:     this.getFirstName = (function () { return firstName; });
   4:     this.getLastName = (function () { return lastName; });
   5:   
   6:     this.Age = 33;
   7:   
   8:     this.Name = (function () { return this.getFirstName() + " " + this.getLastName(); });
   9:   
  10:     Human.CopyHuman = (function (h) { return new Human(h.getFirstName(), h.getLastName()); });
  11:  }
  12:   
  13:  var h = new Human("Sergiy", "Baydachnyy");
  14:   
  15:  alert(h.Name());
  16:   
  17:  var hCopy = Human.CopyHuman(h);
  18:   
  19:  alert(hCopy.Name());

 

Ну посмотрите, чем не класс (особенно для C# разработчиков, где весь код находится внутри класса)? Тут мы с Вами объявили функцию Human, где, использовав замыкание, создали два метода для чтения переменных, передаваемых функции при инициализации объекта (О!), затем объявили поле с данным, почему-то присвоив ему значение 33, создали еще один метод, который использовал уже созданные нами функции. В завершении всего, мы создали «статическую» функцию, которая предназначена для копирования объектов и может быть доступна через имя нашей функции-конструктора («класса»).

При этом к созданным объектам можно добавить новые данные и методы (или удалить существующие).

Таким образом, мы не просто добились эмуляции классов, но и расширили эту возможность.

На самом деле вариант выше не идеален. Дело в том, что используя this, мы добавили все наши методы к каждому объекту, сожрав какое-то количество памяти. В JavaScript можно поступить более экономно, используя специальное свойство prototype. Последнее является ссылкой на объект-прототип для всех порожденных объектов типа Human и позволяет сделать наши функции общими для всех объектов:

 

   1:  function Human(firstName, lastName) {
   2:     this.getFirstName = (function () { return firstName; });
   3:     this.getLastName = (function () { return lastName; });
   4:   
   5:     Human.prototype.Age = 33;
   6:   
   7:     Human.prototype.Name = (function () { return this.getFirstName() + " " + this.getLastName(); });
   8:   
   9:     Human.CopyHuman = (function (h) { return new Human(h.getFirstName(), h.getLastName()); });
  10:  }

 

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

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

Human.prototype.inn = 0;

Хочешь узнать реальный код, приходи в налоговую и получи справкуJ Все как в реальной жизни! А С++ так не может.

Многие разработчики определяют функцию-конструктор пустым, а затем записывают код, который добавляет методы к прототипу. Я не считаю такой подход правильным, так как он выпадает из привычного мне ООП стиля (все определяем в классе). Код получается разбросанный по разным местам, нельзя использовать замыкание (private свойства в классе), а также могут возникнуть проблемы с наследованием. Но JavaScript позволяет все. Тут скорее язык можно упрекнуть за излишние возможности, но не за недостаток.

Наследование и полиморфизм

Перейдем теперь к вопросам наследования и полиморфизма.

Поскольку в JavaScript нет четкой типизации ссылок, то язык по умолчанию поддерживает полиморфизм (чем-то похоже на Java). А вот наследование, это отдельная история. Наследование не просто присутствует в JavaScript, но и может быть реализовано несколькими способами (молчу про версию ECMA 5, где есть специальные методы в Object).

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

 

   1:  function Human(firstName, lastName) {
   2:     this.getFirstName = (function () { return firstName; });
   3:     this.getLastName = (function () { return lastName; });
   4:     
   5:     this.Age = 33;
   6:   
   7:     this.Name = (function () { return this.getFirstName() + " " + this.getLastName(); });
   8:   
   9:     Human.CopyHuman = (function (h) { return new Human(h.getFirstName(), h.getLastName()); });
  10:  }
  11:   
  12:  function Women(firstName, lastName, colorOfHead) {
  13:     Human.call(this, firstName, lastName);
  14:   
  15:     this.color = colorOfHead;
  16:  }
  17:   
  18:  var w = new Women("Jessica", "Alba", "Brune");
  19:   
  20:  alert(w.Name());

 

Именно подход выше соответствует стандартной практике наследования в С++ или С#.

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

Заключение

Поскольку я пишу уже девятую страницу текста, то пора закругляться. Поэтому я не буду показывать все подходы. Если будет время, то в других постах я постараюсь освятить каждую тему (и другие) более детально. Целью же этого поста было желание дать Вам понять, что JavaScript является полноценным ООП языком и при этом очень интересным. Обратите на него внимание. Причем начинайте с самого языка, а уже потом с каких-то библиотек (типа JQuery), которые привязаны к каким-то окружениям.

Рекомендуемая литература:

Стоян Стефанов – JavaScript. Шаблоны

Дэвид Флэнаган – JavaScript. Подробное руководство.

Джон Рейсинг – JavaScript: Профессиональные приемы программирования

Written by Sergiy Baydachnyy

26.08.2011 at 08:32

Опубликовано в .NET Development, JavaScript

Tagged with

Продолжаем работать с WebMatrix

3 комментария

В предыдущем посте мы познакомились с продуктом WebMatrix, который позволяет создавать простые сайты, имея минимум знаний в программировании. Как было сказано, WebMatrix позволяет перемешивать серверный код и HTML на подобии классического ASP или PHP. Давайте рассмотрим простые синтаксические конструкции, которые будут полезны для написания любого серверного кода.

Начнем с того, что весь серверный код начинается с символа @. Так, если Вы планируете вставить в HTML значение переменной или статического свойства, то достаточно записать конструкцию @имя переменной/свойства в том месте, где Вы хотите получить значение (например, внутри элемента div). Если же Вы планируете писать более сложный код, содержащий определение переменных и какую-то логику, то подобный код необходимо заключить в фигурные скобки, а каждую отдельную строку заканчивать точкой с запятой.

Пример 1.

@DateTime.Now.Day

Пример 2.

@{
var i=3;
Response.Write(i);
}

Естественно, что при описании логики кода, Вы можете использовать стандартные конструкции любого языка: условия и циклы. Так, WebMatrix поддерживает два языка при разработке динамических страниц, это C# и VB.NET. Мы будем писать весь код на C#. Ниже Вы можете увидеть небольшой пример, использующий конструкцию if.

<!DOCTYPE html>
<html>
    <head>
        <title></title>
    </head>
    <body>
        @{
        var message="";
        if (IsPost)
        {
            message="His name is Sergiy";
        }
        }
        <form action="" method="post">
            <p><label>Enter ID:</label>
               <input type="text" name="text2" />
            </p>
            <p><input type="submit" value="Add" /></p>
        </form>
        <p>@message</p>
    </body>
</html>

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

Код нашего примера можно переписать, используя различные синтаксические особенности ASP.NET Razor. В примере ниже, мы успешно смешиваем серверный код и HTML, не прилагая каких-то специальных усилий.

<!DOCTYPE html>
<html>
    <head>
        <title></title>
    </head>
    <body>
        <form action="" method="post">
            <p><label>Enter ID:</label>
               <input type="text" name="text2" />
            </p>
            <p><input type="submit" value="Add" /></p>
        </form>
        @{
        if (IsPost)
        {
            <p>His name is Sergiy</p>
        }
        }
    </body>
</html>

Выглядит потрясающе. Такого нельзя было выполнить в старом добром ASP.NET. Тут есть одно ограничение: вставки HTML в серверный код должны быть полноценными HTML тегами, иными словами нельзя вставить обычный текст. Если Вы все же решили вставить обычный текст, то и для этого случая есть решение – оператор @:. Вот наш пример, с использованием этого оператора:

<!DOCTYPE html>
<html>
    <head>
        <title></title>
    </head>
    <body>
        <form action="" method="post">
            <p><label>Enter ID:</label>
               <input type="text" name="text2" />
            </p>
            <p><input type="submit" value="Add" /></p>
        </form>
        <p>
        @{
        if (IsPost)
        {
            @: His name is Sergiy
        }
        }
        </p>
    </body>
</html>

Оператор @: указывается только в начале строки, и также допускает перемешивать HTML и серверные переменные. Наконец, если текст состоит из нескольких строк, то его вывод можно оформить и с помощью элемента text:

<!DOCTYPE html>
<html>
    <head>
        <title></title>
    </head>
    <body>
        <form action="" method="post">
            <p><label>Enter ID:</label>
               <input type="text" name="text2" />
            </p>
            <p><input type="submit" value="Add" /></p>
        </form>
        <p>
        @{
        if (IsPost)
        {
            <text>His name is Sergiy</text>
        }
        }
        </p>
    </body>
</html>

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

Written by Sergiy Baydachnyy

11.08.2010 at 16:50

Опубликовано в .NET Development, ASP.NET, Web Matrix

Tagged with

Начинаем работать с WebMatrix

12 комментариев

Каждый раз, рассказывая об ASP.NET, я сталкиваюсь с одной и той же проблемой со стороны НЕ Microsoft разработчиков: мы не хотим учить ООП, осваивать универсальный продукт Visual Studio, изучать громадный набор классов и т. д., чтобы создавать простые сайты. Действительно, ASP.NET позволяет создавать сложные корпоративные приложения, позволяющие выдерживать большие нагрузки. Но для небольших компаний большинство возможностей ASP.NET не применимы. Ведь большинству компаний нужны простые «визитки», содержащие минимум интерактивности и работы с данными. Вот поэтому все небольшие сайты и продолжают писать на PHP – ведь не нужно нанимать дорогого .NET разработчика, тем более, что сам сайт представляет собой набор HTML страниц. Именно поэтому, Microsoft представляет новый инструмент – Web Matrix, который позволяет покрыть потребности разработчиков небольших сайтов.

Итак, Web Matrix представляет собой легковесный и простой инструмент для создания веб-сайтов (именно веб-сайтов, а не веб-приложений). Инструмент, который ориентирован не только на начинающего ASP.NET разработчика, но и на PHP-разработчика.

Чтобы установить Web Matrix, достаточно воспользоваться следующей ссылкой http://www.microsoft.com/web/webmatrix/. Тут Вам будет предложено использовать Web Platform Installer, чтобы установить не только Web Matrix, но и все требуемые компоненты. Кроме того, Вы можете выбрать любые другие компоненты, предоставляемые Web Platform Installer (развернуть одно или несколько приложений из галереи, добавить возможности к Вашему веб-серверу и т. д.).

clip_image002

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

clip_image004

Если Вы выбираете механизм создания сайта из галереи, то Web Matrix отображает несколько десятков уже готовых приложений. Данные веб-приложения чаще всего являются популярными в мире системами с открытым кодом, оптимизированные для работы на платформе Windows. Причем тут есть и PHP-приложения (например, WordPress) и ASP.NET приложения. Преимущество такого подхода состоит в том, что Вы сразу получаете готовый сайт, поддерживающий большое количество функционала. Как правило, перед публикацией такого сайта, Вы вносите минимум необходимых изменений (а многие публикуют сайт в исходном виде, особенно если речь идет о CMS). Естественно, чтобы использовать этот подход, необходимо потратить какое-то время на исследование возможностей существующих приложений.

clip_image006

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

clip_image008

Чаще всего Вы будете использовать Empty Site. Остальные шаблоны больше подходят для изучения возможностей Web Matrix.

Cоздав веб-сайт, Вы попадаете в главное окно Web Matrix, которое тут же предоставляет список активностей, которые Вы можете делать с созданным сайтом:

clip_image010

Главное окно оснащено Лентой, содержащей основные действия над сайтом (Запустить, Опубликовать и т. д.). Кроме того тут имеются четыре закладки, описывающие соответствующие рабочие пространства Web Matrix. Давайте рассмотрим каждую из закладок более подробно:

· Site – тут содержатся основные настройки сайта и присутствует возможность проанализировать список запросов ко всем составляющим сайта, чтобы определить потенциальные проблемы при работе со страницами (отсутствующие страницы на сайте);

· Files – это рабочее пространство позволяет просматривать все файлы, из которых состоит ваш веб-сайт, а также добавлять и редактировать файлы сайта. Фактически это основное рабочее пространство с которым придется работать;

· Databases – тут вы можете создать новую базу данных, используя SQL Server Compact Edition, либо подключиться к существующей базе данных, которая храниться в SQL Server или My SQL. Данное пространство имен позволяет взаимодействовать с базой данных, как на уровне отдельных объектов, так и на уровне данных;

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

Чтобы приступить к созданию нового сайта, перейдите в рабочее пространство Files и выберите существующий index.cshtml файл (двойным щелчком). Файл будет открыт на редактирование. Расширение cshtml представляет собой специальное расширение для файлов содержащих HTML-код и специальные вставки кода. Вот тут самое интересное! Компания Microsoft долгое время пропагандировала разделение кода и содержимого. Это замечательный подход, если речь идет о сложных приложениях, разрабатываемых годами и поддерживаемых разными разработчиками. Но, если речь идет и создании простого сайта, то разработчики предпочитают смешивать код и представление. Последнее легко сделать в PHP, но сложно реализовать в ASP.NET. Именно поэтому в Web Matrix были включены специальные объекты, позволяющие легко смешивать код, используя ASP.NET (в PHP в этом не было необходимости, так как там все было и так плохо, то есть хорошо). В качестве примера можно взять следующий код:

<!DOCTYPE html>

<html>

<head>

<title></title>

</head>

<body>

@DateTime.Now

</body>

</html>

Запустив приложение выше, Вы увидите текущую дату и время. Фактически мы обращаемся к свойству Now класса DateTime, определенного в .NET Framework. И, хотя этот код не похож на синтаксис ASP.NET, это ASP.NET, использующий новый синтаксис, получивший название RazorJ

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

<!DOCTYPE html>

<html>

<head>

<title></title>

</head>

<body>

@Twitter.Profile(«sbaidachni»)

</body>

</html>

clip_image012

Итак, если Вас хоть немного заинтересовал новый продукт, попробуйте поиграться с его интерфейсом несколько минут, чтобы полностью освоится. И ждите продолжение рассказа об ASP.NET Razor в следующем посте.

Written by Sergiy Baydachnyy

10.08.2010 at 17:00

Опубликовано в .NET Development, ASP.NET, Web Matrix

Tagged with

Сборки со строгим именем: повышение уровня безопасности приложения

5 комментариев

Всегда, рассказывая о сборках со строгим именем, я делал основной акцент на механизме развертывания подобных сборок.

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

С появлением .NET Framework ситуация кардинально поменялась.

С одной стороны, практически все управляемые библиотеки начали размещать в Глобальном кеше сборок (GAC), который представляет собой целый набор вложенных директорий, количество которых зависит от количества развернутых сборок. Так, каждой сборки соответствует своя директория. При этом задача развертывания ложится на вспомогательные утилиты, такие как gacutil.

С одной стороны, чтобы избежать путаницы, характерной для неуправляемых библиотек, сборки начали делить на два типа: сборки со строгим именем и сборки с нестрогим именем. Сборки с нестрогим именем размещаются только в директории самого приложения и не могут использоваться другими продуктами. Сборки со строгим именем могут быть развернуты в GAC и использоваться всеми приложениями системы. Основное различие между двумя типами сборок состоит в том, что для сборок со строгим именем в качестве имени учитывается не только имя файла (.dll), но и ряд других параметров, которые содержатся внутри сборки: версия сборки, культура сборки (языковая принадлежность) и цифровой ключ. Данные параметры позволяют развернуть несколько сборок с одинаковым именем, но с различными версиями или культурой. Таким образом, более старые приложения могут ссылаться на старые версии сборки, а новые – на более новые. Цифровой ключ позволяет полностью исключить тот вариант, когда две компании поставляют сборки с одним именем, версией и культурой.

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

Правило 1. Всегда старайтесь создавать сборки со строгим именем.

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

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

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

Правило 2. Ключ эффективен, если он содержится в безопасном месте.

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

Выделить открытую часть ключа можно следующей командой:

Sn.exe –p «ключ.snk» «открытый ключ.snk»

Настроить компьютеры разработчиков для игнорирования подписи можно с помощью команды:

Sn.exe –Vr «имя сборки» «открытый ключ»

Кроме этого нужно прописать атрибут [assembly: AssemblyDelaySign(true)], говорящий об отложенном подписании сборки.

Written by Sergiy Baydachnyy

29.01.2010 at 15:08

Опубликовано в .NET Development, Security

Tagged with ,