My team and I are having a discussion about whether or not to use DTO models as method parameters of an interface contract. Bear in mind that we are using an interface so we can use dependency inversion and mock this as a dependency for unit testing.

```
public interface IContract {
    object Method1(DTOModel model);
}

public class Implementation1 {
    public object Method1(DTOModel model) {
        //do stuff with Property1 and Property2
    }
}

public class Implementation2 {
    public object Method1(DTOModel model) {
       //do stuff with Property3 and Property4
    }
}

public class DTOModel {
    public string Property1 {get;set;}
    public string Property2 {get;set;}
    public string Property3 {get;set;}
    public string Property4 {get;set;}
}

```

The scenario is this: We are trying to be flexible in our implementations so that we could possibly use both of them at the same time. I disagree with this approach unless both implementations require the same information in the contract. In my opinion, that would be a separate contract/implementation or the current contract must change and only 1 implementation should be used at the same time.

My thoughts are that if you use a DTO in this fashion you are defeating the contract by allowing two different implementations to behave differently based on which properties are set. It also means that the consumer has to know which implementation is being used to know which properties are required for the operation to be completed. Finally, it means that both implementations have access to properties of each other where they are not necessary.

The way I would fix this is to instead pass properties of `DTOModel` to the implementation and make `Implementation2` adhere to that contract:

```
public object Method1(string property1, string property2) {
    //do stuff with property1 and property2
}

```

The question is: Is it acceptable to pass in a DTO like above knowing that your implementations don't rely on the whole contract and/or rely on different parts of the contract in order to do different things? Or should the contract be explicit in what the implementation needs to do its work?

Thanks in advance.

UPDATE: 
To clarify, both of these implementations have the same purpose but operate on different providers. For example, we may be using 2 membership providers and one provider requires 2 specific properties, and the other requires 2 different properties. Their purpose is the same in that they will both be authenticating a user, however the means by which each implementation does so is different.