Dependency Inversion Principle in WCF - wcf

Question

I have a WCF service and I was trying following dependency Inversion Principle there. I have some queries and list below.
Code before dependency principle and after dependency principle is given below..
Code before dependency principle:-
INodeAppService.cs
namespace MyAppService
{
public class Nodes
{
[DataMember]
public int NodeID { get; set; }
[DataMember]
public string Item { get; set; }
}
[ServiceContract]
public interface INodeAppService
{
[OperationContract]
[WebGet(ResponseFormat = WebMessageFormat.Json)]
List<Nodes> GetNodes(); //changed
}
}
NodeAppService.svc.cs
namespace MyAppService
{
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class NodeAppService: INodeAppService
{
public List<Nodes> GetNodes()
{
List<Nodes> nodeList = new List<Nodes>(); //changed
SqlCommand sqlCommand = new SqlCommand("myquery", conn);
SqlDataAdapter da = new SqlDataAdapter(sqlCommand);
DataTable dt = new DataTable();
try
{
da.Fill(dt);
foreach (DataRow row in dt.Rows)
{
Nodes node= new Nodes();
node.NodeID = Convert.ToInt32(row["NodeID"]);
node.Item = row["Item"].ToString();
nodeList.Add(node); //changed
}
return nodeList;
}
catch (Exception e)
{
throw e;
}
finally
{
conn.Close();
}
}
Code after dependency principle :-
INodeAppService.cs
namespace MyAppService
{
public class Nodes
{
[DataMember]
public int NodeID { get; set; }
[DataMember]
public string Item { get; set; }
}
[ServiceContract]
public interface INodeAppService
{
[OperationContract]
[WebGet(ResponseFormat = WebMessageFormat.Json)]
IList<Nodes> GetNodes(); // List changed to IList
}
}
NodeAppService.svc.cs
namespace MyAppService
{
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class NodeAppService: INodeAppService
{
private IList<Nodes> _nodeList;
public NodeAppService(IList<Nodes> nodeList)
{
_nodeList= nodeList;
}
public IList<Nodes> GetNodes()
{
SqlCommand sqlCommand = new SqlCommand("myquery", conn);
SqlDataAdapter da = new SqlDataAdapter(sqlCommand);
DataTable dt = new DataTable();
try
{
da.Fill(dt);
foreach (DataRow row in dt.Rows)
{
Nodes node= new Nodes(); // How can I remove this dependency?
node.NodeID = Convert.ToInt32(row["NodeID"]);
node.Item = row["Item"].ToString();
_nodeList.Add(node);
}
return _nodeList;
}
catch (Exception e)
{
throw e;
}
finally
{
conn.Close();
}
}
1) But I am getting error "The service type provided could not be loaded as a service because it does not have a default (parameter-less) constructor. To fix the problem, add a default constructor to the type, or pass an instance of the type to the host".
But giving default parameter will not fix my problem. Please give a solution to solve the problem.
2) Nodes node= new Nodes(); // How can I remove this dependency? [Please see the code]
3) Dependency Inversion Principle and wcf is good approach?
Thanks.
I was able to implement Dependency Inversion Principle using the Dependency Injection Container named "Castle Windsor". But it seems like in my case creating object of Nodes class is not referred as "Dependency".
List<Nodes> nodeList = new List<Nodes>();
I have read like this .
"A data only object are not typically referred to as a "dependency", since they don't perform some needed function." Any thoughts?
Thanks.

Answer 1

The dependency here is your Service implementation not the specific nodes collection, Your WCF service is dependent on SQL data access code that should be abstracted and injected into the service.
Essentially the following code needs to be put in front of an interface so your WCF service no longer has this dependency
SqlCommand sqlCommand = new SqlCommand("myquery", conn);
SqlDataAdapter da = new SqlDataAdapter(sqlCommand);
DataTable dt = new DataTable();
try
{
da.Fill(dt);
foreach (DataRow row in dt.Rows)
{
Nodes node= new Nodes(); // How can I remove this dependency?
node.NodeID = Convert.ToInt32(row["NodeID"]);
node.Item = row["Item"].ToString();
_nodeList.Add(node);
}
return _nodeList;
}
catch (Exception e)
{
throw e;
}
finally
{
conn.Close();
}
The following Blog uses a repository pattern to implement dependency inversion
http://thedersen.com/blog/2010/04/20/dependency-inversion/