Catel.Core by GeertvanHorrik

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

---

API Diff between 3.9.0.1402161444-beta and 3.4.1303081031-beta

855 Additions 162 Removals

Catel

• public static class Argument
  • public static void ImplementsInterface<TInterface>(string paramName, object instance)
  • public static void InheritsFrom(string paramName, Type type, Type baseType)
  • public static void InheritsFrom(string paramName, object instance, Type baseType)
  • public static void InheritsFrom<TBase>(string paramName, object instance)
  • public static void IsMaximum<T>(string paramName, T paramValue, T maximumValue)
  • public static void IsMaximum<T>(Expression<Func<T>> expression, T maximumValue)
  • public static void IsMinimal<T>(string paramName, T paramValue, T minimumValue)
  • public static void IsMinimal<T>(Expression<Func<T>> expression, T minimumValue)
  • public static void IsNotOutOfRange<T>(string paramName, T paramValue, T minimumValue, T maximumValue)
  • public static void IsNotOutOfRange<T>(Expression<Func<T>> expression, T minimumValue, T maximumValue)
• 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 CoreModule()
  • public void Initialize(IServiceLocator serviceLocator)
• public class DynamicEventListener
• public static class Enum<TEnum> where TEnum : struct, IComparable, IFormattable
  • public static TEnum Parse(string input, bool ignoreCase = false)
• public interface ICompositeFilter<T>
  • CompositePredicate<T> Excludes { get; set; }
  • CompositePredicate<T> Includes { get; set; }
  • bool Matches(T target)
• public interface IFluent
  • bool Equals(object obj)
  • int GetHashCode()
  • Type GetType()
  • string ToString()
• public static class ModuleInitializer
• public class NotSupportedInSilverlightException : Exception
• public class NotSupportedInWindowsPhone7Exception : Exception
• public class NotSupportedInWinRTException : Exception
• public class NotSupportedInPlatformException : Exception
  • public SupportedPlatforms Platform { get; }
  • public string Reason { get; }
  • public NotSupportedInPlatformException(string featureFormat = "", object[] args)
• public static class ObjectToStringHelper
  • public static string ToFullTypeString(object instance)
• public static class ParallelHelper
  • public static void ExecuteInParallel<T>(List<T> items, Action<T> actionToInvoke, int itemsPerBatch = 1000, string taskName = null)
• public static class Platforms
  • public static SupportedPlatforms CurrentPlatform { get; }
• public static class ResourceHelper
  • public static void AddCustomAssemblyMapping(string assemblyName, string mappedAssemblyName)
  • public static string GetString(string resourceName)
• public static class StringToObjectHelper
  • public static TEnumValue ToEnum<TEnumValue>(string value, TEnumValue defaultValue) where TEnumValue : struct, IComparable, IFormattable
• public enum SupportedPlatforms
  • NET40 = 0
  • NET45 = 1
  • NET50 = 2
  • PCL = 7
  • Silverlight5 = 3
  • Windows80 = 5
  • Windows81 = 6
  • WindowsPhone80 = 4
• public static class ThreadHelper
  • public static int GetCurrentThreadId()
  • public static void SpinWait(int iterations)
• public static class UrlHelper
  • public static string GetSafeUriString(Uri uri)
  • public static bool IsAbsoluteUrl(string url)
• public static class WeakEventListener<TTarget, TSource>
  • public static IWeakEventListener SubscribeToWeakEventWithExplicitSourceType<TExplicitSourceType>(TTarget target, TSource source, string eventName, Delegate handler)
• public class WeakEventListener<TTarget, TSource, TEventArgs> : IWeakEventListener
  • public static IWeakEventListener SubscribeToWeakEventWithExplicitSourceType<TExplicitSourceType>(TTarget target, TSource source, string eventName, Delegate handler)

Catel.Caching

• public static class CacheFactory

Catel.Collections

• public static class CollectionExtensions
  • public static ReadOnlyCollection<T> AsReadOnly<T>(this IList<T> collection)
  • public static void ForEach<TItem>(this IEnumerable<TItem> collection, Action<TItem> action)
  • public static void RemoveFirst(this IList list)
  • public static void RemoveLast(this IList list)

Catel.Configuration

• public static class ConfigurationExtensions
• public class ConfigurationChangedEventArgs : EventArgs
  • public string Key { get; }
  • public object NewValue { get; }
  • public ConfigurationChangedEventArgs(string key, object newValue)
• public class ConfigurationService : IConfigurationService
  • public event EventHandler<ConfigurationChangedEventArgs> ConfigurationChanged
  • public ConfigurationService()
  • public T GetValue<T>(string key, T defaultValue = null)
  • protected virtual string GetValueFromStore(string key)
  • public void SetValue(string key, object value)
  • protected virtual void SetValueToStore(string key, string value)
  • protected virtual bool ValueExists(string key)
• public interface IConfigurationService
  • event EventHandler<ConfigurationChangedEventArgs> ConfigurationChanged
  • T GetValue<T>(string key, T defaultValue = null)
  • void SetValue(string key, object value)

Catel.Core

• public static class ModuleInitializer
  • public static void Initialize()

Catel.Data

• public class AllowNonSerializableMembersAttribute : Attribute
• public class AttributeValidatorProvider : ValidatorProviderBase
  • public AttributeValidatorProvider()
• public class CatelTypeInfo
  • public bool IsRegisterPropertiesCalled { get; }
  • public Type Type { get; }
  • public CatelTypeInfo(Type type)
  • public Dictionary<string, PropertyData> GetCatelProperties()
  • public Dictionary<string, CachedPropertyInfo> GetNonCatelProperties()
  • public PropertyData GetPropertyData(string name)
  • public bool IsPropertyRegistered(string name)
  • public void RegisterProperties()
  • public void RegisterProperty(string name, PropertyData propertyData)
• public class ChangeNotificationWrapper
  • public static bool IsUsefulForObject(object obj)
  • 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, ICloneable, ISerializable, IDeserializationCallback
• 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, ICloneable, ISerializable, IDeserializationCallback
• public interface IDataObject<TModel>
• public interface IModelEqualityComparer : IEqualityComparer
  • bool CompareCollections { get; set; }
  • bool CompareProperties { get; set; }
  • bool CompareValues { get; set; }
• public interface ISavableDataObjectBase : ISavableModel, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable, ICloneable, ISerializable, IDeserializationCallback
• public static class IParentExtensions
  • public static TParent FindParent<TParent>(IParent model, int maxLevels = -1)
• public interface ISavableModel : IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
  • void Save(string fileName)
  • void Save(string fileName, SerializationMode mode)
  • void Save(IRandomAccessStream fileStream)
• public interface IValidationContext
  • DateTime LastModified { get; }
  • long LastModifiedTicks { get; }
  • void AddBusinessRuleValidationResult(IBusinessRuleValidationResult businessRuleValidationResult)
  • void AddFieldValidationResult(IFieldValidationResult fieldValidationResult)
  • void RemoveBusinessRuleValidationResult(IBusinessRuleValidationResult businessRuleValidationResult)
  • void RemoveFieldValidationResult(IFieldValidationResult fieldValidationResult)
• public interface IValidationSummary
  • DateTime LastModified { get; }
  • long LastModifiedTicks { get; }
• public interface IValidator
  • void Validate(object instance, ValidationContext validationContext)
• public abstract class ModelBase : ObservableObject, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
  • public static bool DefaultSuspendValidationValue { get; set; }
  • protected bool ContainsNonSerializableMembers { get; }
  • protected bool DisableEventSubscriptionsOfChildValues { get; protected set; }
  • protected IModelEqualityComparer EqualityComparer { get; protected set; }
  • protected bool LeanAndMeanModel { get; protected set; }
  • protected ModelBase(SerializationInfo info, StreamingContext context)
  • public static XmlQualifiedName GetModelBaseXmlSchema(XmlSchemaSet schemaSet)
  • public static T Load<T>(string fileName, bool enableRedirects = false)
  • public static T Load<T>(string fileName, SerializationMode mode, bool enableRedirects = false)
  • 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 = false)
  • public static T Load<T>(Stream stream, SerializationMode mode)
  • public static IModel Load(Type type, Stream stream, SerializationMode mode)
  • public static PropertyData RegisterProperty<TModel, TValue>(Expression<Func<TModel, TValue>> propertyExpression, TValue defaultValue, Action<TModel, AdvancedPropertyChangedEventArgs> propertyChangedEventHandler = null, bool includeInSerialization = true, bool includeInBackup = true, bool setParent = true)
  • public static PropertyData RegisterProperty<TModel, TValue>(Expression<Func<TModel, TValue>> propertyExpression, Func<TValue> createDefaultValue = null, Action<TModel, AdvancedPropertyChangedEventArgs> propertyChangedEventHandler = null, bool includeInSerialization = true, bool includeInBackup = true, bool setParent = true)
  • protected virtual void GetDataFromSerializationInfo(SerializationInfo info)
  • protected void GetDataFromSerializationInfoInternal(SerializationInfo info)
  • public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
  • protected virtual object GetPropertyValueForDeserialization(PropertyData property, object serializedValue)
  • protected virtual object GetPropertyValueForSerialization(PropertyData property, object propertyValue)
  • protected void InitializePropertyAfterConstruction(PropertyData property)
  • protected void NotifyValidationResult(IValidationResult validationResult, bool notifyGlobal)
  • public void OnDeserialization(object sender)
• public abstract class ModelBase<TModel> : ModelBase
• public class ModelEqualityComparer : EqualityComparer<ModelBase>, IModelEqualityComparer, IEqualityComparer
  • public bool CompareCollections { get; set; }
  • public bool CompareProperties { get; set; }
  • public bool CompareValues { get; set; }
  • public ModelEqualityComparer()
• public class ObservableObject : IAdvancedNotifyPropertyChanging, INotifyPropertyChanging, IAdvancedNotifyPropertyChanged, INotifyPropertyChanged
  • public static XmlQualifiedName GetObservableObjectXmlSchema(XmlSchemaSet schemaSet)
• public class PropertyBag : INotifyPropertyChanged
  • public object this[string name] { get; set; }
  • public event PropertyChangedEventHandler PropertyChanged
  • public PropertyBag()
  • public Dictionary<string, object> GetAllProperties()
  • public TValue GetPropertyValue<TValue>(string propertyName)
  • public void Import(Dictionary<string, object> propertiesToImport)
  • public bool IsPropertyAvailable(string propertyName)
  • public void SetPropertyValue(string propertyName, object value)
• public class PropertyData
  • public bool IsCalculatedProperty { get; }
  • public CachedPropertyInfo GetPropertyInfo(Type containingType)
• public class PropertyDataManager
  • public static PropertyDataManager Default { get; }
  • public PropertyDataManager()
  • public CatelTypeInfo GetCatelTypeInfo(Type type)
  • public PropertyData GetPropertyData(Type type, string name)
  • public bool IsPropertyNameMappedToXmlAttribute(Type type, string propertyName)
  • public bool IsPropertyNameMappedToXmlElement(Type type, string propertyName)
  • public bool IsPropertyRegistered(Type type, string name)
  • public bool IsXmlAttributeNameMappedToProperty(Type type, string xmlName)
  • public bool IsXmlElementNameMappedToProperty(Type type, string xmlName)
  • public string MapPropertyNameToXmlAttributeName(Type type, string propertyName)
  • public string MapPropertyNameToXmlElementName(Type type, string propertyName)
  • public string MapXmlAttributeNameToPropertyName(Type type, string xmlName)
  • public string MapXmlElementNameToPropertyName(Type type, string xmlName)
  • public CatelTypeInfo RegisterProperties(Type type)
  • public void RegisterProperty(Type type, string name, PropertyData propertyData)
• public class PropertyValue
  • public int GraphId { get; set; }
  • public int GraphRefId { get; set; }
  • public PropertyData PropertyData { get; }
  • public PropertyValue(KeyValuePair<string, object> keyValuePair)
  • public PropertyValue(string name, object value)
  • public PropertyValue(PropertyData propertyData, KeyValuePair<string, object> keyValuePair)
  • public PropertyValue(PropertyData propertyData, string name, object value)
• public abstract class SavableDataObjectBase<T> : SavableModelBase<T>, ISavableDataObjectBase, ISavableModel, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable, ICloneable, ISerializable, IDeserializationCallback
• public abstract class SavableModelBase<T> : ModelBase, ISavableModel, IModel, INotifyPropertyChanging, INotifyPropertyChanged, IParent, INotifyDataErrorInfo, INotifyDataWarningInfo, IDataErrorInfo, IDataWarningInfo, IAdvancedEditableObject, IEditableObject, IXmlSerializable
  • protected SavableModelBase(SerializationInfo info, StreamingContext context)
  • public static T Load(string fileName, bool enableRedirects = false)
  • public static T Load(string fileName, SerializationMode mode, bool enableRedirects = false)
  • public static T Load(IRandomAccessStream fileStream, SerializationMode mode)
  • 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 = false)
  • public void Save(string fileName)
  • public void Save(string fileName, SerializationMode mode)
  • public static T Load(Stream stream, SerializationMode mode)
  • public void Save(IRandomAccessStream fileStream)
• public enum SerializationMode
  • Binary = 0
• public class ValidateModelAttribute : Attribute
  • public Type ValidatorType { get; }
  • public ValidateModelAttribute(Type validatorType)
• public class ValidationContext : IValidationContext
  • public DateTime LastModified { get; }
  • public long LastModifiedTicks { get; }
  • public ValidationContext(IEnumerable<IFieldValidationResult> fieldValidationResults, IEnumerable<IBusinessRuleValidationResult> businessRuleValidationResults, DateTime lastModified)
  • public void AddBusinessRuleValidationResult(IBusinessRuleValidationResult businessRuleValidationResult)
  • public void AddFieldValidationResult(IFieldValidationResult fieldValidationResult)
  • public void RemoveBusinessRuleValidationResult(IBusinessRuleValidationResult businessRuleValidationResult)
  • public void RemoveFieldValidationResult(IFieldValidationResult fieldValidationResult)
• public class ValidationSummary : IValidationSummary
  • public DateTime LastModified { get; }
  • public long LastModifiedTicks { get; }
  • public ValidationSummary(IValidationContext validationContext)
  • public ValidationSummary(IValidationContext validationContext, object tag)
• public abstract class ValidatorBase<TTargetType> : IValidator
  • public void Validate(object instance, ValidationContext validationContext)
  • protected virtual void Validate(TTargetType instance, ValidationContext validationContext)

Catel.ExceptionHandling

• public class BufferedEventArgs : EventArgs
  • public Exception BufferedException { get; }
  • public DateTime DateTime { get; }
  • public BufferedEventArgs(Exception bufferedException, DateTime dateTime)
• public class BufferPolicy : PolicyBase, IBufferPolicy, IPolicy
  • public BufferPolicy(int numberOfTimes, TimeSpan interval)
• public class ExceptionHandler : IExceptionHandler
  • public IBufferPolicy BufferPolicy { get; set; }
  • public Type ExceptionType { get; }
  • public IRetryPolicy RetryPolicy { get; set; }
  • public ExceptionHandler(Type exceptionTypeType, Action<Exception> action)
  • public void Handle(Exception exception)
• public static class ExceptionHandlerExtensions
  • public static void OnErrorRetry(this IExceptionHandler exceptionHandler, int numberOfTimes, TimeSpan interval)
  • public static void OnErrorRetryImmediately(this IExceptionHandler exceptionHandler, int numberOfTimes = 2147483647)
  • public static void UsingTolerance(this IExceptionHandler exceptionHandler, int numberOfTimes, TimeSpan interval)
• public class ExceptionService : IExceptionService
  • public event EventHandler<BufferedEventArgs> ExceptionBuffered
  • public event EventHandler<RetryingEventArgs> RetryingAction
  • public IExceptionHandler GetHandler(Type exceptionType)
  • public IExceptionHandler GetHandler<TException>() where TException : Exception
  • public bool IsExceptionRegistered<TException>() where TException : Exception
  • public bool IsExceptionRegistered(Type exceptionType)
  • protected virtual void OnExceptionBuffered(Exception bufferedException, DateTime dateTime)
  • protected virtual void OnRetryingAction(int retryCount, Exception lastError, TimeSpan delay)
  • public IExceptionHandler Register<TException>(Action<Exception> handler) where TException : Exception
  • 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 void ProcessWithRetry(Action action)
  • public TResult ProcessWithRetry<TResult>(Func<TResult> action)
  • public IExceptionHandler Register<TException>(Action<TException> handler) where TException : Exception
• public interface IBufferPolicy : IPolicy
• public interface IExceptionHandler
  • Type Exception { get; }
  • IBufferPolicy BufferPolicy { get; set; }
  • Type ExceptionType { get; }
  • IRetryPolicy RetryPolicy { get; set; }
• public interface IExceptionService
  • event EventHandler<BufferedEventArgs> ExceptionBuffered
  • event EventHandler<RetryingEventArgs> RetryingAction
  • IExceptionHandler GetHandler(Type exceptionType)
  • IExceptionHandler GetHandler<TException>() where TException : Exception
  • bool IsExceptionRegistered<TException>() where TException : Exception
  • bool IsExceptionRegistered(Type exceptionType)
  • IExceptionHandler Register<TException>(Action<Exception> handler) where TException : Exception
  • 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)
  • void ProcessWithRetry(Action action)
  • TResult ProcessWithRetry<TResult>(Func<TResult> action)
  • IExceptionHandler Register<TException>(Action<TException> handler) where TException : Exception
• public interface IPolicy
  • TimeSpan Interval { get; }
  • int NumberOfTimes { get; }
• public interface IRetryPolicy : IPolicy
• public class PolicyBase : IPolicy
  • public TimeSpan Interval { get; protected set; }
  • public int NumberOfTimes { get; protected set; }
  • public PolicyBase()
• public class RetryingEventArgs : EventArgs
  • public int CurrentRetryCount { get; }
  • public TimeSpan Delay { get; }
  • public Exception LastException { get; }
  • public RetryingEventArgs(int currentRetryCount, TimeSpan delay, Exception lastException)
• public class RetryPolicy : PolicyBase, IRetryPolicy, IPolicy
  • public RetryPolicy(int numberOfTimes, TimeSpan interval)

Catel.IO

• public static class Path
  • public static string GetApplicationDataDirectory()
  • public static string GetApplicationDataDirectory(string productName)
  • public static string GetApplicationDataDirectory(string companyName, string productName)
  • public static string GetFullPath(string relativePath, string basePath)

Catel.IoC

• public static class DependencyInjectionHelper
• public abstract class ExternalContainerHelperBase : IExternalContainerHelper
• public class CatelDependencyResolver : IDependencyResolver
  • public CatelDependencyResolver(IServiceLocator serviceLocator)
  • public bool CanResolve(Type type, object tag = null)
  • public bool CanResolveAll(Type[] types)
  • public object Resolve(Type type, object tag = null)
  • public object[] ResolveAll(Type[] types, object tag = null)
• public class CircularDependencyException : Exception
  • public ITypeRequestPath TypePath { get; }
• public static class DependencyResolverExtensions
  • public static bool CanResolve<T>(this IDependencyResolver dependencyResolver, object tag = null)
  • public static T Resolve<T>(this IDependencyResolver dependencyResolver, object tag = null)
• public class DependencyResolverManager : IDependencyResolverManager
  • public static IDependencyResolverManager Default { get; set; }
  • public IDependencyResolver DefaultDependencyResolver { get; set; }
  • public DependencyResolverManager()
  • public virtual IDependencyResolver GetDependencyResolverForInstance(object instance)
  • public virtual IDependencyResolver GetDependencyResolverForType(Type type)
  • public virtual void RegisterDependencyResolverForInstance(object instance, IDependencyResolver dependencyResolver)
  • public virtual void RegisterDependencyResolverForType(Type type, IDependencyResolver dependencyResolver)
• public interface IExternalContainerHelper
• public sealed class IoCConfigurationSection : ConfigurationSection
• public class FirstInterfaceRegistrationConvention : RegistrationConventionBase
  • public FirstInterfaceRegistrationConvention(IServiceLocator serviceLocator, RegistrationType registrationType = 0)
• public interface IDependencyResolver
  • bool CanResolve(Type type, object tag = null)
  • bool CanResolveAll(Type[] types)
  • object Resolve(Type type, object tag = null)
  • object[] ResolveAll(Type[] types, object tag = null)
• public interface IDependencyResolverManager
  • IDependencyResolver DefaultDependencyResolver { get; set; }
  • IDependencyResolver GetDependencyResolverForInstance(object instance)
  • IDependencyResolver GetDependencyResolverForType(Type type)
  • void RegisterDependencyResolverForInstance(object instance, IDependencyResolver dependencyResolver)
  • void RegisterDependencyResolverForType(Type type, IDependencyResolver dependencyResolver)
• public interface INeedCustomInitialization
  • void Initialize()
• public class InjectAttribute : Attribute
  • public object Tag { get; }
  • public Type Type { get; set; }
  • public InjectAttribute(Type type = null, object tag = null)
• public class InjectionConstructorAttribute : Attribute
  • public InjectionConstructorAttribute()
• public static class IoCConfiguration
  • public static IDependencyResolver DefaultDependencyResolver { get; }
  • public static IServiceLocator DefaultServiceLocator { get; }
  • public static ITypeFactory DefaultTypeFactory { get; }
  • 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; }
  • bool CanResolveNonAbstractTypesWithoutRegistration { get; set; }
  • event EventHandler<TypeInstantiatedEventArgs> TypeInstantiated
  • void ExportInstancesToExternalContainers()
  • void ExportToExternalContainers()
  • bool AreAllTypesRegistered(Type[] types)
  • bool IsExternalContainerSupported(object externalContainer)
  • bool IsTypeRegistered<TService>()
  • bool IsTypeRegisteredAsSingleton<TService>()
  • void RegisterExternalContainer(object externalContainer)
  • void RegisterExternalContainerHelper(IExternalContainerHelper externalContainerHelper)
  • void RegisterInstance<TService>(TService instance)
  • void RegisterType<TService, TServiceImplementation>(RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true) where TServiceImplementation : TService
  • void RegisterTypeIfNotYetRegistered<TService, TServiceImplementation>(RegistrationType registrationType = 0) where TServiceImplementation : TService
  • void RegisterTypeIfNotYetRegistered(Type serviceType, Type serviceImplementationType, object tag = null, RegistrationType registrationType = 0)
  • void RegisterType(Type serviceType, Func<ServiceLocatorRegistration, object> createServiceFunc, object tag = null, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true)
  • void RemoveAllTypes(Type serviceType)
  • TService ResolveType<TService>()
  • void RemoveType(Type serviceType, object tag = null)
  • object[] ResolveAllTypes(Type[] types)
  • IEnumerable<TService> ResolveTypes<TService>()
• public interface IServiceLocatorInitializer
  • void Initialize(IServiceLocator serviceLocator)
• public interface ITypeFactory
  • T CreateInstance<T>()
  • T CreateInstanceUsingActivator<T>()
  • object CreateInstanceWithParametersAndAutoCompletion(Type typeToConstruct, object[] parameters)
• public interface ITypeRequestPath
  • TypeRequestInfo[] AllTypes { get; }
  • TypeRequestInfo FirstType { get; }
  • bool IgnoreValueTypes { get; }
  • bool IsValid { get; }
  • TypeRequestInfo LastType { get; }
  • string Name { get; }
  • int TypeCount { get; }
  • void ThrowsExceptionIfInvalid()
• public sealed class LateBoundImplementation
• public class Registration : ConfigurationElement
• public class NamingRegistrationConvention : RegistrationConventionBase
  • public NamingRegistrationConvention(IServiceLocator serviceLocator, RegistrationType registrationType = 0)
• public static class ObjectExtensions
  • public static IDependencyResolver GetDependencyResolver(this object obj)
  • public static IServiceLocator GetServiceLocator(this object obj)
  • public static ITypeFactory GetTypeFactory(this object obj)
• 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 bool IsTypeInstantiatedForSingleton { get; }
• public class ServiceLocator : IServiceLocator, IServiceProvider
  • public static IServiceLocator Instance { get; }
  • public bool AutomaticallyKeepContainersSynchronized { get; set; }
  • public bool CanResolveNonAbstractTypesWithoutRegistration { get; set; }
  • public event EventHandler<TypeInstantiatedEventArgs> TypeInstantiated
  • public void ExportInstancesToExternalContainers()
  • public void ExportToExternalContainers()
  • public bool AreAllTypesRegistered(Type[] types)
  • public bool IsExternalContainerSupported(object externalContainer)
  • public bool IsTypeRegistered<TService>()
  • public bool IsTypeRegisteredAsSingleton<TService>()
  • public void RegisterExternalContainer(object externalContainer)
  • public void RegisterExternalContainerHelper(IExternalContainerHelper externalContainerHelper)
  • public void RegisterInstance<TService>(TService instance)
  • public void RegisterType<TService, TServiceImplementation>(RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true) where TServiceImplementation : TService
  • public void RegisterTypeIfNotYetRegistered<TService, TServiceImplementation>(RegistrationType registrationType = 0) where TServiceImplementation : TService
  • public void RegisterTypeIfNotYetRegistered(Type serviceType, Type serviceImplementationType, object tag = null, RegistrationType registrationType = 0)
  • public void RegisterType(Type serviceType, Func<ServiceLocatorRegistration, object> createServiceFunc, object tag = null, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true)
  • public void RemoveAllTypes(Type serviceType)
  • public TService ResolveType<TService>()
  • public void RemoveType(Type serviceType, object tag = null)
  • public object[] ResolveAllTypes(Type[] types)
  • public IEnumerable<TService> ResolveTypes<TService>()
• public sealed class ServiceLocatorConfiguration : ConfigurationElementCollection
• public sealed class ServiceLocatorConfigurationCollection : ConfigurationElementCollection
• public static class ServiceLocatorExtensions
  • 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, TServiceImplementation>(this IServiceLocator serviceLocator, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true) where TServiceImplementation : TService
  • public static void RegisterType<TService>(this IServiceLocator serviceLocator, Func<ServiceLocatorRegistration, TService> createServiceFunc, RegistrationType registrationType = 0, bool registerIfAlreadyRegistered = true)
  • public static void RegisterTypeIfNotYetRegistered<TService, TServiceImplementation>(this IServiceLocator serviceLocator, RegistrationType registrationType = 0) where TServiceImplementation : TService
  • 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 static T ResolveTypeAndReturnNullIfNotRegistered<T>(this IServiceLocator serviceLocator, object tag = null)
  • public static object ResolveTypeAndReturnNullIfNotRegistered(this IServiceLocator serviceLocator, Type serviceType, object tag = null)
  • public static IEnumerable<TService> ResolveTypes<TService>(this IServiceLocator serviceLocator)
  • public static object ResolveTypeUsingParameter(this IServiceLocator serviceLocator, Type serviceType, object[] parameters, object tag = null)
  • public static T ResolveTypeUsingParameters<T>(this IServiceLocator serviceLocator, object[] parameters, object tag = null)
• public class ServiceLocatorRegistration
  • public Func<ServiceLocatorRegistration, object> CreateServiceFunc { get; }
  • public Type DeclaringType { get; }
  • public string DeclaringTypeName { get; }
  • public Type ImplementingType { get; }
  • public string ImplementingTypeName { get; }
  • public RegistrationType RegistrationType { get; }
  • public object Tag { get; }
  • public ServiceLocatorRegistration(Type declaringType, Type implementingType, object tag, RegistrationType registrationType, Func<ServiceLocatorRegistration, object> createServiceFunc)
• public class ServiceLocatorRegistrationAttribute : Attribute
  • public ServiceLocatorRegistrationMode RegistrationMode { get; }
  • public ServiceLocatorRegistrationAttribute(Type interfaceType, RegistrationType registrationType = 0, object tag = null)
  • public ServiceLocatorRegistrationAttribute(Type interfaceType, ServiceLocatorRegistrationMode registrationMode = 2, object tag = null)
• public class ServiceLocatorRegistrationGroup
  • public ServiceLocatorRegistration EntryRegistration { get; }
  • public ServiceLocatorRegistrationGroup(ServiceLocatorRegistration entryRegistration)
• public enum ServiceLocatorRegistrationMode
  • SingletonInstantiateImmediately = 1
  • SingletonInstantiateWhenRequired = 2
  • Transient = 0
• public class TypeFactory : ITypeFactory
  • public TypeFactory(IServiceLocator serviceLocator)
  • public TypeFactory(IDependencyResolver dependencyResolver)
  • public T CreateInstance<T>()
  • public T CreateInstanceUsingActivator<T>()
  • public object CreateInstanceWithParametersAndAutoCompletion(Type typeToConstruct, object[] parameters)
• public static class TypeFactoryExtensions
  • public static T CreateInstance<T>(this ITypeFactory typeFactory)
  • public static T CreateInstanceUsingActivator<T>(this ITypeFactory typeFactory)
  • public static T CreateInstanceWithParameters<T>(this ITypeFactory typeFactory, object[] parameters)
  • public static T CreateInstanceWithParametersAndAutoCompletion<T>(this ITypeFactory typeFactory, object[] parameters)
• public class TypeInstantiatedEventArgs : EventArgs
  • public RegistrationType RegistrationType { get; }
  • public Type ServiceImplementationType { get; }
  • public Type ServiceType { get; }
  • public object Tag { get; }
  • public TypeInstantiatedEventArgs(Type serviceType, Type serviceImplementationType, object tag, RegistrationType registrationType)
• public class TypeRequestInfo
  • public object Tag { get; }
  • public Type Type { get; }
  • public TypeRequestInfo(Type type, object tag = null)
  • public static bool op_Equality(TypeRequestInfo firstObject, TypeRequestInfo secondObject)
  • public static bool op_Inequality(TypeRequestInfo firstObject, TypeRequestInfo secondObject)
• public class TypeRequestPath : ITypeRequestPath
  • public TypeRequestInfo[] AllTypes { get; }
  • public TypeRequestInfo FirstType { get; }
  • public bool IgnoreDuplicateRequestsDirectlyAfterEachother { get; set; }
  • public bool IgnoreValueTypes { get; }
  • public bool IsValid { get; }
  • public TypeRequestInfo LastType { get; }
  • public string Name { get; }
  • public int TypeCount { get; }
  • public TypeRequestPath(TypeRequestInfo typeRequestInfo, bool ignoreValueTypes = true, string name = null)
  • public TypeRequestPath(TypeRequestInfo[] typeRequestInfos, bool ignoreValueTypes = true, string name = null)
  • public void MarkTypeAsCreated(TypeRequestInfo typeRequestInfo)
  • public void MarkTypeAsNotCreated(TypeRequestInfo typeRequestInfo)
  • public void PopType()
  • public void PushType(TypeRequestInfo typeRequestInfo, bool throwExceptionForDuplicateTypes)
  • public void ThrowsExceptionIfInvalid()

Catel.Logging

• public abstract class BatchLogListenerBase : LogListenerBase, IBatchLogListener
  • public int MaximumBatchCount { get; }
  • public BatchLogListenerBase(int maxBatchCount = 50)
  • public void Flush()
  • protected abstract void WriteBatch(List<LogBatchEntry> batchEntries)
• public class ConsoleLogListener : LogListenerBase
  • public ConsoleLogListener()
• public interface IBatchLogListener
  • void Flush()
• 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 class LogBatchEntry
  • public object ExtraData { get; }
  • public ILog Log { get; }
  • public LogEvent LogEvent { get; }
  • public string Message { get; }
  • public LogBatchEntry(ILog log, string message, LogEvent logEvent, object extraData)
• 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 bool? IsDebugEnabled { get; set; }
  • public static bool? IsErrorEnabled { get; set; }
  • public static bool? IsInfoEnabled { get; set; }
  • public static bool? IsWarningEnabled { get; set; }
  • public static ILogListener AddDebugListener(bool ignoreCatelLogging = false)
  • public static void FlushAll()
  • public static ILogListener RegisterDebugListener()
  • public static ILogListener RegisterDebugListener(bool ignoreCatelLogging)

Catel.Memento

• public class ActionUndo : UndoBase
• public enum CollectionChangeType
• public class CollectionChangeUndo : UndoBase
• public class CollectionObserver : ObserverBase
• public sealed class IgnoreMementoSupportAttribute : Attribute
• public interface IMementoService
• public interface IMementoSupport
• public class MementoService : IMementoService
• public class ObjectObserver : ObserverBase
• public abstract class ObserverBase
• public class OperationSet : UndoBase
• public class PropertyChangeUndo : UndoBase
• public abstract class UndoBase : IMementoSupport

Catel.Messaging

• public interface IMessageMediator
  • bool IsMessageRegistered<TMessage>(object tag = null)
  • bool IsMessageRegistered(Type messageType, object tag = null)
• public class MessageMediator : IMessageMediator
  • public bool IsMessageRegistered<TMessage>(object tag = null)
  • public bool IsMessageRegistered(Type messageType, object tag = null)

Catel.Reflection

• public static class AppDomainExtensions
  • public static void LoadAssemblyIntoAppDomain(this AppDomain appDomain, string assemblyFilename, bool includeReferencedAssemblies = true)
  • public static void LoadAssemblyIntoAppDomain(this AppDomain appDomain, Assembly assembly, bool includeReferencedAssemblies = true)
  • public static void LoadAssemblyIntoAppDomain(this AppDomain appDomain, AssemblyName assemblyName, bool includeReferencedAssemblies = true)
  • public static void PreloadAssemblies(this AppDomain appDomain, string directory = null)
• 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 MemberInfoExtensions
  • public static bool IsStatic(this PropertyInfo propertyInfo)
• public static class ObjectExtensions
  • public static Attribute[] ToAttributeArray(this object[] objects)
• public static class PropertyHelper
  • public static TValue GetHiddenPropertyValue<TValue>(object obj, string property, Type baseType)
  • public static string GetPropertyName(Expression propertyExpression, bool allowNested = false)
• public static class ReflectionExtensions
  • public static bool ContainsGenericParametersEx(this Type type)
  • public static object GetCustomAttributeEx(this Assembly assembly, Type attributeType, bool inherit)
  • public static object GetCustomAttributeEx(this MethodInfo methodInfo, Type attributeType, bool inherit)
  • public static object GetCustomAttributeEx(this PropertyInfo propertyInfo, Type attributeType, bool inherit)
  • public static object GetCustomAttributeEx(this Type type, Type attributeType, bool inherit)
  • public static object[] GetCustomAttributesEx(this Assembly assembly, Type attributeType, bool inherit)
  • public static object[] GetCustomAttributesEx(this MethodInfo methodInfo, Type attributeType, bool inherit)
  • public static object[] GetCustomAttributesEx(this PropertyInfo propertyInfo, Type attributeType, bool inherit)
  • public static object[] GetCustomAttributesEx(this Type type, Type attributeType, bool inherit)
  • public static Attribute GetCustomAttributeEx(this Assembly assembly, Type attributeType)
  • public static Attribute GetCustomAttributeEx(this MethodInfo methodInfo, Type attributeType, bool inherit)
  • public static Attribute GetCustomAttributeEx(this PropertyInfo propertyInfo, Type attributeType, bool inherit)
  • public static Attribute GetCustomAttributeEx(this Type type, Type attributeType, bool inherit)
  • public static Attribute[] GetCustomAttributesEx(this Assembly assembly, Type attributeType)
  • public static Attribute[] GetCustomAttributesEx(this MethodInfo methodInfo, bool inherit)
  • public static Attribute[] GetCustomAttributesEx(this MethodInfo methodInfo, Type attributeType, bool inherit)
  • public static Attribute[] GetCustomAttributesEx(this PropertyInfo propertyInfo, bool inherit)
  • public static Attribute[] GetCustomAttributesEx(this PropertyInfo propertyInfo, Type attributeType, bool inherit)
  • public static Attribute[] GetCustomAttributesEx(this Type type, bool inherit)
  • public static Attribute[] GetCustomAttributesEx(this Type type, Type attributeType, bool inherit)
  • 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 string GetSafeFullName(this Type type)
  • public static bool ImplementsInterfaceEx<TInterface>(this Type type)
  • public static bool IsClassEx(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 string ConvertTypeToVersionIndependentType(string type)
  • public static string FormatInnerTypes(string[] innerTypes)
  • public static string ConvertTypeToVersionIndependentType(string type, bool stripAssemblies = false)
  • public static string FormatInnerTypes(string[] innerTypes, bool stripAssemblies = false)
  • 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 IsTypeNullable(Type type)

Catel.Runtime

• public class ReferenceEqualityComparer<TObject> : IEqualityComparer<TObject>
  • public ReferenceEqualityComparer()
  • public bool Equals(TObject x, TObject y)
  • public int GetHashCode(TObject obj)
• public class ReferenceInfo
  • public int Id { get; }
  • public object Instance { get; }
  • public bool IsFirstUsage { get; }
  • public ReferenceInfo(object instance, int id, bool isFirstUsage)
• public class ReferenceManager
  • public int Count { get; }
  • public ReferenceManager()
  • public ReferenceInfo GetInfo(object instance)
  • public ReferenceInfo GetInfoAt(int index)
  • public ReferenceInfo GetInfoById(int id)
  • public void RegisterManually(int id, object instance)

Catel.Runtime.Serialization

• public class RedirectTypeAttribute : Attribute
• public static class SerializationHelper
• public static class XmlSchemaHelper
• public class XmlSchemaManager
• public class ExcludeFromSerializationAttribute : Attribute
  • public ExcludeFromSerializationAttribute()
• public interface IModelBaseSerializer
  • event EventHandler<SerializationEventArgs> Deserialized
  • event EventHandler<MemberSerializationEventArgs> DeserializedMember
  • event EventHandler<SerializationEventArgs> Deserializing
  • event EventHandler<MemberSerializationEventArgs> DeserializingMember
  • event EventHandler<SerializationEventArgs> Serialized
  • event EventHandler<MemberSerializationEventArgs> SerializedMember
  • event EventHandler<SerializationEventArgs> Serializing
  • event EventHandler<MemberSerializationEventArgs> SerializingMember
  • void Deserialize(ModelBase model, Stream stream)
  • ModelBase Deserialize(Type modelType, Stream stream)
  • List<MemberValue> DeserializeMembers(Type modelType, Stream stream)
  • List<MemberValue> GetSerializableMembers(ModelBase model, string[] membersToIgnore)
  • void Serialize(ModelBase model, Stream stream)
  • void SerializeMembers(ModelBase model, Stream stream, string[] membersToIgnore)
  • void Warmup(IEnumerable<Type> types = null, int typesPerThread = 1000)
• public interface IModelBaseSerializer<TSerializationContext> : IModelBaseSerializer
  • void Deserialize(ModelBase model, TSerializationContext serializationContext)
  • ModelBase Deserialize(Type modelType, TSerializationContext serializationContext)
  • List<MemberValue> DeserializeMembers(Type modelType, TSerializationContext serializationContext)
  • void Serialize(ModelBase model, TSerializationContext serializationContext)
• public class IncludeInSerializationAttribute : Attribute
  • public IncludeInSerializationAttribute()
• public interface ISerializationContext : IDisposable
  • SerializationContextMode ContextMode { get; }
  • int Depth { get; }
  • ModelBase Model { get; }
  • Type ModelType { get; }
  • ReferenceManager ReferenceManager { get; }
• public interface ISerializationContext<TSerializationContext> : ISerializationContext, IDisposable
  • TSerializationContext Context { get; }
• public interface ISerializationManager
  • Dictionary<string, MemberMetadata> GetCatelProperties(Type type)
  • HashSet<string> GetCatelPropertyNames(Type type)
  • HashSet<string> GetFieldNames(Type type)
  • Dictionary<string, MemberMetadata> GetFields(Type type)
  • HashSet<string> GetFieldsToSerialize(Type type)
  • HashSet<string> GetPropertiesToSerialize(Type type)
  • Dictionary<string, MemberMetadata> GetRegularProperties(Type type)
  • HashSet<string> GetRegularPropertyNames(Type type)
  • ISerializerModifier[] GetSerializerModifiers(Type type)
  • void Warmup(Type type)
• public interface ISerializerModifier
  • void DeserializeMember(ISerializationContext context, MemberValue memberValue)
  • void OnDeserialized(ISerializationContext context, IModel model)
  • void OnDeserializing(ISerializationContext context, IModel model)
  • void OnSerialized(ISerializationContext context, IModel model)
  • void OnSerializing(ISerializationContext context, IModel model)
  • void SerializeMember(ISerializationContext context, MemberValue memberValue)
  • bool ShouldIgnoreMember(ISerializationContext context, IModel model, MemberValue memberValue)
• public class MemberMetadata
  • public Type ContainingType { get; }
  • public SerializationMemberGroup MemberGroup { get; }
  • public string MemberName { get; }
  • public Type MemberType { get; }
  • public MemberMetadata(Type containingType, Type memberType, SerializationMemberGroup memberGroup, string memberName)
• public class MemberSerializationEventArgs : SerializationEventArgs
  • public MemberValue MemberValue { get; }
  • public MemberSerializationEventArgs(ISerializationContext serializationContext, MemberValue memberValue)
• public class MemberValue
  • public SerializationMemberGroup MemberGroup { get; }
  • public Type ModelType { get; }
  • public string Name { get; }
  • public Type Type { get; }
  • public object Value { get; set; }
  • public MemberValue(SerializationMemberGroup memberGroup, Type modelType, Type type, string name, object value)
• public class SerializationContext<TContext> : ISerializationContext<TContext>, ISerializationContext, IDisposable
  • public TContext Context { get; }
  • public SerializationContextMode ContextMode { get; }
  • public int Depth { get; }
  • public ModelBase Model { get; }
  • public Type ModelType { get; }
  • public ReferenceManager ReferenceManager { get; }
  • public SerializationContext(ModelBase model, TContext context, SerializationContextMode contextMode)
  • public void Dispose()
• public static class SerializationContextHelper
  • public static string GetSerializationReferenceManagerScopeName()
• public enum SerializationContextMode
  • Deserialization = 1
  • Serialization = 0
• public class SerializationEventArgs : EventArgs
  • public ISerializationContext SerializationContext { get; }
  • public SerializationEventArgs(ISerializationContext serializationContext)
• public static class SerializationFactory
  • public static IXmlSerializer GetXmlSerializer()
• public class SerializationManager : ISerializationManager
  • public SerializationManager()
  • public Dictionary<string, MemberMetadata> GetCatelProperties(Type type)
  • public HashSet<string> GetCatelPropertyNames(Type type)
  • public HashSet<string> GetFieldNames(Type type)
  • public Dictionary<string, MemberMetadata> GetFields(Type type)
  • public virtual HashSet<string> GetFieldsToSerialize(Type type)
  • public virtual HashSet<string> GetPropertiesToSerialize(Type type)
  • public Dictionary<string, MemberMetadata> GetRegularProperties(Type type)
  • public HashSet<string> GetRegularPropertyNames(Type type)
  • public virtual ISerializerModifier[] GetSerializerModifiers(Type type)
  • public void Warmup(Type type)
• public enum SerializationMemberGroup
  • CatelProperty = 0
  • Field = 2
  • RegularProperty = 1
• public class SerializationObject
  • public bool IsSuccessful { get; }
  • public SerializationMemberGroup MemberGroup { get; }
  • public string MemberName { get; }
  • public object MemberValue { get; }
  • public Type ModelType { get; }
  • public static SerializationObject FailedToDeserialize(Type modelType, SerializationMemberGroup memberGroup, string memberName)
  • public static SerializationObject SucceededToDeserialize(Type modelType, SerializationMemberGroup memberGroup, string memberName, object memberValue)
• public abstract class SerializerBase<TSerializationContext> : IModelBaseSerializer<TSerializationContext>, IModelBaseSerializer
  • protected ISerializationManager SerializationManager { get; }
  • public event EventHandler<SerializationEventArgs> Deserialized
  • public event EventHandler<MemberSerializationEventArgs> DeserializedMember
  • public event EventHandler<SerializationEventArgs> Deserializing
  • public event EventHandler<MemberSerializationEventArgs> DeserializingMember
  • public event EventHandler<SerializationEventArgs> Serialized
  • public event EventHandler<MemberSerializationEventArgs> SerializedMember
  • public event EventHandler<SerializationEventArgs> Serializing
  • public event EventHandler<MemberSerializationEventArgs> SerializingMember
  • protected SerializerBase(ISerializationManager serializationManager)
  • protected virtual void AfterDeserialization(ISerializationContext<TSerializationContext> context)
  • protected virtual void AfterDeserializeMember(ISerializationContext<TSerializationContext> context, MemberValue memberValue)
  • protected virtual void AfterSerialization(ISerializationContext<TSerializationContext> context)
  • protected virtual void AfterSerializeMember(ISerializationContext<TSerializationContext> context, MemberValue memberValue)
  • protected abstract void AppendContextToStream(ISerializationContext<TSerializationContext> context, Stream stream)
  • protected virtual void BeforeDeserialization(ISerializationContext<TSerializationContext> context)
  • protected virtual void BeforeDeserializeMember(ISerializationContext<TSerializationContext> context, MemberValue memberValue)
  • protected virtual void BeforeSerialization(ISerializationContext<TSerializationContext> context)
  • protected virtual void BeforeSerializeMember(ISerializationContext<TSerializationContext> context, MemberValue memberValue)
  • public virtual void Deserialize(ModelBase model, Stream stream)
  • public virtual void Deserialize(ModelBase model, TSerializationContext serializationContext)
  • public virtual ModelBase Deserialize(Type modelType, Stream stream)
  • public virtual ModelBase Deserialize(Type modelType, TSerializationContext serializationContext)
  • protected abstract SerializationObject DeserializeMember(ISerializationContext<TSerializationContext> context, MemberValue memberValue)
  • public virtual List<MemberValue> DeserializeMembers(Type modelType, Stream stream)
  • public virtual List<MemberValue> DeserializeMembers(Type modelType, TSerializationContext serializedContext)
  • protected virtual List<MemberValue> DeserializeMembers(ISerializationContext<TSerializationContext> context)
  • protected ISerializationContext<TSerializationContext> GetContext(Type modelType, TSerializationContext context, SerializationContextMode contextMode)
  • protected ISerializationContext<TSerializationContext> GetContext(Type modelType, Stream stream, SerializationContextMode contextMode)
  • protected virtual ISerializationContext<TSerializationContext> GetContext(ModelBase model, TSerializationContext context, SerializationContextMode contextMode)
  • protected abstract ISerializationContext<TSerializationContext> GetContext(ModelBase model, Stream stream, SerializationContextMode contextMode)
  • protected SerializationMemberGroup GetMemberGroup(Type modelType, string memberName)
  • protected Type GetMemberType(Type modelType, string memberName)
  • public virtual List<MemberValue> GetSerializableMembers(ModelBase model, string[] membersToIgnore)
  • protected virtual void PopulateModel(ModelBase model, MemberValue[] members)
  • public virtual void Serialize(ModelBase model, Stream stream)
  • public virtual void Serialize(ModelBase model, TSerializationContext context)
  • protected abstract void SerializeMember(ISerializationContext<TSerializationContext> context, MemberValue memberValue)
  • public virtual void SerializeMembers(ModelBase model, Stream stream, string[] membersToIgnore)
  • protected virtual void SerializeMembers(ISerializationContext<TSerializationContext> context, List<MemberValue> membersToSerialize)
  • protected virtual bool ShouldIgnoreMember(ModelBase model, string propertyName)
  • public void Warmup(IEnumerable<Type> types, int typesPerThread = 1000)
  • protected abstract void Warmup(Type type)
• public class SerializerModifierAttribute : Attribute
  • public Type SerializerModifierType { get; }
  • public SerializerModifierAttribute(Type serializerModifierType)
• public abstract class SerializerModifierBase : ISerializerModifier
  • protected SerializerModifierBase()
  • public virtual void DeserializeMember(ISerializationContext context, MemberValue memberValue)
  • public virtual void OnDeserialized(ISerializationContext context, IModel model)
  • public virtual void OnDeserializing(ISerializationContext context, IModel model)
  • public virtual void OnSerialized(ISerializationContext context, IModel model)
  • public virtual void OnSerializing(ISerializationContext context, IModel model)
  • public virtual void SerializeMember(ISerializationContext context, MemberValue memberValue)
  • public virtual bool ShouldIgnoreMember(ISerializationContext context, IModel model, MemberValue memberValue)
• public abstract class SerializerModifierBase<TModel> : SerializerModifierBase where TModel : IModel
  • protected SerializerModifierBase()
  • public virtual void OnDeserialized(ISerializationContext context, TModel model)
  • public virtual void OnDeserializing(ISerializationContext context, TModel model)
  • public virtual void OnSerialized(ISerializationContext context, TModel model)
  • public virtual void OnSerializing(ISerializationContext context, TModel model)

Catel.Runtime.Serialization.Xml

• public class DataContractSerializerFactory : IDataContractSerializerFactory
  • protected class XmlSerializerTypeInfo
  • public DataContractSerializerFactory()
  • protected virtual bool AddTypeToKnownTypesIfSerializable(Type typeToAdd, XmlSerializerTypeInfo serializerTypeInfo)
  • protected virtual bool AllowNonPublicReflection(Type type)
  • public virtual DataContractSerializer GetDataContractSerializer(Type serializingType, Type typeToSerialize, string xmlName, string rootNamespace = null, object serializingObject = null, List<Type> additionalKnownTypes = null)
  • protected virtual void GetKnownTypes(Type type, XmlSerializerTypeInfo serializerTypeInfo)
  • protected virtual void GetKnownTypesForInstance(object obj, XmlSerializerTypeInfo serializerTypeInfo)
  • protected virtual Type[] GetKnownTypesViaAttributes(Type type)
  • protected virtual bool ShouldTypeBeIgnored(Type type, XmlSerializerTypeInfo serializerTypeInfo)
• public interface IDataContractSerializerFactory
  • DataContractSerializer GetDataContractSerializer(Type serializingType, Type typeToSerialize, string xmlName, string rootNamespace = null, object serializingObject = null, List<Type> additionalKnownTypes = null)
• public interface IXmlNamespaceManager
  • XmlNamespace GetNamespace(Type type, string preferredPrefix)
• public interface IXmlSerializer : IModelBaseSerializer<XmlSerializationContextInfo>, IModelBaseSerializer
  • XmlSerializerOptimalizationMode OptimalizationMode { get; set; }
• public static class XmlHelper
  • public static object ConvertToObject(XElement element, Type objectType, Func<object> createDefaultValue)
  • public static XElement ConvertToXml(string elementName, Type objectType, object objectValue)
• public class XmlNamespace
  • public string Prefix { get; }
  • public string Uri { get; }
  • public XmlNamespace(string prefix, string uri)
• public class XmlNamespaceManager : IXmlNamespaceManager
  • public XmlNamespaceManager()
  • public XmlNamespace GetNamespace(Type type, string preferredPrefix)
• public class XmlSerializationContextInfo
  • public XElement Element { get; }
  • public ModelBase Model { get; }
  • public XmlSerializationContextInfo(XElement element, ModelBase model)
• public class XmlSerializer : SerializerBase<XmlSerializationContextInfo>, IXmlSerializer, IModelBaseSerializer<XmlSerializationContextInfo>, IModelBaseSerializer
  • public XmlSerializerOptimalizationMode OptimalizationMode { get; set; }
  • public XmlSerializer(ISerializationManager serializationManager, IDataContractSerializerFactory dataContractSerializerFactory, IXmlNamespaceManager xmlNamespaceManager)
  • protected virtual string GetNamespacePrefix()
  • protected virtual string GetNamespaceUrl()
  • protected virtual void OptimizeXDocument(XDocument document)
• public enum XmlSerializerOptimalizationMode
  • Performance = 1
  • PrettyXml = 0

Catel.Scoping

• public class ScopeClosedEventArgs : EventArgs
  • public string ScopeName { get; }
  • public object ScopeObject { get; }
  • public ScopeClosedEventArgs(object scopeObject, string scopeName)
• public class ScopeManager<T> : IDisposable
  • public int RefCount { get; }
  • public T ScopeObject { get; }
  • public event EventHandler<ScopeClosedEventArgs> ScopeClosed
  • protected ScopeManager(string scopeName, Func<T> createScopeFunction)
  • public static ScopeManager<T> GetScopeManager(string scopeName = "", Func<T> createScopeFunction = null)
  • public static bool ScopeExists(string scopeName = "")
  • public void Dispose()

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()

Catel.Test

• public static class ExceptionTester
  • public static void CallMethodAndExpectException<TException>(Action action, Func<TException, bool> exceptionValidator = null) where TException : Exception
  • public static TException CallMethodAndExpectException<TException>(Action action, Func<TException, bool> exceptionValidator = null) where TException : Exception

System

• public sealed class AppDomain
  • public static AppDomain CurrentDomain { get; }
  • public AppDomain()
  • public Assembly[] GetAssemblies()

System.ComponentModel

• public class BackgroundWorker : DependencyObject
  • public bool CancellationPending { get; }
  • public bool IsBusy { get; set; }
  • public bool WorkerReportsProgress { get; set; }
  • public bool WorkerSupportsCancellation { get; set; }
  • public event DoWorkEventHandler DoWork
  • public event ProgressChangedEventHandler ProgressChanged
  • public event RunWorkerCompletedEventHandler RunWorkerCompleted
  • public BackgroundWorker()
  • public void CancelAsync()
  • protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
  • public void ReportProgress(int percentProgress)
  • public void ReportProgress(int percentProgress, object userState)
  • public void RunWorkerAsync()
  • public void RunWorkerAsync(object userState)
• public class DoWorkEventArgs : EventArgs
  • public object Argument { get; set; }
  • public bool Cancel { get; set; }
  • public object Result { get; set; }
  • public DoWorkEventArgs()
  • public DoWorkEventArgs(object argument)
• public sealed delegate DoWorkEventHandler : MulticastDelegate
  • public DoWorkEventHandler(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(object sender, DoWorkEventArgs e, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(object sender, DoWorkEventArgs e)
• public interface IDataErrorInfo
  • string Error { get; }
  • string this[string columnName] { get; }
• public interface INotifyPropertyChanging
  • event PropertyChangingEventHandler PropertyChanging
• public class PropertyChangingEventArgs : EventArgs
  • public string PropertyName { get; }
  • public PropertyChangingEventArgs(string propertyName)
• public sealed delegate PropertyChangingEventHandler : MulticastDelegate
  • public PropertyChangingEventHandler(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(object sender, PropertyChangingEventArgs e, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(object sender, PropertyChangingEventArgs e)
• public class RunWorkerCompletedEventArgs : EventArgs
  • public bool Cancelled { get; set; }
  • public Exception Error { get; set; }
  • public object Result { get; set; }
  • public RunWorkerCompletedEventArgs()
  • public RunWorkerCompletedEventArgs(object result, Exception error, bool cancelled)
• public sealed delegate RunWorkerCompletedEventHandler : MulticastDelegate
  • public RunWorkerCompletedEventHandler(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(object sender, RunWorkerCompletedEventArgs e, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(object sender, RunWorkerCompletedEventArgs e)

System.Reflection

• public enum BindingFlags
  • CreateInstance = 512
  • DeclaredOnly = 2
  • Default = 0
  • ExactBinding = 65536
  • FlattenHierarchy = 64
  • GetField = 1024
  • GetProperty = 4096
  • IgnoreCase = 1
  • IgnoreReturn = 16777216
  • Instance = 4
  • InvokeMethod = 256
  • NonPublic = 32
  • OptionalParamBinding = 262144
  • Public = 16
  • PutDispProperty = 16384
  • PutRefDispProperty = 32768
  • SetField = 2048
  • SetProperty = 8192
  • Static = 8
  • SuppressChangeType = 131072

System.Threading

• public class Timer
  • public int Interval { get; set; }
  • public event EventHandler<EventArgs> Elapsed
  • public Timer()
  • public Timer(int interval)
  • public Timer(TimerCallback callback, object state, int dueTime, int interval)
• public sealed delegate TimerCallback : MulticastDelegate
  • public TimerCallback(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(object state, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(object state)