/// <summary>Initializes a new instance of the <see cref="PropertyChangedRegistration"/> class.</summary>
        /// <param name="handler">The handler to which all change notifications are forwarded.</param>
        /// <param name="properties">The properties for which change notifications should be forwarded.</param>
        /// <exception cref="ArgumentException">One or more elements of <paramref name="properties"/> equal <c>null</c>.
        /// </exception>
        /// <exception cref="ArgumentNullException"><paramref name="handler"/> and/or <paramref name="properties"/>
        /// equal <c>null</c>.</exception>
        /// <remarks>After construction, each change to one of the properties in <paramref name="properties"/> is
        /// forwarded to <paramref name="handler"/> until <see cref="Dispose"/> is called.</remarks>
        public PropertyChangedRegistration(
            PropertyChangedEventHandler handler, params IProperty<INotifyPropertyChanged>[] properties)
        {
            if (handler == null)
            {
                throw new ArgumentNullException(nameof(handler));
            }

            if (properties == null)
            {
                throw new ArgumentNullException(nameof(properties));
            }

            if (Array.IndexOf(properties, null) >= 0)
            {
                throw new ArgumentException("Array elements cannot be null.", nameof(properties));
            }

            this.handler = handler;
            this.propertyNames = properties.ToLookup(p => p.Owner, p => p.PropertyInfo.Name);

            foreach (var grouping in this.propertyNames)
            {
                grouping.Key.PropertyChanged += this.OnPropertyChanged;
            }
        }

        public static Action Bind(this UISwitch toggle, INotifyPropertyChanged source, string propertyName)
        {
            var property = source.GetProperty(propertyName);

            if (property.PropertyType == typeof(bool))
            {
                toggle.SetValue(source, property);
                var handler = new PropertyChangedEventHandler ((s, e) =>
                {
                    if (e.PropertyName == propertyName)
                    {
                            toggle.InvokeOnMainThread(()=>
                                toggle.SetValue(source, property));
                    }
                });

                source.PropertyChanged += handler;

                var valueChanged = new EventHandler(
                    (sender, e) => property.GetSetMethod().Invoke (source, new object[]{ toggle.On }));

                toggle.ValueChanged += valueChanged;

                return new Action(() =>
                {
                    source.PropertyChanged -= handler;
                    toggle.ValueChanged -= valueChanged;
                });
            } 
            else
            {
                throw new InvalidCastException ("Binding property is not boolean");
            }
        }

        public override void Intercept(IInvocation invocation)
        {
            // WPF will call a method named add_PropertyChanged to subscribe itself to the property changed events of
            // the given entity. The method to call is stored in invocation.Arguments[0]. We get this and add it to the
            // proxy subscriber list.
            if (invocation.Method.Name.Contains("PropertyChanged"))
            {
                PropertyChangedEventHandler propertyChangedEventHandler = (PropertyChangedEventHandler)invocation.Arguments[0];
                if (invocation.Method.Name.StartsWith("add_"))
                {
                    subscribers += propertyChangedEventHandler;
                }
                else
                {
                    subscribers -= propertyChangedEventHandler;
                }
            }

            // Here we call the actual method of the entity
            base.Intercept(invocation);

            // If the method that was called was actually a proeprty setter (set_Line1 for example) we generate the
            // PropertyChanged event for the property but with event generator the proxy. This must do the trick.
            if (invocation.Method.Name.StartsWith("set_"))
            {
                subscribers(invocation.InvocationTarget, new PropertyChangedEventArgs(invocation.Method.Name.Substring(4)));
            }
        }

 public PlayerView()
 {
     InitializeComponent();
     this.DataContextChanged += new DependencyPropertyChangedEventHandler(PlayerInfoView_DataContextChanged);
     _OnPropertyChanged = new PropertyChangedEventHandler(model_PropertyChanged);
     Unloaded += PlayerView_Unloaded;
 }

 public Book(string author, string name, int year, PropertyChangedEventHandler propertyChanged)
 {
     this.author = author;
     this.name = name;
     this.year = year;
     PropertyChanged = propertyChanged;
 }

 public MainPlayerView()
 {
     InitializeComponent();
     this.DataContextChanged += new DependencyPropertyChangedEventHandler(PlayerInfoView_DataContextChanged);
     _OnPropertyChanged = new PropertyChangedEventHandler(model_PropertyChanged);
     handCardArea.OnHandCardMoved += handCardArea_OnHandCardMoved;
 }

        public static PropertyChangedEventHandler Bind(this SeekBar seekBar, INotifyPropertyChanged source, string propertyName)
        {
            var property = source.GetProperty(propertyName);

            var r = property.GetCustomAttribute<RangeAttribute> ();

            if (r != null)
            {
                seekBar.Max = (int)r.Maximum;
            }

            var handler = new PropertyChangedEventHandler ((s, e) =>
                {
                    if (e.PropertyName == propertyName)
                    {
                        //textField.SetText(source, property);
                    }
                });

            source.PropertyChanged += handler;

            //textField.AfterTextChanged += (sender, e) => property.GetSetMethod().Invoke(source, new []{textField.Text});

            return handler;
        }

 public Composition(string path, PropertyChangedEventHandler PropertyChanged)
 {
     this.PropertyChanged += PropertyChanged;
     FileInfo = TagLib.File.Create(path);
     if (FileInfo.Tag.Artists.Length == 0)
         Artists = "Unknown artist";
     else
     {
         foreach (string str in FileInfo.Tag.Artists)
         {
             Artists += str;
             Artists += "; ";
         }
         Artists = Artists.Substring(0, Artists.Length - 2);
     }
     if (FileInfo.Tag.Title == null)
         Title = "Unknown title";
     else
         Title = FileInfo.Tag.Title;
     if (FileInfo.Tag.Album == null)
         Album = "Unknown album";
     else
         Album = FileInfo.Tag.Album;
     Name = FileInfo.Name;
     Image = new BitmapImage();
     Image.BeginInit();
     if (FileInfo.Tag.Pictures.Length != 0)
         Image.StreamSource = new MemoryStream(FileInfo.Tag.Pictures[0].Data.Data);
     else
         Image.UriSource = new Uri("Content\\note-blue.png", UriKind.RelativeOrAbsolute);
     Image.EndInit();
 }

 public object AddPropertyChangedListener( object target, PropertyChangedEventHandler listener ) {
     EventHandler changedHandler = ( sender, args ) => {
         listener.Invoke( this, new PropertyChangedEventArgs( "S" ) );
     };
     ( ( TargetClass ) target ).SChanged += changedHandler;
     return changedHandler;
 }

        /// <summary>
        /// Create a ProfilingTargetView with default values.
        /// </summary>
        public ProfilingTargetView() {
            var solution = NodejsProfilingPackage.Instance.Solution;
            
            var availableProjects = new List<ProjectTargetView>();
            foreach (var project in solution.EnumerateLoadedProjects(onlyNodeProjects: true)) {
                availableProjects.Add(new ProjectTargetView((IVsHierarchy)project));
            }
            _availableProjects = new ReadOnlyCollection<ProjectTargetView>(availableProjects);

            _project = null;
            _standalone = new StandaloneTargetView();
            _isProjectSelected = true;

            _isValid = false;

            PropertyChanged += new PropertyChangedEventHandler(ProfilingTargetView_PropertyChanged);
            _standalone.PropertyChanged += new PropertyChangedEventHandler(Standalone_PropertyChanged);

            var startupProject = NodejsProfilingPackage.Instance.GetStartupProjectGuid();
            Project = AvailableProjects.FirstOrDefault(p => p.Guid == startupProject) ??
                AvailableProjects.FirstOrDefault();
            if (Project != null) {
                IsStandaloneSelected = false;
                IsProjectSelected = true;
            } else {
                IsProjectSelected = false;
                IsStandaloneSelected = true;
            }
            _startText = Resources.ProfilingStart;
        }

        // Constructeur
        public MainPage()
        {
            InitializeComponent();
            this.Language = XmlLanguage.GetLanguage(Thread.CurrentThread.CurrentCulture.Name);
            Failure_Handler = new PropertyChangedEventHandler(FailureOccured);

            _viewModel = DataContext as MainPageVM;
            _viewModel.PropertyChanged += VM_PropertyChanged;

            ViewModelLocator.Client.PropertyChanged += Failure_Handler;

            version_text.Text = Helper.GetVersionNumber();

            ApplicationBar.Buttons.Add(new ApplicationBarIconButton()
            {
                Text = AppLanguage.AppBar_Refresh,
                IconUri = new Uri("/icons/appbar.refresh.rest.png", UriKind.Relative)
            });
            (ApplicationBar.Buttons[0] as ApplicationBarIconButton).Click += Sync_Btn_Click;

            ApplicationBar.MenuItems.Add(new ApplicationBarMenuItem(AppLanguage.AppBar_Settings));
            (ApplicationBar.MenuItems[0] as ApplicationBarMenuItem).Click += SettingsPage_Click;
#if DEBUG
            ApplicationBar.MenuItems.Add(new ApplicationBarMenuItem("[DEV] CLEAR"));
            (ApplicationBar.MenuItems[1] as ApplicationBarMenuItem).Click += DEV_clrDB_Click ;
#endif
        }

 public Student(string name, int age)
 {
     this.args = new ModifiedEventArgs();
     this.onChange += new PropertyChangedEventHandler(ActionPerformed);
     this.Name = name;
     this.Age = age;
 }

 protected internal DefaultableSettings(DefaultSettings defaultSettings, PropertyChangedEventHandler eventHandler = null)
 {
     DefaultSettings = defaultSettings;
     PropertyBag = new PropertyBagCollection<DefaultBoolean>(DefaultBoolean.Default, RaisePropertyChanged);
     if (null != eventHandler)
         this.PropertyChanged += eventHandler;
 }

        /// <summary>
        /// Create a ProfilingTargetView with default values.
        /// </summary>
        public ProfilingTargetView(IServiceProvider serviceProvider) {
            var solution = serviceProvider.GetService(typeof(SVsSolution)) as IVsSolution;
            
            var availableProjects = new List<ProjectTargetView>();
            foreach (var project in solution.EnumerateLoadedProjects()) {
                availableProjects.Add(new ProjectTargetView((IVsHierarchy)project));
            }
            _availableProjects = new ReadOnlyCollection<ProjectTargetView>(availableProjects);

            _project = null;
            _standalone = new StandaloneTargetView(serviceProvider);
            _isProjectSelected = true;

            _isValid = false;

            PropertyChanged += new PropertyChangedEventHandler(ProfilingTargetView_PropertyChanged);
            _standalone.PropertyChanged += new PropertyChangedEventHandler(Standalone_PropertyChanged);

            var startupProject = PythonProfilingPackage.GetStartupProjectGuid(serviceProvider);
            Project = AvailableProjects.FirstOrDefault(p => p.Guid == startupProject) ??
                AvailableProjects.FirstOrDefault();
            if (Project != null) {
                IsStandaloneSelected = false;
                IsProjectSelected = true;
            } else {
                IsProjectSelected = false;
                IsStandaloneSelected = true;
            }
            _startText = "_Start";
        }

 internal OpenFileLocalization(PropertyChangedEventHandler eventHandler = null)
 {
     PropertyBag = new PropertyBagCollection<string>("<Empty>", RaisePropertyChanged);
     Set1033Default(null, new EventArgs());
     if (null != eventHandler)
         this.PropertyChanged += eventHandler;
 }

 public static void RegisterPropertyChanged(this IEnumerable<Param> that, PropertyChangedEventHandler handler)
 {
     foreach (var param in that)
     {
         param.PropertyChanged += handler;
     }
 }

 public BassEngine(PropertyChangedEventHandler PropertyChanged)
 {
     Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero);
     Compositions = new ObservableCollection<Composition>();
     Compositions.CollectionChanged += Compositions_CollectionChanged;
     Volume = 50;
 }

 internal TemplateFoldersSettings(DefaultSettings defaultSettings, PropertyChangedEventHandler eventHandler = null) : base(defaultSettings, eventHandler)
 {
     FolderTemplates = new TemplateFolderDescriptionCollection();
     DontFireEvents = true;
     PropertyBag.Add("Visible", DefaultBoolean.False);
     DontFireEvents = false;
 }

        public StandaloneTargetView(IServiceProvider serviceProvider) {
            var componentService = serviceProvider.GetComponentModel();
            
            var interpreterProviders = componentService.DefaultExportProvider.GetExports<IPythonInterpreterFactoryProvider, Dictionary<string, object>>();
            var interpreterOptions = componentService.GetService<IInterpreterOptionsService>();
            var registry = componentService.GetService<IInterpreterRegistryService>();
            var pythonService = serviceProvider.GetPythonToolsService();

            var availableInterpreters = registry.Configurations.Select(
                config => new PythonInterpreterView(
                    config.Description, 
                    config.Id, 
                    config.InterpreterPath
                )
            ).ToList();

            _customInterpreter = new PythonInterpreterView("Other...", "", null);
            availableInterpreters.Add(_customInterpreter);
            _availableInterpreters = new ReadOnlyCollection<PythonInterpreterView>(availableInterpreters);

            _interpreterPath = null;
            _canSpecifyInterpreterPath = false;
            _scriptPath = null;
            _workingDirectory = null;
            _arguments = null;

            _isValid = false;

            PropertyChanged += new PropertyChangedEventHandler(StandaloneTargetView_PropertyChanged);

            if (IsAnyAvailableInterpreters) {
                var defaultId = interpreterOptions.DefaultInterpreterId;
                Interpreter = AvailableInterpreters.FirstOrDefault(v => v.Id == defaultId);
            }
        }

        private IMethodReturn InvokeINotifyPropertyChangedMethod(IMethodInvocation input)
        {
            if (input.MethodBase.DeclaringType == typeof(INotifyPropertyChanged))
            {
                switch (input.MethodBase.Name)
                {
                    case "add_PropertyChanged":
                        lock (handlerLock)
                        {
                            handler = (PropertyChangedEventHandler)Delegate.Combine(handler, (Delegate)input.Arguments[0]);
                        }
                        break;

                    case "remove_PropertyChanged":
                        lock (handlerLock)
                        {
                            handler = (PropertyChangedEventHandler)Delegate.Remove(handler, (Delegate)input.Arguments[0]);
                        }
                        break;

                    default:
                        return input.CreateExceptionMethodReturn(new InvalidOperationException());
                }

                return input.CreateMethodReturn(null);
            }

            return null;
        }