Различие между кастингом в C# и VB.NET
Несомненно, Вы можете" diff file1.txt file2.txt", но поддержки Bash замена процесса , который позволяет Вам diff вывод команд.
, Например, скажем, я хочу удостовериться, что мой сценарий дает мне вывод, который я ожидаю. Я могу просто обернуть свой сценарий в < () и канал это к diff для получения быстрого и грязного модульного теста:
$ cat myscript.sh
#!/bin/sh
echo -e "one\nthree"
$
$ ./myscript.sh
one
three
$
$ cat expected_output.txt
one
two
three
$
$ diff <(./myscript.sh) expected_output.txt
1a2
> two
$
Как другой пример, скажем, я хочу проверить, имеют ли два сервера тот же список установленного RPMs. Вместо sshing к каждому серверу, написав каждый список RPMs для разделения файлов, и делая diff на тех файлах я могу просто сделать diff от моей рабочей станции:
$ diff <(ssh server1 'rpm -qa | sort') <(ssh server2 'rpm -qa | sort')
241c240
< kernel-2.6.18-92.1.6.el5
---
> kernel-2.6.18-92.el5
317d315
< libsmi-0.4.5-2.el5
727,728d724
< wireshark-0.99.7-1.el5
< wireshark-gnome-0.99.7-1.el5
$
существует больше примеров в Усовершенствованном Руководстве по созданию сценариев Bash в http://tldp.org/LDP/abs/html/process-sub.html .
5 ответов
Из MSDN :
Чтобы арифметические операции, приведение типов или преобразование вызывали исключение OverflowException, операция должна выполняться в проверенном контексте. По умолчанию в Visual Basic проверяются арифметические операции и переполнения; в C # - нет. Если операция происходит в неконтролируемом контексте, результат обрезается путем отбрасывания всех старших битов, которые не соответствуют типу назначения.
EDIT: Если вы собираетесь переносить код с C # на VB.NET, вас могут заинтересовать различия между ними . Также сравните и явно установите настройки компилятора , чтобы они были такими же, как настройки по умолчанию в C # (при необходимости).
?CType(b, Int16)
Constant expression not representable in type 'Short'.
?b
65535
?directcast(b, Int16)
Value of type 'Integer' cannot be converted to 'Short'.
?int16.TryParse(b.ToString(), c)
False
Вы пробовали использовать DirectCast (b, Int16) ? CType - это не то же самое, что преобразование C #.
Вот статья , в которой сравнивается производительность DirectCast и CType , а также более подробно рассматривается, когда либо следует использовать.
Прежде всего: я понимаю, что CType (b, Int16) не то же самое, что (Int16) b. Один - это преобразование типа (CType), а другой - приведение. (Int16) b приравнивается к DirectCast (b, Int16), а не к CType (b, Int16).
Разница между ними (как отмечено в MSDN) заключается в том, что CType работает успешно, пока существует допустимое преобразование, однако DirectCast требует, чтобы тип объекта во время выполнения был одинаковым, и поэтому все, что вы делаете, - это сообщаете компилятору во время разработки, что этот объект относится к этому типу, вместо того, чтобы сообщать ему о преобразовании в этот тип.
См .: http://msdn.microsoft.com/en-us/library/7k6y2h6x (VS.71) .aspx
Однако основная проблема заключается в том, что вы пытаетесь преобразовать 32-битное целое число в 16-битное целое число, которое ... [Я пропустил нужное слово, возможно, кто-нибудь сможет вставить его здесь для меня] с потерями. Преобразование из 16-битного в 32-битное разрешено, поскольку оно выполняется без потерь, преобразование из 32-битного в 16-битное значение не определено. Чтобы узнать, почему это работает на C #, вы можете увидеть ответ @ Roman - он связан с тем фактом, что C # не проверяет переполнение.
Полученное значение & H7FFFFFFF And & HFFFF приводит к UInt16.MaxValue (65535) UInt16 работает от 0 до 65535, вы пытаетесь втиснуть это в Int16, который работает от -32768 до 32767, что, как вы видите, не сработает. Также случайным является то, что это значение может уместиться в UInt16, добавление двух 32-битных целых чисел и попытка втиснуть их в 16-битное целое (короткое) часто вызывает переполнение, и поэтому я бы сказал, что это опасная по своей сути операция.
Полученное значение & H7FFFFFFF And & HFFFF приводит к UInt16.MaxValue (65535) UInt16 работает от 0 до 65535, вы пытаетесь втиснуть это в Int16, который работает от -32768 до 32767, что, как вы видите, не сработает. Также случайным является то, что это значение может уместиться в UInt16, добавление двух 32-битных целых чисел и попытка втиснуть их в 16-битное целое (короткое) часто вызывает переполнение, и поэтому я бы сказал, что это опасная по своей сути операция.
Полученное значение & H7FFFFFFF And & HFFFF приводит к UInt16.MaxValue (65535) UInt16 работает от 0 до 65535, вы пытаетесь втиснуть это в Int16, который работает от -32768 до 32767, что, как вы видите, не сработает. Также случайным является тот факт, что это значение может уместиться в UInt16, добавление двух 32-битных целых чисел и попытка втиснуть их в 16-битное целое число (короткое) часто вызывает переполнение, и поэтому я бы сказал, что это опасная по своей сути операция.
Полученное значение & H7FFFFFFF And & HFFFF приводит к UInt16.MaxValue (65535) UInt16 работает от 0 до 65535, вы пытаетесь втиснуть это в Int16, который работает от -32768 до 32767, что, как вы видите, не сработает. Также случайным является то, что это значение может уместиться в UInt16, добавление двух 32-битных целых чисел и попытка втиснуть их в 16-битное целое (короткое) часто вызывает переполнение, и поэтому я бы сказал, что это опасная по своей сути операция.
Полученное значение & H7FFFFFFF And & HFFFF приводит к UInt16.MaxValue (65535) UInt16 работает от 0 до 65535, вы пытаетесь втиснуть это в Int16, который работает от -32768 до 32767, что, как вы видите, не сработает. Также случайным является то, что это значение может уместиться в UInt16, добавление двух 32-битных целых чисел и попытка втиснуть их в 16-битное целое (короткое) часто вызывает переполнение, и поэтому я бы сказал, что это опасная по своей сути операция.
Результирующее значение & H7FFFFFFF And & HFFFF приводит к UInt16.MaxValue (65535) UInt16 работает от 0 до 65535, вы пытаетесь втиснуть это в Int16, который работает от -32768 до 32767, что как как видите, не сработает. Также случайным является то, что это значение может уместиться в UInt16, добавление двух 32-битных целых чисел и попытка втиснуть их в 16-битное целое (короткое) часто вызывает переполнение, и поэтому я бы сказал, что это опасная по своей сути операция.
Результирующее значение & H7FFFFFFF And & HFFFF приводит к UInt16.MaxValue (65535) UInt16 работает от 0 до 65535, вы пытаетесь втиснуть это в Int16, который работает от -32768 до 32767, что, как как видите, не сработает. Также случайным является то, что это значение может уместиться в UInt16, добавление двух 32-битных целых чисел и попытка втиснуть их в 16-битное целое (короткое) часто вызывает переполнение, и поэтому я бы сказал, что это опасная по своей сути операция.
Вы можете усечь этот тип переполнения с помощью структуры.
<StructLayout(LayoutKind.Explicit)> _
Public Structure int3216
<FieldOffset(0)> Public i32 As Int32
<FieldOffset(0)> Public i16high As Int16
<FieldOffset(2)> Public i16low As Int16
End Structure
...
Dim _i3216 As int3216
_i3216.i32 = a And &HFFFF
c = _i3216.i16low