Abhängigkeitsbehälter und Konstrukteure ⇐ C#

[Anonymous]

Ich habe einige Zeit damit verbracht, mich auf Abhängigkeitsinjektion und IOC zu dokumentieren, aber ich habe keine Lösung für mein Problem gefunden. In fast allen Beispielen, auf die ich gestoßen bin, haben die Konstruktoren der Betonklassen keine Argumentation. Es macht alles eher "einfach". Daher meine Frage hier. Zum Beispiel CSV und XML. Wir müssen so etwas für Quelle B. < /p>

hier nicht angebenusing System.Net;
using System.IO;
using System.Reflection;

namespace Question
{
class Program
{
static void Main(string[] args)
{
//exemple of code using Client A
DependencyContainer container1 = GetContainer1();
IClient client1 = container1.Resolve("xml");
User user1 = new User(client1);
user1.run();

DependencyContainer container2 = GetContainer2();
IClient client2 = container2.Resolve();
User user2 = new User(client2);
user2.run();
}

public static DependencyContainer GetContainer1()
{
DependencyContainer container = new DependencyContainer();
container.Register();
return container;
}

public static DependencyContainer GetContainer2()
{
DependencyContainer container = new DependencyContainer();
container.Register();
return container;
}
}

public class User
{
private readonly IClient _Client;

public User(IClient client)
{
_Client = client;
}

public void run()
{
string address = _Client.getAddress();
string data = _Client.getData(address);
_Client.writeData(data);
}
}
// Abstraction
public interface IClient
{
///
/// create the address or the name of the file storing the data
///
string getAddress();

///
/// uses a WebClient to go and get the data at the address indicated
///
string getData(string adress);

///
/// Write the data in a local folder
///
void writeData(string data);
}

//Implementation A
public class ClientA : IClient
{
// Specify the type of the file to be queried in the database
// could be a csv or an xml for example
private readonly string _FileType;

public ClientA(string fileType)
{
_FileType = fileType;
}

public string getAddress()
{
return "addressOfFileContainingData." + _FileType;
}

public string getData(string address)
{
string data = string.Empty;
using (WebClient client = new WebClient())
{
data = client.DownloadString(address);
}
return data;
}

public void writeData(string data)
{
string localAddress = "C:/Temp/";
using (StreamWriter writer = new StreamWriter(localAddress))
{
writer.Write(data);
}
}
}

//Implementation B
public class ClientB : IClient
{
public ClientB()
{
}

public string getAddress()
{
return "addressOfFileContainingData";
}

public string getData(string address)
{
string data = string.Empty;
using (WebClient client = new WebClient())
{
data = client.DownloadString(address);
}
return data;
}

public void writeData(string data)
{
string localAddress = "C:/Temp/";
using (StreamWriter writer = new StreamWriter(localAddress))
{
writer.Write(data);
}
}
}

public class DependencyContainer
{
private Dictionary _Map = new Dictionary();

public void Register()
{
_Map.Add(typeof(TypeToResolve), typeof(ResolvedType));
}

public T Resolve(params object[] constructorParameters)
{
return (T)Resolve(typeof(T), constructorParameters);
}

public object Resolve(Type typeToResolve, params object[] constructorParameters)
{
Type resolvedType = _Map[typeToResolve];
ConstructorInfo ctorInfo = resolvedType.GetConstructors().First();
object retObject = ctorInfo.Invoke(constructorParameters);
return retObject;
}
}
< /code>

} < /p>

Ich denke, es gibt einige gute Punkte in diesem Code, aber ich kann mich gerne korrigieren. Die Instantiationen jedoch: < /p>

IClient client = container.Resolve("xml");
< /code>

und < /p>

IClient client = container.Resolve();
< /code>

Zeichnen Sie mir viele Bedenken. Das hochstufige Modul (Klassenbenutzer hier) hängt nicht wie erwartet von der konkreten Implementierung ab. Jetzt hängt das Klassenprogramm jedoch von der Struktur des Konstruktors der konkreten Klasse ab! Daher löst es ein Problem, indem es woanders ein viel größeres Problem erzeugt. Ich würde mich eher auf die konkrete Implementierung verlassen, sondern auf der Struktur seines Konstruktors. Stellen Sie uns vor, der Code von Clienta ist refaktiert und der Konstruktor wird geändert. Dann habe ich keine Ahnung, dass das Klassenprogramm es tatsächlich verwendet. Lösen Sie dieses Problem? Aber bedeutet das, dass ein Konstruktor bei der Verwendung eines Abhängigkeitsbehälters niemals Argumente haben sollte? Oder bedeutet das, dass ein Objekt mit Argumenten in seinem Konstruktor kein guter Kandidat für diese Art von Technik ist?>