public void ModifyEntity(Employee employee)
{
EmployeeDTO employeeDTO = AllEmployees.Where <EmployeeDTO>(x => x.ID == employee.ID).FirstOrDefault();
if (employeeDTO == null)
{
employeeDTO = new EmployeeDTO()
{
ID = employee.ID,
FIO = employee.FIO,
Company = new CompanyDTO {
ID = employee.Company.ID, Name = employee.Company.Name
}
};
AllEmployees.Add(employeeDTO);
}
else
{
AllEmployees.Remove(employeeDTO);
employeeDTO = new EmployeeDTO()
{
ID = employee.ID,
FIO = employee.FIO,
Company = new CompanyDTO {
ID = employee.Company.ID, Name = employee.Company.Name
}
};
AllEmployees.Add(employeeDTO);
}
}
public void Search(string searched)
{
searched = searched.ToLower();
List <Employees> results = new List <Employees>();
results = AllEmployees.Where((x) => {
string initials = x.FirstName.ToLower().Substring(0, 2) + x.LastName.ToLower().Substring(0, 2);
return(initials.Contains(searched));
}).ToList();
List <Employees> results2 = AllEmployees.Where((x) => {
string fullName = x.FirstName.ToLower() + " " + x.LastName.ToLower();
string initials = x.FirstName.ToLower().Substring(0, 2) + x.LastName.ToLower().Substring(0, 2);
//string region = x.Region==null?"Unknown region"
return(!(initials.Contains(searched)) &&
(fullName.Contains(searched) ||
x.Country.ToLower() == searched ||
x.Region.ToLower() == searched));
}).ToList();
foreach (Employees e in results2)
{
results.Add(e);
}
EmployeeResults = new ObservableCollection <Employees>(results);
}
protected void Delete_ButtonClick(object sender, EventArgs e)
{
AllEmployees.DataSource = SqlDataSource2;
SqlDataSource2.Select(DataSourceSelectArguments.Empty);
AllEmployees.DataTextField = "last_name";
AllEmployees.DataValueField = "ssn";
AllEmployees.DataBind();
}
public void AddEmployee(Employee employee)
{
employee.ID = employeeService.AddEmployee(employee);
AllEmployees.Add(employee);
Filter();
Search();
mainWindow.DisplayEmployeesList();
}
public void UpdateEmployee(Employee employee)
{
employeeService.UpdateEmployee(employee);
AllEmployees[AllEmployees.IndexOf(AllEmployees.FirstOrDefault(m => m.ID == employee.ID))] = employee;
Filter();
Search();
mainWindow.DisplayEmployeesList();
}
public void DeleteEmployee(Employee employee)
{
employeeService.DeleteEmployee(employee);
AllEmployees.Remove(employee);
Filter();
Search();
mainWindow.DisplayEmployeesList();
}
private void AddEmployeeExecute(object parameter)
{
var newEmployee = new EmployeeViewModel(m_unitOfWorkFactory, AllDepartments.First());
AllEmployees.Add(newEmployee);
SelectedEmployee = newEmployee;
}
private void DeleteEmployee()
{
var selected = AllEmployees.Where(e => e.EmpIsSelected).ToList();
//// TODO: Если из бд не удалится по какой-то причине, надо об этом сообщить, чтобы из коллекции тоже не удалялось.
//// Либо после удаления из бд инициировать перезагрузку коллекции.
//DeleteEmployeeFromDatabase(selected);
//DeleteEmployeeFromCollection(selected);
}
protected void FormView1_ItemUpdated(object sender, FormViewUpdatedEventArgs e)
{
AllEmployees.DataSource = SqlDataSource2;
SqlDataSource2.Select(DataSourceSelectArguments.Empty);
AllEmployees.DataTextField = "last_name";
AllEmployees.DataValueField = "ssn";
AllEmployees.DataBind();
}
public async Task <IActionResult> ViewEmployees()
{
var workers = await repoWorker.getEmployees();
var storageWorkers = await repoStorageWorker.getStorageWorkers();
AllEmployees employees = new AllEmployees(workers, storageWorkers);
return(View(employees));
}
private void Search()
{
string searchText = null;
if (!string.IsNullOrEmpty(SearchText))
{
searchText = SearchText.ToLower().Trim();
Employees = new ObservableCollection <Models.Employee>(AllEmployees.Where(x => ($"{x.FirstName} {x.LastName}".ToLower().Contains(searchText)) || (x.Salary.ToString().ToLower().Contains(searchText))));
}
}
public OrderFormViewModel()
{
Order = StateService.CurrentOrder;
AllCustomers = ComboBoxService.GetOptions(ComboBoxTargets.Customers);
CurrentCustomer = AllCustomers.FirstOrDefault(x => x.ID == Order.CustomerID);
AllEmployees = ComboBoxService.GetOptions(ComboBoxTargets.Employees);
CurrentEmployee = AllEmployees.FirstOrDefault(x => x.ID == Order.EmployeeID);
AllProducts = ComboBoxService.GetOptions(ComboBoxTargets.Products);
CurrentProduct = AllProducts.FirstOrDefault(x => x.ID == Order.ProductID);
}
/// <summary>
/// Displays employee by searched Id
/// </summary>
/// <param name="id"></param>
public void DisplayEmployeeById(int id)
{
AllUsers.Clear();
foreach (Employee e in AllEmployees.ToList())
{
if (e.EmployeeId == id)
{
AllUsers.Add(e);
}
}
}
public void NewEmployee()
{
Employee e = new Employee();
e.EmployeeName = "naam";
e.Email = "email";
e.Address = "adres";
e.Phone = "telefoonnummer";
e.Edit = Visibility.Visible;
AllEmployees.Add(e);
}
/// <summary>
/// Обрабатывает одну строку из списка рассылки
/// </summary>
/// <param name="recipientString"></param>
/// <param name="errorMessage"></param>
/// <returns></returns>
string ProcessUsername(string username)
{
Employee foundEmployee = AllEmployees.FirstOrDefault(i => (string.Compare(i.Username, username) == 0));
if (foundEmployee != null)
{
return(foundEmployee.ToString);
}
return(username);
}
protected void FormView1_ItemDeleted(object sender, FormViewDeletedEventArgs e)
{
AllEmployees.DataSource = SqlDataSource2;
SqlDataSource2.Select(DataSourceSelectArguments.Empty);
AllEmployees.DataTextField = "last_name";
AllEmployees.DataValueField = "ssn";
AllEmployees.DataBind();
Add.Visible = false;
initial.Visible = true;
employeeview.Visible = false;
}
/// <summary>
/// We get the picked employee and sends it to be deleted from DB
/// </summary>
/// <param name="employee"></param>
public void DeleteEmployee(Employee employee)
{
ApiHelper.Instance.DeleteEmployee(employee.EmployeeId);
foreach (Employee e in AllEmployees.ToList())
{
if (e.EmployeeId == employee.EmployeeId)
{
AllEmployees.Remove(e);
AllUsers.Remove(e);
}
}
}
public static IList <T> Find <T>(Func <T, bool> filter) where T : class
{
if (typeof(T) == typeof(Department))
{
return(AllDepartments.Where(department => filter(department as T)).ToList() as IList <T>);
}
if (typeof(T) == typeof(Employee))
{
return(AllEmployees.Where(empl => filter(empl as T)).ToList() as IList <T>);
}
throw new NotSupportedException("Type not supported");
}
private void OnNextCommand(object obj)
{
TaskManager.RunInBackground(() =>
{
_currentEmployeeIndex++;
if (AllEmployees.Count() <= _currentEmployeeIndex)
{
_currentEmployeeIndex = 0;
}
BuildUI();
});
}
private void DeleteEmployeeExecute(object parameter)
{
// update model
using (IUnitOfWork unitOfWork = m_unitOfWorkFactory.Create())
{
Employee storedEmployee = unitOfWork.Employees.Get(SelectedEmployee.EmployeeId);
unitOfWork.Employees.Remove(storedEmployee);
unitOfWork.Complete();
}
// update viewmodel
AllEmployees.Remove(SelectedEmployee);
SelectedEmployee = null;
}
private void OnPreviousCommand(object obj)
{
TaskManager.RunInBackground(() =>
{
_currentEmployeeIndex--;
if (_currentEmployeeIndex < 0)
{
_currentEmployeeIndex = AllEmployees.Count();
}
BuildUI();
});
}
/// <summary>
/// Обновляет строку RecipientsString и коллекцию RecipientEmployees по коллекции Recipients
/// </summary>
/// <remarks>
/// Необхдимо вызввать при каждом изменении Recipients
/// </remarks>
public void UpdateByRecipients()
{
recipientsEmployees.Clear();
foreach (var item in recipients)
{
Employee employee = AllEmployees.FirstOrDefault(row => (string.Compare(row.Username, item.RecipientUsername) == 0));
if (employee != null)
{
recipientsEmployees.Add(employee);
}
}
string buf = Employee.CollectionToString(recipientsEmployees);
RecipientsString = JoinToString(UnrecognizedUsernames, buf);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
Add.Visible = false;
employeeview.Visible = false;
ProjectName.DataSource = SqlDataSource1;
ProjectName.DataTextField = "name";
ProjectName.DataValueField = "project_id";
ProjectName.DataBind();
AllEmployees.DataSource = SqlDataSource2;
AllEmployees.DataTextField = "last_name";
AllEmployees.DataValueField = "ssn";
AllEmployees.DataBind();
}
}
private void BuildUI()
{
if (AllEmployees.Count() > _currentEmployeeIndex)
{
var Empobj = AllEmployees.Skip(_currentEmployeeIndex).FirstOrDefault();
if (Empobj != null)
{
CurrentEmployee = Empobj;
List <EmployeeHours> _list = new List <EmployeeHours>();
for (var i = Convert.ToDateTime(PayStartDate); i <= Convert.ToDateTime(PayEndDate); i = i.AddDays(1))
{
_list.Add(new EmployeeHours
{
WorkDate = i,
Employee = new Employee {
EmployeeNumber = CurrentEmployee.EmployeeNumber, EmployeeFirstName = CurrentEmployee.EmployeeFirstName, EmployeeLastName = CurrentEmployee.EmployeeLastName, HireDate = CurrentEmployee.HireDate
},
HoursWorked = 0,
Description = String.Empty
});
}
var db = EmployeeData.GetEmployeeHoursByEmpnonDate(CurrentEmployee.EmployeeNumber, Convert.ToDateTime(PayStartDate), Convert.ToDateTime(PayEndDate));
EmployeeHours = (from l in _list
join d in db on l.WorkDate equals d.WorkDate into temp
from d in temp.DefaultIfEmpty()
select new EmployeeHours
{
WorkDate = l.WorkDate,
Employee = l.Employee,
Id = d == null?0:d.Id,
Description = d == null?String.Empty:d.Description,
HoursWorked = d == null?0 : d.HoursWorked
}).ToList();
}
}
}
public async Task <IActionResult> ViewEmployees(string Search)
{
if (Search != null)
{
var workers = await repoWorker.search(Search);
var storageWorkers = await repoStorageWorker.search(Search);
AllEmployees employees = new AllEmployees(workers, storageWorkers);
return(View(employees));
}
else
{
var workers = await repoWorker.getEmployees();
var storageWorkers = await repoStorageWorker.getStorageWorkers();
AllEmployees employees = new AllEmployees(workers, storageWorkers);
return(View(employees));
}
}
/// <summary>
/// Проверяет существование пользователя по его username
/// </summary>
/// <param name="usernames"></param>
/// <returns>
/// Возвращает строку содержащую ошибки проверки
/// </returns>
string CheckUsernameExistence(string[] usernames)
{
string errorMessage = string.Empty;
if (usernames != null)
{
foreach (var item in usernames)
{
string msg = string.Empty;
Employee foundEmployee = AllEmployees.FirstOrDefault(i => (string.Compare(i.Username, item) == 0));
if (foundEmployee == null)
{
msg = AddUsernameToUnrecognizedUsernames(item);
}
else
{
AddEmployeeToRecipientsEmployees(foundEmployee);
}
errorMessage = JoinToString(errorMessage, msg);
}
}
return(errorMessage);
}
static void Main(string[] args)
{
ArrayList list = new ArrayList {
"First", "Second", "Third"
};
IEnumerable <string> strings = list.Cast <string>();
foreach (var item in list)
{
Console.WriteLine(item);
}
list = new ArrayList {
1, 3, 2
};
IEnumerable <int> ints = list.Cast <int>();
foreach (var item in ints)
{
Console.WriteLine(item);
}
// short cannot be casted to int
//List<short> shortList = new List<short> { 1, 2, 3, 4 };
//ints = shortList.Cast<int>();
//foreach (var item in ints)
//{
// Console.WriteLine(item);
//}
// на нетипізованій колекції ми не можемо визвати Select
Console.WriteLine(new string('-', 80));
foreach (var item in list.Cast <int>().Select(i => i * i))
{
Console.WriteLine(item);
}
// приведення до типу перед використанням колекції
Console.WriteLine(new string('-', 80));
List <IInterface> myList = new List <IInterface> {
new MyClass {
A = 1, N = "Bla"
},
new MyClass {
A = 4, N = "Gla"
},
new MyClass {
A = 12, N = "Ila"
},
new MyClass {
A = 32, N = "Bla"
},
new MyClass {
A = 32, N = "Ala"
}
};
List <IInterface> myList1 = new List <IInterface> {
new MyClass {
A = 1, N = "Bla1"
},
new MyClass {
A = 4, N = "Gla1"
},
new MyClass {
A = 22, N = "Ila1"
},
new MyClass {
A = 31, N = "Bla1"
},
new MyClass {
A = 32, N = "Ala1"
}
};
var myListElements = myList.Cast <MyClass>().Select(m => m.A);
foreach (var item in myListElements)
{
Console.WriteLine(item);
}
// застосування декілької where
Console.WriteLine(new string('-', 80));
var myFilteredList = myList.Cast <MyClass>()
.Where(m => m.A > 0)
.Where(m => m.A > 1)
.Where(m => m.A < 20)
.Select(m => m.A * m.A);
foreach (var item in myFilteredList)
{
Console.WriteLine(item);
}
// сортування даних
Console.WriteLine(new string('-', 80));
var mySortedList = myList.Cast <MyClass>()
.Where(m => m.A > 0)
.OrderByDescending(m => m.A)
.ThenBy(m => m.N)
.Select(m => new { A = m.A, N = m.N });
foreach (var item in mySortedList)
{
Console.WriteLine(item.A + " : " + item.N);
}
// змінна let
Console.WriteLine(new string('-', 80));
var myLet = from m in myList.Cast <MyClass>()
let Number = m.A
let Name = m.N
orderby Number
select new { Num = Number, SomeName = Name };
foreach (var item in myLet)
{
Console.WriteLine(item);
}
// let в термінах розширюючих методів
Console.WriteLine(new string('-', 80));
var myLetInMethod = myList.Cast <MyClass>()
.Select(u => new { u, u.A })
.OrderBy(z => z.A)
.Select(z => new { Name = z.u.N, Number = z.A });
foreach (var item in myLetInMethod)
{
Console.WriteLine(item);
}
// inner JOIN через LINQ
Console.WriteLine(new string('-', 80));
var myInnerJoinedList = from m in myList.Cast <MyClass>()
join m1 in myList1.Cast <MyClass>()
on m.A equals m1.A
select new { m_A = m.A, m1_A = m1.A, m_Name = m.N, m1_Name = m1.N };
foreach (var item in myInnerJoinedList)
{
Console.WriteLine("M.A = {0}, M1.A = {1}, M.Name = {2}, M1.Name = {3}", item.m_A, item.m1_A, item.m_Name, item.m1_Name);
}
// inner join фільтрована колекція (простіше якшо лівою є колекція яку треба сортувати + вигідніше сортувати до join)
Console.WriteLine(new string('-', 80));
var myInnerFilteredList = from m in myList.Cast <MyClass>()
where m.A > 10
join m1 in myList1.Cast <MyClass>()
on m.A equals m1.A
select new { mA = m.A, m1A = m1.A, mN = m.N, m1N = m1.N };
var myInnerFilteredList1 = from m1 in myList1.Cast <MyClass>()
join m in (from m in myList.Cast <MyClass>()
where m.A > 10
select m)
on m1.A equals m.A
select new { m_A = m.A, m1_A = m1.A, m_Name = m.N, m1_Name = m1.N };
foreach (var item in myInnerFilteredList1)
{
Console.WriteLine(item);
}
// зєднання для робітників і менеджерів
List <Human> employees = new List <Human>
{
new Employee {
ID = 1, Age = 23, Name = "Oles", ManagerID = 1
},
new Employee {
ID = 2, Age = 18, Name = "Alex", ManagerID = 2
},
new Employee {
ID = 3, Age = 34, Name = "Ivan", ManagerID = 1
},
new Employee {
ID = 4, Age = 22, Name = "Vasil", ManagerID = 2
},
new Employee {
ID = 5, Age = 23, Name = "Nazar", ManagerID = 1
},
new Employee {
ID = 6, Age = 54, Name = "Valentin", ManagerID = 2
},
new Employee {
ID = 7, Age = 33, Name = "Boris", ManagerID = 1
}
};
List <Human> managers = new List <Human>
{
new Manager {
ID = 1, Age = 25, Name = "Bogdan", Employees = new List <int> {
1, 3, 5, 7
}
},
new Manager {
ID = 2, Age = 32, Name = "Roman", Employees = new List <int> {
2, 4
}
},
new Manager {
ID = 3, Age = 40, Name = "Valera"
}
};
// inner join менеджерів і робітників
Console.WriteLine("1" + new string('-', 79));
var empMangInnerJoin = from e in employees.Cast <Employee>()
join m in managers.Cast <Manager>()
on e.ManagerID equals m.ID
orderby e.ID
select new { ManagerId = m.ID, ManagerName = m.Name, EmpId = e.ID, EmpName = e.Name };
foreach (var item in empMangInnerJoin)
{
Console.WriteLine("Employee ID = {0}, manager id = {1}, employee name = {2}, manager name = {3}",
item.EmpId, item.ManagerId, item.EmpName, item.ManagerName);
}
// inner join через розшивюючі методи
Console.WriteLine("2" + new string('-', 79));
var empMangInnerJoinExtMethods = employees.Cast <Employee>()
.Join(managers.Cast <Manager>(),
e => e.ManagerID,
m => m.ID,
(e, m) => new { ManagerId = m.ID, ManagerName = m.Name, EmpId = e.ID, EmpName = e.Name })
.OrderBy(z => z.EmpId);
foreach (var item in empMangInnerJoinExtMethods)
{
Console.WriteLine("Employee ID = {0}, manager id = {1}, employee name = {2}, manager name = {3}",
item.EmpId, item.ManagerId, item.EmpName, item.ManagerName);
}
// групове зєднання менеджера з робітниками (групове з'єднання виводить навіть ті елементи лівої таблиці які не мають
// відповідних у правій таблиці - це як left outer join)
Console.WriteLine("3" + new string('-', 79));
var empMangInnerIntoJoin = from m in managers.Cast <Manager>()
join e in employees.Cast <Employee>()
on m.ID equals e.ManagerID into allEmployees
where allEmployees.Count() > 1
select new { ManagerId = m.ID, ManagerName = m.Name, AllEmployees = allEmployees };
foreach (var manager in empMangInnerIntoJoin)
{
Console.WriteLine("Manager id = {0}, name = {1}", manager.ManagerId, manager.ManagerName);
foreach (var emp in manager.AllEmployees)
{
Console.WriteLine(" Employee id = {0}, name = {1}", emp.ID, emp.Name);
}
}
// теж саме тільки з group join
Console.WriteLine("4" + new string('-', 79));
var empManagerOuterJoin = managers.Cast <Manager>()
.GroupJoin(employees.Cast <Employee>(),
m => m.ID,
e => e.ManagerID,
(m, emps) => new { ManagerId = m.ID, ManagerName = m.Name, AllEmployees = emps });
//.Where(z => z.AllEmployees.Count() > 1);
foreach (var manager in empManagerOuterJoin)
{
Console.WriteLine("Manager id = {0}, name = {1}", manager.ManagerId, manager.ManagerName);
foreach (var emp in manager.AllEmployees)
{
Console.WriteLine(" Employee id = {0}, name = {1}", emp.ID, emp.Name);
}
}
// генерування кількості працівників для кожного менеджера
Console.WriteLine("5" + new string('-', 79));
var mngEmpsCount = from m in managers.Cast <Manager>()
join e in employees.Cast <Employee>()
on m.ID equals e.ManagerID into AllEmployees
select new { ManagerID = m.ID, ManagerName = m.Name, EmpsCount = AllEmployees.Count() };
foreach (var item in mngEmpsCount)
{
Console.WriteLine("Manager ID = {0}, manager name = {1}, employees number = {2}",
item.ManagerID, item.ManagerName, item.EmpsCount);
}
// тож саме тільки з розширюючими методами
Console.WriteLine("6" + new string('-', 79));
var msgEmpsCountExpMethods = managers.Cast <Manager>()
.GroupJoin(employees.Cast <Employee>(),
m => m.ID,
e => e.ManagerID,
(m, emps) => new { ManagerID = m.ID, ManagerName = m.Name, EmpsCount = emps.Count() });
foreach (var item in msgEmpsCountExpMethods)
{
Console.WriteLine("Manager ID = {0}, manager name = {1}, employees number = {2}",
item.ManagerID, item.ManagerName, item.EmpsCount);
}
// cross join
Console.WriteLine("7" + new string('-', 79));
var someSequence = from m in managers.Cast <Manager>()
from ml in myList.Cast <MyClass>()
select new { ManagerId = m.ID, SomeValue = ml.A };
foreach (var item in someSequence)
{
Console.WriteLine("Manager id = {0}, some value = {1}", item.ManagerId, item.SomeValue);
}
// cross join коли права послідовність залежить від лівої послідовності
Console.WriteLine("8" + new string('-', 79));
var fooSequence = from n in Enumerable.Range(1, 4)
from m in Enumerable.Range(11, n)
select new { Left = n, Right = m };
foreach (var item in fooSequence)
{
Console.WriteLine("Left = {0}, right = {1}", item.Left, item.Right);
}
// cross join коли права послідовність залежить від лівої послідовності
// через розширюючі методи
// *** також треба зазначити що SelectMany має потокове виконання, порівнюючи з внутрішніми і груповими
// зєднаннями - де права таблиця завантажується одразу, тут права таблиця буде заново генеруватись для
// кожного елемента з лівої таблиці ***
Console.WriteLine("9" + new string('-', 79));
var fooSequenceExtMethods = Enumerable.Range(1, 4)
.SelectMany(n => Enumerable.Range(11, n),
(n, m) => new { Left = n, Right = m });
foreach (var item in fooSequenceExtMethods)
{
Console.WriteLine("Left = {0}, right = {1}", item.Left, item.Right);
}
// cross join для працівників і менеджерів
Console.WriteLine("9.1" + new string('-', 77));
var empMngsSelMany = managers.Cast <Manager>()
//.Where(m => m.ID == 1)
.SelectMany(m => employees.Cast <Employee>()
.Where(e => e.ManagerID == m.ID)
.Select(e => new { EmpId = e.ID, EmpName = e.Name }),
(m, e) => new { ManagerId = m.ID, EmpId = e.EmpId, EmpName = e.EmpName })
.GroupBy(z => z.ManagerId,
z => new { EmpId = z.EmpId, EmpName = z.EmpName })
.OrderByDescending(z => z.Key);
foreach (var item in empMngsSelMany)
{
//Console.WriteLine("Manager id = {0} : Employee id = {1}, employee name = {2}",item.ManagerId, item.EmpId, item.EmpName);
Console.WriteLine("Manager id = {0}", item.Key);
foreach (var e in item)
{
Console.WriteLine(" Employee id = {0}, employee name = {1}", e.EmpId, e.EmpName);
}
}
// групування елементів
// *** групування не виконується потоково воно буферизує елементи які відсортовані по ключу ***
Console.WriteLine("10" + new string('-', 78));
var groupedEmployees = from e in employees.Cast <Employee>()
where e.ManagerID >= 1
group e by e.ManagerID;
foreach (var item in groupedEmployees)
{
Console.WriteLine("Manager id : {0}", item.Key);
foreach (var emp in item)
{
Console.WriteLine(" Employee id = {0}, employee name = {1}", emp.ID, emp.Name);
}
}
// групування елементів на основі розширюючих методів
Console.WriteLine("11" + new string('-', 78));
var groupedEmployeesExtMethods = employees.Cast <Employee>()
.Where(e => e.ManagerID >= 1)
.GroupBy(e => e.ManagerID);
foreach (var item in groupedEmployeesExtMethods)
{
Console.WriteLine("Manager id : {0}", item.Key);
foreach (var emp in item)
{
Console.WriteLine(" Employee id = {0}, employee name = {1}", emp.ID, emp.Name);
}
}
// групування елементів вибираючи не сам елемент а його пропертю
Console.WriteLine("12" + new string('-', 78));
var groupedEmpsPropetry = from e in employees.Cast <Employee>()
where e.ManagerID >= 1
group e.ID by e.ManagerID;
foreach (var item in groupedEmpsPropetry)
{
Console.WriteLine("Manager id = {0}", item.Key);
foreach (var e in item)
{
Console.WriteLine(" " + e);
}
}
// теж саме через розширюючий метод
Console.WriteLine("13" + new string('-', 78));
var groupedEpmsPropExtMethods = employees.Cast <Employee>()
.GroupBy(e => e.ManagerID,
e => e.ID);
foreach (var item in groupedEpmsPropExtMethods)
{
Console.WriteLine("Manager id = {0}", item.Key);
foreach (var e in item)
{
Console.WriteLine(" " + e);
}
}
// продовження запиту
Console.WriteLine("14" + new string('-', 78));
var queryContinuation = from e in employees.Cast <Employee>()
where e.ManagerID >= 0
group e by e.ManagerID
into groupedSeq
select new { ManagerId = groupedSeq.Key, Count = groupedSeq.Count() };
foreach (var item in queryContinuation)
{
Console.WriteLine("Manager id = {0}, emps count = {1}", item.ManagerId, item.Count);
}
// продовження запиту через розширюючі методи
Console.WriteLine("15" + new string('-', 78));
var queryContinuationExtMethods = employees.Cast <Employee>()
.Where(e => e.ManagerID >= 1)
.GroupBy(e => e.ManagerID)
.Select(z => new { ManagerId = z.Key, Count = z.Count() });
foreach (var item in queryContinuationExtMethods)
{
Console.WriteLine("Manager id = {0}, emps count = {1}", item.ManagerId, item.Count);
}
Console.ReadLine();
}
void RemoveExecute(object param)
{
AllEmployees.Remove(SelectEmployee);
}
void AddExecute(object param)
{
AllEmployees.Add(Employee.CreateEmployee(NewEmployee.Name, NewEmployee.Age));
}
private void Filter()
{
Employees = (SelectedDepartment.Equals(TeamName.All) ? AllEmployees : new ObservableCollection <Models.Employee>(AllEmployees.Where(x => x.Team.Equals(SelectedDepartment))));
this.EmployeeGridTitle = SelectedDepartment == TeamName.All ? "All Employees" : $"{SelectedDepartment.ToString()} Team Employees";
}
