Cronus.DomainModeling by Elders

<PackageReference Include="Cronus.DomainModeling" Version="3.3.1" />

---

API Diff between 3.3.1 and 6.1.0-beta0009

296 Additions 69 Removals

Elders.Cronus

• public class AggregateRoot<TState> : IAggregateRoot, IAmEventSourced, IHaveState<IAggregateRootState>, IUnderstandPublishedLanguage where TState : IAggregateRootState
• public class AggregateRootException : Exception
• public class AggregateRootId : AggregateUrn, IAggregateRootId, IUrn, IEquatable<IUrn>, IBlobId
• public abstract class AggregateRootId<T> : AggregateUrn, IAggregateRootId, IUrn, IEquatable<IUrn>, IBlobId where T : AggregateRootId<T>
• public abstract class AggregateRootState<TAggregateRoot, TAggregateRootId> : IAggregateRootState where TAggregateRoot : IAggregateRoot where TAggregateRootId : IAggregateRootId
• public class AggregateUrn : Urn, IAggregateRootId, IUrn, IEquatable<IUrn>, IBlobId
• public abstract class ApplicationService<AR> : IApplicationService, IMessageHandler where AR : IAggregateRoot
• public class Base64UrlTokenUrnFormatProvider : IUrnFormatProvider
• public class Base64UrnFormatProvider : IUrnFormatProvider
• public static class ByteArrayHelper
• public class DomainObjectEventHandlerMapping
• public abstract class Entity<TAggregateRoot, TEntityState> : IEntity, IHaveState<IEntityState> where TAggregateRoot : IAggregateRoot where TEntityState : IEntityState
• public class EntityEvent : IEvent, IMessage
• public static class EntityExtensions
• public abstract class EntityId<TAggregateRootId> : EntityUrn, IEntityId, IUrn, IEquatable<IUrn>, IBlobId where TAggregateRootId : IAggregateRootId
• public abstract class EntityState<TEntityId> : IEntityState where TEntityId : IEntityId
• public class EntityUrn : Urn
• public class EventHandlerRegistrations
• public interface IAggregateRepository
• public interface IAggregateRoot : IAmEventSourced, IHaveState<IAggregateRootState>, IUnderstandPublishedLanguage
• public interface IAggregateRootId : IUrn, IEquatable<IUrn>, IBlobId
• public interface IAggregateRootState
• public interface IAmEventSourced
• public interface IApplicationService : IMessageHandler
• public interface IBlobId
• public interface ICommand : IMessage
• public interface ICommandHandler<T> where T : ICommand
• public interface IEntity : IHaveState<IEntityState>
• public interface IEntityId : IUrn, IEquatable<IUrn>, IBlobId
• public interface IEntityState
• public interface IEvent : IMessage
• public interface IEventHandler<T> where T : IEvent
• public interface IGateway : IMessageHandler
• public interface IHaveState<TState>
• public interface IMessage
• public interface IMessageHandler
• public interface IPort : IMessageHandler
• public interface IProjection : IMessageHandler
• public interface IPublicEvent : IMessage
• public interface IPublisher<TMessage> where TMessage : IMessage
• public interface ISaga : IMessageHandler
• public interface ISagaTimeoutHandler<T> where T : IScheduledMessage
• public interface IScheduledMessage : IMessage
• public interface ISignal : IMessage
• public interface ISignalHandle<T> where T : ISignal
• public interface ITrigger : IMessageHandler
• public interface IUnderstandPublishedLanguage
• public interface IUrn : IEquatable<IUrn>
• public interface IUrnFormatProvider
• public interface IValueObject<T> : IEqualityComparer<T>, IEquatable<T>
• public static class MessageInfo
• public class PlainUrnFormatProvider : IUrnFormatProvider
• public struct ReadResult<T>
• public static class ReflectionExtensions
• public abstract class Saga : ISaga, IMessageHandler
• public static class StringExtensions
• public class UberUrnFormatProvider : IUrnFormatProvider
• public class Urn : IUrn, IEquatable<IUrn>, IBlobId
• public static class UrnRegex
• public abstract class ValueObject<T> : IValueObject<T>, IEqualityComparer<T>, IEquatable<T> where T : ValueObject<T>

Elders.Cronus.DomainModeling

• public class AggregateRoot<TState> : IAggregateRoot, IAmEventSourced, IHaveState<IAggregateRootState> where TState : IAggregateRootState
  • protected TState state
  • protected List<IEvent> uncommittedEvents
  • public AggregateRoot()
  • public TState InitializeState()
• public class AggregateRootApplicationService<AR> : IAggregateRootApplicationService where AR : IAggregateRoot
  • public IAggregateRepository Repository { get; set; }
  • public AggregateRootApplicationService()
  • public void Update(IAggregateRootId id, Action<AR> update)
• public class AggregateRootException : Exception
  • public AggregateRootException(string message)
  • public AggregateRootException()
  • protected AggregateRootException(SerializationInfo info, StreamingContext context)
  • public AggregateRootException(string message, Exception innerException)
• public class AggregateRootId : IAggregateRootId, IHaveUrn, IBlobId, IEquatable<IAggregateRootId>
  • protected Func<IUrn, byte[]> setRawId
  • public string AggregateRootName { get; protected set; }
  • public byte[] RawId { get; protected set; }
  • public virtual IUrn Urn { get; }
  • protected AggregateRootId()
  • protected AggregateRootId(string aggregateRootName)
  • public static bool op_Equality(AggregateRootId left, AggregateRootId right)
  • public static bool op_Inequality(AggregateRootId a, AggregateRootId b)
  • public virtual bool Equals(IAggregateRootId other)
• public abstract class AggregateRootState<TAggregateRoot, TAggregateRootId> : IAggregateRootState where TAggregateRoot : IAggregateRoot where TAggregateRootId : IAggregateRootId
  • public abstract TAggregateRootId Id { get; set; }
  • public TAggregateRoot Root { get; set; }
  • protected AggregateRootState()
• public sealed class BoundedContextAttribute : Attribute
  • public string BoundedContextName { get; }
  • public string BoundedContextNamespace { get; }
  • public string CompanyName { get; }
  • public string ProductName { get; }
  • public string ProductNamespace { get; }
  • public BoundedContextAttribute(string boundedContextNamespace)
  • public BoundedContextAttribute(string companyName, string productName, string boundedContextName)
• public static class ByteArrayHelper
  • public static byte[] Combine(byte[] first, byte[] second)
  • public static bool Compare(byte[] b1, byte[] b2)
  • public static int ComputeHash(byte[] data)
• public class DomainObjectEventHandlerMapping
  • public DomainObjectEventHandlerMapping()
  • public Dictionary<Type, Action<IEvent>> GetEventHandlers(Func<object> target)
• public abstract class Entity<TAggregateRoot, TEntityState> : IEntity, IHaveState<IEntityState> where TAggregateRoot : IAggregateRoot where TEntityState : IEntityState
  • protected TEntityState state
  • protected Entity(TAggregateRoot root, IEntityId entityId)
  • protected void Apply(IEvent event)
• public class EntityEvent : IEvent, IMessage
  • public IEntityId EntityId { get; }
  • public IEvent Event { get; }
  • public EntityEvent(IEntityId id, IEvent event)
• public class EntityGuidId<TAggregateRootId> : EntityId<TAggregateRootId> where TAggregateRootId : IAggregateRootId
  • public Guid Id { get; }
  • protected EntityGuidId()
  • public EntityGuidId(Guid idBase, TAggregateRootId rootId, string entityName)
  • public EntityGuidId(EntityGuidId<TAggregateRootId> idBase, string entityId)
  • public static bool IsValid(EntityGuidId<TAggregateRootId> entityId)
• public class EntityId<TAggregateRootId> : IEntityId, IHaveUrn, IBlobId, IEquatable<IEntityId> where TAggregateRootId : IAggregateRootId
  • protected Func<IUrn, byte[]> setRawId
  • public string EntityName { get; protected set; }
  • public byte[] RawId { get; protected set; }
  • public TAggregateRootId RootId { get; set; }
  • public virtual IUrn Urn { get; }
  • protected EntityId()
  • protected EntityId(TAggregateRootId rootId, string entityName)
  • public static bool op_Equality(EntityId<TAggregateRootId> left, EntityId<TAggregateRootId> right)
  • public static bool op_Inequality(EntityId<TAggregateRootId> a, EntityId<TAggregateRootId> b)
  • public virtual bool Equals(IEntityId other)
• public abstract class EntityState<TEntityId> : IEntityState where TEntityId : IEntityId
  • public abstract TEntityId EntityId { get; set; }
  • protected EntityState()
• public class EntityStringId<TAggregateRootId> : EntityId<TAggregateRootId> where TAggregateRootId : IAggregateRootId
  • public string Id { get; }
  • protected EntityStringId()
  • public EntityStringId(string idBase, TAggregateRootId rootId, string entityName)
  • public EntityStringId(EntityStringId<TAggregateRootId> idBase, string entityId)
  • public static bool IsValid(EntityStringId<TAggregateRootId> entityId)
• public class EventHandlerRegistrations
  • public EventHandlerRegistrations()
  • public Action<IEvent> GetEventHandler(IEvent event, out IEvent realEvent)
  • public void Register(Type eventType, Action<IEvent> handler)
  • public void Register(IEntityId entityId, Type eventType, Action<IEvent> handler)
• public class GuidId : AggregateRootId
  • public Guid Id { get; }
  • protected GuidId()
  • public GuidId(Guid idBase, string aggregateRootName)
  • public GuidId(GuidId idBase, string aggregateRootName)
  • public static bool IsValid(GuidId aggregateRootId)
• public class GuidTenantId : AggregateRootId
  • public Guid Id { get; }
  • public string Tenant { get; }
  • protected GuidTenantId()
  • public GuidTenantId(Guid idBase, string aggregateRootName, string tenant)
  • public GuidTenantId(GuidTenantId idBase, string aggregateRootName)
  • public GuidTenantId(IUrn urn, string aggregateRootName)
  • public static bool IsValid(GuidTenantId aggregateRootId)
• public interface IAggregateRepository
  • AR Load<AR>(IAggregateRootId id) where AR : IAggregateRoot
  • void Save<AR>(AR aggregateRoot) where AR : IAggregateRoot
  • bool TryLoad<AR>(IAggregateRootId id, out AR aggregateRoot) where AR : IAggregateRoot
• public interface IAggregateRoot : IAmEventSourced, IHaveState<IAggregateRootState>
  • int Revision { get; }
• public interface IAggregateRootApplicationService
  • IAggregateRepository Repository { get; set; }
• public interface IAggregateRootId : IHaveUrn, IBlobId, IEquatable<IAggregateRootId>
  • string AggregateRootName { get; }
• public interface IAggregateRootState
  • IAggregateRootId Id { get; }
• public interface IAmEventSourced
  • IEnumerable<IEvent> UncommittedEvents { get; }
  • void RegisterEventHandler(Type eventType, Action<IEvent> handleAction)
  • void RegisterEventHandler(IEntityId entityId, Type eventType, Action<IEvent> handleAction)
  • void ReplayEvents(List<IEvent> events, int currentRevision)
• public interface IBlobId
  • byte[] RawId { get; }
• public interface ICommand : IMessage
• public interface ICommandHandler<T> where T : ICommand
  • void Handle(T command)
• public interface IEntity : IHaveState<IEntityState>
• public interface IEntityId : IHaveUrn, IBlobId, IEquatable<IEntityId>
  • IAggregateRootId AggregateRootId { get; }
  • string EntityName { get; }
• public interface IEntityState
  • IEntityId EntityId { get; }
• public interface IEvent : IMessage
• public interface IEventHandler<T> where T : IEvent
  • void Handle(T event)
• public interface IGateway
• public interface IHaveState<TState>
  • TState State { get; }
• public interface IHaveUrn
  • IUrn Urn { get; }
• public interface IMessage
• public interface IPort
  • IPublisher<ICommand> CommandPublisher { get; set; }
• public interface IProjection
• public interface IPublisher<TMessage> where TMessage : IMessage
  • bool Publish(TMessage message, Dictionary<string, string> messageHeaders = null)
  • bool Publish(TMessage message, DateTime publishAt, Dictionary<string, string> messageHeaders = null)
  • bool Publish(TMessage message, TimeSpan publishAfter, Dictionary<string, string> messageHeaders = null)
• public interface ISaga
  • IPublisher<ICommand> CommandPublisher { get; set; }
  • IPublisher<IScheduledMessage> TimeoutRequestPublisher { get; set; }
• public interface ISagaTimeoutHandler<T> where T : IScheduledMessage
  • void Handle(T sagaTimeout)
• public interface IScheduledMessage : IMessage
  • long PublishAt { get; }
• public interface IUrn
  • string NID { get; }
  • string NSS { get; }
  • IList<string> Parts { get; }
  • string Value { get; }
• public interface IValueObject<T> : IEqualityComparer<T>, IEquatable<T>
• public static class MessageInfo
  • public static BoundedContextAttribute GetBoundedContext(this Type contractType)
  • public static BoundedContextAttribute GetBoundedContext(this Assembly contractAssembly)
  • public static string GetContractId(this Type messageType)
  • public static string ToString(this IMessage message, string messageInfo)
• public static class ReflectionExtensions
  • public static IEnumerable<MemberInfo> GetAllMembers(this Type t)
  • public static T GetAssemblyAttribute<T>(this Type type)
  • public static T GetAssemblyAttribute<T>(this Assembly assembly)
  • public static TResultType GetAttrubuteValue<TAttribute, TResultType>(this ICustomAttributeProvider self, Func<TAttribute, TResultType> get)
  • public static bool HasAttribute<TAttribute>(this ICustomAttributeProvider self)
• public class Saga : ISaga
  • public IPublisher<ICommand> CommandPublisher { get; set; }
  • public IPublisher<IScheduledMessage> TimeoutRequestPublisher { get; set; }
  • public Saga()
  • public void RequestTimeout<T>(T timeoutMessage) where T : IScheduledMessage
• public class StringId : AggregateRootId
  • public string Id { get; protected set; }
  • protected StringId()
  • public StringId(string idBase, string aggregateRootName)
  • public StringId(StringId idBase, string aggregateRootName)
  • public static bool IsValid(StringId aggregateRootId)
• public class StringTenantId : AggregateRootId
  • public string Id { get; }
  • public string Tenant { get; }
  • protected StringTenantId()
  • public StringTenantId(string idBase, string aggregateRootName, string tenant)
  • public StringTenantId(StringTenantId idBase, string aggregateRootName)
  • public StringTenantId(IUrn urn, string aggregateRootName)
  • public static bool IsValid(StringTenantId aggregateRootId)
• public class StringTenantUrn : Urn
  • public string ArName { get; }
  • public string Id { get; }
  • public string Tenant { get; }
  • public StringTenantUrn(string tenant, string arName, string id)
  • public static StringTenantUrn Parse(string urn)
  • public static bool TryParse(string urn, out StringTenantUrn parsedUrn)
• public class Urn : IUrn
  • public const string Delimiter = ":"
  • public const char DelimiterChar = ':'
  • public const string Prefix = "urn"
  • public string NID { get; }
  • public string NSS { get; }
  • public IList<string> Parts { get; }
  • public string Value { get; }
  • protected Urn()
  • public Urn(string nid, string nss)
  • public Urn(IUrn urn)
  • public static bool IsUrn(string candidate)
  • public static string op_Implicit(Urn urn)
  • public static IUrn Parse(string urn)
  • protected void Initialize(string nid, string nss)
• public abstract class ValueObject<T> : IValueObject<T>, IEqualityComparer<T>, IEquatable<T> where T : ValueObject<T>
  • protected ValueObject()
  • public static bool op_Equality(ValueObject<T> left, ValueObject<T> right)
  • public static bool op_Inequality(ValueObject<T> left, ValueObject<T> right)
  • public virtual bool Equals(T other)
  • public bool Equals(T left, T right)
  • public int GetHashCode(T obj)

Elders.Cronus.DomainModeling.Projections

• public interface IAmEventSourcedProjection
  • void ReplayEvents(IEnumerable<IEvent> events)
• public interface ICollectionDataTransferObject<VCollectionId> : IProjectionCollectionState, IProjectionState
• public interface ICollectionDataTransferObjectItem<TId, VCollectionId> : ICollectionDataTransferObject<VCollectionId>, IProjectionCollectionState, IProjectionState
• public interface IDataTransferObject<T> : IProjectionState
• public interface IHaveState
  • IBlobId Id { get; set; }
  • object State { get; set; }
  • void InitializeState(IBlobId id, object state)
• public interface IKeyValueCollectionPersister
  • void AddToCollection(KeyValueCollectionItem collectionItem)
  • void DeleteCollectionItem(KeyValueCollectionItem collectionItem)
  • IEnumerable<KeyValueCollectionItem> GetCollection(string collectionId, string keySpace)
  • KeyValueCollectionItem GetCollectionItem(string collectionId, string itemId, string columnFamily)
  • void Update(KeyValueCollectionItem collectionItem, byte[] data)
• public interface IKeyValuePersister
  • void Delete(string id, string keySpace)
  • KeyValueData Get(string id, string keySpace)
  • void Save(KeyValueData data)
  • void Update(KeyValueData item, byte[] data)
• public interface IPersiter : IKeyValuePersister, IKeyValueCollectionPersister
• public interface IProjectionCollectionState : IProjectionState
  • object CollectionId { get; }
• public interface IProjectionDefinition : IHaveState, IAmEventSourcedProjection
  • void Apply(IEvent event)
  • IEnumerable<IBlobId> GetProjectionIds(IEvent event)
• public interface IProjectionGetResult<T>
  • T Projection { get; }
  • bool Success { get; }
• public interface IProjectionRepository
  • IProjectionGetResult<T> Get<T>(IBlobId projectionId) where T : IProjectionDefinition
• public interface IProjectionState
  • object Id { get; }
• public interface IRepository
  • Func<byte[], object> Desirealizer { get; }
  • Func<object, byte[]> Serializer { get; }
  • void ClearTrack()
  • void CommitChanges()
  • void Delete<T, V>(T obj) where T : IDataTransferObject<V>
  • void DeleteCollectionItem<T, V, C>(T obj) where T : ICollectionDataTransferObjectItem<V, C>
  • T Get<T, V>(V ids) where T : IDataTransferObject<V>
  • IEnumerable<T> GetAsCollectionItems<T, C>(C collectionIds) where T : ICollectionDataTransferObject<C>
  • Query<T> Query<T>()
  • void Save<T, V>(T obj) where T : IDataTransferObject<V>
  • void Save<T, V, C>(T[] items) where T : ICollectionDataTransferObjectItem<V, C>
• public static class IRepositoryExtentions
  • public static void Delete<T, C, V>(this Query<T> self, ICollectionDataTransferObjectItem<C, V> obj) where T : ICollectionDataTransferObjectItem<C, V>
  • public static T Get<T, V>(this Query<T> self, V id) where T : IDataTransferObject<V>
  • public static IEnumerable<T> GetCollection<T, V>(this Query<T> self, V id) where T : ICollectionDataTransferObject<V>
  • public static T GetCollectionItem<T, V, C>(this Query<T> self, V id, C collectionId) where T : ICollectionDataTransferObjectItem<V, C>
  • public static void Save<T, V>(this Query<T> self, IDataTransferObject<V> obj) where T : IDataTransferObject<V>
  • public static void Save<T, C, V>(this Query<T> self, ICollectionDataTransferObjectItem<C, V> obj) where T : ICollectionDataTransferObjectItem<C, V>
• public class KeyValueCollectionItem
  • public virtual byte[] Blob { get; set; }
  • public virtual string CollectionId { get; set; }
  • public virtual Guid Id { get; set; }
  • public virtual string ItemId { get; set; }
  • public virtual string Table { get; set; }
  • public KeyValueCollectionItem()
  • public KeyValueCollectionItem(string collectionId, string id, string table, byte[] blob)
• public class KeyValueData
  • public virtual byte[] Blob { get; set; }
  • public virtual Guid Id { get; set; }
  • public virtual string ItemId { get; set; }
  • public virtual string Table { get; set; }
  • public KeyValueData()
  • public KeyValueData(string id, string table, byte[] blob)
• public class ProjectionDefinition<TState, TId> : IProjectionDefinition, IHaveState, IAmEventSourcedProjection, IProjection where TId : IBlobId
  • public TId ProjectionId { get; }
  • public TState State { get; }
  • public ProjectionDefinition()
  • protected ProjectionDefinition<TState, TId> Subscribe<TEvent>(Func<TEvent, TId> projectionId) where TEvent : IEvent
• public class ProjectionGetResult<T> : IProjectionGetResult<T>
  • public static IProjectionGetResult<T> NoResult
  • public T Projection { get; }
  • public bool Success { get; }
  • public ProjectionGetResult(bool success, T projection)
• public class Query<T>
  • public IRepository Session { get; set; }
  • public Query(IRepository session)
• public class SubscriptionIdResolver
  • public Func<IEvent, IBlobId> IdResolver { get; }
  • public Type ProjectionType { get; }
  • public SubscriptionIdResolver(Type projectionType, Func<IEvent, IBlobId> idResolver)

Elders.Cronus.Projections

• public class ContinueId : IBlobId
• public interface IAmEventSourcedProjection
• public interface IHaveState
• public interface IProjectionDefinition : IHaveState, IAmEventSourcedProjection
• public interface IProjectionReader
• public abstract class ProjectionDefinition<TState, TId> : IProjectionDefinition, IHaveState, IAmEventSourcedProjection, IProjection, IMessageHandler where TId : IBlobId
• public class SubscriptionIdResolver

Elders.Cronus.Testing

• public static class Aggregate<T> where T : IAggregateRoot
• public static class AggregateRootExtensions