Язык С #

*.cs
using System;

class HelloClass
{
// Как ни удивительно, функция Main() может быть

объявлена как private,
// если, конечно, вам это нужно…
public static int Main (string[] args)
{
Console.WriteLine ("Hello, World");
return 0;
}
}

args)
{
// Выводим параметры на консоль!
for(int x=0; x < args.Length; x++)
{
Console.WriteLine("Arg:

{0}", args[x]);
}

Console.WriteLine("Hello, World!");
return 0;
}
}

using System;

class HelloClass
{
public static int Main (string[] args)
{
foreach(string s in args)
Console.WriteLine("Arg: {0}", s);
}
}

умолчанию присвоит переменным-членам значения по умолчанию
public HelloClass()
{ Console.WriteLine("Default constructor called!"); }

// Наш

собственный конструктор присвоит переменным-членам специальные значения
public HelloClass(int x, int y)
{ Console.WriteLine("Custom constructor called!");
intX = x; intY = y; }

// Объявляем переменные-члены класса
public int intX, intY;

// Точка входа для программы
public static int Main(string[] args)
{ // Применяем конструктор по умолчанию
HelloClass c1 = new HelloClass();
Console.WriteLine("c1.intX = {0}\nc1.intY = {1}\n", c1.intX, c1.intY);

// Применяем конструктор с параметрами
HelloClass c2 = new HelloClass(100, 200);
Console.WriteLine("c2.intX = {0}\nc2.intY = {1}\n", c2.intX, c2.intY);
return 0;
}
}

(int x, int y)
{
Console.WriteLine ("Custom ctor called!");
intX = x; intY

= y;
}
public int intX, intY;

// Новая функция-член
public void SayHi() {Console.WriteLine("Hi there!");}
}

class HelloApp
{
public static int Main(string[] args)
{
// Создаем объекты HelloClass и выводим приветствие
HelloClass c1 = new HelloClass();
c1.SayHi();
...
}
}

string MyStr = 90;
private Person stud1 = new Person(”Маша”,

19, 3216565);
. . .
}

и вывода данных
using System;
class BasicIO
{
public static void Main(string[] args)
{
// Выводим

приглашение ввести имя
Console.Write("Enter your name: ");

string s;
s = Console.ReadLine();
Console.WriteLine("Hello, {0}", s);
Console.Write("Enter your age: ");

s = Console.ReadLine();
Console.WriteLine("You are {0} years old\n", s);
}
}

= 90;
float theFloat = 9.99;
BasicIO myIO = new BasicIO();

// Комбинируем

символьную строку:
Console.WriteLine("Int is: {0}\nFloat is: {1}\nYou are: {2}",
theInt, theFloat, myIO.ToString());
}
}

// Применяем параметры форматирования
public static void Main(string[] args)
{
...
Console.WriteLine("C format: {0:C}", 99989,987);
Console.WriteLine("D9 format: {0:D9}", 99999);
Console.WriteLine("E format: {0:E}", 99999,76543);
Console.WriteLine("F format: {0:F3}", 99999,9999);
Console.WriteLine("N format: {0:N}", 99999);
Console.WriteLine("X format: {0:X}", 99999);
Console.WriteLine("x format: {0:x}", 99999);
}

int Main(string[ ] args)
{
// При создании структуры с применением конструктора

по умолчанию // использование ключевого слова "new" является необязательным
FOO f1 = new FOO();
f1.x = 100; f1.y = 100;

// Присваиваем новому типу FOO (f2) существующий тип FOO (f1)
FOO f2 = f1;

// Выводим содержимое f1
Console.WriteLine("F1.x = {0}", f1.x);
Console.WriteLine("F1.y = {0}", f1.y);

// Выводим содержимое f2
Console.WriteLine("F2.x = {0}", f2.x);
Console.WriteLine("F2.y = {0}", f2.y);

// А теперь вносим изменения в f2.x. Они не отразятся на f1.x
Console.WriteLine ("Changing f2.x");
f2.x = 900;

// Снова выводим содержимое
Console.WriteLine("F2.x = {0}", f2.x);
Console.WriteLine("F1.x = {0}", f1.x);
return 0;
}
}

System
{
public class Object
{
public Object();
public virtual Boolean Equals (Object obj);
public virtual

Int32 GetHashCode();
public Type GetType();
public virtual String ToString();
protected virtual void Finalize();
protected Object MemberwiseClone();
}
}

System.Object
using System;
class ObjTest
{
public static int Main(string[] args)
{
// Создаем экземпляр ObjTest
ObjTest

c1 = new ObjTest();

// Выводим информацию на консоль
Console.WriteLine("ToString: {0}", c1.ToString());
Console.WriteLine("Hash Code: {0}", c1.GetHashCode());
Console.WriteLine("Type: {0}", c1.GetType().ToString());

// Создаем еще одну ссылку на c1
ObjTest c2 = c1;
object o = c2;

// Действительно ли все три экземпляра указывают на одну
// и ту же область в оперативной памяти?
if(o.Equals(c1) && c2.Equals(o))
Console.WriteLine("Same instance!");

return 0;
}
}

от класса
// System.Object

class Person
{
public Person(string fname, string lname, string

inn, byte a)
{
firstName = fname;
lastname = lname;
INN = inn;
age = a;
}

public Person(){} // Всем переменным-членам будут присвоены
// значения по умолчанию

// Данные о человеке
public string firstName;
public string lastName;
public string INN;
public byte age;
}

получения
// доступа к типу StringBuilder
using System.Text;

// В нашем классе

Person метод ToString будет реализован
// следующим образом:
class Person
{
...
// Замещаем метод, унаследованный от System.Object:
public override srting ToString()
{
StringBuilder sb = new StringBuilder()

sb.Append("[FirstName= " + this.firstName);
sb.Append(" LastName= " + this.lastName);
sb.Append(" INN= " + this.INN);
sb.Append(" Age= " + this.age + "]");

return sb.ToString();
}
...
}

образом:
class Person
{
...
public override bool Equals (object o)
{//

Совпадают ли у объекта, принимаемого в качестве
// параметра, значения переменных с моими?

Person temp = (Person)o;

if (temp.firstName = = this.firstName &&
temp.lastName = = this.lastName &&
temp.INN = = this.INN &&
temp.age = = this.age)
return true;
else
return false;
}

public override int GetHashCode() { return INN.GetHashCode(); }
...
}

int Main(string[] args)
{
// Создаем несколько объектов и производим их сравнение

на идентичность.
// Мы специально присваиваем одинаковые значения переменным-членам для целей
// тестирования метода Equals()
Person p1 = new Person("Fred", "Jones", "222-22-2222", 98);
Person p2 = new Person("Fred", "Jones", "222-22-2222", 98);

// Используем замещенный для сравнения внутреннего состояния метод Equals()
if(p1.Equals(p2) && p1.GetHashCode() = = p2.GetHashCode())
Console.WriteLine ("P1 and P2 have same state\n");
else
Console.WriteLine ("P1 and P2 are DIFFERENT\n");

// Теперь меняем внутреннее состояние p2
p2.age = 2;

// Производим сравнение заново:
if(p1.Equals(p2) && p1.GetHashCode() = = p2.GetHashCode())
Console.WriteLine ("P1 and P2 have same state\n");
else
Console.WriteLine ("P1 and P2 are DIFFERENT\n");

// Теперь используем замещенный метод ToString()
Console.WriteLine(p1.ToString());
Console.WriteLine(p2); // Вообще-то, метод WriteLine() вызывает метод
// ToString() автоматически
return 0;
}

= new Person("Sally", "Jones","333", 4);

// Одинаково ли внутреннее состояние

p3 и p4? Да!
Console.WriteLine("\n\nP3 and P4 have same state: {0}",
object.Equals(p3, p4));

// Представляют ли они один и тот же объект в ОП? Нет!
Console.WriteLine("P3 and P4 are pointing to same object: {0}",
object.ReferenceEquals(p3, p4));

Работаем с UInt16 как со структурным типом
System.UInt16 myUInt16 = 30000;
Console.WriteLine("Max

for an UInt16 is: {0}", UInt16.MaxValue);
Console.WriteLine("Min for an UInt16 is: {0}", UInt16.MinValue);
Console.WriteLine("Your value is: {0}", myUInt16.ToString());
Console.WriteLine("I am a: {0}", myUInt16.GetType().ToString());

// Почти то же самое, но уже используем псевдоним C# ushort
// для типа System.Uint16
ushort myOtherUInt16 = 12000;
Console.WriteLine("\nYour value is: {0}", myOtherUInt16.ToString());
Console.WriteLine("I am a: {0}", myOtherUInt16.GetType().ToString());

return 0;
}
}

Unicode)
Нет типов char *, LPSTR, wchar_t * и т.п.

переменную типа short и присваиваем ей значение
short s = 25;

//

Упаковываем переменную s (boxing)
object objShort = s;

// Распаковка объекта
short anotherShort = (short) objShort;

Main(string[] args)
{
...
try
{
// Мы пытаемся распаковать в тип данных string объект,

// исходный тип данных для которого — short!
string str = (string)objShort;
}
catch(InvalidCastException e)
{
Console.WriteLine("OOPS!\n{0}", e.ToString());
}
...
}

+ o); }

public static int Main(string[] args)
{ short s = 25;

// Make a simple value.
Console.WriteLine("short s = {0}", s);
Console.WriteLine("short is a: {0}\n", s.GetType().ToString());

object objShort = s; // Box the value into a reference.
Console.WriteLine("Boxed object is a: {0}\n", objShort.GetType().ToString());

// Now, unbox the reference back into a short:
short anotherShort = (short)objShort;
Console.WriteLine("short anotherShort = {0}", anotherShort);
Console.WriteLine("Unboxed object is a: {0}",anotherShort.GetType().ToString());

try // Bad unboxing!
{ // The type contained in the box is NOT a string, but a short!
string str = (string)objShort;
}
catch(InvalidCastException e)
{
Console.WriteLine("\nOOPS!\n{0}", e.ToString());
}

Console.WriteLine("\n\nThe Auto Box"); // Auto-box.
int x = 99;
Foo(x);
return 0;
}
}

переменным-членам присваиваются значения по умолчанию
Но переменные, описанные внутри метода, не

инициализируются

компилятора Console.Writeline(localInt.ToString()); }
public static void Main() { int localInt = 0; Console.Writeline(localInt.ToString()); }

int myIntConst = 5;
public const string myStringConst = "I'm a

const";

public static void Main()
{
// Эта константа определена на уровне метода
const string localConst = "I am a rock, I am an island";
// А теперь мы применяем константы (обратите внимание на указание
// диапазона, в котором они были созданы).
Console.WriteLine("myIntConst = {0}\nmyStringConst = {1}",
MyConstants.myIntConst,
MyConstants.myStringConst);
Console.WriteLine("Local constant: {0}", localConst);
}
}

конструктор как private.
class MyConstants
{
// Некоторые константы
public const int

myIntConst = 5;
public const string myStringConst = "I'm a const";

// А теперь запретим пользователю создавать экземпляры данного класса,
// ведь единственное назначение этого класса — хранить константы
private MyConstants(){}
}

// Определив класс как абстрактный, мы запрещаем создание
// экземпляров этого класса.
abstract class MyConstants
{
// Некоторые константы
public const int myIntConst = 5;
public const string myStringConst = "I'm a const";
}

только внутри for
for (int i; i

Console.WriteLine(“Number is: {0}”,i);
}
return 0; // здесь i уже не видна
}

int Main(string[] args)
{
string[] arrBookTitles = new String[] {"Complex Algorithms",
"COM

for the Fearful Programmer",
"Do you Remember Classic COM?",
"C# and the .NET platform",
"COM for the Angry Engineer"};
int COM = 0, NET = 0;

// Считаем, что книг по COM и .NET (охватывающих оба предмета) пока не существует
foreach (string s in arrBookTitles)
{
if (-1 != s.IndexOf("COM"))
COM++;
else if(-1 != s.IndexOf(".NET"))
NET++;
}
Console.WriteLine("Found {0} COM references and {1} .NET references.", COM, NET);
return 0;
}

не окажется
{
// Открываем файл config.win
StreamReader strReader = File.OpenText("C:\config.win");

// Считываем каждую

строку и выводим ее на консоль
string strLine;
while(null != (strLine = strReader.ReadLine()));
{
Console.WriteLine(strLine);
}
// Файл необходимо закрыть
strReader.Close();
}
catch(FileNotFoundException e) // Про исключения рассказано далее
{
Console.WriteLine(e.Message);
}

так теперь нельзя

// можно только так if (s.Length != 0) {

… }

args)
{
Console.WriteLine("Welcome to the world of .NET");
Console.WriteLine("1

= C#\n2 = Managed C++ (MC++)\n3 = VB.NET\n");
Console.Write("Please select your implementation language:");
string s = Console.ReadLine();

// Все встроенные типы данных поддерживают статический метод Parse()
int n = int.Parse(s);

switch(n)
{ // C# требует, чтобы каждый вариант (включая "default" — по умолчанию), в котором
// предусмотрены команды для выполнения, содержал выражение выхода "break" или "goto"
case 1: Console.WriteLine("Good choice! C# is all about managed code.");
break;
case 2: Console.WriteLine("Let me guess, maintaining a legacy system?");
break;
case 3: Console.WriteLine("VB.NET: It is not just for kids anymore...");
break;
default: Console.WriteLine("Well...good luck with that!");
break;
}
return 0;
}
}

внутри класса, в котором определен
protected – доступен из класса и

всех его потомках
internal – доступен из всех классов внутри сборки, в которой он определен

только из типов данных SomeClass
private void MethodB(){};

// Доступен только из

SomeClass и из классов, производных от
// SomeClass (на любом нижестоящем уровне иерархии)
protected void MethodC(){};

// Доступен только из той же самой сборки
internal void MethodD(){};

// Будет действовать как protected или internal
protected internal void MethodE(){};

// Будет считаться protected — по умолчанию
void Method() {};
}

return x*x;
}
}

…

public static void Main(string[ ] args)
{
Console.WriteLine(mat.sqr(3.0));
}

Эта статическая переменная будет совместно использоваться всеми
// объектами Airplane

private static int NumberInTheAir = 0;

public Airplane()
{
NumberInTheAir++;
}

// Метод для получения значения NumberInTheAir через экземпляр
// объекта Airplane
public int GetNumberFromObject() {return NumberInTheAir;}

// Статический метод — для получения значения NumberInTheAir напрямую
// через класс Airplane
public static int GetNumber() {return NumberInTheAir;}
}

Main(string[] args)
{
// Создадим несколько самолетов
Airplane a1 = new Airplane();
Airplane a2

= new Airplane();

// Сколько взлетело самолетов?
Console.WriteLine("Number of planes: {0}", a1.GetNumberFromObject());
Console.WriteLine("Number of planes: {0}", Airplane.GetNumber());

// Добавим самолетов
Airplane a3 = new Airplane();
Airplane a4 = new Airplane();

// А теперь сколько?
Console.WriteLine("Number of planes: {0}", a3.GetNumberFromObject());
Console.WriteLine("Number of planes: {0}", Airplane.GetNumber());

return 0;
}
}

полезных статических типов класса Environment
using System;
class SytemSpy
{
public static int

Main(string[] args)
{
// Под какой операционной системой мы работаем?
Console.WriteLine("Current OS: {0}", Environment.OSVersion);

// Текущий каталог?
Console.WriteLine("Current Directory: {0}", Environment.CurrentDirectory);

// А теперь выведем список логических дисков:
string[] drives = Environment.GetLogicalDrives();

for(int i = 0; i < drives.Length; i++)
Console.WriteLine("Drive {0} : {1}", i, drives[i]);

// А какая версия платформы .NET у нас используется?
Console.WriteLine("CurrentVeersion of .NET: {0}", Environment.Version);

return 0;
}
}

ссылке
params – передача набора параметров как единое целое

Add(int x, int y, out int ans)
{
ans = x

+ y;
}
…

// Предположим, что метод Add() определен в классе с именем Methods
public static void Main()
{
...
Methods m = new Methods();
int ans; // Исходное значение присваивать не обязательно  // — значение вскоре присвоит вызываемый метод

// Обратите внимание на использование ключевого слова out
// в синтаксисе вызова метода
m.Add(90, 90, out ans);
Console.WriteLine("90 + 90 = {0}", ans);
}

UpperCaseThisString(ref string s)
{
// Возвращаем символьную строку, в которой все буквы

станут заглавными
s = s.ToUpper();
}


// Вызываем этот метод через Main()
public static void Main()
{
...
// Используем ключевое слово ref
string s = "Can you really have sonic hearing for $19.00?";
Console.WriteLine("Before: {0}", s);

m.UpperCaseThisString(ref s)
Console.WriteLine("After: {0}", s);
}

msg, params int[] list)
{
Console.WriteLine(msg);
for (int i=0; i

Console.WriteLine(list[i]);
}

Первый параметр – символьная строка
Второй параметр – любое количество целых чисел


int[] intArray = new int[3] {10,11,12};
m.DisplayArraysOfInt(“Here is an array of ints”, intArray);
m.DisplayArraysOfInt(“Enjoy these 3 ints”, 1,2,3);
m.DisplayArraysOfInt(“Take some more”, 55,4,983,10432,98,33);

string fullName;
private byte age;

public Person(string n, byte a)
{

fullName = n;
age = a;
}

public void PrintInfo()
{
Console.WriteLine("{0} is {1} years old", fullName, age);
}
}

void DisplayArrayOfObjects(params object[] list)
{
for (int i=0; i < list.Length; i++)
{

if(list[i] is Person) // Является ли текущий объект в массиве
// объектом класса Person?
{ // Если да, вызываем нужный метод
((Person)list[i]).PrintInfo();
}
else
Console.WriteLine(list[i]);
Console.WriteLine();
}

Person p = new Person("Fred", 93);
m.DisplayArrayOfObjects(777, p, "I really am an instance of System.String");

booksOnCOM;
booksOnCOM = new string[10];

// Массив символьных строк из 100 элементов

{0,1, … , 99 }
string[] booksOnDotNet = new string[100];
booksOnDotNet[0] = "Троелсен";

// Массив символьных строк с 2 элементами {0,1}
string[] booksOnPL1 = new string[2] { "one", "two"} ;

// Так нельзя
int[4] ages = {30,54,4,10}; // Нет слова new – обязательно для // массива фиксированного размера

// Но так можно (размер массива определяет компилятор),
// без new можно только в этом случае
int[] ages = {20,22,23,0};

6];

// Заполняем массив 6 на 6:
for (int i = 0;

i < 6; i++)
for (int j = 0; j < 6; j++)
myMatrix[i, j] = i*j;

// Выводим элементы многомерного массива на системную консоль
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < 6; j++)
{
Console.Write(myMatrix[i, j] + "\t");
}
Console.WriteLine();
}

нашем случае —
// это массив из пяти внутренних массивов разного

размера
int[][] myJagArray = new int[5][];

// Создаем "ломаный" массив
for (int i = 0; i < myJagArray.Length; i++)
{
myJagArray[i] = new int[i + 7];
}

// Выводим каждую строку на системную консоль (как мы помним, каждому элементу
// присваивается значение по умолчанию — в нашем случае 0)
for (int i = 0; i < 5; i++)
{
Console.Write("Length of row {0} is {1}:\t", i, myJagArray[i].Length);
for (int j = 0; j < myJagArray[i].Length; j++)
{
Console.Write(myJagArray[i][j] + " ");
}
Console.WriteLine();
}

– копирование элементов из исходного массива в массив назначения
GetEnumerator() –

возвращает интерфейс IEnumerator
GetLength(), Length – количество элементов в указанном измерении и общее количество элементов
GetLowerBound(), GetUpperBound() – определение нижней и верхней границы выбранного измерения
GetValue(), SetValue() – возвращает или устанавливает значение указнного индекса
Reverse() – расставляет элементы в обратном порядке
Sort() – сортирует массив

Синим цветом выделены статические методы класса Array

символьных строк
string[] firstNames = new string[5] {"Меркурий","Венера","Земля","Марс","Юпитер"};

// Выводим имена в

соответствии с порядком элементов в массиве
Console.WriteLine("Here is the array:");

for (int i = 0; i < firstNames.Length; i++)
Console.Write(firstNames[i] + "\t");
Console.WriteLine();

// Расставляем элементы в обратном порядке при помощи статического метода Reverse()
Array.Reverse(firstNames);

// ...и снова выводим имена
Console.WriteLine("Here is the array once reversed:");
for (int i = 0; i < firstNames.Length; i++)
Console.Write(firstNames[i] + "\t");
Console.WriteLine();

// А теперь вычищаем всех, кроме Юпитера
Console.WriteLine("Cleared out all but one...");
Array.Clear(firstNames, 1, 4);

for (int i = 0; i < firstNames.Length; i++)
Console.Write(firstNames[i] + "\t\n");
return 0;
}
}

в одну
CompareTo() – сравнивает две строки
Copy() – создает копию строки
Format()

– форматирование строки
Insert() – вставка строки внутрь существующей
PadLeft(), PadRight() – заполнение строки указанными символами
Remove(), Replace() – создают копию строки с указанными изменениями
ToUpper(), ToLower() – создают копию строки строчными или прописными буквами

объектов.
// + используется для операции конкатенации.
public static int

Main(string[] args)
{
System.String strObj = "This is a TEST";
string s = "This is another TEST";

// Производим сравнение значений строк
if(s = = strObj)
Console.WriteLine("Same info...");
else
Console.WriteLine("Not the same info...");

// А теперь — операция конкатенации
string newString = s + strObj;
Console.WriteLine("s + strObj = {0}", newString);

// А еще System.String предоставляет в ваше распоряжение индексатор
// для доступа к любому символу массива
for (int k = 0; k < s.Length; k++)
Console.WriteLine("Char {0} is {1}", k, s[k]);

return 0;
}

строку
\r возврат каретки
\t горизонтальная табуляция
\u вставить символ Unicode
\v вертикальная табуляция
\0 пустой символ

string finalString = @"\n\tString

file: 'C:\CSharpProjects\Strings\string.cs'";
Console.WriteLine(finalString);

strFixed = "This is how I began life";
Console.WriteLine(strFixed);

string upperVersion =

strFixed.ToUpper(); // создание копии строки

Console.WriteLine(strFixed);
Console.WriteLine(upperVersion + "\n\n");

StringBuilder!

class StringApp
{
public static int Main(string[] args)
{
// Создаем объект StringBuilder и

изменяем его содержимое
StringBuilder myBuffer = new StringBuilder("I am a buffer");
myBuffer.Append(" that just got longer...");
Console.WriteLine(myBuffer);
return 0;
}
}

Здесь живет StringBuilder

class StringApp
{
public static int Main(string[] args)
{
StringBuilder myBuffer =

new StringBuilder("I am a buffer");

myBuffer.Append(" that just got longer...");
Console.WriteLine(myBuffer);

myBuffer.Append("and even longer.");
Console.WriteLine(myBuffer);

// Делаем все буквы прописными
string theReallyFinalString = myBuffer.ToString().ToUpper();
Console.WriteLine(theReallyFinalString);
return 0;
}
}

// = 1
Contractor, // = 2
VP

// = 3
}

enum EmpType
{
Manager = 102,
Grunt, // = 103
Contractor, // = 104
VP // = 105
}

enum EmpType
{
Manager = 10,
Grunt =1,
Contractor = 100
VP = 99
}

enum EmpType : byte
{
Manager = 10,
Grunt =1,
Contractor = 100
VP = 99
}

get enough cash...");
break;

case EmpType.Grunt:
Console.WriteLine("You havve got to be kidding...");
break;

case EmpType.Manager:
Console.WriteLine("How

about stock options instead?");
break;

case EmpType.VP:
Console.WriteLine("VERY GOOD, Sir!");
break;

default: break;
}
}

public static int Main(string[] args)
{
// Создаем тип Contractor
EmpType fred;
fred = EmpType.Contractor;

AskForBonus(fred);

return 0;
}
}

ec = new EnumClass();

// Получаем тип данных перечисления
Console.WriteLine(Enum.GetUnderlyingType(typeof(EmpType)));
Console.WriteLine("You

are a {0}", Enum.Format(typeof(EmpType), fred, "G"));

// Получаем информацию о количестве элементов в перечислении
Array obj = Enum.GetValues(typeof(EmpType));
Console.WriteLine("This enum has {0} members.", obj.Length);

// Выводим имена элементов перечисления и соответсвующие им числовые значения
foreach(EmpType e in obj)
{ Console.Write("String name: {0}", Enum.Format(typeof(EmpType), e, "G"));
Console.Write(" ({0})", Enum.Format(typeof(EmpType), e, "D"));
Console.Write(" hex: {0}\n", Enum.Format(typeof(EmpType), e, "X"));
}

// Есть ли в EmpType элемент SalesPerson?
if(Enum.IsDefined(typeof(EmpType), "SalesPerson"))
Console.WriteLine("Yep, we have sales people.");
else
Console.WriteLine("No, we have no profits....");

// Какому их этих двух переменных-членов перечисления соответствует большее числовое значение
EmpType Joe = EmpType.VP;
EmpType Fran = EmpType.Grunt;

if(Joe < Fran)
Console.WriteLine("Joe's value is less than Fran's");
else
Console.WriteLine("Fran's value is less than Joe's");

return 0;
}

// созданные вами конструкторы должны принимать параметры

struct EMPLOYEE
{
// Поля
public

EmpType title;
public string name;
public short deptID;

// Конструктор
public EMPLOYEE (EmpType et, string n, short d)
{
title = et;
name = n;
deptID = d;
}
}

// при помощи конструктора
public static int Main(string[] args)
{

// Для вызова нашего конструктора мы обязаны
// использовать ключевое слово new
EMPLOYEE mary = new EMPLOYEE(EmpType.VP, "Mary", 10);
...
return 0;
}
}

\'s info:", e.name);
Console.WriteLine("Department ID: {0}", e.deptID);
Console.WriteLine("Title: {0}",

Enum.Format(typeof(EmpType), e.title, "G"));
}


…
StructTester t = new StructTester();
t.DisplayEmpStats(mary);
t.DisplayEmpStats(fred);
…

сотрудника
EMPLOYEE stan = new EMPLOYEE(EmpType.Grunt, "Stan", 10);
object stanInBox = stan;

// это уже ссылочный тип

…

public void UnboxThisEmployee(object o)
{
EMPLOYEE temp = (EMPLOYEE)o;
Console.WriteLine(temp.name + " is alive!");
}

…

// Передаем упакованного сотрудника на обработку
t.UnboxThisEmployee(stanInBox);

// C# при необходимости производит упаковку автоматически
t.UnboxThisEmployee(stan);

MyShapes
{
using System;

// Класс Circle
public class Circle { // Интересные методы

}

// Класс Hexagon
public class Hexagon { // Более интересные методы }

// Класс Square
public class Square { // Еще более интересные методы }
}

Circle
class Circle { // Интересные методы }
}

// hexagon.cs
namespace MyShapes
{
using

System;
// Класс Hexagon
class Hexagon { // Более интересные методы }
}

// square.cs
namespace MyShapes
{
using System;
// Класс Square
class Square { // Еще более интересные методы }
}

namespace MyApp
{
using System;
using MyShapes;

class ShapeTester
{
public static void Main()
{
// Все эти

объекты были определены в пространстве имен MyShapes
Hexagon h = new Hexagon();
Circle c = new Circle();
Square s = new Square();
}
}
}

коде есть двусмысленности!
namespace MyApp
{
using System;
using MyShapes;
using My3DShapes;

class ShapeTester
{
public static void

Main()
{
// Неизвестно, к объектам какого пространства имен мы обращаемся
Hexagon h = new Hexagon();
Circle c = new Circle();
Square s = new Square();
}
}

// Еще одно пространство имен для
// геометрических фигур
namespace My3DShapes
{ class Circle{} // Класс 3D Circle
class Hexagon{} // Класс 3D Hexagon
class Square{} // Класс 3D Square
}

больше нет
public static void Main()
{
My3DShapes.Hexagon h = new My3DShapes.Hexagon();
My3DShapes.Circle c

= new My3DShapes.Circle();
MyShapes.Square s = new MyShapes.Square();

}

псевдоним для класса из другого пространства имен
using The3DHexagon =

My3DShapes.Hexagon;

class ShapeTester
{
public static void Main()
{
// Создаем объект при помощи псевдонима
The3DHexagon h2 = new The3DHexagon();
}
}
}

// имен Lecture2Types.My3DShapes
namespace Lecture2Types
{
namespace My3DShapes
{
using System;

// Класс 3D Circle

class Circle{}

// Класс 3D Hexagon
class Hexagon{}

// Класс 3D Square
class Square{}
}
}