protected virtual CodeTypeDeclaration GenerateClass(CodeNamespace @namespace) { var generator = typeof(ResourceTypeBuilder); var version = generator.Assembly.GetName( ).Version; var type = Declare.Class(settings.ClassName) .Modifiers(settings.AccessModifiers) .IsPartial(CodeDomProvider.Supports(GeneratorSupport.PartialTypes)) .AddSummary(ClassSummary) .AddTo(@namespace); if (settings.CustomToolType != null) { type.AddRemarks(ClassRemarksFormat, generator.FullName, settings.CustomToolType.Name); } else { type.AddRemarks(ClassRemarksToollessFormat, generator.FullName); } if (string.Equals(@namespace.Name.Split('.').Last( ), settings.ClassName, StringComparison.OrdinalIgnoreCase)) { type.Attributed(Declare.Attribute <SuppressMessageAttribute> ("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces")); } return(type.Attributed(Declare.Attribute <GeneratedCodeAttribute> (generator.FullName, version.ToString( )), Declare.Attribute <DebuggerNonUserCodeAttribute> ( ), Declare.Attribute <ObfuscationAttribute> ( ) .WithArgument(nameof(ObfuscationAttribute.Exclude), true) .WithArgument(nameof(ObfuscationAttribute.ApplyToMembers), true))); }
private static CodeTypeDeclaration WPF(string className, MemberAttributes memberAttributes, IList <ResourceMapping> map) { return(Build(className, memberAttributes, map, "Linguist.WPF.TypedLocalizeExtension", true, "System.Windows.Data.BindingBase", Declare.Attribute <TypeConverterAttribute> (Code.TypeOf(Code.NestedType("Linguist.WPF.BindingSyntax", "TypeConverter"))))); }
private static CodeTypeDeclaration XamarinForms(string className, MemberAttributes memberAttributes, IList <ResourceMapping> map) { return(Build(className, memberAttributes, map, "Linguist.Xamarin.Forms.TypedLocalizeExtension", false, "Xamarin.Forms.BindingBase", Declare.Attribute(Code.Type("Xamarin.Forms.TypeConverterAttribute"), Code.TypeOf(Code.NestedType("Linguist.Xamarin.Forms.BindingSyntax", "TypeConverter"))))); }
public static CodeAttributeDeclaration WithAttribute <TMember, TAttribute> (this TMember member, params CodeAttributeArgument[] arguments) where TMember : CodeTypeMember => member.AddAttribute(Declare.Attribute <TAttribute> (arguments));
public static CodeAttributeDeclaration WithAttribute <TMember, TAttribute> (this TMember member) where TMember : CodeTypeMember => member.AddAttribute(Declare.Attribute <TAttribute> ());
public static CodeAttributeDeclaration AddAttribute <T> (this T member, CodeTypeReference attributeType, params CodeAttributeArgument[] arguments) where T : CodeTypeMember => member.AddAttribute(Declare.Attribute(attributeType, arguments));
public static CodeAttributeDeclaration AddAttribute <T> (this T member, CodeTypeReference attributeType) where T : CodeTypeMember => member.AddAttribute(Declare.Attribute(attributeType));
public static CodeParameterDeclarationExpression Params(this CodeParameterDeclarationExpression parameter) => parameter.WithAttribute(Declare.Attribute(TypeReference.ParamArrayAttribute));
protected virtual CodeMemberMethod GenerateFormatMethod(ResourceMapping mapping) { var resource = mapping.Resource; var numberOfArguments = mapping.NumberOfArguments; if (numberOfArguments <= 0) { throw new ArgumentOutOfRangeException(nameof(numberOfArguments), numberOfArguments, "Number of argument must be greater than zero"); } var localizer = (CodeExpression)null; if (settings.LocalizerType != null) { localizer = Code.Static( ).Property(LocalizerPropertyName); } var format = Code.Type <string> ( ).Static( ).Method(nameof(string.Format)); var formatExpression = (CodeExpression)Code.Instance(settings.AccessModifiers).Property(mapping.Property); if (localizer != null) { format = localizer.Method(nameof(ILocalizer.Format)); formatExpression = Code.Constant(resource.Name); } var summary = Format(FormatMethodSummary, GeneratePreview((string)resource.Value)); var formatMethod = Declare.Method <string> (mapping.FormatMethod, settings.AccessModifiers) .AddSummary(summary + FormatResourceComment(resource.Comment)); var objectType = Code.Type <object> ( ); var start = localizer != null ? 3 : 2; var parameters = new CodeExpression [start + numberOfArguments]; parameters [0] = Code.Instance(settings.AccessModifiers).Field(CultureInfoFieldName); parameters [1] = formatExpression; if (localizer != null) { parameters [2] = parameters [1]; parameters [1] = parameters [0]; } for (var index = 0; index < numberOfArguments; index++) { var parameterName = Format(CultureInfo.InvariantCulture, FormatMethodParameterName, index); formatMethod.Parameters.Add(objectType.Parameter(parameterName)); parameters [start + index] = Code.Variable(parameterName); if (numberOfArguments > 1) { formatMethod.AddParameterComment(parameterName, FormatMultiParameterComment, Ordinals [Math.Min(index, Ordinals.Length - 1)]); } else { formatMethod.AddParameterComment(parameterName, FormatParameterComment, index); } } if (numberOfArguments > 3) { formatMethod.Attributed(Declare.Attribute <SuppressMessageAttribute> ("Microsoft.Design", "CA1025:ReplaceRepetitiveArgumentsWithParamsArray")); } return(formatMethod.Define(method => method.Return(format.Invoke(parameters))) .AddReturnComment(FormatReturnComment)); }
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); }