creating a concreate implemetation inside a method
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.