Почему С# статически типизирован?

Ответ 1

Как говорили другие, С# является статическим/сильно типизированным. Но я больше задаю ваш вопрос: "Почему вы хотите, чтобы С# был статическим/сильно типизированным? Какие преимущества у этого есть для динамических языков?"

Имея это в виду, есть много веских причин:

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

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

  Вероятно, поэтому, например, в руководствах по стилю Microsoft рекомендуется, чтобы программисты VB6 помещали префикс типа с именами переменных, но программисты VB.Net этого не делают.

• Производительность. Это самая слабая причина, но поздняя привязка/утка может быть медленнее. В конце концов, переменная относится к памяти, которая структурирована определенным образом. Без сильных типов программа должна будет выполнять дополнительную проверку типа или преобразование за кулисами во время выполнения, поскольку вы используете память, которая структурирована в физическом смысле так, как если бы она была структурирована по-другому логически.

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

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

• Улучшенные инструменты для разработчиков. Если ваша IDE знает, какой тип переменной ожидается, она может дать вам дополнительную информацию о том, какие вещи могут выполнять переменные. Это намного сложнее для IDE, если он должен вывести тип для вас. И если вы получите больше помощи с minutia API от IDE, то вы, как разработчик, сможете получить голову вокруг более крупного и богатого API и быстрее добраться туда.

Или, может быть, вам просто интересно, почему вам нужно дважды указывать имя класса для одной и той же переменной в одной строке? Ответ двоякий:

• Часто вы этого не делаете. В С# 3.0 и более поздних версиях вы можете использовать ключевое слово var вместо имени типа во многих случаях. Переменные, созданные таким образом, все еще статически типизированы, но тип теперь выведен для вас компилятором.
• Благодаря наследованию и интерфейсам иногда тип с левой стороны не соответствует типу с правой стороны.

Ответ 2

Это просто, как был разработан язык. С# является языком C-стиля и следует по шаблону, имеющему типы слева.

В С# 3.0 и выше вы можете обойти это во многих случаях с помощью вывода локального типа.

var variable = new SomeClass();

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

EDIT

Прочитайте это в контексте исходного вопроса пользователей

зачем нам [имя класса] перед именем переменной?

Я хотел прокомментировать несколько других ответов в этой теме. Многие люди дают "С# статически тип" в качестве ответа. Хотя утверждение верно (С# статически типизирован), он почти полностью не связан с вопросом. Статическая типизация не требует, чтобы имя типа находилось слева от имени переменной. Конечно, это может помочь, но это выбор дизайнера языка, который не является необходимой особенностью статических типизированных языков.

Это легко доказывать, рассматривая другие статически типизированные языки, такие как F #. Типы в F # отображаются справа от имени переменной и очень часто могут быть полностью опущены. Также есть несколько примеров для сравнения. Например, PowerShell чрезвычайно динамичен и ставит все его типы, если они включены, слева.

Ответ 3

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

Например, заданы следующие типы:

class Foo { }
class Bar : Foo { }
interface IBaz { }
class Baz : IBaz { }

С# позволяет это сделать:

Foo f = new Bar();
IBaz b = new Baz();

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

Редактировать. В качестве точки порядка - в то время как С# строго типизировано, важное различие (насколько это касается обсуждения) состоит в том, что он на самом деле также является статически типизированным языком. Другими словами, компилятор С# проверяет статический тип во время компиляции.

Ответ 4

С# является статически типизированным, strongly-typed язык C или С++. В этих языках все переменные должны быть объявлены определенного типа.

Ответ 5

В конечном счете, потому что Андерс Хейлсберг так сказал...

Ответ 6

Вам нужно [имя класса] впереди, потому что существует много ситуаций, в которых первое [имя класса] отличается от второго, например:

 IMyCoolInterface obj = new MyInterfaceImplementer();
 MyBaseType obj2 = new MySubTypeOfBaseType();

и т.д.. Вы также можете использовать слово "var", если вы не хотите явно указывать тип.

Ответ 7

Почему нам нужно знать тип данных до экземпляра класса?

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

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

 void FunctionCalledVeryUnfrequently()
 {
   ClassA a = new ClassA();
   ClassB b = new ClassB();
   ClassA a2 = new ClassB(); //COMPILER ERROR(thank god)

   //100 lines of code

   DoStuffWithA(a);
   DoStuffWithA(b);      //COMPILER ERROR(thank god)
   DoStuffWithA(a2);
 }

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

   string s = "abc";
   string s2 = new string(new char[]{'a', 'b', 'c'});
   //Does exactly the same thing

   DoStuffWithAString("abc");
   DoStuffWithAString(new string(new char[]{'a', 'b', 'c'}));
   //Does exactly the same thing

Ответ 8

С#, как указывали другие, - это сильно, статически типизированный язык.

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

Наконец, и довольно красиво, С# (и многие другие языки) не имеет такого же смешного, "конвертировать что-либо во что угодно, даже если это не имеет смысла", что делает PHP, что совершенно откровенно может вас тронуть больше, чем помогает.

Ответ 9

Поскольку С# - строго типизированный язык

Ответ 10

С# - строго типизированный язык, например С++ или java. Поэтому он должен знать тип переменной. вы можете выманить его немного в С# 3.0 с помощью ключевого слова var. Это позволяет компилятору выводить тип.

Ответ 11

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

Ответ 12

Когда мы определяем переменные для хранения данных, мы должны указать тип данных, которые будут удерживать эти переменные. Затем компилятор проверяет, что то, что мы делаем с данными, имеет смысл, т.е. Следует правилам. Мы не можем, например, хранить текст в числе - компилятор не разрешит его.

int a = "fred"; // Not allowed. Cannot implicitly convert 'string' to 'int' 

Переменная a имеет тип int и присваивает ей значение "fred", которое является текстовой строкой, нарушает правила - компилятор не может выполнить любое преобразование этой строки.

Ответ 13

В С# 3.0 вы можете использовать ключевое слово 'var' - это использует вывод типа статического типа, чтобы определить, какой тип переменной находится во время компиляции

var foo = new ClassName();

переменная 'foo' будет иметь тип "ClassName" с этого момента.

Ответ 14

Одна вещь, о которой не упоминалось, это то, что С# является языком, совместимым с CLS (Common Language Specification). Это набор правил, которым должен придерживаться язык .NET, чтобы он мог взаимодействовать с другими языками .NET.

Так что действительно С# просто придерживается этих правил. Чтобы процитировать эту статью MSDN:

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

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

Частью CLS является CTS система Common Type.

Если для этого недостаточно аббревиатур, тогда в .NET есть еще тонна, такая как CLI, ILasm/MSIL, CLR, BCL, FCL,

Ответ 15

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

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

Я не заметил, было ли это упомянуто или нет, но С# 4.0 представляет динамическую проверку VIA ключевое слово dynamic. Хотя я уверен, что вы захотите избежать этого, когда это не понадобится.

Ответ 16

Почему С# требует, чтобы я указывал тип данных при создании переменной.

Почему нам нужно знать тип данных перед экземпляром класса?

Я думаю, что одна вещь, на которую не ссылались большинство ответов, - это тот факт, что С# был изначально обозначен и спроектирован как "управляемый", "безопасный" язык между прочим, и многие из этих целей прибыл с помощью проверки статичности/времени компиляции. Знание переменной типа данных явно делает эту проблему намного проще. Это означает, что можно сделать несколько автоматических оценок (компилятор С#, а не JIT) о возможных ошибках/нежелательном поведении без возможности выполнения.

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

Ответ 17

Статично типизированный означает, что компилятор может выполнять какие-то проверки во время компиляции не во время выполнения. Каждая переменная имеет особый или сильный тип в статическом типе. С# строго определенно строго типизирован.