J>    public class User
J>    {
J>        public Guid Id { get; private set; }

J>        public string UserName { get; private set; }

J>        public string Info { get; private set; }

J>        public ContactInformation ContactInformation { get; private set; }

J>        protected internal User() { }

J>        /// <summary>
J>        /// Used for loading for ex. from the DB
J>        /// </summary>
J>        public static User Create(Guid id, string userName, string info, ContactInformation contactInformation)
J>        {
J>            return new User
J>            {
J>                Id = id,
J>                Info = info,
J>                UserName = userName,
J>                ContactInformation = contactInformation,
J>            };
J>        }

J>        /// <summary>
J>        /// Used for creation 
J>        /// </summary>
J>        public static User Create(string userName, string info, ContactInformation contactInformation)
J>        {
J>            if (string.IsNullOrWhiteSpace(userName))
J>            {
J>                throw new ArgumentException();
J>            }
J>            // other validation ...

J>            var id = Guid.NewGuid();

J>            return Create(id, info, userName, contactInformation);
J>        }

J>        public virtual ContactInformation GetContactInformation() => ContactInformation;

J>        public virtual void UpdateInformation(string info, string email)
J>        {
J>            // validation ..

J>            this.Info = info;
J>            GetContactInformation().UpdateEmail(email);
J>        }
J>    }
J>    public class ContactInformation
J>    {
J>        public Guid Id { get; private set; }

J>        public string Phone { get; private set; }

J>        public string Email { get; private set; }

J>        protected internal ContactInformation() { }

J>        public static ContactInformation Create(Guid id, string phone, string email) => new ContactInformation
J>        {
J>            Id = id,
J>            Phone = phone,
J>            Email = email
J>        };

J>        public static ContactInformation Create(string phone, string email)
J>        {
J>            var id = Guid.NewGuid();
J>            return Create(phone, email);
J>        }

J>        public static ContactInformation Create(string email) => Create(null, email);

J>        internal virtual void UpdateEmail(string newEmail)
J>        {
J>            if (newEmail.Contains("admin"))
J>            {
J>                throw new ArgumentException();
J>            }

J>            this.Email = newEmail;
J>        }
J>    }

J>

J>    public class UserRepository
J>    {

J>        public User Load(Guid id)
J>        {
J>            // Loading from the DB ...
J>            var contactInformation = ContactInformation.Create(Guid.NewGuid(), "bob@example.com", "+123456");
J>            var user = User.Create(id, "Bob", "Smth", contactInformation);
J>            return user;
J>        }
J>        public void Save(User user)
J>        {

J>        }
J>    }
J>

J>   public class UserInformationDto
J>    {
J>        public string Email { get; set; }
J>        public string Info { get; set; }
J>    }

J>    public class UserService
J>    {

J>        // IUserRepository
J>        private UserRepository userRepository;

J>        public UserService(UserRepository userRepository)
J>        {
J>            this.userRepository = userRepository;
J>        }

J>        public void UpdateUserInformation(Guid userId, UserInformationDto userInformation)
J>        {

J>            // validation ..

J>            var user = userRepository.Load(userId);

J>            user.UpdateInformation(userInformation.Info, userInformation.Email);

J>            userRepository.Save(user);
J>        }
J>    }
J>

    public class User
    {
        public Guid Id { get; private set; }

        public string UserName { get; private set; }

        public string Info { get; private set; }

        public ContactInformation ContactInformation { get; private set; }

        protected internal User() { }

        /// <summary>
        /// Used for loading for ex. from the DB
        /// </summary>
        public static User Create(Guid id, string userName, string info, ContactInformation contactInformation)
        {
            return new User
            {
                Id = id,
                Info = info,
                UserName = userName,
                ContactInformation = contactInformation,
            };
        }

        /// <summary>
        /// Used for creation 
        /// </summary>
        public static User Create(string userName, string info, ContactInformation contactInformation)
        {
            if (string.IsNullOrWhiteSpace(userName))
            {
                throw new ArgumentException();
            }
            // other validation ...

            var id = Guid.NewGuid();

            return Create(id, info, userName, contactInformation);
        }

        public virtual ContactInformation GetContactInformation() => ContactInformation;

        public virtual void UpdateInformation(string info, string email)
        {
            // validation ..

            this.Info = info;
            GetContactInformation().UpdateEmail(email);
        }
    }
    public class ContactInformation
    {
        public Guid Id { get; private set; }

        public string Phone { get; private set; }

        public string Email { get; private set; }

        protected internal ContactInformation() { }

        public static ContactInformation Create(Guid id, string phone, string email) => new ContactInformation
        {
            Id = id,
            Phone = phone,
            Email = email
        };

        public static ContactInformation Create(string phone, string email)
        {
            var id = Guid.NewGuid();
            return Create(phone, email);
        }

        public static ContactInformation Create(string email) => Create(null, email);

        internal virtual void UpdateEmail(string newEmail)
        {
            if (newEmail.Contains("admin"))
            {
                throw new ArgumentException();
            }

            this.Email = newEmail;
        }
    }

    public class UserRepository
    {

        public User Load(Guid id)
        {
            // Loading from the DB ...
            var contactInformation = ContactInformation.Create(Guid.NewGuid(), "bob@example.com", "+123456");
            var user = User.Create(id, "Bob", "Smth", contactInformation);
            return user;
        }
        public void Save(User user)
        {

        }
    }

   public class UserInformationDto
    {
        public string Email { get; set; }
        public string Info { get; set; }
    }

    public class UserService
    {

        // IUserRepository
        private UserRepository userRepository;

        public UserService(UserRepository userRepository)
        {
            this.userRepository = userRepository;
        }

        public void UpdateUserInformation(Guid userId, UserInformationDto userInformation)
        {

            // validation ..

            var user = userRepository.Load(userId);

            user.UpdateInformation(userInformation.Info, userInformation.Email);

            userRepository.Save(user);
        }
    }

public class UserTests
    {
        private User user;
        private ContactInformation contactInformation;

        public UserTests()
        {
            contactInformation = Mock.Of<ContactInformation>();
            user = Mock.Of<User>();
        }

        [Fact]
        public void UpdateInformationTest()
        {
            // Arrange
            var email = "bob2@example.com";
            Mock.Get(user).Setup(x => x.GetContactInformation()).Returns(contactInformation);

            // Act
            var ex = Record.Exception(() => user.UpdateInformation("xxx", email));

            // Assert
            Assert.Null(ex);
        }
    }

public class Order
{
  // ..

  public Order(string userId, string userName, Address address, int cardTypeId, string cardNumber, string cardSecurityNumber,
                string cardHolderName, DateTime cardExpiration, int? buyerId = null, int? paymentMethodId = null) : this()
        {
            _buyerId = buyerId;
            _paymentMethodId = paymentMethodId;
            _orderStatusId = OrderStatus.Submitted.Id;
            _orderDate = DateTime.UtcNow;
            Address = address;

            // Add the OrderStarterDomainEvent to the domain events collection 
            // to be raised/dispatched when comitting changes into the Database [ After DbContext.SaveChanges() ]
            AddOrderStartedDomainEvent(userId, userName, cardTypeId, cardNumber,
                                       cardSecurityNumber, cardHolderName, cardExpiration);
        }

  public void AddOrderItem(int productId, string productName, decimal unitPrice, decimal discount, int units = 1)
        {
            var existingOrderForProduct = _orderItems.Where(o => o.ProductId == productId)
                .SingleOrDefault();

            if (existingOrderForProduct != null)
            {
                //if previous line exist modify it with higher discount  and units..

                if (discount > existingOrderForProduct.GetCurrentDiscount())
                {
                    existingOrderForProduct.SetNewDiscount(discount);
                }

                existingOrderForProduct.AddUnits(units);
            }
            else
            {
                //add validated new order item

                var orderItem = new OrderItem(productId, productName, unitPrice, discount, pictureUrl, units);
                _orderItems.Add(orderItem);
            }
        }

    // ...

     public void SetPaidStatus()
        {
            if (_orderStatusId == OrderStatus.StockConfirmed.Id)
            {
                AddDomainEvent(new OrderStatusChangedToPaidDomainEvent(Id, OrderItems));

                _orderStatusId = OrderStatus.Paid.Id;
                _description = "The payment was performed at a simulated \"American Bank checking bank account ending on XX35071\"";
            }
        }
}