<PackageReference Include="Castle.Core" Version="4.4.1" />

---

API Differences between 4.4.1 and 5.0.0

636 Additions 118 Removals

Castle.Components.DictionaryAdapter

• public class BindingList<T> : IBindingList<T>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IBindingListSource, ICancelAddNew, IRaiseItemChangedEvents, IList, ICollection
• public class BindingListInitializer<T> : IValueInitializer
• public abstract class DictionaryAdapterBase : IDictionaryCreate, IDictionaryAdapter, IDictionaryEdit, IEditableObject, IRevertibleChangeTracking, IChangeTracking, IDictionaryNotify, INotifyPropertyChanging, INotifyPropertyChanged, IDictionaryValidate
  • public string Error { get; }
  • public string this[string columnName] { get; }
• public class DictionaryAdapterFactory : IDictionaryAdapterFactory
  • public T GetAdapter<T>(XmlNode xmlNode)
  • public object GetAdapter(Type type, XmlNode xmlNode)
• public class DictionaryValidateGroup : IDictionaryValidate, INotifyPropertyChanged, IDisposable
  • public string Error { get; }
  • public string this[string columnName] { get; }
• public class EditableBindingList<T> : BindingList<T>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IEditableObject, IRevertibleChangeTracking, IChangeTracking
• public interface IBindingList<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
  • ListSortDirection SortDirection { get; }
  • event ListChangedEventHandler ListChanged
  • void ApplySort(PropertyDescriptor property, ListSortDirection direction)
• public interface IBindingListSource
• public interface IDictionaryAdapterFactory
  • T GetAdapter<T>(XmlNode xmlNode)
  • object GetAdapter(Type type, XmlNode xmlNode)
• public class ListProjection<T> : IBindingList<T>, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IEditableObject, IRevertibleChangeTracking, IChangeTracking, ICollectionProjection, ICollectionAdapterObserver<T>
  • protected enum ListChangedType<T>
  • public IBindingList AsBindingList { get; }
  • public event ListChangedEventHandler ListChanged
  • protected void NotifyListChanged(ListChangedType type, int index)
  • protected void NotifyListChanged(ListChangedType<T> type, int index)
  • protected virtual void OnListChanged(ListChangedEventArgs args)
• public class SetProjection<T> : ListProjection<T>, ISet<T>, ICollection<T>, IEnumerable<T>, IEnumerable

Castle.Components.DictionaryAdapter.Xml

• public class CompiledXPath
• public class CompiledXPathNode
• public class CompiledXPathStep : CompiledXPathNode
• public enum CursorFlags
• public static class CursorFlagsExtensions
• public sealed class DefaultXmlReferenceFormat : IXmlReferenceFormat
• public static class DictionaryAdapterExtensions
• public interface IConfigurable<T>
• public interface IRealizable<T> : IRealizableSource
• public interface IRealizableSource
• public interface IXmlAccessor
• public interface IXmlBehaviorSemantics<T>
• public interface IXmlCollectionAccessor : IXmlAccessor
• public interface IXmlContext : IXmlNamespaceSource
• public interface IXmlCursor : IXmlIterator, IXmlNode, IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual
• public interface IXmlIdentity
• public interface IXmlIncludedType
• public interface IXmlIncludedTypeMap
• public interface IXmlIterator : IXmlNode, IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual
• public interface IXmlKnownType : IXmlIdentity
• public interface IXmlKnownTypeMap
• public interface IXmlNamespaceSource
• public interface IXmlNode : IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual
• public interface IXmlNodeSource
• public interface IXmlPropertyAccessor : IXmlAccessor
• public interface IXmlReferenceFormat
• public static class RealizableExtensions
• public class SingletonDispenser<TKey, TItem>
• public class SysXmlCursor : SysXmlNode, IXmlCursor, IXmlIterator, IXmlNode, IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual
• public static class SysXmlExtensions
• public class SysXmlNode : XmlNodeBase, IXmlNode, IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual, IRealizable<XmlNode>, IRealizable<XPathNavigator>
• public class SysXmlSubtreeIterator : SysXmlNode, IXmlIterator, IXmlNode, IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual
• public static class Try
• public static class TypeExtensions
• public static class Wsdl
• public abstract class XmlAccessor : IXmlPropertyAccessor, IXmlAccessor, IXmlCollectionAccessor
• public sealed delegate XmlAccessorFactory<TAccessor> : MulticastDelegate where TAccessor : XmlAccessor
• public class XmlAdapter : DictionaryBehaviorAttribute, IDictionaryInitializer, IDictionaryBehavior, IDictionaryPropertyGetter, IDictionaryPropertySetter, IDictionaryCreateStrategy, IDictionaryCopyStrategy, IDictionaryReferenceManager, IVirtual, IXmlNodeSource
• public class XmlArrayBehaviorAccessor : XmlNodeAccessor, IConfigurable<XmlArrayAttribute>, IConfigurable<XmlArrayItemAttribute>
• public class XmlArraySerializer : XmlTypeSerializer
• public class XmlAttributeBehaviorAccessor : XmlNodeAccessor, IConfigurable<XmlAttributeAttribute>
• public abstract class XmlCollectionSerializer : XmlTypeSerializer
• public class XmlComponentSerializer : XmlTypeSerializer
• public class XmlContext : XmlContextBase, IXmlContext, IXmlNamespaceSource
• public class XmlContextBase : XsltContext, IXmlNamespaceSource
• public class XmlCustomSerializer : XmlTypeSerializer
• public class XmlDefaultBehaviorAccessor : XmlNodeAccessor
• public class XmlDefaultSerializer : XmlTypeSerializer
• public class XmlDynamicSerializer : XmlTypeSerializer
• public class XmlElementBehaviorAccessor : XmlNodeAccessor, IConfigurable<XmlElementAttribute>, IXmlBehaviorSemantics<XmlElementAttribute>
• public class XmlEnumerationSerializer : XmlStringSerializer
• public class XmlIgnoreBehaviorAccessor : XmlAccessor
• public class XmlIncludedType : IXmlIncludedType
• public static class XmlIncludedTypeMapExtensions
• public class XmlIncludedTypeSet : IXmlIncludedTypeMap, IEnumerable<IXmlIncludedType>, IEnumerable
• public class XmlKnownType : IXmlKnownType, IXmlIdentity
• public static class XmlKnownTypeMapExtensions
• public class XmlKnownTypeSet : IXmlKnownTypeMap, IEnumerable<IXmlKnownType>, IEnumerable
• public class XmlListSerializer : XmlCollectionSerializer
• public class XmlMetadata : IXmlKnownType, IXmlIdentity, IXmlKnownTypeMap, IXmlIncludedType, IXmlIncludedTypeMap
• public class XmlMetadataBehavior : DictionaryBehaviorAttribute, IDictionaryMetaInitializer, IDictionaryBehavior
• public struct XmlName : IEquatable<XmlName>
• public class XmlNameComparer : IEqualityComparer<XmlName>
• public abstract class XmlNodeAccessor : XmlAccessor, IXmlKnownType, IXmlIdentity, IXmlKnownTypeMap
• public abstract class XmlNodeBase : IRealizableSource, IVirtual
• public static class Xmlns
• public class XmlPositionComparer
• public class XmlReferenceManager
• public class XmlSelfAccessor : XmlAccessor
• public class XmlSelfCursor : IXmlCursor, IXmlIterator, IXmlNode, IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual
• public class XmlSetSerializer : XmlCollectionSerializer
• public static class XmlSimpleSerializer
• public class XmlSimpleSerializer<T> : XmlTypeSerializer
• public class XmlStringSerializer : XmlTypeSerializer
• public class XmlSubtreeReader : XmlReader
• public class XmlSubtreeWriter : XmlWriter
• public enum XmlTypeKind
• public abstract class XmlTypeSerializer
• public class XmlXmlNodeSerializer : XmlTypeSerializer
• public class XPathAttribute : Attribute
• public class XPathBehaviorAccessor : XmlAccessor, IXmlIncludedType, IXmlIncludedTypeMap, IConfigurable<XPathAttribute>, IConfigurable<XPathVariableAttribute>, IConfigurable<XPathFunctionAttribute>
• public static class XPathCompiler
• public static class XPathExtensions
• public abstract class XPathFunctionAttribute : Attribute, IXsltContextFunction
• public class XPathNode : XmlNodeBase, IXmlNode, IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual, IRealizable<XPathNavigator>, IRealizable<XmlNode>
• public class XPathReadOnlyCursor : XPathNode, IXmlCursor, IXmlIterator, IXmlNode, IXmlKnownType, IXmlIdentity, IRealizableSource, IVirtual
• public abstract class XPathVariableAttribute : Attribute, IXsltContextVariable
• public static class XRef
• public static class Xsd
• public static class Xsi

Castle.Core

• public class Pair<TFirst, TSecond> : IEquatable<Pair<TFirst, TSecond>>
  • public TFirst First { get; }
  • public TSecond Second { get; }
  • public Pair(TFirst first, TSecond second)
  • public bool Equals(Pair<TFirst, TSecond> other)

Castle.Core.Internal

• public static class CollectionExtensions
  • public static bool AreEquivalent<T>(IList<T> listA, IList<T> listB)
  • public static T Find<T>(this T[] items, Predicate<T> predicate)
  • public static T[] FindAll<T>(this T[] items, Predicate<T> predicate)
  • public static int GetContentsHashCode<T>(IList<T> list)
  • public static bool IsNullOrEmpty(this IEnumerable this)
• public interface ILockHolder : IDisposable
  • bool LockAcquired { get; }
• public interface IUpgradeableLockHolder : ILockHolder, IDisposable
  • ILockHolder Upgrade()
  • ILockHolder Upgrade(bool waitForLock)
• public abstract class Lock
  • protected Lock()
  • public static Lock Create()
  • public abstract ILockHolder ForReading()
  • public abstract ILockHolder ForReading(bool waitForLock)
  • public abstract IUpgradeableLockHolder ForReadingUpgradeable()
  • public abstract IUpgradeableLockHolder ForReadingUpgradeable(bool waitForLock)
  • public abstract ILockHolder ForWriting()
  • public abstract ILockHolder ForWriting(bool waitForLock)

Castle.Core.Logging

• public class DiagnosticsLogger : LevelFilteredLogger, IDisposable
• public class DiagnosticsLoggerFactory : AbstractLoggerFactory
• public class LoggerException : Exception
  • protected LoggerException(SerializationInfo info, StreamingContext context)

Castle.Core.Resource

• public class ResourceException : Exception
  • protected ResourceException(SerializationInfo info, StreamingContext context)

Castle.Core.Smtp

• public class DefaultSmtpSender : IEmailSender
• public interface IEmailSender

Castle.DynamicProxy

• public sealed class DynamicProxyException : Exception
• public class InvalidMixinConfigurationException : Exception
  • public InvalidMixinConfigurationException(string message)
  • public InvalidMixinConfigurationException(string message, Exception innerException)
• public class InvalidProxyConstructorArgumentsException : ArgumentException
  • public Type ClassToProxy { get; }
  • public Type ProxyType { get; }
  • public InvalidProxyConstructorArgumentsException(string message, Type proxyType, Type classToProxy)
• public class ModuleScope
  • public Lock Lock { get; }
  • public INamingScope NamingScope { get; }
  • public ModuleBuilder StrongNamedModule { get; }
  • public ModuleBuilder WeakNamedModule { get; }
  • public ModuleScope(bool savePhysicalAssembly, bool disableSignedModule, INamingScope namingScope, string strongAssemblyName, string strongModulePath, string weakAssemblyName, string weakModulePath)
  • public TypeBuilder DefineType(bool inSignedModulePreferably, string name, TypeAttributes flags)
  • public Type GetFromCache(CacheKey key)
  • public ModuleBuilder ObtainDynamicModule(bool isStrongNamed)
  • public ModuleBuilder ObtainDynamicModuleWithStrongName()
  • public ModuleBuilder ObtainDynamicModuleWithWeakName()
  • public void RegisterInCache(CacheKey key, Type type)
• public class ProxyGenerationException : Exception
  • public ProxyGenerationException(string message)
  • public ProxyGenerationException(string message, Exception innerException)

Castle.DynamicProxy.Contributors

• public class ClassMembersCollector : MembersCollector
  • public ClassMembersCollector(Type targetType)
• public class ClassProxyInstanceContributor : ProxyInstanceContributor
  • public ClassProxyInstanceContributor(Type targetType, IList<MethodInfo> methodsToSkip, Type[] interfaces, string typeId)
• public class ClassProxyTargetContributor : CompositeTypeContributor
  • public ClassProxyTargetContributor(Type targetType, IList<MethodInfo> methodsToSkip, INamingScope namingScope)
• public class ClassProxyWithTargetTargetContributor : CompositeTypeContributor
  • public ClassProxyWithTargetTargetContributor(Type targetType, IList<MethodInfo> methodsToSkip, INamingScope namingScope)
• public abstract class CompositeTypeContributor : ITypeContributor
  • protected readonly ICollection<Type> interfaces
  • protected readonly INamingScope namingScope
  • public ILogger Logger { get; set; }
  • protected CompositeTypeContributor(INamingScope namingScope)
  • public void AddInterfaceToProxy(Type interface)
  • public void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)
  • protected abstract IEnumerable<MembersCollector> CollectElementsToProxyInternal(IProxyGenerationHook hook)
  • public virtual void Generate(ClassEmitter class, ProxyGenerationOptions options)
  • protected abstract MethodGenerator GetMethodGenerator(MetaMethod method, ClassEmitter class, ProxyGenerationOptions options, OverrideMethodDelegate overrideMethod)
• public class DelegateProxyTargetContributor : CompositeTypeContributor
  • public DelegateProxyTargetContributor(Type targetType, INamingScope namingScope)
• public class DelegateTypeGenerator : IGenerator<AbstractTypeEmitter>
  • public DelegateTypeGenerator(MetaMethod method, Type targetType)
  • public AbstractTypeEmitter Generate(ClassEmitter class, ProxyGenerationOptions options, INamingScope namingScope)
• public class FieldReferenceComparer : IComparer<Type>
  • public FieldReferenceComparer()
  • public int Compare(Type x, Type y)
• public class ForwardingMethodGenerator : MethodGenerator
  • public ForwardingMethodGenerator(MetaMethod method, OverrideMethodDelegate overrideMethod, GetTargetReferenceDelegate getTargetReference)
• public sealed delegate GetTargetExpressionDelegate : MulticastDelegate
  • public GetTargetExpressionDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ClassEmitter class, MethodInfo method, AsyncCallback callback, object object)
  • public virtual Expression EndInvoke(IAsyncResult result)
  • public virtual Expression Invoke(ClassEmitter class, MethodInfo method)
• public sealed delegate GetTargetReferenceDelegate : MulticastDelegate
  • public GetTargetReferenceDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(ClassEmitter class, MethodInfo method, AsyncCallback callback, object object)
  • public virtual Reference EndInvoke(IAsyncResult result)
  • public virtual Reference Invoke(ClassEmitter class, MethodInfo method)
• public class InterfaceMembersCollector : MembersCollector
  • public InterfaceMembersCollector(Type interface)
• public class InterfaceMembersOnClassCollector : MembersCollector
  • public InterfaceMembersOnClassCollector(Type type, bool onlyProxyVirtual, InterfaceMapping map)
• public class InterfaceProxyInstanceContributor : ProxyInstanceContributor
  • public InterfaceProxyInstanceContributor(Type targetType, string proxyGeneratorId, Type[] interfaces)
• public class InterfaceProxyTargetContributor : CompositeTypeContributor
  • public InterfaceProxyTargetContributor(Type proxyTargetType, bool canChangeTarget, INamingScope namingScope)
  • protected virtual MembersCollector GetCollectorForInterface(Type interface)
• public class InterfaceProxyWithOptionalTargetContributor : InterfaceProxyWithoutTargetContributor
  • public InterfaceProxyWithOptionalTargetContributor(INamingScope namingScope, GetTargetExpressionDelegate getTarget, GetTargetReferenceDelegate getTargetReference)
• public class InterfaceProxyWithoutTargetContributor : CompositeTypeContributor
  • protected bool canChangeTarget
  • public InterfaceProxyWithoutTargetContributor(INamingScope namingScope, GetTargetExpressionDelegate getTarget)
• public class InterfaceProxyWithTargetInterfaceTargetContributor : InterfaceProxyTargetContributor
  • public InterfaceProxyWithTargetInterfaceTargetContributor(Type proxyTargetType, bool allowChangeTarget, INamingScope namingScope)
• public class InvocationWithDelegateContributor : IInvocationCreationContributor
  • public InvocationWithDelegateContributor(Type delegateType, Type targetType, MetaMethod method, INamingScope namingScope)
  • public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
  • public MethodInfo GetCallbackMethod()
  • public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args, Reference targetField, MethodEmitter invokeMethodOnTarget)
  • public Expression[] GetConstructorInvocationArguments(Expression[] arguments, ClassEmitter proxy)
• public class InvocationWithGenericDelegateContributor : IInvocationCreationContributor
  • public InvocationWithGenericDelegateContributor(Type delegateType, MetaMethod method, Reference targetReference)
  • public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
  • public MethodInfo GetCallbackMethod()
  • public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args, Reference targetField, MethodEmitter invokeMethodOnTarget)
  • public Expression[] GetConstructorInvocationArguments(Expression[] arguments, ClassEmitter proxy)
• public interface ITypeContributor
  • void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)
  • void Generate(ClassEmitter class, ProxyGenerationOptions options)
• public abstract class MembersCollector
  • protected readonly Type type
  • public IEnumerable<MetaEvent> Events { get; }
  • public ILogger Logger { get; set; }
  • public IEnumerable<MetaMethod> Methods { get; }
  • public IEnumerable<MetaProperty> Properties { get; }
  • protected MembersCollector(Type type)
  • protected bool AcceptMethod(MethodInfo method, bool onlyVirtuals, IProxyGenerationHook hook)
  • public virtual void CollectMembersToProxy(IProxyGenerationHook hook)
  • protected abstract MetaMethod GetMethodToGenerate(MethodInfo method, IProxyGenerationHook hook, bool isStandalone)
• public class MinimialisticMethodGenerator : MethodGenerator
  • public MinimialisticMethodGenerator(MetaMethod method, OverrideMethodDelegate overrideMethod)
• public class MixinContributor : CompositeTypeContributor
  • public IEnumerable<FieldReference> Fields { get; }
  • public MixinContributor(INamingScope namingScope, bool canChangeTarget)
  • public void AddEmptyInterface(Type interface)
• public class OptionallyForwardingMethodGenerator : MethodGenerator
  • public OptionallyForwardingMethodGenerator(MetaMethod method, OverrideMethodDelegate overrideMethod, GetTargetReferenceDelegate getTargetReference)
• public sealed delegate OverrideMethodDelegate : MulticastDelegate
  • public OverrideMethodDelegate(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(string name, MethodAttributes attributes, MethodInfo methodToOverride, AsyncCallback callback, object object)
  • public virtual MethodEmitter EndInvoke(IAsyncResult result)
  • public virtual MethodEmitter Invoke(string name, MethodAttributes attributes, MethodInfo methodToOverride)
• public abstract class ProxyInstanceContributor : ITypeContributor
  • protected readonly Type targetType
  • protected ProxyInstanceContributor(Type targetType, Type[] interfaces, string proxyTypeId)
  • public void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)
  • public virtual void Generate(ClassEmitter class, ProxyGenerationOptions options)
  • protected abstract Reference GetTargetReference(ClassEmitter emitter)
  • protected void ImplementProxyTargetAccessor(ClassEmitter emitter, FieldReference interceptorsField)
• public class WrappedClassMembersCollector : ClassMembersCollector
  • public WrappedClassMembersCollector(Type type)
  • protected bool IsGeneratedByTheCompiler(FieldInfo field)
  • protected virtual bool IsOKToBeOnProxy(FieldInfo field)

Castle.DynamicProxy.Generators

• public abstract class BaseProxyGenerator
  • protected readonly Type targetType
  • public ILogger Logger { get; set; }
  • protected ProxyGenerationOptions ProxyGenerationOptions { get; protected set; }
  • protected ModuleScope Scope { get; }
  • protected BaseProxyGenerator(ModuleScope scope, Type targetType)
  • protected void AddMapping(Type interface, ITypeContributor implementer, IDictionary<Type, ITypeContributor> mapping)
  • protected void AddMappingNoCheck(Type interface, ITypeContributor implementer, IDictionary<Type, ITypeContributor> mapping)
  • protected void AddToCache(CacheKey key, Type type)
  • protected virtual ClassEmitter BuildClassEmitter(string typeName, Type parentType, IEnumerable<Type> interfaces)
  • protected void CheckNotGenericTypeDefinition(Type type, string argumentName)
  • protected void CheckNotGenericTypeDefinitions(IEnumerable<Type> types, string argumentName)
  • protected void CompleteInitCacheMethod(ConstructorCodeBuilder constCodeBuilder)
  • protected virtual void CreateFields(ClassEmitter emitter)
  • protected void CreateInterceptorsField(ClassEmitter emitter)
  • protected FieldReference CreateOptionsField(ClassEmitter emitter)
  • protected void CreateSelectorField(ClassEmitter emitter)
  • protected virtual void CreateTypeAttributes(ClassEmitter emitter)
  • protected void EnsureOptionsOverrideEqualsAndGetHashCode(ProxyGenerationOptions options)
  • protected void GenerateConstructor(ClassEmitter emitter, ConstructorInfo baseConstructor, FieldReference[] fields)
  • protected void GenerateConstructors(ClassEmitter emitter, Type baseType, FieldReference[] fields)
  • protected void GenerateParameterlessConstructor(ClassEmitter emitter, Type baseClass, FieldReference interceptorField)
  • protected ConstructorEmitter GenerateStaticConstructor(ClassEmitter emitter)
  • protected Type GetFromCache(CacheKey key)
  • protected void HandleExplicitlyPassedProxyTargetAccessor(ICollection<Type> targetInterfaces, ICollection<Type> additionalInterfaces)
  • protected void InitializeStaticFields(Type builtType)
  • protected Type ObtainProxyType(CacheKey cacheKey, Func<string, INamingScope, Type> factory)
• public class CacheKey
  • public CacheKey(MemberInfo target, Type type, Type[] interfaces, ProxyGenerationOptions options)
  • public CacheKey(Type target, Type[] interfaces, ProxyGenerationOptions options)
• public class ClassProxyGenerator : BaseProxyGenerator
  • public ClassProxyGenerator(ModuleScope scope, Type targetType)
  • public Type GenerateCode(Type[] interfaces, ProxyGenerationOptions options)
  • protected virtual Type GenerateType(string name, Type[] interfaces, INamingScope namingScope)
  • protected virtual IEnumerable<Type> GetTypeImplementerMapping(Type[] interfaces, out IEnumerable contributors, INamingScope namingScope)
• public class ClassProxyWithTargetGenerator : BaseProxyGenerator
  • public ClassProxyWithTargetGenerator(ModuleScope scope, Type classToProxy, Type[] additionalInterfacesToProxy, ProxyGenerationOptions options)
  • public Type GetGeneratedType()
  • protected virtual IEnumerable<Type> GetTypeImplementerMapping(out IEnumerable contributors, INamingScope namingScope)
• public class CompositionInvocationTypeGenerator : InvocationTypeGenerator
  • public static readonly Type BaseType
  • public CompositionInvocationTypeGenerator(Type target, MetaMethod method, MethodInfo callback, bool canChangeTarget, IInvocationCreationContributor contributor)
• public class DelegateMembersCollector : MembersCollector
  • public DelegateMembersCollector(Type type)
• public class DelegateProxyGenerationHook : IProxyGenerationHook
  • public DelegateProxyGenerationHook()
  • public void MethodsInspected()
  • public void NonProxyableMemberNotification(Type type, MemberInfo memberInfo)
  • public bool ShouldInterceptMethod(Type type, MethodInfo methodInfo)
• public class DelegateProxyGenerator : BaseProxyGenerator
  • public DelegateProxyGenerator(ModuleScope scope, Type delegateType)
  • public Type GetProxyType()
  • protected virtual IEnumerable<Type> GetTypeImplementerMapping(out IEnumerable contributors, INamingScope namingScope)
• public class GeneratorException : Exception
  • public GeneratorException(string message)
  • public GeneratorException(string message, Exception innerException)
• public static class GeneratorUtil
  • public static void CopyOutAndRefParameters(TypeReference[] dereferencedArguments, LocalReference invocation, MethodInfo method, MethodEmitter emitter)
• public interface IGenerator<T>
  • T Generate(ClassEmitter class, ProxyGenerationOptions options, INamingScope namingScope)
• public interface IInvocationCreationContributor
  • ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
  • MethodInfo GetCallbackMethod()
  • MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args, Reference targetField, MethodEmitter invokeMethodOnTarget)
  • Expression[] GetConstructorInvocationArguments(Expression[] arguments, ClassEmitter proxy)
• public interface INamingScope
  • INamingScope ParentScope { get; }
  • string GetUniqueName(string suggestedName)
  • INamingScope SafeSubScope()
• public class InheritanceInvocationTypeGenerator : InvocationTypeGenerator
  • public static readonly Type BaseType
  • public InheritanceInvocationTypeGenerator(Type targetType, MetaMethod method, MethodInfo callback, IInvocationCreationContributor contributor)
• public class InterfaceProxyWithoutTargetGenerator : InterfaceProxyWithTargetGenerator
  • public InterfaceProxyWithoutTargetGenerator(ModuleScope scope, Type interface)
• public class InterfaceProxyWithTargetGenerator : BaseProxyGenerator
  • protected FieldReference targetField
  • protected virtual bool AllowChangeTarget { get; }
  • protected virtual string GeneratorType { get; }
  • public InterfaceProxyWithTargetGenerator(ModuleScope scope, Type interface)
  • protected virtual ITypeContributor AddMappingForTargetType(IDictionary<Type, ITypeContributor> typeImplementerMapping, Type proxyTargetType, ICollection<Type> targetInterfaces, ICollection<Type> additionalInterfaces, INamingScope namingScope)
  • public Type GenerateCode(Type proxyTargetType, Type[] interfaces, ProxyGenerationOptions options)
  • protected virtual Type GenerateType(string typeName, Type proxyTargetType, Type[] interfaces, INamingScope namingScope)
  • protected virtual InterfaceProxyWithoutTargetContributor GetContributorForAdditionalInterfaces(INamingScope namingScope)
  • protected virtual IEnumerable<Type> GetTypeImplementerMapping(Type[] interfaces, Type proxyTargetType, out IEnumerable contributors, INamingScope namingScope)
  • protected virtual Type Init(string typeName, out ClassEmitter emitter, Type proxyTargetType, out FieldReference interceptorsField, IEnumerable<Type> interfaces)
• public class InterfaceProxyWithTargetInterfaceGenerator : InterfaceProxyWithTargetGenerator
  • public InterfaceProxyWithTargetInterfaceGenerator(ModuleScope scope, Type interface)
• public abstract class InvocationTypeGenerator : IGenerator<AbstractTypeEmitter>
  • protected readonly MetaMethod method
  • protected readonly Type targetType
  • protected InvocationTypeGenerator(Type targetType, MetaMethod method, MethodInfo callback, bool canChangeTarget, IInvocationCreationContributor contributor)
  • public AbstractTypeEmitter Generate(ClassEmitter class, ProxyGenerationOptions options, INamingScope namingScope)
  • protected abstract ArgumentReference[] GetBaseCtorArguments(Type targetFieldType, ProxyGenerationOptions proxyGenerationOptions, out ConstructorInfo baseConstructor)
  • protected abstract Type GetBaseType()
  • protected virtual MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args, MethodInfo callbackMethod, Reference targetField, MethodEmitter invokeMethodOnTarget)
  • protected abstract FieldReference GetTargetReference()
  • protected virtual void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, Reference targetField)
• public class MetaEvent : MetaTypeElement, IEquatable<MetaEvent>
  • public MetaMethod Adder { get; }
  • public EventAttributes Attributes { get; }
  • public EventEmitter Emitter { get; }
  • public MetaMethod Remover { get; }
  • public MetaEvent(string name, Type declaringType, Type eventDelegateType, MetaMethod adder, MetaMethod remover, EventAttributes attributes)
  • public void BuildEventEmitter(ClassEmitter classEmitter)
  • public bool Equals(MetaEvent other)
• public class MetaMethod : MetaTypeElement, IEquatable<MetaMethod>
  • public MethodAttributes Attributes { get; }
  • public bool HasTarget { get; }
  • public MethodInfo Method { get; }
  • public MethodInfo MethodOnTarget { get; }
  • public string Name { get; }
  • public bool Proxyable { get; }
  • public bool Standalone { get; }
  • public MetaMethod(MethodInfo method, MethodInfo methodOnTarget, bool standalone, bool proxyable, bool hasTarget)
  • public bool Equals(MetaMethod other)
• public class MetaProperty : MetaTypeElement, IEquatable<MetaProperty>
  • public Type[] Arguments { get; }
  • public bool CanRead { get; }
  • public bool CanWrite { get; }
  • public PropertyEmitter Emitter { get; }
  • public MethodInfo GetMethod { get; }
  • public MetaMethod Getter { get; }
  • public MethodInfo SetMethod { get; }
  • public MetaMethod Setter { get; }
  • public MetaProperty(string name, Type propertyType, Type declaringType, MetaMethod getter, MetaMethod setter, IEnumerable<CustomAttributeBuilder> customAttributes, Type[] arguments)
  • public void BuildPropertyEmitter(ClassEmitter classEmitter)
  • public bool Equals(MetaProperty other)
• public class MetaType
  • public IEnumerable<MetaEvent> Events { get; }
  • public IEnumerable<MetaMethod> Methods { get; }
  • public IEnumerable<MetaProperty> Properties { get; }
  • public MetaType()
  • public void AddEvent(MetaEvent event)
  • public void AddMethod(MetaMethod method)
  • public void AddProperty(MetaProperty property)
• public abstract class MetaTypeElement
  • protected readonly Type sourceType
  • protected MetaTypeElement(Type sourceType)
• public class MethodFinder
  • public MethodFinder()
  • public static MethodInfo[] GetAllInstanceMethods(Type type, BindingFlags flags)
• public abstract class MethodGenerator : IGenerator<MethodEmitter>
  • protected MethodInfo MethodOnTarget { get; }
  • protected MethodInfo MethodToOverride { get; }
  • protected MethodGenerator(MetaMethod method, OverrideMethodDelegate overrideMethod)
  • protected abstract MethodEmitter BuildProxiedMethodBody(MethodEmitter emitter, ClassEmitter class, ProxyGenerationOptions options, INamingScope namingScope)
  • public MethodEmitter Generate(ClassEmitter class, ProxyGenerationOptions options, INamingScope namingScope)
• public class MethodSignatureComparer : IEqualityComparer<MethodInfo>
  • public static readonly MethodSignatureComparer Instance
  • public MethodSignatureComparer()
  • public bool EqualGenericParameters(MethodInfo x, MethodInfo y)
  • public bool EqualParameters(MethodInfo x, MethodInfo y)
  • public bool Equals(MethodInfo x, MethodInfo y)
  • public bool EqualSignatureTypes(Type x, Type y)
  • public int GetHashCode(MethodInfo obj)
• public class MethodWithInvocationGenerator : MethodGenerator
  • public MethodWithInvocationGenerator(MetaMethod method, Reference interceptors, Type invocation, GetTargetExpressionDelegate getTargetExpression, OverrideMethodDelegate createMethod, IInvocationCreationContributor contributor)
  • public MethodWithInvocationGenerator(MetaMethod method, Reference interceptors, Type invocation, GetTargetExpressionDelegate getTargetExpression, GetTargetExpressionDelegate getTargetTypeExpression, OverrideMethodDelegate createMethod, IInvocationCreationContributor contributor)
  • protected FieldReference BuildMethodInterceptorsField(ClassEmitter class, MethodInfo method, INamingScope namingScope)
• public class NamingScope : INamingScope
  • public INamingScope ParentScope { get; }
  • public NamingScope()
  • public string GetUniqueName(string suggestedName)
  • public INamingScope SafeSubScope()
• public class TypeElementCollection<TElement> : ICollection<TElement>, IEnumerable<TElement>, IEnumerable where TElement : MetaTypeElement, IEquatable<TElement>
  • public int Count { get; }
  • public TypeElementCollection()
  • public void Add(TElement item)
  • public bool Contains(TElement item)
  • public IEnumerator<TElement> GetEnumerator()

Castle.DynamicProxy.Generators.Emitters

• public abstract class AbstractTypeEmitter
  • public Type BaseType { get; }
  • public TypeConstructorEmitter ClassConstructor { get; }
  • public ConstructorCollection Constructors { get; }
  • public GenericTypeParameterBuilder[] GenericTypeParams { get; }
  • public NestedClassCollection Nested { get; }
  • public TypeBuilder TypeBuilder { get; }
  • protected AbstractTypeEmitter(TypeBuilder typeBuilder)
  • public void AddCustomAttributes(ProxyGenerationOptions proxyGenerationOptions)
  • public virtual Type BuildType()
  • public void CopyGenericParametersFromMethod(MethodInfo methodToCopyGenericsFrom)
  • public ConstructorEmitter CreateConstructor(ArgumentReference[] arguments)
  • public void CreateDefaultConstructor()
  • public EventEmitter CreateEvent(string name, EventAttributes atts, Type type)
  • public FieldReference CreateField(string name, Type fieldType)
  • public FieldReference CreateField(string name, Type fieldType, bool serializable)
  • public FieldReference CreateField(string name, Type fieldType, FieldAttributes atts)
  • public MethodEmitter CreateMethod(string name, MethodAttributes attrs, Type returnType, Type[] argumentTypes)
  • public MethodEmitter CreateMethod(string name, Type returnType, Type[] parameterTypes)
  • public MethodEmitter CreateMethod(string name, MethodInfo methodToUseAsATemplate)
  • public MethodEmitter CreateMethod(string name, MethodAttributes attributes, MethodInfo methodToUseAsATemplate)
  • public PropertyEmitter CreateProperty(string name, PropertyAttributes attributes, Type propertyType, Type[] arguments)
  • public FieldReference CreateStaticField(string name, Type fieldType)
  • public FieldReference CreateStaticField(string name, Type fieldType, FieldAttributes atts)
  • protected Type CreateType(TypeBuilder type)
  • public ConstructorEmitter CreateTypeConstructor()
  • public void DefineCustomAttribute(CustomAttributeBuilder attribute)
  • public void DefineCustomAttribute<TAttribute>(object[] constructorArguments) where TAttribute : Attribute
  • public void DefineCustomAttribute<TAttribute>() where TAttribute : Attribute
  • public void DefineCustomAttributeFor<TAttribute>(FieldReference field) where TAttribute : Attribute
  • protected virtual void EnsureBuildersAreInAValidState()
  • public IEnumerable<FieldReference> GetAllFields()
  • public FieldReference GetField(string name)
  • public Type GetGenericArgument(string genericArgumentName)
  • public Type[] GetGenericArgumentsFor(Type genericType)
  • public Type[] GetGenericArgumentsFor(MethodInfo genericMethod)
  • public void SetGenericTypeParameters(GenericTypeParameterBuilder[] genericTypeParameterBuilders)
• public abstract class ArgumentsUtil
  • protected ArgumentsUtil()
  • public static Expression[] ConvertArgumentReferenceToExpression(ArgumentReference[] args)
  • public static ArgumentReference[] ConvertToArgumentReference(Type[] args)
  • public static ArgumentReference[] ConvertToArgumentReference(ParameterInfo[] args)
  • public static ReferenceExpression[] ConvertToArgumentReferenceExpression(ParameterInfo[] args)
  • public static void EmitLoadOwnerAndReference(Reference reference, ILGenerator il)
  • public static Type[] GetTypes(ParameterInfo[] parameters)
  • public static Type[] InitializeAndConvert(ArgumentReference[] args)
  • public static void InitializeArgumentsByPosition(ArgumentReference[] args, bool isStatic)
  • public static bool IsAnyByRef(ParameterInfo[] parameters)
• public class ClassEmitter : AbstractTypeEmitter
  • public ModuleScope ModuleScope { get; }
  • public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumerable<Type> interfaces)
  • public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumerable<Type> interfaces, TypeAttributes flags)
  • public ClassEmitter(ModuleScope modulescope, string name, Type baseType, IEnumerable<Type> interfaces, TypeAttributes flags, bool forceUnsigned)
  • public ClassEmitter(TypeBuilder typeBuilder)
  • protected virtual IEnumerable<Type> InitializeGenericArgumentsFromBases(ref Type baseType, IEnumerable<Type> interfaces)
• public class ConstructorCollection : Collection<ConstructorEmitter>
  • public ConstructorCollection()
• public class ConstructorEmitter : IMemberEmitter
  • public virtual ConstructorCodeBuilder CodeBuilder { get; }
  • public ConstructorBuilder ConstructorBuilder { get; }
  • public MemberInfo Member { get; }
  • public Type ReturnType { get; }
  • public virtual void EnsureValidCodeBlock()
  • public virtual void Generate()
• public class EventCollection : Collection<EventEmitter>
  • public EventCollection()
• public class EventEmitter : IMemberEmitter
  • public MemberInfo Member { get; }
  • public Type ReturnType { get; }
  • public EventEmitter(AbstractTypeEmitter typeEmitter, string name, EventAttributes attributes, Type type)
  • public MethodEmitter CreateAddMethod(string addMethodName, MethodAttributes attributes, MethodInfo methodToOverride)
  • public MethodEmitter CreateRemoveMethod(string removeMethodName, MethodAttributes attributes, MethodInfo methodToOverride)
  • public void EnsureValidCodeBlock()
  • public void Generate()
• public interface IMemberEmitter
  • MemberInfo Member { get; }
  • Type ReturnType { get; }
  • void EnsureValidCodeBlock()
  • void Generate()
• public sealed class LdcOpCodesDictionary : Dictionary<Type, OpCode>
  • public static OpCode EmptyOpCode { get; }
  • public static LdcOpCodesDictionary Instance { get; }
  • public OpCode this[Type type] { get; }
• public sealed class LdindOpCodesDictionary : Dictionary<Type, OpCode>
  • public static OpCode EmptyOpCode { get; }
  • public static LdindOpCodesDictionary Instance { get; }
  • public OpCode this[Type type] { get; }
• public class MethodCollection : Collection<MethodEmitter>
  • public MethodCollection()
• public class MethodEmitter : IMemberEmitter
  • public ArgumentReference[] Arguments { get; }
  • public virtual MethodCodeBuilder CodeBuilder { get; }
  • public GenericTypeParameterBuilder[] GenericTypeParams { get; }
  • public MemberInfo Member { get; }
  • public MethodBuilder MethodBuilder { get; }
  • public Type ReturnType { get; }
  • public void DefineCustomAttribute(CustomAttributeBuilder attribute)
  • public virtual void EnsureValidCodeBlock()
  • public virtual void Generate()
  • public void SetParameters(Type[] paramTypes)
• public class NestedClassCollection : Collection<NestedClassEmitter>
  • public NestedClassCollection()
• public class NestedClassEmitter : AbstractTypeEmitter
  • public NestedClassEmitter(AbstractTypeEmitter maintype, string name, Type baseType, Type[] interfaces)
  • public NestedClassEmitter(AbstractTypeEmitter maintype, string name, TypeAttributes attributes, Type baseType, Type[] interfaces)
  • public NestedClassEmitter(AbstractTypeEmitter maintype, TypeBuilder typeBuilder)
• public class PropertiesCollection : Collection<PropertyEmitter>
  • public PropertiesCollection()
• public class PropertyEmitter : IMemberEmitter
  • public MemberInfo Member { get; }
  • public Type ReturnType { get; }
  • public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes, Type propertyType, Type[] arguments)
  • public MethodEmitter CreateGetMethod(string name, MethodAttributes attrs, MethodInfo methodToOverride, Type[] parameters)
  • public MethodEmitter CreateGetMethod(string name, MethodAttributes attributes, MethodInfo methodToOverride)
  • public MethodEmitter CreateSetMethod(string name, MethodAttributes attrs, MethodInfo methodToOverride, Type[] parameters)
  • public MethodEmitter CreateSetMethod(string name, MethodAttributes attributes, MethodInfo methodToOverride)
  • public void DefineCustomAttribute(CustomAttributeBuilder attribute)
  • public void EnsureValidCodeBlock()
  • public void Generate()
• public sealed class StindOpCodesDictionary : Dictionary<Type, OpCode>
  • public static OpCode EmptyOpCode { get; }
  • public static StindOpCodesDictionary Instance { get; }
  • public OpCode this[Type type] { get; }
• public static class StrongNameUtil
  • public static bool CanStrongNameAssembly { get; set; }
  • public static bool IsAnyTypeFromUnsignedAssembly(IEnumerable<Type> types)
  • public static bool IsAnyTypeFromUnsignedAssembly(Type baseType, IEnumerable<Type> interfaces)
  • public static bool IsAssemblySigned(this Assembly assembly)
• public class TypeConstructorEmitter : ConstructorEmitter

Castle.DynamicProxy.Generators.Emitters.CodeBuilders

• public abstract class AbstractCodeBuilder
  • public ILGenerator Generator { get; }
  • protected AbstractCodeBuilder(ILGenerator generator)
  • public AbstractCodeBuilder AddExpression(Expression expression)
  • public AbstractCodeBuilder AddStatement(Statement stmt)
  • public LocalReference DeclareLocal(Type type)
  • public void SetNonEmpty()
• public class ConstructorCodeBuilder : AbstractCodeBuilder
  • public ConstructorCodeBuilder(Type baseType, ILGenerator generator)
  • public void InvokeBaseConstructor()
  • public void InvokeBaseConstructor(ConstructorInfo constructor)
  • public void InvokeBaseConstructor(ConstructorInfo constructor, ArgumentReference[] arguments)
• public class MethodCodeBuilder : AbstractCodeBuilder
  • public MethodCodeBuilder(ILGenerator generator)

Castle.DynamicProxy.Generators.Emitters.SimpleAST

• public class AddressOfReferenceExpression : Expression
  • public AddressOfReferenceExpression(Reference reference)
• public class ArgumentReference : TypeReference
  • public ArgumentReference(Type argumentType)
  • public ArgumentReference(Type argumentType, int position)
• public class AssignArgumentStatement : Statement
  • public AssignArgumentStatement(ArgumentReference argument, Expression expression)
• public class AssignArrayStatement : Statement
  • public AssignArrayStatement(Reference targetArray, int targetPosition, Expression value)
• public class AssignStatement : Statement
  • public AssignStatement(Reference target, Expression expression)
• public class AsTypeReference : Reference
  • public AsTypeReference(Reference reference, Type type)
• public class BindDelegateExpression : Expression
  • public BindDelegateExpression(Type delegate, Expression owner, MethodInfo methodToBindTo, GenericTypeParameterBuilder[] genericTypeParams)
• public class ByRefReference : TypeReference
  • public ByRefReference(LocalReference localReference)
• public class ConstReference : TypeReference
  • public ConstReference(object value)
• public class ConstructorInvocationStatement : Statement
  • public ConstructorInvocationStatement(ConstructorInfo method, Expression[] args)
• public class ConvertExpression : Expression
  • public ConvertExpression(Type targetType, Expression right)
  • public ConvertExpression(Type targetType, Type fromType, Expression right)
• public class DefaultValueExpression : Expression
  • public DefaultValueExpression(Type type)
• public class EndExceptionBlockStatement : Statement
  • public EndExceptionBlockStatement()
• public abstract class Expression : IILEmitter
  • protected Expression()
  • public abstract void Emit(IMemberEmitter member, ILGenerator gen)
• public class ExpressionStatement : Statement
  • public ExpressionStatement(Expression expression)
• public class FieldReference : Reference
  • public FieldBuilder Fieldbuilder { get; }
  • public FieldInfo Reference { get; }
  • public FieldReference(FieldInfo field)
  • public FieldReference(FieldBuilder fieldbuilder)
• public class FinallyStatement : Statement
  • public FinallyStatement()
• public class IfNullExpression : Expression
  • public IfNullExpression(Reference reference, IILEmitter ifNull, IILEmitter ifNotNull = null)
  • public IfNullExpression(Expression expression, IILEmitter ifNull, IILEmitter ifNotNull = null)
• public interface IILEmitter
  • void Emit(IMemberEmitter member, ILGenerator gen)
• public class IndirectReference : TypeReference
  • public IndirectReference(TypeReference byRefReference)
  • public static TypeReference WrapIfByRef(TypeReference reference)
  • public static TypeReference[] WrapIfByRef(TypeReference[] references)
• public class LiteralIntExpression : Expression
  • public LiteralIntExpression(int value)
• public class LoadArrayElementExpression : Expression
  • public LoadArrayElementExpression(int index, Reference arrayReference, Type returnType)
  • public LoadArrayElementExpression(ConstReference index, Reference arrayReference, Type returnType)
• public class LoadRefArrayElementExpression : Expression
  • public LoadRefArrayElementExpression(int index, Reference arrayReference)
  • public LoadRefArrayElementExpression(ConstReference index, Reference arrayReference)
• public class LocalReference : TypeReference
  • public LocalReference(Type type)
• public class MethodInvocationExpression : Expression
  • protected readonly Expression[] args
  • protected readonly MethodInfo method
  • protected readonly Reference owner
  • public bool VirtualCall { get; set; }
  • public MethodInvocationExpression(MethodInfo method, Expression[] args)
  • public MethodInvocationExpression(MethodEmitter method, Expression[] args)
  • public MethodInvocationExpression(Reference owner, MethodEmitter method, Expression[] args)
  • public MethodInvocationExpression(Reference owner, MethodInfo method, Expression[] args)
• public class MethodTokenExpression : Expression
  • public MethodTokenExpression(MethodInfo method)
• public class MultiStatementExpression : Expression
  • public MultiStatementExpression()
  • public void AddExpression(Expression expression)
  • public void AddStatement(Statement statement)
• public class NewArrayExpression : Expression
  • public NewArrayExpression(int size, Type arrayType)
• public class NewInstanceExpression : Expression
  • public NewInstanceExpression(ConstructorInfo constructor, Expression[] args)
  • public NewInstanceExpression(Type target, Type[] constructor_args, Expression[] args)
• public class NopStatement : Statement
  • public NopStatement()
• public class NullCoalescingOperatorExpression : Expression
  • public NullCoalescingOperatorExpression(Expression expression, Expression default)
• public class NullExpression : Expression
  • public static readonly NullExpression Instance
  • protected NullExpression()
• public abstract class Reference
  • protected Reference owner
  • public Reference OwnerReference { get; set; }
  • protected Reference()
  • protected Reference(Reference owner)
  • public virtual void Generate(ILGenerator gen)
  • public abstract void LoadAddressOfReference(ILGenerator gen)
  • public abstract void LoadReference(ILGenerator gen)
  • public abstract void StoreReference(ILGenerator gen)
  • public virtual Expression ToAddressOfExpression()
  • public virtual Expression ToExpression()
• public class ReferenceExpression : Expression
  • public ReferenceExpression(Reference reference)
• public class ReferencesToObjectArrayExpression : Expression
  • public ReferencesToObjectArrayExpression(TypeReference[] args)
• public class ReturnStatement : Statement
  • public ReturnStatement()
  • public ReturnStatement(Reference reference)
  • public ReturnStatement(Expression expression)
• public class SelfReference : Reference
  • public static readonly SelfReference Self
  • protected SelfReference()
• public abstract class Statement : IILEmitter
  • protected Statement()
  • public abstract void Emit(IMemberEmitter member, ILGenerator gen)
• public class ThrowStatement : Statement
  • public ThrowStatement(Type exceptionType, string errorMessage)
• public class TryStatement : Statement
  • public TryStatement()
• public abstract class TypeReference : Reference
  • public Type Type { get; }
  • protected TypeReference(Type argumentType)
  • protected TypeReference(Reference owner, Type type)
• public class TypeTokenExpression : Expression
  • public TypeTokenExpression(Type type)

Castle.DynamicProxy.Internal

• public static class AttributeUtil
  • public static CustomAttributeInfo CreateInfo(CustomAttributeData attribute)
  • public static CustomAttributeInfo CreateInfo<TAttribute>() where TAttribute : Attribute
  • public static CustomAttributeInfo CreateInfo(Type attribute, object[] constructorArguments)
  • public static IEnumerable<CustomAttributeInfo> GetNonInheritableAttributes(this MemberInfo member)
  • public static IEnumerable<CustomAttributeInfo> GetNonInheritableAttributes(this ParameterInfo parameter)
• public sealed class InterfaceMethodWithoutTargetInvocation : AbstractInvocation
• public static class InternalsUtil
  • public static bool IsAccessible(this MethodBase method)
  • public static bool IsInternal(this MethodBase method)
  • public static bool IsInternalToDynamicProxy(this Assembly asm)
• public static class InvocationHelper
  • public static MethodInfo GetMethodOnObject(object target, MethodInfo proxiedMethod)
  • public static MethodInfo GetMethodOnType(Type type, MethodInfo proxiedMethod)
• public static class TypeUtil
  • public static Type[] AsTypeArray(this GenericTypeParameterBuilder[] typeInfos)
  • public static FieldInfo[] GetAllFields(this Type type)
  • public static Type[] GetAllInterfaces(Type[] types)
  • public static Type GetClosedParameterType(this AbstractTypeEmitter type, Type parameter)
  • public static bool IsFinalizer(this MethodInfo methodInfo)
  • public static bool IsGetType(this MethodInfo methodInfo)
  • public static bool IsMemberwiseClone(this MethodInfo methodInfo)
  • public static bool IsNullableType(this Type type)
  • public static void SetStaticField(this Type type, string fieldName, BindingFlags additionalFlags, object value)

Castle.DynamicProxy.Tokens

• public static class DelegateMethods
  • public static readonly MethodInfo CreateDelegate
• public static class InterceptorSelectorMethods
  • public static readonly MethodInfo SelectInterceptors
• public static class InvocationMethods
  • public static readonly ConstructorInfo CompositionInvocationConstructor
  • public static readonly MethodInfo CompositionInvocationEnsureValidTarget
  • public static readonly FieldInfo CompositionInvocationTarget
  • public static readonly MethodInfo EnsureValidTarget
  • public static readonly MethodInfo GetArguments
  • public static readonly MethodInfo GetArgumentValue
  • public static readonly MethodInfo GetReturnValue
  • public static readonly ConstructorInfo InheritanceInvocationConstructor
  • public static readonly ConstructorInfo InheritanceInvocationConstructorWithSelector
  • public static readonly MethodInfo Proceed
  • public static readonly FieldInfo ProxyObject
  • public static readonly MethodInfo SetArgumentValue
  • public static readonly MethodInfo SetGenericMethodArguments
  • public static readonly MethodInfo SetReturnValue
  • public static readonly FieldInfo Target
  • public static readonly MethodInfo ThrowOnNoTarget
• public static class MethodBaseMethods
  • public static readonly MethodInfo GetMethodFromHandle
• public static class TypeMethods
  • public static readonly MethodInfo GetTypeFromHandle
  • public static readonly MethodInfo StaticGetType
• public static class TypeUtilMethods
  • public static readonly MethodInfo GetTypeOrNull
  • public static readonly MethodInfo Sort