I've got a simple application that loads data from an XML file to some database.

public class EmployeeLoader()  
{ 
   public void LoadEmpoyees()
   {...}

   public void LoadSalaries()
   {...}

   public void LoadRegistrationData()
   {...}    

   public void LoadTaxData()
   {...}
}

Could it be smart to have multiple "Load" techniques because this appears like a code smell when i have about tweney Load techniques? If that's the case, how do you make my code more readable?
Each Load method loads data towards the corresponding table within the database using a repository?

Really, getting it divided into well-named steps like this is readable.

Check this out article: http://www.codinghorror.com/blog/2008/07/coding-without-comments.html

The large real question is whether these techniques all need to be public. Ideally you'd want something similar to just one public Load method that loads from the database by calling all your private Load* techniques.

Getting them separate allow it to be a lot more readable than the usual load method with a lot of boilerplate to handle the various situations

You'd have something similar to

public void Load() {
  if (condition1 that makes me know I'm loading an employee) {
    //whatever applies to this condition
  }
  if (condition2 that makes me know I'm loading salaries) {
    //whatever applies to this condition
  }
  if (condition3 that makes me know I'm loading registrationData) {
    //whatever applies to this condition
  }
  if (condition4 that makes me know I'm loading taxData) {
    //whatever applies to this condition
  }
}

Ugh.

Even when the techniques do much the same stuff, it may be advisable separating them and calling similar techniques. By doing this, if something changes, it will likely be a simple refactor =).

Finally, when the class will get too large (a lot of duties), you may consider entering more classes with increased specific duties.

What about just one exposure indicate the consumer known as "Load()" this process might take an enum argument inside it showing what they need to load, after which underneath the covers you could have as numerousOrcouple of techniques since you needOrwish to implement this outer uncovered call.

I am presuming the loaded data will probably be held in local fields/dictionaries, after which utilized by permanently.

if that's the situation you can lazy load the values because they are needed.

public class EmployeeLoader
{

    private List<String> _Employees = null;
    public List<String> Employees
    {
        get
        {
            if (_Employees == null)
            {
                LoadEmployees();
            }
            return _Employees;
        }
    }

    private void LoadEmployees()
    {
        //Load Data
    }
}

to enhance you could have just one Load() approach to pressure load the values into individuals backing fields.