private CSharpGatewayExpressionBinder(CodeGenerationContext codeGenerationContext)
        {
            this.CodeGenerationContext = codeGenerationContext;

            this.httpClientType = FickleType.Define(this.CodeGenerationContext.Options.ServiceClientTypeName ?? "HttpClient");
            this.httpStreamSerializerType = FickleType.Define("IHttpStreamSerializer");
        }

 /// <summary>
 /// Constructor for the custom code generator
 /// </summary>
 /// <param name="context">Context of the current code generation operation based on how scaffolder was invoked(such as selected project/folder) </param>
 /// <param name="information">Code generation information that is defined in the factory class.</param>
 public ElementGenerator(
     CodeGenerationContext context,
     CodeGeneratorInformation information)
     : base(context, information)
 {
     _viewModel = new ElementViewModel();
 }

 /// <summary>
 /// Constructor for the custom code generator
 /// </summary>
 /// <param name="context">Context of the current code generation operation based on how scaffolder was invoked(such as selected project/folder) </param>
 /// <param name="information">Code generation information that is defined in the factory class.</param>
 public CustomCodeGenerator(
     CodeGenerationContext context,
     CodeGeneratorInformation information)
     : base(context, information)
 {
     _viewModel = new CustomViewModel(Context);
 }

 protected PropertiesToCopyExpressionBinder(CodeGenerationContext codeGenerationContext, Type type, Expression zone, Expression theCopy)
 {
     this.codeGenerationContext = codeGenerationContext;
     this.type = type;
     this.zone = zone;
     this.theCopy = theCopy;
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="context">The code generation context</param>
        public CustomViewModel(CodeGenerationContext context)
        {
            this.Context = context;

            // we typically name our custom binding handlers like this
            this.CustomBindingHandlerName = "yourBindingHandler";

            // not sure on this one, we'll set it as a global dependency by default, if for nothing other than convenience 
            this.IncludeAsGlobalDependency = true;

            // normally we dont generate unit tests for a custom binding handler, only if we're being thorough
            this.GenerateUnitTests = false;

            // we normally don't have less files for a custom binding handler, so set this to off as default
            this.GenerateLessFile = false;

            // if we do want a less file, we'll probably want that imported
            this.ImportLessFile = true;

            this.CreateInitCallback = true;

            this.CreateUpdateCallback = false;


            this.MasterLessFilePath = @"src\css\all-components.less";

            this.UnitTestModuleLocation = @"src\test\all-tests.ts";

            this.RootPathForBindingHandler = @"src\bindingHandlers\";

            this.UnitTestCreationLocation = @"src\test\bindingHandlers\";

            this.PathForAmdDependency = @"src/app/startup.ts";
            
        }

        internal static IEnumerable<IVsPackageMetadata> GetInstalledPackages(CodeGenerationContext context)
        {
            var packageInstallerServices = context.ServiceProvider
                .GetService<IComponentModel, SComponentModel>().GetService<IVsPackageInstallerServices>();

            return packageInstallerServices.GetInstalledPackages(context.ActiveProject);
        }

 /// <summary>
 /// Constructor for the custom code generator
 /// </summary>
 /// <param name="context">Context of the current code generation operation based on how scaffolder was invoked(such as selected project/folder) </param>
 /// <param name="information">Code generation information that is defined in the factory class.</param>
 public FieldGenerator(
     CodeGenerationContext context,
     CodeGeneratorInformation information)
     : base(context, information)
 {
     _viewModel = new FieldViewModel();
 }

        private static bool IsApplicableProject(CodeGenerationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (ProjectLanguage.CSharp == context.ActiveProject.GetCodeLanguage())
            {
                FrameworkName targetFramework = null;

                // GetTargetFramework() may:
                // 1) Throw an exception if TargetFramework string is not valid during the internal parsing.
                // 2) Return null if the active project is not null but the TargetFrameworkMoniker is null.
                //
                // Both of them fall into the case in which the mvc scaffolding does not support the target framework.
                try
                {
                    targetFramework = context.ActiveProject.GetTargetFramework();
                }
                catch
                {
                    return false;
                }

                if (targetFramework != null &&
                    targetFramework.Identifier == ".NETFramework" && targetFramework.Version >= new Version(4, 5))
                {
                    return true;
                }
            }

            return false;
        }

        public static Expression Bind(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression, ParameterExpression zone, ParameterExpression theCopy)
        {
            var builder = new PropertiesToCopyExpressionBinder(codeGenerationContext, expression.Type, zone, theCopy);

            builder.Visit(expression);

            return builder.statements.ToStatementisedGroupedExpression();
        }

        public static Expression Build(TypeDefinitionExpression expression, CodeGenerationContext context)
        {
            var builder = new PropertiesToDictionaryExpressionBinder(expression.Type, context);

            builder.Visit(expression);

            return builder.propertySetterExpressions.ToStatementisedGroupedExpression(GroupedExpressionsExpressionStyle.Wide);
        }

        public static Type GetWrappedResponseType(CodeGenerationContext context, Type type)
        {
            if (TypeSystem.IsPrimitiveType(type) ||  type is FickleListType)
            {
                return context.ServiceModel.GetServiceType(GetValueResponseWrapperTypeName(type));
            }

            return type;
        }

        /// <summary>
        /// Provides a way to check if the custom scaffolder is valid under this context
        /// </summary>
        /// <param name="codeGenerationContext">The code generation context</param>
        /// <returns>True if valid, False otherwise</returns>
        public override bool IsSupported(CodeGenerationContext codeGenerationContext)
        {
            if (codeGenerationContext.ActiveProject.CodeModel.Language != EnvDTE.CodeModelLanguageConstants.vsCMLanguageCSharp)
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="context">The code generation context</param>
        public CustomViewModel(CodeGenerationContext context)
        {
            Context = context;
            ICodeTypeService codeTypeService = (ICodeTypeService)Context.ServiceProvider.GetService(typeof(ICodeTypeService));

            this.ModelTypes = codeTypeService.GetAllCodeTypes(Context.ActiveProject)
                //.Where(codeType => codeType.IsValidWebProjectEntityType())
                                            .Where(codeType => codeType.IsDerivedType("System.Web.Http.ApiController"))
                                            .Select(codeType => new ModelType(codeType));
        }

        protected ScaffolderModel(CodeGenerationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            Context = context;
            ServiceProvider = context.ServiceProvider;
        }

        public FrameworkDependencyStatus EnsureDependencyInstalled(CodeGenerationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ODataDependencyInstaller dependencyInstaller = new ODataDependencyInstaller(context, VisualStudioIntegration);
            return dependencyInstaller.Install();
        }

        protected override void GenerateGateway(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression)
        {
            using (var writer = this.GetTextWriterForFile(expression.Type.Name + ".java"))
            {
                var classFileExpression = GatewayExpressionBinder.Bind(codeGenerationContext, expression);

                var codeGenerator = new JavaCodeGenerator(writer);

                codeGenerator.Generate(classFileExpression);
            }
        }

        protected override void GenerateEnum(CodeGenerationContext codeGenerationContext, TypeDefinitionExpression expression)
        {
            using (var writer = this.GetTextWriterForFile(expression.Type.Name + ".h"))
            {
                var enumFileExpression = EnumHeaderExpressionBinder.Bind(codeGenerationContext, expression);

                var codeGenerator = new ObjectiveCodeGenerator(writer);

                codeGenerator.Generate(enumFileExpression);
            }
        }

        // We support CSharp WAPs targetting at least .Net Framework 4.5 or above.
        // We DON'T currently support VB
        public override bool IsSupported(CodeGenerationContext codeGenerationContext)
        {
            if (ProjectLanguage.CSharp.Equals(codeGenerationContext.ActiveProject.GetCodeLanguage()) )
            {
                FrameworkName targetFramework = codeGenerationContext.ActiveProject.GetTargetFramework();
                return (targetFramework != null) &&
                        String.Equals(".NetFramework", targetFramework.Identifier, StringComparison.OrdinalIgnoreCase) &&
                        targetFramework.Version >= new Version(4, 5);
            }

            return false;
        }

        private static bool DisplayScaffolders(CodeGenerationContext context, string projectReferenceName, Version minVersion, Version maxExcludedVersion)
        {
            if (IsApplicableProject(context))
            {
                var referenceDetails = IsValidProjectReference(context, projectReferenceName, minVersion, maxExcludedVersion);

                // We want to show when the reference exists and is of supported version
                // or when the reference does not exist.
                return referenceDetails != ReferenceDetails.ReferenceVersionNotSupported;
            }

            return false;
        }

        public bool IsDependencyInstalled(CodeGenerationContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            bool isODataRestierAssemblyReferenced = ProjectReferences.IsAssemblyReferenced(context.ActiveProject, AssemblyVersions.ODataRestierAssemblyName);
            context.Items[ContextKeys.IsODataRestierAssemblyReferencedKey] = isODataRestierAssemblyReferenced;

            bool isEntityFrameworkAssemblyReferenced = ProjectReferences.IsAssemblyReferenced(context.ActiveProject, AssemblyVersions.EntityFrameworkAssemblyName);
            context.Items[ContextKeys.IsEntityFrameworkAssemblyReferencedKey] = isEntityFrameworkAssemblyReferenced;

            return isODataRestierAssemblyReferenced && isEntityFrameworkAssemblyReferenced;
        }