creating a concreate implemetation inside a method I have this code:

public bool IsWorkAddedWIthConcreteImplementation()
{
    SomeAgentClass agentClass = new SomeAgentClass();
    bool param1 = true;
    string param2 = "Hello";
    DataTable dt1 = agentClass.ProvideData(param1, param2);
    SimpleDAl da = new SimpleDAl();
    DataTable dt = da.ProvideData(dt1);
    bool isDataSentSuccessfully = agentClass.SendDataToClient(dt);
    IUnImplementedInterface dalInterface = new SimpleDAl();
    if (dalInterface.ReturnMeTrue(dt1))
    {
        return true;
    }
    else
    {
        return false;
    }


}


And the implementation

 IUnImplementedInterface dalInterface = new SimpleDAl();


Should I have passed the interface as a parameter to method or in the class constructor?
What will happen to the method signature or class constructor signature if more interfaces are introduced ?

Update:

In the actual implementation new SimpleDal() class is replaced by DaFactory.GetUnImplementedInterface(), which is returning me the concrete instance of IUnImplementedInterface.

Now the DaFactory is using Activator.CreateInstance() in order to give me correct instantiation.

Update2

One thing I forgot to tell was, that I am passing the DaFactory instance in the constructor of this class, and later using this factory instance to create concrete IUnImplementedInterface instance.

Update3 and Solution

Finally my code structure will now be having a IUnImplementedInterface instance in the class rather than the Factory instance.So now the caller of this class will have to pass the correct concrete implementation of this interface in its constructor.
This article is a great overview of Inversion of Control (IoC), and why it makes code easier to work with. But here's an example in the context of the code you posted. Imagine you are working on the SimpleDal class and decide that you have some configuration setting that you need to pass in. So now your constructor looks like this.

public class SimpleDal:IUnImplementedInterface
{
    public SimpleDal(string configSetting)
    {
        ...do something with it
    }

    ...

    public bool ReturnMeTrue(DataTable dt1){...}
}


This is not an issue in itself, except for now your line   

IUnImplementedInterface dalInterface = new SimpleDAl();


needs to have that string in the constructor call (or you could add another constructor that called it with a default value). The point here is that in the end all your calling code really cares about is the IUnImplementedInterface.ReturnMeTrue() method. You "should" be able to replace SimpleDal with any other class that implements that interface (polymorphism). So, by deferring the creation of the IUnImplementedInterface instance to a level above the calling code or by using a factory method, you separate the concern of creating a dependency and using that dependency. The two most popular methods of achieving that are Dependency Injection, or Factory methods.