.1 Глобальные пространства имен.
Работа добавлена на сайт samzan.net:
Пространства имен. Ключевое слово using.
Пространство имен, вложенное по умолчанию.
Препроцессор. Препроцессорные операторы.
Компоновочные файлы.
Модификатор Internal
СОДЕРЖАНИЕ
1 Простраство имен ……………………………………………………… 2
1.1 Глобальные пространства имен…………………………………. 2
№ 1…………………………………………………………………. 4
1.2 Объявление пространства имен…………………………………. 5
№ 2………………………………………………………………… 6
1.3 Объявления внутри пространства имен………………………… 8
№ 3…………………………………………………………………. 8
1.4 Директива using………………………………………………….. 11
№ 4………………………………………………………………… 13
1.5 Использование псевдонимов пространства имен……………… 16
№ 5………………………………………………………………… 16
1.6 Вложенные пространства имен…………………………………. 18
№ 6………………………………………………………………… 18
№ 7………………………………………………………………… 19
2 Сборки и компоновочные файлы……………………………………. 21
№ 8…………………………………………………………………. 22
3 Препроцессор………………………………………………………… 23
3.1 Задача генерации “хороших” случайных чисел………………… 24
№ 9…………………………………………………………………. 25
№ 10………………………………………………………………… 26
№ 11………………………………………………………………… 27
№ 12………………………………………………………………… 28
Рассматриваемые и применяемые в данной работе средства языка программирования С# (постранство имен, препроцессорных операторов, сборок) служат для улучшения структуры программы и повышения устойчивости взаимодействия ее компонентов.
1 Пространство имен
Под пространством имен понимается ограниченная область взаимодействия хранящихся в нем имен классов, полей и методов. Текст программы может содержать множество отдельных пространств имен, в каждом из которых используется неповторяющийся набор имен, но допускающий любой уровень повторения в разных пространствах. Механизм пространства имен упрощает технологию выбора имен и позволяет избежать конфликта имен при разработке и отладке больших программных проектов. В С# используется глобальное пространство имен System, которое реализуется обязательным включением в каждую программу текста (оператора) using System;. Для простых программ этого достаточно, чтобы контролировать правильное использование имен (их уникальность).
Типовая задача пространства имена локализовать видимость имен, объявленных внутри него. Это гарантирует устранения конфликта имен, что особенно важно при разработке больших пограммных проектов.
- Объявление постранства имен
Для создания пространства имен используется ключевое слово namespace. Структора объявления пространства имен имеет вид:
namespace имя {
// члены
}
Внутри пространства имен членами могут быть объявлены классы, структуры, делегаты, перечисления, интерфейсы или другие пространства имен .
В рассматриваемых далее примерах используется применение автоматически реализуемых свойств.
Обычно часто встречается код такого вида:
class MyClass
{ private int _field = 0;
public int Field { get { return _field; } set { _field = value; } }
}
В языке C# 4.0 для приведенной конструкции применяется сокращенный вариант:
class MyClass
{ public int Field { get; set; }
// Теперь необходимо инициализировать value в конструкторе
public MyClass()
{
this.Field = 0;
}
}
С учетом такой замены ниже приведен пример типовой структуры текста программы с пространством имен MyNameSpace для класса class MyClass:
// Пространство имен MiyNameSpace
namespace MyNameSpace
{
// Класс MyClase, обрабатываемый в пространстве имен
class MyClass
{
// Сокращенный вариант свойств для каждого типа данных
Public string MyItemstr { get; set; }
public int Myitemint { get; set; }
// Конструктор класса
public MyClass() { }
// Вывод информации о полях пространства имен
public void WriteInfo() { }
// Работа с дополнительной информацией
public void Complementary( ) { }
}
}
// Пространство имен MyProgram - можно обойтись без этого пространства
namespace MyProgram
{
class Program
{
public static void Main()
{ // При создании ссылки приходится имена начинать с имени пространства имен, в нашем случае
// MyNameSpace.MyClass Refer = new MyNameSpace.MyClass(); , вместо MyClass Refer = new MyClass()
MyNameSpace.MyClass Refer = new MyNameSpace.MyClass();
// Заполняем поля класса MyClass
Refer.Name1 = ??;
……….
Refer.NameK = ????;
// Вывод текущей информации
Refer . WriteInfo();
}
}
}
№ 1
/* В примере программы рассматриваются два различных университета (для них организуются два различных пространства имен namespace University1 и namespace University2), которые имеют одинаковые (это не обязательно) факультеты (class Faculty) и для каждого из них сообщается имя факультета и количество их студентов. Для каждого факультета организуются ссылки CIT1 и CIT2, с помощью которых организуется вывод необходимой информации (используется метод WriteInfo()). Результаты приведены на рис 1.
*/
// Первая программа демонстрации пространства имен
using System;
using System.Collections.Generic;
using System.Text;
namespace University1 // Объявление пространства имен University1
{
/*Класс Faculty, содержащийся в пространстве имен University1 */
class Faculty
{ public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся студентов
/* Метод WriteInfo - метод выводит информацию о факультете следующим образом:
название факультета + количество обучающихсяс студентов.
*/
public void WriteInfo() {
Console.WriteLine(" At faculty '" + FacultyName + "' \n are qualifing "
+ StudentsNumber + " students");
}
/* Конструктор класса Faculty */
public Faculty() {
}
}
}
namespace University2 // Объявление пространства имен University2
{
/* Класс Faculty, содержащийся в пространстве имен University2 */
class Faculty
{ public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся студентов
/* Метод WriteInfo()-метод выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo() {
Console.WriteLine(" There are qualifing " + StudentsNumber
+ " students \n at the faculty '" + FacultyName + "'");
}
/* Конструктор класса Faculty */
public Faculty() {
}
}
}
namespace ExampleApp
{
class Program
{ static void Main()
{ // Cоздаем обект класса Faculty в пространстве имен University1
University1.Faculty CIT1 = new University1.Faculty();
/* Несмотря на то, что пространства имен избавляют от конфликтов имен объявленных класов, в глобальном пространстве имен мы не можем создать два объкта этих классов с одинаковым именем. Cоздаем обект класса Faculty, объявленного в пространстве имен University2
*/
University2.Faculty CIT2 = new University2.Faculty();
// Заполняем поля класса Faculty, объявленного в namespace University1
CIT1.FacultyName = "Computer and Information technology";
CIT1.StudentsNumber = 79;
// Заполняем поля класса Faculty, объявленного в namespace University2
CIT2.FacultyName = "Computer and Information technology";
CIT2.StudentsNumber = 65;
// Выводим текущую информацию о каждом факультете
Console.WriteLine("\n Faculty in namespace University1");
CIT1.WriteInfo();
Console.WriteLine("\n Faculty in namespace University2");
CIT2.WriteInfo();
Console.ReadKey();
}
}
}
Рис 1 Результат применения пространства имен
- Применение ключевого слова using для создания пространства имен
В предыдущем примере обращено внимание на необходимость описания ссылочных имен начинать с имени пространства имен, что при большом количестве параметров вызывает определенные затруднения. Этого можно избежать, если использовать перед описанием пространства имен директиву using. Эта директива имеет две формы:
первая форма: using имя; // имя пространства имен
вторая форма: using псевдоимя = имя;// псевдоимя – еще одно имя для класса
//или пространства имен, заданного элементом имя (рассматривается в разд. 1.4)
Ниже приводится структура первой формы:
// Делаем текущим пространство имен MyNameSpace
using MiyNameSpace; // Применена первая форма using
// Пространство имен MiyNameSpace
namespace MyNameSpace
{ // Класс MyClass, обрабатываемый в пространстве имен
class MyClass
{ // Сокращенный вариант свойств для каждого типа данных
public string MyItemstr { get; set; }
public int Myitemint { get; set; }
// Конструктор класса
public MyClass() { }
// Вывод информации о полях пространства имен
public void WriteInfo() { }
// Работа с дополнительной информацией
public void Complementary( ) { }
}
}
// Пространство имен MyProgram - можно обойтись без этого пространства
namespace MyProgram
{ class Program
{ public static void Main()
{ // Теперь класс MyClass можно использовать без указания имени пространства имен
MyClass Refer = new .MyClass();
// Теперь можно переходить к тексту программы
В приводимом тексте программы использовано два пространства имен для каждого университета. Для контрастности использование первой формы using применена только для первого пространства, второе оставлено без изменения.
№ 2
using System;
using System.Collections.Generic;
using System.Text;
// Используем директиву using для доступа к членам пространства имен University1
using University1;
// Объявление пространства имен University1
namespace University1
{
//Класс Faculty, содержащийся в пространстве имен University1
class Faculty
{
public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // Количество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo() {
Console.WriteLine(" At faculty '" + FacultyName + "' \n are qualifing "
+ StudentsNumber + " students");
}
//Конструктор класса Faculty
public Faculty() {
}
}
}
namespace University2 // Объявление пространства имен University2
{
// Класс Faculty, содержащийся в пространстве имен University2
class Faculty
{ public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // Количество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo() {
Console.WriteLine(" There are qualifing " + StudentsNumber
+ " students \n at the faculty '" + FacultyName + "'" );
}
// Конструктор класса Faculty
public Faculty() {
}
}
}
namespace ExampleApp
{ class Program
{ static void Main() {
// Создаем обект класса Faculty, объявленного в пространстве имен University1.
Faculty CIT1 = new Faculty();
// В связи с использованием директивы using для этого пространства имен
// нет необходимости использовать оператор "." для доступа к членам
// данного пространства имен.
// Cоздаем объект класса Faculty, объявленного в пространстве имен University2
// Для создания объекта класса Faculty в пространстве имен University2
// необходимо использовать оператор ".".
University2.Faculty CIT2 = new University2.Faculty();
// Заполняем поля класса Faculty, объявленного в namespace University1
CIT1.FacultyName = " Computer and Information technology ";
CIT1.StudentsNumber = 79;
// Заполняем поля класса Faculty, объявленного в namespace University2
CIT2.FacultyName = " Computer and Information technology ";
CIT2.StudentsNumber = 65;
// Выводим текущую информацию о каждом из факультетов
Console.WriteLine("\n Faculty in namespace University1");
CIT1.WriteInfo();
Console.WriteLine("\n Faculty in namespace University2");
CIT2.WriteInfo();
Console.ReadKey();
}
}
}
Рис 2 Результат применения первой формы using University1
- Применение первой формы using для двух пространств времен
В данном примере рассматривается ситуация, при которой оба пространства имен подключены с помощью директивы using. Также в пространства имен University1 и University2 добавлены классы Faculty1 и Facultу2 соответственно. Тогда для создания объекта класса Faculty необходимо использовать оператор «.», т.к. в глобальном пространстве имен возникает неоднозначность и необходимо уточнять, в каком пространстве имен находится необходимый нам класс. Для создания объектов классов Faculty1 и Facultу2 использование оператора «.» не обязательно.
№ 3
using System;
using System.Collections.Generic;
using System.Text;
using University1; // Используем директиву using для доступа к членам
// пространства имен University1
using University2; // Используем директиву using для доступа к членам
// пространства имен University2
namespace University1 // Объявление пространства имен University1
{
// Класс Faculty, содержащийся в пространстве имен University1
class Faculty
{
public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{
Console.WriteLine("\n At faculty '" + FacultyName +
"' \n are qualifing " + StudentsNumber + " students");
}
/* Конструктор класса Faculty
@params facultyName - название факультета
@params studentsNumber - число обучающихся студентов.
*/
public Faculty(string facultyName, int studentsNumber)
{
FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
// Класс Faculty1, содержащийся в пространстве имен University1
class Faculty1
{
public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // Kоличество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{
Console.WriteLine("\n There are qualifing " + StudentsNumber
+ " students \n at the faculty '" + FacultyName + "'" );
}
/* Конструктор класса Faculty1
@params facultyName - название факультета
@params studentsNumber - количество обучающихся студентов.
*/
public Faculty1(string facultyName, int studentsNumber)
{
FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
}
namespace University2 // Объявление пространства имен University2
{
// Класс Faculty, содержащийся в пространстве имен University2
class Faculty
{
public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{
Console.WriteLine("\n There are qualifing " + StudentsNumber +
" students \n at the faculty '" + FacultyName + "'" );
}
/* Конструктор класса Faculty
@params facultyName - название факультета
@params studentsNumber - количество обучающихся студентов.
*/
public Faculty(string facultyName, int studentsNumber)
{
FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
// Класс Faculty2, содержащийся в пространстве имен University2
class Faculty2
{
public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{
Console.WriteLine(" At faculty '" + FacultyName +
"' \n are qualifing " + StudentsNumber + " students");
}
/* Конструктор класса Faculty2
@params facultyName - название факультета
@params studentsNumber - количество обучающихся студентов.
*/
public Faculty2(string facultyName, int studentsNumber)
{
FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
}
namespace ExampleApp
{
class Program
{ static void Main()
{
/* Для избежания конфликта имен при создании объектов класса Faculty
используем оператор "." и указываем к какому пространству имен принадлежит данный класс. В данном случае создаются объекты классов Faclty в каждом пространстве имен.
*/
University1.Faculty CIT1 = new University1.Faculty(" Computer and Information technology",79);
University2.Faculty CIT2 = new University2.Faculty(" Computer and Information technology",65);
/* В данном случае нет необходимости указывать к какому пространству имен относятся классы Faculty1 и Faculty2,так как они не вступают между собой в конфликт в глобальном пространстве имен.
*/
Faculty1 IF = new Faculty1(" Informatics and Management", 57);
Faculty2 AP = new Faculty2(" Automation and Instrumentation", 68);
// Выводим текущую информацию о каждом из факультетов
Console.WriteLine("\n Faculty in namespace University1\n");
CIT1.WriteInfo();
Console.WriteLine();
IF.WriteInfo();
Console.WriteLine("\n Faculty in namespace University2\n");
CIT2.WriteInfo();
Console.WriteLine();
AP.WriteInfo();
Console.ReadKey();
}
}
}
Рис 3 Результат применения первой формы using для всех постранств имен
- Создание пространства имен с расширенной формой using
Ранее была описана общая структура расширенной формы using в виде
using псевдоимя = имя;
В нашем случае для пространства имен University форма using будет такой:
using Uni = University;
Ниже приведена структура текста программы, которая упрощает детальное знакомство с полным текстом самой программы. Основой самой программы есть текст пограммы задачи № 3.
// Со здаем псевдоимена Uni1 и Uni2 пространств имен University1 и University2
using Uni1 = University1; // Применена вторая форма using
using Uni2 = University2; // Применена вторая форма using
// Объявляем пространство имен University1
namespace University1;
{ // Класс Faculty, обрабатываемый в пространстве имен
class Faculty
{ // Сокращенный вариант свойств для каждого типа данных
public string FacultyName { get; set; }
public int StudentsNumber { get; set; }
// Конструктор класса
public Faculty(string facultyName, int studentsNamber ) { }
// Вывод информации о полях пространства имен
public void WriteInfo() { }
// Работа с дополнительной информацией
public void Complementary( ) { }
}
// Класс Faculty1, обрабатываемый в пространстве имен
class Faculty1
{ // Сокращенный вариант свойств для каждого типа данных
public string FacultyName { get; set; }
public int StudentsNumber { get; set; }
// Конструктор класса Faculty1
public Faculty1(string facultyName, int studentsNamber ) { }
// Вывод информации о полях пространства имен
public void WriteInfo() { }
// Работа с дополнительной информацией
public void Complementary( ) { }
}
}
// Объявляем пространство имен University2
namespace University2;
{ // Класс Faculty, обрабатываемый в пространстве имен
class Faculty
{ // Сокращенный вариант свойств для каждого типа данных
public string FacultyName { get; set; }
public int StudentsNumber { get; set; }
// Конструктор класса
public Faculty(string facultyName, int studentsNamber ) { }
// Вывод информации о полях пространства имен
public void WriteInfo() { }
// Работа с дополнительной информацией
public void Complementary( ) { }
}
// Класс Faculty2, обрабатываемый в пространстве имен
class Faculty2
{ // Сокращенный вариант свойств для каждого типа данных
public string FacultyName { get; set; }
public int StudentsNumber { get; set; }
// Конструктор класса Faculty2
public Faculty2(string facultyName, int studentsNamber ) { }
// Вывод информации о полях пространства имен
public void WriteInfo() { }
// Работа с дополнительной информацией
public void Complementary( ) { }
}
}
// Пространство имен ExampleApp - можно обойтись без этого пространства
namespace ExampleApp
{ class Program
{ public static void Main()
{ // Теперь для создания ссылок CIT1 и CIT2 можно использовать псевдоимена Uni1 и Uni2 вместо // University1 и University2
Uni1.Faculty CIT1 = new Uni1.Faculty();
Uni2.Faculty CIT2 = new Uni2.Faculty();
// Faculty1 и Faculty2 не конфликтуют, так как находятся в разных пространствах, поэтому для них
// можно записать ссылки IF и AP, не используя псевдоимена
Faculty1 IF = new Faculty1();
Faculty2 AP = new Faculty2();
// Далее организуется вывод результатов
……………………………………………
Console.ReadKey();
}
}
}
Далее по приведенной структуре составляется полный текст программы
№ 4
// Использование псевдоимен
using System;
using System.Collections.Generic;
using System.Text;
using University1;
using University2;
using Uni1 = University1; // Объявляем псевдоним пространства имен University1
using Uni2 = University2; // Объявляем псевдоним пространства имен University2
namespace University1 // Объявление пространства имен University1
{ // Класс Faculty, содержащийся в пространстве имен University1
class Faculty
{ public string FacultyName { get; set; }// Название факультета
public int StudentsNumber { get; set; }//Kоличество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество студентов, обучающихся на нем.
*/
public void WriteInfo()
{ Console.WriteLine("\n At faculty '" + FacultyName
+ "' \n are qualifing " + StudentsNumber + " students");
}
/* Конструктор класса Faculty
@params facultyName - название факультета
@params studentsNumber - количество обучающихся студентов.
*/
public Faculty(string facultyName, int studentsNumber)
{ FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
// Класс Faculty1, содержащийся в пространстве имен University1
class Faculty1
{ public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // Kоличество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{ Console.WriteLine(" There are qualifing " + StudentsNumber +
" students \n at the faculty '" + FacultyName + "'");
}
/* Конструктор класса Faculty1
@params facultyName - название факультета
@params studentsNumber - число студентов, обучающихся на факультете.
*/
public Faculty1(string facultyName, int studentsNumber)
{ FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
}
namespace University2 // Объявление пространства имен University2
{ //* Класс Faculty, содержащийся в пространстве имен University2
class Faculty
{ public string FacultyName { get; set; }// Название факультета
public int StudentsNumber { get; set; }// Количество обучающихся студентов
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{ Console.WriteLine(" There are qualifing " + StudentsNumber +
" students \n at the faculty '" + FacultyName + "'");
}
/* Конструктор класса Faculty
@params facultyName - название факультета
@params studentsNumber - число студентов, обучающихся на факультете.
*/
public Faculty(string facultyName, int studentsNumber)
{ FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
// Класс Faculty2, содержащийся в пространстве имен University2
class Faculty2
{ public string FacultyName { get; set; }// Название факультета
public int StudentsNumber { get; set; }// Kоличество обучающихся студентов.
/* Метод WriteInfo метод выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{ Console.WriteLine(" At faculty '" + FacultyName +
"' \n are qualifing " + StudentsNumber + " students");
}
/* Конструктор класса Faculty2
@params facultyName - название факультета
@params studentsNumber - количество обучающихся студентов.
*/
public Faculty2(string facultyName, int studentsNumber)
{ FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
}
namespace ExampleApp
{
class Program
{
static void Main()
{
/* Чтобы избежать конфликта имен при создании объектов класса Faculty
используем псевдоимена пространств имен.
*/
// Доступ к членам пространства имен осуществляется с помощью
// описателя псевдонима пространства имен "::".
Uni1.Faculty CIT1 = new Uni1.Faculty(" Computer and Information technology", 79);
// Доступ к членам пространства имен осуществляется с помощью оператора ".".
Uni2.Faculty CIT2 = new Uni2.Faculty(" Computer and Information technology", 65);
/* В данном случае нет необходимости указывать, к какому пространству имен относится классы Faculty1 и Faculty2, так как они не вступают между собой в конфликт в глобальном пространстве имен.
*/
Faculty1 IF = new Faculty1(" Informatics and Management", 57);
Faculty2 AP = new Faculty2(" Automation and Instrumentation", 68);
// Выводим текущую информацию о каждом из факультетов
Console.WriteLine("\n Faculty in namespace University1");
CIT1.WriteInfo();
Console.WriteLine();
IF.WriteInfo();
Console.WriteLine("\n Faculty in namespace University2\n");
CIT2.WriteInfo();
Console.WriteLine();
AP.WriteInfo();
Console.ReadKey();
}
}
}
Рис 4 Результаты использования псевдоимен совместно с using
- Аддитивное свойство пространств имен
Одно пространрство имен можно объявлять несколько раз. Эти пространства можно распределить по нескольким файлам или даже разместить их в одном файле.
Инструкция using имя_пространства делает ”видимыми” содержимое обоих пространств и к различным в них методам можно обращаться без уточняющего имени пространства (не забываем- оно одно и тоже). Поэтому разделение одного пространства имен на различные части не оказывает влияние (при компиляции содержимое обоих пространств объединяется в одно). Применение разбиения пространства имен на отдельные части удобно выполнять, когда их содержания в текстовом документе удалены друг от друга.
Ниже приведена структура пограммы, в которой одно и тоже пространство имен namespace counter используется дважды: реализуется счетчик в обратном направлении (countdown) и в прямом направлении (countup).
// Первая форма using
using Counter;
// Первое постранство имен Counter
namespace Counter
{ class CountDown
{ public CountDown() { }
……………………
}
}
// Втоое простраство имен Counter
namespace Counter
{ class CountUp
{ public CountUp() { }
…………………….
}
}
class NS
{ public static void Main()
{ CountDown cd = new CountDown(k1);
CountUp cu = CountUp(k2);
……………………..
}
}
В соответствие с приведенной структуой ниже представлен полный текст пограммы.
№ 5
// Работа с одинаковыми пространствами имен
using System;
using Counter; //
// Первое пространство имен Counter
namespace Counter //
{ // Счетчик в обратном направлении CountDown //
class CountDown
{ int val;
public CountDown(int n)
{ val = n; }
public void reset(int n)
{ val = n; }
public int count()
{ if (val > 0) return val--;
else return 0;
}
}
} //
// Второе пространство имен Counter
namespace Counter //
{ // Счетчик в прямом направлении CountUp //
class CountUp
{
int val;
int target;
public int Target
{
get { return target; }
}
public CountUp(int n)
{
target = n;
val = 0;
}
public void reset(int n)
{
target = n;
val = 0;
}
public int count()
{
if (val < target) return val++;
else return target;
}
}
} //
class NS
{ public static void Main()
{ CountDown cd = new CountDown(15);
CountUp cu = new CountUp(19);
int i;
Console.WriteLine(" ");
do {
i = cd.count();
Console.Write(" " + i);
} while (i > 0);
Console.WriteLine("\n ");
do {
i = cu.count();
Console.Write(" " + i);
} while (i < cu.Target);
Console.WriteLine("\n\n\n ");
}
}
Рис 5 Результат работы с двумя одинаковыми пространствами имен
В тексте программы с правой стороны поставлены символы комментарий (“//”). Если закомментировать полностью их строки, то в работе программы ничего не изменится. Это говорит о том, что одинаковые пространства имен после компиляции объединяются и не оказывают влияние на работу программы.
- Вложенные пространства имен
Пространства имен могут быть вложенными друг друга. Количество вложений определяется разумной необходимостью. Рассмотрим пример вложения трех пространств друг в друга. Обозначим имена пространств NS1, NS2 и NS3. Характер вложения обозначим NS1(NS2(NS3)). Пусть в каждом пространстве есть свой сласс: NS1→class ClassA, NS2→class ClassB, NS3→ class ClassC. Далее приводится текст пограммы.
№ 6
// Работа с вложенными пространствами имен NS1, NS2, NS3
using System;
namespace NS1
{ class ClassA
{ public ClassA()
{ Console.WriteLine(" Cоздание класса ClassA."); }
}
namespace NS2 // Вложенное постранство имен
{ class ClassB
{ public ClassB()
{ Console.WriteLine(" Создание класса ClassB."); }
}
namespace NS3 // Вложенное пространство имен
{ class ClassC
{ public ClassC()
{ Console.WriteLine(" Создание класса ClassC."); }
}
}
}
}
class NestedNS
{ public static void Main()
{ Console.WriteLine(" ");
NS1.ClassA a = new NS1.ClassA();
NS1.NS2.ClassB b = new NS1.NS2.ClassB();
NS1.NS2.NS3.ClassC c = new NS1.NS2.NS3.ClassC();
Console.WriteLine("\n\n\n ");
}
}
Рис 6 Результаты вложения трех пространств имен NS1, NS2, NS3
№ 7
// Работа с вложенными пространствами имен
using System;
using System.Collections.Generic;
using System.Text;
using Universityes.University1; // Открываем доступ к членам пространства имен // University1, как ко вложенному пространству имен
using Universityes.University2; // Открываем доступ к членам пространства имен // University2, как ко вложенному пространству имен
using Uni1 = Universityes.University1; // Объявляем псевдоним пространства имен // University1, как вложенного пространства имен
namespace Universityes
{ namespace University1 // Объявление пространства имен University1 как // вложенного в пространство имен Universityes
{ // Класс Faculty, содержащийся в пространстве имен University1
class Faculty
{ public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся
// Метод WriteInfo выводит информацию о факультете следующим образом:
// название факультета + количество обучающихся.
public void WriteInfo()
{ Console.WriteLine(" At faculty '" + FacultyName +
"' \n are qualifing " + StudentsNumber + " students");
}
/* Конструктор класса Faculty
@params facultyName - название факультета
@params studentsNumber - число обучающихся студентов.
*/
public Faculty(string facultyName, int studentsNumber)
{ FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
//Класс Faculty1, содержащийся в пространстве имен University1
class Faculty1
{
public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся
// Метод WriteInfo выводит информацию о факультете следующим образом:
// название факультета + количество обучающихся студентов.
public void WriteInfo()
{ Console.WriteLine(" There are qualifing " + StudentsNumber + " students \n at the faculty '" + FacultyName + "'");
}
/* Конструктор класса Faculty1
@params facultyName - название факультета
@params studentsNumber - число студентов, обучающихся на факультете.
*/
public Faculty1(string facultyName, int studentsNumber)
{ FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
}
namespace University2 // Объявление пространства имен University2 как вложенного в пространство имен Universityes
{ /* Класс Faculty, содержащийся в пространстве имен University2 */
class Faculty
{ public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{ Console.WriteLine(" There are qualifing " + StudentsNumber
+ " students \n at the faculty '" + FacultyName + "'");
}
/* Конструктор класса Faculty
@params facultyName - название факультета
@params studentsNumber - количество обучающихся студентов.
*/
public Faculty(string facultyName, int studentsNumber)
{ FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
// Класс Faculty2, содержащийся в пространстве имен University2
class Faculty2
{ public string FacultyName { get; set; } // Название факультета
public int StudentsNumber { get; set; } // количество обучающихся
/* Метод WriteInfo выводит информацию о факультете следующим образом:
название факультета + количество обучающихся студентов.
*/
public void WriteInfo()
{ Console.WriteLine(" At faculty '" + FacultyName + "' \n are qualifing " + StudentsNumber + " students");
}
/* Конструктор класса Faculty2
@params facultyName - название факультета
@params studentsNumber - число обучающихся студентов.
*/
public Faculty2(string facultyName, int studentsNumber)
{
FacultyName = facultyName;
StudentsNumber = studentsNumber;
}
}
}
}
namespace ExampleApp
{ class Program
{ static void Main()
{ // Для избежания конфликта имен при создании объектов класса Faculty
// используем псевдонимы пространств имен.
Uni1::Faculty CIT1 = new Uni1::Faculty(" Computer and Information technology", 79); // Доступ к членам вложенного пространства имен // существляется с помощью описателя псевдонима пространства имен "::".
Universityes.University1.Faculty CIT2 = new Universityes.University1.Faculty(" Computer and Information technology", 65); // Доступ к членам пространства имен осуществляется с помощью оператора ".".
// В данном случае нет необходимости указывать,к какому пространству имен // относится классы Faculty1 и Faculty2, так как они не вступают между собой в // конфликт в глобальном пространстве имен.
Faculty1 IF = new Faculty1(" Informatics and Management", 57);
Faculty2 AP = new Faculty2(" Automation and Instrumentation", 68);
// Выводим текущую информацию о каждом из факультетов
Console.WriteLine("\n Faculty in namespace University1\n");
CIT1.WriteInfo();
Console.WriteLine();
IF.WriteInfo();
Console.WriteLine("\n Faculty in namespace University2\n");
CIT2.WriteInfo();
Console.WriteLine();
AP.WriteInfo();
Console.ReadKey();
}
}
}
Рис 7 Результаты вложения двух пространств имен
- Сборки и компоновочные файлы
Сборка в программе на языке C# представляет собой один или несколько файлов, содержащих всю необходимую информацию о программе, такую как ее версия, информация о развертывании программы, надежный механизм связывания компонентов программы, межъязыковой механизм управления версиями. Сборки являются ключевым понятием при работе в среде .NET.
Сборку составляют компоновочные файлы – файлы с исходным кодом программы, а также файлы, содержащие необходимую информацию о сборке.
Исполняемый файл, получаемый в результате компиляции, представляет собой сборку, в которой содержится вся необходимая информация для работы программы.
Каждая сборка состоит из четырех разделов:
1 Декларация сборки.
2 Метаданные типов.
3 Программный код.
4 Ресурсы.
В разделе «Декларация сборки» содержатся информация о самой сборке, такая как имя сборки, номер версии, сведения о соответствии типов, язык, региональные стандарты.
В разделе «Метаданные типов» содержится информация о типах данных, используемых в программе.
В разделе «Программный код» содержится кот программы в формате MSIL (Microsoft Intermediate Language — промежуточный язык корпорации Microsoft).
В разделе «Ресурсы» содержатся все необходимые ресурсы, используемые программой.
В связи с понятием сборки, кроме трех основных модификаторов доступа private, protected, public, в языке С# реализован четвертый модификатор доступа internal. Данный модификатор доступа делает соответствующее поле, свойство, метод или весь класс доступным только в данной версии сборки и недоступным в другой версии.
Рассмотрим пример использования модификатора internal в задаче № 8.
№ 8
// Работа с модификатором intergal
using System;
using System.Collections.Generic;
using System.Text;
namespace ExAp
{ // Класс InternalExample -иллюстрациz применения модификатора доступа internal.
public class InternalExample
{ // Свойство Message, с модификатором доступа internal.
// Доступно только в данной версии сборки.
internal string Message { get; set; }
// Конструктор класса InternalExample
// @params message - строковая величина для инициализации свойства Message
public InternalExample(string message)
{
Message = message;
}
}
}
// Класс Program,содержащий главную функцию Main().
class Program
{
static void Main()
{
// Создаем объект класса InternalExample
ExAp.InternalExample Example = new ExAp.InternalExample("\n This is item with internal protection type");
// Имеем доступ к свойству Message класса InternalExample, т.к. доступ к нему существует
// в данной версии сборки (в данном файле, т.е. програме)
// Выводится с новой строки текст " This is item with internal protection type".
Console.WriteLine(Example.Message);
Console.ReadKey();
}
}
Рис 8 Результат применения модификатора доступа internal для контроля
появления текстовой строки внутри класса internalExample.
3 Препроцессор
Препроцессор – набор директив процессора для предварительной обработки исходного файла до трансляции программы в объектный код. Современная технология компиляторов не требует отдельного этапа предварительной обработки. Вместо этого директивы препроуессора обраьатываютс как часть этапа лексического анализа при компиляции. Имя директивы всегда сопровождается префиксом (#) и в тексте программы распологается на отдельной строке. Наиболее распространенные директивы ниже приведены в таблице.
Таблица Директивы препроцессора
|
№ |
|
Описание |
Сигнатура |
|
1 |
#define |
Позволяет определить символ или последовательность символов (идентификатор). |
#define идентификатор |
|
2 |
#if |
Компиляция кода между директивами #if и #endif Происходит только если идентификатор определен с помощью директивы #define. |
#if идентификатор //последовательностьоператоров #endif |
|
3 |
#endif |
||
|
4 |
#else |
Альтернативное действие, если идентификатор при директиве #if не определен. |
#if идентификатор //последовательностьоператоров #else//последовательностьоператоров #endif |
|
5 |
#elif |
Представляет собой последовательность if-else-if, т.е. действие выполняется, если идентификатор перед директивой #if неопределен, но определен идентификатор перед директивой #elif. |
#if идентификатор1 //последовательность операторов #elif идентификатор2 //последовательность операторов #endif |
|
6 |
#undef |
Определенный с помощью директивы #define идентификатор становится неопределенным. |
#define идентификатор |
|
7 |
#warning |
Генерирует предупреждение при определенном идентификаторе, т.е., если идентификатор был определен, будет выдано предупреждение |
#warning идентификатор |
|
8 |
#error |
Генерирует ошибку, если идентификатор был определен, т.е. работает аналогично директиве #warning, но выдается ошибка, если идентификатор был определен. |
#error идентификатор |
|
9 |
#line |
Устанавливает номер строки и имя файла для вывода предупреждений и ошибок. Т.е., если в строке 12 в файле MyFile.cs будет генерироваться ошибка, то после использования директивы #line 30 “Example.cs” Ошибка будет найдена в строке 40 файла «Example.cs» Директива #line default возвращает стандартную нумерацию строк. Директива #line hidden при переходе к строкам по коду ошибки указанные после директивы строки будут пропущены. Директива #line file name позволяет изменять имя файла. |
#line номер_строки “имя_файла” #line default #line hidden #line filename “имя_файла” |
|
10 |
#region |
Обозначают область кода, который можно разворачивать и сворачивать с помощью функции структурирования в редакторе кода Visual Studio. |
#region //фрагмент кода программы #endregion |
|
11 |
#endregion |
||
|
12 |
#pragma |
Директива #pragma является опцией, передаваемой компилятору со следующими параметрами #pragma pragma-имя pragma-аргументы Разработано 2 pragma-имени:
#pragmawarning – работа с предупреждениями: disable – отключение предупреждения restore – разрешение предупреждений Существует возможность указать сразу несколько кодов предупреждений через запятую. #pragmachecksum – создает контрольные суммы в отладчике ASP.NET Ее аргументами являются: Имя файла Идентификатор GUID файла Контрольная сумма в шестнадцатеричной системе счисления |
#pragma warning disable коды_предупреждений #pragma warning disable коды_предупреждений #pragma checksum «имя_файла»«{GUID}» “контрольная сумма” |
3.1 Задача генерации “хороших” случайных чисел
Обычный способ генерирования слачайных чисел основан на применении фрагмента (в качестве примера рассмотрим получение целых чисел)
Random rand = new Random();
int x = rand.Next();
Для чисел типа Int32 этот текст имеет вид
Random rand = new Random();
Int32 x = rand.Next();
При повышенном требовании к безопасности передачи применять класс System.Random ( в качестве случайного значения берется текущее время суток в секундах ) запрещено.
Применяется класс RNGCryptoServiceProvider (текущее случайное значение берется как сложная комбинация, в котоой учитывается информация о процессоре, значения счетчиков операционной системы и счетчиков циклов, текущее время и пр.). Полученные при этом числа считаются криптографически безопасными, однако и это не абсолютно надежный подход для продолжительной передачи. Ниже приведена программа создания подобных слуяайных чисел.
№ 9
// Генерирование случайных чисел для целей, связанных с безопасностью
using System;
using System.Collections.Generic;
//using System.Linq;
using System.Text;
namespace ClassSample
{
// Использовать модификатор public,
// чтобы класс был виден за пределами сборки
public class Vertex3d
{ public static void Main()
{
int k1 = 0;
Console.WriteLine(" ");
System.Security.Cryptography.RNGCryptoServiceProvider cryptRand =
new System.Security.Cryptography.RNGCryptoServiceProvider();
for (Int32 i = 1; i < 95; i++)
{
byte[] bytes = new byte[4];
cryptRand.GetBytes(bytes);
Int32 number = BitConverter.ToInt32(bytes, 0);
Console.Write(" {0,11}{1,2}", number,i);
if (i % 5 == 0) { k1 += 1; Console.WriteLine(" ");
if (k1 % 7 == 0) Console.WriteLine(" ");
}
}
Console.WriteLine("\n\n\n ");
}
}
}
Рис 9 Приведены 94 случайных числа повышенной безопасности
№ 10 Выполнение директив #define, if, end.
// Работа с директивами #define, #if, #endif
#define intRandom
#define doubleRandom
#define RNGCrypto
using System;
namespace Preprocessor
{ class ProcessMe
{ public static void Main(/*string[] args*/) {
#if intRandom // В строке перед if должно быть чисто
Console.WriteLine("\n Применение класса Random для работы \n с целыми случайными числами\n") ;
Random rani = new Random();//rani,rand – имена не должны повторяться
for(int i = 0; i < 4; i++)
Console.Write(" " + rani.Next(-1000, 1000));
#endif
#if doubleRandom
Console.WriteLine("\n\n\n Применение класса Random для работы \n с вещественнымии случайными числами\n") ;
Random rand = new Random();
for(int i = 0; i < 4; i++)
Console.Write(" " + rand.NextDouble()*1000);
#endif
#if RNGCrypto
Console.WriteLine("\n\n\n Применение класса RNGCrypto для работы \n с 'хорошими' случайными числами (см.№ 9)") ;
int k1 = 0;
Console.WriteLine(" ");
System.Security.Cryptography.RNGCryptoServiceProvider cryptRand =
new System.Security.Cryptography.RNGCryptoServiceProvider();
for (Int32 i = 1; i < 5; i++)
{
byte[] bytes = new byte[4];
cryptRand.GetBytes(bytes);
Int32 number = BitConverter.ToInt32(bytes, 0);
Console.Write(" {0,11}{1,2}", number,i);
if (i % 5 == 0) { k1 += 1; Console.WriteLine(" ");
if (k1 % 7 == 0) Console.WriteLine(" ");
}
}
#endif
Console.WriteLine("\n\n\n ");
}
}
}
Рис 10 Применение лиректив #define, #if, #endif
№ 11 Работа с директивами define, if, elif,#endif и с большими числами double
// Работа с директивами #define, #if, #elif, #endif
// и с предельными числами типа double
#define RELEASE
using System;
using System.Collections.Generic;
class Test
{
public static void Main()
{
double n = 10.5;
Console.WriteLine(" ");
for (int i = 0; i < 101; i++)
{
#if EXPERT
Console.WriteLine(" Not Allowed 1!");
#elif RELEASE
Console.WriteLine(" Allowed! n= " + n);
n = n * n;
if ((n - 1.7E+308) > 0.0) break;
#else
Console(" Not Allowed 2!");
#endif
}
Console.WriteLine("\n n1=" + n + "\n\n\n ");
}
}
Рис 11 Работа с директивами #define, #ig, #elif, endif и с числами типа double
№ 12
PAGE 26
2. Конечно в первую очередь это касалось богатых семей
3. философская революция XVII век
4. Основные философские направления идеализм и его формы философский монизм дуализм и плюрализм
5. Передача администрации нормотворческих и судебных полномочий в США
6. Контрольная работа- Ветеринарное дело
7. Доклад по первоисточнику Э
8. Судебники 1497 и 1550 годов, сравнительный анализ
9. Рождество в Германии
10. Гробница Тутанхамона
11. Основы деловой риторики.html
12. Бухгатерский учёт теоретические вопросы
13. то речи об этом не заходило
14. реферату- Основні моменти протоколуРозділ- Діловодство Основні моменти протоколу Протокол ~ це одна з най
15. Сказание
16. Либерализации и демократизации в Тунисе при президенте Бен Али
17. Дать определение понятию криминального процесса его заданию и месту в борьбе с преступностью
18. тема социального обеспечения- современное состояние правовые проблемы дальнейшего развития
19. Defult in Russi in 1998
20. скорость ЖЧ во вращающейся системе отсчета