public static Int16 ToInt16(char value)
        {
            CodeContract.Requires(value <= (char)32767);

            return(default(Int16));
        }
        public Byte[] CreateSignature(Byte[] !rgbHash)
        {
            CodeContract.Requires(rgbHash != null);

            return(default(Byte[]));
        }
Beispiel #3
0
        public static T ContractAssumeNotNull <T>(this T obj, string assumptionReason) where T : class
        {
            CodeContract.Requires(!String.IsNullOrEmpty(assumptionReason));

            return(obj);
        }
 public void SetCustomAttribute(CustomAttributeBuilder !customBuilder)
 {
     CodeContract.Requires(customBuilder != null);
 }
        public System.Runtime.Serialization.ISerializationSurrogate GetSurrogate(Type !type, System.Runtime.Serialization.StreamingContext context, ref System.Runtime.Serialization.ISurrogateSelector ssout)
        {
            CodeContract.Requires(type != null);

            return(default(System.Runtime.Serialization.ISerializationSurrogate));
        }
        public static int ToInt32(UInt64 value)
        {
            CodeContract.Requires(value <= 2147483647);

            return(default(int));
        }
 public void DefineUnmanagedResource(Byte[] !resource)
 {
     CodeContract.Requires(resource != null);
 }
        public static SByte ToSByte(char value)
        {
            CodeContract.Requires(value <= (char)127);

            return(default(SByte));
        }
        public static Char ToChar(UInt32 value)
        {
            CodeContract.Requires(value <= 65535);

            return(default(Char));
        }
        public static byte ToByte(char value)
        {
            CodeContract.Requires(value <= (char)255);

            return(default(byte));
        }
        public static SByte ToSByte(UInt16 value)
        {
            CodeContract.Requires(value <= 127);

            return(default(SByte));
        }
        public static byte ToByte(SByte value)
        {
            CodeContract.Requires(value >= 0);

            return(default(byte));
        }
        public static byte ToByte(UInt16 value)
        {
            CodeContract.Requires(value <= 255);

            return(default(byte));
        }
        public static byte ToByte(string value, int fromBase)
        {
            CodeContract.Requires(fromBase == 2 || fromBase == 8 || fromBase == 10 || fromBase == 16);

            return(default(byte));
        }
        public static UInt32 ToUInt32(SByte value)
        {
            CodeContract.Requires(value >= 0);

            return(default(UInt32));
        }
        public static Char ToChar(SByte value)
        {
            CodeContract.Requires(value >= 0);

            return(default(Char));
        }
        public static int ToInt32(string value, int fromBase)
        {
            CodeContract.Requires(fromBase == 2 || fromBase == 8 || fromBase == 10 || fromBase == 16);

            return(default(int));
        }
        public static string ToBase64String(Byte[] !inArray)
        {
            CodeContract.Requires(inArray != null);

            return(default(string));
        }
 public void DefineUnmanagedResource(string !resourceFileName)
 {
     CodeContract.Requires(resourceFileName != null);
 }
        public static string ToString(byte value, int toBase)
        {
            CodeContract.Requires(toBase == 2 || toBase == 8 || toBase == 10 || toBase == 16);

            return(default(string));
        }
        public SignatureToken GetSignatureToken(SignatureHelper !sigHelper)
        {
            CodeContract.Requires(sigHelper != null);

            return(default(SignatureToken));
        }
        public static UInt64 ToUInt64(Int16 value)
        {
            CodeContract.Requires(value >= 0);

            return(default(UInt64));
        }
 public void SetCustomAttribute(System.Reflection.ConstructorInfo !con, Byte[] !binaryAttribute)
 {
     CodeContract.Requires(con != null);
     CodeContract.Requires(binaryAttribute != null);
 }
        public static Int64 ToInt64(UInt64 value)
        {
            CodeContract.Requires(value <= 4294967295);

            return(default(Int64));
        }
 public void SetRootObject(object !obj)
 {
     CodeContract.Requires(obj != null);
 }
        public static Int64 ToInt64(string value, int fromBase)
        {
            CodeContract.Requires(fromBase == 2 || fromBase == 8 || fromBase == 10 || fromBase == 16);

            return(default(Int64));
        }
Beispiel #27
0
 public void FromXml(System.Security.SecurityElement !e, PolicyLevel level)
 {
     CodeContract.Requires(e != null);
 }
        public static UInt32 ToUInt32(UInt64 value)
        {
            CodeContract.Requires(value <= 0xFFFFFFFF);

            return(default(UInt32));
        }
Beispiel #29
0
        public static string ContractAssumeLengthIs(this string s, int length, string assumptionReason)
        {
            CodeContract.Requires(!String.IsNullOrEmpty(assumptionReason));

            return(s);
        }
        public static Int16 ToInt16(UInt32 value)
        {
            CodeContract.Requires(value <= 32767);

            return(default(Int16));
        }