Naming Properties in MVVM

I use a helper class to get property names based on expressions

    public static class ObservableHelper
    {
        public static PropertyChangedEventArgs CreateArgs<t>(Expression<func><t,>> propertyExpression)
        {
            return new PropertyChangedEventArgs(GetPropertyName<t>(propertyExpression));
        }

        public static string GetPropertyName<t>(Expression<func><t,>> propertyExpression)
        {
            var lambda = propertyExpression as LambdaExpression;
            MemberExpression memberExpression;
            if (lambda.Body is UnaryExpression)
            {
                var unaryExpression = lambda.Body as UnaryExpression;
                memberExpression = unaryExpression.Operand as MemberExpression;
            }
            else
            {
                memberExpression = lambda.Body as MemberExpression;
            }

            if (memberExpression == null)
            {
                throw new InvalidOperationException("Lambda expression not in the correct format, use format like '() => PropertyName'");
            }

            var propertyInfo = memberExpression.Member as PropertyInfo;
            return propertyInfo.Name;
        }
    }

I can call this in my class to create the PropertyChangedEventArgs, but to keep reflection calls to a minimum I declare them as static readonly fields, so for example:

public class CustomersViewModel : INotifyPropertyChanged
    {
        private static readonly PropertyChangedEventArgs idArgs = ObservableHelper.CreateArgs<customersviewmodel>(x => x.Id);
        private static readonly PropertyChangedEventArgs nameArgs = ObservableHelper.CreateArgs<customersviewmodel>(x => x.Name);
        
        private int id;
        private string name;

        public int Id
        {
            get { return this.id; }
            set
            {
                if (this.id != value)
                {
                    this.id = value;
                    this.OnPropertyChanged(idArgs);
                }
            }
        }

        public string Name
        {
            get { return this.name; }
            set
            {
                if (this.name != value)
                {
                    this.name = value;
                    this.OnPropertyChanged(nameArgs);
                }
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;

        public void OnPropertyChanged(PropertyChangedEventArgs args)
        {
            if (this.PropertyChanged != null) 
            {
                this.PropertyChanged(this, args);
            }
        }
    }

I don't really know if the reflection calls are really a huge performance loss in this, but no more magical strings and save to rename properties. - Edited because I remembered that this is something I saw in Cinch framework from Sacha Barber, so all credit should go to him ;-)