Показаны сообщения с ярлыком перевод. Показать все сообщения
Показаны сообщения с ярлыком перевод. Показать все сообщения

понедельник, 24 января 2011 г.

31 день с Silverlight :: День #1: События мыши в Silverlight

Полный список англоязычный постов, вы можете найти тут: 31 Days of Silverlight Series = Awesome!


Оригинал англоязычного поста: Day #1: Mouse Events in Silverlight

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


Событие MouseEnter


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

<UserControl x:Class="SilverlightMouseEvents.MouseEnterDemo"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="400" Height="300">
<Grid x:Name="LayoutRoot" Background="White">
<Ellipse x:Name="myEllipse" Fill="Blue" Width="150" Height="150" />
</Grid>
</UserControl>


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

<UserControl x:Class="SilverlightMouseEvents.MouseEnterDemo"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="400" Height="300" MouseEnter="UserControl_MouseEnter">
<Grid x:Name="LayoutRoot" Background="White">
<Ellipse x:Name="myEllipse" Fill="Blue" Width="150" Height="150" MouseEnter="myEllipse_MouseEnter" />
</Grid>
</UserControl>


Теперь нам необходимо перейти на code-behind файл кодом на C#, для реализации обработчика событий. Как только я создал обработчиков событий в XAML коде, студия автоматически создала для меня заготовки методов обработки событий в C# коде. Вот как выглядит первоначальное содержимое C# code-behind файла:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SilverlightMouseEvents
{
public partial class MouseEnterDemo : UserControl
{
public MouseEnterDemo()
{
InitializeComponent();
}

private void UserControl_MouseEnter(object sender, MouseEventArgs e)
{

}

private void myEllipse_MouseEnter(object sender, MouseEventArgs e)
{

}
}
}


Для того, чтобы сохранить разумной длину этого поста, я не буду делать ничего сложного в моих обработчиках событий, но я покажу вам, как изменить цвет эллипса. Я добавил одну строку кода в каждый метод, и каждый из них закрашивает эллипс другим цветом. Сейчас, когда мы перемещаем курсор мыши в области Silverlight приложения — круг будет залит зеленым цветом, а когда курсор мыши окажется внутри круга — фигура будет закрашена пурпурным.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SilverlightMouseEvents
{
public partial class MouseEnterDemo : UserControl
{
public MouseEnterDemo()
{
InitializeComponent();
}

private void UserControl_MouseEnter(object sender, MouseEventArgs e)
{
myEllipse.Fill = new SolidColorBrush(Colors.Green);
}

private void myEllipse_MouseEnter(object sender, MouseEventArgs e)
{
myEllipse.Fill = new SolidColorBrush(Colors.Purple);
}
}
}


Событие MouseLeave


Это событие работает практически точно также, как и событие MouseEnter. MouseLeave срабатывает тогда, когда курсор мыши ПОКИДАЕТ некую область. Что еще можно сюда добавить, а? На этот раз, однако, я вообще не делал изменений в моем XAML коде. Так вот, еще раз привожу начальный XAML код.

<UserControl x:Class="SilverlightMouseEvents.MouseLeaveDemo"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="400" Height="300">
<Grid x:Name="LayoutRoot" Background="White">
<Ellipse x:Name="myEllipse" Fill="Blue" Width="150" Height="150" />
</Grid>
</UserControl>


На этот раз я сделаю все в C#-коде. Я добавлю обработчики событий в момент инициализации приложения. Вот мое окончательное решение на C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SilverlightMouseEvents
{
public partial class MouseLeaveDemo : UserControl
{
public MouseLeaveDemo()
{
InitializeComponent();
this.MouseLeave += new MouseEventHandler(MouseLeaveDemo_MouseLeave);
myEllipse.MouseLeave += new MouseEventHandler(myEllipse_MouseLeave);
}

void myEllipse_MouseLeave(object sender, MouseEventArgs e)
{
myEllipse.Fill = new SolidColorBrush(Colors.Purple);
}

void MouseLeaveDemo_MouseLeave(object sender, MouseEventArgs e)
{
myEllipse.Fill = new SolidColorBrush(Colors.Green);
}
}
}


Событие MouseLeftButtonDown


В этом случае, я продолжаю использовать тот же самый XAML код. Единственным изменением является ссылка на наш новый класс MouseLeftButtonDownDemo из XAML кода нашего юзер-контрола. Я уже показал, как использовать обработчики событий как в XAML, так и в C# коде. Вы уже видели XAML, так что я просто покажу только C# код.

Событие MouseLeftButtonDown, как вы уже догадались, срабатывает при нажатии левой кнопки мыши Пожалуйста, обратите внимание, что код этого примера так же охватывает пример события MouseLeftButtonUp, которое рассматривается ниже, и то, что значительной разницы между ними нет. Это будет особенно очевидно, когда мы займемся реализацией Drag & Drop. Вот пример добавления события MouseLeftButtonDown в наш код.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SilverlightMouseEvents
{
public partial class MouseLeftButtonDownDemo : UserControl
{
public MouseLeftButtonDownDemo()
{
InitializeComponent();
this.MouseLeftButtonDown += new MouseButtonEventHandler(MouseLeftButtonDownDemo_MouseLeftButtonDown);
myEllipse.MouseLeftButtonDown += new MouseButtonEventHandler(myEllipse_MouseLeftButtonDown);
}

void myEllipse_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
myEllipse.Fill = new SolidColorBrush(Colors.Green);
}

void MouseLeftButtonDownDemo_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
LayoutRoot.Background = new SolidColorBrush(Colors.Purple);
}
}
}


Событие MouseLeftButtonUp


До сих пор мы создавали отдельные методы-обработчики событий для каждого отдельного события. Во множестве случаев, вы обязательно захотите, чтобы разные элементы управления вызывали один и тот же метод обработки событий, чтобы каждый раз не писать один и тот же код обработки событий. В следующем примере, я добавлю еще один круг внутрь StackPanel. Обе эти фигуры будут менять свой фон на оранжевый. Вот наш новый, дополненный, XAML код:
<UserControl x:Class="SilverlightMouseEvents.MouseLeftButtonUpDemo"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="400" Height="300">
<StackPanel x:Name="LayoutRoot" Background="White" Orientation="Horizontal" HorizontalAlignment="Center" >
<Ellipse x:Name="myEllipse" Fill="Blue" Width="150" Height="150" />
<Ellipse x:Name="myEllipse2" Fill="Red" Width="150" Height="150" />
</StackPanel>
</UserControl>


Теперь мы добавим обработчик события MouseLeftButtonUp в нашем C# коде:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SilverlightMouseEvents
{
public partial class MouseLeftButtonUpDemo : UserControl
{
public MouseLeftButtonUpDemo()
{
InitializeComponent();
myEllipse.MouseLeftButtonUp += new MouseButtonEventHandler(Ellipse_MouseLeftButtonUp);
myEllipse2.MouseLeftButtonUp += new MouseButtonEventHandler(Ellipse_MouseLeftButtonUp);
}

void Ellipse_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
Ellipse myCircle = sender as Ellipse;
myCircle.Fill = new SolidColorBrush(Colors.Orange);
}
}
}


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

Событие MouseMove


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

Мой XAML настоящее время состоит из двух TextBox'ов на странице. Первый я, ловко, назвал Xbox, а второй — Ybox. Мы будем отображать новые X и Y координаты мыши в этих полях, каждый раз, в момент перемещения пользователем курсора мыши.

<UserControl x:Class="SilverlightMouseEvents.MouseMoveDemo"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
Width="400" Height="300" VerticalAlignment="Center">
<StackPanel x:Name="LayoutRoot" Background="White">
<TextBox x:Name="Xbox" Width="200" Height="35" Text="X" />
<TextBox x:Name="Ybox" Width="200" Height="35" Text="Y"/>
</StackPanel>
</UserControl>


Сейчас C# code behind файл выглядит не слишком сложными. В данном примере мы используем параметр MouseEventArgs, от которого мы получим текущие координаты мыши. После чего, просто запишем значения координат в текстовые поля.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace SilverlightMouseEvents
{
public partial class MouseMoveDemo : UserControl
{
public MouseMoveDemo()
{
InitializeComponent();
this.MouseMove += new MouseEventHandler(MouseMoveDemo_MouseMove);
}

void MouseMoveDemo_MouseMove(object sender, MouseEventArgs e)
{
Xbox.Text = e.GetPosition(null).X.ToString();
Ybox.Text = e.GetPosition(null).Y.ToString();
}
}
}


Резюме


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

четверг, 26 ноября 2009 г.

10 простых правил, чтобы лучше писать приложения на ASP.NET

При создании приложений на ASP.NET, мы, как правило, тратим множество усилий на проектирование и изоляцию различных слоев приложения, с упором на предметную область и тому подобное. Однако, как только мы приближаемся к программированию пользовательского интерфейса, код становится более грязным. Я могу объяснить это тем, что чем ближе мы к пользовательскому интерфейсу, тем меньше шансов того, что код используется повторно, или, по крайней мере, предназначен для многократного использования. Несмотря на то, что это может быть правдой (что код не предназначен для повторного использования), UI-код должен быть чистыми и легким для сопровождения.

Код UI должен использовать такие принципы ООП, как наследование и инкапсуляция, ровно как код любого другого слоя. Кроме того, некоторые принципы SOLID, могут и должны быть применены при разработке наших юзер-контролов и веб-страниц. Так как ASP.NET WebForms по-прежнему широко используется, и я полагаю, что так продлится еще долгое время, в этой статье, я предлагаю тот набор правил для программирования и проектирования, который я использую в своих ASP.NET проектах. Надеюсь, что следующие правила помогут вам сделать ваш UI код более чистым и и облегчат его поддержку в дальнейшем.

1. Используйте собственный базовый класс для классов пользовательского интерфейса


Начинайте проект со создания крайней мере двух базовых классов BasePage и BaseUserControl и наследовать от них все ваши веб-формы и юзер-контролы. Это считается хорошим стилем. Причина в том, что у вас непременно возникнет необходимость реализовать общий код для всех или части ваших веб-форм или юзер-контролов.
К примеру, все страницы вашего сайта должны иметь название и, в дальнейшем, некоторым мета-теги. Добавление свойства PageID, а также метода, который вернет название страницы и ее мета-теги будет довольно легко достигнуть при помощи наследования, а поддерживать код, очевидно, станет намного легче.
Другим распространенным случаем является необходимость показать / скрыть элементы веб-формы, в зависимости от определенного условия. Добавив виртуальный метод в базовый класс, который вызывается при возникновении события OnPreRender, вы сможете реализовать механизм скрытия и отображения элементов веб-формы. И весь этот код будет удобно расположен в одном методе и работать для всех классов-наследников, пока вы не переопределите его. Следующий код демонстрирует все вышесказанное, используя дизайн-паттерн "Шаблонный метод"

Пример:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Collections.Specialized;
using System.Data;
public class BasePage : System.Web.UI.Page
{
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
DoEnableDisableControls();
SetTitleFromCMS();
SetMetaTagsFromCMS();
}
public string PageID
{
get;
set;
}
/// &lt;summary&gt;
/// Overwrite this method to enable or disable controls
/// depending on the state of the page.
/// &lt;/summary&gt;
protected virtual void DoEnableDisableControls()
{
}

private void SetTitleFromCMS()
{
if (String.IsNullOrEmpty(PageID))
return;
//Queries the CMS for the page title
this.Title = "Whatever we got from the CMS";
}
private void SetMetaTagsFromCMS()
{
//Queries the CMS for the MetaTags
//add the meta tags
}
}


Странице, которая наследуется от базового класса, будет просто необходимо установить свойство PageID – и она будет иметь заголовок и мета-теги (обратите внимание на возможность задать PageID непосредственно в директивах .aspx файла страницы).

<% @ Page Language = "C #" PageID = "DefaultPage" AutoEventWireup = "True" CodeBehind = "Default.aspx.cs" Inherits = "% ExtRefWebApp._Default">


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

2. Скрывайте переменные сессии


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

  • Переменные сессии широко используется в веб-приложениях. Они очень полезны, но мы не должны забывать, что переменная Session, с точки зрения ООП – это ничто иное, как глобальная переменная.
  • При отладке или поддержке веб-приложений, мы часто сталкиваемся с участками кода, которые используют значения, хранящиеся в Session, и нам необходимо проверить, где эти значения были установлены. И это не легко выяснить.
  • Session может содержать любой тип. Если мы заменим тип значения, хранящегося в определенном ключе Session, нам придется проверить весь код и изменить все приведения типов (мы делаем это с помощью поиска/замены текста в коде).
  • Конкретного ключа Session может не существовать, либо он может иметь значение null. Не существует способа для того, чтобы получить по умолчанию для несуществующего ключа Session и, таким образом, всякий раз, когда мы используем переменную сессии, мы должны проверить ее значение (на null) перед использованием.

Лучший способ избежать этих проблем – создать набор классов, по средствам установки свойств которых мы и будем изменять значения Session. При помощи функции Visual Studio "Find all references"/"Find Usages", из контекстного меню при клике на сеттере свойства, вы найдете все объекты, которые устанавливают переменную сеанса. С другой стороны, если мы изменим тип значения в переменной Session, то код, использующий старый тип просто выдаст ошибку компиляции, следовательно, эти ошибки будет очень легко найти и сделать все изменения или оценить объем работы, необходимой, чтобы сделать изменения. Это ужесточает контроль типов и делает наш код более безопасным.
Доступ к значениям Session должен быть инкапсулирован в разных классах, и если их будет слишком много, то, желательно, чтобы они принадлежали одному пространству имен и находились в одной папке, это облегчит их поддержку.

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

3. Не создавайте глубокой иерархии UI-контролов


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

Обычно, это хорошая привычка ограничить дерево максимум на 2 или 3 уровня. Страница содержит элементы управления, которые могут содержать другие элементы управления. Но внутренние элементы должны содержать только базовые элементы управления .NET Framework (или элементы управления веб-сервером). И даже на одном уровне, мы должны ограничивать число юзер-контролов, включенных в родительский юзер-контрол. В том смысле, что создание одного большого юзер-контрола, который содержит множество внутренних юзер-контролов – это не всегда хорошая идея. Имейте в виду, что сама страница может содержать столько контролов, сколько вы пожелаете: я заметил, что очень часто разработчики не используют базовые контролы ASP.NET, а встраивают все в пользовательский Сверх-элемент управления, который в свою очередь, содержит дочерние элементы. Зачем нам добавлять этот уровень косвенности и сложности? Страница – это прекрасный контейнер для элементов управления.

4. Не все должно быть включено в отдельный пользовательский элемент управления


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

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

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

5. Используйте события для обмена данными между юзер-контролами и их контейнерами


Использование свойств пользовательских элементов управления, чтобы сообщить о своем состоянии своему контейнеру – это типичная схема, которую мы видим в веб-разработке. В большинстве случаев разработчики устанавливают переменную сессии, когда что-то случается в пользовательском элементе управления, и контейнер (будь то страница или другой пользовательский элемент управления) проверяет значение переменной сессии для того, чтобы определить, действительно ли что-то случилось или нет. Это обычно делается в событие "OnLoad". Наверное, вы заметили, что очень быстро, мы, в итоге, получаем довольно беспорядочный код в этом обработчике событий.
Во-первых, мы должны гарантировать, что код, который устанавливает переменную сессии выполняется перед кодом, который проверяет ее значение. Кроме того, мы должны гарантировать, что значение переменной сбрасывается: в противном случае, в следующий раз, когда мы попадаем на ту же страницу, мы можем спровоцировать событие, без всяких на то причин.
Один элегантный способ уведомить об изменение статуса одного элемента другому – это создать событие, на которое можно будет подписаться (прим.: public event в C#). Есть много преимуществ такого подхода:

  • Чистый код, который реагирует на конкретные события с внутренних контролов,
  • Один и тот же механизм может быть использован для стольких контролов, сколько мы пожелаем,
  • Мы будем уверены в том, что наш контрол будет извещен только в том случае, если событие действительно произошло; в то время как использование переменных сессии добавляет неопределенности, поскольку мы не знаем, какой код выполняется первым: код, который установил значение Session, или код, который проверяет его.
  • Мы не должны заботиться о переменной сессии и сбрасывать его после событий, поскольку мы больше не используем их.
  • Мы не используем значения Session просто для того, чтобы поставить/считать флаг (а это экономия памяти и уважение основных принципов ООП).


6. Избегайте встраивания C#/VB кода в файлах ASPX


Лучшее место, чтобы добавить программный код в веб-формы – это code-behind файл. Внедрение кода в файлы ASPX делает его грязным и очень трудно поддерживаемым, как в старые времена ASP.

7. Используйте декларативный стиль программирования как можно чаще


Если вам необходимо настроить пользовательский или любой другой серверный элемент управления – сделайте это по средствам свойств в ASPX-файле вместо code-behind. Конечно же, бывают ситуации, когда у нас нет выбора, где настроить элемент управления (условные значения, например), но, в общем, это делает код HTML более четким и облегчает его поддержку, поскольку мы знаем многое о контроле, просто взглянув на один ASPX файл (и нет необходимости смотреть в code-behind файл).

8. Будьте осторожны при использовании статических переменных


Статические члены являются общими и сохраняют свое значение до тех пор, пока работает процесс ASP.NET. Это означает, если вы используете статические члены, вы потребляете память, которая не будет освобождена, пока вы не сделаете это явно.

Один пример я видел в прошлом, проект хранил пользовательскую информацию в виде статического словаря (между прочим, это может быть любой тип коллекции). При нагрузочном тестировании, использование памяти приложения выросло до 12 ГБ на пару сотен пользователей. Так как словарь хранился в статической переменной, ее размер увеличивался при добавлении новых пользователей и, в конце концов, мы получили исключение "Out of memory".

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

9. Рассматривайте производительность с точки зрения клиента


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

Существуют различные средства и способы, чтобы сделать производительность страницы лучше на клиентской стороне (хорошей отправной точкой, будет эта статья: http://www.codeproject.com/KB/aspnet/PeformanceAspnet.aspx).

В коде на серверной стороне, мы не должны допускать чрезмерного использования ViewState. С одной стороны, хранение дерева объектов в ViewState может показаться полезной и более эффективным техникой, чем сохранять его в сессии, ведь объект не будет висеть на неопределенное время в памяти. Но, эффективность будет еще хуже, поскольку на самом деле ваше дерево объектов будет сериализовано и передано как часть ответа в браузер клиента. И когда клиент отправит форму, сериализованный объект отправляется обратно на сервер.

Другой проблемой является количество Javascript файлов, которые загружаются вместе со страницей. Мы должны объединить их с помощью ScriptManager (см. http://bellouti.wordpress.com/2008/09/14/combining-javascript-files-with-ajax-toolkit-library/ ).

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

10. Используйте кэширование, где это только возможно


Пользовательские элементы управления можно кэшировать с помощью директивы OutputCache. При создании пользовательских элементов управления, которые должны показываться содержание, взятое из БД или внешних источников, следует рассмотреть возможность использования этой директивы.
Мы также можем кэшировать данные в статических членах или пользования объектами кэширования EnterpriseLibrary. Если мы сделаем это, мы должны гарантировать, что мы создаем кэш в форме, ближайшей к той, что будет выводиться в интерфейсе пользователя. Например, если вы получаете XML из базы данных и трансформируете его по правилам XSLT в HTML, который и будет отображаться, то кэшировать следует результирующий HTML, а не XML. Кэширование HTML позволит избежать повторных преобразований XML в следующий раз, когда будет запрошена страница.



Автор статьи: Samir Bellouti
Оригинал: 10 simple rules to write better ASP.NET applications
Перевод: Дмитрий Жарий

суббота, 24 октября 2009 г.

10 типов программистов, с которыми вы обязательно столкнетесь

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

#01: Гендальф

Такой тип программиста может успешно сыграть роль Гэндальфа во "Властелине колец". У него (или у нее! :) длинная борода по колено, глупая шляпа; может носить плащ или накидку зимой. К счастью для команды, на рабочем месте, это адепт белой магии, прямо как Гэндальф. К несчастью для команды, они должны будут терпеть часы рассказов Гэндальфа о том, как он или она шел в гору, по снегу, чтобы доставить перфокарты в далекий вычислительный центр. Гэндальф ¬¬– это ваш наилучший ударник IT-шного труда, но если вы попробуйте оставить его позади команды – это вызовет отчаяние.



#02: Мученик

В любой другой профессии, Мученик – это обычный "трудоголик". Но в области разработки, мученик выходит за эти рамки в другое измерение. По крайней мере, трудоголики уходят домой, в душ – и спать. А мученики гордятся тем, что просыпаться на рабочем столе среди пустых коробок из-под пиццы. Проблема в том, что никто не просил Мученика так работать. И он или она пытается заставить остальную часть команды почувствовать себя виноватыми, такими фразами как: "Да, пойду я домой, хотя бы пообедаю. Сегодня ночью закончил с участком кода, на который отводились ближайшие три недели.

#03: Фанатик

Следите за Фанатиком. Если он или она настигнет вас врасплох, и прижмет в угол, то вы будете обречены, прослушать трехчасовую лекцию о превосходстве Opera по сравнению с Firefox, или почему Playstation 3 лучше, чем XB 360. На рабочем столе Фанатика разложены плакаты, фигурки и другие безделушки, связанные с его навязчивыми идеями, скорее всего, привезенные из Японии. С фанатиками невозможно иметь дело, они тратят настолько много времени на свою одержимость (внутри и вне офиса), что они совершенно не понимают, когда нужно выполнять работу, для которой их наняли.


#04: Винс Нил

Это человек около сорока лет, который живет в далеком к 1984 году. Длинные волосы, потертые стираные джинсы и бандана. На протяжении рабочего дня, Винс сидит в офисе, напевая мелодии Bon Jovi и Def Leppard. И, в принципе, все не так уж и плохо, если бы песня "Pour Some Sugar On Me" не была бы так чертовски заразительной.

Винс – веселый человек и работать с ним – одно удовольствие, и на самом деле он очень опытный человек, но просто... никогда не взрослеет. Но Винс доставляет хлопоты, когда он или она пытается жить в стиле Rock-n-Roll; с длинными волосами на голове, и с берцами на ногах. И… достаточно сложно работать с теми, кто приходит на работу с похмелья каждый день.

#05: Ниндзя

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

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

#06: Теоретик

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

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

#07: Ковбой

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

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

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

#08: Десантник

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

#09: Посредственный Человек

"Достаточно хорошо" это лучшее, что вы можете получить от Посредственного Человека. Он или она всегда тратят больше времени для создания худшего кода, чем у кто-либо в команде. "Тише едешь – дальше будешь" – так можно описать проекты П.Ч. Но П.Ч. всегда просто "достаточно хорош" чтобы не быть уволенным.

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


#10: Евангелист

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

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



Оригинал статьи: 10 types of programmers you'll encounter in the field
Автор: Justin James

Перевод: Дмитрий Жарий

вторник, 5 мая 2009 г.

Учишь? Меня? Но я ведь Эксперт!

Ты был кодером на протяжении нескольких лет, возможно, даже десятилетий. Ты нашел успешную работу, зарабатываешь достаточно денег. Ты знаешь «респектабельные» технологии, которые так востребованы на рынке труда: C++, C#, Java и т.д. И тебе без надобности учить что-то новое. Оставайся в своей зоне комфорта. Бери пример с этих парней:
"Я думаю, что весь мировой рынок состоит приблизительно из 5 компьютеров."
- Thomas J. Watson, Председатель Совета, IBM, приблизительно 1948

"Кажется, что мы достигли пределов того, чего возможно достигнуть в компьютерной технологии, хотя нужно быть осторожным с такими утверждениями, поскольку они имеют тенденцию казаться довольно глупыми через 5 лет."
- Джон Von Neumann, приблизительно 1949

"Но, где это можно будет использовать?"
- Инженер в Advanced Computing Systems Division of IBM, комментируя микрочип, 1968

"Нет никакой причины для любого человека иметь компьютер в своем доме."
- Кен Olson, президент, Digital Equipment Corporation, 1977

В самом деле, мудрые слова.
Ты должен учится, когда ты знаешь, что не знаешь достаточно. Легко взять книгу, когда ты чувствуешь неуверенность в собственных знаниях. Но, опасней всего, когда ты действительно думаешь, что знаешь достаточно. Программирования (как и вся компьютерная наука) походит на бег Красной Королевы: ты должен бежать с такой скоростью, с которой только можешь для того, чтобы оставаться на своем прежнем месте.

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

Уходи из своей зоны комфорта. Признай свое незнание. Изучи что-то новое. Изучи что-то бесполезное, чтобы в следующем году ты мог бы назвать это бесполезным. Не говори мне, что все, что ты знаешь сейчас – это все что тебе необходимо знать вообще. Не становись цитируемым в моем следующем списке.

Если вам понравились цитаты, то их можно почитать еще и это: A Double Handful of Programming Quotes

Оригинальная статья: Learning? Me? But I’m An Expert
Перевод: Дмитрий Жарий

воскресенье, 5 апреля 2009 г.

10 навыков, которые потребуются разработчикам в ближайшие 5 лет

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

1. Один из «Большой Тройки» (.NET, Java, PHP)

Если в мире разработки не произойдет радикальных изменений (скажем, на Редмонд упадет астероид), то разработчикам будет необходимо знать по крайней мере один, из «Большой Тройки» языков программирования и платформ разработки: .NET (VB.NET or C#), Java, или PHP в самом ближайшем будущем. И недостаточно знать одного лишь синтаксиса языка программирования. Поскольку проекты охватывают самые разнообразные функциональности, вам будет просто необходимо знать Фреймворки и библиотеки, связанные с необходимым функционалом, более углубленно.

2. Насыщенные Интернет Приложения (RIA)

Любили вы RIA, или ненавидели, но Flash используется сейчас не только для создания мультфильмов про политиков, которые поют глупые песенки. Flash нарастил дополнительную функциональность по для создания приложений, используя такие технологии как Flex и AIR. Конкуренты Flash, такие как JavaFx и Silverlight, также разрабатывают подобные фичи и повышают производительность. И чтобы укрепить связь между этими вещами, HTML5 объединит себе всю функциональность RIA, включая соединение с базами данных, и ставя этим официальную печать W3C на технологии AJAX. И это значит, что в ближайшем будущем, различия RIA платформ будут очень сильно сглажены.

3. Веб-разработка

Веб-разработка никуда не уйдет, по крайней мере в ближайшее время. Многие разработчики игнорируют Веб, или по крайней мере знакомы лишь с теми основами, которые предоставляют им фреймворки. Но, компаниям требуется все больше и больше людей, умеющих работать с теми технологиями, которые лежат ниже уровня фреймворка. Так что JavaScript, CSS, и HTML будут успешны на протяжении еще 5-ти лет.

4. Веб-службы

REST или SOAP? JSON или XML? То, что выбор решения зависит от проекта, сложность работы разработчика возрастает без использования технологии Веб-служб. Даже те сферы, где раньше использовались ODBC, COM, или RPC, постепенно переходят на использование Веб-служб. Разработчики, которые не умеют работать с Веб-службами, найдут себя в сфере поддержки и баг-фикса старых проектов.

5. Социальные навыки

Все что сейчас происходит, движется к увеличению видимости IT внутри и снаружи предприятия. Разработчики постепенно вовлекаются в сферы, не связанные непосредственно с разработкой, для получения от них ответов на существующие вопросы. Скажем, финансовый директор не может изменить правила бухгалтерского учета, без помощи IT для внесения изменений в необходимые системы. Точно так же, как нельзя изменить работу кол-центра, без внесения необходимых изменений в CRM-систему предприятия. Также, клиентам часто необходимо работать с разработчиками напрямую, чтобы убедится в том, что их требования были учтены. Пойдут ли разработчики изучать ораторское искусство, или начнут изучать книгу по типу «Как завоевать друзей и влиять на людей»? Нет. Но, разработчики, которые все-таки сделают так, будут более ценны для своего начальства и высоко ценится на рынке труда.

6. Один динамически и/или функциональный язык

Такие языки, как Ruby, Python, F#, Perl и Groovy это не совсем мейнстрим, но хорошие идеи в них есть. Скажем, LINQ из .NET Framework – это прямой потомок функциональных технологий программирования. Python и Ruby стают более востребованы в некоторых областях, благодаря фреймворку Ruby on Rails и хорошей поддержки программирования под Silverlight. Изучение одного из этих языков не просто улучшит ваше резюме, но и расширит ваш кругозор. Каждый признанный и уважаемый разработчик, рекомендует изучить по крайней мере один динамический или функциональный язык программирования, чтобы познать новые способы мышления и решения задач. И из личного опыта, могу сказать вам, что это действительно работает.

7. Гибкие методологии

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

8. Знание предметной области

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

9. «Гигиена» разработки

Несколько лет назад, много коллективов разработчиков не использовали такие инструменты как: баг-трекинговые системы, системы контроля версия и другие подобные инструменты. Они просто работали со своей IDE и все. Но, благодаря новым подходам по интеграции, и новым инструментам, таким как Microsoft Visual Studio Team System и появлению высококачественных инструментов с открытым исходным кодом, коллективов не использующих такие инструменты стает все меньше. Но, разработчикам уже недостаточно знать только то, как можно залить код в репозиторий, или забрать его оттуда, или как использовать виртуальные машины для создания тестовой среды. Они должны быть аккуратны, и уверены в том, что они надлежащим образом координируют свои действия с действиями команды. Те люди, которые копируют все на свою персональную флешку, не документируют то, каким элементам задачи соостветсвуют изменения кода и тому подобное, не приветствуются в традиционных коллективах, и еще больше не приветствуются в Agile-командах, полагающихся на тесную координацию и коммуникацию между членами команды.

10. Разработка для мобильных устройств

В конце 1990-х годов, Веб-разработка росла и получала всеобщие признание, и постепенно начала утеснять традиционные настольные приложения во многих областях. В 2008-м году, развитие мобильной разработки уже покинуло стартовую площадку, и на протяжении следующих 5-ти лет, она станет все более и более важной. Конечно, есть множество подходов разработки программного обеспечения для портативных устройств: создание веб-приложений, RIA, и приложения, которые работают непосредственно на устройстве. Независимо от того, какой путь вы выберете, добавление умений по разработке для мобильных устройств в вашу копилку мастерства обеспечит вашу востребованность на рынке труда, в будущем.


От себятинка:
Одиннадцатым пунктом я бы добавил в этот список «знание английского языка», этот скилл был востребован и раньше и будет востребован еще и через пять и пять десятков лет. Если, конечно же, на Редмонд не упадет огромный астероид ;)
Подобные переводы, отнимают кучу моего времени, но вместе с тем, они прокачивают мой уровень английского языка, и просто приносят удовольствие.
Поэтому, могу посоветовать тебе, Читатель, ищи что-то интересное на английском, и переводи на свой родной язык.

Оригинал статьи:
10 skills developers will need in the next five years

Про автора оригинальной статьи:
Justin James is an employee of Levit & James, Inc. in a multi-disciplinary role that combines programming, network management, and systems administration.
 

.NET ate my MOSK;. Powered By Blogger © 2009 Bombeli | Theme Design: ooruc