Dto could be any plain get/set properties class or struct, collections of those and combination that may be data carrier
IDto interface should be implemented:

public interface IDto
{
   void Extend();
   void Resolve();
}

  Extend member could be used for addition of calculative fields at initial structure - ex. column in DataRow - or other extension.
Resolve member may be used for iteration/navigation of Dto collections of Dto and in memory persistence of business calculations.
Structure of constructs in solution explorer:



   Using a Dto, classes (Order.cs) consists of stateless function calls, for business manipulation/validation. The sequence Interface > Abstract class >[Implementation] > Class, offers different implementation of business layer with common interface.  Implementation execution becomes through singleton Managers(OrderMngr.cs, containers) by dependency injection and factory methods.
Rules containing object is unique in memory (Order.cs), per process, per implementation - not singleton object/static functions. The sample Dal in source code implemented with mainstream Table Adapters and Northwind DB...

public abstract class ManagerAb
{
   ...

   protected IObject GetDefaultInstance() {      
   }

   protected IObject GetInstanceByKey( Implementation implementation ){         
   }   

   protected void AddToRepository( Implementation implementation, Type baseType ){
   } 

   ...
}


public class OrderMngr : ManagerAb
{
  ...

   OrderMngr()
   {
       AddToRepository( defaultImplementation, typeof(OrderAb) ); // Config Manager
    }  

    public IOrder GetInstance()
   {
      return (IOrder)GetDefaultInstance();
    }

   ...
}

Rules containing objects(Order.cs) return IBllError with IDto argument

public interface IObject
{
   IBllError Prepare( IDto dto );
   IBllError Load( IDto dto );
   IBllError Add( IDto dto );
   IBllError Modify( IDto dto );
   IBllError Remove( IDto dto );
   IBllError Search( IDto dto );
}

Call for a business function may be

OrderMngr.Actions.GetInstance().CheckOut( IDto );  

and intrincic functions:

public interface IOrder : IObject
{
  IBllError AddToCart( IDto dto );
  IBllError CheckOut( IDto dto );
  IBllError SubmitOrder( IDto dto );
  IBllError GetUserOrderHistory( IDto dto );
}


public class Order : OrderAb
{
   ...

   public override IBllError CheckOut( IDto dto ){

      OrderDto orDto = dto as OrderDto; 
      try
      {   
         // Custom Validation rules for Checking Out
                
         return base.CheckOut( dto );
      }
      catch( Exception ex )
      {
         return new BllError( ex, null );
      }
      finally
     {     

      }
   }

   ...
}

  Adopting a plain data structure back and forth to UI and data persistence medium, business rules implementation is granular and accurate.