В "Искусстве войны" Сунь Цзы утверждает, что "необходимо рассматривать вещи большой важности с небольшим усилием, а вещи небольшой важности с большим усилием". Это может звучать странно, но автор хочет, видимо, сказать, что если заботиться о незначительных вещах, то важные вещи тогда позаботятся о себе сами. Как это применимо к C# и Java?

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

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

Одно из основных различий между C# и Java лежит не в самом языке, а в платформе, поверх которой они реализованы. Программам Java требуется для выполнения кода рабочая среда времени выполнения Java Runtime Environment. C# и, на самом деле, вся платформа .NET выполняются в среде Common Language Runtime.

Большинство свойств CLR, внутреннее управление памятью, согласованность среды, масштабируемость и независимость от базовой платформы отражены в JRE Java. В то время, как JRE ограничена исключительно одним языком Java, CLR предоставляет поддержку и интеграцию нескольких языков с помощью VOS (virtual object system — система виртуальных объектов), которая предоставляет богатую типами систему, предназначенную для реализации множества различных типов языков программирования. Исходный код Java можно компилировать в промежуточное состояние, называемое байт-кодом. Он может затем выполняться с помощью поставляемой виртуальной машины. CLR, наоборот, не предоставляет виртуальную машину. Код C# также компилируется в промежуточное состояние, называемое для удобства промежуточным языком (IL, Intermediate Language). Но код IL передается в управляемые CLR процессы выполнения или компиляторам JIT CLR, обычно называемым JITters, которые преобразуют по требованию разделы IL в собственный код.

Давайте рассмотрим известный пример "Hello, World!" на Java (который будет показан здесь без затенения): 

public class Hello {

 public static void main(String args[]) {

  System.out.println("Hello world! This is Java Code!");

 }

}

Соответствующий код C# для этого примера следующий (представлен на сером фоне):

public class Hello {

 public static void Main(string[] args) {

  System.Console.WriteLine("Hello world! This is C# code!");

 }

}

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

string

Main

System.Console.WriteLine

System.out.println

Необходимо отметить тип

string

String

public class Hello {

 public static void Main(String [] args) {

  System.Console.WriteLine("Hello world! This is C# code!");

 }

}

Можно заметить, что спецификатор ранга массива

[]

args

string

args

[]

// C#

int [] X; // массив целых чисел в C#

// пример java

int [] х; // массив целых чисел в java

int x[]; // массив целых чисел в java

Тот же самый код C# можно также представить следующим образом:

using System;

class Hello {

 public static int Main() {

  Console.WriteLine ("Hello world! This is C# code!");

  return 0;

 }

}

Как можно видеть, изменилось несколько элементов. Объявление

string [] args

using

include

System

System

Console.WriteLine

int

void

return 0;

Блоки кода C# заключаются в фигурные кавычки, также как в Java. Можно сказать, что метод

Main()

static Main

main()

Main

public

Аналогично в Java ключевое слове

static

Main()

void

int

void

int

Ключевые слова, рассматриваемые в следующем разделе, не могут служить идентификаторами ни в Java, ни в C#, однако в C# можно использовать ключевые слова как идентификаторы, помещая перед ними символ

@

$

int 7х; // неверно, цифра не может начинать идентификатор

int х7; // верно, цифра может быть частью идентификатора

int х; // верно

int х$; // неверно, никакие символы недопустимы

int @7k; // неверно, @ работает только для ключевых слов

int @class; // верно, @ перед ключевым словом позволяет использовать

            // его в качестве идентификатора

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

camel

int id;

int idName;

int id_name; // также используется

final int CONSTANT_NAME; // широко распространен

int reallyLongId;

public class ClassName; // каждая первая буква заглавная

public interface _InterfaceName; // с предшествующим подчеркиванием

public void method(){}

public void methodName(){}

public void longMethodName(){}

public void reallyLongMethodName(){}

На основе библиотеки классов, предоставленной компанией Microsoft для C#, можно сделать некоторые предположения о стандартах наименований в C#. Документированные рекомендации по именованию для C# не были представлены в то время когда писалась эта книга. Каждая первая буква идентифицирующих имен всех методов и свойств будет заглавной, так же как и каждая первая буква имен всех классов и пространств имен (рассматриваемых позже). Интерфейсы используют в качестве первого символа

I

int id;

int idName;

public class ClassName // каждая первая буква заглавная

public interface IInterfaceName // имени интерфейса предшествует I

public void Method(){} // первая буква всегда заглавная

public void MethodName(){} // первая буква всех других слов

                           // будет заглавная

public void LongMethodName(){}

public void ReallуLongMetodName(){}

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

int

public

class

static

void

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

Примитивные типы данных в обоих языках ссылаются на низкоуровневые типы значений языка. Конечно, диапазон значений указанных типов может различаться в том или другом языке. Логические значения в C# идентифицируются ключевым словом bool в противоположность boolean в Java. Ниже представлен табличный список типов данных Java и их аналогов в C#:

Существует также ряд типов, поддерживаемых C#, которые Java не использует. Таблица ниже выделяет эти типы данных.

Эти ключевые слова сами являются переменными. Оба языка, Java и C#, имеют по три ключевых слова, которые попадают в эту категорию. Ключевые слова

this

void

super

base

Power

public class SuperEX {

 int power;

 public SuperEX(int power) {

  this.power = power;

 }

 public int aMethod(int x) {

  int total = 1;

  for (int i = 0; i < power; i++) {

   total *= x;

  }

  return total;

 }

 public static void main(String args[]) {

  SuperEX x = new SuperEX(Integer.parseInt(args[0]));

  int tot = x.aMethod(Integer.parseInt(args[1]));

  System.out.println(tot);

 }

}

Класс-потомок этого класса сможет получить доступ к методу

aMethod

super.aMethod(<int value>)

power

super.power = <int value>

super(<int value>)

<int value>

Аналогично в C# класс-потомок этого класса сможет получить доступ к методу

aMethod

super.aMethod(<int value>)

power

super.power = <int value>

namespace SuperEX {

 using System;

 public class SuperEX {

  internal int power;

  public SuperEX(int power) {

   this.power = power;

  }

  public int aMethod(int x) {

   int total = 1;

   for (int i = 0; i < power; i++) {

    total *= x;

   }

   return total;

  }

  public static void Main(String [] args) {

   SuperEX x = new SuperEX(int.Parse(args[0]));

   int tot = x.aMethod(int.Parse(args[1]));

   Console.WriteLine(tot);

  }

 }

 public class Child: SuperEX {

  public Child() : base(55) { }

 }

}

Как можно видеть на примере класса-потомка

Child

<child constructor>: base constructor(<int value>)

<int value>

<child constructor>

ChildConstructor(argument_list) : BaseConstructor(argument_list)

Так же как в Java, в C# инструкции

import

using

package

Большинство упомянутых выше ключевых слов имеют одинаковые имена, синтаксис и функциональность в C# и Java. Исключением является оператор Java

instanceof

is

public static void Main (string[] args)

 int option = int.Parse(arg[0]);

 if (option == 1) {

  // что-нибудь сделать

 }

 else if (option == 2) {

  // сделать что-нибудь еще

 }

 switch (option) {

 case 1:

  // сделать что-нибудь

  break;

 case 2:

  // сделать что-нибудь еще

 default:

  break;

 }

}

C# вводит инструкцию

foreach

foreach

foreach(ItemType item in TargetCollection)

ItemType

TargetCollection

foreach

□ Тип коллекции должен быть интерфейсом, классом или структурой.

□ Тип коллекции должен включать метод

GetEnumerator()

Второй набор требований имеет дело с составом типа перечислителя, возвращаемого упомянутым выше методом

GetEnumerator()

□ Перечислитель должен предоставить метод

MoveNext()

boolean

□ 

MoveNext()

true

□ 

MoveNext()

□ Тип перечислителя должен предоставлять свойство с именем

Current

ItemType

ItemType

□ Метод доступа свойства должен возвращать текущий элемент коллекции.

Следующий пример использует

foreach

Hashtable

Hashtable t = new Hashtable();

t["a"] = "hello";

t["b"] = "world";

t["c"] = "of";

t["d"] = "c-sharp";

foreach (DictionaryEntry b in t) {

 Console.WriteLine(b.Value);

}

Ключевое слово

private

public

C# и Java различаются в том, как обрабатываются

protected

'default'

protected

protected

C# вводит также новый модификатор доступа —

internal

internal

internal

internal

Модификатор

abstract

class

extends

implements

:

interface

class ClassA: BaseClass, Iface1, Iface2 {

 // члены класса

}

public interface IfruitHaver {

 public void Fruit();

}

public class plant: IfruitHaver {

 public Plant() {

 }

 public void Fruit() {

 }

}

class Tree : Plant {

 public Tree() {

 }

}

Ключевое слово

final

final

final

final

final

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

new

Это делается присоединением

new

namespace Fona {

 using System;

 public class Plant {

  public Plant(){}

  public void BearFruit() {

   Console.WriteLine("Generic plant fruit");

  }

 }

 class Tree : Plant {

  public Tree(){}

  // ключевое слово new используется здесь явно, чтобы скрыть

  // базовую версию

  new public void BearFruit() {

   Console.WriteLine("Tree fruit is:->Mango");

  }

 }

 public class PlantEX {

  public PlantEX(){}

  public static void Main(String[] args) {

   Plant p = new Plant();

   p.BearFruit(); // вызывает реализацию базового класса

   Tree t = new Tree();

   t.BearFruit(); // вызывает реализацию класса наследника

   ((Plant)t).BearFruit(); // вызывает реализацию базового класса,

                           // используя наследника.

  }

 }

}

Выполнение этого примера создает следующий вывод:

Generic plant fruit

Tree fruit is:->Mango

Generic plant fruit

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

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

new

не было использовано.

Чтобы предоставить функциональность переопределения, используются модификаторы

virtual

override

virtual

override

Tree

class Tree Plant {

 public Tree() {}

 public override void Fruit() {

  Console.WriteLine("Tree fruit is:->Mango");

 }

}

Компиляция и выполнение этого создают следующий вывод.

Generic plant fruit

Tree fruit is:->Mango

Tree fruit is:->Mango

Как можно видеть, вызывается самый последний переопределенный метод

Fruit()

((Plant)t).BearFruit()

Fruit()

Чтобы помешать случайному наследованию класса, используется ключевое слово

sealed

Plant

public sealed class Plant

Tree

C# не имеет модификатора

native

native

extern

extern

abstract

Plant

extern

public class Plant : IfruitHaver {

 public extern int See();

 public Plant(){}

 public void Fruit() {

  Console.WriteLine("Generic plant fruit");

 }

}

Это не имеет большого смысла без использования атрибута

DllImport

See

User32.dll

public class Plant: IfruitHaver {

 [System.Runtime.InteropServices.DllImport("User32.dll)]

 public static extern int See();

 public Plant(){}

 public void Fruit() {

  Console.WriteLine("Generic plant fruit");

 }

}

Здесь метод

See()

DllImport

Пока не существует версии C# ключевых слов

transient

volatile

synchronized

NonSerialized

transient

Синхронизация в C# несколько усложнена (более трудоемка) по сравнению с ее аналогом в Java. В общем, любой поток выполнения может по умолчанию получить доступ ко всем членам объекта. Имеется, однако ряд способов синхронизации кода в зависимости от потребностей разработчика с помощью использования таких средств, как

Monitors

SyncBlocks

ReaderWriterLock

Mutex

System.Threading.Interlocked

Первый шаг к синхронизации в C# состоит в ссылке на сборку

System.EnterpriseServices.dll

lock(<expression>) {// блок кода}

<ref>

<expression>

this

System.Type

Type

System.Type

Эти модификаторы являются одинаковыми в обоих языках, за исключением инструкции

throws

throws

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

// OverflowEX.java

public class OverfTowEX {

 publiс static void main(String args []) {

  byte x = 0;

  for (int i = 0; i < 130; i++) {

   x++;

   System.out.println(x);

  }

 }

}

Как известно,

byte

byte

126

127

-128

-127

-126

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

□ Программный подход. Чтобы бороться с этим типом молчаливых ошибок, C# вводит концепцию проверяемых и непроверяемых инструкций. Ключевое слово

checked

checked/unchecked

i

checked/unchecked

ii

(i) checked {block_of_code}

unchecked { block_of_code}

(ii) checked (expression)

unchecked (expression)

block_of_code

checked/unchecked

expression

checked/unchecked

checked/unchecked

// OverflowEX.cs

public class OverflowEX {

 public static void Main(String() args) {

  sbyte x = 0; // помните, что необходимо изменить byte на sbyte

  for (int i = 0; i < 130; i++) {

   checked {

    // можно также использовать checked(x++)

    x++;

    Console.WriteLine(x);

   }

  }

 }

}

□ Подход с ключом компилятора. Для контроля переполнения во всем приложении может использоваться настройка компилятора

/checked+

checked

/checked+

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

unchecked

unchecked

OverflowEX.java

// OverflowEX.сs.

public class OverflowEX {

 public static void Main(String[] args) {

  sbyte X = 0;

  for (int i = 0; i < 130; i++) {

   unchecked { // можно также использовать unchecked(x++)

    x++;

    Console.WriteLine(x);

   }

  }

 }

}

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

java.io.BufferedReader

System.in

JavaEcho

Java.io

// JavaEcho.java

import java.io.*;

public class JavaEcho {

 public static void main(String[] args) throws IOException {

  BufferedReader stdin = new BufferedReader(new InputSreamReader(System.in));

  String userInput = stdin.readLine();

  System.out.println("You said: " + userInput);

 }

}

Класс

System.Console

Console

System.Console

Console

Console

Console

Как можно видеть, все члены

Console

static

С помощью мощных методов из класса

Console

JavaEcho

class CSEchoer {

 static void Main(string[] args) {

  string userInput = System.Console.ReadLine();

  System.Console.WriteLine("You said : " + userInput);

 }

}

Приведенный выше код значительно короче и легче, чем его аналог на Java. Статический метод

Console.WriteLine

EchoGame

class EchoGame {

 static void Main(string[] args) {

  System.Console.WriteLine("Once upon a time in a far away" + "?");

  string userInput1 = System.Console.ReadLine();

  System.Console.WriteLine("a young prince ?");

  string userInput2 = System.Console.ReadLine();

  System.Console.WriteLine("One day while?");

  string userInput3 ? System.Console.ReadLine();

  System.Console.WriteLine("He came across a ?");

  string userInput4 = System.ConsoleReadLine();

  System.Console.WriteLine("The prince ?");

  String userInput5 = System.Console.ReadLine();

  System.Console.WriteLine("Once upon a time in a far away"

   + " {0}, a young prince {1}. \n One day"

   + "while {2}, He came across a (3). \n The "

   + "prince {4} ! ", userInput1, userInput2,

   userInput3, userInput4, userInput5);

 }

}

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

{0}

userInput1

WriteLine

{1}

{0}

strA

{2}

strC

Console.WriteLine("hello {0} {1} {2}", strA, strB, strC);

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

Test.java

// Test.java

class x {}

class у {}

class z {}

Компиляция этого файла будет создавать три файла классов:

х.class

у.class

z.class

// Test.java

public class x {}

class у {}

class z {}

В приведенном выше примере имя исходного файла

Test.java

Test.java

х.java

В противоположность этому, компилированный в IL код C# выполняется VES (Virtual Execution System), которая предоставляет поддержку для IL, загружая управляемый код, и JITters (которые преобразуют управляемый код в форме промежуточного языка в собственный код машины). Имя файла

Hello.cs

/out

main

Hello

Goodbу.cs

MisterHanky.exe

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

hello.cs

csc hello.cs

Файл будет компилирован в

hello.exe

Все файлы Java компилируются в файл байт-кода с расширением

.class

Form

AddLib.java

JavaFrame

AddLib

// код для JavaFrame.java

Package com.javaapp;

import java.awt.*;

import java.io.*;

import com.javalib.AddLib;

public class JavaFrame extends java.awt.Frame {

 public static void main (String[] args) {

  JavaFrame jfrm = new JavaFrame();

  jfrm.setSize(100, 100);

  jfrm.setVisible(true);

  AddLib lib = new AddLib();

  jfrm setTitle("Frame Version " + lib.operationAdd(12, 23));

 }

}

// код для AddLib.java

Package com.javalib;

public class AddLib {

 public AddLib() {

 }

 public int operationAdd(int a, int b) {

  return a + b;

 }

}

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

-classpath

Classpath

-classpath

-classpath

Classpath

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

JavaFrame

AddLib

CLASSPATH

java javalib.JavaFrame

приводит к выполнению программы

JavaFrame

Frame

Код в C# всегда после компиляции автоматически объединяется в тот или иной тип компонента. Единицы компиляции могут содержать столько файлов и определений классов, сколько потребуется. Способ использования этой функциональности снова делится между использованием командной строки и использованием IDE (в частности, Visual Studio.NET). Создание нового проекта с помощью VS.NET требует, чтобы был определен тип создаваемого проекта. Среди других имеются возможности создать консольное приложение, оконное приложение и библиотеку классов. Можно создать даже пустой проект и определить тип вывода позже. Процесс определения типа вывода проекта с помощью VS.NET описан дальше в этом разделе. В командной строке для изменения типа вывода используется ключ

/target: <target-type>

target-type

□

Ехе

□

Library

□

Winexe

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

csc /target:<target-type> <file1> <file2> ... <filen>

Добавление нескольких файлов в единицу компиляции с помощью VS.NET является вопросом добавления отдельных файлов в проект. Можно легко изменить тип выходного файла, поменяв свойство Output Type на странице General Properties (смотрите выше детали доступа к странице с общими свойствами).

Цель данного изложения состоит в создании версии C# файлов исходного кода

JavaFrame

AddLib

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

Пространства имен в C# предоставляют аналогичный механизм для объединения управляемых классов, но являются значительно более мощными и гибкими. Здесь речь идет об управляемых классах, а не специальных классах C#, так как классы в пространстве имен могут быть из любого, соответствующего CLS, языка (вспомните, что CLS является независимым от языка). Пакеты и пространства имен, однако, существенно различаются своей реализацией. Класс Java, который необходимо, например, сделать частью пакета

com.samples

Package com.samples

com.samples

// package_samples.java

package samples.on; // отображает прямо в папку, где находится файл класса

public class Packaging {

 int x;

 public class Internal {

  // находится автоматически в том же пакете

 }

 public static void main(String args[]) {

 }

}

class Internal {

 // находится автоматически в том же пакете

}

Примеры того, как этот код может выполняться, приведены ниже. Это, конечно, предполагает, что файл класса был сделан доступным для JRE:

□ Из командной строки:

java samples.on.Packaging

□ Как непосредственная ссылка в коде:

// Referencer.java

public class Referencer {

 samples.on.Packaging pack = new samples.on.two.three.Packaging();

□ Используя директиву

import

Referencer

// Referencer.java

import samples.on.*;

public class Referencer{

 Packaging pack = new Packaging();

}

Помещение класса в пространство имен достигается в C# с помощью ключевого слова

namespace

// namespace_samples.cs

namespace Samples.On {

 using System;

 public class Example {

  public Example() {

  }

 }

}

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

// namespace_samples.cs

namespace Samples.On {

 using System;

 public class Example {

  public Example() {

  }

 }

}

namespace Com.Cslib {

 using System;

 using System.Collections;

 public class AddLib {

  public AddLib() {

  }

  public int operationAdd(int a, int b) {

   return a + b;

  }

 }

}

Пространства имен вводятся с помощью директивы

using <namespace name>

<namespace name>

*

using

Example

AddLib

namespace_samples.cs

Example

System.Collections

AddLib

import

х.java

// х.java

public class x {

}

class у {

}

class z {

}

Если добавить инструкцию импорта, такую как

import java.util.Hashtable

Hashtable

// x.java

package samples;

import java.util.Hashtable;

public class x {

 Hashtable hash = new Hashtable();

}

class у {

 Hashtable hash = new Hashtable();

}

class z {

 Hashtable hash = new Hashtable();

}

Пространства имен можно также определять внутри другого пространства имен. Этот тип гибкости недоступен в Java без создания подкаталогов. Приведенное выше пространство

Com.Cslib

namespace Com.Cslib {

 using System;

 public class AddLib {

  public AddLib() {

  }

  public int operationAdd(int a, int b) {

   return a + b;

  }

 }

 namespace Ext {

  public class AddLib {

   public AddLib() {

   }

   public int operationAdd(int a, int b) {

    return a + b;

   }

  }

 }

}

Пакет Java

com.javalib

\EXT

com\javalib

AddLib.java

package com.javalib.ext;

public class AddLib {

 public AddLib() {

 }

 public int operationAdd(int a, int b) {

  return a + b;

 }

}

Отметим, что имя пакета было расширено для этого класса до

com.javalib.ext

Внутреннее пространство имен и подпакеты доступны с помощью оператора точки "."; следовательно, можно было в C# извлечь расширенный AddLib с помощью нотации

Com.Cslib.Ext.AddLib

com.javalib.ext.AddLib

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

Com.Cslib.AddLib

Com.Cslib.Ext.AddLib

Классы Java являются частью пакета, нравится им это или нет. Все классы, созданные без указания пакета, предполагают включение в пакет по умолчанию. C# имитирует эту функциональность. Даже если не объявить пространство имен, оно будет создано по умолчанию. Оно присутствует в каждом файле и доступно для использования в именованных пространствах имен. Так же как в Java нельзя изменить информацию о пакете, пространства имен нельзя модифицировать. Пакеты могут охватывать несколько файлов в одной папке, пространство имен может охватывать несколько файлов в любом числе папок и даже в нескольких сборках (сборки будут рассмотрены в следующем разделе). Два класса, охватываемые пространством имен А, которые определены в отдельных файлах и существуют в отдельных папках, оба являются частью пространства имен А.

Чтобы получить доступ к элементу в пространстве имен, необходимо либо использовать полностью квалифицированное имя типа (в приведенном выше примере это

Com.Cslib.AddLib

using

public

final

abstract

Последним атрибутом, который относится к пространству имен, но не имеет отношения к пакетам, является возможность задания алиаса для

using

using

Very.Very.Long.Namespace.Name

using

using WLNN = Very.Very.Long.Namespace.Name;

Конечно, имя псевдонима (алиаса) является произвольным, но должно следовать правилам именования переменных в C#.

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

Classpath

jar

Classpath

Classpath

C# предоставляет совсем другие механизмы для упаковки классов в библиотеку. По умолчанию все файлы C# в проекте станут частью единицы компиляции при использовании VS.NET. Если применяется командная строка, необходимо будет явно добавлять каждый файл, который должен быть частью единицы компиляции, как описано выше.

Библиотеки кодов компилируются в РЕ (portable executable — переносимый исполнимый) тип файла. Необходимо в этом месте сделать различие между библиотеками кодов, о которых идет речь, и проектом Class Library в C#, который может создаваться с помощью IDE VS.NET. Под библиотекой кода понимается повторно используемое множество файлов C#, соединенных вместе в некоторой единице компиляции, поэтому происходит ссылка на файл РЕ, а не на реальную DLL или ЕХЕ. Библиотека кода такого вида более часто называется сборкой, поэтому это название будем использовать в дальнейшем, чтобы избежать путаницы.

Так же как файл JAR, сборка имеет манифест, который описывает ее содержимое. Манифест сборки C# делает, однако, значительно больше. Он содержит все метаданные (совокупность данных, описывающая, как связаны элементы сборки), необходимые для определения требований версии, идентичности безопасности и всей информации, служащей для определения области действия сборки и разрешения ссылок на ресурсы и классы. Манифест сборки может храниться либо в файле РЕ (ЕХЕ или DLL) с кодом IL, либо как автономный файл, который содержит только данные манифеста сборки. В .NET пространства имен, содержащиеся внутри сборки, представлены внешнему миру (то есть, любым потребителям сборки, таким, как другие сборки) с помощью информации метаданных о типах, хранящейся в манифесте сборки.

Классы в

namespace_samples.cs

CSC /target:library /out:FirstLibrary.dll namespace_samples.cs

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

/addmodule

/reference

/reference

/addmodule

csc /reference: <lib.dll>; <libn.cs> <filename.exe>

или:

csc /addmodule: <lib.dll>; <libn.cs> <filename.exe>

Чтобы добиться этого с помощью VS.NET, сделайте щелчок правой кнопкой мыши на папке References своего проекта в Solution Explorer и выберите Add Reference. Появится диалоговое окно, содержащее ряд доступных ссылок и позволяющее просматривать файловую систему в поисках ссылок. Можно также вызвать это диалоговое окно, выбирая пункт Add Reference из меню Project, когда выделен требуемый проект. Добавление ссылки в текущую сборку обычно копирует упомянутый файл в папку проекта, где будет располагаться новая сборка.

Давайте создадим теперь потребителя для библиотеки

AddLib

JavaFrame

// LibConsumer.cs

namespace Com.CSapp {

 using System;

 using System.Windows.Forms;

 using Com.CsLib;

 public class Form1 : System.Windows.Forms.Form {

  public Form1() {

   AddLib al = new AddLib();

   this.Text = "C# Form version " + al.operationAdd(12, 23);

  }

  public override void Dispose() {

   base.Dispose();

  }

  Static void Main(string[] args) {

   Form1 f1 = new Form1();

   Application.Run(f1);

  }

 }

}

Этот код можно компилировать из командной строки со ссылкой на

FirstLibrary.dll

csc /reference: FirstLibrary.dll /target:exe /out:EmptyForm.exe LibConsumer.cs

Используя VS.NET, надо сначала сослаться на

FirstLibrary.dll

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

EmptyForm.exe

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

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

admin.cfg

Затем CLR необходимо найти сборку. В Java JRE будет действовать в текущем каталоге и в

classpass

<codeBase>

<probing>

.exe

.dll

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

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

sn -k <имя файла ключа>

Например, чтобы создать файл ключа

examplekey.key

sn -k examplekey.key

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

alink

al /keyfile: <имя файла ключа> <имя сборки>

Чтобы задать для

FirstLibrary.dll

al /keyfile:examplekey.key FiretLibrary.dll

или в VS.NET изменить атрибут

[assembly: AssemblyKeyFile("")]

AssemblyInfo.cs

FirstLibrary.dll

AssemblyKeyFile

[assembly: AssemblyKeyFile("examplekey.key")]

Все сборки в глобальном кэше сборок должны иметь устойчивое имя. Глобальный кэш сборок применяется для хранения сборок, специально созданных для общего использования несколькими приложениями на машине. Существует несколько способов размещения сборки в глобальном кэше сборок. Можно использовать программу установки, созданную для работы с глобальным кэшем сборок, .NET Framework SDK предоставляет программу установки с именем

gacutil.exe

FirstLibrary.dll

gacutil -i FirstLibrary.dll

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

Типы данных в Java и в C# можно сгруппировать в две основные категории: типы данных значений и ссылочные типы. Существует только одна категория типа данных значений в Java. Все типы данных значений являются по умолчанию примитивными типами данных языка. C# предлагает более обильный ассортимент. Типы данных значений можно разбить на три основные категории:

□ Простые типы

□ Типы перечислений

□ Структуры

Давайте рассмотрим каждый из них по очереди.

Ранее в разделе о ключевых словах было сделано подробное сравнение между примитивными типами данных Java и их эквивалентами в C# (по размеру). Был также введен ряд типов данных значений, представленных в C#, которых Java не имеет. Это были 8-битовый без знака

byte

от

sbyte

ushort

uint

ulong

decimal

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

int

uint

long

ulong

decimal

int dec = 52;

int hex = 0x34;

Console.WriteLine("decimal {0}, hexadecimal {1}", dec, hex);

char

\х

\u

bool

boolean

true

false

bool first_time = true;

cool second_time = (counter < 0);

C# вводит тип данных

decimal

decimal

m

double

decimal

double

decimal precise = 1.234m;

decimal precise = (decimal)1.234;

Значения с плавающей точкой могут быть либо

double

float

double

float

double

float f = 5.6;

Console.WriteLine(x);

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

C:\_wrox\c# for java developers\code\SuperEX\Class1.cs(15): Literal of type double cannot De implicitly converted to type 'float'; use an 'F' suffix to create a literal of this type

Существует два способа решения этой проблемы. Можно преобразовать литерал во

float

F

float

double

D

Double

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

static final

interface Color {

 static int RED = 0;

 static int GREEN = 1;

 static int BLUE = 2;

}

Этот подход проблематичен тем, что он не является безопасным в отношении типов данных. Любое считанное или вычисленное целое используется в качестве цвета. Можно, однако, программным путем реализовать перечисление с безопасными типами в Java, используя вариант шаблона (паттерна) Singleton, который ограничивает класс предопределенным числом экземпляров. Приведенный далее код показывает, как это можно сделать:

final class Day {

 // final, поэтому нельзя создавать подклассы этого класса

 private String internal;

 private Day(String Day) {internal = Day;} // закрытый конструктор

 public static final Day MONDAY = new Day("MONDAY");

 public static final Day TUESDAY = new Day("TUESDAY");

 public static final Day WEDNESDAY = new Day("WEDNESDAY");

 public static final Day THURSDAY = new Day("THURSDAY");

 public static final Day FRIDAY = new Day("FRIDAY");

}

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

final

Можно согласиться с тем, что хотя концепция достаточно простая, обход включает развитую технику и она может не сразу стать понятной новичку, в конце концов нам требуется только список констант; C#, в противоположность, предоставляет встроенную поддержку перечислении, которая обеспечивает также безопасность типов. Чтобы объявить в C# перечисление, используется ключевое слово

enum

enum

public enum Status {

 Working,

 Complete,

 BeforeBegin

}

В приведенном выше случае первое значение равно 0 и

enum

Complete

enum

public enum Status {

 Working = 131,

 Complete = 129,

 BeforeBegin = 132

}

Имеется также возможность использовать другие числовые целые типы 'наследуя' от

long

short

byte

int

public enum Status : int {

 Working,

 Complete,

 BeforeBegin

}

public enum SmallStatus : byte {

 Working,

 Complete,

 BeforeBegin

}

public enum BigStatus : long {

 Working,

 Complete,

 BeforeBegin

}

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

byte

SmallStatus

sizeof()

Status

int х = sizeof(Status);

int у = sizeof(SmallStatus);

int Z = sizeof(BigStatus);

Console.WriteLine("Regular size:\t{0}\nSmall size \t{1}\nLarge size:\t{2}", x, y, z);

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

Regular size: 4

Small size:   1

Large size:   8

Одним из основных различий между структурой C# (идентифицируемой ключевым словом

struct

struct

struсt

public struct WroxInt {

 int internalVal;

 private WroxInt(int x) {

  internalVal = x;

 }

 public override string ToString() {

  return Int.ToString(internalVal);

 }

 public static impicit operator WroxInt(int x) {

  return new WroxInt(x);

 }

}

public static void UseWroxInt() {

 WroxInt wi = 90;

 Console.WriteLine(wi);

}

Этот пример показывает типы, которыми владеют мощные структуры.

WroxInt

int

□ 

struct

struct

□ 

struct

□ Хотя

struct

□ Члены

struct

□ Возможно создание экземпляра

struct

new

□ 

struct

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

StructLayout

System.Runtime.InteropServices

struct

union

union

union

union

struct

[StructLayout(LayoutKind.Explicit)]

public struct Variant {

 [FieldOffset(0)] public int intVal;

 [FieldOffset(0)] public string stringVal;

 [FieldOffset(0)] public decimal decVal;

 [FieldOffset(0)] public float floatVal;

 [FieldOffset(0)] public char charVal;

}

Атрибут

FieldOffset

decimal

Ссылочные типы хранят ссылку на данные, которые существуют в куче. Только адреса памяти хранимых объектов сохраняются в стеке. Тип объекта, массивы, интерфейсы тип класса и делегаты являются ссылочными типами. Объекты, классы и отношения между ними не отличаются в Java и C#. Интерфейсы и их использование также похожи в обоих языках. Одно из основных различий, которое, вероятно, уже встречалось, состоит в том, что C# не имеет ключевых слов

extends

implements

:

using

import

C# поддерживает "неровные" массивы и добавляет многомерные массивы. Может сбить с толку то, что Java не делает между ними различий:

int [] х = new int[20]; // как в Java, только [] должны следовать

                        // за типом

int [,] у = new int[12, 3]; // то же самое, что int у[] [] = new

                            // int[12][3];

int[][] z = new int[5][]; // то же самое, что и int x[][] = new

                          // int [5][];

Примечание. Ключевое слово

int[]

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

C# и Java используют знак

=

ExOperators

public class EXOperators {

 internal int р;

 public EXOperators() {}

 public static void Main() {

  ExOperators one = new EXOperators();

  one.p = 200;

  EXOperators two;

  two = one;

  two.p = 100;

  Console.WriteLine(two.p);

  Console.WriteLine(one.p);

 }

}

Пока проигнорируем ключевое слово

internal

р

р

Main

EXOperators

one

two

p

two

p

two.р

one.р

Операторы сравнения обычно совпадают по форме и функциональности в обоих языках. Четырьмя основными операторами являются

<

>

<=

>=

Чтобы определить, принадлежит ли объект заданному классу или любому из классов предков, Java использует оператор

instanceof

String у = "a string";

Object х = у;

if (х instanceof String) {

 System.out.println("х is a string");

}

В C# эквивалентом

instanceof

is

true

string у = "a string";

object х = у;

if (х is System.String) {

 System.Console.WriteLine("x is a string");

}

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

Преобразование в Java состоит из неявного или явного сужения или расширения преобразования типа при использовании оператора

()

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

Упаковка объекта означает неявное преобразование любого типа значения в объектный тип. Экземпляр объекта создается и выделяется, а значение из типа значения копируется в новый объект. Здесь приведен пример, показывающий, как упаковка работает в C#:

// BoxEx.cs

public class OverflowEX {

 public static void Main(String[] args) {

  int x = 10;

  Object obj = (Object)x;

  Console.WriteLine(obj);

 }

}

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

// BoxEx.java

public class BoxEX {

 public static void main(String args[]) {

  int x = 10;

  object obj = (object)x;

  System.out.println(obj);

 }

}

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

BoxEx.cs

// BoxEX.cs

public class OverflowEX {

 public static void Main(String[] args) {

  int x = 10;

  Object, obj = (Object)x;

  Console.WriteLine(obj);

  int у = (int)obj;

  Console.WriteLine(y);

 }

}

Другим эффективным способом C#, предназначенным для преобразования типов, является возможность определить специальные операторы преобразования. Определенные пользователем преобразования выполняются из типа данных в тип, а не из экземпляра в экземпляр, поэтому они должны быть статическими операциями. Можно использовать ключевое слово

implicite

Man

Car

Man.cs

public class Man {

 int arms, legs;

 string name;

 public Man(){}

 public int Arms {

  set {

   arms = value;

  }

  get {

   return arms;

  }

 }

 public string Name {

  set {

   name = value;

  }

  get {

   return name;

  }

 }

 public int Legs {

  set {

   legs = value;

  }

  get {

   return legs;

  }

 }

}

Как можно видеть из приведенного примера, класс

Man

Legs

Arms

Name

Car

public class Car {

 int wheels, doors, headlights;

 public Car(int wheels, int doors, int headlights) {

  this.wheels = wheels;

  this.doors = doors;

  this.headlights = headlights;

 }

}

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

Car.wheel

Man.legs

Car.doors

Man.arms

Car

Man.Name

Car.headlights

Man.name

Man.name

Car.headlights

headlights

Man.name

Car

public class Car {

 int wheels, doors, headlights;

 public Car(int wheels, int doors, int headlights) {

  this.wheels = wheels;

  this.doors = doors;

  this.headlight = headlights;

 }

 public static implicit operator Car(Man man) {

  return new Car(man.Legs, man.Arms, 2);

 }

 public static explicit operator(Car car) {

  Man man = new Man();

  man.Arms = car.doors;

  man.Legs = car.wheels;

  man.Name = "john";

  return man;

 }

}

Мы добавим также переопределенные версии для методов

ToString()

Car

// для Man.cs

public override string ToString() {

 return "[arms:" + arms + "|legs:" + legs + "|name:" + name + "]";

}

// для Car.cs

public override string ToString() {

 return "[wheels:" + wheels + "|doors:" + doors + "|headlights:" + headlights + "]";

}

Листинг кода ниже показывает использование специального преобразования:

// BoxEx.cs

public class OverflowEX {

 public static void Main(String[] args) {

  Car car = new Car (4, 5, 2);

  Man man = (Man) car; // использует явное специальное преобразование

  Console.WriteLine("Man - ");

  Console.WriteLine(man);

  Console.WriteLine();

  Car car2 = man; // использует неявное специальное преобразование

  Console.WriteLine("Car - ");

  Console.WriteLine(car2);

 }

}

Компиляция и выполнение этого кода создает показанные ниже результаты:

Man -

[arms:5|legs:4|name:john]

Car -

[wheels:4|doors:5|headlights:2]

В начале важно отметить, что перезагрузка операторов не определена в CLS. Однако CLS обращается к ней, потому что языки, обеспечивающие ее функциональность, делают это способом, который могут понять другие языки. Таким образом, языки, которые не поддерживают перезагрузку операторов, все-таки имеют доступ к базовой функциональности. Java является примером языка, который не поддерживает перезагрузку операторов, — ни одна из концепций, рассмотренных в этом разделе, не может ее использовать. Спецификация среды .NET включает ряд рекомендаций для проведения перезагрузки операторов.

□ Определите операторы на типах данных значений, которые логически являются встроенным типом языка (таким, как

System.Decimal

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

□ Применяйте соглашения об именах и сигнатурах, описанные в CLS.

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

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

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

static

public

В нижеследующем примере создается тип данных значения

Wheels

public struct Wheels {

 int wheel;

 // загрузить начальное значение в wheel

 private Wheels(int initVal); {

  wheel = initVal;

 }

 /// <summary>

 /// показывает внутреннее число wheels

 /// </summary>

 internal int Number {

  set {

   wheel = value;

  }

  get {

   return wheel;

  }

 }

 /// <summary>

 /// возвращает внутреннее число. Если этот метод

 /// не переопределен, то возвращаемой строкой будет тип Two.Wheels.

 /// </ summary >

 /// <returns></returns>

 public override string ToString() {

  return wheel.ToString();

 }

 /// < summary>

 /// выполнить операцию сложения на двух wheels

 /// </summary>

 /// <param name="w1"></param>

 /// <param name="w2"></param>

 /// <returns></returns>

 public static Wheels operator + (Wheels w1, Wheels w2) {

  w1.wheel += w2.wheel; return w1;

 }

 /// <summary>

 /// предоставляет альтернативную функциональность сложения.

 /// отметим, что вторая альтернатива операции сложения

 /// находится не в этой структуре, а в классе car

 /// </summary>

 /// <param name= "w"></param>

 /// <returns></returns>

 public Wheels AddWeels(Wheels w) {

  this.wheel += w.wheel;

  return this;

 }

 /// <summary>

 /// поэтому целые литералы можно неявно преобразовать в wheel

 /// </summary>

 /// <param name="x"></param>

 /// <returns></returns>

 public static implicit operator Wheels(int x) {

  return new Wheels(x);

 }

}

Здесь выделим использование метода

AddWheel()

public static void Main(String[] args) {

 Wheels front = 2; // неявное преобразование

 Wheels back = 4; // неявное преобразование

 Wheels total = front + back; // перезагруженная версия сложения

 Console.WriteLine(total);

}

Компиляция и выполнение этого кода дадут в результате 6. Можно также изменить тип

Car

Wheels

Car

public class Car {

 int wheels, doors, headlights;

 public Car(int wheels, int doors, int headlights) {

  this.wheels = wheels;

  this.doors = doors;

  this.headlights = headlights;

 }

 public Car AddWheel(Two.Wheels w) {

  this.wheels += w.Number;

  return this;

 }

 internal int Wheels {

  set {

   wheels = value;

  }

  get {

   return wheels;

  }

 }

 /// <summary>

 /// выполняет операцию сложения на Wheel и Car

 /// </summary>

 /// <param name="c1">car</param>

 /// <param name="w1">wheel</param>

 /// <returns></returns>

 public static Car operator +(Car c1, Wheels w1) {

  c1.Wheels += w1.Number;

  return c1;

 }

 /// <summary>

 /// выполняет операцию вычитания на Wheel и Car

 /// </summary>

 /// <param name="c1">car</param>

 /// <param name="w1">wheel</param>

 /// <returns></returns>

 public static Car operator -(Car c1, Wheels w1) {

  c1.Wheels -= w1.Number;

  return c1;

 }

 public override string ToString() {

  return

   "[wheels = " + wheels + "| doors = " + doors + "|"

   + " headlights = " + headlights + "]";

 }

}

В класс

Car

AddWheel

Car

public static void Main(String[] args) {

 Wheels front = 2;

 Wheels back = 4;

 Wheels total = front + back;

 Car greenFordExpedition = new Car(0, 4, 2);

 Console.WriteLine("initial:\t" + greenFordExpedition);

 greenFordExpedition += total;

 Console.WriteLine("after add:\t" + greenFordExpedition);

 greenFordExpedition -= front;

 Console.WriteLine("after subtract:\t" + greenFordExpedition);

}

Компиляция и выполнение этого кода создадут приведенные ниже результаты:

initial:        CAR-[wheels = 0| doors = 4| headlights = 2 ]

after add:      CAR-[wheels = 6| doors = 4| headlights = 2 ]

after subtract: CAR-[wheels = 4| doors = 4| headlights = 2 ]

Так как Java не имеет других типов данных значений, кроме примитивных, размер которых всегда известен, то реального применения для оператора

sizeof

struct

enum

sizeof

sizeof(<Value Type>)

<Value Type>

struct

enum

sizeof

sizeof

Оператор

typeof

public static

Class

typeof

sizeof

typeof(<Type>)

<Type>

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

namespace Samples {

 using System;

 using System.Collections;

 public delegate void TestDelegate(string k); // определяет делегата,

  // который получает строку в качестве аргумента

 public class Sample {

  public Sample() {}

  public void test(string i) {

   Console.WriteLine(i + " has been invoked.");

  }

  public void text2(string j) {

   Console.WriteLine("this is another way to invoke {0}" + j);

  }

  public static void Main(string[] args) {

   Sample sm = new Sample();

   TestDelegate aDelegate = new TestDelegate(sm.test);

   TestDelegate anotherDelegate = new TestDelegate(sm.test2);

   aDelegate("test");

   anotherDelegate("test2");

  }

 }

}

Первый шаг по использованию делегатов состоит в определении делегата. Наш тестовый делегат определяется в строке

public delegate void TestDelegate(string k);

new

aDelegate

aDelegate("test");

Как в Java, как и в C#, класс является скелетом, который содержит методы, но не данные. Это структура потенциального объекта. Образование экземпляра класса создает объект на основе этой структуры. Существуют различные ключевые слова и концепции, связанные с классами, которые, были рассмотрены ранее. В этом разделе мы повторим эти ключевые слова и введем новые.

Как и в Java, модификаторы в C# используются для модификации объявлений типа и членов. Далее представлен список модификаторов C#. Более подробное определение значений отдельных идентификаторов дано в разделе о ключевых словах данного приложения. Однако некоторые из перечисленных модификаторов являются новыми и будут рассмотрены в ближайших разделах.

Первый метод, который будет вызван в классе в процессе создания экземпляра объекта,— это конструктор. Утверждение справедливо для Java, C++, C# и других языков. Фактически, даже если специально не писать свой собственный конструктор, будет создан конструктор по умолчанию. Но в C# обращение к объекту-предку или другому конструктору обрабатывается совершенно по-другому, чем в Java:

public class Parent {

}

public class Sample: Parent {

 private string internalVal;

 private string newVal;

 public Sample():base() {}

 public Sample(String s) {

  internalVal = s;

 }

 public Sample(String s, String t) : this(s) {

  newVal = t;

 }

}

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

:

base

base

Sample

public class Parent {

 protected Parent(string a) {

  Console.WriteLine(a);

 }

 protected Parent() {

  Console.WriteLine("This is the base constructor");

 }

}

public class Sample: Parent {

 public Sample() {

 }

 public Sample(String s):base(s) {

 }

 public Sample(String s, String t): this(s) {

  Console.WriteLine(t);

 }

}

C# вводит концепцию деструкторов, позаимствованную из C++. Они работают аналогично завершителям (

finalizer

~

~Sample() {

}

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

close

Java и C# существенно различаются в синтаксисе и идеологии в отношении способа, которым объект образовывает методы. Это связано с одной причиной — не все параметры типа ссылочных данных передаются как ссылки и не все простые типы данных должны передаваться по значению. Имеется возможность передавать аргументы по значению, как параметр

in

ref

out

public static void Main(string[] args) {

 int a = 10;

 Console.WriteLine(a);

 Add(a);

 Console.WriteLine(a);

}

public static void Add(int a) {

 a++;

}

будет создавать результат, показанный ниже, как в C#, так и в Java:

10

10

Мы передаем

а

Main

Add

а

public static void Main(string[] args) {

 int a = 10;

 Console.WriteLine(a);

 Add(ref a);

 Console.WriteLine(a);

}

public static void Add(ref int a) {

 a++;

}

и получить:

10

11

Чтобы использовать ссылочный параметр, надо перед типом параметра использовать ключевое слово

ref

out

public static void Main(string[] args) {

 int a;

 Add(out a);

 Console.WriteLine(a);

}

public static void Add(out int a) {

 a = 100;

}

Еще одним удачным способом в C# является сокрытие метода. Концепция сокрытия метода обсуждалась ранее в этом приложении. Она позволяет иметь такую же сигнатуру, как и у метода базового класса, не переопределяя базовый метод. Это делается с помощью ключевого слова new, которое помещается перед реализацией метода. Отметим, что, как описано ранее, отсутствие ключевого слова

new

this

namespace Sample {

 using System;

 public class SuperHider {

  public string Test() {

   return "parent test";

  }

 }

 public class Hider: SuperHider {

  public Hider() {

  }

  new public string Test() {

   return "child test";

  }

 }

}

Следующий листинг показывает, как вызывается любая версия метода

Test()

Rider hider = new Hider();

Console.WriteLine(hider.Test());

Console.WriteLine(((SuperHider)h).Test());

Результатом этих вызовов будет:

Child test

Parent test

Сокрытие методов существенно отличается от переопределения методов. В C# переопределение метода является явной процедурой. Это отличается от подхода Java, где переопределение является поведением по умолчанию, когда сигнатура члена суперкласса совпадает с сигнатурой в его подклассе. Чтобы переопределить метод базового класса в C#, необходимо пометить его как

virtual

Hider

namespace Samples {

 using System; public class SuperHider {

  public string Test() {

   return "parent test";

  }

 }

 public class Hider: SuperHider {

  public Hider() {

  }

  public override string Test() {

   return "child test";

  }

 }

}

Этот код не будет компилироваться. Надо сначала проинформировать компилятор, что указанный метод, в данном случае

SuperHider.test()

virtual

namespace Samples {

 using System;

 public class SuperHider {

  public virtual string Test() {

   return "parent test";

  }

 }

 public class Hider: SuperHider {

  public Hider() { }

  public override string Test() {

   return "child test";

  }

 }

}

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

Hider hider = new Hider();

Console.WriteLine(hider.Test());

Console.WriteLine(((SuperHider)hider).Test());

Так как гарантировано, что всегда вызывается версия

test

Hider

Child test

Child test

Единственное синтаксическое различие между абстрактными классами в Java и C# состоит в размещении ключевого слова

abstract

Раньше методы

get()

set()

accessor

value

set

get

namespace Samples {

 using System;

 public class Properties {

  private int age;

  private string name;

  public Properties(string name) {

   this.name = name;

  }

  public int Age {

   get {

    return age;

   }

   set {

    age = value;

   }

  }

  public string Name {

   get {

    return name;

   }

  }

 }

}

В указанном примере свойство

Age

get

set

Name

Name

Properties props = new Properties("john");

props.Age = 21;

Console.WriteLine("My name is {0}, and I am {1} years old.", props.Name, props.Age);

Результатом этого кода является:

My name is john, and I am 21 years old.

Примечание. Имена свойств должны быть уникальными.

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

public string this[string a] {

 get {

  if (a.Equals("Age")) return int.ToString(age);

  else if (a.Equals("Name")) return name;

  else {

throw new Exception("can only accept 'name' or 'age' key");

  }

 }

 set {

  if (a.Equals("Age")) age = int.Parse(value);

  else {

throw new Exception(a + " is read only or does not exist");

  }

 }

}

Затем можно обратиться к атрибутам свойств следующим образом:

Properties props = new Properties("john");

props["Age"] = "21";

Console.WriteLine("my name is {0}, I am {1} years old.", props["Name"], props["Age"]);

В результате мы получим:

My name is john, I am 21 years old.

События C# предоставляют значительно более надежный и гибкий паттерн наблюдателя, чем в Java. Более того, они могут быть объявлены либо как поля, либо как свойства. Создание события является процессом из трех частей. Сначала мы получаем делегата, а затем событие, связанное с этим делегатом, и наконец, когда происходит некоторое действие, вызывается событие.

Проиллюстрируем это, удаляя исключения из класса

Properties

Properties

public delegate void ObservableDelegate(string message);

Затем объявляется

delegate

event

public event ObservableDelegate ExceptionEventListener;

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

public string this[string а] {

 get {

  if (a.Equals("Age")) {

   return int.ToString(age);

  } else if (a.Equals("Name")) {

   return name;

  } else {

ExceptionEventListener(can only accept 'name' or 'age' key");

   return null; // поток программы продолжается после того, как

                // событие было инициировано, поэтому необходимо

                // вернуть значение. В этом случае, так как ключ

                // является недействительным (не 'name' или 'age'),

                // возвращается null, указывая отсутствие значения

  }

 }

 set {

  if (a.Equals("Age") {

   age = int.Parse(value);

  }

  else {

   listener(a+ " is read only or does not exist");

  }

 }

}

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

□ Создание в событии новых экземпляров делегатов

□ Удаление экземпляров делегатов из события

C# использует операторы

+=

-=

public delegate void TestEvent();

public class Tester {

 public event TestEvent testEvent;

 Tester() { }

 public void Perform() {

  testEvent();

 }

 public class Client {

  Client() {

   Tester tester = new Tester();

   TestEvent a = new TestEvent(Callback1); // сначала создать делегата

   tester.testEvent += a; // затем добавить его

   tester.testEvent += new Test(CallBack2); // или можно сделать это

                                            // за один проход

   tester.testEvent += new Test(Callback3);

   tester.testEvent += new Test(Callback4);

   tester.Perform();

  }

  public void CallBack1() {

   // уведомить через e-mail)

  }

  public void CallBack2() {

   // послать факсы

  }

  public void CallBack3() {

   // послать беспроводное сообщение

  }

  public void CallBack4() {

   // сохранить в журнале

  }

 }

}

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

Notify()

public static void Notify(string i) {

 Console.WriteLine(i);

}

Этот метод использует такую же сигнатуру, что и приемник событий класса

Properties

Main

Notify()

Properties props = new Properties("hello"); // зарегистрировать обработчик событий

props.ExceptionEventListener += new ExceptionEventListener(test);

p["Aged"] = "35"; // неправильный ключ используется

                  // для моделирования ошибки

Исключения в C# на первый взгляд являются такими же, как в Java. Инструкции C#

try-catch

try-catch-finally

throws

try-finally

finally

Порождение исключений делается с помощью инструкции

throw

SystemException

throw new SystemException (<arg-list>);

throws

□ 

Exception

□ 

SystemException

□ 

IndexOutOfRangeException

□ 

NullReferenceException

null

□ 

InvalidOperationException

□ 

ArgumentException

□ 

ArgumentNullException

null

□ 

InteropException

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

System.OverflowException

checked

unchecked

checked

unchecked

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

true

/define

csc /define:TEST_TEST samples.cs

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

#define

□ 

#if

□ 

#elif

#if

□ 

#else

#if

#elif

□ 

#endif

#if

namespace Samples {

 using System;

#if EXAMPLE

 public class Example {

  public Example() {

  }

 }

#elif TEST_TEST

 public class Test {

  public Test() {

  }

 }

#else

 public class None {

  public None() {

  }

 }

#endif

}

Добавление инструкции

#define TEST_TEST

Test

#define EXAMPLE

Example

None

#warning

#error

#if

#else

#warning I wouldn't try to instantiate the example object if I were you

C# также поддерживает условную функциональность. В коде ниже добавление условного атрибута в

AMethod()

Test

[conditional("TEST_TEST")]

public void AMethod() {

 string s = "I am available only when Test is defined";

}

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

java.policy

policytool

□ Код может требовать, чтобы вызывающая сторона имела специальные полномочия.

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

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

□ Определяются полномочия, которые представляют определенные права для доступа к различным системным ресурсам.

□ Администраторы могут выбирать политику системы безопасности, которая присваивает определенные полномочия определенным группам кода.

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

Обеспечение политики безопасности делает надежной среду управляемого кода .NET. Это объясняется тем, что каждая загружаемая сборка подчиняется политике безопасности, которая предоставляет полномочия для кода на основе доверия, где доверие базируется на признаках данного кода. Система безопасности .NET позволяет коду использовать защищенные ресурсы, только если он имеет на это "полномочие". Код запрашивает полномочия, которые ему требуются, а политика безопасности, применяемая .NET, определяет, какие полномочия будут реально предоставлены коду. Среда .NET предоставляет в C# классы полномочий доступа к коду, каждый из которых инкапсулирует возможность доступа к определенному ресурсу. Связанный с каждым полномочием класс является перечислением флагов полномочий, используемых для определения конкретного флага полномочий доступа к объекту. Эти полномочия используются для указания .NET, что надо разрешить коду делать и что должно быть разрешено вызывающей этот код стороне. Политика использует эти объекты также для определения, какие полномочия дать коду. Далее следует список стандартных полномочий:

□ 

EnvironmentPermission

□ 

FileIOPermission

□ 

ReflectionPermission

Reflection.Emit

□ 

RegistryPermission

□ 

SecurityPermission

□ 

UIPermission

□ 

FileDialogPermission

□ 

IsolatedStoragePermission

В C# существуют два способа изменения текущих полномочий безопасности с помощью использования: вызовов для классов полномочий в средах .NET или атрибутов полномочий безопасности.

Microsoft описывает C# как простой, современный, объектно-ориентированный и обеспечивающий безопасность типов язык программирования, производный из С и C++. Так как Java также является модернизацией C++, большая часть синтаксиса и встроенных свойств, представленных в C#, также доступны в Java.

C# использует среду .NET и поэтому предлагает встроенный, обеспечивающий безопасность типов, объектно-ориентированный код, взаимодействующий с любым языком, который поддерживает CTS (общую систему типов). Java может работать с С и C++, но без обеспечения безопасности типов. Более того, это достаточно сложно. В то же время C# предоставляет перезагрузку операторов, a Java этого не делает.

Имена файлов в C# не связаны с классами в них, как это предусмотрено в Java, а также имена пространств имен не связаны с папками, как имена пакетов в Java. C# вводит концепцию делегатов — указателей функций, которые могут использоваться для инкапсуляции метода с определенной сигнатурой. Также C# предлагает множество встроенных типов данных значений, включая обеспечивающие безопасность типов перечисления, структуры и встроенные примитивы, которые представляют достойную альтернативу примитивам Java.

В C# реализовано двунаправленное преобразование между ссылками и типами данных значений, называемое упаковкой и распаковкой. Эта функциональность не поддерживается в Java. C# поддерживает использование классов, укомплектованных полями, конструкторами и методами в качестве шаблонов для описания типов данных, и предоставляет возможность определить деструкторы — методы, вызываемые перед тем, как класс попадает к сборщику мусора. C# предоставляет также три подхода к параметрам методов —

in

out

ref

in

C# вводит также концепцию сокрытия методов, а также поддержку явного переопределения с помощью ключевых слов

virtual

override

getXXX()

setXXX()

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