Home / Questions / 304194
Accepted
D. Albarracín
Asked: 2020-10-29 08:22:27 +0800 CST 2020-10-29 08:22:27 +0800 CST

Question regarding MVVM C# ​​- RaiseProperty

  • 772

I'm trying to fully understand the MVVM topic, and some of its methods. I have seen the method RaiseProperty()in two different ways and I don't understand what the difference is.

This would be one:

    public void RaiseProperty([CallerMemberName] string propertyName = "")
    {                       
    }

And the other directly does not have the [CallerMemberName].

I've been reading about it [CallerMemberName]and it says it's to receive the name of the method that calls it.

And one of my doubts: Why know the name of the method that invokes it?

Then another thing that I don't quite understand is what is incorporated, in this case, by the method RaisePropertyin my exercise:

    public void RaiseProperty([CallerMemberName] string propertyName = "")
    {            
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));            
    }

What is it doing ?, and what is it used for .Invoke()?

c#

1 Answers

  1. Best Answer

    Let's go point by point

    Why know the name of the method that calls it?

    As stated in the documentation, the CallerMemberName attribute allows you to avoid literal strings. To focus on the MVVM architecture, it is usual for a class to implement the interface INotifyPropertyChangedas follows:

    public class MiClase : INotifyPropertyChanged
{
   private string nombre;

   public string Nombre
   {
       get => nombre;
       set
       {
           if (value != nombre)
           {
               nombre = value;
               RaiseProperty("Nombre");
           }    
       }    
    }
}

    Where the method RaisePropertyis defined similar to the following:

    private void RaiseProperty(string nombrePropiedad)
{
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nombrePropiedad));
}

    Well, what if you later want to change the name of the property, let's say instead of Nombreit being NombreCompleto. The change will not affect the literal strings as it happens inside the property setter , when the method is called: RaiseProperty("Nombre");, resulting in the code not compiling. That is why the attribute is used CallerMemberNameto avoid using string literals.

    However, the use of this attribute in the MVVM architecture is already somewhat obsolete since from version 6.0 of the C# language there is an operator nameofthat allows obtaining the name of the variables, methods or types at compile time. Then, a more current implementation of the INotifyPropertyChanged interface would be something like:

    public class MiClase : INotifyPropertyChanged
{
   private string nombre;

   public string Nombre
   {
       get => nombre;
       set
       {
           if (value != nombre)
           {
               nombre = value;
               RaiseProperty(nameof(Nombre));
           }    
       }    
    }
}

    By referencing the property name instead of using a literal string, name changes are no longer an issue.

    What is the ? doing, and what is the .Invoke() used for?

    The symbol ?.is the null conditional operator and is a syntactic sugar that is valid as of C# 6.0 to avoid comparing an object to the value nulland works like the ternary operator ?:. Suppose we have A?.Metodo(), if it Ais different from nullthen the method is called, ie , A.Metodo()but if it Ais nullthen the result is nullalso.

    Focusing on the implementation of the method RaiseProperty, instead of doing

    if (PropertyChanged != null)
{
    PropertyChanged(this, new PropertyChangedEventArgs(nombrePropiedad));
}

    the null conditional operator is used: PropertyChanged?.Invoke()in such a way that the code is more compact and easier to understand (the latter is debatable). Finally, the method Invokeis a method that allows events to be fired, as in this particular case with the event PropertyChanged.

    • 1