protected override void GenerateDefaultArgMethod(
     CodeParameterDeclarationExpression[] argList,
     CodeExpression [] paramList)
 {
     var cons = gen.Constructor(argList, () => {});
     cons.ChainedConstructorArgs.AddRange(paramList);
 }

		public CodeMethodInvokeExpression(CodeExpression targetObject,
						   string methodName,
						   params CodeExpression[] parameters)
		{
			this.method = new CodeMethodReferenceExpression(targetObject, methodName);
			this.Parameters.AddRange(parameters);
		}

 public CodeForStatement(CodeExpression init, CodeExpression condition,CodeExpression next, CodeStatement statement)
 {
   Init = init;
   Condition = condition;
   Next = next;
   Statement = statement;
 }

		public CodeMethodReferenceExpression(CodeExpression targetObject, 
			string methodName, params CodeTypeReference[] typeParameters) :
			this (targetObject, methodName)
		{
			if (typeParameters != null && typeParameters.Length > 0)
				TypeArguments.AddRange(typeParameters);
		}

		public static CodeExpression WrapInCast(CodeExpression srcExpr, byte sizeInBits, bool forceCastOnLiteral = false)
		{
			CodeTypeReference tp = null;
			if (sizeInBits <= 8)
				tp = StaticTypeReferences.Byte;
			else if (sizeInBits <= 16)
				tp = StaticTypeReferences.UShort;
			else if (sizeInBits <= 32)
				tp = StaticTypeReferences.UInt;
			else if (sizeInBits <= 64)
				tp = StaticTypeReferences.ULong;
			else
				throw new Exception("Geeze, that's giant!");
			
			if (srcExpr is CodeCastExpression)
			{
				if (((CodeCastExpression)srcExpr).TargetType != tp)
					((CodeCastExpression)srcExpr).TargetType = tp;
				return srcExpr;
			}
			// This is only valid because of the 
			// context in which this method is called.
			// (aka. this call is used only to widen
			// values, it is never used to make them
			// smaller)
			else if (!forceCastOnLiteral && srcExpr is CodePrimitiveExpression)
			{
				return srcExpr;
			}
			
			return new CodeCastExpression(tp, srcExpr);
		}

 public CodeIterationStatement(CodeStatement initStatement, CodeExpression testExpression, CodeStatement incrementStatement, params CodeStatement[] statements)
 {
     InitStatement = initStatement;
     TestExpression = testExpression;
     IncrementStatement = incrementStatement;
     Statements.AddRange(statements);
 }

		public CodeVariableDeclarationStatement(string type,
							 string name, 
							 CodeExpression initExpression)
		{
			this.type = new CodeTypeReference(type);
			this.name = name;
			this.initExpression = initExpression;
		}

		public CodeBinaryOperatorExpression(CodeExpression left,
						     CodeBinaryOperatorType op,
						     CodeExpression right)
		{
			this.left = left;
			this.op = op;
			this.right = right;
		}

		public CodeConditionStatement(CodeExpression condition,
					       CodeStatement[] trueStatements,
					       CodeStatement[] falseStatements)
		{
			this.condition = condition;
			this.TrueStatements.AddRange(trueStatements);
			this.FalseStatements.AddRange(falseStatements);
		}

 public CodeMethodReferenceExpression(CodeExpression targetObject, string methodName, params CodeTypeReference[] typeParameters)
 {
     TargetObject = targetObject;
     MethodName = methodName;
     if (typeParameters != null && typeParameters.Length > 0)
     {
         TypeArguments.AddRange(typeParameters);
     }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="T:System.Windows.Forms.Form"/> class.
 /// </summary>
 /// <remarks></remarks>
 public CodeView(CodeExpression<Proband> code)
 {
     InitializeComponent();
     Code = code;
     if (code != null)
     {
         string rtf = RenderToRtf(code);
         richTextBoxCode.Rtf = rtf;
     }
 }

		public void AddRange(CodeExpression[] value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}

			for (int i = 0; i < value.Length; i++)
			{
				Add(value[i]);
			}
		}

		public void Ctor(string name, CodeExpression value)
		{
			if (string.IsNullOrEmpty(name))
			{
				var argument1 = new CodeAttributeArgument(value);
				Assert.Empty(argument1.Name);
				Assert.Equal(value, argument1.Value);
			}
			var argument2 = new CodeAttributeArgument(name, value);
			Assert.Equal(name ?? string.Empty, argument2.Name);
			Assert.Equal(value, argument2.Value);
		}

 /// <summary>
 /// Rendert den Code als Rich Text
 /// </summary>
 /// <param name="code">Der Code</param>
 /// <returns></returns>
 private string RenderToRtf(CodeExpression<Proband> code)
 {
     StringBuilder builder = new StringBuilder();
     builder.AppendLine(@"{\rtf1\ansi\deff0");
     // crimson --> #DC143C
     // dodger --> #1E90FF
     builder.AppendLine(@"{\colortbl;\red255\green255\blue255;\red220\green20\blue60;\red30\green144\blue255;}");
     builder.AppendLine(@"{\fonttbl\f0\fswiss Consolas;}\f0\cf1");
     RenderToRtf(code, 0, builder);
     builder.AppendLine("}");
     return builder.ToString();
 }

		public override CodeExpression GetPaddedHexToString(CodeExpression obj, int padSize)
		{
			return new CodeBinaryOperatorExpression(
				new CodePrimitiveExpression("0x"),
				CodeBinaryOperatorType.StringConcat,
				new CodeMethodInvokeExpression(
					new CodeMethodReferenceExpression()
					{
						MethodName = "format"
					},
					new CodePrimitiveExpression("%0" + padSize.ToString() + "X"),
					obj
				)
			);
		}

	public override CodeExpression GetCodeExpression(
		BoundPropertyEntry entry, object parsedData,
		ExpressionBuilderContext context)
	{
		// entry.Expression is the number string
		// (minus the RandomNumber: prefix).
		if (!entry.Expression.Contains(","))
		{
			throw new ArgumentException("Must include two numbers separated by a comma.");
		}
		else
		{
			// Get the two numbers.
			string[] numbers = entry.Expression.Split(',');

			if (numbers.Length != 2)
			{
				throw new ArgumentException("Only include two numbers.");
			}
			else
			{
				int lowerLimit, upperLimit;
				if (Int32.TryParse(numbers[0], out lowerLimit) &&
					Int32.TryParse(numbers[1], out upperLimit))
				{

					// So far all the operations have been performed in
					// normal code. That's because the two numbers are
					// specified in the expression, and so they won't
					// change each time the page is requested.
					// However, the random number should be allowed to
					// change each time, so you need to switch to CodeDOM.
					Type type = entry.DeclaringType;
					PropertyDescriptor descriptor = TypeDescriptor.GetProperties(type)[entry.PropertyInfo.Name];
					CodeExpression[] expressionArray = new CodeExpression[2];
					expressionArray[0] = new CodePrimitiveExpression(lowerLimit);
					expressionArray[1] = new CodePrimitiveExpression(upperLimit); 
					return new CodeCastExpression(descriptor.PropertyType, new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(base.GetType()), "GetRandomNumber", expressionArray));
				}
				else
				{
					throw new ArgumentException("Use valid integers.");
				}

			}
		}
		
	}

    public override CodeExpression GetCodeExpression(BoundPropertyEntry entry,
        object parsedData, ExpressionBuilderContext context)
    {
        // entry.Expression - строка с числом 
        // без префикса (например: "1,6").
        if (!entry.Expression.Contains(","))
        {
            throw new ArgumentException(" Должны быть указаны два числа, разделенные запятой");
        }
        else
        {
            // Получить два числа
            string[] numbers = entry.Expression.Split(',');

            if (numbers.Length != 2)
            {
                throw new ArgumentException("Должны быть указаны два числа");
            }
            else
            {
                int min, max;
                if (Int32.TryParse(numbers[0], out min) &&
                    Int32.TryParse(numbers[1], out max))
                {

                    // Получить ссылку на класс, имеющий метод GetRandomNumber(). 
                    // (Это класс, где данный код выполняется.)
                    CodeTypeReferenceExpression typeRef = new CodeTypeReferenceExpression(this.GetType());

                    // Определить параметры для GetRandomNumber().
                    CodeExpression[] methodParameters = new CodeExpression[2];
                    methodParameters[0] = new CodePrimitiveExpression(min);
                    methodParameters[1] = new CodePrimitiveExpression(max);

                    // Вернуть выражение привязки вызвав метод GetRandomNumber()
                    CodeMethodInvokeExpression methodCall = new CodeMethodInvokeExpression(
                        typeRef, "GetRandomNumber", methodParameters);
                    return methodCall;
                }
                else
                {
                    throw new ArgumentException("Должны использоваться допустимые целые числа");
                }

            }
        }
    }

		public virtual CodeExpression GetPaddedHexToString(CodeExpression obj, int padSize)
		{
			return new CodeBinaryOperatorExpression(
				new CodePrimitiveExpression("0x"),
				CodeBinaryOperatorType.StringConcat,
				new CodeMethodInvokeExpression(
					new CodeMethodInvokeExpression(
						obj,
						"ToString",
						new CodePrimitiveExpression("X")
					),
					"PadLeft",
					new CodePrimitiveExpression(padSize),
					new CodePrimitiveExpression('0')
				)
			);
		}

			public CodeExpression GetExpression(CodeExpression src)
			{
				CodeExpression baseExpression = new CodeBinaryOperatorExpression(
					src,
					CodeBinaryOperatorType.BitwiseAnd,
					new CodePrimitiveExpression((uint)(((1u << (byte)(EndIdx - StartIdx + 1)) - 1) << (byte)StartIdx))
				);
				if (StartIdx != 0)
				{
					baseExpression = new CodeBinaryOperatorExpression(
						baseExpression,
						CodeBinaryOperatorType.ShiftRight,
						new CodePrimitiveExpression((int)StartIdx)
					);
				}
				return Utils.WrapInCast(
					baseExpression,
					(byte)Length
				);
			}

 public override CodeExpression GetCodeExpression(System.Web.UI.BoundPropertyEntry entry, object parsedData, ExpressionBuilderContext context)
 {
     if (!entry.Expression.Contains(","))
     {
         throw new ArgumentException(
         "Must include two numbers separated by a comma.");
     }
     else
     {
         // Get the two numbers.
         string[] numbers = entry.Expression.Split(',');
         if (numbers.Length != 2)
         {
             throw new ArgumentException("Only include two numbers.");
         }
         else
         {
             int lowerLimit, upperLimit;
             if (Int32.TryParse(numbers[0], out lowerLimit) &&
             Int32.TryParse(numbers[1], out upperLimit))
             {
                 // Get a reference to the class that has the
                 // GetRandomNumber() method.
                 // (It's the class where this code is executing.)
                 CodeTypeReferenceExpression typeRef = new
                 CodeTypeReferenceExpression(this.GetType());
                 CodeExpression[] methodParameters = new CodeExpression[2];
                 methodParameters[0] = new CodePrimitiveExpression(lowerLimit);
                 methodParameters[1] = new CodePrimitiveExpression(upperLimit);
                 return new CodeMethodInvokeExpression(typeRef, "GetRandomNumber", methodParameters);
             }
             else
             {
                 throw new ArgumentException("Use valid integers.");
             }
         }
     }
 }