Q:

Send funds to owner after each buy or after several?

I copied and modified smart contracts from TenX and EOS.
TenX sends funds to their wallet after every purchase from a buyer:
function createTokens(address recipient) public isUnderHardCap saleIsOn payable {
    uint rate = exchangeRate.getRate("ETH");
    uint tokens = rate.mul(msg.value).div(1 ether);
    token.mint(recipient, tokens);
    require(multisigVault.send(msg.value));
    TokenSold(recipient, msg.value, tokens, rate);
  }

Whereas EOS does not.  EOS seems to collect funds every once in a while:
// Crowdsale owners can collect ETH any number of times
    function collect() auth {
        assert(today() > 0); // Prevent recycling during window 0
        exec(msg.sender, this.balance);
        LogCollect(this.balance);
    }

Doesn't it get too expensive (with gas) to do it TenX's way, especially if there are thousands of transactions?  Is it insecure to do it EOS's way, because they are leaving funds on the contract?
Which is the better method? 
UPDATED 2017-08-25
Maybe the better way is something in between.  I'm thinking of adding the following code, which is to send only if contract's balance is over 50 ETH and also give the owner the option to disable/enable this.  If this the best method or compromise?:
  bool public autoSend = true;

  function createTokens(address recipient) public payable {
    require(recipient != 0x0);
    require(validPurchase());
    uint256 tokens = rate.mul(msg.value).div(1 ether);
    require(token.mint(recipient, tokens));
    weiRaised = weiRaised.add(msg.value);
    if (autoSend && this.balance > 50000000000000000000) { // > 50 ETH
        uint256 amount = this.balance;
        Vault.transfer(this.balance);
        LogCollect(amount);
    }
    LogBuy(recipient, msg.value, tokens, rate);
  }

  function collect() onlyOwner returns (uint256) {
    uint256 amount = this.balance;
    Vault.transfer(this.balance);
    LogCollect(amount);
    return amount;
  }

  function setAutoSend(bool _auto) public onlyOwner {
    autoSend = _auto;
  }

A:

I suggest to follow EOS design choice:

It costs less in terms of overall GAS spent
Transfer costs are payed from the recipent of the funds, not from senders (this seems to me more fair)
It uses a best practice about sending funds. From Solidity
documentation:

The recommended method of sending funds after an effect is using the
  withdrawal pattern.
  Although the most intuitive method of sending Ether, as a result of an
  effect, is a direct send call, this is not recommended as it
  introduces a potential security risk. You may read more about this on
  the Security Considerations page.

