I just finished James Kovac's article on Inversion of Control and Dependency Injection and then used what I learned to make my own IoC/DI example below.
I'm quite satisified with this example since it:
satisfies the testability aspect of IoC in that it instantiates Customers by passing both a Repository and a MockRepository
also the authorization service is decoupled which would allow you to e.g. write another authorization service with different rules, and then you could easily swap them out based on other conditions
However, looking toward progressing from here, some things seem odd:
I don't seem to have a "container". Is my Customer class "acting as a container" in this sense?
if I were to port this to WPF, where would Modules (in terms of Prism) fit into this example (e.g. would AuthorizationService and Repository be modules?)
if I were to port this to WPF, where would MVVM fit in? Do have have parts of MVVM through having the dependency injection or is MVVM something separate altogether.
Thanks for any direction you can provide on this.
NEW CODE BASED ON COMMENTS:
using System;
using System.Linq;
using System.Collections.Generic;
namespace TestSimpleDependencyInjection1
{
class Program
{
static void Main(string[] args)
{
AuthorizationService authorizationService = new AuthorizationService();
//real example
Repository repository = new Repository(authorizationService);
for (int id = 1; id <= 3; id++)
{
Customer customer = repository.GetCustomer(id);
customer.Display();
}
Console.WriteLine();
//mock test example
MockRepository mockRepository = new MockRepository(authorizationService);
Customer mockCustomerAdministrator = repository.GetCustomer(1);
Customer mockCustomerSalesperson = repository.GetCustomer(2);
UnitTester.Assert("Administrators have access", mockCustomerAdministrator.GetAuthorizationMessage(), "Access Granted");
UnitTester.Assert("Salespeople do not have access", mockCustomerAdministrator.GetAuthorizationMessage(), "Access Granted");
Console.ReadLine();
}
}
public static class UnitTester
{
public static void Assert(string title, string value, string expectedResult)
{
Console.WriteLine(value == expectedResult ? String.Format("{0}: test succeeded", title) : String.Format("{0}: TEST FAILED!", title));
}
}
public class Customer
{
public int ID { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public AccessGroup AccessGroup { get; set; }
public AuthorizationService AuthorizationService { get; set; }
public string GetAuthorizationMessage()
{
return this.AuthorizationService.GetAccessMessage(this);
}
public Customer()
{
}
public void Display()
{
Console.WriteLine("Customer: {1}, {0} ({2}): {3}", this.FirstName, this.LastName, this.AccessGroup, this.GetAuthorizationMessage());
}
}
public class AuthorizationService
{
public string GetAccessMessage(Customer customer)
{
return customer.AccessGroup == AccessGroup.Administrator ? "Access Granted" : "Access Denied";
}
}
public class Repository : IRepository
{
private List<Customer> _customerSet = new List<Customer>();
private AuthorizationService _authorizationService;
public Repository(AuthorizationService authorizationService)
{
_authorizationService = authorizationService;
_customerSet.Add(new Customer {AuthorizationService = _authorizationService, ID = 1, FirstName = "Jim", LastName = "Smith", AccessGroup = AccessGroup.Administrator });
_customerSet.Add(new Customer {AuthorizationService = _authorizationService, ID = 2, FirstName = "John", LastName = "Johnson", AccessGroup = AccessGroup.Administrator });
_customerSet.Add(new Customer {AuthorizationService = _authorizationService, ID = 3, FirstName = "Hank", LastName = "Rivers", AccessGroup = AccessGroup.Salesperson });
}
public Customer GetCustomer(int id)
{
return (from c in _customerSet
where c.ID == id
select c).SingleOrDefault();
}
}
public class MockRepository : IRepository
{
private List<Customer> _customerSet = new List<Customer>();
private AuthorizationService _authorizationService;
public MockRepository(AuthorizationService authorizationService)
{
_authorizationService = authorizationService;
_customerSet.Add(new Customer { AuthorizationService = _authorizationService, ID = 1, FirstName = "Test1AdministratorFirstName", LastName = "Test1AdministratorLastName", AccessGroup = AccessGroup.Administrator });
_customerSet.Add(new Customer { AuthorizationService = _authorizationService, ID = 2, FirstName = "Test2SalespersonFirstName", LastName = "Test2SalesPersonLastName", AccessGroup = AccessGroup.Salesperson });
}
public Customer GetCustomer(int id)
{
return (from c in _customerSet
where c.ID == id
select c).SingleOrDefault();
}
}
public interface IRepository
{
Customer GetCustomer(int id);
}
public enum AccessGroup
{
Administrator,
Salesperson
}
}
AND PER REQUEST, HERE IS THE ORIGINAL CODE:
using System;
using System.Collections.Generic;
namespace TestSimpleDependencyInjection1
{
class Program
{
static void Main(string[] args)
{
AuthorizationService authorizationService = new AuthorizationService();
//real example
Repository repository = new Repository();
for (int id = 1; id <= 3; id++)
{
Customer customer = new Customer(id, authorizationService, repository);
customer.Display();
}
Console.WriteLine();
//mock test example
MockRepository mockRepository = new MockRepository();
Customer mockCustomerAdministrator = new Customer(1, authorizationService, mockRepository);
Customer mockCustomerSalesperson = new Customer(2, authorizationService, mockRepository);
UnitTester.Assert("Administrators have access", mockCustomerAdministrator.GetAuthorizationMessage(), "Access Granted");
UnitTester.Assert("Salespeople do not have access", mockCustomerAdministrator.GetAuthorizationMessage(), "Access Granted");
Console.ReadLine();
}
}
public static class UnitTester
{
public static void Assert(string title, string value, string expectedResult)
{
Console.WriteLine(value == expectedResult ? String.Format("{0}: test succeeded", title) : String.Format("{0}: TEST FAILED!", title));
}
}
public class Customer
{
private AuthorizationService authorizationService;
private IRepository repository;
public int ID { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public AccessGroup AccessGroup { get; set; }
public string GetAuthorizationMessage()
{
return authorizationService.GetAccessMessage(this);
}
public Customer(int id, AuthorizationService authorizationService, IRepository repository)
{
this.authorizationService = authorizationService;
this.repository = repository;
CustomerDB customerDB = repository.GetCustomerDB(id);
this.ID = customerDB.ID;
this.FirstName = customerDB.FirstName;
this.LastName = customerDB.LastName;
this.AccessGroup = customerDB.AccessGroup;
}
public void Display()
{
Console.WriteLine("Customer: {1}, {0} ({2}): {3}", this.FirstName, this.LastName, this.AccessGroup, this.GetAuthorizationMessage());
}
}
public class AuthorizationService
{
public string GetAccessMessage(Customer customer)
{
return customer.AccessGroup == AccessGroup.Administrator ? "Access Granted" : "Access Denied";
}
}
public class Repository : IRepository
{
private List<CustomerDB> _customerDBSet = new List<CustomerDB>();
public Repository()
{
_customerDBSet.Add(new CustomerDB { ID = 1, FirstName = "Jim", LastName = "Smith", AccessGroup = AccessGroup.Administrator });
_customerDBSet.Add(new CustomerDB { ID = 2, FirstName = "John", LastName = "Johnson", AccessGroup = AccessGroup.Administrator });
_customerDBSet.Add(new CustomerDB { ID = 3, FirstName = "Hank", LastName = "Rivers", AccessGroup = AccessGroup.Salesperson });
}
public CustomerDB GetCustomerDB(int id)
{
CustomerDB customerDBchosen = null;
//this should be done with LINQ (couldn't get it CustomerDB to implement IEnumerable correctly)
foreach (CustomerDB customerDB in _customerDBSet)
{
if (customerDB.ID == id)
{
customerDBchosen = customerDB;
break;
}
}
return customerDBchosen;
}
}
public class MockRepository : IRepository
{
public CustomerDB GetCustomerDB(int id)
{
switch (id)
{
case 1:
return new CustomerDB { ID = 1, FirstName = "Test1AdministratorFirstName", LastName = "Test1AdministratorLastName", AccessGroup = AccessGroup.Administrator };
case 2:
return new CustomerDB { ID = 2, FirstName = "Test2SalespersonFirstName", LastName = "Test2SalesPersonLastName", AccessGroup = AccessGroup.Salesperson };
default:
return null;
}
}
}
public interface IRepository
{
CustomerDB GetCustomerDB(int id);
}
public class CustomerDB
{
public int ID { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public AccessGroup AccessGroup { get; set; }
}
public enum AccessGroup
{
Administrator,
Salesperson
}
}
Your code violates the single responsibility principal in a pretty serious way.
http://en.wikipedia.org/wiki/Single_responsibility_principle
Your Customer object shouldn't be loading itself from a repository, the repository should be loading the Customer object and handing it back to the caller.
I would expect something more like:
Customer customer = repository.GetCustomer(3);
usage of Switch statements in most cases violate SRP. Do check this out for ways to eliminate switch statements in your code. The challenge & beauty of writing loosely coupled code is to eliminate if, if else & switch statements.
Related
New to XUnit and attempting to test the following method but test is failing.
I believe the reason is that a new instance of the data is created when the assert is called.
So even thought the results are the same the object reference is not.
When a new record is added to the collection, it is supposed to returned the same record added.
Employee Data Class:
public class EmployeeData
{
public int Id { get; set; }
public string LastName { get; set; }
public string FirstName { get; set; }
public string Title { get; set; }
}
Method to test:
public List<EmployeeData> Add(List<EmployeeData> employees)
{
foreach(var employee in employees)
{
data.Add(new EmployeeData() { Id = newId(),
FirstName = employee.FirstName, LastName = employee.LastName,
Title = employee.Title });
}
return data;
}
Test Method:
[Fact]
public void Add()
{
// Arrange
var data = new List<EmployeeData>();
data.Add(new EmployeeData() { Id = 1, FirstName = "Adams", LastName = "John", Title = "Fireman" });
// Mocking the employee class constructor arguments.
var mockLogging = new Mock<ILogger<DataService>>();
var mockConfig = new Mock<IConfiguration>();
var sut = new Employee(mockLogging.Object, mockConfig.Object);
var result = sut.Add(data);
// Assert should return the exact data inputted
Assert.Equal(result, data);
}
Test Result:
Message:
Assert.Equal() Failure
Expected: List<EmployeeData> [EmployeeData { FirstName = "Adams", Id = 1, LastName = "John", Title = "Fireman" }]
Actual: List<EmployeeData> [EmployeeData { FirstName = "Adams", Id = 1, LastName = "John", Title = "Fireman" }]
What does it mean that EmployeeData equals EmployeeData?
You can override Equals methods in the EmployeeData class.
public override bool Equals(object obj)
{
return this.FirstName == ((EmployeeData)obj).FirstName;
}
The second option is to pass IEqualityComparer<T> to the Equal method.
public class GenericCompare<T> : IEqualityComparer<T> where T : class
{
private Func<T, object> _expr { get; set; }
public GenericCompare(Func<T, object> expr)
{
this._expr = expr;
}
public bool Equals(T x, T y)
{
var first = _expr.Invoke(x);
var sec = _expr.Invoke(y);
if (first != null && first.Equals(sec))
return true;
else
return false;
}
public int GetHashCode(T obj)
{
return obj.GetHashCode();
}
}
And use it:
Assert.Equal<EmployeeData>(result, data, new GenericCompare<EmployeeData>(x => x.Id));
Copy pasted GenericCompare from https://stackoverflow.com/a/23623976/6629020
I am using Moq and want to verify the contents of a List parameter that is passed to the method.
Now how can I verify if the called Write Method,
public class DBStore
{
public virtual void Write(string retailName, List<CustomerInfo> list, List<Order> orderList)
{
}
}
had Customer Name "a" and the count?
public class CustomerInfo
{
public string Name;
public int CustomerInfoId;
}
I am able to verify string but not contents of a given list or the count.
[TestClass]
public class UnitTests
{
[TestMethod]
public void TestCustomer()
{
var dbStore = new Mock<DBStore>();
dbStore.Setup(x => x.Write(
It.IsAny<string>(),
It.IsNotNull<List<CustomerInfo>>(),
It.IsNotNull<List<Order>>()));
var updateInfo = new UpdateInfo(dbStore.Object);
updateInfo.UpdateCustomer();
dbStore.Verify(
o => o.Write(
"Walmart",
It.IsNotNull<List<CustomerInfo>>(),
It.IsNotNull<List<Order>>()));
}
}
Can I use IsAny<> in the Verify method? If so, how?
Supporting classes:
public class Order
{
public int CustomerInfoId;
public string Details;
public int OrderId;
}
public class UpdateInfo
{
public DBStore DB { get;set; }
public UpdateInfo(DBStore dbStore)
{
this.DB = dbStore;
}
public void UpdateCustomer()
{
// Logic to get some more info and get retail name
string retailName = "walmart";
List<CustomerInfo> customerList = new List<CustomerInfo>();
customerList.Add(new CustomerInfo { Name = "a", CustomerInfoId = 1 });
customerList.Add(new CustomerInfo { Name = "b", CustomerInfoId = 2 });
List<Order> orderList = new List<Order>();
orderList.Add(new Order { OrderId = 1, CustomerInfoId = 1 });
orderList.Add(new Order { OrderId = 2, CustomerInfoId = 1 });
this.DB.Write(retailName, customerList, orderList);
}
}
I am trying to write a unit test for My Processor class I have two problems
I do not know how to test my Methods Only.
this is my processor
OrderProcessor class
public class OrderProcessor
{
public void Process(CustomersOrder order)
{
var oldOrder = _repository.GetOldorderId(order.Code.Value);
if (oldOrder != 0)
{
updateOrder(order);
}
else
{
SaveOrder(order);
}
}
private void updateOrder(CustomersOrder order)
{
_repository.UpdateOrder(order);
}
private void SaveOrder(CustomersOrder order)
{
_repository.SaveOrder(order);
}
}
}
Repository class
public class Repository : IRepository
{
private static PracticeEntities4 _context;
public Repository(PracticeEntities4 context)
{
_context = context;
}
public int GetOldCustomerId( int customerCode)
{
var CuID= _context.Customers.First(e => e.Code == customerCode);
return CuID.Id;
}
public int GetOldorderId(int orderCode)
{
var oldOrder = _context.CustomersOrders.FirstOrDefault(e => e.Code == orderCode);
return oldOrder.Id;
}
public void SaveCustomer(Customer customer)
{
_context.Customers.Add(customer);
_context.SaveChanges();
}
public void SaveOrder(CustomersOrder order)
{
_context.CustomersOrders.Add(order);
_context.SaveChanges();
}
public void UpdateOrder(CustomersOrder order)
{
_context.CustomersOrders.AddOrUpdate(order);
_context.SaveChanges();
}
}
and this is My unit test I don't know how to fix it and where is the problem exactly and also I want to test the Methods too.
UnitTests Class
[TestClass]
public class OrderProcessorTest
{
[ClassInitialize]
{...}
[TestInitialize]
public void TestInitialize()
{
....
}
[TestMethod]
public void Customer_OrderProcess()
{
//Arange
Mock<IRepository> mock= new Mock<IRepository>();
//Act
mock.Setup(e => e.GetOldCustomerId(1001)).Returns(3);
mock.Setup(e => e.GetOldStoreId(200)).Returns(3);
var dtos = OrderDeserializer.Deserialize(path);
var dto = dtos.First(e => e.Code == 300);
OrderBuilder builder = new OrderBuilder(mock.Object);
builder.OrderBuild(dto);
//Asset
Assert.AreEqual(0, _orders.Count);
}
}
Order Builder Class
public class OrderBuilder
{
public IRepository _repository { get; set; }
public OrderBuilder(IRepository repository)
{
_repository = repository;
}
public CustomersOrder OrderBuild(OrderDto dto)
{
var oldStoreId = _repository.GetOldStoreId(dto.StoreCode);
var oldCustomerId = _repository.GetOldCustomerId(dto.CustomerCode);
return new CustomersOrder()
{
OrderDate = Convert.ToDateTime(dto.OrderDate),
OrderStatus = dto.OrderStatus,
DeliveryDate = Convert.ToDateTime(dto.DeliveryDate),
CustomerId = oldCustomerId,
StoreId = oldStoreId,
Code = dto.Code
};
}
}
In your code I see that there are all sorts of Mocking and Initial test setups that is taking place without a clear intention on what to test.
Unit Test: What ?
Tests a unit of an application without its external dependencies
Unit Test: Why ?
Makes refactoring faster and ensures you don't break existing portion of your code
Unit Test: Steps ?
We first need to re-factor the code before we do unit tests. Modularity is the key
By using Interfaces remove the tight couplings in the code
Inject the dependency via method parameters, constructor, properties or use Dependency Injection
Consider using Mock objects, as a good practice, only when dealing with external dependency.
In the [TestMethod] we organize the tests into 3 categories Arrange -> Act -> Assert
Example:
//Arrange
var res = new Reservation();
//Act
var op = res.Method(new User{IsAdmin=true});
// Assert
Assert.IsTrue(op);
Naming Conventions in UnitTests:
TestProjectName: [InserProjectName].UnitTests
TestClasses: [InsertClassName]Tests
TestMethod: [MethodYourTesting]_[Scenario]_[ExpectedBehavior]
I have created a Console app as close as possible to your problem
(minus the DBContext) that you can replicate on your PC to understand
the various portions.
All the domain classes are part of one single
file for the sake of testability to reproduce faster.
Console App Project
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StackOrderProcessor
{
public class CustomersOrder
{
public OrderDto Order { get; set; }
public List<CustomersOrder> CustomersOrders = new List<CustomersOrder>();
public DateTime OrderDate { get; set; }
public string OrderStatus { get; set; }
public int CustomerID { get; set; }
public int Code { get; set; }
public int ID { get; set; }
}
public class Customer
{
public OrderDto Order { get; set; }
public List<Customer> Customers = new List<Customer>();
public int Code { get; set; }
public int ID { get; set; }
}
public class OrderDto
{
public DateTime OrderDate { get; set; }
public int CustomerCode { get; set; }
public string OrderStatus { get; set; }
public int Code { get; set; }
}
public interface IRepository
{
int GetOldCustomerId(int customerCode);
int GetOldOrderId(int orderCode);
void SaveCustomer(Customer customer);
void SaveOrder(CustomersOrder order);
}
public class Repository : IRepository
{
private readonly Customer _cust;
private readonly CustomersOrder _custOrder;
public Repository(Customer cust, CustomersOrder custOrder )
{
_cust = cust;
_custOrder = custOrder;
}
public int GetOldCustomerId(int customerCode)
{
var cuId = _cust.Customers.First(e => e.Code == customerCode);
return cuId.ID;
}
public int GetOldOrderId(int orderCode)
{
var oId = _custOrder.CustomersOrders.FirstOrDefault(e => e.Code == orderCode);
return oId.ID;
}
public void SaveCustomer(Customer customer)
{
_cust.Customers.Add(customer);
}
public void SaveOrder(CustomersOrder order)
{
_custOrder.CustomersOrders.Add(order);
}
}
public class OrderProcess
{
private readonly IRepository _repository;
public OrderProcess(IRepository repository)
{
_repository = repository;
}
public void Process(CustomersOrder order)
{
var oldOrder = _repository.GetOldOrderId(order.Code);
if (oldOrder == 0)
_repository.SaveOrder(order);
}
}
public class OrderBuilder
{
private readonly IRepository _repository;
public OrderBuilder(IRepository repository)
{
_repository = repository;
}
public CustomersOrder OrderBuild(OrderDto dto)
{
var oldCustomerId = _repository.GetOldCustomerId(dto.CustomerCode);
return new CustomersOrder()
{
Order = dto,
OrderDate = Convert.ToDateTime(dto.OrderDate),
OrderStatus = dto.OrderStatus,
ID = oldCustomerId,
CustomerID = oldCustomerId,
Code = dto.Code
};
}
}
class Program
{
static void Main(string[] args)
{
var cust = new Customer();
var custOrder = new CustomersOrder();
#region PopulatingCustomer
//Populating OrderDto
var dto1 = new OrderDto { Code = 1, CustomerCode = 1, OrderDate = DateTime.Now.Date, OrderStatus = "OK" };
//Populating Customer
var customerList = cust.Customers = new List<Customer>();
var customerOrderList = custOrder.CustomersOrders = new List<CustomersOrder>();
var customer1 = new Customer
{
Code = 1,
ID = 1, Order=dto1
};
var customer2 = new Customer
{
Code = 2,
ID = 2,
};
customerList.Add(customer1);
customerList.Add(customer2);
#endregion
#region PopulatingCustomerOrder
var customersOrder1 = new CustomersOrder { Code = 1, CustomerID = 1, ID = 1, Order = dto1, OrderDate = dto1.OrderDate, OrderStatus = dto1.OrderStatus };
customerOrderList.Add(customersOrder1);
#endregion
#region InvokingMethods
//IRepository
IRepository IRepo = new Repository(cust,custOrder);
//OrderProcessor
var orderProcesor = new OrderProcess(IRepo);
//OrderBuilder
var dto2 = new OrderDto { Code = 2, CustomerCode = 2, OrderDate = DateTime.Now.Date, OrderStatus = "OK" };
var oBuilder = new OrderBuilder(IRepo);
var newCustOrder = oBuilder.OrderBuild(dto2);
customerOrderList.Add(newCustOrder);
#endregion
Console.Read();
}
}
}
UnitTest Project
using System;
using System.Collections.Generic;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using StackOrderProcessor;
namespace StackOrderProcessor.UnitTests
{
[TestClass]
public class RepositoryTests
{
[TestMethod]
public void GetOldCustomerId_WhenCalled_ReturnsOId()
{
//Arrange
var cust = new Customer();
var custOrder = new CustomersOrder();
IRepository repo = new Repository(cust,custOrder);
var customerList = cust.Customers = new List<Customer>();
var dto1 = new OrderDto { Code = 1, CustomerCode = 1, OrderDate = DateTime.Now.Date, OrderStatus = "OK" };
var customer1 = new Customer
{
Code = 1,
ID = 1,
Order = dto1
};
var customer2 = new Customer
{
Code = 2,
ID = 2,
};
customerList.Add(customer1);
customerList.Add(customer2);
//Act
repo.GetOldCustomerId(1);
//Assert
Assert.AreEqual(1, 1); //Test will Pass as we have a customer of Code 1
}
[TestMethod]
//MethodName_Scenario_Expectedbehavior
public void SaveCustomer_WhenCalled_AddsNewCustomer()
{
var cust = new Customer();
var custOrder = new CustomersOrder();
IRepository repo = new Repository(cust, custOrder);
var customerList = cust.Customers = new List<Customer>();
var dto1 = new OrderDto { Code = 1, CustomerCode = 1, OrderDate = DateTime.Now.Date, OrderStatus = "OK" };
var customer1 = new Customer
{
Code = 1,
ID = 1,
Order = dto1
};
var customer2 = new Customer
{
Code = 2,
ID = 2,
};
customerList.Add(customer1);
customerList.Add(customer2);
//Act
var custToSave = new Customer
{
Code = 3,
ID = 3,
Order = null
};
repo.SaveCustomer(custToSave);
//Assert
Assert.AreEqual(3, customerList.Count);
}
}
[TestClass]
public class OrderProcessor1Tests
{
[TestMethod]
public void Process_WhenOrderIsZero_AddsNewCustomerOrder()
{
//Arrange
var cust = new Customer();
var custOrder = new CustomersOrder();
var customerOrderList = custOrder.CustomersOrders = new List<CustomersOrder>();
IRepository repo = new Repository(cust, custOrder);
var orderProcessor = new OrderProcess(repo);
var dto1 = new OrderDto { Code = 1, CustomerCode = 1, OrderDate = DateTime.Now.Date, OrderStatus = "OK" };
var custOrder1 = new CustomersOrder { ID = 1, Code = 1, CustomerID = 1, Order = dto1, OrderDate = dto1.OrderDate, OrderStatus = dto1.OrderStatus };
customerOrderList.Add(custOrder1);
//Act
orderProcessor.Process(custOrder1);
//Assert
Assert.AreEqual(1, customerOrderList.Count);
}
}
}
Note: Make sure to add reference of StackOrderProcessor in StackOrderProcessor.UnitTests
You will still need to better organize the Unit Test Methods, this was just for demonstration purposes, I hope concepts are much more clear now
Your question doesn't have enough information, you don't need your repository code for this question, but OrderBuiler class and _orders field needs. I'm sorry for this comment in answers location.
I've come across a problem with Entity framework Core 2.0.2 and I wonder if someone can enlighten me.
What I have is a person class with a collection of phone numbers.
Person
public class Person : BaseEntity
{
[Required]
public string FirstName { get; set; }
public string MiddleName { get; set; }
[Required]
public string LastName { get; set; }
[Required]
public string Context { get; set; }
public string Email { get; set; }
public ICollection<PhoneNumber> PhoneNumbers { get; set; } = new List<PhoneNumber>();
}
PhoneNumber
public class PhoneNumber : BaseEntity
{
public string Usage { get; set; }
public int PersonId { get; set; }
public Person Person { get; set; }
}
BaseEntity is basically just a property with an id.
Then I have a generic repo
Repository
public class Repository<T> where T : BaseEntity
{
private readonly Dab2_2RdbContext _context;
public Repository(Dab2_2RdbContext context)
{
_context = context;
}
public void Create(T t)
{
_context.Entry<T>(t).State = EntityState.Added;
_context.SaveChanges();
}
public T Read(int id)
{
return _context.Find<T>(id);
}
public void Update(int id, T t)
{
_context.Entry<T>(t).State = EntityState.Modified;
_context.SaveChanges();
}
public void Delete(T t)
{
_context.Entry<T>(t).State = EntityState.Deleted;
_context.SaveChanges();
}
}
All of this code is very simple and works fine.
The situation happens when I test the code like this:
var context = new Dab2_2RdbContext();
var personRepo = new Repository<Person>(context);
var phoneNumberRepo = new Repository<PhoneNumber>(context);
var person = new Person()
{
FirstName = "Kasper",
LastName = "Lastname",
Email = "Something#gmail.com",
Context = "Myself",
};
person.PhoneNumbers = new List<PhoneNumber>()
{
new PhoneNumber() {Usage = "Work"},
new PhoneNumber() {Usage = "School"}
};
// Create
personRepo.Create(person);
This code generates a person with proper values, however, it doesn't include the Phone numbers.
var context = new Dab2_2RdbContext();
var personRepo = new Repository<Person>(context);
var phoneNumberRepo = new Repository<PhoneNumber>(context);
var person = new Person()
{
FirstName = "Kasper",
LastName = "Lastname",
Email = "Something#gmail.com",
Context = "Myself",
};
// Create
personRepo.Create(person);
person.PhoneNumbers = new List<PhoneNumber>()
{
new PhoneNumber() {Usage = "Work"},
new PhoneNumber() {Usage = "School"}
};
personRepo.Update(person.Id, person);
This code makes the proper relationship (the person.The phonenumber relation has been made. Notice the // Create person, shifted above person.Phone number
I wonder if someone can enlighten me, I really can figure out why this is.
The answer is that setting the state of the entry. Will only track the entity, and none of it's properties. While add will track all the navigation properties.
Thanks to those who answered my last question I got the code below to work which allows the developer to send multiple where clauses to a method which includes each of them in a LINQ statement. However, how can I get the inclusion of the where clauses to be dynamic? Instead of this:
return customers
.Where(whereClauses[0])
.Where(whereClauses[1])
.ToList();
something like this (pseudo-code):
List<Customer> customers = new List<Customer>();
foreach (var whereClause in whereClauses)
{
customers
.Where(whereClause...???)
.ToList();
}
return customers;
Here is the code that works:
using System;
using System.Collections.Generic;
using System.Linq;
namespace TestDynamicLinq2343
{
public class Program
{
static void Main(string[] args)
{
List<Customer> customers = Customer.GetCustomers();
List<Func<Customer, bool>> whereClauses = new List<Func<Customer, bool>>();
whereClauses.Add(c => c.LastName.ToUpper().Contains("A"));
whereClauses.Add(c => c.FirstName.ToUpper().Contains("J"));
foreach (var customer in Customer.GetFilteredCustomers(customers, whereClauses))
{
Console.WriteLine(customer.LastName);
}
Console.ReadLine();
}
}
public class Customer
{
public string FirstName { get; set; }
public string LastName { get; set; }
public string Street { get; set; }
public string Location { get; set; }
public string ZipCode { get; set; }
public static List<Customer> GetCustomers()
{
List<Customer> customers = new List<Customer>();
customers.Add(new Customer { FirstName = "Jim", LastName = "Jones" });
customers.Add(new Customer { FirstName = "Joe", LastName = "Adams" });
customers.Add(new Customer { FirstName = "Jake", LastName = "Johnson" });
customers.Add(new Customer { FirstName = "Angie", LastName = "Reckar" });
customers.Add(new Customer { FirstName = "Jean", LastName = "Anderson" });
return customers;
}
public static List<Customer> GetFilteredCustomers(List<Customer> customers, List<Func<Customer, bool>> whereClauses)
{
return customers
.Where(whereClauses[0])
.Where(whereClauses[1])
.ToList();
}
}
}
IEnumerable<Customer> dbCustomers = customers;
foreach (var whereClause in whereClauses)
{
dbCustomers = dbCustomers.Where(whereClause);
}
return dbCustomers.ToList();
maybe interesting extensionMethod:
public static class IEnumerableExtension
{
public static void AttachWhereClauses<T>(this IEnumerable<T> source, IEnumerable<Func<T, bool>> whereClauses)
{
foreach (var whereClause in whereClauses)
{
source = source.Where(whereClause);
}
}
}
var listedCustomers = customers.AttachWhereClauses(whereClauses).ToList();
but: not tested - i do not know for sure, if attaching the whereClauses to the same object works!
Something like this:
public IEnumerable<Customer> ApplyConditions(IEnumerable<Func<Customer, bool>> conditions)
{
IEnumerable<Customer> customers = ...;
foreach(var condition in conditions)
customers = customers.Where(condition);
return customers;
}