Пример #1
0
 public BuildInfo <T> Mapping <TR>(Func <TR, object> func)
 {
     MethodInformation.Delegates.Add(func);
     CurrentMethod.Mapping = new MappingAttribute(typeof(TR));
     CurrentMethod         = BuilderHelper.CompleteMethodInfo(typeof(T), CurrentMethod);
     MethodInformations.Add(CurrentMethod);
     return(this);
 }
Пример #2
0
        protected static void FillBuilderHelper(TypeDefinition type, PropertyDefinition property, BuilderHelper builderHelper)
        {
            builderHelper.IsArray = property.PropertyType.IsArray;
            builderHelper.IsComplexType = IsComplexType(property.PropertyType.Resolve());

            FillBuilderHelperXml(type, property, builderHelper);
            FillBuilderHelperData(type, property, builderHelper);
        }
Пример #3
0
        private void AnalyseBuilder(SymbolAnalysisContext context, INamedTypeSymbol builderSymbol, INamedTypeSymbol builderForSymbol)
        {
            IList <IFieldSymbol> fieldsWithoutSetterMethods = BuilderHelper.FindFieldsWithoutSetterMethodInBuilder(builderSymbol, builderForSymbol);

            foreach (IFieldSymbol fieldWithoutSetterMethod in fieldsWithoutSetterMethods)
            {
                context.ReportFieldHasNoSetterInBuilder(fieldWithoutSetterMethod);
            }
        }
Пример #4
0
 public void Build(System.Collections.Generic.List <string> scenesToBuild, UnityEditor.BuildTarget buildTarget, UnityEditor.BuildOptions buildOptions)
 {
     Console.WriteLine("ios PreBuild");
     BuilderHelper.BootSceneFilename = "Assets/Scenes/Boot/Boot.unity";
     BuilderHelper.BuildInsidePlayer(ref scenesToBuild, ref buildTarget, ref buildOptions, this);
     InJoy.UnityBuildSystem.AutoBuild.UnityBuildPlayer(scenesToBuild, buildTarget, buildOptions);
     AssetBundlesFtp.GenerateIndexSizeMapToFile("assetBundlesSizeFile.txt");
     Console.WriteLine("ios PostBuild");
 }
Пример #5
0
 /// <summary>
 /// Sets the minimum log level to show to the user
 /// </summary>
 /// <returns></returns>
 public static IApplicationBuilder UseLogger(this IApplicationBuilder builder,
                                             LoggerOptions options)
 {
     builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.LoggerBuildAction((container) =>
     {
         BuilderHelper.RegisterLoggers(options, container);
     }));
     return(builder);
 }
Пример #6
0
        private static Function ConvolutionWithActivation(Variable features, DeviceDescriptor device,
                                                          ConvolutionConfigurationModel configuration)
        {
            var convFunction = Convolution(features, device, configuration);
            var convWithActivationFunction =
                BuilderHelper.GetActivationFunction(configuration.ActivationFunction, convFunction);

            return(convWithActivationFunction);
        }
Пример #7
0
    public void Cmd_InstantiateBuilding(NetworkHash128 prefabId, int builderId, Vector3 position)
    {
        GameObject go       = Instantiate(PrefabIdHelper.IdGoBuilding[prefabId], position, Quaternion.identity, _world.transform);
        Attackable building = go.GetComponent <Attackable>();

        building.CreatorId  = BuilderId;
        building.Allegiance = BuilderHelper.GetBuilderById(BuilderId).Allegiance;
        building.IsActive   = true;

        NetworkServer.Spawn(go);
    }
        Ensure_When_We_Configure_An_Authorizer_With_A_Post_Build_Action_The_Resolver_Returns_An_Authorizer_That_Has_Had_The_Action_Executed_Against_It
            ()
        {
            var conf = BuilderHelper.BuildConfigurationObject();

            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).AuthorizedBy <HasRoles>(r => r.AuthorizedRoles = new[] { "Test" }));

            var resolver   = BuildAuthorizerResolver(conf.ActivityRegistrations);
            var authorizer = (HasRoles)resolver.GetAuthorizers(new MethodActivity(typeof(TestCodeClass).GetMethod("DoSomething"))).First();

            Assert.That(authorizer.AuthorizedRoles.First(), Is.EqualTo("Test"));
        }
        Ensure_When_We_Register_The_Method_Of_A_Base_Class_We_Can_Resolve_The_Activity_With_An_Expression_Using_The_Child_Class
            ()
        {
            var conf = BuilderHelper.BuildConfigurationObject();

            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).As <TestActivity>().AuthorizedBy <UnauthorizedAuthorizer>());

            var resolver = BuildActivityResolver(conf.ActivityRegistrations);
            var act      = resolver.GetActivity <TestChildClass>(c => c.DoSomething("test"));

            Assert.That(act is TestActivity);
        }
        Ensure_If_We_Provide_A_Specific_Name_For_An_Activity_Registered_By_Method_The_Name_Is_Correctly_Set_On_The_Resolved_Activity
            ()
        {
            var conf = BuilderHelper.BuildConfigurationObject();

            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).Name("TestActivity").AuthorizedBy <AllowAnonymous>());

            var resolver = BuildActivityResolver(conf.ActivityRegistrations);
            var activity = resolver.GetActivity <TestCodeClass>(c => c.DoSomething("test"));

            Assert.That(activity.Name, Is.EqualTo("TestActivity"));
        }
        Ensure_When_We_Register_A_Method_As_A_Specific_Activity_Type_Ensure_When_We_Resolve_By_Lamdba_Expression_The_Method_Parameters_Are_Used_In_The_Type_Constructor
            ()
        {
            var conf = BuilderHelper.BuildConfigurationObject();

            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).As <TestActivity>().AuthorizedBy <UnauthorizedAuthorizer>());

            var resolver = BuildActivityResolver(conf.ActivityRegistrations);
            var act      = (TestActivity)resolver.GetActivity <TestCodeClass>(c => c.DoSomething("test"));

            Assert.That(act.Id, Is.EqualTo("test"));
        }
Пример #12
0
    new private void Start()
    {
        base.Start();

        attack = new Attack(0, 1.0f, this, 10, (Targetable attackable) => TargetingFunction.IsEnemy(this, attackable))
        {
            Effects = new List <Effect> {
                new FaithKill(new ResourceFaith(1), BuilderHelper.GetBuilderById(this.CreatorId), TargetingFunction.IsUnit)
            }
        };
        Skills = new[] { attack };
    }
        public void Ensure_We_Can_Resolve_An_Activity_By_Expression_With_A_Variable()
        {
            var conf = BuilderHelper.BuildConfigurationObject();

            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).As <TestActivity>().AuthorizedBy <UnauthorizedAuthorizer>());

            var resolver = BuildActivityResolver(conf.ActivityRegistrations);
            var test     = "test";
            var activity = (TestActivity)resolver.GetActivity <TestCodeClass>(c => c.DoSomething(test));

            Assert.That(activity.Id, Is.EqualTo("test"));
        }
Пример #14
0
 public static void Analyze(IDbConnection connection)
 {
     if (!connection.ToString().Contains("System.Data.SqlClient"))
     {
         throw new InvalidOperationException("Only Sql Server is supported.");
     }
     BuilderHelper.BuildSchemas(connection);
     BuilderHelper.BuildTables(connection);
     BuilderHelper.BuildTableColumns(connection);
     BuilderHelper.BuildViewColumns(connection);
     BuilderHelper.BuildRelation(connection);
 }
Пример #15
0
        virtual public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
        {
            BuilderHelper.CheckParameter("ClassName", itemData);
            BuilderHelper.CheckParameter("Caption", itemData);
            BuilderHelper.CheckParameter("Sort", itemData);
            string restrictionGroup; // optional

            if (itemData.Attributes.TryGetValue("RestrictionGroup", out restrictionGroup))
            {
                ServiceRegistration.Get <IUserManagement>().RegisterRestrictionGroup(restrictionGroup);
            }
            return(_constructor(plugin.GetPluginType(itemData.Attributes["ClassName"]), itemData.Attributes["Caption"], itemData.Attributes["Sort"], restrictionGroup, itemData.Id));
        }
Пример #16
0
        private static Function Dense(Variable input, int outputDim, DeviceDescriptor device,
                                      ActivationFunction activationFunction, string outputName)
        {
            if (input.Shape.Rank != 1)
            {
                var newDim = input.Shape.Dimensions.Aggregate((d1, d2) => d1 * d2);
                input = CNTKLib.Reshape(input, new [] { newDim });
            }

            var fullyConnected = FullyConnectedLinearLayer(input, outputDim, device, outputName);

            return(BuilderHelper.GetActivationFunction(activationFunction, fullyConnected));
        }
        Ensure_That_If_A_Method_Activity_Has_Been_Registered_With_The_Allow_Anonymous_Authorizer_That_Is_The_Only_One_The_Authorizer_Resolver_Returns
            ()
        {
            var conf = BuilderHelper.BuildConfigurationObject();

            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).AuthorizedBy <UnauthorizedAuthorizer>());
            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).AuthorizedBy <AllowAnonymous>());

            var resolver    = BuildAuthorizerResolver(conf.ActivityRegistrations);
            var authorizers = resolver.GetAuthorizers(new MethodActivity(typeof(TestCodeClass).GetMethod("DoSomething")));

            Assert.That(authorizers.Count, Is.EqualTo(1));
        }
Пример #18
0
        // At the moment, we simply use an InstanceBuilder here. In the future, we could provide the option to
        // give a set of supported file extensions in the player builder item registration, which can be evaluated before
        // requesting the player builder -> lazy load the player builders on request
        public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
        {
            BuilderHelper.CheckParameter("ClassName", itemData);
            int    priority = 0;
            string prioString;

            if (itemData.Attributes.TryGetValue("Priority", out prioString))
            {
                int.TryParse(prioString, out priority);
            }

            return(new PlayerBuilderWrapper(itemData.Id, plugin.InstantiatePluginObject(itemData.Attributes["ClassName"]) as IPlayerBuilder, priority));
        }
Пример #19
0
        public void Ensure_That_The_Failure_Manager_Assigns_A_404_Result_To_An_Unauthorizer_Activity_Registered_By_Name_With_A_404_Handler()
        {
            var conf = BuilderHelper.BuildConfigurationBuilder();

            conf.Register(a => a.Name("Test").AuthorizedBy <UnauthorizedAuthorizer>().HandleFailureWith <HttpNotFoundResult>());

            var context = FilterContextHelper.ContextFromExpression <TestController>(c => c.ControllerAction("test"));

            var manager = new AuthorizationFailureManager(conf.ActivityRegistrations);

            manager.HandleFailedAuthorization(new NamedActivity("Test"), context);
            Assert.That(context.Result.GetType(), Is.EqualTo(typeof(HttpNotFoundResult)));
        }
        Ensure_That_If_Two_Methods_Are_Registered_To_The_Same_Activity_With_The_Same_Authorizer_And_An_ActivityType_The_Authorizer_Is_Returned_Correctly_By_The_Resolver
            ()
        {
            var builder = BuilderHelper.BuildConfigurationObject();

            builder.RegisterEach <TestCodeClass>(c => c.DoSomething(""), c => c.DoSomething2("")).With(a => a.As <TestActivity>().AuthorizedBy <UnauthorizedAuthorizer>());

            var resolver    = BuildAuthorizerResolver(builder.ActivityRegistrations);
            var authorizer1 = resolver.GetAuthorizers <TestCodeClass>(c => c.DoSomething("")).First();
            var authorizer2 = resolver.GetAuthorizers <TestCodeClass>(c => c.DoSomething2("")).First();

            Assert.That(authorizer1.GetType(), Is.EqualTo(typeof(UnauthorizedAuthorizer)));
            Assert.That(authorizer2.GetType(), Is.EqualTo(typeof(UnauthorizedAuthorizer)));
        }
        public void Ensure_When_We_Register_A_Method_Activity_By_Name_We_Can_Resolve_Is_Authorizer()
        {
            var conf = BuilderHelper.BuildConfigurationObject();

            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).Name("TestActivity").AuthorizedBy <UnauthorizedAuthorizer>());

            var resolver   = BuildAuthorizerResolver(conf.ActivityRegistrations);
            var authorizer = resolver.GetAuthorizers(new MethodActivity(typeof(TestCodeClass).GetMethod("DoSomething"))
            {
                Name = "TestActivity"
            }).First();

            Assert.That(authorizer is UnauthorizedAuthorizer);
        }
Пример #22
0
        public override void BuildCode(Builder builder)
        {
            base.BuildCode(builder);

            builder.AppendLine("{0} {1}", this.Type, this.Name);

            builder.AppendLine("{");
            builder.EnterBlock();
            if (this.Getter != null)
            {
                builder.Append(BuilderHelper.ModifiersToString(this.Getter.Modifiers));
                builder.Append("get");
                string body = this.Getter.Body.ToString();
                if (body.Length == 0)
                {
                    builder.AppendLine("; ");
                }
                else
                {
                    builder.AppendLine();
                    builder.AppendLine("{");
                    builder.EnterBlock();
                    builder.Append(body);
                    builder.LeaveBlock();
                    builder.AppendLine("}");
                }
            }
            if (this.Setter != null)
            {
                builder.Append(BuilderHelper.ModifiersToString(this.Setter.Modifiers));
                builder.Append("set");
                string body = this.Setter.Body.ToString();
                if (body.Length == 0)
                {
                    builder.AppendLine("; ");
                }
                else
                {
                    builder.AppendLine();
                    builder.AppendLine("{");
                    builder.EnterBlock();
                    builder.Append(body);
                    builder.LeaveBlock();
                    builder.AppendLine("}");
                }
            }
            builder.LeaveBlock();
            builder.AppendLine("}");
        }
Пример #23
0
        internal FilterBuilder(BuilderHelper helper)
        {
            this.helper = helper;

            Expressions = new Dictionary <Operation, Func <Expression, Expression, Expression, Expression> >
            {
                { Operation.EqualTo, (member, constant, constant2) => Expression.Equal(member, constant) },
                { Operation.NotEqualTo, (member, constant, constant2) => Expression.NotEqual(member, constant) },
                { Operation.GreaterThan, (member, constant, constant2) => Expression.GreaterThan(member, constant) },
                {
                    Operation.GreaterThanOrEqualTo,
                    (member, constant, constant2) => Expression.GreaterThanOrEqual(member, constant)
                },
                { Operation.LessThan, (member, constant, constant2) => Expression.LessThan(member, constant) },
                {
                    Operation.LessThanOrEqualTo,
                    (member, constant, constant2) => Expression.LessThanOrEqual(member, constant)
                },
                { Operation.Contains, (member, constant, constant2) => Contains(member, constant) },
                {
                    Operation.StartsWith,
                    (member, constant, constant2) => Expression.Call(member, startsWithMethod, constant)
                },
                {
                    Operation.EndsWith,
                    (member, constant, constant2) => Expression.Call(member, endsWithMethod, constant)
                },
                { Operation.Between, (member, constant, constant2) => Between(member, constant, constant2) },
                { Operation.In, (member, constant, constant2) => Contains(member, constant) },
                {
                    Operation.IsNull,
                    (member, constant, constant2) => Expression.Equal(member, Expression.Constant(null))
                },
                {
                    Operation.IsNotNull,
                    (member, constant, constant2) => Expression.NotEqual(member, Expression.Constant(null))
                },
                {
                    Operation.IsEmpty,
                    (member, constant, constant2) => Expression.Equal(member, Expression.Constant(string.Empty))
                },
                {
                    Operation.IsNotEmpty,
                    (member, constant, constant2) => Expression.NotEqual(member, Expression.Constant(string.Empty))
                },
                { Operation.IsNullOrWhiteSpace, (member, constant, constant2) => IsNullOrWhiteSpace(member) },
                { Operation.IsNotNullNorWhiteSpace, (member, constant, constant2) => IsNotNullNorWhiteSpace(member) }
            };
        }
        public void Ensure_We_Can_Resolve_A_Named_Activity_By_Name()
        {
            var config = BuilderHelper.BuildConfigurationObject();

            var resolver = BuildActivityResolver(new List <ActivityRegistration>()
            {
                new ActivityRegistration
                {
                    ActivityName = "Activity"
                }
            });
            var activity = resolver.GetActivity("Activity");

            Assert.That(activity.Name, Is.EqualTo("Activity"));
        }
        Ensure_When_We_Register_Two_Methods_With_The_Same_As_The_Same_Activity_Type_We_Can_Resolve_Each_Individually
            ()
        {
            var conf = BuilderHelper.BuildConfigurationObject();

            conf.Register(a => a.Method <TestCodeClass>(c => c.DoSomething(default(string))).As <TestActivity>().AuthorizedBy <UnauthorizedAuthorizer>());
            conf.Register(a => a.Method <TestCodeClass2>(c => c.DoSomething(default(string))).As <TestActivity>().AuthorizedBy <UnauthorizedAuthorizer>());

            var resolver = BuildActivityResolver(conf.ActivityRegistrations);
            var act1     = resolver.GetActivity <TestCodeClass>(c => c.DoSomething("test"));
            var act2     = resolver.GetActivity <TestCodeClass2>(c => c.DoSomething("test"));

            Assert.That(act1 is TestActivity);
            Assert.That(act2 is TestActivity);
        }
Пример #26
0
    void ClickUpgrade(GameObject upgrade)
    {
        Builder Creator = NetworkHelper.IsOffline ? BuilderHelper.GetBuilderById(Building.CreatorId) : NetworkHelper.Builder;

        if (!Creator.CanPayBuilding(upgrade.GetComponent <IBuildingCost>()))
        {
            // Proc not enough money message
        }
        else
        {
            Creator.PayBuilding(upgrade.GetComponent <IBuildingCost>());
            GameObject previousBuilding = this.Building.gameObject;
            InstantiateBuilding(upgrade, Creator, previousBuilding);
            Destroy(previousBuilding);
        }
    }
Пример #27
0
        public void FreezeReference(TableModel table, IEnumerable <TableModel> tables)
        {
            ReferenceTable = tables.FirstOrDefault(t => t.Property.Name == _referenceTable.Name);

            if (ReferenceTable == null)
            {
                throw BuilderError.SelectorNotMappedToTable(_referenceTable.Name, _referenceTable.DeclaringType.Name).AsException();
            }

            ReferenceColumns = _referenceColumns.MatchColumns(ReferenceTable.Name, ReferenceTable.Columns).ToImmutableArray();

            // If the name was not explicitly set then we generate one based on the table and column names
            if (Name == null)
            {
                Name = BuilderHelper.GenerateForeignKeyName(table.Schema, table.Name, KeyColumns.Select(c => c.Name), ReferenceTable.Schema, ReferenceTable.Name);
            }
        }
Пример #28
0
        Ensure_When_We_Call_The_Authorize_Method_And_Handle_Failures_With_An_Unauthorized_ActionExecutingContext_The_Context_Result_Is_Set_To_The_Registered_Failure_Manager
            ()
        {
            //arrange
            var conf    = BuilderHelper.BuildConfigurationBuilder();
            var context = FilterContextHelper.ContextFromExpression <TestController>(c => c.ControllerAction("test"));

            conf.Register(a => a.Method <TestController>(c => c.ControllerAction(default(string))).AuthorizedBy <UnauthorizedAuthorizer>().HandleFailureWith <HttpNotFoundResult>());

            var service = BuilderHelper.ServiceBuilder(conf);

            //act
            service.Authorize(context, new TestPrincipal(), true);

            //assert
            Assert.That(context.Result.GetType(), Is.EqualTo(typeof(HttpNotFoundResult)));
        }
Пример #29
0
    public void Build(System.Collections.Generic.List <string> scenesToBuild, UnityEditor.BuildTarget buildTarget, UnityEditor.BuildOptions buildOptions)
    {
        Console.WriteLine("ios_binary_with_special_bundle begin");

        BuilderHelper.BootSceneFilename = "Assets/Scenes/Boot/PreBoot.unity";
        const int basicSceneCount = 7;

        if (scenesToBuild.Count > basicSceneCount)
        {
            scenesToBuild.RemoveRange(basicSceneCount, scenesToBuild.Count - basicSceneCount);
        }
        BuilderHelper.CleanStreamingAssets();
        BuilderHelper.Build(ref scenesToBuild, ref buildTarget, ref buildOptions, this, "index", null, false);
        BuilderHelper.CopyToStreamingAssets();

        InJoy.UnityBuildSystem.AutoBuild.UnityBuildPlayer(scenesToBuild, buildTarget, buildOptions);
        Console.WriteLine("ios_binary_with_special_bundle end");
    }
        public void Deve_gerar_os_arquivos_de_sitemap()
        {
            List <Url> urls = new List <Url>();

            urls.Add(BuilderHelper.UrlBuilder(ChangeFreq.always, null, DateTime.Now, string.Empty, 0.9m));
            urls.Add(BuilderHelper.UrlBuilder(ChangeFreq.always, null, DateTime.Now, string.Empty, 0.9m));

            SitemapEngine engine = new SitemapEngine()
            {
                UrlSite       = "www.code4dev.net",
                Urls          = urls,
                SitemapPath   = @"C:\",
                SitemapName   = "code4dev",
                MaxUrlSitemap = 10
            };

            engine.Builder();
        }
        public object BuildItem(PluginItemMetadata itemData, PluginRuntime plugin)
        {
            BuilderHelper.CheckParameter("ClassName", itemData);
            BuilderHelper.CheckParameter("Filter", itemData);
            // Support for simplified escaping inside XML tag
            string        filter = itemData.Attributes["Filter"].Replace("{", "<").Replace("}", ">");
            FilterWrapper wrapper;

            if (_serializer == null)
            {
                _serializer = new XmlSerializer(typeof(FilterWrapper));
            }

            using (var reader = new StringReader(filter))
                wrapper = (FilterWrapper)_serializer.Deserialize(reader);

            return(new MediaNavigationFilter(itemData.Attributes["ClassName"], wrapper.Filter));
        }
Пример #32
0
        private static void FillBuilderHelperXml(TypeDefinition type, PropertyDefinition property, BuilderHelper builderHelper)
        {
            if (type.Properties.Count(p => p.Name == property.Name + XmlAttributeConstants.SpecifiedPostFix) == 1)
            {
                //optional field
                builderHelper.Xml.IsOptional = true;
            }

            var xmlTypeAttribute = property.DeclaringType.CustomAttributes.FirstOrDefault(x => x.AttributeType.FullName == XmlAttributeConstants.XmlTypeAttribute);
            if (xmlTypeAttribute != null)
            {
                builderHelper.Xml.Namespace = GetNamespaceXml(xmlTypeAttribute, builderHelper.Xml.Namespace);
            }

            var xmlAttributeAttribute = property.CustomAttributes.FirstOrDefault(x => x.AttributeType.FullName == XmlAttributeConstants.XmlAttributeAttribute);
            if (xmlAttributeAttribute != null)
            {
                builderHelper.Xml.UsesAttribute = true;

                builderHelper.Xml.Name = GetAttributeName(xmlAttributeAttribute, builderHelper.Xml.Name);
            }

            var xmlElementAttribute = property.CustomAttributes.FirstOrDefault(x => x.AttributeType.FullName == XmlAttributeConstants.XmlElementAttribute);
            if (xmlElementAttribute != null)
            {
                builderHelper.Xml.Name = GetElementName(xmlElementAttribute, builderHelper.Xml.Name);
                builderHelper.Xml.DataType = GetDataType(xmlElementAttribute, builderHelper.Xml.DataType);
            }

            var xmlArrayItemAttribute = property.CustomAttributes.FirstOrDefault(x => x.AttributeType.FullName == XmlAttributeConstants.XmlArrayItemAttribute);
            if (xmlArrayItemAttribute != null)
            {
                builderHelper.Xml.ArrayItemName = GetElementName(xmlArrayItemAttribute, builderHelper.Xml.ArrayItemName);
            }
        }
Пример #33
0
 private static void FillBuilderHelperData(TypeDefinition type, PropertyDefinition property, BuilderHelper builderHelper)
 {
     var dataMemberAttribute = property.CustomAttributes.FirstOrDefault(x => x.AttributeType.FullName == DataAttributeConstants.DataMemberAttribute);
     if (dataMemberAttribute != null)
     {
         builderHelper.Data.Name = GetName(dataMemberAttribute, builderHelper.Data.Name);
         builderHelper.Data.Namespace = GetNamespaceData(dataMemberAttribute, builderHelper.Data.Namespace);
         builderHelper.Data.EmitDefaultValue = GetEmitDefaultValue(dataMemberAttribute, builderHelper.Data.EmitDefaultValue);
         builderHelper.Data.IsRequired = GetIsRequired(dataMemberAttribute, builderHelper.Data.IsRequired);
         builderHelper.Data.Order = GetOrder(dataMemberAttribute, builderHelper.Data.Order);
     }
 }