/// <summary>
			/// 分割数を指定して初期化。
			/// </summary>
			/// <param name="variable">変数</param>
			/// <param name="min">最小値</param>
			/// <param name="max">最大値</param>
			/// <param name="n">分割数</param>
			public Range(Variable variable, ValueType min, ValueType max, int n)
			{
				this.variable = variable;
				this.min = min;
				this.max = max;
				this.step = (max - min) / (ValueType)n;
			}

        public static int GetHashCode(ValueType aThis)
        {
            if (aThis is byte)
                return (int)aThis;

            return -1;
        }

 /// <summary>
 /// 
 /// </summary>
 /// <remarks></remarks>
 /// <seealso cref=""/>
 /// <param name="name"></param>
 /// <param name="dataType"></param>
 public DataTypeCheck(string name, string dataType, DecimalCharacter decimalCharacter)
 {
     this.appliedTo = ValueType.Number;
     this.name = name;
     this.dataType = dataType;
     this.decimalCharacter = decimalCharacter;
 }

 public ParameterDefintion(string ParameterName, ParamAllowType AllowType, ValueType ValueType, string ParameterHelp)
 {
     this.Parameter = ParameterName;
     this.AllowType = AllowType;
     this.ValueType = ValueType;
     this.Help = ParameterHelp;
 }           

 internal TimeCondition(ValueType valueType, CounterType counter, uint value, DayOfWeek dayOfWeek)
 {
     ValueType = valueType;
     CounterType = counter;
     Value = value;
     DayOfWeek = dayOfWeek;
 }

		static InstanceMethods()
		{
			DateTime dateTime = new DateTime();
			ValueType valueType = dateTime;
			//new DateTime(0x270f, 12, 31, 23, 59, 59, 0x3e7, DateTimeKind.Utc)
			InstanceMethods.maxValidCimTimestamp = valueType;
		}

		/// <summary>
		/// Сериализует значение (Mpower или ushort (mmmm кВт*ч)) в массив
		/// из 2 байт в BCD формате
		/// </summary>
		/// <param name="value"></param>
		/// <returns></returns>
		public static byte[] ToArray(ValueType value)
		{
			if (value is Menerg)
			{
				var bcd = (Menerg)value;
				return BitConverter.GetBytes(bcd._powerLimitBcd);
			}
			else if (value is ushort)
			{
				var x = (ushort)value;

				if (x >= 10000)
				{
					throw new ArgumentOutOfRangeException(
						"Значение лимта мощьности не можеть быть больше или равно 100");
				}

				var bcd = BcdConverter.ToBcdUInt16(x);
				return BitConverter.GetBytes(bcd);
			}
			else
			{
				throw new InvalidCastException("Невозможно сериализовать значение");
			}
		}

		public ImmediateValue(ValueType value)
		{
			if (value == null)
				throw new ArgumentNullException("value");
			else
				Value = value;
		}

 internal static object EnumerateUDT(ValueType oStruct, IRecordEnum intfRecEnum, bool fGet)
 {
     Type typ = oStruct.GetType();
     if ((Information.VarTypeFromComType(typ) != VariantType.UserDefinedType) || typ.IsPrimitive)
     {
         throw new ArgumentException(Utils.GetResourceString("Argument_InvalidValue1", new string[] { "oStruct" }));
     }
     FieldInfo[] fields = typ.GetFields(BindingFlags.Public | BindingFlags.Instance);
     int num2 = 0;
     int num4 = fields.GetUpperBound(0);
     for (int i = num2; i <= num4; i++)
     {
         FieldInfo fieldInfo = fields[i];
         Type fieldType = fieldInfo.FieldType;
         object obj3 = fieldInfo.GetValue(oStruct);
         if (Information.VarTypeFromComType(fieldType) == VariantType.UserDefinedType)
         {
             if (fieldType.IsPrimitive)
             {
                 throw ExceptionUtils.VbMakeException(new ArgumentException(Utils.GetResourceString("Argument_UnsupportedFieldType2", new string[] { fieldInfo.Name, fieldType.Name })), 5);
             }
             EnumerateUDT((ValueType) obj3, intfRecEnum, fGet);
         }
         else
         {
             intfRecEnum.Callback(fieldInfo, ref obj3);
         }
         if (fGet)
         {
             fieldInfo.SetValue(oStruct, obj3);
         }
     }
     return null;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <remarks></remarks>
 /// <seealso cref=""/>
 /// <param name="name"></param>
 /// <param name="dataType"></param>
 /// <param name="optional"></param>
 public OptionalCheck(string name, string dataType, bool optional)
 {
     this.appliedTo = ValueType.All;
     this.optional = optional;
     this.name = name;
     this.dataType = dataType;
 }

        public void TypeLayoutCanBeControlledUsingStructLayoutAttribute()
        {
            ValueType value = new ValueType(1, 2);

            value.X.ShouldBe(1);
            value.Y.ShouldBe(2);
        }

        public static void TestUseCase(Assert assert)
        {
            assert.Expect(7);

            var t1 = new Type();
            assert.Ok(t1 != null, "#565 t1");

            var t2 = new ValueType();
            assert.Ok(t2 != null, "#565 t2");

            var t3 = new IntPtr();
            assert.Ok(t3.GetType() == typeof(IntPtr) , "#565 t3");

            var t4 = new UIntPtr();
            assert.Ok(t4.GetType() == typeof(UIntPtr), "#565 t4");

            var t5 = new ParamArrayAttribute();
            assert.Ok(t5 != null, "#565 t5");

            var t6 = new RuntimeTypeHandle();
            assert.Ok(t6.GetType() == typeof(RuntimeTypeHandle), "#565 t6");

            var t7 = new RuntimeFieldHandle();
            assert.Ok(t7.GetType() == typeof(RuntimeFieldHandle), "#565 t7");
        }

 private StructureId(ValueType value, Type dataType, StructureIdTypes idType)
 {
     _value = value;
     _hasValue = value != null;
     _dataType = dataType;
     _idType = idType;
 }

 public BasicBinaryOperator(string @operator, ValueType operandsAndReturnType, Func<object, object, object> evaluator)
 {
     _evaluator = evaluator;
     Operator = @operator;
     ReturnType = operandsAndReturnType;
     LHS = operandsAndReturnType;
     RHS = operandsAndReturnType;
 }

 public CheckControlParams(string name,string value,string errormsg, ValueType valueType,bool isRequired)
 {
     Name = name;
     Value = value;
     Type = valueType;
     Errormsg = errormsg;
     IsRequired = isRequired;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <remarks></remarks>
 /// <seealso cref=""/>
 /// <param name="name"></param>
 /// <param name="dataType"></param>
 /// <param name="min"></param>
 /// <param name="max"></param>
 public RangeValidation(string name, string dataType , double min, double max)
 {
     this.appliedTo = ValueType.All;
     this.min = min;
     this.max = max;
     this.name = name;
     this.dataType = dataType;
 }

 public void ConvertToString_GivenType_ShouldConvert(Type type, ValueType value, string expectedValue)
 {
     var converter = CreateValueTypeConverter(type);
     converter
         .ConvertToString(value)
         .Should()
         .Be(expectedValue);
 }

 public virtual ValueType FromDescription(string v, ValueType d)
 {
     if(v==null) return d;
     IDictionaryEnumerator ie = _descToValue.GetEnumerator();
     while(ie.MoveNext()) {
         if(v==LoadString((string)ie.Key)) return (ValueType)ie.Value;
     }
     return d;
 }

 public MxeWord( int position, string header )
     : base(position)
 {
     _header = header;
     if (header.Length > 0 && Enum.IsDefined(typeof(ValueType), (int)header[0]))
     {
         _valueType = (ValueType)header[0];
     }
 }

        public void ConvertFromString_GivenType_ShouldConvert(Type type, string stringValue, ValueType expectedValue)
        {
            var converter = CreateValueTypeConverter(type);

            var value = converter.ConvertFromString(stringValue);
            value
                .Should()
                .Be(expectedValue);
        }