Class ExtensionPointDescriptor
Inheritance
ExtensionPointDescriptor
Assembly: Serenity.ServiceExtensionCreator.Editor.dll
Syntax
public sealed class ExtensionPointDescriptor
Constructors
ExtensionPointDescriptor(ExtensionPointKind, string, string, Type, Type, bool, WiringCapability, IReadOnlyList<MemberInfo>, AggregateDescriptor, Type, MethodInfo, string, IReadOnlyList<Type>, bool)
Declaration
public ExtensionPointDescriptor(ExtensionPointKind kind, string name, string moduleName, Type contractType, Type concreteType, bool concreteHasVirtualMembers, WiringCapability wiringCapability, IReadOnlyList<MemberInfo> contractMembers, AggregateDescriptor underlyingAggregate = null, Type installerType = null, MethodInfo installerHookMethod = null, string discoveryWarning = null, IReadOnlyList<Type> eligibleSubclassBases = null, bool requiresVirtualization = false)
Parameters
Properties
ConcreteAssemblyName
Declaration
public string ConcreteAssemblyName { get; }
Property Value
ConcreteHasVirtualMembers
True when ConcreteType declares at least one public (or, for Installer,
protected) virtual member — the Subclass generation style's prerequisite.
Declaration
public bool ConcreteHasVirtualMembers { get; }
Property Value
ConcreteType
The reference concrete implementation used for the Subclass generation style, or null
when none was found. For the Installer kind this equals ContractType itself — the
abstract PersistenceInstaller is both the contract and the type a generated backend
subclasses directly.
Declaration
public Type ConcreteType { get; }
Property Value
ContractAssemblyName
Declaration
public string ContractAssemblyName { get; }
Property Value
ContractMembers
Every public member of ContractType, used to generate stub/forwarding/override members.
Declaration
public IReadOnlyList<MemberInfo> ContractMembers { get; }
Property Value
ContractType
The port this extension point extends — an interface for every kind except Installer,
which targets the abstract PersistenceInstaller class directly.
Declaration
public Type ContractType { get; }
Property Value
DiscoveryWarning
A human-readable warning produced during discovery (e.g. an ambiguous installer or hook
lookup that was skipped rather than silently first-picked), for the wizard window and generated
README to surface. Null when discovery was unambiguous.
Declaration
public string DiscoveryWarning { get; }
Property Value
EligibleSubclassBases
Every public, non-abstract, non-test-assembly implementer of ContractType with
overridable public or protected members — each one a valid base for the InfrastructureSubclass
style, canonical reference concrete first. Empty when nothing subclassable exists, and always empty
for the Installer kind (it subclasses the abstract PersistenceInstaller through its own
dedicated path).
Declaration
public IReadOnlyList<Type> EligibleSubclassBases { get; }
Property Value
InstallerAssemblyName
Declaration
public string InstallerAssemblyName { get; }
Property Value
InstallerHookMethod
Declaration
public MethodInfo InstallerHookMethod { get; }
Property Value
InstallerType
The aggregate's Unity{X}Installer hosting InstallerHookMethod, for
Repository/Gateway kinds — present even when no matching hook was found, so a generated README can
still name the installer a hook should be added to.
Declaration
public Type InstallerType { get; }
Property Value
Kind
Which extension point kind this descriptor represents.
Declaration
public ExtensionPointKind Kind { get; }
Property Value
ModuleName
The business module this extension point belongs to (e.g. "Persistence", "Score"),
resolved from ContractType's namespace.
Declaration
public string ModuleName { get; }
Property Value
Name
The extension point's identity within its Kind — the aggregate name for
Service (e.g. "Score"), or the contract type name with its leading "I" stripped for every other
kind (e.g. "BlobStore", "ScoreRepository", "AudioPlayerGateway").
Declaration
public string Name { get; }
Property Value
RequiresVirtualization
True for a Class-kind user class that is NOT subclassable yet — no public or protected virtual
methods, but at least one patchable public or protected instance method (see DiscoverVirtualizableUserClasses()).
Generation against such a descriptor is always rejected; the wizard routes it to a member-selection
virtualization step instead of the style step. False for every other descriptor.
Declaration
public bool RequiresVirtualization { get; }
Property Value
UnderlyingAggregate
Declaration
public AggregateDescriptor UnderlyingAggregate { get; }
Property Value
WiringCapability
How a generated implementation of this extension point is naturally wired into the game.
Declaration
public WiringCapability WiringCapability { get; }
Property Value
Methods
FromAggregate(AggregateDescriptor)
Adapts an AggregateDescriptor into the shared ExtensionPointDescriptor
shape — the Service kind's natural wiring is PipelineReplace for a core-installed aggregate and
AutoRegister otherwise, though Wiring remains a free
user choice for this kind regardless of this hint. A user-authored aggregate
(IsUserDefined) is grouped under one "User" module in the wizard
instead of its own aggregate name, since it has no Serenity package module to group by.
Declaration
public static ExtensionPointDescriptor FromAggregate(AggregateDescriptor aggregate)
Parameters
Returns