The Labs \ Source Viewer \ SSCLI \ System \ Byte

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class:  Byte
  18. **
  19. **
  20. ** Purpose: This class will encapsulate a byte and provide an
  21. **          Object representation of it.
  22. **
  23. **
  24. ===========================================================*/
  25. namespace System
  26. {
  27.    
  28.     using System;
  29.     using System.Globalization;
  30.     using System.Runtime.InteropServices;
  31.    
  32.     // The Byte class extends the Value class and
  33.     // provides object representation of the byte primitive type.
  34.     //
  35.     [System.Runtime.InteropServices.ComVisible(true)]
  36.     [Serializable(), System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
  37.     public struct Byte : IComparable, IFormattable, IConvertible, IComparable<byte>, IEquatable<byte>
  38.     {
  39.         private byte m_value;
  40.        
  41.         // The maximum value that a Byte may represent: 255.
  42.         public const byte MaxValue = (byte)255;
  43.        
  44.         // The minimum value that a Byte may represent: 0.
  45.         public const byte MinValue = 0;
  46.        
  47.        
  48.         // Compares this object to another object, returning an integer that
  49.         // indicates the relationship.
  50.         // Returns a value less than zero if this object
  51.         // null is considered to be less than any instance.
  52.         // If object is not of type byte, this method throws an ArgumentException.
  53.         //
  54.         public int CompareTo(object value)
  55.         {
  56.             if (value == null) {
  57.                 return 1;
  58.             }
  59.             if (!(value is byte)) {
  60.                 throw new ArgumentException(Environment.GetResourceString("Arg_MustBeByte"));
  61.             }
  62.            
  63.             return m_value - (((byte)value).m_value);
  64.         }
  65.        
  66.         public int CompareTo(byte value)
  67.         {
  68.             return m_value - value;
  69.         }
  70.        
  71.         // Determines whether two Byte objects are equal.
  72.         public override bool Equals(object obj)
  73.         {
  74.             if (!(obj is byte)) {
  75.                 return false;
  76.             }
  77.             return m_value == ((byte)obj).m_value;
  78.         }
  79.        
  80.         public bool Equals(byte obj)
  81.         {
  82.             return m_value == obj;
  83.         }
  84.        
  85.         // Gets a hash code for this instance.
  86.         public override int GetHashCode()
  87.         {
  88.             return m_value;
  89.         }
  90.        
  91.         public static byte Parse(string s)
  92.         {
  93.             return Parse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
  94.         }
  95.        
  96.         public static byte Parse(string s, NumberStyles style)
  97.         {
  98.             NumberFormatInfo.ValidateParseStyleInteger(style);
  99.             return Parse(s, style, NumberFormatInfo.CurrentInfo);
  100.         }
  101.        
  102.         public static byte Parse(string s, IFormatProvider provider)
  103.         {
  104.             return Parse(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
  105.         }
  106.        
  107.        
  108.         // Parses an unsigned byte from a String in the given style. If
  109.         // a NumberFormatInfo isn't specified, the current culture's
  110.         // NumberFormatInfo is assumed.
  111.         public static byte Parse(string s, NumberStyles style, IFormatProvider provider)
  112.         {
  113.             NumberFormatInfo.ValidateParseStyleInteger(style);
  114.             return Parse(s, style, NumberFormatInfo.GetInstance(provider));
  115.         }
  116.        
  117.         private static byte Parse(string s, NumberStyles style, NumberFormatInfo info)
  118.         {
  119.             int i = 0;
  120.             try {
  121.                 i = Number.ParseInt32(s, style, info);
  122.             }
  123.             catch (OverflowException e) {
  124.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"), e);
  125.             }
  126.            
  127.             if (i < MinValue || i > MaxValue)
  128.                 throw new OverflowException(Environment.GetResourceString("Overflow_Byte"));
  129.             return (byte)i;
  130.         }
  131.        
  132.         public static bool TryParse(string s, out byte result)
  133.         {
  134.             return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
  135.         }
  136.        
  137.         public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out byte result)
  138.         {
  139.             NumberFormatInfo.ValidateParseStyleInteger(style);
  140.             return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
  141.         }
  142.        
  143.         private static bool TryParse(string s, NumberStyles style, NumberFormatInfo info, out byte result)
  144.         {
  145.             result = 0;
  146.             int i;
  147.             if (!Number.TryParseInt32(s, style, info, out i)) {
  148.                 return false;
  149.             }
  150.             if (i < MinValue || i > MaxValue) {
  151.                 return false;
  152.             }
  153.             result = (byte)i;
  154.             return true;
  155.         }
  156.        
  157.         public override string ToString()
  158.         {
  159.             return Number.FormatInt32(m_value, null, NumberFormatInfo.CurrentInfo);
  160.         }
  161.        
  162.         public string ToString(string format)
  163.         {
  164.             return Number.FormatInt32(m_value, format, NumberFormatInfo.CurrentInfo);
  165.         }
  166.        
  167.         public string ToString(IFormatProvider provider)
  168.         {
  169.             return Number.FormatInt32(m_value, null, NumberFormatInfo.GetInstance(provider));
  170.         }
  171.        
  172.         public string ToString(string format, IFormatProvider provider)
  173.         {
  174.             return Number.FormatInt32(m_value, format, NumberFormatInfo.GetInstance(provider));
  175.         }
  176.        
  177.         //
  178.         // IValue implementation
  179.         //
  180.        
  181.         public TypeCode GetTypeCode()
  182.         {
  183.             return TypeCode.Byte;
  184.         }
  185.        
  186.        
  187.         /// <internalonly/>
  188.         bool IConvertible.ToBoolean(IFormatProvider provider)
  189.         {
  190.             return Convert.ToBoolean(m_value);
  191.         }
  192.        
  193.         /// <internalonly/>
  194.         char IConvertible.ToChar(IFormatProvider provider)
  195.         {
  196.             return Convert.ToChar(m_value);
  197.         }
  198.        
  199.         /// <internalonly/>
  200.         sbyte IConvertible.ToSByte(IFormatProvider provider)
  201.         {
  202.             return Convert.ToSByte(m_value);
  203.         }
  204.        
  205.         /// <internalonly/>
  206.         byte IConvertible.ToByte(IFormatProvider provider)
  207.         {
  208.             return m_value;
  209.         }
  210.        
  211.         /// <internalonly/>
  212.         short IConvertible.ToInt16(IFormatProvider provider)
  213.         {
  214.             return Convert.ToInt16(m_value);
  215.         }
  216.        
  217.         /// <internalonly/>
  218.         ushort IConvertible.ToUInt16(IFormatProvider provider)
  219.         {
  220.             return Convert.ToUInt16(m_value);
  221.         }
  222.        
  223.         /// <internalonly/>
  224.         int IConvertible.ToInt32(IFormatProvider provider)
  225.         {
  226.             return Convert.ToInt32(m_value);
  227.         }
  228.        
  229.         /// <internalonly/>
  230.         uint IConvertible.ToUInt32(IFormatProvider provider)
  231.         {
  232.             return Convert.ToUInt32(m_value);
  233.         }
  234.        
  235.         /// <internalonly/>
  236.         long IConvertible.ToInt64(IFormatProvider provider)
  237.         {
  238.             return Convert.ToInt64(m_value);
  239.         }
  240.        
  241.         /// <internalonly/>
  242.         ulong IConvertible.ToUInt64(IFormatProvider provider)
  243.         {
  244.             return Convert.ToUInt64(m_value);
  245.         }
  246.        
  247.         /// <internalonly/>
  248.         float IConvertible.ToSingle(IFormatProvider provider)
  249.         {
  250.             return Convert.ToSingle(m_value);
  251.         }
  252.        
  253.         /// <internalonly/>
  254.         double IConvertible.ToDouble(IFormatProvider provider)
  255.         {
  256.             return Convert.ToDouble(m_value);
  257.         }
  258.        
  259.         /// <internalonly/>
  260.         decimal IConvertible.ToDecimal(IFormatProvider provider)
  261.         {
  262.             return Convert.ToDecimal(m_value);
  263.         }
  264.        
  265.         /// <internalonly/>
  266.         DateTime IConvertible.ToDateTime(IFormatProvider provider)
  267.         {
  268.             throw new InvalidCastException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidCast_FromTo"), "Byte", "DateTime"));
  269.         }
  270.        
  271.         /// <internalonly/>
  272.         object IConvertible.ToType(Type type, IFormatProvider provider)
  273.         {
  274.             return Convert.DefaultToType((IConvertible)this, type, provider);
  275.         }
  276.     }
  277. }

Developer Fusion