Skip to content

ChangeLog

Jump to bottom
Jay Tuley edited this page Jul 3, 2013 · 6 revisions

Core 6.1.4 / MVVM 4.0.11 / FSharp 1.2.11

  • Core: Fix for null comparison bug in ActLike proxy
  • Core: Better proxy handling of generics
  • Core: Extension Method to Instance Method Proxy
  • Core: UseNamedArgument can be applied at interface level -Thanks @fearthecowboy!

Core 6.0.6 / MVVM 4.0.6-beta / FSharp 1.2.6

  • Core: Strong Named (but not secret in Repository)
  • Core: Recursive Interfaces when using ActLIke
  • Core: FluentRegex
  • Core: Impromtu.CoerceConvert(object target, Type type) - This uses every dynamic conversion api avaialbe
  • Core: Fixed ImpromptuDictionary coercion bug with Enums
  • Core: Add Int and String indexer support to InvokeGetChain & InvokeSetChain
  • Core: Added Support for Silverlight5
  • Core: Added Impromptu.InvokeBinaryOperator and Impromptu.InvokeUnaryOpartor
  • MVVM: Strong Named (but not secret in Repository)
  • MVVM: Added support for dynamic property binding syntax in Silverlight 5
  • MVVM: Added 3rd party IoC support from combining with NoMVVM
  • MVVM: Updated configuring property dependencies to use Setup fluent property
  • FSharp: Strong Named (but not secret in Repository)

Core 5.6.7

  • Simplified Dynamic ActLike Syntax
  • Fixed bug involving subsequent named argument invoke calls forgeting argument names

Core 5.6.6

  • Improved Com interop

Core 5.6.4

  • Fixed recursive bug with type coercion of !ImpromptuDictionary & !ImpromptuGet

FSharp 1.1.0

  • >?> operator for dynamically calling implicit operator
  • >>?>> operator for dynamically calling explicit operator
  • dynAddAssign(obj)?Event<-EventHandler operator for dynamically adding events
  • dynSubtractAssign(obj)?Event<-EventHandler operator for dynamically removing events
  • dynArg(objArg)?Name syntax for pairing argument names when dynamically invoking

Core 5.6.2 / MVVM 3.6.2 / FSharp 1.0.2

  • Core: can cast type to StaticContext to late bind static methods
  • Core: interface proxy hides implementation methods with separate interface
  • Core: fixed large number of arguments bug (>15)
  • Core: Build<>.NewList is now property rather than method so that it can be stored and used from a variable
  • Core: Curry Cast no longer has artificial argument limit
  • Core: added ImpromptuLazy<> dynamic wrapper around Lazy<>
  • Core: added ImpromptuLateLibraryType dynamic lookup type at runtime can dynamically call static methods and constructor.
  • FSharp: Dynamic operator implementation
  • FSharp: !? prefix operator allows direct invoke of delegates/objects dynamically

Core 5.5.8

  • Small curry bugs with currying instance and static methods.
  • Mono runtime & compiler fixes for currying.

Core 5.5.6 / MVVM 3.5.6#

  • Core: Function & Method Currying/Partial Apply with Impromptu.Curry
  • Core: Impromptu.Invoke(!CallSite,...) is now Impromptu.!InvokeCallSite(!CallSite,..) old name marked as obsolete.
  • Core: Impromptu.Invoke(target,...) allows for dynamic invocation of delegates and dynamic objects.
  • Core: InvokeGetChained, InvokeSetChained - Allows calling via property chain.
  • Core: InvokeSetAll - Allows calling several properties in one method.
  • Core: Impromptu.GetMemberNames() gets dynamic members and public properties.
  • Core: Interface result coercion of ImpromptuGet & ImpromptuDictionary fall back to TypeConverter if need be (including builtin silverlight converters).
  • Core: Proxy indexers now work with VB.NET
  • Core: Fixed issues with possible interface collisions.
  • Core: PropertyNotifyChanged more efficient
  • Core: ImpromptuFactory can now create via method call with constructor args.
  • MVVM: new experimental window factory

Core 5.1.1 / MVVM 3.1.1#

  • Core: Fixed bug that wouldn't allow context parameter for really late binding to be just a plain Type object
  • Core: Improved proxy generation to include attributes used by dynamic invocation to resolve overloads
  • MVVM: Added a Property-ToString proxy object

Core 5.0.4 / MVVM 3.0.4#

  • Core: Fixed invocation issue with delegates that have out parameters in ImpromptuDictionary
  • Core: Fixed Issue with InvokeConstructor on Mono
  • Core: Improved Invoke methods performance by a factor of 2.
  • Core: Added a convenience factory method for CacheableInvocation the uses CallInfo
  • Core: Added equals/hashcode methods to CacheableInvocation

Core 5.0.3 / MVVM 3.0.3#

  • Core: Added missing event support for ActLike
  • Core: Added Impromptu.InvokeIsEvent, Impromptu.InvokeAddAssign and InvokeSubtractAssign
  • Core: Added ImpromptuPropertyDescriptor for Dynamic PropertyDescriptor and ImpromptuList implementsITypedList
  • Core: ImpromptuForwarder supports forwarding events.
  • Core: class Invocation breaking change InvokeWithArgs ->Invoke, and Invoke->InvokeWithStoredArgs
  • Core: Added CacheableInvocation with more signature information added in the creation of this invocation performance gains up to 25x faster on invoke.
  • MVVM: Added ViewModel Event Binding Syntax
  • MVVM: Added ViewModel specific PropertyChange subscription Syntax
  • MVVM: ImpromptuBindingList supports DataGrid AutoColumns
  • All: Added Public symbol/source server debugging support

Core 4.0.7 / MVVM 2.0.7#

  • Core: ActLike Proxies and most dynamic classes now serializable.
  • Core: Added ImpromptuForwarder base class
  • Core: Added ImpromptuRecorder dynamic class
  • Core: Added Impromptu.InvokeConvert static method
  • Core: Added Impromptu.InvokeConstuctor static method
  • Core: Added Impromptu.Get\SetIndex static method
  • Core: Suports Syntax for really late binding static methods (InvokeStaticContext), generic parameters(InvokeMemberName), and permissions context (InvokeContext),.
  • Core: Deprecated Call... static methods use InvokeContext syntax instead
  • Core: Fixed bug with proxying arrays
  • mvvm: Can put compile time contract on dynamic properties (gain intellisense) with ImpromptuViewModel
  • mvvm: Dependancies property on ImpromptuViewModel that allows linking properties on dependent properties.
  • mvvm: ImpromptuToString<TTarget> proxy class allows replacing of ToString method so that you can bind model objects to view items.

Core 3.1 / MVVM 1.09

  • Core: Added prototype object initialization syntax based on Clay. dynamic New # Impromptu.Builder(); 99% Compatible with Clay initialization syntax but resulting prototype object is ImpromptuDictionary which is 100x faster than Clay.
  • Core: dynamic New # Impromptu.Builder<T>(); gives basic initialization syntax to work on any object, including ExpandoObject which is less compatible with Clay syntax but 500x faster than Clay, or even clay objects themselves which can be 100% compatible
  • Core: Better Support for Xaml Binding for ImpromptuDictionary
  • Core: Added InvokeArg syntax for extreme late binding support with named arguments.
  • Core: Added [UseNamedArgument] attribute that can be used on Methods or Method Arguments on an Interface to tell the proxy use the argument name in the binding.
  • MVVM: ImpromptuViewModel Dynamically does work necessary for binding properties and commands that normally requires lots of boilerplate.
  • MVVM: ImpromptuRelayCommand extreme late binding relay command.

3.0

  • Silverlight passes all unit tests
  • ImpromptuDictionary will also act like a dynamic proxy for any IDictionary<string,object> including nested IDictionary<string,object>
  • Added ImpromptuGet dynamic proxy that only exposes getters including Funcs as methods (works with anonymous objects).
  • Added Impromptu.FastDynamicInvoke(this Delegate del, params object[] args) runs about 20x faster than Delegate.DynamicInvoke(params object[] arg)
  • All Impromtu.Invoke functions leveraging the DLR run faster than reflection in Microsoft.net & Silverlight
  • Added readable convenience syntax for inline lambdas Return<T>.Arguments<T1,..>((T1,..)#> code) and ReturnVoid.Arguments<T1,..>((T1,..)#> code)

2.x

Added functions to extremely late binding calls.

  • var result # Impromptu.InvokeMember(target, "name", arg1,...);
  • Impromptu.InvokeMemberAction(target, "name", arg1,...);
  • var result # Impromptu.InvokeGet(target, "name");
  • Impromptu.InvokeSet(target, "name", value); These calls can be used on static or dynamic objects.

1.x

  • Basic Functionality of ActLike<Interface>() Plus some primitive base classes when using ImpromptuInterface.Dynamic;
  • ImpromptuObject --Similar to DynamicObject but the expected static return type from the wrapped interface can be queried.
  • ImpromptuFactory -- Functional base class, used to create fluent factories with less boilerplate
  • ImpromptuDictionary -- Similar to ExpandoObject but returns default of the static return type if the property has never been set.
Clone this wiki locally