SByte

src\Framework\System\Windows\Markup\Baml2006\WpfGeneratedKnownTypes.cs (1)

8671bamlType.DefaultConstructor = delegate() { return new System.SByte(); };

microsoft\win32\oavariantlib.cs (1)

system\convert.cs (16)

system\decimal.cs (2)

848if (temp < SByte.MinValue || temp > SByte.MaxValue) throw new OverflowException(Environment.GetResourceString("Overflow_SByte"));

System\Diagnostics\Eventing\TraceLogging\SimpleTypeInfos.cs (5)

86: TraceLoggingTypeInfo<SByte> 96public override void WriteData(TraceLoggingDataCollector collector, ref SByte value) 398: TraceLoggingTypeInfo<SByte[]> 408public override void WriteData(TraceLoggingDataCollector collector, ref SByte[] value) 673collector.AddScalar(EnumHelper<SByte>.Cast(value));

System\Diagnostics\Eventing\TraceLogging\Statics.cs (3)

609else if (elementType == typeof(SByte)) 683else if (underlyingType == typeof(SByte)) 721else if (dataType == typeof(SByte))

system\internal.cs (2)

121new List<SByte>(); 145SZArrayHelper<SByte>(null);

system\io\unmanagedmemoryaccessor.cs (7)

395public SByte ReadSByte(Int64 position) { 396int sizeOfType = sizeof(SByte); 399SByte result; 406result = *((SByte*)pointer); 893public void Write(Int64 position, SByte value) { 894int sizeOfType = sizeof(SByte); 903*((SByte*)pointer) = value;

system\math.cs (1)

257if (value == SByte.MinValue)

system\reflection\emit\ilgenerator.cs (2)

280if (updateAddr < SByte.MinValue || updateAddr > SByte.MaxValue)

system\resources\resourcereader.cs (1)

621else if (type == typeof(SByte))

system\resources\resourcewriter.cs (1)

541else if (type == typeof(SByte))

system\runtime\compilerservices\AsyncMethodBuilder.cs (3)

776(typeof(TResult) == typeof(SByte) && default(SByte) == (SByte)(object)result) ||

system\Runtime\InteropServices\Variant.cs (2)

75[FieldOffset(0)] internal SByte _i1; 374public SByte AsI1 {

system\runtime\serialization\formatter.cs (1)

145} else if (varType==typeof(SByte)) {

system\runtime\serialization\formatters\binary\binaryconverter.cs (3)

307array = new SByte[length]; 500internal static Type typeofSByte = typeof(SByte); 525internal static Type typeofSByteArray = typeof(SByte[]);

system\runtime\serialization\formatters\binary\binaryformatterwriter.cs (1)

128internal void WriteSByte(SByte value)

system\runtime\serialization\formatters\binary\binaryparser.cs (2)

345internal SByte ReadSByte() 347return(SByte)ReadByte();

system\runtime\serialization\formatters\binary\binaryutilclasses.cs (3)

843SByte[] sbyteA = null; 879sbyteA = (SByte[])array; 922sbyteA[index] = SByte.Parse(value, CultureInfo.InvariantCulture);

system\sbyte.cs (11)

30, IComparable<SByte>, IEquatable<SByte> 55if (!(obj is SByte)) { 58return m_value - ((SByte)obj).m_value; 61public int CompareTo(SByte value) { 67if (!(obj is SByte)) { 70return m_value == ((SByte)obj).m_value; 74public bool Equals(SByte obj) 167public static bool TryParse(String s, out SByte result) { 172public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out SByte result) { 177private static bool TryParse(String s, NumberStyles style, NumberFormatInfo info, out SByte result) {

system\threading\volatile.cs (1)

51var value = location;

system\variant.cs (1)

95typeof(SByte),

Base\System\Windows\Markup\TypeConverterHelper.cs (1)

217else if (typeof(SByte).IsAssignableFrom(type))

Framework\System\Windows\Markup\KnownTypes.cs (1)

5500case KnownElements.SByte: t = typeof(SByte); break;

src\Framework\MS\Internal\Data\DefaultValueConverter.cs (2)

539typeof(UInt32), typeof(UInt64), typeof(UInt16), typeof(SByte), // non-CLS compliant types 546typeof(UInt32), typeof(UInt64), typeof(UInt16), typeof(SByte), // non-CLS compliant types

src\Framework\System\Windows\Markup\Baml2006\Baml2006KnownTypes.cs (1)

636case 544: t = () => typeof(SByte); break;

src\Framework\System\Windows\Markup\Baml2006\Baml2006Reader.cs (2)

1155SByte flags = _binaryReader.ReadSByte(); 2373private void InjectPropertyAndFrameIfNeeded(XamlType elementType, SByte flags)

src\Framework\System\Windows\Markup\Baml2006\WpfGeneratedKnownTypes.cs (1)

8669typeof(System.SByte),

src\Framework\System\Windows\Markup\KnownTypes.cs (1)

6088case KnownElements.SByte: t = typeof(System.SByte); break;

compmod\microsoft\csharp\csharpcodeprovider.cs (2)

1193else if (e.Value is SByte) { 1195Output.Write(((SByte)e.Value).ToString(CultureInfo.InvariantCulture));

compmod\microsoft\visualbasic\VBCodeProvider.cs (2)

1064else if (e.Value is SByte) { 1066Output.Write(((SByte)e.Value).ToString(CultureInfo.InvariantCulture));

compmod\system\componentmodel\ReflectTypeDescriptionProvider.cs (1)

121temp[typeof(SByte)] = typeof(SByteConverter);

compmod\system\componentmodel\SByteConverter.cs (4)

32return typeof(SByte); 47return SByte.Parse(value, NumberStyles.Integer, formatInfo); 55return SByte.Parse(value, culture); 62return ((SByte)value).ToString("G", formatInfo);

parent\parent\parent\InternalApis\NDP_FX\inc\ZLibNative.cs (1)

748String msgStr = new String((SByte*) zStreamPtr->msg);

System\Addin\MiniReflection\MiniParameterInfo.cs (1)

83return new TypeInfo(typeof(SByte));

System\Addin\Contract\RemoteArgument.cs (5)

598public RemoteArgument(System.SByte value) 607public RemoteArgument(System.SByte value, bool isByRef) 1264public System.SByte SByteValue 1272return default(System.SByte); 1278return (System.SByte)this._value;

Microsoft\Scripting\Ast\ParameterExpression.cs (1)

71case TypeCode.SByte: return new PrimitiveParameterExpression<SByte>(name);

System\Diagnostics\Eventing\Reader\NativeWrapper.cs (2)

1240return ConvertToArray (val,typeof(SByte), sizeof(SByte)); // not CLS-compliant

fx\src\data\Microsoft\SqlServer\Server\MetadataUtilsSmi.cs (1)

104ht.Add( typeof( System.SByte ), ExtendedClrTypeCode.SByte );

fx\src\data\System\Data\CodeGen\datacache.cs (1)

852col.DataType == typeof(SByte) || col.DataType == typeof(Byte) ||

fx\src\data\System\Data\ColumnTypeConverter.cs (1)

37typeof(SByte),

fx\src\data\System\Data\Common\BigIntegerStorage.cs (4)

66else if (value.GetType() == typeof(SByte)) { return (BigInteger)(SByte)value; } 76else if (type == typeof(SByte)) { return checked((SByte)value); }

fx\src\data\System\Data\Common\DataStorage.cs (1)

76typeof(SByte),

fx\src\data\System\Data\Common\SByteStorage.cs (22)

18private const SByte defaultValue = 0; 20private SByte[] values; 23: base(column, typeof(SByte), defaultValue, StorageType.SByte) { 54SByte mean; 55checked {mean = (SByte)(meanSum / meanCount);} 97SByte min = SByte.MaxValue; 111SByte max = SByte.MinValue; 136throw ExprException.Overflow(typeof(SByte)); 142SByte valueNo1 = values[recordNo1]; 143SByte valueNo2 = values[recordNo2]; 165SByte valueNo1 = values[recordNo]; 169return valueNo1.CompareTo((SByte)value); 191SByte value = values[record]; 211SByte[] newValues = new SByte[capacity]; 224return XmlConvert.ToString((SByte)value); 228return new SByte[recordCount]; 232SByte[] typedStore = (SByte[]) store; 238values = (SByte[]) store;

fx\src\data\System\Data\Common\SQLConvert.cs (2)

500return ((IConvertible)(SByte)value).ToString(formatProvider); 747return XmlConvert.ToString((SByte) value);

fx\src\data\System\Data\OleDb\ColumnBinding.cs (6)

457Value_I1((SByte) value); 852private SByte Value_I1() { 856return unchecked((SByte)value); 858private void Value_I1(SByte value) { 1289if (variant is SByte) { 1290value = (Int16)(SByte) variant;

fx\src\data\System\Data\OleDb\PropertyInfoSet.cs (1)

158case VarEnum.VT_I1: return typeof(System.SByte);

fx\src\data\System\Data\XDRSchema.cs (2)

219new NameType("byte" , typeof(SByte) ), /* XDR */ 229new NameType("i1" , typeof(SByte) ), /* XDR */

fx\src\data\System\Data\xmlsaver.cs (1)

222if (type == typeof(SByte)|| type == typeof(SqlByte))

fx\src\data\System\Data\XMLSchema.cs (1)

1571new NameType("byte" , typeof(SByte) ), /* XSD Apr */

System\Data\EntityModel\SchemaObjectModel\ScalarType.cs (2)

142SByte temp; 143if (!SByte.TryParse(text, System.Globalization.NumberStyles.Integer, System.Globalization.CultureInfo.InvariantCulture, out temp))

System\Data\Mapping\Update\Internal\Propagator.ExtentPlaceholderCreator.cs (1)

69typeDefaultMap[PrimitiveTypeKind.SByte] = default(SByte);

System\Data\Metadata\Edm\EnumMember.cs (1)

51Debug.Assert(value is SByte || value is Byte || value is Int16 || value is Int32 || value is Int64, "Unsupported type of enum member value.");

System\Data\Metadata\Edm\Provider\ClrProviderManifest.cs (1)

220primitiveTypes[(int)PrimitiveTypeKind.SByte] = CreatePrimitiveType(typeof(SByte), PrimitiveTypeKind.SByte);

System\Data\Metadata\Edm\Provider\EdmProviderManifest.cs (1)

168InitializePrimitiveType(primitiveTypes[(int)PrimitiveTypeKind.SByte], PrimitiveTypeKind.SByte, EdmConstants.SByte, typeof(SByte));

System\Data\Metadata\Helper.cs (2)

518{ PrimitiveTypeKind.SByte, new long[] { SByte.MinValue, SByte.MaxValue } },

SqlClient\Reader\ObjectReaderCompiler.cs (1)

2345this.GenerateConstInt((SByte)value);

System\Data\Services\Parsing\WebConvert.cs (4)

409else if (typeof(SByte) == targetType) 526else if (typeof(SByte) == targetType) 663else if (typeof(SByte) == valueType) 665result = XmlConvert.ToString((SByte)value);

System\Data\Services\Serializers\JsonDeserializer.cs (1)

122else if (propertyType == typeof(SByte))

System\Data\Services\Serializers\JsonSerializer.cs (2)

325else if (typeof(SByte) == valueType) 327this.writer.WriteValue((SByte)value);

System\Data\Services\WebUtil.cs (2)

88new KeyValuePair<Type, string>(typeof(SByte), XmlConstants.EdmSByteTypeName), 89new KeyValuePair<Type, string>(typeof(SByte?), XmlConstants.EdmSByteTypeName),

parent\Server\System\Data\Services\Parsing\WebConvert.cs (2)

663else if (typeof(SByte) == valueType) 665result = XmlConvert.ToString((SByte)value);

System\Data\Services\Client\ClientConvert.cs (3)

337return XmlConvert.ToString((SByte)propertyValue); 478types[(int)StorageType.SByte] = typeof(SByte); 509named.Add(XmlConstants.EdmSByteTypeName, typeof(SByte));

Instrumentation\SchemaMapping.cs (2)

391 if(t2 == typeof(Byte) || t2 == typeof(SByte)) 516 else if(t2 == typeof(SByte))

InteropClasses\WMIInterop.cs (1)

1079[PreserveSig] int MakeSingleton_([In] SByte bSet);

property.cs (9)

307 val = new SByte [length]; 310 ((SByte[])val) [i] = (SByte)((Int16)(wmiValueArray.GetValue(i))); 344 val = (SByte)((Int16)wmiValue); 403 ((Int16[])(wmiValue))[i] = (Int16)Convert.ToSByte(valArray.GetValue(i),(IFormatProvider)culInfo.GetFormat(typeof(System.SByte))); 648 else if (elementType == typeof(System.SByte)) 656 ((short[])wmiValue) [i] = ((IConvertible)((System.SByte)(arrayValue[i]))).ToInt16(null); 785 else if (valueType == typeof(System.SByte)) 788 wmiValue = ((IConvertible)((System.SByte)val)).ToInt16(null);

System\Numerics\BigInteger.cs (2)

1137public static implicit operator BigInteger(SByte value) 1197public static explicit operator SByte(BigInteger value)

System\Numerics\Complex.cs (1)

236public static implicit operator Complex(SByte value) {

metadata\sudscommon.cs (1)

76internal static Type typeofSByte = typeof(SByte);

System\Runtime\Serialization\DataContract.cs (1)

740type = typeof(SByte);

System\Runtime\Serialization\XmlReaderDelegator.cs (6)

607public SByte ReadElementContentAsSignedByte() 612internal SByte ReadContentAsSignedByte() 617SByte ToSByte(int value) 619if (value < SByte.MinValue || value > SByte.MaxValue) 623return (SByte)value;

System\Runtime\TypeHelper.cs (2)

320SByte sbyteSource = (SByte)source;

System\ServiceModel\Dispatcher\QueryStringConverter.cs (3)

31this.defaultSupportedQueryStringTypes.Add(typeof(SByte), null); 80return parameter == null ? default(SByte) : XmlConvert.ToSByte(parameter); 179return XmlConvert.ToString((SByte) parameter);

State\SessionStateItemCollection.cs (1)

175t=typeof(SByte);

UI\PropertyMapper.cs (1)

115if ((type == typeof(SByte)) ||

Util\altserialization.cs (2)

92else if (value is SByte) { 94writer.Write((SByte) value);

Common\DataManager\DataPoint.cs (2)

2070 else if(value is SByte) 2072 return (double)((SByte)value);

Common\DataManager\DataSeries.cs (1)

936 type == typeof(SByte) ||

System\Data\WebControls\EntityDataSourceUtil.cs (2)

355return typeof(SByte); 415return typeof(SByte);

UI\WebControls\Dynamic.cs (1)

603typeof(SByte),

winforms\Managed\System\WinForms\ComponentModel\COM2Interop\COM2TypeInfoProcessor.cs (1)

945return typeof(SByte);

winforms\Managed\System\WinForms\DataGridTable.cs (1)

1479dataType.Equals(typeof(SByte))) {

winforms\Managed\System\WinForms\NativeMethods.cs (3)

4353else if (t == typeof(SByte)) { 4420return (SByte) (0xFF & (SByte) val);

Common\DataManager\DataPoint.cs (2)

2070 else if(value is SByte) 2072 return (double)((SByte)value);

Common\DataManager\DataSeries.cs (1)

936 type == typeof(SByte) ||

System\Xml\BinaryXml\XmlBinaryReader.cs (1)

2889map[(int)BinXmlToken.XSD_BYTE] = typeof(System.SByte);

System\Xml\Schema\XmlValueConverter.cs (2)

845if (value < (int) SByte.MinValue || value > (int) SByte.MaxValue)

System\Xml\Serialization\PrimitiveXmlSerializers.cs (2)

108WriteElementStringRaw(@"byte", @"", System.Xml.XmlConvert.ToString((System.SByte)((System.SByte)o)));

System\Xml\Serialization\Types.cs (2)

463AddPrimitive(typeof(SByte), "byte", "SByte", TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired); 559AddSoapEncodedPrimitive(typeof(SByte), "byte", ns, "SByte", new XmlQualifiedName("string", XmlSchema.Namespace), TypeFlags.CanBeAttributeValue | TypeFlags.CanBeElementValue | TypeFlags.XmlEncodingNotRequired);

System\Xml\Serialization\XmlSerializationReader.cs (3)

348return typeof(SByte); 411return typeof(SByte); 738value = default(Nullable<SByte>);

System\Xml\XmlConvert.cs (5)

653public static string ToString(SByte value) { 895public static SByte ToSByte (string s) { 896return SByte.Parse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo); 900internal static Exception TryToSByte(string s, out SByte result) { 901if (!SByte.TryParse(s, NumberStyles.AllowLeadingSign|NumberStyles.AllowLeadingWhite|NumberStyles.AllowTrailingWhite, NumberFormatInfo.InvariantInfo, out result)) {

Base\System\Windows\Markup\TypeConverterHelper.cs (3)

217else if (typeof(SByte).IsAssignableFrom(type)) 301else if (type == typeof(SByte)) 401else if (typeof(SByte).IsAssignableFrom(type))

parent\parent\InternalApis\NDP_FX\inc\ZLibNative.cs (1)

748String msgStr = new String((SByte*) zStreamPtr->msg);

Shared\MS\Win32\NativeMethodsCLR.cs (2)

4732return (SByte) (0xFF & (SByte) val);