[Required]
public string Title { get; set; }

پوشه Contracts شامل واسط‌های مورد نیاز برای repository logic می‌باشد:

namespace ASPCoreGraphQL.Contracts
{
    public interface IOwnerRepository
    {
    }
}

namespace ASPCoreGraphQL.Contracts
{
    public interface IAccountRepository
    {
    }
}

@if (!SecurityService.IsAuthenticated)
{
                            <li>@Html.ActionLink("ورود", "Login", "Main")</li>
}

public abstract class CustomViewPage : ViewPage
    {
        public CustomViewPage(IUserService userService, ISecurityService securityService, IUnitOfWork uow)
        {
            Uow = uow;
            SecurityService = securityService;
            UserService = userService;
        }

        public IUserService UserService { get; private set; }
        public ISecurityService SecurityService { get; private set; }
        public IUnitOfWork Uow { get; private set; }
        
    }
    public abstract class CustomViewPage<TModel> : ViewPage<TModel>
    {
        public CustomViewPage(IUserService userService, ISecurityService securityService, IUnitOfWork uow)
        {
            Uow = uow;
            SecurityService = securityService;
            UserService = userService;
        }

        public IUserService UserService { get; private set; }
        public ISecurityService SecurityService { get; private set; }
        public IUnitOfWork Uow { get; private set; }

        
    }

 public class Kala
    {
        [Key]
        public int Kala_id { get; set; }
        
        [DisplayName("نام کالا")]
        public string Name { get; set; }

        [DisplayName("قیمت خرید")]
        public double Fee_Kharid { get; set; }
     
        public virtual Brand Brand { get; set; }
        
        public ICollection<Anbar_Kala> Anbar_Kalas { get; set; }
    }

 public class Anbar_Kala
    {
        [ForeignKey("Anbar_Id")]
        public virtual Anbar Anbar { get; set; }
        public int Anbar_Id { get; set; }

        [ForeignKey("Kala_Id")]
        public virtual Kala Kala{ get; set; }
        public int Kala_Id { get; set; }

        [DisplayName("تعداد")]
        public int Tedad { get; set; } //تعداد کالاها در هر انبار
    }

public class KalaViewModel 
    {
        public int Kala_Id { get; set; }
        public string  Name { get; set; }
        public double Fee_Kharid { get; set; }
        public string Brand_Name { get; set; }
        public int Tedad { get; set; }
    }

//controller
        var kala = _Kala_Service.GetAllKalas();
        var tedad= _Anbar_Kala_Service.GetAllAnbar_Kalas();

        var kalaviewmodel = EntityMapper.Map<List<KalaViewModel>>(kala, tedad);


protected override void Configure()
        {
        Mapper.CreateMap<Kala, KalaViewModel>()
       .ForMember(des => des.Brand_Name, op => op.MapFrom(src => src.Brand.Brand_Name));
              
       Mapper.CreateMap<Anbar_Kala, KalaViewModel>(); // این نگاشت باید به چه صورتی باشد؟
      .ForMember(des =>des.Kala_Id, op=>op.Ignore();     
        }

public class MyBaseEntity
{
  public int Id {get;set;}
}

public class Student : MyBaseEntity
{
  public string Name {get;set;}
 //...
}

public class SomeGenericWorker <TEntity> where TEntity : BaseEntity
{
 //...

  public void DoSth(TEntity entity)
{
  if (entity is Student)
{
  // ...
}

}
 
}

using System;
using SimpleCqrs.Domain;

namespace CqrsPattern.Cqrs.Command
{
    public class Account : AggregateRoot
    {
        public Account(Guid id)
        {
            Apply(new AccountCreatedEvent { AggregateRootId = id });
        }

        public void SetName(string firstName, string lastName)
        {
            Apply(new AccountNameSetEvent { FirstName = firstName, LastName = lastName });
        }

        public void OnAccountCreated(AccountCreatedEvent evt)
        {
            Id = evt.AggregateRootId;
        }
    }
}

using SimpleCqrs.Commanding;

namespace CqrsPattern.Cqrs.Command
{
    public class CreateAccountCommand : ICommand
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}

using System;
using SimpleCqrs.Commanding;
using SimpleCqrs.Domain;

namespace CqrsPattern.Cqrs.Command
{
    public class CreateAccountCommandHandler : CommandHandler<CreateAccountCommand>
    {
        private readonly IDomainRepository repository;

        public CreateAccountCommandHandler(IDomainRepository repository)
        {
            this.repository = repository;
        }

        public override void Handle(CreateAccountCommand command)
        {
            var account = new Account(Guid.NewGuid());
            account.SetName(command.FirstName, command.LastName);

            repository.Save(account);
        }
    }
}

using System.Linq;
using SimpleCqrs.Eventing;
using CqrsPattern.Cqrs.Db;

namespace CqrsPattern.Cqrs.Command
{
    public class AccountEventHandler : IHandleDomainEvents<AccountCreatedEvent>,
                                             IHandleDomainEvents<AccountNameSetEvent>
    {
        private readonly FakeAccountTable accountTable;

        public AccountEventHandler(FakeAccountTable accountTable)
        {
            this.accountTable = accountTable;
        }

        public void Handle(AccountCreatedEvent domainEvent)
        {
            accountTable.Add(new FakeAccountTableRow { Id = domainEvent.AggregateRootId });
        }

        public void Handle(AccountNameSetEvent domainEvent)
        {
            var account = accountTable.Single(x => x.Id == domainEvent.AggregateRootId);
            account.Name = domainEvent.FirstName + " " + domainEvent.LastName;
        }
    }
}

using System;
using SimpleCqrs.Commanding;
using CqrsPattern.Cqrs.Query;
using CqrsPattern.Cqrs.Command;

namespace CqrsPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            var runtime = new SampleRunTime();

            runtime.Start();

            var fakeAccountTable = new FakeAccountTable();
            runtime.ServiceLocator.Register(fakeAccountTable);
            runtime.ServiceLocator.Register(new AccountReportReadService(fakeAccountTable));
            var commandBus = runtime.ServiceLocator.Resolve<ICommandBus>();

            var cmd = new CreateAccountCommand { FirstName = "Ali", LastName = "Kh" };

            commandBus.Send(cmd);

            var accountReportReadModel = runtime.ServiceLocator.Resolve<AccountReportReadService>();

            Console.WriteLine("Accounts in database");
            Console.WriteLine("####################");
            foreach (var account in accountReportReadModel.GetAccounts())
            {
                Console.WriteLine(" Id: {0} Name: {1}", account.Id, account.Name);
            }

            runtime.Shutdown();

            Console.ReadLine();
        }
    }
}

namespace Refactoring.Day1.EncapsulateCollection
{
    public class OrderItem
    {
        public int Id { set; get; }
        public string Name { set; get; }
        public int Amount { set; get; }
    }
}

using System.Collections.Generic;

namespace Refactoring.Day1.EncapsulateCollection
{    
    public class Orders
    {
        public List<OrderItem> OrderItems { set; get; }
    }
}

Error, Certainty 95, for Do Not Expose Generic Lists

Warning, Certainty 75, for Collection Properties Should Be ReadOnly

using System.Linq;
using System.Collections.Generic;

namespace Refactoring.Day1.EncapsulateCollection
{
    public class Orders
    {
        private int _orderTotal;
        private List<OrderItem> _orderItems;

        public IEnumerable<OrderItem> OrderItems
        {
            get { return _orderItems; }
        }

        public void AddOrderItem(OrderItem orderItem)
        {
            _orderTotal += orderItem.Amount;
            _orderItems.Add(orderItem);
        }

        public void RemoveOrderItem(OrderItem orderItem)
        {
            var order = _orderItems.Find(o => o == orderItem);
            if (order == null) return;

            _orderTotal -= orderItem.Amount;
            _orderItems.Remove(orderItem);
        }
    }
}