Question: In my research I have found mixed messages on this subject so I'm looking for expertise to explain the best approach to encrypting variable amounts of data.

**Requirements:**

[Edit: Adding additional requirement #3 in response to comment]

1. I would like to use RSA for the public/private key encryption scheme
so I can distribute the public key to an application that should
encrypt data but should not know how to decrypt it
2. I need to support data lengths from 16 characters (credit card
number) to kilobytes (serialized objects) and beyond. Most of the
 data I encrypt will be small (credit cards, addresses, etc).
3. This is for encrypting data at rest.

**Options I'm Aware Of:**

1. **RSA-ONLY:** Use `RSACryptoServiceProvider` to encrypt all data using public key. 
Iterate through the data in blocks that are less than the key size
minus padding.
2. **HYBRID:** Use `AesCryptoServiceProvider` to encrypt the data, calling
`.GenerateKey()` and `.GenerateIV()` to generate a random key and IV.
Then use RSACryptoServiceProvider to encrypt the above key and IV
and prepend or append that to the data.

It seems to my the Hybrid approach gives me the best of both worlds. Strong block cipher (AES) and distributed public key (RSA).

What are the pros and cons of these approaches? What is the standard? Surprisingly I have not found much opinion or information on the subject and would appreciate any references you might have.

**Bonus:**
I am rolling my own for various reasons including corporate licensing restrictions but I'm curious if there is a good standard opensource approach for C#.

Answer: 
in most cases RSA is used to encrypt a symetric key (you don't really need to encrypt the IV, but hey...)

if you use RSA for encryption of data (instead of a key) you might run into the ECB (Electronic Code Book mode) problem that is known in the context of symetric block cyphers: for a given key, a clear-text is always mapped to the same cypher-text ... that alone doesn't help in breaking the encryption, but it can leak information since an attacker can identify which data packages contain the same clear-texts 

i'd choose the hybrid approach, because it's suitable for arbitrary sized data, and won't be prone to this information leak unless you choose ECB for the mode of operation (CBC - Cypher Block Chaining mode - should do)
If you just want to use RSA to store a small amount of data, smaller than the number of bits in the key, you can pad the input data with random numbers. There are several padding schemes listed at <https://en.wikipedia.org/wiki/RSA_(cryptosystem)#Padding>