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

ЛИЧНЫЙ КАБИНЕТ 

 

Здравствуйте гость!

 

Логин:

Пароль:

 

Запомнить

 

 

Забыли пароль? Регистрация

Повышение уникальности

Предлагаем нашим посетителям воспользоваться бесплатным программным обеспечением «StudentHelp», которое позволит вам всего за несколько минут, выполнить повышение уникальности любого файла в формате MS Word. После такого повышения уникальности, ваша работа легко пройдете проверку в системах антиплагиат вуз, antiplagiat.ru, etxt.ru или advego.ru. Программа «StudentHelp» работает по уникальной технологии и при повышении уникальности не вставляет в текст скрытых символов, и даже если препод скопирует текст в блокнот – не увидит ни каких отличий от текста в Word файле.

Результат поиска


Наименование:


реферат Платформа .Net Framework

Информация:

Тип работы: реферат. Добавлен: 24.05.2012. Сдан: 2011. Страниц: 11. Уникальность по antiplagiat.ru: < 30%

Описание (план):


ОГЛАВЛЕНИЕ
1 ПЛАТФОРМА .NET FRAMEWORK 2
2 ОБЩЕЯЗЫКОВАЯ ИСПОЛНЯЮЩАЯ  СРЕДА 2
2.1 Независимость от  платформы 3
2.2 Повышение производительности 3
2.3 Языковая способность  к взаимодействию 4
    2.3.1 Visual Basic 2008 4
    2.3.2 Visual C++ 2008 5
    2.3.3 COM и COM+ 6
3 ОСОБЕННОСТИ ПРОМЕЖУТОЧНОГО  ЯЗЫКА (IL) 6
3.1 Поддержка объектной  ориентации и интерфейсов 7
3.2 Различие типов  значений и типов  ссылок 9
3.3 Строгая типизация  данных 9
    3.3.1 Важность строгой  типизации данных  для межъязыкового  взаимодействия 10
    3.3.2 Общая система  типов 10
    3.3.3 Общая спецификация  языка 12
    3.3.4 Сборка мусора 13
    3.3.5 Безопасность 15
    3.3.6 Домены приложений 16
3.4 Обработка ошибок  с помощью исключений 19
3.5 Применение атрибутов 20
4 СБОРКИ 20
4.1 Приватные сборки 21
4.2 Разделяемые сборки 22
4.3 Рефлексия 23
5 КЛАССЫ .NET FRAMEWORK 24
6 ПРОСТРАНСТВА ИМЕН 25
ЗАКЛЮЧЕНИЕ. 26
СПИСОК  ЛИТЕРАТУРЫ 27 
 
 

       1 ПЛАТФОРМА .NET FRAMEWORK

 
       .NET Framework — программная платформа компании Microsoft, предназначенная для создания обычных программ и веб-приложений. 

       Microsoft, мировой лидер в области разработки ПО начала работать над созданием .NET Framework в конце 90-х. Тогда проект носил название Next Generation Windows Services (NGWS).  Бета версия .NET 1.0 была представлена публике в 2000 году, окончательный же релиз состоялся в 2002-м. Последующие поколения программного пакета .NET выходили в 2003-м (Visual Studio .NET 2003), 2005-м (Visual Studio 2005), 2006-м (в рамках адаптации Visual Studio 2005 к Windows Vista), и в 2007-м (релиз Visual Studio 2008). Последняя на момент написания этого текста версия .NET Framework 4.0 была выпущена 12 апреля 2010 г. вместе с окончательной версией Visual Studio 2010. 

       Ниже  рассмотрим основные черты платформы .NET Framework.

       2 ОБЩЕЯЗЫКОВАЯ ИСПОЛНЯЮЩАЯ  СРЕДА

 
       Центральной частью каркаса .NET является его общеязыковая исполняющая среда, известная как Common Language Runtime (CLR) или .NET runtime. Код, выполняемый под управлением CLR, часто называют управляемым кодом.
       Однако  перед тем как код сможет выполняться  CLR, любой исходный текст (на С# или другом языке) должен быть скомпилирован. Компиляция в .NET состоит из двух шагов.
       1.  Компиляция исходного кода в IL.
       2.  Компиляция IL в специфичный для платформы код с помощью CLR.
       Этот  двухшаговый процесс компиляции очень важен, потому что наличие IL (управляемого кода) — это ключ ко многим преимуществам .NET.
       Промежуточный язык Microsoft (MSIL) разделяет с байт-кодом Java идею низкоуровневого языка с простым синтаксисом (базирующегося на числовых кодах вместо текста), который может быть очень быстро транслирован в родной машинный код. Наличие этого кода с четко определенным универсальным синтаксисом дает ряд существенных преимуществ.

       2.1 Независимость от платформы

       Во-первых, это значит, что файл, содержащий инструкции байт-кода, может быть размещен на любой платформе; во время выполнения финальная стадия компиляции может  быть легко осуществлена, что позволит выполнить код на конкретной платформе. Другими словами, компилируя в IL, вы получаете платформенную независимость .NET — во многом так же, как компиляция в байт-код Java обеспечивает независимость от платформы программам на Java.
       Следует отметить, что независимость .NET от платформы в настоящее время лишь теоретическая, поскольку на данный момент полная реализация .NET доступна только для ОС Windows. Однако уже существуют частичные реализации для других платформ (например, проект Mono— попытка создать реализацию .NET с открытым кодом).

       2.2 Повышение производительности

       В сравнении IL с Java, все же IL на самом деле лучше, чем байт-код Java. IL всегда компилируется оперативно (Just-In-Time, известно также, как JIT-компиляция), в то время, как байт-код Java еще часто интерпретируется. Одним из недостатков Java было то, что во время выполнения программ процесс трансляции байт-кода Java в родной машинный код приводил к снижению производительности (за исключением самых последних версий, где Java компилируется JIT на некоторых платформах).
       Вместо  компиляции всего приложения за один проход (что может привести к задержкам при запуске), JIT-компилятор просто компилирует каждую порцию кода при ее вызове (just-in-time — оперативно). Если промежуточный код однажды скомпилирован, то результирующий машинный исполняемый код сохраняется до момента завершения работы приложения, поэтому его перекомпиляция при повторных вызовах не требуется. Microsoft аргументирует, что такой процесс более эффективен, чем компиляция всего приложения при запуске, поскольку высока вероятность того, что большие куски кода приложения на самом деле не будут выполняться при каждом запуске. При использовании JIT-компилятора такой код никогда не будет скомпилирован.
       Это объясняет, почему можно рассчитывать на то, что выполнение управляемого кода IL будет почти настолько же быстрым, как и выполнение родного машинного кода. Однако это не объясняет того, почему Microsoft ожидает повышения производительности. Причина состоит в том, что поскольку финальная стадия компиляции происходит во время выполнения, JIT-компилятор на этот момент уже знает, на каком типе процессора будет запущена программа. А это значит, что он может оптимизировать финальный исполняемый код, используя инструкции конкретного машинного кода, предназначенные для конкретного процессора.
       Традиционные  компиляторы оптимизируют код, но они  могут выполнить лишь оптимизацию, не зависящую от конкретного процессора, на котором код будет выполняться. Это происходит потому, что традиционные компиляторы генерируют исполняемые программы до того, как они поставляются пользователям. А потому компилятор не знает, на каком типе процессора они будут работать, за исключением самых общих характеристик вроде того, что это будет х86-совместимый процессор либо же процессор Alpha. Так, например, Visual Studio 6 оптимизирует код для обобщенной машины Pentium, поэтому сгенерированный код не может использовать аппаратные преимущества процессора Pentium III. Однако JIT-компилятор может выполнять всю оптимизацию, которую реализует Visual Studio 6, и вдобавок может оптимизировать код под конкретный процессор, на котором он будет работать.

       2.3 Языковая способность к взаимодействию

       Применение  IL не только обеспечивает независимость от платформы; оно также обеспечивает способность к взаимодействию. Другими словами, можно скомпилировать программу на одном языке в код IL, и этот скомпилированный код сможет свободно взаимодействовать с IL-кодом, скомпилированным из другого языка.
       Так же очень полезным является и то, что с .NET совместимы и другие языки помимо С#. Ниже кратко описано, как некоторые языки общего назначения стыкуются с .NET.

       2.3.1 Visual Basic 2008

       Visual Basic .NET 2002 подвергся полной переделке по сравнению с Visual Basic 6 для синхронизации его с первой версией среды .NET Framework. Сам язык Visual Basic серьезно эволюционировал по сравнению с VB6, и это значит, что VB6 — неподходящий язык для разработки программ .NET. Например, VB6 в значительной степени интегрирован с моделью компонентных объектов (Component Object Model — COM) и работает, предоставляя в распоряжение разработчика только исходный код обработчиков событий — большая часть лежащего в основе кода недоступна в виде исходных текстов. Помимо этого существуют и другие ограничения. Так, VB6 не поддерживает реализацию наследования, а стандартные типы Visual Basic 6 не совместимы с .NET.
       Visual Basic 6 был обновлен до Visual Basic .NET в 2002 г., и изменения в языке были настолько значительны, что Visual Basic теперь можно рассматривать как совершенно новый язык. Существующий код Visual Basic 6 не компилируется в современный код Visual Basic 2008 (или в Visual Basic .NET 2002, 2003 и 2005 - по той же причине). Преобразование программ Visual Basic 6 в Visual Basic 2008 требует серьезных изменений исходного кода. Однако Visual Studio 2008 (обновленная среда разработки Visual Studio для использования с .NET) может выполнить большую часть этой работы. Если вы попытаетесь загрузить проект Visual Basic 6 в среду Visual Studio 2008, она самостоятельно обновит проект. Это значит, что она перепишет исходный код Visual Basic 6 на Visual Basic 2008. Хотя это избавляет от рутинной работы, все же после такого преобразования придется проверить новый код Visual Basic 2008 на работоспособность, поскольку преобразование может оказаться далеким от идеала.
       Один  побочный эффект такого преобразования языка состоит в том, что теперь уже нельзя скомпилировать исходные текст Visual Basic 2008 в родной машинный код. Теперь Visual Basic 2008 компилирует только в код IL, как это делает и С#. Если вам нужно продолжать кодировать на Visual Basic 6, вы можете это делать, но полученный  исполняемый код будет полностью игнорировать .NET Framework и вам придется держать на машине инсталлированным Visual Basic 6, если вы хотите продолжать разработку в этой среде.

       2.3.2 Visual C++ 2008

       Visual C++ 6 уже имел множество специфичных для Microsoft расширений Windows. С появлением Visual C++ .NET были добавлены новые расширения, обеспечивающие поддержку среды .NET. Это значит, что существующий исходный код C++ будет по-прежнему компилироваться в родной машинный код безо всяких модификаций. Однако это значит также, что он будет работать независимо от среды выполнения .NET. Если вы хотите, чтобы ваши программы C++ запускались внутри среды .NET, вы можете поместить в начало исходного кода следующую строку:
       #using <mscorlib.dll>
       Вы  также можете передать флаг /clr компилятору, который предположит, что вы хотите компилировать в управляемый код, и потому сгенерирует IL вместо родного машинного кода. Интересно, что во время компиляции C++ в управляемый код, компилятор может сгенерировать IL, включающий в себя исполняемый машинный код. Это означает, что в есть возможность коде на C++ смешивать управляемые (managed) типы с неуправляемыми (unmanaged). To есть управляемый код C++
           class MyClass
           {
       объявляет простой класс C++, в то время как  код
           ref class MyClass
           {
       приведет  к появлению управляемого класса, как если бы он был написан на С# или Visual Basic 2008. Преимущество применения управляемого кода C++ перед С# состоит в том, что можно вызывать неуправляемые классы C++ из управляемого кода C++ без необходимости обращаться к средствам взаимодействия СОМ.
       Компилятор  выдает ошибку при попытке использования  средств, которые не поддерживаются .NET или управляемыми типами (например, шаблонов или множественного наследования классов). Кроме того, вы столкнетесь с необходимостью применения нестандартных средств C++ при работе с управляемыми классами.
       Из-за свободы, которую представляет C++ в  отношении низкоуровневых манипуляций с указателями и тому подобного, компилятор C++ не может генерировать код, который успешно пройдет тесты CLR на безопасность типов. Если для вас важно, чтобы код распознавался CLR как безопасный в отношении типов, при написании вашего исходного кода вам лучше отдать предпочтение какому-то другому языку (такому как С# или Visual Basic 2008).

       2.3.3 COM и COM+

       С технической точки зрения СОМ  и СОМ+ не являются технологиями, нацеленными на .NET, поскольку компоненты, основанные на них, не могут компилироваться в IL (хотя в определенной степени это и можно сделать, применяя управляемый C++, если исходный компонент СОМ+ был написан на C++). Однако СОМ+ остается важным инструментом, потому что его средства не дублируют .NET. К тому же компоненты СОМ будут по-прежнему работать, и .NET включает средства взаимодействия с СОМ, позволяющие управляемому коду вызывать компоненты СОМ и наоборот (это обсуждается в главе 24). Однако в большинстве случаев удобнее кодировать новые компоненты как компоненты .NET, чтобы воспользоваться преимуществами базовых классов .NET, а также другими выгодами от запуска управляемого кода.

       3 ОСОБЕННОСТИ ПРОМЕЖУТОЧНОГО  ЯЗЫКА (IL)

 
       Как становится понятным из предыдущего раздела, промежуточный язык Microsoft очевидно играет фундаментальную роль в среде .NET. Теперь совершенно ясно, что перед тем, как запуститься на выполнение, код С# компилируется в IL (на самом деле компилятор С# компилирует только в управляемый код). Теперь имеет смысл внимательнее рассмотреть основные характеристики IL, поскольку логично, что любой язык, предназначенный для .NET, также должен поддерживать эти основные характеристики IL.
       Важнейшие свойства IL могут быть сформулированы следующим образом:
      объектная ориентация и применение интерфейсов;
      строгое различие между типами значений и типами ссылок;
      строгая типизация данных;
      обработка ошибок через использование исключений;
      использование атрибутов.

       3.1 Поддержка объектной ориентации и интерфейсов

       Независимость .NET от языка имеет некоторые практические ограничения. IL неизбежно должен воплощать некоторую определенную методологию программирования, а это означает, что исходный язык также должен быть совместим с этой методологией. Принципы, которым руководствовалась Microsoft при создании IL: классическое объектно-ориентированное программирование с реализацией одиночного наследования классов.
       В дополнение к классической объектной  ориентации IL также вводит понятие интерфейсов, которые впервые были реализованы под Windows с СОМ. Интерфейсы, построенные с использованием .NET — это не то же самое, что интерфейсы СОМ; им не требуется поддержка со стороны инфраструктуры СОМ {так, например, они не наследуются от IUnknown и не имеют ассоциированных глобальных идентификаторов GUID). Однако они разделяют с интерфейсами СОМ идею предоставления контракта, и классы, реализующие заданный интерфейс, должны предлагать реализацию методов и свойств, специфицированных этим интерфейсом.
       Так как работа с .NET означает компиляцию в IL, а это, в свою очередь, значит, что нужно придерживаться объектно-ориентированной методологии. Однако только этого недостаточно, чтобы обеспечить межъязыковое взаимодействие. В конце концов, C++ и Java также используют объектно-ориентированную парадигму, но их нельзя назвать способными к взаимодействию. Нам нужно рассмотреть более подробно концепцию языкового взаимодействия.
       Для начала разберемся, что вообще подразумевается  под языковым взаимодействием. В конце концов, уже СОМ позволял писать компоненты на разных языках, обеспечивая их совместную работу, — в том смысле, что они могли вызывать методы друг друга. Однако СОМ, будучи бинарным стандартом, не позволял компонентам создавать экземпляры других компоненты и вызывать их методы и свойства, не заботясь о языке, на котором компоненты были написаны. Чтобы обеспечить такую возможность, каждый объект должен был быть создан через исполняющую систему СОМ и доступен через интерфейс. В зависимости от моделей потоков зависимых компонентов, они могли приводить к существенным потерям производительности, связанным с передачей данных между выполняющимися компонентами в разных потоках. В крайнем случае, когда компоненты размещались в исполняемых файлах, а не в DLL, приходилось запускать отдельные процессы, чтобы выполнить их. Постоянно подчеркивалось, что компоненты могут общаться друг с другом, но только через исполняющую среду СОМ. В СОМ не было способа организовать прямое взаимодействие компонентов, написанных на разных языках, или создавать экземпляры друг друга — все это делалось только при посредничестве СОМ. Мало того, архитектура СОМ не позволяла реализовать наследование, тем самым сводя на нет все преимущества объектно-ориентированного программирования.
       Еще одна связанная с этим проблема заключалась  в том, что отлаживать компоненты, написанные на разных языках, приходилось независимо друг от друга. Невозможно было в отладчике переходить от одного языка к другому. Поэтому в действительности под способностью языкового взаимодействия мы подразумеваем возможность для классов, написанных на одном языке, напрямую обращаться к классам, написанным на другом языке. В частности:
      класс, написанный на одном языке, может быть унаследован от класса, реализованного на другом языке;
      класс может содержать экземпляр другого класса, независимо от того, на каких языках написан каждый из них;
      объект может напрямую вызывать методы другого объекта, написанного на другом языке;
      объекты (или ссылки на объекты) могут передаваться между методами.
      при вызове методов между языками можно шагать в отладчике по вызовам, даже если это означает необходимость перемещения между фрагментами исходного кода, написанными на разных языках.
       Все это достаточно амбициозные цели, но как ни удивительно, благодаря .NET и IL, они были достигнуты. В случае перемещения между методами в отладчике эта возможность обеспечивается интегрированной средой разработки (IDE) Visual Studio .NET, а не самой CLR.

       3.2 Различие типов значений и типов ссылок

       Как и любой язык программирования, IL представляет множество предопределенных примитивных типов данных. Одна из особенностей IL, заключается в том, что он делает четкое различие значениями и ссылочными типами. Типы значений — это те, переменные которых непосредственно хранят их данные, в то время как ссылочные типы— это те, переменные которых просто хранят адрес, по которому соответствующие данные могут быть найдены.
       В терминах C++ ссылочные типы можно  рассматривать, как будто они  обращаются к переменным через указатель, в то время как для Visual Basic лучшая аналогия для ссылочных типов — это объекты, обращение к которым в Visual Basic 6 всегда осуществляется по ссылке. IL также устанавливает свою спецификацию относительно хранения данных: экземпляры ссылочных типов всегда хранятся в области памяти, известной как управляемая куча (managed heap), в то время как типы значений обычно хранятся в стеке (хотя, если типы значений объявлены как поля внутри ссылочных типов, то они также будут сохранены в куче). В главе 2 рассказывается о стеке, куче и о том, как они работают.

       3.3 Строгая типизация данных

       Один  из наиболее важных аспектов IL состоит в том, что он основан на исключительно строгой типизации данных. Это значит, что все переменные имеют четко определенный конкретный тип данных (так, например, в IL нет места для типа данных Variant, который существует в Visual Basic и сценарных языках). В частности, IL обычно не допускает никаких действий, которые дают в результате неопределенные типы данных.
       Например, разработчики Visual Basic 6 могут позволить себе передавать переменные, не особенно заботясь об их типах, поскольку Visual Basic автоматически выполняет необходимые преобразования. Разработчики C++ привыкли к приведению указателей к различным типам. Возможность выполнения таких действий полезна для производительности, но при этом нарушаются принципы безопасности типов. Поэтому такие действия допустимы лишь при некоторых обстоятельствах в некоторых языках, компилируемых в управляемый код. В самом деле, указатели (в отличие от ссылок) разрешены только в помеченных блоках кода С# и вовсе не допускаются в Visual Basic (хотя и разрешены в управляемом C++). Применение указателей в вашем коде приводит к тому, что проверки типов в памяти, выполняемые CLR, завершаются неудачей.
       Стоит отметить, что некоторые языки, совместимые  с .NET, такие как Visual Basic 2008, все еще допускают некоторую небрежность типизации, но это возможно лишь потому, что компиляторы, находящиеся "за кулисами", гарантируют безопасность типов в сгенерированном коде IL.
       Хотя  обеспечение безопасности типов  может поначалу принести ущерб производительности, все же во многих случаях преимущества, полученные от служб, предоставляемых .NET, которые полагаются на безопасность типов, намного превышают потери от некоторого снижения производительности. Эти службы включают следующие аспекты:
      способность межъязыкового взаимодействия;
      сборка мусора;
      безопасность;
      домены приложений.

       3.3.1 Важность строгой типизации данных для межъязыкового взаимодействия

       Если  некоторый класс унаследован  от другого либо содержит в себе экземпляры других классов, то он должен знать обо всех типах данных, используемых другими классами. Вот почему строгая типизация данных так важна. Действительно, недостаток информации в любой согласованной системе в прошлом всегда являлся настоящим барьером для наследования и взаимодействия между разными языками. Информация подобного рода попросту отсутствует в стандартном исполняемом файле или библиотеке DLL.
       Предположим, что один из методов класса Visual Basic 2008 определен как возвращающий тип Integer— один из стандартных типов, доступных в Visual Basic 2008. С# просто не имеет типа данных с таким именем. Ясно, что вы сможете наследовать от этого класса, вызывать этот метод и использовать возвращаемый тип из кода С# только в том случае, если компилятор будет знать, как отобразить тип Integer языка Visual Basic 2008 на некоторый тип, определенный в С#.

       3.3.2 Общая система типов

       Эта проблема с типами данных решается в .NET за счет применения общей системы типов (Common Type System — CTS). CTS описывает предопределенные типы данных, которые доступны в IL, поэтому все языки, ориентированные на среду .NET, генерируют компилированный код, который в конечном итоге базируется на этих типах.
       Что касается предыдущего примера, то Integer из Visual Basic 2008 — это на самом деле 32-битное целое со знаком, которое отображается непосредственно на тип, известный в IL как Int32. Потому это и будет тот тип, который специфицирован в коде IL. Поскольку компилятор С# знает об этом типе, здесь проблем нет. На уровне исходного кода С# ссылается на Int32 по ключевому слову int, поэтому компилятор просто будет трактовать этот метод Visual Basic 2008 так, как будто он возвращает int.
       CTS описывает не просто примитивные типы данных, а целую богатую иерархию типов, включающую хорошо определенные точки, в которых код может определять свои собственные типы. Иерархическая структура общей системы типов (CTS) отражает объектно-ориентированную методологию одиночного наследования IL и показана на рис. 1.1.
       В табл. 1.1 представлено описание типов, показанных на рис. 1.1. 


Рис. 1.1 Общая система типов (CTS) 

       Таблица 1.1. Описание типов, показанных на рис. 1.1
       Тип        Значение
       Тип        Базовый класс, представляющий тип.
       Типы значений        Базовый класс, представляющий любой тип  значений.
       Ссылочные типы        Любые типы, которые доступны по ссылке и  хранятся в куче.
       Тип        Значение
       Встроенные типы значений        Включают  большинство стандартных примитивных  типов, представляющих числа, булевские  значения или символы.
       Перечисления        Наборы  перечислимых значений.
       Пользовательские  типы значений        Типы, которые определены в исходном коде и сохраняются как типы значений. В терминологии С# это означает любые структуры.
       Интерфейсные типы        Интерфейсы.
       Типы указателей        Указатели.
       Самодокументированные типы        Типы  данных, которые представляют информацию о себе, полезную для сборщика мусора.
       Массивы        Любой тип, содержащий массив объектов.
       Типы классов                Самодокументированные типы, но не массивы.
       Делегаты        Типы, предназначенные для хранения ссылок на методы.
       Пользовательские  ссылочные типы        Типы, определенные в исходном коде и сохраняемые  как ссылочные. В терминологии С# это любые классы.
       Упакованные типы значений        Типы  значений, временно помещенные в ссылки, благодаря чему могут сохраняться  в куче.
 
 
       В С# каждый предопределенный тип, распознанный компилятором, отображается на один встроенный тип IL. То же справедливо и в отношении Visual Basic 2008.

       3.3.3 Общая спецификация языка

       Общая спецификация языка (CLS) работает вместе с CTS для обеспечения языкового взаимодействия. CLS — это набор минимальных стандартов, которых должны придерживаться все компиляторы, ориентированные на .NET. Поскольку IL— очень богатый язык, разработчики большинства компиляторов предпочитают ограничивать возможности конкретного компилятора поддержкой только подмножества средств IL и CTS. Это нормально до тех пор, пока компилятор поддерживает все, что определено в CTS.
       Вполне  допустимо писать код, не совместимый  с CLS. Однако в этом случае не гарантируется, что скомпилированный IL-код будет полностью способным к взаимодействию.
       Например, возьмем чувствительность к регистру. IL чувствителен к регистру символов. Разработчики, которые пишут на языках, чувствительных к регистру, широко используют гибкость, которую обеспечивает эта зависимость от регистра при выборе имен переменных. Однако Visual Basic 2008 не чувствителен к регистру символов. CLS обходит эту проблему указывая, что любой CLS-совместимый код не должен включать  никаких пар имен, отличающихся только регистром. Таким образом, код Visual Basic 2008 может работать с CLS-совместимым кодом.
и т.д.................


Перейти к полному тексту работы


Скачать работу с онлайн повышением уникальности до 90% по antiplagiat.ru, etxt.ru или advego.ru


Смотреть полный текст работы бесплатно


Смотреть похожие работы


* Примечание. Уникальность работы указана на дату публикации, текущее значение может отличаться от указанного.