Catel.Core by GeertvanHorrik

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

---

API Diff between 3.9.0.1402161444-beta and 3.6.1307112354-beta

660 Additions 98 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 CoreModule()
  • public void Initialize(IServiceLocator serviceLocator)
• 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 NotSupportedInWindows8Exception : Exception
• public class NotSupportedInWindowsPhone7Exception : 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 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)

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.Configuration

• 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 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
• 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 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
• public static class IParentExtensions
  • public static TParent FindParent<TParent>(IParent model, int maxLevels = -1)
• 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; }
  • public static T Load<T>(IRandomAccessStream fileStream, bool enableRedirects = false)
  • public static T Load<T>(IRandomAccessStream fileStream, 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)
  • protected virtual object GetPropertyValueForDeserialization(PropertyData property, object serializedValue)
  • protected virtual object GetPropertyValueForSerialization(PropertyData property, object propertyValue)
  • protected void InitializePropertyAfterConstruction(PropertyData property)
• 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 PropertyData
  • 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
• 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 = 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 static T Load(Stream stream, SerializationMode mode)

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
  • 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
  • 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.IoC

• 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 static class DependencyInjectionHelper
• public abstract class ExternalContainerHelperBase : IExternalContainerHelper
• 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 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 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; }
  • event EventHandler<TypeInstantiatedEventArgs> TypeInstantiated
  • 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)
  • void RemoveAllTypes(Type serviceType)
  • void RemoveType(Type serviceType, object tag = null)
• public interface IServiceLocatorInitializer
  • void Initialize(IServiceLocator serviceLocator)
• public interface ITypeFactory
  • object CreateInstanceWithParametersAndAutoCompletion(Type typeToConstruct, object[] parameters)
• public interface ITypeRequestPath
  • string Name { get; }
  • void ThrowsExceptionIfInvalid()
• public sealed class LateBoundImplementation
• 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 class ServiceLocator : IServiceLocator, IServiceProvider
  • public static IServiceLocator Instance { get; }
  • public bool AutomaticallyKeepContainersSynchronized { get; set; }
  • public event EventHandler<TypeInstantiatedEventArgs> TypeInstantiated
  • 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 void RemoveAllTypes(Type serviceType)
  • public void RemoveType(Type serviceType, object tag = null)
• 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 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 object CreateInstanceWithParametersAndAutoCompletion(Type typeToConstruct, object[] parameters)
• public static class TypeFactoryExtensions
  • 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 TypeRequestPath : ITypeRequestPath
  • public bool IgnoreDuplicateRequestsDirectlyAfterEachother { get; set; }
  • public string Name { get; }
  • public TypeRequestPath(TypeRequestInfo typeRequestInfo, bool ignoreValueTypes = true)
  • public TypeRequestPath(TypeRequestInfo[] typeRequestInfos, bool ignoreValueTypes = true)
  • 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 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 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.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 MemberInfoExtensions
  • public static bool IsStatic(this PropertyInfo propertyInfo)
• public static class ObjectExtensions
  • public static Attribute[] ToAttributeArray(this object[] objects)
• 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 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 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()