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

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

Инкапсуляция.

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

Приведу пример инкапсуляции свойств на примере класса автомобиль:

Auto.cs:

using System;

namespace OOPLibrary.Auto
{
	/// <summary>
	/// Класс описывающий свойства автомобиля и его действия
	/// </summary>
	public class Auto
	{
		/// <summary>
		/// Хранит возраст автомобиля. Так как возраст нельзя менять из клиента,
		/// то это свойство объявлено с модификатором private.
		/// </summary>
		private int _age;

		/// <summary>
		/// Хранит признак стоит автомобиль или едет. Свойство используется только внутри класса Auto
		/// и не должно быть доступно в клиентах, потому оно так же объявлено с модификатором private.
		/// </summary>
		private bool _isMoving;

		/// <summary>
		/// Хранит цвет автомобиля. Его можно менять из клиентских классов,
		/// поэтому свойство объявлено с модификатором public.
		/// </summary>
		public string Color;

		/// <summary>
		/// Хранит имя автомобиля, допустим, что его тоже можно менять,
		/// поэтому тоже объявляем с модификатором public.
		/// </summary>
		public string Name;

		/// <summary>
		/// Конструктор класса. Тут задаются начальные свойства автомобиля.
		/// </summary>
		public Auto()
		{
			_age = 5;
			_isMoving = false;
			Color = "Красный";
			Name = "Мой автомобиль";
		}

		/// <summary>
		/// С помощью этого метода можно получить возраст автомобиля,
		/// так как свойство _age недоступно из клиентов.
		/// </summary>
		/// <returns>Возвращает возраст автомобиля.</returns>
		public string GetAge()
		{
			return "Этому автомобилю " + _age + " лет.";
		}

		/// <summary>
		/// Метод стартует автомобиль, если он еще не стартовал.
		/// </summary>
		public void Start()
		{
			if (_isMoving)
			{
				Console.WriteLine("Да и так уже едем.");
			}
			else
			{
				_isMoving = true;
				Console.WriteLine("Поехали...");
			}
		}

		/// <summary>
		/// Метод останавливает автомобиль, если он ехал.
		/// </summary>
		public void Stop()
		{
			if (_isMoving)
			{
				_isMoving = false;
				Console.WriteLine("Остановились.");
			}
			else
			{
				Console.WriteLine("И так уже стоим, куда же дальше?");
			}
		}

		/// <summary>
		/// Если автомобиль едет, то поворачиваем налево.
		/// </summary>
		public void MoveLeft()
		{
			if (_isMoving)
			{
				Console.WriteLine("Поворнули налево.");
			}
			else
			{
				Console.WriteLine("Да куда же поворачивать, мы же стоим.");
			}
		}
		/// <summary>
		/// Если автомобиль едет, то поворачиваем направо.
		/// </summary>
		public void MoveRight()
		{
			if (_isMoving)
			{
				Console.WriteLine("Поворнули направо.");
			}
			else
			{
				Console.WriteLine("Да куда же поворачивать, мы же стоим.");
			}
		}
	}
}

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

AutoManager.cs:

using System;

namespace OOPLibrary.Auto
{
	/// <summary>
	/// Класс управления автомобилем.
	/// </summary>
	public class AutoManager
	{
		/// <summary>
		/// Менеджер создает объект автомобиля и не дает доступа к нему из других классов,
		/// объявив его при помощи модификатора private.
		/// </summary>
		private Auto _myAuto;

		/// <summary>
		/// Конструктор менеджера автомобилей.
		/// </summary>
		public AutoManager()
		{
			// Создаем новый автомобиль
			_myAuto = new Auto();
		}

		/// <summary>
		/// Метод запускает проверку методов и свойств автомобиля.
		/// </summary>
		public void Run()
		{
			// Выводим имя автомобиля, которое было назначено по умолчанию в конструкторе класса Auto
			Console.WriteLine("Имя автомобиля: " + _myAuto.Name);
			// Выводим цвет автомобиля, которsq был назначен по умолчанию в конструкторе класса Auto
			Console.WriteLine("Цвет автомобиля: " + _myAuto.Color);
			// Выводим возраст автомобиля, который был назначен по умолчанию в конструкторе класса Auto
			Console.WriteLine(_myAuto.GetAge());

			// Если попытаться добраться до свойства _age напрямую, то мы получим ошибку компилятора,
			// так как оно объявлено с модификатором private в классе Auto
			//Console.WriteLine(_myAuto._age);   // Ошибка компилятора
			Console.WriteLine();

			// Меняем имя на новое
			_myAuto.Name = "Новое имя";
			// Меняем цвет автомобиля
			_myAuto.Color = "Синий";

			// Поменять возраст автомобиля не получится, так как он доступен только внутри класса Auto
			//_myAuto._age = 6;   // Ошибка компилятора

			// Выводим новое имя автомобиля
			Console.WriteLine("Новое имя автомобиля: " + _myAuto.Name);
			// Выводим новый цвет автомобиля
			Console.WriteLine("Новый цвет автомобиля: " + _myAuto.Color);
			Console.WriteLine();

			// Поворачиваем налево
			Console.Write("Попытаемся повернуть налево: ");
			_myAuto.MoveLeft();

			// Стартуем автомобиль
			Console.Write("Вспомнили, что автомобиль не заведен, и стартуем его: ");
			_myAuto.Start();

			// Поворачиваем налево
			Console.Write("Поворачиваем налево: ");
			_myAuto.MoveLeft();

			// Поворачиваем направо
			Console.Write("Поворачиваем направо: ");
			_myAuto.MoveRight();

			// Останавливаем автомобиль
			Console.Write("Останавливаем автомобиль: ");
			_myAuto.Stop();
			// Останавливаем автомобиль
			Console.Write("Пробуем еще раз остановить стоящий автомобиль: ");
			_myAuto.Stop();
		}
	}
}

Данный класс, является клиентским классом по отношению к классу Auto, поэтому ему будут доступны только публичные свойства класса Auto.

Program.cs:

using OOPLibrary.Auto;

namespace OOPLibrary
{
	public class Program
	{
		public static void Main()
		{
			// Создаем инстанс объекта менеджера автомобиля
			var autoMng = new AutoManager();

			// К свойству _myAuto класса AutoManager доступ невозможен, так как он объявлен как private.
			// autoMng._myAuto.Start();    // Ошибка компилятора
			// Стартуем менеджер
			autoMng.Run();
		}
	}
}

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

Результат работы данной программы:

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

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

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

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

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

Shape.cs:

namespace OOPLibrary.Shape
{
	/// <summary>
	/// Абстрактный класс фигур, инстанс данного класса создать невозможно,
	/// можно создавать только неабстрактных наследников
	/// </summary>
	public abstract class Shape
	{
		/// <summary>
		/// Свойство бумаги будет доступно во всех наследниках
		/// оно будет общим для всех наследников, поэтому
		/// в наследниках ненужно будет писать один и тот же код
		/// </summary>
		public string Paper { get { return "Белая бумага"; } }

		/// <summary>
		/// Свойство абстрактное, то есть в наследниках его нужно обязательно перекрыть,
		/// то есть описать логику повдеения этого свойства - это и есть полиморфизм
		/// </summary>
		public abstract string Name { get; }
		/// <summary>
		/// Метод абстрактный, то есть в наследниках его нужно обязательно перекрыть,
		/// то есть описать логику повдеения этого метода - это и есть полиморфизм
		/// </summary>
		public abstract void Draw();
	}
}

Класс Shape (Фигура), является абстрактным классом, и содержит внутри себя свойства и методы общие для всех фигур, которые могут быть созданы на основании данного класса (Круг, Прямоугольник, Треугольник и т.д.).

Circle.cs:

using System;

namespace OOPLibrary.Shape
{
	/// <summary>
	/// Класс описывающий круг наследованный от класса фигуры (Shape).
	/// Свойство Paper доступно и в классе Circle, хотя тут оно и не описано.
	/// </summary>
	public class Circle : Shape // наследование
	{
		// Свойства присущие только этому классу, которых не было у родителя
		// При приведении данного типа к базовому классу (Shape), эти свойства
		// будут недоступны. Пример будет показан в классе ShapeManager
		public int X1;
		public int Y1;
		public int Radius;

		// Конструктор для инициализации точек на координатной плоскости
		public Circle()
		{
			// точка центра круга
			X1 = 1; Y1 = 4;
			// радиус
			Radius = 3;
		}

		/// <summary>
		/// Имплементирует свойство из базового класса (наследование и полиморфизм)
		/// </summary>
		public override string Name
		{
			get { return "Круг"; }
		}
		/// <summary>
		/// Имплементирует метод из базового класса (наследование и полиморфизм)
		/// </summary>
		public override void Draw()
		{
			Console.WriteLine(String.Format("Рисуем круг с центром X1,Y1:({0},{1}) и радиусом {2}", X1, Y1, Radius));
		}
	}
}

Класс Circle (Круг) – унаследован от класса Shape, поэтому он получил все свойства и методы присущие в классе Shape. А так же данный класс добавляет свойства, которые присущи только кругу – это координаты центра круга и его радиус.

Rectangle.cs:

using System;

namespace OOPLibrary.Shape
{
	/// <summary>
	/// Класс описывающий прямоугольник наследованный от класса фигуры (Shape).
	/// Свойство Paper доступно и в классе Rectangle, хотя тут оно и не описано.
	/// </summary>
	public class Rectangle : Shape // наследование
	{
		// Свойства присущие только этому классу, которых не было у родителя
		// При приведении данного типа к базовому классу (Shape), эти свойства
		// будут недоступны. Пример будет показан в классе ShapeManager
		public int X1;
		public int Y1;
		public int X2;
		public int Y2;

		// Конструктор для инициализации точек на координатной плоскости
		public Rectangle()
		{
			// точка левого верхнего угла
			X1 = 1; Y1 = 4;
			// точка правого нижнего угла
			X2 = 6; Y2 = 1;
		}

		/// <summary>
		/// Имплементирует свойство из базового класса (наследование и полиморфизм)
		/// </summary>
		public override string Name
		{
			get { return "Прямоугольник"; }
		}
		/// <summary>
		/// Имплементирует метод из базового класса (наследование и полиморфизм)
		/// </summary>
		public override void Draw()
		{
			Console.WriteLine(String.Format("Рисуем прямоугольник X1,Y1:({0},{1}); X2,Y2:({2},{3});", X1, Y1, X2, Y2));
		}
	}
}

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

Triangle.cs:

using System;

namespace OOPLibrary.Shape
{
	/// <summary>
	/// Класс описывающий треугольник наследованный от класса фигуры (Shape).
	/// Свойство Paper доступно и в классе Triangle, хотя тут оно и не описано.
	/// </summary>
	public class Triangle : Shape // наследование
	{
		// Свойства присущие только этому классу, которых не было у родителя
		// При приведении данного типа к базовому классу (Shape), эти свойства
		// будут недоступны. Пример будет показан в классе ShapeManager
		public int X1;
		public int Y1;
		public int X2;
		public int Y2;
		public int X3;
		public int Y3;

		// Конструктор для инициализации точек на координатной плоскости
		public Triangle()
		{
			X1 = 1; Y1 = 1;
			X2 = 1; Y2 = 4;
			X3 = 6; Y3 = 1;
		}

		/// <summary>
		/// Имплементирует свойство из базового класса (наследование и полиморфизм)
		/// </summary>
		public override string Name
		{
			get { return "Треугольник"; }
		}
		/// <summary>
		/// Имплементирует метод из базового класса (наследование и полиморфизм)
		/// </summary>
		public override void Draw()
		{
			Console.WriteLine(String.Format("Рисуем треугольник X1,Y1:({0},{1}); X2,Y2:({2},{3}); X3,Y3:({4},{5});", X1, Y1, X2, Y2, X3, Y3));
		}
	}
}

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

На самом деле, во всех вышеприведенных классов, кроме наследования, показан также и полиморфизм. То есть абстрактные метод Draw и свойство Name были переопределены в каждом из наследников, а переопределение поведения и называется полиморфизмом.

Полиморфизм.

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

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

ShapeManager.cs:

using System;
using System.Collections.Generic;

namespace OOPLibrary.Shape
{
	/// <summary>
	/// Класс управления фигурами.
	/// </summary>
	public class ShapeManager
	{
		private Circle _circle;
		private Rectangle _rectangle;
		private Triangle _triangle;

		private List<Shape> _shapes;

		// Конструктор класса, в нем создаются первоначальные объекты
		public ShapeManager()
		{
			// Создаем объект круг
			_circle = new Circle();
			// Создаем объект прямоугольник
			_rectangle = new Rectangle();
			// Создаем объект треугольник
			_triangle = new Triangle();

			// Невозможно создать объект из абстрактного класса фигуры,
			// но можно создать объекты из его наследников: круга, прямоугольника и треугольника,
			// а также можно создать список и з абстрактных фигур, и положить в него объекты
			// наследников, но при проходе этого списка в цикле будут доступны только
			// общие поля и методы из абстрактоного класса Shape
			//Shape shape = new Shape();    // Ошибка компилятора

			// Создаем список фигур, в него можно положить те объекты,  // которые отнаследованы от класса Shape
			_shapes = new List<Shape>();
			_shapes.Add(_circle);        // добавляем круг в список фигур
			_shapes.Add(_rectangle);     // добавляем прямоугольник в список фигур
			_shapes.Add(_triangle);      // добавляем треугольник в список фигур
		}

		/// <summary>
		/// Метод вывводит информацию о круге
		/// </summary>
		private void ProntCircleInfo()
		{
			Console.WriteLine(_circle.Name);
			Console.WriteLine("X1: " + _circle.X1);
			Console.WriteLine("Y1: " + _circle.Y1);
			Console.WriteLine("Радиус: " + _circle.Radius);
			_circle.Draw();
			Console.WriteLine();
		}

		/// <summary>
		/// Метод вывводит информацию о прямоугольнике
		/// </summary>
		private void PrintRectangleInfo()
		{
			Console.WriteLine(_rectangle.Name);
			Console.WriteLine("X1: " + _rectangle.X1);
			Console.WriteLine("Y1: " + _rectangle.Y1);
			Console.WriteLine("X2: " + _rectangle.X2);
			Console.WriteLine("Y2: " + _rectangle.Y2);
			_rectangle.Draw();
			Console.WriteLine();
		}

		/// <summary>
		/// Метод вывводит информацию о треуголнике
		/// </summary>
		private void PrintTriangleInfo()
		{
			Console.WriteLine(_triangle.Name);
			Console.WriteLine("X1: " + _triangle.X1);
			Console.WriteLine("Y1: " + _triangle.Y1);
			Console.WriteLine("X2: " + _triangle.X2);
			Console.WriteLine("Y2: " + _triangle.Y2);
			Console.WriteLine("X3: " + _triangle.X3);
			Console.WriteLine("Y3: " + _triangle.Y3);
			_triangle.Draw();
			Console.WriteLine();
		}

		/// <summary>
		/// Метод выводит общую информацию для всех наследников,
		/// находящихся в списке фигур
		/// </summary>
		private void PrintCommonShapeInfo()
		{
			foreach (var shape in _shapes)
			{
				// общие свойства доступны для всех фигур (Name и Paper).
				// независимо от того какая конкретная фигура, будет находится
				// в данный моемент в переменно shape доступ к ее полям,
				// например X1, Y1, Radius будут недоступны без предварительного
				// явного приведения к конкретному типу (Circle, Triangle...)
				Console.WriteLine(String.Format("{0} будет нарисован на '{1}'...", shape.Name, shape.Paper));
				// метод доступен для всех фигур, но при помощи полиморфизма,
				// он перекрты в каждом наследнике, таким образом,
				// чтобы каждый объект мог реализовать свой механизм отрисовки самомго себя.
				// поэтому в runtime будет подставлен нужный метод конкретного наследника,
				// несмотря на то, что список хранит абстрактные фигуры
				shape.Draw();
				Console.WriteLine();
			}
		}
		/// <summary>
		/// Метод запускает проверку методов и свойств фигур и их наследников.
		/// </summary>
		public void Run()
		{
			// выводим информацию, доступную для круга
			ProntCircleInfo();
			// выводим информацию, доступную для прямоугольника
			PrintRectangleInfo();
			// выводим информацию, доступную для треугольника
			PrintTriangleInfo();
			// проверяем возможности полиморфизма
			PrintCommonShapeInfo();
		}
	}
}

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

Program.cs:

using OOPLibrary.Shape;

namespace OOPLibrary
{
	public class Program
	{
		public static void Main()
		{
			// Создаем инстанс объекта менеджера фигур
			var shapeMng = new ShapeManager();
			// Стартуем менеджер
			shapeMng.Run();
		}
	}
}

Результат работы данной программы:

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

Общаясь со многими ребятами, которые желают научиться программировать, я натыкаюсь на одну тему, которая вначале для них кажется очень сложной и неподъёмной – это ООП (Объектно-ориентированное программирование). Многим начинающим всегда кажется, что процедурное программирование проще. Не исключено что в этом есть доля правды, но давайте подумаем, какими терминами привыкли мы мыслить в повседневной жизни.

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

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

Есть три основных столпа ООП:

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

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

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

Класс – это как бы аналог чертежа, на основании которого можно построить много одинаковых домов – объектов. Поэтому класс только описывает объект, но не создает его.

Иногда бывает так, что из доступа к базе данных бывает только доступ через phpMyAdmin. А также бывает, что кто-то, создал базу с неправильной кодировкой. В моем случае этой кодировкой была — шведская. Что же делать для того чтобы поменять кодировку на более нужную — к примеру utf8?

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

ALTER TABLE tbl_name CONVERT TO CHARACTER SET charset_name [COLLATE collation_name]

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

Итак, MySQL сервер версии 5.0 и выше, умеет выполнить вот такой вот запрос:

SELECT CONCAT('ALTER TABLE `', t.`TABLE_SCHEMA`, '`.`', t.`TABLE_NAME`, '` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;') as sqlcode
  FROM `information_schema`.`TABLES` t
 WHERE 1
   AND t.`TABLE_SCHEMA` = 'db_name'
 ORDER BY 1

в этом запросе, вместо db_name необходимо поменять на реальное имя базы данных, кодировку которой вы собираетесь менять.

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

ALTER TABLE `mydatabase`.`auth_group_permissions` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`auth_group` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`auth_message` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`auth_permission` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`auth_user_groups` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`auth_user_user_permissions` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`auth_user` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`blog_post` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`django_admin_log` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`django_comments` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`django_comment_flags` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`django_content_type` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`django_session` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`gallery_album` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`gallery_photo` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`gallery_video` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;
ALTER TABLE `mydatabase`.`members_userprofile` CONVERT TO CHARACTER SET utf8 COLLATE utf8_general_ci;

Вот теперь можно копировать результирующий скрипт и выполнять его в окошке SQL зпросов. Результатом выполнения данного скрипта будет изменение кодировки во всех таблицах MySQL базы данных.

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

Иногда у людей возникает вопрос: какая разница между фреймворком и архитектурой.

Совершенно случайно увидел обалденный ответ на Stack Overflow. Размещу его и у себя.

Фреймворк (Framework):

Архитектура (Architecture):

По другому можно еще сказать так: архитектура — теория,  фреймворк — ее реализация.

Прежде чем переходить к дальнейшему рассмотрению HTML, в частности тега <body>, необходимо разобраться, хотя бы, с основными понятиями CSS.

Итак, CSS (Cascading Style Sheets — каскадные таблицы стилей) — технология описания внешнего вида документа, написанного языком разметки, в основном это будет HTML. Или, другими словами — это технология, которая позволит изменять цвета, стиль шрифта, размер блоков (элментов, тегов языка HTML).

Для чего придумли CSS?

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

<h1>Это заголовок</h1>
<p>Это абзац.</p>

Здесь тег <h1> показывает, что текст внутри него будет заголовком, без указания каким стилем его отобразить. Точно таким же образом, тег <p> указывает бразуеру, что текст внутри него является абзацем.

Когда теги визуализации, такие как <font>, и цветовые атрибуты были добавлены в спецификацию HTML 3.2, начался кошмар для веб-разработчиков. Развитие больших веб-сайтов, где шрифты и цветовую информацию необходимо было добавлять на каждую страницу, стало долгим и дорогостоящим процессом.

Для решения этой проблемы, World Wide Web Consortium (W3C) создал CSS.

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

При рендеринге страницы, стили для ее отображения, могут быть взяты из нескольких источников:

• Авторские стили — стили, которые указал разработчик веб страницы, они могут быть указаны несколькими способами:
  • Внешняя таблица стилей — располагается во внешнем файле стилей, с расширением .css, и подключается к документу, при помощи ссылки на внешний файл, расположенной в секции <head> HTML-документа.
  • Встроенные стили — блоки CSS располагаются внутри самого HTML-документа, опять же в секции <head>.
  • Inline-стили — указание стиля элемента непосредственно в определенном элементе, а точнее в его атрибуте style.
• Пользовательские стили — стили изменные конечным пользователем вручную
  • Локальный CSS-файл — пользователь, указывает в настройках браузера путь к CSS файлу из которого браузер должен брать стили. При этом данный файл переопределяет авторские стили, и применяемый ко всем документам.
• Стиль браузера — стили, которые заложены в браузере для элементов по умолчанию
  • Стандартный стиль, используемый браузером по умолчанию для представления элементов.

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

Например:

div, p {
  font-family: "Arial", sans-serif;
  color: red;
  background: white;
}

данный набор стилей определяет семейство шрифтов, цвет текста и его фон ко всем элементам заключенным в теги <div> и <p>. Таким образом можно переопределить отображение любого тега в HTML документе.

Думаю, что для начального знакомстав с CSS, данной информации будет достаточно.

Намного удобнее за компом, когда тебе не мешают провода. При использовании wi-fi сетей, одним кабелем становиться меньше, и радость от работы в сети интернет возрастает.

При взгляде на структуру HTML документа, видно, что она состоит из трех основных секций.

• <html> – корень любого HTML документа, в котором располагаются все остальные секции (данный тег должен быть в единственном экземпляре, и должен присутствовать на каждой странице).
• <head> – заголовок в котором прописывается служебная информация и инструкции браузеру, по отображению контента.
• <body> – основная секция в которой находится контент, то есть вся полезная информация (текст, картинки, видео). Помимо контента, в этой секции расположена сетка сайта, либо его макет – описано местоположения основных разделов сайта, таких как: шапка, подвал, главное меню, боковые колонки, и т.д.

Тег <html> ничем особым не отличается, кроме того, что это есть корневой элемент – контейнер для всех остальных блоков. Поэтому приступим к более детальному рассмотрению секции <head>.

Элементы данной секции напрямую не показываются на веб странице. Единственный тег из данной секции, который будет отображать информацию – это тег <title>. В теге <title>, секции <head>, прописывается заголовок веб-страницы этот текст будет выведен в строке заголовка окна браузера.

<html>
  <head>
    <title>Заголовок, будет выведен в строке заголовка браузера</title>
  </head>
  <body>
    <!—Тут будет размещен контент—>
  </body>
</html>

Данный тег является единым обязательном тегом в секции <head>.

Кроме тега <title>, в этой секции можно размещать следующие теги: <link>, <meta>, <script>, <style>.

Тег <link>

Этот тег указывает браузеру где находятся некие внешние ресурсы, например, внешние стили (CSS). Также при помощи тега <link> и указания соответствующего атрибута rel, можно указать адрес канала RSS, фавиконку для сайта, и другие внешние ресурсы.

<head>
  <link rel="stylesheet" type="text/css" href="theme.css" />
  <link rel="alternate" type="application/rss+xml"
        title="Генеральский чай" href="http://generaltea.ru/feed/">
  <link rel="shortcut icon" href="http://generaltea.ru/favicon.ico">
</head>

Тег <meta>

Это универсальный тег, который описывает данные. Тег <meta> предоставляет метаданные о документе HTML браузеру. Метаданные, не отображаются, а только используются для служебных целей, либо движком браузера, либо поисковыми пауками. Мета элементы, как правило, используется для описания страницы (description), указания ключевых слов (keywords), указание автора документа (author), указания типа контента и его кодировки, и другие метаданные.

<head>
  <meta name="description" content="Описание отсюда, выводится поисковиками" />
  <meta name="keywords" content="HTML,CSS,верстка" />
  <meta name="author" content="Sergii Mykhailov" />
  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
</head>

Тег <script>

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

<head>
  <script type="text/javascript"
          src="http://generaltea.ru/wp-includes/js/jquery/jquery-v1.4.2.js">
  </script>
</head>

либо же, вставить скрипт прямо в данную секцию:

<head>
  <script type="text/javascript">
    document.write("Hello World!")
  </script>
</head>

Тег <style>

Данный тег можно использовать, для того, чтобы задать стили, необходимые, только для этой странички, а также, если нету необходимости подключать внешний файл стилей, при помощи тега <link>. Можно задавать более чем один тег <style>

<head>
  <style type="text/css">
    h1 {color: red}
    p  {color: blue}
  </style>
</head>

Вот и вся информация, которую необходимо знать о секции <head>. Далее будем рассматривать секцию <body>, которая будет содержать основной контент веб странички.

Описание DOCTYPE будет неполным, если не привести таблицу, в которой указано, какой из тегов HTML поддерживается тем или иным объявлением DOCTYPE.

Поэтому пользуемся этим замечательным справочником, оригинал которого можно найти на сайте w3schools.com.

При использовании таблицы, не забываем о том что в спецификациях с приставкой X, необходимо придерживаться правил оформления веб-документа по спецификации XML. То есть, все теги должны быть обязательно закрыты. Все теги должны иметь общего родителя, которым в HTML документе является тег <html></html>. Все атрибуты должны быть заключены в кавычки.

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

Как я заметил в посте Основы HTML. Структура документа, первой строкой в документе HTML, должно идти объявление DOCTYPE. Этим постом, я расскажу что это такое и с чем его едят.

Определение DOCTYPE - это не тег HTML, а инструкция веб-браузеру, указывающая, на какой версии языка HTML написан документ (веб страничка).

DOCTYPE ссылается на определение типа документа (DTD — Document Type Definition). DTD задает правила для языка разметки, для того чтобы браузеры могли правильно отобразить содержание веб странички.

Рассмотрим все доступные варианты DOCTYPE по рекомендации W3C.

HTML 4.01 Strict

Этот DTD содержит все HTML элементы и атрибуты, но не включает презентационные или устаревшие элементы (например: тег font). Использование фреймов не допускается.

<!DOCTYPE HTML PUBLIC "- / / W3C / / DTD HTML 4.01 / / EN"
          "http://www.w3.org/TR/html4/strict.dtd">

HTML 4.01 Transitional

Данный DTD содержит все HTML элементы и атрибуты, включая презентационные и устаревшие элементы (например: тег font). Использование фреймов в документе объявленном с таким DOCTYPE также не допускается.

<!DOCTYPE HTML PUBLIC "- / / W3C / / DTD HTML 4.01 Transitional / / EN"
          "http://www.w3.org/TR/html4/loose.dtd">

HTML 4.01 Frameset

Следующий DTD, такой же как и HTML 4.01 Transitional, но позволяет использование фреймов в содержании документа.

<!DOCTYPE HTML PUBLIC "- / / W3C / / DTD HTML 4.01 Frameset / / EN"
          "http://www.w3.org/TR/html4/frameset.dtd">

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

XHTML 1.0 Strict

DTD, который содержит все HTML элементы и атрибуты, но не включает презентационные или устаревшие элементы (например, все тот же, тег font). Использование фреймов не допускается. Разметка веб страницы должна быть оформлена по всем правилам документа XML. То есть, все теги должны быть обязательно закрыты. Все теги должны иметь общего родителя, которым в HTML документе является тег <html></html>. Все атрибуты должны быть заключены в кавычки.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

В настоящее время, как по мне, данный DOCTYPE является наиболее предпочтительным для наиболее валидной верстки.

XHTML 1.0 Transitional

И еще один переходной DTD, который содержит все HTML элементы и атрибуты, включая презентационные и устаревшие элементы (например: тег center). Использование фреймов, данный DTD, также не допускает. Разметка веб страницы тоже должна быть оформлена по всем правилам документа XML.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

XHTML 1.0 Frameset

И еще один DTD с фреймами, аналогичен XHTML 1.0 Transitional, но позволяет использование фреймов в содержании веб документа.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"
          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">

XHTML 1.1

И последний DTD, аналогичен XHTML 1.0 Strict, но позволяет добавлять модули (например, обеспечить поддержку Ruby для Восточно-азиатских языков).

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
          "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

В следующем посте можно будет посмотреть на таблицу всех HTML / XHTML элементов, которые поддерживаются в той или иной DTD.

Для проверки валидности HTML документа можно воспользоваться валидатором W3C Validator.

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

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

Итак, выглядит это примерно так:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
          "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html>
  <head>
    <!-- служебная информация располагается в голове –>
  </head>
  <body>
    <!-- описание самого документа, то есть его тело –>
  </body>
</html>

А теперь рассмотрим этот пример под микроскопом.

Самой первой строчкой идет объявление типа документа, так называемый DOCTYPE. Эта строка является очень важной, так как, она указывает браузеру, какую версию HTML движка, он должен использовать для рендеринга этого документа, в случае неправильного указания, некоторые элементы оформления могут “съезжать”.

Далее идет тег <html>, который является корневым элементом. С него начинается вся разметка HTML документа, этот тег является контейнером для всех остальных тегов.

HTML документ, всегда, разбит на две части:

• голову — тег <head>
• тело – тег <body>

В секции head размещается служебная информация, такая как:

• заголовок страницы – тег <title>
• ссылки на CSS файлы, и RSS потоки – <link>
• также могут размещаться ссылки на скрипты, либо сами скрипты, но это не желательно, в целях повышения производительности, скрипты лучше выносить в самый низ документа, перед закрывающим тегом </body>.

В секции <body> помещаются все теги, которые будут описывать структуру страницы:

• блоки – <div>
• праграфы – <p>
• ссылки – <a>
• списки – <ul>, <ol>
• картинки – <img />
• таблицы – <table>
• и иные элементы разметки документа

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

При использовании фреймворка ASP.NET MVC, есть возможность использования серверной и клиентской валидации при помощи атрибутов из пространства
имен DataAnnotations.

Для отображения ошибок полей ввода, можно воспользоваться расширениями для отображения сообщений об ошибках, входящими в фреймворк ASP.NET MVC:

Html.ValidationMessage
Html.ValidationMessageFor
Html.ValidationSummary

Расширения Html.ValidationMessage и Html.ValidationMessageFor, предназначены для отображения ошибок ввода для конкретного поля, а Html.ValidationSummary — отображает все ошибки, как относящиеся к полям, так и добавленные в словарь ModelState вручную из контроллера.

У расширения Html.ValidationSummary имеется булевый атрибут, который управляет отображением ошибок, при значении true будут исключены ошибки полей и отображены только ошибки модели, а при значении false (оно включено по умолчанию) будут показаны и ошибки полей и ошибки модели.

При использовании нижеприведенного кода для своего приложения, я столкнулся с одной странностью. При возникновении исключения в строке:

MembersManager.RegisterMember(member);

в секции catch добавляется ошибка в словарь ModelState, следующим образом:

ModelState.AddModelError("error", ex.Message);

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

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

Модель (Model):

public class Member
{
    [Required(ErrorMessage = "*")]
    [DisplayName("Login:")]
    public string Login { get; set; }

    [Required(ErrorMessage = "*")]
    [DataType(DataType.Password)]
    [DisplayName("Password:")]
    public string Password { get; set; }
    [Required(ErrorMessage = "*")]
    [DataType(DataType.Password)]
    [DisplayName("Confirm Password:")]
    public string ConfirmPassword { get; set; }
}

Контроллер (Controller):

[HttpPost]
public ActionResult Register(Member member)
{
    try
    {
        if (!ModelState.IsValid)
            return View();

        MembersManager.RegisterMember(member);
    }
    catch (Exception ex)
    {
        ModelState.AddModelError("error", ex.Message);
        return View(member);
    }
}

Представление (View):

<% using (Html.BeginForm("Register", "Members", FormMethod.Post, new { enctype = "multipart/form-data" })) {%>

    <p>
        <%= Html.LabelFor(model => model.Login)%>
        <%= Html.TextBoxFor(model => model.Login)%>
        <%= Html.ValidationMessageFor(model => model.Login)%>
    </p>

    <p>
        <%= Html.LabelFor(model => model.Password)%>
        <%= Html.PasswordFor(model => model.Password)%>
        <%= Html.ValidationMessageFor(model => model.Password)%>
    </p>

    <p>
        <%= Html.LabelFor(model => model.ConfirmPassword)%>
        <%= Html.PasswordFor(model => model.ConfirmPassword)%>
        <%= Html.ValidationMessageFor(model => model.ConfirmPassword)%>
    </p>

    <div>
        <input type="submit" value="Create" />
    </div>

    <%= Html.ValidationSummary(true)%>
<% } %>

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

Как выяснилось ValidationSummary, ищет ошибки модели, которые привязаны к полям (в качестве ключа словаря ModelState передаются имена полей). Поэтому достаточно было в качестве ключа, при добавлении ошибки в ModelState, передать пустую строку

ModelState.AddModelError(String.Empty, ex.Message);

и все стало работать именно так, как и задумывалось

P.S. При использовании классов LINQ To SQL, может возникнуть необходимость пробежаться по набору EntitySet при помощи цикла foreach, но тут может возникнуть ошибка приведения типов. По ссылке можно увидеть решение данной проблемы.

А вы знаете как заработать деньги в интернете — заходите, расскажем.