new progress

Author: codingseb

CodingSeb.Localization.FodyAddin.Fody/CodingSeb.Localization.FodyAddin.Fody.csproj

@@ -6,4 +6,7 @@
   <ItemGroup>
     <PackageReference Include="FodyHelpers" Version="6.3.0" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CodingSeb.Localization\CodingSeb.Localization.csproj" />
+  </ItemGroup>
 </Project>

CodingSeb.Localization.FodyAddin.Fody/ModuleWeaver.cs

@@ -39,10 +39,29 @@ private void AddCurrentLanguageChangedSensitivity(TypeDefinition typeDefinition)
 
             FieldDefinition propertyListFieldDefinition = AddLocalizedPropertyNamesStaticList(typeDefinition, propertyToLocalize.Select(p => p.Name));
 
+            MethodDefinition triggerPropertyChangedMethod = typeDefinition.FindPropertyChangedTriggerMethod();
+
+            if (triggerPropertyChangedMethod == null)
+            {
+                triggerPropertyChangedMethod = new MethodDefinition("__NotifyPropertyChanged__", MethodAttributes.Private, TypeSystem.VoidReference);
+                triggerPropertyChangedMethod.Parameters.Add(new ParameterDefinition("propertyName", ParameterAttributes.None, ModuleDefinition.ImportReference(typeof(string))));
+                typeDefinition.Methods.Add(triggerPropertyChangedMethod);
+
+                // TODO
+            }
+
             var method = new MethodDefinition("__CurrentLanguageChanged__", MethodAttributes.Private, TypeSystem.VoidReference);
+            method.Parameters.Add(new ParameterDefinition("sender", ParameterAttributes.None, TypeSystem.ObjectReference));
+            method.Parameters.Add(new ParameterDefinition("e", ParameterAttributes.None, ModuleDefinition.ImportReference(typeof(CurrentLanguageChangedEventArgs))));
             ILProcessor processor = method.Body.GetILProcessor();
-            processor.Append(Instruction.Create(OpCodes.Ldstr, "Hello World"));
-            processor.Append(Instruction.Create(OpCodes.Ret));
+            processor.Emit(OpCodes.Nop);
+            processor.Emit(OpCodes.Ldsfld, propertyListFieldDefinition);
+            processor.Emit(OpCodes.Ldarg_0);
+            processor.Emit(OpCodes.Ldftn, triggerPropertyChangedMethod);
+            processor.Emit(OpCodes.Newobj, ModuleDefinition.ImportReference(typeof(Action<string>).GetConstructors().First()));
+            processor.Emit(OpCodes.Callvirt, ModuleDefinition.ImportReference(typeof(List<string>).GetMethod("ForEach", new Type[] { typeof(Action<string>) })));
+            processor.Emit(OpCodes.Nop);
+            processor.Emit(OpCodes.Ret);
             typeDefinition.Methods.Add(method);
         }
 
@@ -56,37 +75,37 @@ public FieldDefinition AddLocalizedPropertyNamesStaticList(TypeDefinition typeDe
 
             typeDefinition.Fields.Add(field);
 
-            MethodDefinition staticConstructor = GetOrCreateStaticConstructor(typeDefinition);
+            MethodDefinition staticConstructor = typeDefinition.GetStaticConstructor();
+
+            if (staticConstructor == null)
+            {
+                staticConstructor = new MethodDefinition(".cctor", staticConstructorAttributes, TypeSystem.VoidReference);
+                typeDefinition.Methods.Add(staticConstructor);
+            }
 
-            var il = staticConstructor.Body.GetILProcessor();
+            var instructions = staticConstructor.Body.Instructions;
 
-            if (il.Body.Instructions.LastOrDefault(i => i.OpCode == OpCodes.Ret) is Instruction instruction)
+            if (instructions.LastOrDefault(i => i.OpCode == OpCodes.Ret) is Instruction instruction)
             {
-                il.Remove(instruction);
+                instructions.Remove(instruction);
             }
 
-            il.Emit(OpCodes.Newobj, constructorOnStringList);
+            instructions.Add(Instruction.Create(OpCodes.Newobj, constructorOnStringList));
 
-            //propertiesNames.ToList().ForEach(propertyName =>
-            //{
-            //    instructions.Add(Instruction.Create(OpCodes.Dup));
-            //    instructions.Add(Instruction.Create(OpCodes.Ldstr, propertyName));
-            //    instructions.Add(Instruction.Create(OpCodes.Callvirt, addMethodOnStringList));
-            //});
+            propertiesNames.ToList().ForEach(propertyName =>
+            {
+                instructions.Add(Instruction.Create(OpCodes.Dup));
+                instructions.Add(Instruction.Create(OpCodes.Ldstr, propertyName));
+                instructions.Add(Instruction.Create(OpCodes.Callvirt, addMethodOnStringList));
+            });
 
-            il.Emit(OpCodes.Stsfld, field);
+            instructions.Add(Instruction.Create(OpCodes.Stsfld, field));
 
-            il.Emit(OpCodes.Ret);
+            instructions.Add(Instruction.Create(OpCodes.Ret));
 
             return field;
         }
 
-        public MethodDefinition GetOrCreateStaticConstructor(TypeDefinition typeDefinition)
-        {
-            return typeDefinition.GetStaticConstructor() ??
-                new MethodDefinition(".cctor", staticConstructorAttributes, TypeSystem.VoidReference);
-        }
-
         public override IEnumerable<string> GetAssembliesForScanning()
         {
             yield return "netstandard";

CodingSeb.Localization.FodyAddin.Tests/WeaverTests.cs

@@ -25,15 +25,17 @@ public void ValidateThatPropertyWithLocalizeAttributeIsUpdateWhenLanguageChanged
             var type = testResult.Assembly.GetType("CodingSeb.Localization.AssemblyToProcess.LocalizedWithFodyClass");
 
             FieldInfo propertyNamesField = type.GetField("__localizedPropertyNames__", BindingFlags.NonPublic | BindingFlags.Static);
+            MethodInfo languageChangedMethod = type.GetMethod("__CurrentLanguageChanged__", BindingFlags.NonPublic | BindingFlags.Instance);
 
             Assert.NotNull(propertyNamesField);
+            Assert.NotNull(languageChangedMethod);
 
             var instance = (dynamic)Activator.CreateInstance(type);
 
             List<string> listOfPropertyNames = propertyNamesField.GetValue(instance) as List<string>;
 
             Assert.NotNull(listOfPropertyNames);
-            Assert.Contains("TestPropertya", listOfPropertyNames);
+            Assert.Contains("TestProperty", listOfPropertyNames);
 
             INotifyPropertyChanged notifyPropertyChanged = instance as INotifyPropertyChanged;
 
@@ -46,9 +48,13 @@ void NotifyPropertyChanged_PropertyChanged(object sender, PropertyChangedEventAr
 
             notifyPropertyChanged.PropertyChanged += NotifyPropertyChanged_PropertyChanged;
 
+            languageChangedMethod.Invoke(instance, new object[] { Loc.Instance, new CurrentLanguageChangedEventArgs("en", "fr") });
+            Assert.Equal("TestProperty", propertyName);
+
+            propertyName = string.Empty;
+
             notifyPropertyChanged.PropertyChanged -= NotifyPropertyChanged_PropertyChanged;
 
-            //Assert.Equal("TestProperty" ,propertyName);
         }
     }
 }