示例#1
0
        protected CodeExpression GenerateSingleton(CodeTypeDeclaration @class, CodeTypeReference type, string fieldName, CodeExpression initializer)
        {
            var cctor = Declare.Constructor( ).Static( )
                        .AddComment(SingletonBeforeFieldInitComment);

            if (CodeDomProvider.Supports(GeneratorSupport.NestedTypes))
            {
                var lazyType = Declare.NestedClass(fieldName).Private( ).Static( )
                               .AddTo(@class);

                cctor.AddTo(lazyType);

                Declare.Field(type, SingletonFieldName).Internal( ).Static( )
                .Initialize(initializer)
                .AddTo(lazyType);

                return(Code.Type(fieldName).Local( )
                       .Static( )
                       .Field(SingletonFieldName));
            }
            else
            {
                Declare.Field(type, fieldName).Private( ).Static( )
                .Initialize(initializer)
                .AddTo(@class);

                if ([email protected] <CodeTypeConstructor> ( ).Any( ))
                {
                    @class.Members.Add(cctor);
                }

                return(Code.Static( ).Field(fieldName));
            }
        }
示例#2
0
    public static CodeMemberField AddField(this CodeTypeDeclaration type, string fieldName, CodeTypeReference fieldType, CodeExpression init = null)
    {
        var field = Declare.Field(fieldName, fieldType);

        if (init != null)
        {
            field.InitExpression = init;
        }
        return(type.AddMember(field));
    }
示例#3
0
        private static CodeTypeDeclaration Build(string className, MemberAttributes memberAttributes, IList <ResourceMapping> map, string extensionType, bool generateConstructors, string bindingType, CodeAttributeDeclaration bindingTypeConverter)
        {
            var type = Declare.Class(className + "Extension")
                       .Modifiers(memberAttributes);
            var keyEnum = Declare.NestedEnum(ResourceKeyEnumName)
                          .Modifiers(memberAttributes)
                          .AddSummary(ResourceKeyEnumNameSummary)
                          .AddTo(type);
            var keyEnumType = Code.Type(ResourceKeyEnumName).Local( );
            var objectType  = Code.Type <object> ( );

            type.BaseTypes.Add(Code.Type(extensionType, Code.NestedType(type.Name, ResourceKeyEnumName).Local( )));

            if (generateConstructors)
            {
                var distinctNumberOfArguments = map.Select(mapping => mapping.NumberOfArguments)
                                                .DefaultIfEmpty(0)
                                                .Distinct( )
                                                .OrderBy(numberOfArguments => numberOfArguments);

                foreach (var numberOfArguments in distinctNumberOfArguments)
                {
                    var ctor = new CodeConstructor( )
                    {
                        Attributes = memberAttributes
                    }.AddTo(type);

                    for (var argument = 0; argument < numberOfArguments; argument++)
                    {
                        var parameterName = Format(CultureInfo.InvariantCulture, FormatMethodParameterName, argument);

                        ctor.Parameters.Add(objectType.Parameter(parameterName));
                        ctor.BaseConstructorArgs.Add(Code.Variable(parameterName));
                    }
                }
            }

            var keyPathType = Code.Type(bindingType);

            var _key     = Code.This( ).Field("_key");
            var _keyPath = Code.This( ).Field("_keyPath");
            var _type    = Code.This( ).Field("_type");

            Declare.Field(keyEnumType, _key.FieldName).AddTo(type);
            Declare.Property(keyEnumType, "Key").Public( ).Override( )
            .Get(get => get.Return(_key))
            .Set((set, value) => set.Add(Code.Assign(_key, value)))
            .AddTo(type);


            Declare.Field(keyPathType, _keyPath.FieldName).AddTo(type);
            Declare.Property(keyPathType, "KeyPath").Public( ).Override( )
            .Get(get => get.Return(_keyPath))
            .Set((set, value) => set.Add(Code.Assign(_keyPath, value)))
            .Attributed(bindingTypeConverter)
            .AddTo(type);

            Declare.Field <Type> (_type.FieldName).AddTo(type);
            Declare.Property <Type> ("Type").Public( ).Override( )
            .Get(get => get.Return(_type))
            .Set((set, value) => set.Add(Code.Assign(_type, value)))
            .AddTo(type);

            Declare.Property(Code.Type <ILocalizer> ( ), "Localizer").Protected( ).Override( )
            .Get(get => get.Return(Code.Type(className).Local( ).Static( ).Property(LocalizerPropertyName)))
            .AddTo(type);

            var translation = new CodeArrayCreateExpression(Code.Type <string> ( ));
            var index       = 0;

            foreach (var mapping in map)
            {
                Declare.Field(keyEnumType, mapping.Property).Const( )
                .Modifiers(memberAttributes)
                .Initialize(Code.Constant(index++))
                .AddSummary(ResourceKeyFieldSummaryFormat, mapping.Resource.Name)
                .AddTo(keyEnum);

                translation.Initializers.Add(Code.Constant(mapping.Resource.Name));
            }

            var translator = Declare.Field <string []> (ResourceKeyTranslatorFieldName).Static( )
                             .Initialize(translation)
                             .AddTo(type);

            var translate = Declare.Method <string> ("KeyToName",
                                                     MemberAttributes.Family | MemberAttributes.Override)
                            .AddTo(type);

            var key   = Code.Variable(ResourceKeyParameterName);
            var first = keyEnumType.Static( ).Field(map [0].Property);
            var last  = keyEnumType.Static( ).Field(map [index - 1].Property);

            translate.Parameters.Add(keyEnumType.Parameter(ResourceKeyParameterName));
            translate.Statements.Add(Code.If(key.IsLessThan(first).Or(
                                                 key.IsGreaterThan(last)))
                                     .Then(Code.Throw <ArgumentOutOfRangeException> (Code.Constant(ResourceKeyParameterName))));
            translate.Statements.Return(Code.Static( )
                                        .Field(ResourceKeyTranslatorFieldName)
                                        .Indexer(Code.Variable(ResourceKeyParameterName).Cast <int> ( )));

            return(type);
        }
示例#4
0
        protected virtual void GenerateClassMembers(CodeTypeDeclaration @class)
        {
            var editorBrowsable      = Declare.Attribute <EditorBrowsableAttribute> (Code.Constant(EditorBrowsableState.Advanced));
            var notifyCultureChanged = (CodeExpression)null;

            var ctor = Declare.Constructor( )
                       .AddSummary(ConstructorSummaryFormat, settings.ClassName)
                       .Attributed(Declare.Attribute <SuppressMessageAttribute> ("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode"))
                       .AddTo(@class);

            if (settings.AccessModifiers.HasBitMask(MemberAttributes.Static))
            {
                ctor.Private( );
            }
            else
            {
                ctor.Modifiers(settings.AccessModifiers);
            }

            if ((settings.Options & ResourceTypeOptions.CultureChangedEvent) == ResourceTypeOptions.CultureChangedEvent)
            {
                GenerateCultureChangedEvent(@class, out notifyCultureChanged);
            }

            var resourceManager = GenerateSingleton(@class,
                                                    settings.ResourceManagerType,
                                                    ResourceManagerFieldName,
                                                    settings.ResourceManagerInitializer);

            if (settings.LocalizerType != null)
            {
                var localizer = GenerateSingleton(@class,
                                                  settings.LocalizerType,
                                                  LocalizerFieldName,
                                                  settings.LocalizerInitializer);

                Declare.Property(settings.LocalizerType, LocalizerPropertyName).Static( )
                .Modifiers(settings.AccessModifiers)
                .Get(get => get.Return(localizer))
                .AddSummary(LocalizerPropertySummary)
                .AddTo(@class);
            }

            Declare.Property(settings.ResourceManagerType, ResourceManagerPropertyName).Static( )
            .Modifiers(settings.AccessModifiers)
            .Get(get => get.Return(resourceManager))
            .AddSummary(ResourceManagerPropertySummary)
            .Attributed(editorBrowsable)
            .AddTo(@class);

            var cultureField = Declare.Field <CultureInfo> (CultureInfoFieldName)
                               .Modifiers(settings.AccessModifiers & MemberAttributes.Static)
                               .AddTo(@class);

            var field = @class.Instance( ).Field(CultureInfoFieldName);

            Declare.Property <CultureInfo> (CultureInfoPropertyName)
            .Modifiers(settings.AccessModifiers)
            .Get(get => get.Return(field))
            .Set((set, value) =>
            {
                set.Add(Code.If(field.ObjectEquals(value))
                        .Then(Code.Return( )));
                set.Add(field.Assign(value));
                if (notifyCultureChanged != null)
                {
                    set.Add(notifyCultureChanged);
                }
            })
            .AddSummary(CultureInfoPropertySummary)
            .Attributed(editorBrowsable)
            .AddTo(@class);
        }