Пример #1
0
        public async void ConstructTranslationKeysType(OperationMode mode, string targetTranslationKey, string keysFilePath, string[] catalogFilePaths)
        {
            await Task.Run(() =>
            {
                var targetUnit = new CodeCompileUnit();

                var translationKeysClass = new CodeTypeDeclaration(TranslationKeysGeneratedTypeName)
                {
                    IsClass        = true,
                    TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed
                };

                LocalizationEditorData.GeneratedNamespace.Types.Add(translationKeysClass);
                targetUnit.Namespaces.Add(LocalizationEditorData.GeneratedNamespace);

                //Add existing translation keys to generated field
                foreach (var existingTranslationKey in TranslationKeysType.GetFields().Where(f => f.FieldType == typeof(string)))
                {
                    //Skip a key in order to delete it
                    if (mode == OperationMode.Delete && existingTranslationKey.Name == LocalizationEditorWindow.FormatStringForFieldName(targetTranslationKey))
                    {
                        continue;
                    }

                    translationKeysClass.Members.Add(new CodeMemberField
                    {
                        Type           = new CodeTypeReference(typeof(string)),
                        Attributes     = MemberAttributes.Public | MemberAttributes.Const,
                        Name           = existingTranslationKey.Name,
                        InitExpression = new CodePrimitiveExpression(existingTranslationKey.GetValue(existingTranslationKey))
                    });
                }

                if (mode == OperationMode.Add)
                {
                    //Add new translation key to generated field
                    translationKeysClass.Members.Add(new CodeMemberField
                    {
                        Type           = new CodeTypeReference(typeof(string)),
                        Attributes     = MemberAttributes.Public | MemberAttributes.Const,
                        Name           = LocalizationEditorWindow.FormatStringForFieldName(targetTranslationKey),
                        InitExpression = new CodePrimitiveExpression(LocalizationEditorWindow.FormatStringForTranslationKey(targetTranslationKey))
                    });
                }

                var taskList = new List <Task>
                {
                    Task.Run(() => GenerateTypeFile(keysFilePath, targetUnit))
                };

                foreach (var catalogFilePath in catalogFilePaths)
                {
                    taskList.Add(Task.Run(() => UpdateTranslationCatalogKeys(catalogFilePath, targetTranslationKey, mode)));
                }

                Task.WaitAll(taskList.ToArray());
            });

            _localizationEditorWindow.SetRunning();
        }
      public async void ConstructSupportedLanguagesTypeFile(string targetLanguage, string outputTypeFilePath, string outputCatalogPath, OperationMode mode)
      {
          await Task.Run(() =>
            {
                var targetUnit = new CodeCompileUnit();

                _supportedLanguagesClass = new CodeTypeDeclaration(SupportedLanguagesGeneratedTypeName)
                {
                    IsClass        = true,
                    TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed
                };

                LocalizationEditorData.GeneratedNamespace.Types.Add(_supportedLanguagesClass);
                targetUnit.Namespaces.Add(LocalizationEditorData.GeneratedNamespace);

                var fieldArrayInfo = SupportedLanguagesType.GetField(SupportedLanguagesFieldArrayName);

                var fieldArray = fieldArrayInfo.GetValue(fieldArrayInfo) as string[];

                //Add new language to the type being constructed
                if (mode == OperationMode.Add)
                {
                    var fieldList = fieldArray.ToList();
                    fieldList.Add(targetLanguage);
                    fieldArray = fieldList.ToArray();
                }

                _supportedLanguagesClass.Members.Add(new CodeMemberField
                {
                    Type           = new CodeTypeReference(typeof(string[])),
                    Attributes     = MemberAttributes.Public | MemberAttributes.Static,
                    Name           = SupportedLanguagesFieldArrayName,
                    InitExpression = new CodeArrayCreateExpression(new CodeTypeReference(typeof(string)),
                                                                   fieldArray
                                                                   .Where(l => l != targetLanguage || mode != OperationMode.Delete)
                                                                   .Select(l => new CodePrimitiveExpression(l))
                                                                   .ToArray())
                });

                GenerateTypeFile(outputTypeFilePath, targetUnit);

                GenerateTranslationCatalog(outputCatalogPath, mode);
            });

          _localizationEditorWindow.SetRunning();
      }