Почему C # включает программные конструкции, несовместимые с CLS?

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

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

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

Можете добавить:

[assembly: CLSCompliant(true)]

если хотите, и компилятор сообщит вам, когда вы ошиблись.

И наконец: большая часть кода (по объему) не используется как компонент. Он написан для выполнения определенной работы и, возможно, используется другим внутренним кодом. В основном разработчики / поставщики библиотек должны беспокоиться о таких вещах, как соответствие CLS. Это (по количеству) меньшинство.

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

Вы должны убедиться, что общедоступные видимые типы в вашей сборке соответствуют требованиям CLS. Очень просто сделать так, чтобы члены класса не различались только регистром. Позвольте компилятору помочь вам, используя атрибут [assembly: CLSCompliant (true)], и компилятор предупредит вас, когда вы поскользнетесь.

См. http://msdn.microsoft.com/en-us/library/bhc3fa7f.aspx.

CLS - это спецификация, которую каждый выбирает. Цитата сверху:

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

Некоторые CLS-совместимые языковые компиляторы, такие как компиляторы C # или Visual Basic, позволяют указать, что вы хотите, чтобы ваш код был CLS-совместимым. Эти компиляторы могут проверять соответствие CLS и сообщать вам, когда в вашем коде используются функции, не поддерживаемые CLS. Компиляторы C # и Visual Basic позволяют пометить элемент программы как CLS-совместимый, что приведет к генерации компилятором ошибки времени компиляции, если код несовместим с CLS. Например, следующий код генерирует предупреждение компилятора.

Пример кода по ссылке выше:

using System;

// Assembly marked as compliant.
[assembly: CLSCompliant(true)]

// Class marked as compliant.
[CLSCompliant(true)]
public class MyCompliantClass {
   // ChangeValue exposes UInt32, which is not in CLS.
   // A compile-time warning results.
   public void ChangeValue(UInt32 value){ }

   public static void Main( ) {
   int i = 2;
   Console.WriteLine(i);
   }
}

Этот код генерирует следующее предупреждение C #:

Предупреждение копирования CS3001: тип аргумента uint несовместим с CLS

Мои два цента о соответствии требованиям CLS

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

VB.Net - это язык, унаследованный от более раннего языка VB6. Предполагается, что он очень похож по стилю на VB6 и, как таковой, принимает многие соглашения, используемые VB6. Поскольку предполагалось, что VB6 будет легко изучить / использовать не разработчиками, он имеет определенные характеристики, которые делают его более надежным для идиотов. Динамическая типизация, нечувствительность к регистру - две из этих вещей.

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

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

Например, возьмите код VB.Net, вызывающий код C #. Если бы код C # имел две функции, которые различались только регистром, X () vs x (), VB.net никогда не смог бы правильно вызвать этот код, поскольку он нечувствителен к регистру. Соответствие CLS должно сделать это незаконным. Если вы посмотрите на другие правила, они в основном делают то же самое для других языковых функций между разными языками.

Я предполагаю, что нечувствительность к регистру была включена только в соответствие CLS, чтобы VB.NET мог быть совместимым с CLS. Насколько я понимаю, проблем не возникает, если конкретная языковая конструкция несовместима с CLS, если только вы не используете ее таким образом, что несовместимые элементы доступны в общедоступном API вашего кода.

Намек от Microsoft, казалось бы, заключается в том, что соответствие CLS важно только в коде, к которому вы получаете доступ с разных языков (например, ссылка на сборку C # из проекта VB.NET).

Я думаю, что Microsoft хотела дать разработчикам свободу. Без ограничений, если в этом нет необходимости. C # не ограничивается CLS, потому что не всем нужна совместимость с VB.

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

1. It says that certain features are so important that any language which does not include them should be considered inadequate for general-purpose .net programming.
2. It says that programmers whose libraries don't require any features other than those listed should expect that their libraries will be usable by programmers using any language that is suitable for general-purpose .net programming.
3. It informs programmers that if parts of their libraries would require the use of features which languages are not required to support, those parts might not be usable in languages which are suitable for .net programming, but don't include the required features.

Когда такие языки, как vb.net или C #, позволяют создавать программирование, не совместимое с CLS, это означает, что Microsoft решила, что определенные функции были достаточно полезны, чтобы оправдать включение в эти языки, но не настолько замечательны или бесспорны, чтобы оправдывать обязательное использование всех языков. включить их.