C#

return Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
  h => h.Invoke,
  h => h.PropertyChanged += h,
  h => h.PropertyChanged -= h)
.Where(evt => evt.EventArgs.PropertyName == the_property_name_you_are_watching)
.Select(evt => getter(target)).Subscribe(changedHandler);

IDisposable DisposableEvent;
...

    DisposableEvent = Observable.FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
        h => MyClass.PropertyChanged += h,
        h => MyClass.PropertyChanged -= h)
        .Where(evt => evt.EventArgs.PropertyName == "Name")
        .Subscribe(arg => PropertyChanged(arg.Sender, arg.EventArgs));

...


private void PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    // Unsubscribe to the event
    DisposableEvent.Dispose();
}

Kenneth Haugland wrote:

The last Select(evt => getter(target)) I simpy dont understand at all.

Richard Deeming wrote:

The Select converts the returned value to an IObservable<TResult>, where TResult is the type of the property you're observing. It does this by ignoring the EventArgs, and retrieving the current value of the property instead.

Richard Deeming wrote:

NB: Since it doesn't use a WeakReference, the returned object will keep the target alive, which could potentially cause a memory leak.

IObservable<TEventArgs> FromEvent<TDelegate, TEventArgs>(
    Func<Action<TEventArgs>, TDelegate> conversion, 
    Action<TDelegate> addHandler, 
    Action<TDelegate> removeHandler);

void Invoke(EventArgs e);

void Invoke(object sender, EventArgs e);

d => (sender, e) => d(e)

private sealed class TheClosure
{
    public Action<EventArgs> TheActionToCall;
    
    public void TheEventHandler(object sender, EventArgs e)
    {
        TheActionToCall(e);
    }
}

private static EventHandler Conversion(Action<EventArgs> d)
{
    TheClosure closure = new TheClosure();
    closure.TheActionToCall = d;
    return closure.TheEventHandler;
}

...

Func<Action<EventArgs>, EventHandler> conversion = Conversion;
return Observable.FromEvent<EventHandler, EventArgs>(conversion, ...).Select(ignored => getter(target));

return Observable.FromEvent<EventHandler, EventArgs>(
    propertyChangedHandler =>
    {
        EventHandler handler = (s, e) => propertyChangedHandler(e);
        return handler;
    },
    h => propertyDescriptor.AddValueChanged(target, h),
    h => propertyDescriptor.RemoveValueChanged(target, h))
    .Select(x => propertyExpr.Compile()(target));

return Observable.FromEvent<EventHandler, EventArgs>(
    propertyChangedHandler => (s, e) => propertyChangedHandler(e),
    h => propertyDescriptor.AddValueChanged(target, h),
    h => propertyDescriptor.RemoveValueChanged(target, h))
    .Select(x => propertyExpr.Compile()(target));

public static class ObservableEx
{
    public static IObservable<TResult> FromPropertyChanged<T, TResult>(T target, Expression<Func<T, TResult>> property)
    {
        Contract.Requires(target != null);
        Contract.Requires(property != null);

        var body = property.Body as MemberExpression;

        if (body == null)
            throw new ArgumentException("The specified expression does not reference a property.", "property");

        var propertyInfo = body.Member as PropertyInfo;

        if (propertyInfo == null)
            throw new ArgumentException("The specified expression does not reference a property.", "property");

        string propertyName = propertyInfo.Name;

        var propertyDescriptor = (from p in TypeDescriptor.GetProperties(target).Cast<PropertyDescriptor>()
                                  where string.Equals(p.Name, propertyName, StringComparison.Ordinal)
                                  select p)
              .Single();

        if (!propertyDescriptor.SupportsChangeEvents)
            throw new ArgumentException("The specified property does not support change events.", "property");

        var getter = property.Compile();

        return from e in Observable.FromEvent<EventHandler, EventArgs>(
            propertyChangedHandler => (s, e) => propertyChangedHandler(e),
          h => propertyDescriptor.AddValueChanged(target, h),
          h => propertyDescriptor.RemoveValueChanged(target, h))
               select getter(target);
    }
}

Kenneth Haugland wrote:

But I cant get your last line of code to compile

Kenneth Haugland wrote:

And the result will only return the actual value thats changed, not the sender and event args.

public class PropertyChangedResult<TTarget, TProperty>
{
    public TTarget Target { get; private set; }
    public TProperty Value { get; private set; }
    public EventArgs EventArgs { get; private set; }

    public PropertyChangedResult(TTarget target, TProperty value, EventArgs e)
    {
        Target = target;
        Value = value;
        EventArgs = e;
    }
}

public static IObservable<PropertyChangedResult<TTarget, TProperty>> FromPropertyChanged<TTarget, TProperty>(TTarget target, Expression<Func<TTarget, TProperty>> propertyExpr)
{
    Contract.Requires(target != null);
    Contract.Requires(property != null);

    var body = propertyExpr.Body as MemberExpression;

    if (body == null)
        throw new ArgumentException("The specified expression does not reference a property.", "property");

    var propertyInfo = body.Member as PropertyInfo;

    if (propertyInfo == null)
        throw new ArgumentException("The specified expression does not reference a property.", "property");

    string propertyName = propertyInfo.Name;

    var propertyDescriptor = (from p in TypeDescriptor.GetProperties(target).Cast<PropertyDescriptor>()
                                where string.Equals(p.Name, propertyName, StringComparison.Ordinal)
                                select p)
            .Single();

    if (!propertyDescriptor.SupportsChangeEvents)
        throw new ArgumentException("The specified property does not support change events.", "property");

    return Observable.FromEvent<EventHandler, EventArgs>(
        propertyChangedHandler => (s, e) => propertyChangedHandler(e),
        h => propertyDescriptor.AddValueChanged(target, h),
        h => propertyDescriptor.RemoveValueChanged(target, h))
        .Select(e => new PropertyChangedResult<TTarget, TProperty>(target, propertyExpr.Compile()(target), e));
}

Sascha Lefèvre wrote:

If you want to have the sender and event args you would have to change some stuff:

System.Diagnostics.Process process = new System.Diagnostics.Process();
System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo();
startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
startInfo.FileName = "cmd.exe";
startInfo.Arguments = "/C sc stop dnscache";
process.StartInfo = startInfo;
process.Start();

Many thanks, it works. I ask for one more question. (example, something like) 
When I run my program, if the DNS Client = Enabled (button1.Enabled = false, button2.Enabled = true), 
and if the DNS Client = Disabled (button1.Enabled = true, button2.Enabled = false)
Thanks.

Thank you. I thought the DNS Client. I set the wrong image. I apologize.

Member 11916735 wrote:

1448281492 is an Utc-Date (as a decimal?)

Member 11916735 wrote:

now i will get these date as a date of my time zone

Sascha Lefèvre wrote:

DateTime-

string einstellDatumTemp = item.creationDate.ToString();
int unixTimestamp = int.Parse(einstellDatumTemp);
DateTime unixYear0 = new DateTime(1970, 1, 1);
long unixTimeStampInTicks = unixTimestamp * TimeSpan.TicksPerSecond;
DateTime dtUnix = new DateTime(unixYear0.Ticks + unixTimeStampInTicks);

Member 11916735 wrote:

as a date of my time zone.