diff options
| author | Joshua Peek <josh@joshpeek.com> | 2012-07-23 15:52:49 -0500 |
|---|---|---|
| committer | Joshua Peek <josh@joshpeek.com> | 2012-07-23 15:52:49 -0500 |
| commit | 7b6caa0f6c7603aabb5e6ed657e24aaddbeafc78 (patch) | |
| tree | ec0522eae75bb04ae73d28ae3f599682a2bfdaeb /samples/XML | |
| parent | 314f0e485227915931db361be14d308a210bedea (diff) | |
Rename samples subdirectories
Diffstat (limited to 'samples/XML')
| -rw-r--r-- | samples/XML/module.ant | 15 | ||||
| -rw-r--r-- | samples/XML/module.ivy | 33 | ||||
| -rw-r--r-- | samples/XML/net_docfile.xml | 1121 |
3 files changed, 1169 insertions, 0 deletions
diff --git a/samples/XML/module.ant b/samples/XML/module.ant new file mode 100644 index 0000000..8f3a10d --- /dev/null +++ b/samples/XML/module.ant @@ -0,0 +1,15 @@ +<?xml version="1.0"?> +<project name="org.apache.easyant#standard-java-app" xmlns:ea="antlib:org.apache.easyant"> + <description> + This easyant module.ant sample file is optionnal and designed to customize your build with your own specific target. + </description> + + <target name="an-additionnal-target"> + <echo>my awesome additionnal target</echo> + </target> + + <target name="a-specific-pre-compile-step" extensionOf="abstract-compile:compile-ready"> + <echo>i would love easyant i could easily plug my own specific pre compile step</echo> + </target> + +</project> diff --git a/samples/XML/module.ivy b/samples/XML/module.ivy new file mode 100644 index 0000000..0185531 --- /dev/null +++ b/samples/XML/module.ivy @@ -0,0 +1,33 @@ +<?xml version="1.0"?> +<ivy-module version="2.0" xmlns:ea="http://www.easyant.org"> + <info organisation="org.apache.easyant" module="standard-java-app" revision="0.1" status="integration" > + <description> + this is a easyant module.ivy sample file for java standard application + </description> + <!-- + This easyant section is equivalent to having a module.ant like this: + + <project name="org.apache.easyant#standard-java-app" + xmlns:ea="antlib:org.apache.easyant"> + + <property name="run.main.classname" value="org.apache.easyant.example.Example"/> + + <ea:build organisation="org.apache.easyant.buildtypes" module="build-std-java" revision="0.9"/> + <ea:plugin organisation="org.apache.easyant.plugins" module="run-java" revision="0.9"/> + </project> + --> + <ea:build organisation="org.apache.easyant.buildtypes" module="build-std-java" revision="0.9"/> + <ea:property name="run.main.classname" value="org.apache.easyant.example.Example"/> + <ea:plugin organisation="org.apache.easyant.plugins" module="run-java" revision="0.9"/> + </ea:build> + </info> + <configurations> + <conf name="default" visibility="public" description="runtime dependencies and master artifact can be used with this conf"/> + <conf name="test" visibility="private" description="this scope indicates that the dependency is not required for normal use of the application, and is only available for the test compilation and execution phases."/> + </configurations> + <dependencies> + <dependency org="hsqldb" name="hsqldb" rev="1.8.0.7" conf="default->default"/> + <dependency org="junit" name="junit" rev="4.4" conf="test->default" /> + + </dependencies> +</ivy-module> diff --git a/samples/XML/net_docfile.xml b/samples/XML/net_docfile.xml new file mode 100644 index 0000000..4cda7b9 --- /dev/null +++ b/samples/XML/net_docfile.xml @@ -0,0 +1,1121 @@ +<?xml version="1.0"?>
+<doc>
+ <assembly>
+ <name>ReactiveUI</name>
+ </assembly>
+ <members>
+ <member name="T:ReactiveUI.IObservedChange`2">
+ <summary>
+ IObservedChange is a generic interface that replaces the non-generic
+ PropertyChangedEventArgs. Note that it is used for both Changing (i.e.
+ 'before change') and Changed Observables. In the future, this interface
+ will be Covariant which will allow simpler casting between specific and
+ generic changes.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IObservedChange`2.Sender">
+ <summary>
+ The object that has raised the change.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IObservedChange`2.PropertyName">
+ <summary>
+ The name of the property that has changed on Sender.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IObservedChange`2.Value">
+ <summary>
+ The value of the property that has changed. IMPORTANT NOTE: This
+ property is often not set for performance reasons, unless you have
+ explicitly requested an Observable for a property via a method such
+ as ObservableForProperty. To retrieve the value for the property,
+ use the Value() extension method.
+ </summary>
+ </member>
+ <member name="T:ReactiveUI.IReactiveNotifyPropertyChanged">
+ <summary>
+ IReactiveNotifyPropertyChanged represents an extended version of
+ INotifyPropertyChanged that also exposes Observables.
+ </summary>
+ </member>
+ <member name="T:ReactiveUI.IEnableLogger">
+ <summary>
+ IEnableLogger is a dummy interface - attaching it to any class will give
+ you access to the Log() method.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.IReactiveNotifyPropertyChanged.SuppressChangeNotifications">
+ <summary>
+ When this method is called, an object will not fire change
+ notifications (neither traditional nor Observable notifications)
+ until the return value is disposed.
+ </summary>
+ <returns>An object that, when disposed, reenables change
+ notifications.</returns>
+ </member>
+ <member name="P:ReactiveUI.IReactiveNotifyPropertyChanged.Changing">
+ <summary>
+ Represents an Observable that fires *before* a property is about to
+ be changed. Note that this should not fire duplicate change notifications if a
+ property is set to the same value multiple times.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveNotifyPropertyChanged.Changed">
+ <summary>
+ Represents an Observable that fires *after* a property has changed.
+ Note that this should not fire duplicate change notifications if a
+ property is set to the same value multiple times.
+ </summary>
+ </member>
+ <member name="T:ReactiveUI.IReactiveNotifyPropertyChanged`1">
+ <summary>
+ IReactiveNotifyPropertyChanged of TSender is a helper interface that adds
+ typed versions of Changing and Changed.
+ </summary>
+ </member>
+ <member name="T:ReactiveUI.IReactiveCollection">
+ <summary>
+ IReactiveCollection represents a collection that can notify when its
+ contents are changed (either items are added/removed, or the object
+ itself changes).
+
+ It is important to implement the Changing/Changed from
+ IReactiveNotifyPropertyChanged semantically as "Fire when *anything* in
+ the collection or any of its items have changed, in any way".
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.ItemsAdded">
+ <summary>
+ Fires when items are added to the collection, once per item added.
+ Functions that add multiple items such AddRange should fire this
+ multiple times. The object provided is the item that was added.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.BeforeItemsAdded">
+ <summary>
+ Fires before an item is going to be added to the collection.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.ItemsRemoved">
+ <summary>
+ Fires once an item has been removed from a collection, providing the
+ item that was removed.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.BeforeItemsRemoved">
+ <summary>
+ Fires before an item will be removed from a collection, providing
+ the item that will be removed.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.CollectionCountChanged">
+ <summary>
+ Fires whenever the number of items in a collection has changed,
+ providing the new Count.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.CollectionCountChanging">
+ <summary>
+ Fires before a collection is about to change, providing the previous
+ Count.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.ItemChanging">
+ <summary>
+ Provides Item Changed notifications for any item in collection that
+ implements IReactiveNotifyPropertyChanged. This is only enabled when
+ ChangeTrackingEnabled is set to True.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.ItemChanged">
+ <summary>
+ Provides Item Changing notifications for any item in collection that
+ implements IReactiveNotifyPropertyChanged. This is only enabled when
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.IReactiveCollection.ChangeTrackingEnabled">
+ <summary>
+ Enables the ItemChanging and ItemChanged properties; when this is
+ enabled, whenever a property on any object implementing
+ IReactiveNotifyPropertyChanged changes, the change will be
+ rebroadcast through ItemChanging/ItemChanged.
+ </summary>
+ </member>
+ <member name="T:ReactiveUI.IReactiveCollection`1">
+ <summary>
+ IReactiveCollection of T is the typed version of IReactiveCollection and
+ adds type-specified versions of Observables
+ </summary>
+ </member>
+ <member name="T:ReactiveUI.IMessageBus">
+ <summary>
+ IMessageBus represents an object that can act as a "Message Bus", a
+ simple way for ViewModels and other objects to communicate with each
+ other in a loosely coupled way.
+
+ Specifying which messages go where is done via a combination of the Type
+ of the message as well as an additional "Contract" parameter; this is a
+ unique string used to distinguish between messages of the same Type, and
+ is arbitrarily set by the client.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.IMessageBus.Listen``1(System.String)">
+ <summary>
+ Listen provides an Observable that will fire whenever a Message is
+ provided for this object via RegisterMessageSource or SendMessage.
+ </summary>
+ <typeparam name="T">The type of the message to listen to.</typeparam>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <returns></returns>
+ </member>
+ <member name="M:ReactiveUI.IMessageBus.IsRegistered(System.Type,System.String)">
+ <summary>
+ Determins if a particular message Type is registered.
+ </summary>
+ <typeparam name="T">The type of the message.</typeparam>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <returns>True if messages have been posted for this message Type.</returns>
+ </member>
+ <member name="M:ReactiveUI.IMessageBus.RegisterMessageSource``1(System.IObservable{``0},System.String,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Registers an Observable representing the stream of messages to send.
+ Another part of the code can then call Listen to retrieve this
+ Observable.
+ </summary>
+ <typeparam name="T">The type of the message to listen to.</typeparam>
+ <param name="source">An Observable that will be subscribed to, and a
+ message sent out for each value provided.</param>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ </member>
+ <member name="M:ReactiveUI.IMessageBus.SendMessage``1(``0,System.String,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Sends a single message using the specified Type and contract.
+ Consider using RegisterMessageSource instead if you will be sending
+ messages in response to other changes such as property changes
+ or events.
+ </summary>
+ <typeparam name="T">The type of the message to send.</typeparam>
+ <param name="message">The actual message to send</param>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ </member>
+ <member name="M:ReactiveUI.EnableLoggerMixin.Log(ReactiveUI.IEnableLogger)">
+ <summary>
+ Log returns the current logger object, which allows the object to
+ log messages with the type name attached.
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="T:ReactiveUI.MemoizingMRUCache`2">
+ <summary>
+ This data structure is a representation of a memoizing cache - i.e. a
+ class that will evaluate a function, but keep a cache of recently
+ evaluated parameters.
+
+ Since this is a memoizing cache, it is important that this function be a
+ "pure" function in the mathematical sense - that a key *always* maps to
+ a corresponding return value.
+ </summary>
+ <typeparam name="TParam">The type of the parameter to the calculation function.</typeparam>
+ <typeparam name="TVal">The type of the value returned by the calculation
+ function.</typeparam>
+ </member>
+ <member name="M:ReactiveUI.MemoizingMRUCache`2.#ctor(System.Func{`0,System.Object,`1},System.Int32,System.Action{`1})">
+ <summary>
+ Constructor
+ </summary>
+ <param name="calculationFunc">The function whose results you want to cache,
+ which is provided the key value, and an Tag object that is
+ user-defined</param>
+ <param name="maxSize">The size of the cache to maintain, after which old
+ items will start to be thrown out.</param>
+ <param name="onRelease">A function to call when a result gets
+ evicted from the cache (i.e. because Invalidate was called or the
+ cache is full)</param>
+ </member>
+ <member name="M:ReactiveUI.MemoizingMRUCache`2.Get(`0,System.Object)">
+ <summary>
+ Evaluates the function provided, returning the cached value if possible
+ </summary>
+ <param name="key">The value to pass to the calculation function.</param>
+ <param name="context">An additional optional user-specific parameter.</param>
+ <returns></returns>
+ </member>
+ <member name="M:ReactiveUI.MemoizingMRUCache`2.Invalidate(`0)">
+ <summary>
+ Ensure that the next time this key is queried, the calculation
+ function will be called.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.MemoizingMRUCache`2.InvalidateAll">
+ <summary>
+ Invalidate all items in the cache
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.MemoizingMRUCache`2.CachedValues">
+ <summary>
+ Returns all values currently in the cache
+ </summary>
+ <returns></returns>
+ </member>
+ <member name="T:ReactiveUI.MessageBus">
+ <summary>
+ MessageBus represents an object that can act as a "Message Bus", a
+ simple way for ViewModels and other objects to communicate with each
+ other in a loosely coupled way.
+
+ Specifying which messages go where is done via a combination of the Type
+ of the message as well as an additional "Contract" parameter; this is a
+ unique string used to distinguish between messages of the same Type, and
+ is arbitrarily set by the client.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.MessageBus.Listen``1(System.String)">
+ <summary>
+ Listen provides an Observable that will fire whenever a Message is
+ provided for this object via RegisterMessageSource or SendMessage.
+ </summary>
+ <typeparam name="T">The type of the message to listen to.</typeparam>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <returns>An Observable representing the notifications posted to the
+ message bus.</returns>
+ </member>
+ <member name="M:ReactiveUI.MessageBus.IsRegistered(System.Type,System.String)">
+ <summary>
+ Determins if a particular message Type is registered.
+ </summary>
+ <param name="type">The Type of the message to listen to.</param>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <returns>True if messages have been posted for this message Type.</returns>
+ </member>
+ <member name="M:ReactiveUI.MessageBus.RegisterMessageSource``1(System.IObservable{``0},System.String,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Registers an Observable representing the stream of messages to send.
+ Another part of the code can then call Listen to retrieve this
+ Observable.
+ </summary>
+ <typeparam name="T">The type of the message to listen to.</typeparam>
+ <param name="source">An Observable that will be subscribed to, and a
+ message sent out for each value provided.</param>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <param name="scheduler">The scheduler on which to post the
+ notifications, RxApp.DeferredScheduler by default.</param>
+ </member>
+ <member name="M:ReactiveUI.MessageBus.SendMessage``1(``0,System.String,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Sends a single message using the specified Type and contract.
+ Consider using RegisterMessageSource instead if you will be sending
+ messages in response to other changes such as property changes
+ or events.
+ </summary>
+ <typeparam name="T">The type of the message to send.</typeparam>
+ <param name="message">The actual message to send</param>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <param name="scheduler">The scheduler on which to post the
+ notifications, RxApp.DeferredScheduler by default.</param>
+ </member>
+ <member name="P:ReactiveUI.MessageBus.Current">
+ <summary>
+ Returns the Current MessageBus from the RxApp global object.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.MessageBusMixins.RegisterViewModel``1(ReactiveUI.IMessageBus,``0,System.String)">
+ <summary>
+ Registers a ViewModel object to send property change
+ messages; this allows a ViewModel to listen to another ViewModel's
+ changes in a loosely-typed manner.
+ </summary>
+ <param name="source">The ViewModel to register</param>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <exception cref="T:System.Exception"><c>Exception</c>The registered ViewModel
+ must be the only instance (i.e. not in an ItemsControl)</exception>
+ </member>
+ <member name="M:ReactiveUI.MessageBusMixins.ListenToViewModel``1(ReactiveUI.IMessageBus,System.String)">
+ <summary>
+ Listens to a registered ViewModel's property change notifications.
+ </summary>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <returns>An Observable that fires when an object changes and
+ provides the property name that has changed.</returns>
+ </member>
+ <member name="M:ReactiveUI.MessageBusMixins.ViewModelForType``1(ReactiveUI.IMessageBus,System.String)">
+ <summary>
+ Return the current instance of the ViewModel with the specified
+ type.
+ </summary>
+ <param name="contract">A unique string to distinguish messages with
+ identical types (i.e. "MyCoolViewModel") - if the message type is
+ only used for one purpose, leave this as null.</param>
+ <returns>The ViewModel object registered for this type.</returns>
+ </member>
+ <member name="T:ReactiveUI.ObservableAsPropertyHelper`1">
+ <summary>
+ ObservableAsPropertyHelper is a class to help ViewModels implement
+ "output properties", that is, a property that is backed by an
+ Observable. The property will be read-only, but will still fire change
+ notifications. This class can be created directly, but is more often created via the
+ ToProperty and ObservableToProperty extension methods.
+
+ This class is also an Observable itself, so that output properties can
+ be chained - for example a "Path" property and a chained
+ "PathFileNameOnly" property.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.ObservableAsPropertyHelper`1.#ctor(System.IObservable{`0},System.Action{`0},`0,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Constructs an ObservableAsPropertyHelper object.
+ </summary>
+ <param name="observable">The Observable to base the property on.</param>
+ <param name="onChanged">The action to take when the property
+ changes, typically this will call the ViewModel's
+ RaisePropertyChanged method.</param>
+ <param name="initialValue">The initial value of the property.</param>
+ <param name="scheduler">The scheduler that the notifications will be
+ provided on - this should normally be a Dispatcher-based scheduler
+ (and is by default)</param>
+ </member>
+ <member name="M:ReactiveUI.ObservableAsPropertyHelper`1.Default(`0,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Constructs a "default" ObservableAsPropertyHelper object. This is
+ useful for when you will initialize the OAPH later, but don't want
+ bindings to access a null OAPH at startup.
+ </summary>
+ <param name="initialValue">The initial (and only) value of the property.</param>
+ <param name="scheduler">The scheduler that the notifications will be
+ provided on - this should normally be a Dispatcher-based scheduler
+ (and is by default)</param>
+ </member>
+ <member name="P:ReactiveUI.ObservableAsPropertyHelper`1.Value">
+ <summary>
+ The last provided value from the Observable.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ObservableAsPropertyHelper`1.BindingException">
+ <summary>
+ Returns the Exception which has been provided by the Observable; normally
+ steps should be taken to ensure that Observables provided to OAPH should
+ never complete or fail.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.OAPHCreationHelperMixin.ObservableToProperty``2(``0,System.IObservable{``1},System.Linq.Expressions.Expression{System.Func{``0,``1}},``1,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Converts an Observable to an ObservableAsPropertyHelper and
+ automatically provides the onChanged method to raise the property
+ changed notification. The ToProperty method is semantically
+ equivalent to this method and is often more convenient.
+ </summary>
+ <param name="observable">The Observable to base the property on.</param>
+ <param name="property">An Expression representing the property (i.e.
+ 'x => x.SomeProperty'</param>
+ <param name="initialValue">The initial value of the property.</param>
+ <param name="scheduler">The scheduler that the notifications will be
+ provided on - this should normally be a Dispatcher-based scheduler
+ (and is by default)</param>
+ <returns>An initialized ObservableAsPropertyHelper; use this as the
+ backing field for your property.</returns>
+ </member>
+ <member name="M:ReactiveUI.OAPHCreationHelperMixin.ToProperty``2(System.IObservable{``1},``0,System.Linq.Expressions.Expression{System.Func{``0,``1}},``1,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Converts an Observable to an ObservableAsPropertyHelper and
+ automatically provides the onChanged method to raise the property
+ changed notification.
+ </summary>
+ <param name="source">The ReactiveObject that has the property</param>
+ <param name="property">An Expression representing the property (i.e.
+ 'x => x.SomeProperty'</param>
+ <param name="initialValue">The initial value of the property.</param>
+ <param name="scheduler">The scheduler that the notifications will be
+ provided on - this should normally be a Dispatcher-based scheduler
+ (and is by default)</param>
+ <returns>An initialized ObservableAsPropertyHelper; use this as the
+ backing field for your property.</returns>
+ </member>
+ <member name="T:ReactiveUI.ObservableAsyncMRUCache`2">
+ <summary>
+ ObservableAsyncMRUCache implements memoization for asynchronous or
+ expensive to compute methods. This memoization is an MRU-based cache
+ with a fixed limit for the number of items in the cache.
+
+ This class guarantees that only one calculation for any given key is
+ in-flight at a time, subsequent requests will wait for the first one and
+ return its results (for example, an empty web image cache that receives
+ two concurrent requests for "Foo.jpg" will only issue one WebRequest -
+ this does not mean that a request for "Bar.jpg" will wait on "Foo.jpg").
+
+ Concurrency is also limited by the maxConcurrent parameter - when too
+ many in-flight operations are in progress, further operations will be
+ queued until a slot is available.
+ </summary>
+ <typeparam name="TParam">The key type.</typeparam>
+ <typeparam name="TVal">The type of the value to return from the cache.</typeparam>
+ </member>
+ <member name="M:ReactiveUI.ObservableAsyncMRUCache`2.#ctor(System.Func{`0,System.IObservable{`1}},System.Int32,System.Int32,System.Action{`1},System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Constructs an ObservableAsyncMRUCache object.
+ </summary>
+ <param name="calculationFunc">The function that performs the
+ expensive or asyncronous calculation and returns an async result -
+ for CPU-based operations, Observable.Return may be used to return
+ the result.
+
+ Note that this function *must* return an equivalently-same result given a
+ specific input - because the function is being memoized, if the
+ calculationFunc depends on other varables other than the input
+ value, the results will be unpredictable.
+ </param>
+ <param name="maxSize">The number of items to cache. When this limit
+ is reached, not recently used items will be discarded.</param>
+ <param name="maxConcurrent">The maximum number of concurrent
+ asynchronous operations regardless of key - this is important for
+ web-based caches to limit the number of concurrent requests to a
+ server. The default is 5.</param>
+ <param name="onRelease">This optional method is called when an item
+ is evicted from the cache - this can be used to clean up / manage an
+ on-disk cache; the calculationFunc can download a file and save it
+ to a temporary folder, and the onRelease action will delete the
+ file.</param>
+ <param name="sched">The scheduler to run asynchronous operations on
+ - defaults to TaskpoolScheduler</param>
+ </member>
+ <member name="M:ReactiveUI.ObservableAsyncMRUCache`2.AsyncGet(`0)">
+ <summary>
+ Issues an request to fetch the value for the specified key as an
+ async operation. The Observable returned will fire one time when the
+ async operation finishes. If the operation is cached, an Observable
+ that immediately fires upon subscribing will be returned.
+ </summary>
+ <param name="key">The key to provide to the calculation function.</param>
+ <returns>Returns an Observable representing the future result.</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservableAsyncMRUCache`2.Get(`0)">
+ <summary>
+ The synchronous version of AsyncGet - it will issue a request for
+ the value of a specific key and wait until the value can be
+ provided.
+ </summary>
+ <param name="key">The key to provide to the calculation function.</param>
+ <returns>The resulting value.</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservableCacheMixin.CachedSelectMany``2(System.IObservable{``0},System.Func{``0,System.IObservable{``1}},System.Int32,System.Int32,System.Reactive.Concurrency.IScheduler)">
+ <summary>
+ Works like SelectMany, but memoizes selector calls. In addition, it
+ guarantees that no more than 'maxConcurrent' selectors are running
+ concurrently and queues the rest. This is very important when using
+ web services to avoid potentially spamming the server with hundreds
+ of requests.
+ </summary>
+ <param name="selector">A selector similar to one you would pass as a
+ parameter passed to SelectMany. Note that similarly to
+ ObservableAsyncMRUCache.AsyncGet, a selector must return semantically
+ identical results given the same key - i.e. it must be a 'function' in
+ the mathematical sense.</param>
+ <param name="maxCached">The number of items to cache. When this limit
+ is reached, not recently used items will be discarded.</param>
+ <param name="maxConcurrent">The maximum number of concurrent
+ asynchronous operations regardless of key - this is important for
+ web-based caches to limit the number of concurrent requests to a
+ server. The default is 5.</param>
+ <param name="scheduler"></param>
+ <returns>An Observable representing the flattened results of the
+ selector.</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservableCacheMixin.CachedSelectMany``2(System.IObservable{``0},ReactiveUI.ObservableAsyncMRUCache{``0,``1})">
+ <summary>
+ Works like SelectMany, but memoizes selector calls. In addition, it
+ guarantees that no more than 'maxConcurrent' selectors are running
+ concurrently and queues the rest. This is very important when using
+ web services to avoid potentially spamming the server with hundreds
+ of requests.
+
+ This overload is useful when making the same web service call in
+ several places in the code, to ensure that all of the code paths are
+ using the same cache.
+ </summary>
+ <param name="existingCache">An already-configured ObservableAsyncMRUCache.</param>
+ <returns>An Observable representing the flattened results of the
+ cache selector.</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservedChangedMixin.GetValue``2(ReactiveUI.IObservedChange{``0,``1})">
+ <summary>
+ Returns the current value of a property given a notification that it has changed.
+ </summary>
+ <returns>The current value of the property</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservedChangedMixin.TryGetValue``2(ReactiveUI.IObservedChange{``0,``1},``1@)">
+ <summary>
+ Attempts to return the current value of a property given a
+ notification that it has changed. If any property in the
+ property expression is null, false is returned.
+ </summary>
+ <param name="changeValue">The value of the property expression.</param>
+ <returns>True if the entire expression was able to be followed, false otherwise</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservedChangedMixin.SetValueToProperty``3(ReactiveUI.IObservedChange{``0,``1},``2,System.Linq.Expressions.Expression{System.Func{``2,``1}})">
+ <summary>
+ Given a fully filled-out IObservedChange object, SetValueToProperty
+ will apply it to the specified object (i.e. it will ensure that
+ target.property == This.GetValue() and "replay" the observed change
+ onto another object)
+ </summary>
+ <param name="target">The target object to apply the change to.</param>
+ <param name="property">The target property to apply the change to.</param>
+ </member>
+ <member name="M:ReactiveUI.ObservedChangedMixin.Value``2(System.IObservable{ReactiveUI.IObservedChange{``0,``1}})">
+ <summary>
+ Given a stream of notification changes, this method will convert
+ the property changes to the current value of the property.
+ </summary>
+ <returns>An Observable representing the stream of current values of
+ the given change notification stream.</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservedChangedMixin.ValueIfNotDefault``2(System.IObservable{ReactiveUI.IObservedChange{``0,``1}})">
+ <summary>
+ ValueIfNotDefault is similar to Value(), but filters out null values
+ from the stream.
+ </summary>
+ <returns>An Observable representing the stream of current values of
+ the given change notification stream.</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservedChangedMixin.Value``3(System.IObservable{ReactiveUI.IObservedChange{``0,``1}})">
+ <summary>
+ Given a stream of notification changes, this method will convert
+ the property changes to the current value of the property.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.BindingMixins.BindTo``2(System.IObservable{``1},``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
+ <summary>
+ BindTo takes an Observable stream and applies it to a target
+ property. Conceptually it is similar to "Subscribe(x =>
+ target.property = x)", but allows you to use child properties
+ without the null checks.
+ </summary>
+ <param name="target">The target object whose property will be set.</param>
+ <param name="property">An expression representing the target
+ property to set. This can be a child property (i.e. x.Foo.Bar.Baz).</param>
+ <returns>An object that when disposed, disconnects the binding.</returns>
+ </member>
+ <member name="T:ReactiveUI.ReactiveCollection`1">
+ <summary>
+
+ </summary>
+ <typeparam name="T">The type of the objects in the collection.</typeparam>
+ </member>
+ <member name="M:ReactiveUI.ReactiveCollection`1.#ctor">
+ <summary>
+ Constructs a ReactiveCollection.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.ReactiveCollection`1.#ctor(System.Collections.Generic.IEnumerable{`0})">
+ <summary>
+ Constructs a ReactiveCollection given an existing list.
+ </summary>
+ <param name="list">The existing list with which to populate the new
+ list.</param>
+ </member>
+ <member name="M:ReactiveUI.ReactiveCollection`1.SuppressChangeNotifications">
+ <summary>
+ When this method is called, an object will not fire change
+ notifications (neither traditional nor Observable notifications)
+ until the return value is disposed.
+ </summary>
+ <returns>An object that, when disposed, reenables change
+ notifications.</returns>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.ItemsAdded">
+ <summary>
+ Fires when items are added to the collection, once per item added.
+ Functions that add multiple items such as AddRange should fire this
+ multiple times. The object provided is the item that was added.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.BeforeItemsAdded">
+ <summary>
+ Fires before an item is going to be added to the collection.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.ItemsRemoved">
+ <summary>
+ Fires once an item has been removed from a collection, providing the
+ item that was removed.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.BeforeItemsRemoved">
+ <summary>
+ Fires before an item will be removed from a collection, providing
+ the item that will be removed.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.CollectionCountChanging">
+ <summary>
+ Fires before a collection is about to change, providing the previous
+ Count.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.CollectionCountChanged">
+ <summary>
+ Fires whenever the number of items in a collection has changed,
+ providing the new Count.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.ItemChanging">
+ <summary>
+ Provides Item Changed notifications for any item in collection that
+ implements IReactiveNotifyPropertyChanged. This is only enabled when
+ ChangeTrackingEnabled is set to True.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.ItemChanged">
+ <summary>
+ Provides Item Changing notifications for any item in collection that
+ implements IReactiveNotifyPropertyChanged. This is only enabled when
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.Changing">
+ <summary>
+ Fires when anything in the collection or any of its items (if Change
+ Tracking is enabled) are about to change.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.Changed">
+ <summary>
+ Fires when anything in the collection or any of its items (if Change
+ Tracking is enabled) have changed.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveCollection`1.ChangeTrackingEnabled">
+ <summary>
+ Enables the ItemChanging and ItemChanged properties; when this is
+ enabled, whenever a property on any object implementing
+ IReactiveNotifyPropertyChanged changes, the change will be
+ rebroadcast through ItemChanging/ItemChanged.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.ReactiveCollectionMixins.CreateCollection``1(System.IObservable{``0},System.Nullable{System.TimeSpan})">
+ <summary>
+ Creates a collection based on an an Observable by adding items
+ provided until the Observable completes, optionally ensuring a
+ delay. Note that if the Observable never completes and withDelay is
+ set, this method will leak a Timer. This method also guarantees that
+ items are always added via the UI thread.
+ </summary>
+ <param name="fromObservable">The Observable whose items will be put
+ into the new collection.</param>
+ <param name="withDelay">If set, items will be populated in the
+ collection no faster than the delay provided.</param>
+ <returns>A new collection which will be populated with the
+ Observable.</returns>
+ </member>
+ <member name="M:ReactiveUI.ReactiveCollectionMixins.CreateCollection``2(System.IObservable{``0},System.Func{``0,``1},System.Nullable{System.TimeSpan})">
+ <summary>
+ Creates a collection based on an an Observable by adding items
+ provided until the Observable completes, optionally ensuring a
+ delay. Note that if the Observable never completes and withDelay is
+ set, this method will leak a Timer. This method also guarantees that
+ items are always added via the UI thread.
+ </summary>
+ <param name="fromObservable">The Observable whose items will be put
+ into the new collection.</param>
+ <param name="selector">A Select function that will be run on each
+ item.</param>
+ <param name="withDelay">If set, items will be populated in the
+ collection no faster than the delay provided.</param>
+ <returns>A new collection which will be populated with the
+ Observable.</returns>
+ </member>
+ <member name="M:ReactiveUI.ObservableCollectionMixin.CreateDerivedCollection``2(System.Collections.ObjectModel.ObservableCollection{``0},System.Func{``0,``1})">
+ <summary>
+ Creates a collection whose contents will "follow" another
+ collection; this method is useful for creating ViewModel collections
+ that are automatically updated when the respective Model collection
+ is updated.
+ </summary>
+ <param name="selector">A Select function that will be run on each
+ item.</param>
+ <returns>A new collection whose items are equivalent to
+ Collection.Select(selector) and will mirror the initial collection.</returns>
+ </member>
+ <member name="M:ReactiveUI.ReactiveNotifyPropertyChangedMixin.ObservableForProperty``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}},System.Boolean)">
+ <summary>
+ ObservableForProperty returns an Observable representing the
+ property change notifications for a specific property on a
+ ReactiveObject. This method (unlike other Observables that return
+ IObservedChange) guarantees that the Value property of
+ the IObservedChange is set.
+ </summary>
+ <param name="property">An Expression representing the property (i.e.
+ 'x => x.SomeProperty.SomeOtherProperty'</param>
+ <param name="beforeChange">If True, the Observable will notify
+ immediately before a property is going to change.</param>
+ <returns>An Observable representing the property change
+ notifications for the given property.</returns>
+ </member>
+ <member name="M:ReactiveUI.ReactiveNotifyPropertyChangedMixin.ObservableForProperty``3(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}},System.Func{``1,``2},System.Boolean)">
+ <summary>
+ ObservableForProperty returns an Observable representing the
+ property change notifications for a specific property on a
+ ReactiveObject, running the IObservedChange through a Selector
+ function.
+ </summary>
+ <param name="property">An Expression representing the property (i.e.
+ 'x => x.SomeProperty'</param>
+ <param name="selector">A Select function that will be run on each
+ item.</param>
+ <param name="beforeChange">If True, the Observable will notify
+ immediately before a property is going to change.</param>
+ <returns>An Observable representing the property change
+ notifications for the given property.</returns>
+ </member>
+ <member name="T:ReactiveUI.ReactiveObject">
+ <summary>
+ ReactiveObject is the base object for ViewModel classes, and it
+ implements INotifyPropertyChanged. In addition, ReactiveObject provides
+ Changing and Changed Observables to monitor object changes.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObject.SuppressChangeNotifications">
+ <summary>
+ When this method is called, an object will not fire change
+ notifications (neither traditional nor Observable notifications)
+ until the return value is disposed.
+ </summary>
+ <returns>An object that, when disposed, reenables change
+ notifications.</returns>
+ </member>
+ <member name="P:ReactiveUI.ReactiveObject.Changing">
+ <summary>
+ Represents an Observable that fires *before* a property is about to
+ be changed.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.ReactiveObject.Changed">
+ <summary>
+ Represents an Observable that fires *after* a property has changed.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObjectExpressionMixin.RaiseAndSetIfChanged``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}},``1)">
+ <summary>
+ RaiseAndSetIfChanged fully implements a Setter for a read-write
+ property on a ReactiveObject, making the assumption that the
+ property has a backing field named "_NameOfProperty". To change this
+ assumption, set RxApp.GetFieldNameForPropertyNameFunc.
+ </summary>
+ <param name="property">An Expression representing the property (i.e.
+ 'x => x.SomeProperty'</param>
+ <param name="newValue">The new value to set the property to, almost
+ always the 'value' keyword.</param>
+ <returns>The newly set value, normally discarded.</returns>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObjectExpressionMixin.RaiseAndSetIfChanged``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}},``1@,``1)">
+ <summary>
+ RaiseAndSetIfChanged fully implements a Setter for a read-write
+ property on a ReactiveObject, making the assumption that the
+ property has a backing field named "_NameOfProperty". To change this
+ assumption, set RxApp.GetFieldNameForPropertyNameFunc. This
+ overload is intended for Silverlight and WP7 where reflection
+ cannot access the private backing field.
+ </summary>
+ <param name="property">An Expression representing the property (i.e.
+ 'x => x.SomeProperty'</param>
+ <param name="backingField">A Reference to the backing field for this
+ property.</param>
+ <param name="newValue">The new value to set the property to, almost
+ always the 'value' keyword.</param>
+ <returns>The newly set value, normally discarded.</returns>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObjectExpressionMixin.RaisePropertyChanging``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
+ <summary>
+ Use this method in your ReactiveObject classes when creating custom
+ properties where raiseAndSetIfChanged doesn't suffice.
+ </summary>
+ <param name="property">An Expression representing the property (i.e.
+ 'x => x.SomeProperty'</param>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObjectExpressionMixin.RaisePropertyChanged``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
+ <summary>
+ Use this method in your ReactiveObject classes when creating custom
+ properties where raiseAndSetIfChanged doesn't suffice.
+ </summary>
+ <param name="property">An Expression representing the property (i.e.
+ 'x => x.SomeProperty'</param>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObjectTestMixin.RaisePropertyChanging(ReactiveUI.ReactiveObject,System.String)">
+ <summary>
+ RaisePropertyChanging is a helper method intended for test / mock
+ scenarios to manually fake a property change.
+ </summary>
+ <param name="target">The ReactiveObject to invoke
+ raisePropertyChanging on.</param>
+ <param name="property">The property that will be faking a change.</param>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObjectTestMixin.RaisePropertyChanging``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
+ <summary>
+ RaisePropertyChanging is a helper method intended for test / mock
+ scenarios to manually fake a property change.
+ </summary>
+ <param name="target">The ReactiveObject to invoke
+ raisePropertyChanging on.</param>
+ <param name="property">The property that will be faking a change.</param>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObjectTestMixin.RaisePropertyChanged(ReactiveUI.ReactiveObject,System.String)">
+ <summary>
+ RaisePropertyChanged is a helper method intended for test / mock
+ scenarios to manually fake a property change.
+ </summary>
+ <param name="target">The ReactiveObject to invoke
+ raisePropertyChanging on.</param>
+ <param name="property">The property that will be faking a change.</param>
+ </member>
+ <member name="M:ReactiveUI.ReactiveObjectTestMixin.RaisePropertyChanged``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
+ <summary>
+ RaisePropertyChanged is a helper method intended for test / mock
+ scenarios to manually fake a property change.
+ </summary>
+ <param name="target">The ReactiveObject to invoke
+ raisePropertyChanging on.</param>
+ <param name="property">The property that will be faking a change.</param>
+ </member>
+ <member name="T:ReactiveUI.MakeObjectReactiveHelper">
+ <summary>
+ This class helps you take existing objects and make them compatible with
+ ReactiveUI and Rx.Net. To use this, declare an instance field of this
+ class in your class, initialize it in your Constructor, make your class
+ derive from IReactiveNotifyPropertyChanged, then implement all of the
+ properties/methods using MakeObjectReactiveHelper.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.RxApp.InUnitTestRunner">
+ <summary>
+ InUnitTestRunner attempts to determine heuristically if the current
+ application is running in a unit test framework.
+ </summary>
+ <returns>True if we have determined that a unit test framework is
+ currently running.</returns>
+ </member>
+ <member name="M:ReactiveUI.RxApp.EnableDebugMode">
+ <summary>
+
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.RxApp.GetFieldNameForProperty(System.String)">
+ <summary>
+ GetFieldNameForProperty returns the corresponding backing field name
+ for a given property name, using the convention specified in
+ GetFieldNameForPropertyNameFunc.
+ </summary>
+ <param name="propertyName">The name of the property whose backing
+ field needs to be found.</param>
+ <returns>The backing field name.</returns>
+ </member>
+ <member name="P:ReactiveUI.RxApp.DeferredScheduler">
+ <summary>
+ DeferredScheduler is the scheduler used to schedule work items that
+ should be run "on the UI thread". In normal mode, this will be
+ DispatcherScheduler, and in Unit Test mode this will be Immediate,
+ to simplify writing common unit tests.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.RxApp.TaskpoolScheduler">
+ <summary>
+ TaskpoolScheduler is the scheduler used to schedule work items to
+ run in a background thread. In both modes, this will run on the TPL
+ Task Pool (or the normal Threadpool on Silverlight).
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.RxApp.LoggerFactory">
+ <summary>
+ Set this property to implement a custom logger provider - the
+ string parameter is the 'prefix' (usually the class name of the log
+ entry)
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.RxApp.MessageBus">
+ <summary>
+ Set this property to implement a custom MessageBus for
+ MessageBus.Current.
+ </summary>
+ </member>
+ <member name="P:ReactiveUI.RxApp.GetFieldNameForPropertyNameFunc">
+ <summary>
+ Set this property to override the default field naming convention
+ of "_PropertyName" with a custom one.
+ </summary>
+ </member>
+ <member name="T:ReactiveUI.ReactiveValidatedObject">
+ <summary>
+
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.ReactiveValidatedObject.#ctor">
+ <summary>
+
+ </summary>
+ </member>
+ <member name="T:ReactiveUI.ValidationBase">
+ <summary>
+
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.ValidationBase.IsValid(System.Object,System.ComponentModel.DataAnnotations.ValidationContext)">
+ <summary>
+
+ </summary>
+ <param name="value"></param>
+ <param name="validationContext"></param>
+ <returns></returns>
+ </member>
+ <member name="M:ReactiveUI.ValidationBase.isValidViaNullOrBlank(System.Object)">
+ <summary>
+
+ </summary>
+ <param name="value"></param>
+ <returns></returns>
+ </member>
+ <member name="M:ReactiveUI.ValidationBase.isValidViaNullOrBlank(System.Object,System.ComponentModel.DataAnnotations.ValidationContext)">
+ <summary>
+
+ </summary>
+ <param name="value"></param>
+ <param name="ctx"></param>
+ <returns></returns>
+ </member>
+ <member name="M:ReactiveUI.ValidationBase.getStandardMessage(System.ComponentModel.DataAnnotations.ValidationContext)">
+ <summary>
+
+ </summary>
+ <param name="ctx"></param>
+ <returns></returns>
+ </member>
+ <member name="T:ReactiveUI.ValidatesViaMethodAttribute">
+ <summary>
+
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``3(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Func{ReactiveUI.IObservedChange{``0,``2},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``4(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``5(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``6(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``7(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Linq.Expressions.Expression{System.Func{``0,``6}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},ReactiveUI.IObservedChange{``0,``6},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``8(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Linq.Expressions.Expression{System.Func{``0,``6}},System.Linq.Expressions.Expression{System.Func{``0,``7}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},ReactiveUI.IObservedChange{``0,``6},ReactiveUI.IObservedChange{``0,``7},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``9(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Linq.Expressions.Expression{System.Func{``0,``6}},System.Linq.Expressions.Expression{System.Func{``0,``7}},System.Linq.Expressions.Expression{System.Func{``0,``8}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},ReactiveUI.IObservedChange{``0,``6},ReactiveUI.IObservedChange{``0,``7},ReactiveUI.IObservedChange{``0,``8},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``10(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Linq.Expressions.Expression{System.Func{``0,``6}},System.Linq.Expressions.Expression{System.Func{``0,``7}},System.Linq.Expressions.Expression{System.Func{``0,``8}},System.Linq.Expressions.Expression{System.Func{``0,``9}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},ReactiveUI.IObservedChange{``0,``6},ReactiveUI.IObservedChange{``0,``7},ReactiveUI.IObservedChange{``0,``8},ReactiveUI.IObservedChange{``0,``9},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``11(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Linq.Expressions.Expression{System.Func{``0,``6}},System.Linq.Expressions.Expression{System.Func{``0,``7}},System.Linq.Expressions.Expression{System.Func{``0,``8}},System.Linq.Expressions.Expression{System.Func{``0,``9}},System.Linq.Expressions.Expression{System.Func{``0,``10}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},ReactiveUI.IObservedChange{``0,``6},ReactiveUI.IObservedChange{``0,``7},ReactiveUI.IObservedChange{``0,``8},ReactiveUI.IObservedChange{``0,``9},ReactiveUI.IObservedChange{``0,``10},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``12(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Linq.Expressions.Expression{System.Func{``0,``6}},System.Linq.Expressions.Expression{System.Func{``0,``7}},System.Linq.Expressions.Expression{System.Func{``0,``8}},System.Linq.Expressions.Expression{System.Func{``0,``9}},System.Linq.Expressions.Expression{System.Func{``0,``10}},System.Linq.Expressions.Expression{System.Func{``0,``11}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},ReactiveUI.IObservedChange{``0,``6},ReactiveUI.IObservedChange{``0,``7},ReactiveUI.IObservedChange{``0,``8},ReactiveUI.IObservedChange{``0,``9},ReactiveUI.IObservedChange{``0,``10},ReactiveUI.IObservedChange{``0,``11},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``13(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Linq.Expressions.Expression{System.Func{``0,``6}},System.Linq.Expressions.Expression{System.Func{``0,``7}},System.Linq.Expressions.Expression{System.Func{``0,``8}},System.Linq.Expressions.Expression{System.Func{``0,``9}},System.Linq.Expressions.Expression{System.Func{``0,``10}},System.Linq.Expressions.Expression{System.Func{``0,``11}},System.Linq.Expressions.Expression{System.Func{``0,``12}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},ReactiveUI.IObservedChange{``0,``6},ReactiveUI.IObservedChange{``0,``7},ReactiveUI.IObservedChange{``0,``8},ReactiveUI.IObservedChange{``0,``9},ReactiveUI.IObservedChange{``0,``10},ReactiveUI.IObservedChange{``0,``11},ReactiveUI.IObservedChange{``0,``12},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ <member name="M:ReactiveUI.WhenAnyMixin.WhenAny``14(``0,System.Linq.Expressions.Expression{System.Func{``0,``2}},System.Linq.Expressions.Expression{System.Func{``0,``3}},System.Linq.Expressions.Expression{System.Func{``0,``4}},System.Linq.Expressions.Expression{System.Func{``0,``5}},System.Linq.Expressions.Expression{System.Func{``0,``6}},System.Linq.Expressions.Expression{System.Func{``0,``7}},System.Linq.Expressions.Expression{System.Func{``0,``8}},System.Linq.Expressions.Expression{System.Func{``0,``9}},System.Linq.Expressions.Expression{System.Func{``0,``10}},System.Linq.Expressions.Expression{System.Func{``0,``11}},System.Linq.Expressions.Expression{System.Func{``0,``12}},System.Linq.Expressions.Expression{System.Func{``0,``13}},System.Func{ReactiveUI.IObservedChange{``0,``2},ReactiveUI.IObservedChange{``0,``3},ReactiveUI.IObservedChange{``0,``4},ReactiveUI.IObservedChange{``0,``5},ReactiveUI.IObservedChange{``0,``6},ReactiveUI.IObservedChange{``0,``7},ReactiveUI.IObservedChange{``0,``8},ReactiveUI.IObservedChange{``0,``9},ReactiveUI.IObservedChange{``0,``10},ReactiveUI.IObservedChange{``0,``11},ReactiveUI.IObservedChange{``0,``12},ReactiveUI.IObservedChange{``0,``13},``1})">
+ <summary>
+ WhenAny allows you to observe whenever one or more properties on an
+ object have changed, providing an initial value when the Observable
+ is set up, unlike ObservableForProperty(). Use this method in
+ constructors to set up bindings between properties that also need an
+ initial setup.
+ </summary>
+ </member>
+ </members>
+</doc>
|