public override void DeclareCodeType(IDLInterface idlIntf)
        {
            // Proxy class.
            typeProxy = new CodeTypeDeclaration(name + "Proxy");
            typeProxy.IsClass = true;
            typeProxy.TypeAttributes = TypeAttributes.Public;
            eventsDeclarationHolder = new CodeTypeDeferredNamespaceDeclarationHolderEvents(idlIntf);
            typeProxy.BaseTypes.Add(genInterfaceName);

            // Interface field.
            CodeMemberField memberProxy = new CodeMemberField(genInterfaceName, proxyName);
            memberProxy.Attributes = MemberAttributes.Private;
            typeProxy.Members.Add(memberProxy); // TODO: Going to need a using or a fully qualified name.

            // Constructor.
            CodeConstructor constructor = new CodeConstructor();
            constructor.Attributes = MemberAttributes.Public;
            // TODO - use the actual interface type rather than a string.
            paramProxy = new CodeParameterDeclarationExpression(genInterfaceName, proxyName);
            constructor.Parameters.Add(paramProxy);
            thisProxyFieldRef = new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), proxyName
            );
            assignProxy = new CodeAssignStatement(thisProxyFieldRef,
                new CodeArgumentReferenceExpression(proxyName));
            constructor.Statements.Add(assignProxy);
            typeProxy.Members.Add(constructor);

            declarationHolder = new CodeTypeIgnoredNamespaceDeclarationHolderParams(idlIntf);
            contextDeclarationHolder = declarationHolder;

            bAddNamespace = false;
        }

 internal static CodeMemberField AddFieldDeclaration(CodeTypeDeclaration type, MemberAttributes memberAttribute, string fieldType, string fieldName)
 {
     CodeMemberField cmf = new CodeMemberField(fieldType, fieldName);
     cmf.Attributes = memberAttribute;
     type.Members.Add(cmf);
     return cmf;
 }

        /// <summary>
        /// Compose additional items of the test TearDown method.
        /// </summary>
        /// <param name="teardownMethod">A reference to the TearDown method of the test.</param>
        /// <param name="testObjectMemberField">The member field of the object under test.</param>
        /// <param name="testObjectName">The name of the object under test.</param>
        /// <param name="testObjectType">Type of the object under test(OuT).</param>
        protected override void ComposeTestTearDownMethod(
            CodeMemberMethod teardownMethod,
            CodeMemberField testObjectMemberField,
            string testObjectName,
            Type testObjectType)
        {
            /*var invokeExpression = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("Assert"),
                "AreEqual",
                //new CodePrimitiveExpression("expected")
                new CodeFieldReferenceExpression(testObjectMemberField, "bla")
                , new CodeVariableReferenceExpression("actual"));*/
            var fieldRef1 =
                new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), testObjectMemberField.Name);

            // var objectCreate1 = new CodeObjectCreateExpression(testObjectName, new CodeExpression[] { });
            var as1 =
                new CodeAssignStatement(fieldRef1, new CodePrimitiveExpression(null));

            // new CodeAssignStatement(fieldRef1, objectCreate1);

            // Creates a statement using a code expression.
            // var expressionStatement = new CodeExpressionStatement(fieldRef1);
            teardownMethod.Statements.Add(as1);
            base.ComposeTestTearDownMethod(teardownMethod, testObjectMemberField, testObjectName, testObjectType);
        }

 internal CodeMemberField CreateServiceField(string serviceClassName)
 {
     CodeMemberField serviceField;
     serviceField = new CodeMemberField(serviceClassName, ResourceBaseGenerator.ServiceFieldName);
     serviceField.Attributes = MemberAttributes.Final | MemberAttributes.Private;
     return serviceField;
 }

        protected override void ProcessProperty(CodeTypeDeclaration type, CodeMemberField field, CodeMemberProperty property)
        {
            if (property.Type.ArrayElementType == null) return; // Is array?

            if (property.Name == "Items" || property.Name == "ItemsElementName") return;

            CodeTypeReference genericType = new CodeTypeReference("System.Collections.Generic.List", new CodeTypeReference(property.Type.BaseType));

            property.Type = genericType;
            if (field != null) {
                field.Type = genericType;

                property.GetStatements.Insert(0,
                    // if
                    new CodeConditionStatement(
                        // field == null
                        new CodeBinaryOperatorExpression(
                            new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name),
                            CodeBinaryOperatorType.IdentityEquality,
                            new CodePrimitiveExpression(null)),
                        // field = new List<T>();
                        new CodeAssignStatement(
                            new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), field.Name),
                            new CodeObjectCreateExpression(genericType))));
            }
        }

 public static bool ListContainsConstant(List<CodeMemberField> constants, CodeMemberField c)
 {
     foreach (CodeMemberField d in constants)
         if (d.Name == c.Name)
             return true;
     return false;
 }

 internal CodeMemberField CreateUriField(IService service)
 {
     var uri = new CodeMemberField(typeof(string), BaseUriName);
     uri.Attributes = MemberAttributes.Const | MemberAttributes.Private;
     uri.InitExpression = new CodePrimitiveExpression(service.BaseUri.ToString());
     return uri;
 }

 internal CodeMemberField CreateNameField(IService service)
 {
     var name = new CodeMemberField(typeof(string), NameName);
     name.Attributes = MemberAttributes.Const | MemberAttributes.Private;
     name.InitExpression = new CodePrimitiveExpression(service.Name);
     return name;
 }

 public override object Serialize(IDesignerSerializationManager manager, object value)
 {
     CodeExpression expression;
     CodeTypeDeclaration declaration = manager.Context[typeof(CodeTypeDeclaration)] as CodeTypeDeclaration;
     RootContext context = manager.Context[typeof(RootContext)] as RootContext;
     CodeStatementCollection statements = new CodeStatementCollection();
     if ((declaration != null) && (context != null))
     {
         CodeMemberField field = new CodeMemberField(typeof(IContainer), "components") {
             Attributes = MemberAttributes.Private
         };
         declaration.Members.Add(field);
         expression = new CodeFieldReferenceExpression(context.Expression, "components");
     }
     else
     {
         CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(typeof(IContainer), "components");
         statements.Add(statement);
         expression = new CodeVariableReferenceExpression("components");
     }
     base.SetExpression(manager, value, expression);
     CodeObjectCreateExpression right = new CodeObjectCreateExpression(typeof(Container), new CodeExpression[0]);
     CodeAssignStatement statement2 = new CodeAssignStatement(expression, right);
     statement2.UserData["IContainer"] = "IContainer";
     statements.Add(statement2);
     return statements;
 }

        private void EmitField(CodeTypeDeclaration typeDecl, CodeTypeReference fieldType, bool hasDefault)
        {
            CodeMemberField memberField = new CodeMemberField(fieldType, Utils.FieldNameFromPropName(Item.Name));
            memberField.Attributes = MemberAttributes.Private;

            AttributeEmitter.AddGeneratedCodeAttribute(memberField);

            if (hasDefault)
            {
                if (this.Generator.UseDataServiceCollection)
                {
                    // new DataServiceCollection<T>(null, System.Data.Services.Client.TrackingMode.None, null, null, null);
                    // declare type is DataServiceCollection<T>
                    Debug.Assert(fieldType.TypeArguments.Count == 1, "Declare type is non generic.");

                    // new DataServiceCollection<[type]>(null, TrackingMode.None)
                    memberField.InitExpression = new CodeObjectCreateExpression(
                        fieldType,
                        new CodePrimitiveExpression(null),
                        new CodeFieldReferenceExpression(
                            new CodeTypeReferenceExpression(typeof(System.Data.Services.Client.TrackingMode)),
                            "None"));
                }
                else
                {
                    memberField.InitExpression = new CodeObjectCreateExpression(fieldType);
                }
            }

            typeDecl.Members.Add(memberField);
        }

        static void DumpToFile(string enumName, IEnumerable<string> names, int first)
        {
            // TODO: Необходимо задавать провайдер из параметров командной строки
            // по умолчанию брать Cpp провайдер
            var @enum = new CodeTypeDeclaration(enumName) {
                IsEnum = true,
            };

            foreach(var name in names) {
                var field = new CodeMemberField(string.Empty, name) {
                    InitExpression = new CodePrimitiveExpression(first),
                };
                @enum.Members.Add(field);
                first++;
            }

            var codeProvider = CodeDomProvider.CreateProvider("CSharp");
            var options = new CodeGeneratorOptions {
                BlankLinesBetweenMembers = false,
                BracingStyle = "C",
            };

            using(var writer = new StreamWriter(enumName + "." + codeProvider.FileExtension)) {
                codeProvider.GenerateCodeFromType(@enum, writer, options);
            }
        }

		static void enrichWrapType(CodeTypeDeclaration wrap, TypeInfo type)
		{
			// implement IWrap<T>
			var typeRef = new CodeTypeReference(type, CodeTypeReferenceOptions.GlobalReference);
			var iwrap = new CodeTypeReference(typeof(IWrap<>).Name + "<" + "global::" + type.FullName + ">", CodeTypeReferenceOptions.GenericTypeParameter);
			wrap.BaseTypes.Add(iwrap);

			// implement interface with public members for  underlying object 
			var intf = new CodeTypeReference("I" + type.Name);
			wrap.BaseTypes.Add(intf);

			// create underlying object related stuff
			var _underlyingObject = new CodeMemberField(typeRef, "_underlyingObject") { Attributes = MemberAttributes.Private };
			wrap.Members.Add(_underlyingObject);
			var this_underlyingObject = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), _underlyingObject.Name);
			var UnderlyingObject = new CodeMemberProperty();
			UnderlyingObject.Name = "UnderlyingObject";
			UnderlyingObject.HasGet = true;
			UnderlyingObject.HasSet = false;
			var ret = new CodeMethodReturnStatement(this_underlyingObject);
			UnderlyingObject.GetStatements.Add(ret);
			UnderlyingObject.Attributes = MemberAttributes.Public;
			UnderlyingObject.ImplementationTypes.Add(iwrap);
			UnderlyingObject.PrivateImplementationType = iwrap;
			UnderlyingObject.Type = typeRef;
			wrap.Members.Add(UnderlyingObject);

			addUnderlyingCtor(typeRef, this_underlyingObject, wrap);
			addCtors(type, typeRef, this_underlyingObject, wrap);
			addMethods(type, typeRef, this_underlyingObject, wrap);



		}

        public ClassCreator AddProperties(string propertyName, Type propertyType)
        {
            var backingField = new CodeMemberField(propertyType, "_" + propertyName);
            _targetClass.Members.Add(backingField);

            // Declare the read-only Width property.
            var memberProperty = new CodeMemberProperty
            {
                Attributes = MemberAttributes.Public | MemberAttributes.Final,
                Name = propertyName,
                HasGet = true,
                HasSet = true,
                Type = new CodeTypeReference(propertyType)
            };

            memberProperty.GetStatements.Add(new CodeMethodReturnStatement(
                new CodeFieldReferenceExpression(
                    new CodeThisReferenceExpression(), "_" + propertyName)));

            memberProperty.SetStatements.Add(
                new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_" + propertyName),
                    new CodePropertySetValueReferenceExpression())
                );

            _targetClass.Members.Add(memberProperty);

            return this;
        }

        // Creates the codedom expression for a class variable, and attaches it to the given type.
        public static void Emit(CodeTypeDeclaration codeTypeDeclaration, ClassVariable classVariable)
        {
            var codeField = new CodeMemberField();
            codeTypeDeclaration.Members.Add(codeField);
            codeField.Name = classVariable.Name;
            codeField.Type = new CodeTypeReference(classVariable.TypeName);

            // Translate it's accessibility
            var attr = MemberAttributes.Public;
            switch(classVariable.Accessibility)
            {
                case Accessibility.Internal:
                    attr = MemberAttributes.FamilyAndAssembly;
                    break;
                case Accessibility.Private:
                    attr = MemberAttributes.Private;
                    break;
                case Accessibility.Protected:
                    attr = MemberAttributes.Family;
                    break;
            }

            // shared = static
            if (classVariable.IsShared)
                attr |= MemberAttributes.Static;

            // Final = const
            if (classVariable.IsFinal)
                attr |= MemberAttributes.Const;

            codeField.Attributes = attr;
        }

		protected internal override void CreateMethods ()
		{
			CodeMemberField fld;
			CodeMemberProperty prop;

			/* override the following abstract PageTheme properties:
			   protected abstract string AppRelativeTemplateSourceDirectory { get; }
			   protected abstract IDictionary ControlSkins { get; }
			   protected abstract string[] LinkedStyleSheets { get; }
			*/

			/* ControlSkins */
			fld = new CodeMemberField (typeof (HybridDictionary), "__controlSkins");
			fld.Attributes = MemberAttributes.Private;
			fld.InitExpression = new CodeObjectCreateExpression (typeof (HybridDictionary));
			mainClass.Members.Add (fld);

			prop = new CodeMemberProperty ();
			prop.Name = "ControlSkins";
			prop.Attributes = MemberAttributes.Family | MemberAttributes.Override;
			prop.Type = new CodeTypeReference (typeof (IDictionary));
			prop.GetStatements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("__controlSkins")));
			mainClass.Members.Add (prop);

			/* LinkedStyleSheets */
			fld = new CodeMemberField (typeof (string[]), "__linkedStyleSheets");
			fld.Attributes = MemberAttributes.Private;
			fld.InitExpression = CreateLinkedStyleSheets ();
			mainClass.Members.Add (fld);

			prop = new CodeMemberProperty ();
			prop.Name = "LinkedStyleSheets";
			prop.Attributes = MemberAttributes.Family | MemberAttributes.Override;
			prop.Type = new CodeTypeReference (typeof (string[]));
			prop.GetStatements.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("__linkedStyleSheets")));
			mainClass.Members.Add (prop);

			/* AppRelativeTemplateSourceDirectory */
			prop = new CodeMemberProperty ();
			prop.Name = "AppRelativeTemplateSourceDirectory";
			prop.Attributes = MemberAttributes.Family | MemberAttributes.Override;
			prop.Type = new CodeTypeReference (typeof (string));
			prop.GetStatements.Add (new CodeMethodReturnStatement (
							new CodePrimitiveExpression (
								VirtualPathUtility.ToAbsolute (parser.BaseVirtualDir))));
			mainClass.Members.Add (prop);

			ControlBuilder builder = parser.RootBuilder;
			if (builder.Children != null) {
				foreach (object o in builder.Children) {
					if (! (o is ControlBuilder))
						continue;
					if (o is CodeRenderBuilder)
						continue;
					
					ControlBuilder b = (ControlBuilder) o;
					CreateControlSkinMethod (b);
				}
			}
		}

        // Generates a codedom enumeration and attaches it to the given namespace.
        public static void Emit(CodeNamespace codeNamespace, Pie.Expressions.Enum e)
        {
            // CodeTypeDeclaration is the CodeDOM representation of a
            // class, struct, or enum.
            var codeTypeDeclaration = new CodeTypeDeclaration();
            codeNamespace.Types.Add(codeTypeDeclaration);

            // Assign the unqualified name (without namespace).
            codeTypeDeclaration.Name = e.UnqualifiedName;

            // Flag the type as an enum.
            codeTypeDeclaration.IsEnum = true;

            // Set the accessibility of the enum.
            switch (e.Accessibility)
            {
                case Accessibility.Internal:
                    codeTypeDeclaration.TypeAttributes = TypeAttributes.NestedAssembly;
                    break;
                case Accessibility.Public:
                    codeTypeDeclaration.TypeAttributes = TypeAttributes.Public;
                    break;
            }

            // Translate the list of constants in the enum
            foreach(var c in e.Constants)
            {
                var f = new CodeMemberField(e.UnqualifiedName, c.Name);
                f.InitExpression = new CodePrimitiveExpression(c.Value);
                codeTypeDeclaration.Members.Add(f);
            }
        }

        public CodeTypeDeclaration CreateClass()
        {
            CodeTypeDeclaration declaration = new CodeTypeDeclaration(_sqlDataProviderHelperClassName);

            declaration.IsClass = true;
            declaration.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
            declaration.BaseTypes.Add(typeof(ISqlDataProviderHelper));

            foreach (string keyFieldName in _dataTypeDescriptor.KeyPropertyNames)
            {
                string fieldName = CreateDataIdPropertyInfoFieldName(keyFieldName);

                CodeMemberField codeField = new CodeMemberField(new CodeTypeReference(typeof(PropertyInfo)), fieldName);
                codeField.InitExpression =
                    new CodeMethodInvokeExpression(
                        new CodeMethodReferenceExpression(
                            new CodeTypeReferenceExpression(typeof(IDataExtensions)),
                            "GetDataPropertyRecursivly"
                        ),
                        new CodeExpression[] {
                                new CodeTypeOfExpression(_entityClassName),
                                new CodePrimitiveExpression(keyFieldName)
                            }
                    );

                declaration.Members.Add(codeField);
            }

            AddGetDataByIdMethod(declaration);
            AddAddDataMethod(declaration);
            AddRemoveDataMethod(declaration);

            return declaration;
        }

        private void AddMemberAttributeDeclaration(CodeMemberField field, string jsonName)
        {
            if (this.serializationModel == SerializationModel.DataContractJsonSerializer)
            {
                CodeAttributeDeclaration attr = new CodeAttributeDeclaration(
                    new CodeTypeReference(typeof(DataMemberAttribute)));
                if (field.Name != jsonName)
                {
                    attr.Arguments.Add(new CodeAttributeArgument("Name", new CodePrimitiveExpression(jsonName)));
                }

                field.CustomAttributes.Add(attr);
            }
            else if (this.serializationModel == SerializationModel.JsonNet)
            {
                CodeAttributeDeclaration attr = new CodeAttributeDeclaration(
                    new CodeTypeReference(typeof(JsonPropertyAttribute)));
                if (field.Name != jsonName)
                {
                    attr.Arguments.Add(new CodeAttributeArgument("PropertyName", new CodePrimitiveExpression(jsonName)));
                }

                field.CustomAttributes.Add(attr);
            }
            else
            {
                throw new ArgumentException("Invalid serialization model");
            }
        }

        private static void GenerateCSharpCode(Entity entity, string path)
        {
            var targetUnit = new CodeCompileUnit();
            var targetNamespace = new CodeNamespace(entity.FullName.Substring(0, entity.FullName.LastIndexOf('.')));
            targetNamespace.Imports.Add(new CodeNamespaceImport("System"));
            var targetClass = new CodeTypeDeclaration(entity.FullName.Substring(entity.FullName.LastIndexOf('.') + 1))
            {
                IsClass = true,
                IsPartial = true,
                TypeAttributes = TypeAttributes.Public
            };
            targetNamespace.Types.Add(targetClass);
            targetUnit.Namespaces.Add(targetNamespace);

            foreach (var property in entity.Properties)
            {
                CodeTypeReference propertyType;
                if (property.IsNavigable)
                {
                    propertyType = new CodeTypeReference(typeof(List<>));
                    propertyType.TypeArguments.Add((string)RemapTypeForCSharp(property.Type));
                }
                else
                {
                    propertyType = new CodeTypeReference(RemapTypeForCSharp(property.Type));
                }

                var backingField = new CodeMemberField(propertyType, "_" + property.Name) {Attributes = MemberAttributes.Private};

                if (property.IsNavigable)
                    backingField.InitExpression = new CodeObjectCreateExpression(propertyType);

                targetClass.Members.Add(backingField);

                var codeProperty = new CodeMemberProperty
                {
                    Attributes = MemberAttributes.Public | MemberAttributes.Final,
                    Name = property.Name,
                    HasGet = true,
                    HasSet = true,
                    Type = propertyType,
                };
                codeProperty.GetStatements.Add(new CodeMethodReturnStatement(
                    new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name)));
                codeProperty.SetStatements.Add(
                    new CodeAssignStatement(
                        new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), backingField.Name),
                        new CodeVariableReferenceExpression("value")));

                targetClass.Members.Add(codeProperty);
            }

            var provider = CodeDomProvider.CreateProvider("CSharp");
            var options = new CodeGeneratorOptions {BracingStyle = "C"};
            using (var writer = new StreamWriter(Path.Combine(path, entity.FullName + '.' + provider.FileExtension)))
            {
                provider.GenerateCodeFromCompileUnit(targetUnit, writer, options);
            }
        }

 internal static void AddCallbackDeclaration(CodeTypeMemberCollection members, string callbackMember)
 {
     CodeMemberField field = new CodeMemberField {
         Type = new CodeTypeReference(typeof(SendOrPostCallback)),
         Name = callbackMember
     };
     members.Add(field);
 }