Catel.Core by GeertvanHorrik

<PackageReference Include="Catel.Core" Version="3.9.0.1402161444-beta" />

---

API Diff between 3.9.0.1402161444-beta and 3.8.1312231212-beta

158 Additions 81 Removals

Catel

• public class CompositeFilter<T> : ICompositeFilter<T>
  • public CompositePredicate<T> Excludes { get; set; }
  • public CompositePredicate<T> Includes { get; set; }
  • public CompositeFilter()
  • public bool Matches(T target)
• public class CompositePredicate<T>
  • public CompositePredicate()
  • public static CompositePredicate<T> op_Addition(CompositePredicate<T> invokes, Predicate<T> filter)
  • public bool DoesNotMatchAny(T target)
  • public bool MatchesAll(T target)
  • public bool MatchesAny(T target)
  • public bool MatchesNone(T target)
• public class CoreModule : IServiceLocatorInitializer
  • public static void RegisterServices(IServiceLocator serviceLocator)
  • public CoreModule()
  • public void Initialize(IServiceLocator serviceLocator)
• public interface ICompositeFilter<T>
  • CompositePredicate<T> Excludes { get; set; }
  • CompositePredicate<T> Includes { get; set; }
  • bool Matches(T target)
• public class NotSupportedInSilverlightException : Exception
• public class NotSupportedInWindows8Exception : Exception
• public class NotSupportedInWindowsPhone7Exception : Exception
• public static class ParallelHelper
  • public static void ExecuteInParallel<T>(List<T> items, Action<T> actionToInvoke, int itemsPerBatch = 1000, string taskName = null)
• public static class ResourceHelper
  • public static void AddCustomAssemblyMapping(string assemblyName, string mappedAssemblyName)
  • public static string GetString(string resourceName)

Catel.Caching

• public static class CacheFactory

Catel.Collections

• public static class CollectionExtensions
  • public static void ForEach<TItem>(this IEnumerable<TItem> collection, Action<TItem> action)

Catel.Data

• public class AllowNonSerializableMembersAttribute : Attribute
• public class CatelTypeInfo
  • public Dictionary<string, PropertyInfo> GetNonCatelProperties()
  • public Dictionary<string, CachedPropertyInfo> GetNonCatelProperties()
• public class ChangeNotificationWrapper
  • public void SubscribeNotifyChangedEvents(object value, bool isCollectionItem)
  • public void UnsubscribeNotifyChangedEvents(object value)
  • public void UpdateCollectionSubscriptions(IEnumerable collection)
• public abstract class DataObjectBase : ModelBase, IDataObject, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
• public abstract class DataObjectBase<TDataObject> : ModelBase<TDataObject>, IDataObject<TDataObject>
• public class ExcludeFromValidationAttribute : Attribute
  • public ExcludeFromValidationAttribute()
• public interface IDataObject : IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
• public interface IDataObject<TModel>
• public interface ISavableDataObjectBase : ISavableModel, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
• public abstract class ModelBase : ObservableObject, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
  • public static bool DefaultSuspendValidationValue { get; set; }
  • public static T Load<T>(IRandomAccessStream fileStream, bool enableRedirects)
  • public static T Load<T>(IRandomAccessStream fileStream, SerializationMode mode, bool enableRedirects)
  • public static T Load<T>(byte[] bytes, bool enableRedirects = false)
  • public static T Load<T>(Stream stream, bool enableRedirects = false)
  • public static T Load<T>(Stream stream, SerializationMode mode, bool enableRedirects)
  • public static IModel Load(Type type, Stream stream, SerializationMode mode, bool enableRedirects)
  • public static T Load<T>(IRandomAccessStream fileStream, SerializationMode mode)
• public abstract class ModelBase<TModel> : ModelBase
• public class PropertyData
  • public CachedPropertyInfo GetPropertyInfo(Type containingType)
• public class PropertyDataManager
  • public CatelTypeInfo GetProperties(Type type)
• public abstract class SavableDataObjectBase<T> : SavableModelBase<T>, ISavableDataObjectBase, ISavableModel, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
• public abstract class SavableModelBase<T> : ModelBase, ISavableModel, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
  • public static T Load(IRandomAccessStream fileStream, bool enableRedirects = false)
  • public static T Load(IRandomAccessStream fileStream, SerializationMode mode, bool enableRedirects)
  • public static T Load(byte[] bytes, bool enableRedirects = false)
  • public static T Load(Stream stream, bool enableRedirects = false)
  • public static T Load(Stream stream, SerializationMode mode, bool enableRedirects)

Catel.ExceptionHandling

• public class ExceptionService : IExceptionService
  • public Task ProcessAsync(Action action, CancellationToken cancellationToken = default)
  • public Task ProcessAsync(Func<Task> action)
  • public Task<TResult> ProcessAsync<TResult>(Func<TResult> action, CancellationToken cancellationToken = default)
  • public Task<TResult> ProcessAsync<TResult>(Func<Task<TResult>> action)
• public interface IExceptionService
  • Task ProcessAsync(Action action, CancellationToken cancellationToken = default)
  • Task ProcessAsync(Func<Task> action)
  • Task<TResult> ProcessAsync<TResult>(Func<TResult> action, CancellationToken cancellationToken = default)
  • Task<TResult> ProcessAsync<TResult>(Func<Task<TResult>> action)

Catel.IoC

• public static class DependencyInjectionHelper
• public abstract class ExternalContainerHelperBase : IExternalContainerHelper
• public class FirstInterfaceRegistrationConvention : RegistrationConventionBase
  • public FirstInterfaceRegistrationConvention(IServiceLocator serviceLocator, RegistrationType registrationType = 0)
• public interface IExternalContainerHelper
• public static class IoCConfiguration
  • public static void UpdateDefaultComponents()
• public static class IoCFactory
  • public static Func<IServiceLocator, IDependencyResolver> CreateDependencyResolverFunc { get; set; }
  • public static Func<IServiceLocator> CreateServiceLocatorFunc { get; set; }
  • public static Func<IDependencyResolver, ITypeFactory> CreateTypeFactoryFunc { get; set; }
  • public static IServiceLocator CreateServiceLocator(bool initializeServiceLocator = true)
• public interface IRegistrationConvention
  • RegistrationType RegistrationType { get; }
  • void Process(IEnumerable<Type> typesToRegister)
• public interface IRegistrationConventionHandler
  • ICompositeFilter<Assembly> AssemblyFilter { get; }
  • IEnumerable<IRegistrationConvention> RegistrationConventions { get; }
  • ICompositeFilter<Type> TypeFilter { get; }
  • void AddAssemblyToScan(Assembly assembly)
  • void ApplyConventions()
  • void RegisterConvention<TRegistrationConvention>(RegistrationType registrationType = 0) where TRegistrationConvention : IRegistrationConvention
• public interface IServiceLocator : IServiceProvider
  • bool AutomaticallyKeepContainersSynchronized { get; set; }
  • void ExportInstancesToExternalContainers()
  • void ExportToExternalContainers()
  • bool IsExternalContainerSupported(object externalContainer)
  • void RegisterExternalContainer(object externalContainer)
  • void RegisterExternalContainerHelper(IExternalContainerHelper externalContainerHelper)
  • void RegisterType(Type serviceType, Func<ServiceLocatorRegistration, object> createServiceFunc, object tag = null, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true)
• public interface IServiceLocatorInitializer
  • void Initialize(IServiceLocator serviceLocator)
• public sealed class LateBoundImplementation
• public class NamingRegistrationConvention : RegistrationConventionBase
  • public NamingRegistrationConvention(IServiceLocator serviceLocator, RegistrationType registrationType = 0)
• public abstract class RegistrationConventionBase : IRegistrationConvention
  • public IServiceLocator Container { get; protected set; }
  • public RegistrationType RegistrationType { get; protected set; }
  • public RegistrationConventionBase(IServiceLocator serviceLocator, RegistrationType registrationType = 0)
  • public abstract void Process(IEnumerable<Type> typesToRegister)
• public class RegistrationConventionHandler : IRegistrationConventionHandler
  • public static IRegistrationConventionHandler Default { get; }
  • public ICompositeFilter<Assembly> AssemblyFilter { get; }
  • public IEnumerable<IRegistrationConvention> RegistrationConventions { get; }
  • public ICompositeFilter<Type> TypeFilter { get; }
  • public RegistrationConventionHandler(IServiceLocator serviceLocator = null, ITypeFactory typeFactory = null)
  • public void AddAssemblyToScan(Assembly assembly)
  • public void ApplyConventions()
  • public void RegisterConvention<TRegistrationConvention>(RegistrationType registrationType = 0) where TRegistrationConvention : IRegistrationConvention
  • protected void RemoveIfAlreadyRegistered(Type type)
• public static class RegistrationConventionHandlerExtensions
  • public static IRegistrationConventionHandler AddAssemblyToScan<TAssembly>(this IRegistrationConventionHandler registrationConventionHandler) where TAssembly : Assembly
  • public static IRegistrationConventionHandler ExcludeAllTypesOfNamespace(this IRegistrationConventionHandler registrationConventionHandler, string namespace)
  • public static IRegistrationConventionHandler ExcludeAllTypesOfNamespaceContaining<T>(this IRegistrationConventionHandler registrationConventionHandler)
  • public static IRegistrationConventionHandler ExcludeAssembliesWhere(this IRegistrationConventionHandler registrationConventionHandler, Predicate<Assembly> exclude)
  • public static IRegistrationConventionHandler ExcludeAssembly<TAssembly>(this IRegistrationConventionHandler registrationConventionHandler) where TAssembly : Assembly
  • public static IRegistrationConventionHandler ExcludeType<T>(this IRegistrationConventionHandler registrationConventionHandler)
  • public static IRegistrationConventionHandler ExcludeTypesWhere(this IRegistrationConventionHandler registrationConventionHandler, Predicate<Type> exclude)
  • public static IRegistrationConventionHandler IncludeAllTypesOfNamespace(this IRegistrationConventionHandler registrationConventionHandler, string namespace)
  • public static IRegistrationConventionHandler IncludeAllTypesOfNamespaceContaining<T>(this IRegistrationConventionHandler registrationConventionHandler)
  • public static IRegistrationConventionHandler IncludeType<T>(this IRegistrationConventionHandler registrationConventionHandler)
  • public static IRegistrationConventionHandler IncludeTypesWhere(this IRegistrationConventionHandler registrationConventionHandler, Predicate<Type> include)
  • public static IRegistrationConventionHandler ShouldAlsoUseConvention<TRegistrationConvention>(this IRegistrationConventionHandler registrationConventionHandler, RegistrationType registrationType = 0) where TRegistrationConvention : IRegistrationConvention
• public class RegistrationInfo
  • public bool IsLateBoundRegistration { get; }
• public class ServiceLocator : IServiceLocator, IServiceProvider
  • public static IServiceLocator Instance { get; }
  • public bool AutomaticallyKeepContainersSynchronized { get; set; }
  • public void ExportInstancesToExternalContainers()
  • public void ExportToExternalContainers()
  • public bool IsExternalContainerSupported(object externalContainer)
  • public void RegisterExternalContainer(object externalContainer)
  • public void RegisterExternalContainerHelper(IExternalContainerHelper externalContainerHelper)
  • public void RegisterType(Type serviceType, Func<ServiceLocatorRegistration, object> createServiceFunc, object tag = null, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true)
• public static class ServiceLocatorExtensions
  • public static bool IsTypeRegistered<TService>(this IServiceLocator serviceLocator)
  • public static bool IsTypeRegisteredAsSingleton<TService>(this IServiceLocator serviceLocator)
  • public static void RegisterInstance<TService>(this IServiceLocator serviceLocator, TService instance)
  • public static void RegisterType<TServiceImplementation>(this IServiceLocator serviceLocator, object tag = null, RegistrationType registrationType = 0)
  • public static bool IsTypeRegistered<TService>(this IServiceLocator serviceLocator, object tag = null)
  • public static bool IsTypeRegisteredAsSingleton<TService>(this IServiceLocator serviceLocator, object tag = null)
  • public static void RegisterInstance<TService>(this IServiceLocator serviceLocator, TService instance, object tag = null)
  • public static void RegisterType<TServiceImplementation>(this IServiceLocator serviceLocator, RegistrationType registrationType = 0)
  • public static void RegisterType<TService>(this IServiceLocator serviceLocator, Func<ServiceLocatorRegistration, TService> createServiceFunc, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true)
  • public static void RegisterTypeIfNotYetRegistered(this IServiceLocator serviceLocator, Type serviceType, Type serviceImplementationType, object tag = null, RegistrationType registrationType = 0)
  • public static TService ResolveType<TService>(this IServiceLocator serviceLocator)
  • public static void RegisterTypeIfNotYetRegistered(this IServiceLocator serviceLocator, Type serviceType, Type serviceImplementationType, RegistrationType registrationType = 0)
  • public static void RegisterTypeIfNotYetRegisteredWithTag<TService, TServiceImplementation>(this IServiceLocator serviceLocator, object tag = null, RegistrationType registrationType = 0) where TServiceImplementation : TService
  • public static void RegisterTypeIfNotYetRegisteredWithTag(this IServiceLocator serviceLocator, Type serviceType, Type serviceImplementationType, object tag = null, RegistrationType registrationType = 0)
  • public static IRegistrationConventionHandler RegisterTypesUsingAllConventions(this IServiceLocator serviceLocator, RegistrationType registrationType = 0)
  • public static IRegistrationConventionHandler RegisterTypesUsingConvention<TRegistrationConvention>(this IServiceLocator serviceLocator, RegistrationType registrationType = 0) where TRegistrationConvention : IRegistrationConvention
  • public static IRegistrationConventionHandler RegisterTypesUsingDefaultFirstInterfaceConvention(this IServiceLocator serviceLocator, RegistrationType registrationType = 0)
  • public static IRegistrationConventionHandler RegisterTypesUsingDefaultNamingConvention(this IServiceLocator serviceLocator, RegistrationType registrationType = 0)
  • public static void RegisterTypeWithTag<TServiceImplementation>(this IServiceLocator serviceLocator, object tag = null, RegistrationType registrationType = 0)
  • public static void RegisterTypeWithTag<TService, TServiceImplementation>(this IServiceLocator serviceLocator, object tag = null, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true) where TServiceImplementation : TService
  • public static void RegisterTypeWithTag<TService>(this IServiceLocator serviceLocator, Func<ServiceLocatorRegistration, TService> createServiceFunc, object tag = null, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true)
  • public static void RemoveType<TService>(this IServiceLocator serviceLocator, object tag = null)
  • public static TService ResolveType<TService>(this IServiceLocator serviceLocator, object tag = null)
• public class ServiceLocatorRegistration
  • public Func<ServiceLocatorRegistration, object> CreateServiceFunc { get; }
  • public object OriginalContainer { get; }
  • public ServiceLocatorRegistration(Type declaringType, Type implementingType, object tag, RegistrationType registrationType, object originalContainer)
  • public ServiceLocatorRegistration(Type declaringType, Type implementingType, object tag, RegistrationType registrationType, Func<ServiceLocatorRegistration, object> createServiceFunc)
• public class ServiceLocatorRegistrationAttribute : Attribute
  • public ServiceLocatorRegistrationAttribute(Type interfaceType, RegistrationType registrationType, object tag = null)

Catel.Logging

• public abstract class BatchLogListenerBase : LogListenerBase, IBatchLogListener
  • protected virtual string FormatLogEvent(ILog log, string message, LogEvent logEvent, object extraData)
• public interface ILogListener
  • bool IgnoreCatelLogging { get; set; }
  • void Debug(ILog log, string message)
  • void Error(ILog log, string message)
  • void Info(ILog log, string message)
  • void Warning(ILog log, string message)
  • void Write(ILog log, string message, LogEvent logEvent)
• public abstract class LogListenerBase : ILogListener
  • public virtual void Debug(ILog log, string message)
  • public virtual void Error(ILog log, string message)
  • protected virtual string FormatLogEvent(ILog log, string message, LogEvent logEvent, object extraData)
  • public virtual void Info(ILog log, string message)
  • public virtual void Warning(ILog log, string message)
  • public virtual void Write(ILog log, string message, LogEvent logEvent)
• public static class LogManager
  • public static bool? IgnoreCatelLogging { get; set; }
  • public static ILogListener RegisterDebugListener()
  • public static ILogListener RegisterDebugListener(bool ignoreCatelLogging)

Catel.Reflection

• public static class AssemblyExtensions
  • public static string Path(this Assembly assembly)
• public class CachedPropertyInfo
  • public bool HasPublicGetter { get; }
  • public bool HasPublicSetter { get; }
  • public PropertyInfo PropertyInfo { get; }
  • public CachedPropertyInfo(PropertyInfo propertyInfo)
  • public bool IsDecoratedWithAttribute(Type attributeType)
• public static class ReflectionExtensions
  • public static MethodInfo GetMethodCached(this Type type, string methodName)
  • public static IEnumerable<Type> GetParentTypes(this Type type)
  • public static PropertyInfo GetPropertyCached(this Type type, string propertyName)
  • public static bool ImplementsInterfaceEx<TInterface>(this Type type)
  • public static bool IsPrimitiveEx(this Type type)
• public static class TypeExtensions
  • public static bool IsBasicType(this Type type)
  • public static bool IsClassType(this Type type)
  • public static bool IsNullableType(this Type type)
• public static class TypeHelper
  • public static bool AreObjectsEqual(object object1, object object2)
  • public static Type GetType(string typeNameWithAssembly, bool ignoreCase = false)
  • public static Type[] GetTypes()
  • public static Type[] GetTypes(Func<Type, bool> predicate)
  • public static Type[] GetTypesOfAssembly(Assembly assembly)
  • public static Type GetTypeWithAssembly(string typeName, string assemblyName, bool ignoreCase = false)
  • public static Type GetTypeWithoutAssembly(string typeNameWithoutAssembly, bool ignoreCase = false)
  • public static void InitializeTypes(bool forceFullInitialization, string assemblyName)
  • public static void InitializeTypes(bool forceFullInitialization, Assembly assembly = null)
  • public static bool IsClassType(Type type)
  • public static bool IsTypeNullable(Type type)

Catel.Runtime.Serialization

• public interface ISerializationContext : IDisposable
  • int Depth { get; }
• public class SerializationContext<TContext> : ISerializationContext<TContext>, ISerializationContext, IDisposable
  • public int Depth { get; }

Catel.Services

• public interface ILanguageService
  • CultureInfo FallbackCulture { get; set; }
  • CultureInfo PreferredCulture { get; set; }
  • string GetString(string resourceName)
  • string GetString(string resourceName, CultureInfo cultureInfo)
  • void PreloadLanguageSources()
  • void RegisterLanguageSource(ILanguageSource languageSource)
• public interface ILanguageSource
  • string GetSource()
• public class LanguageService : ILanguageService
  • public CultureInfo FallbackCulture { get; set; }
  • public CultureInfo PreferredCulture { get; set; }
  • public LanguageService()
  • public string GetString(string resourceName)
  • public string GetString(string resourceName, CultureInfo cultureInfo)
  • protected virtual string GetString(ILanguageSource languageSource, string resourceName, CultureInfo cultureInfo)
  • public virtual void PreloadLanguageSources()
  • public void RegisterLanguageSource(ILanguageSource languageSource)
• public abstract class ServiceBase : IService
  • protected TService GetService<TService>(object tag = null)

Catel.Services.Models

• public class LanguageResourceKey : IEquatable<LanguageResourceKey>
  • public CultureInfo CultureInfo { get; }
  • public string ResourceName { get; }
  • public LanguageResourceKey(string resourceName, CultureInfo cultureInfo)
  • public bool Equals(LanguageResourceKey other)
• public class LanguageResourceSource : ILanguageSource
  • public string AssemblyName { get; }
  • public string NamespaceName { get; }
  • public string ResourceFileName { get; }
  • public LanguageResourceSource(string assemblyName, string namespaceName, string resourceFileName)
  • public string GetSource()