HR Skills-Anwendungscode (EDM-Beispielanwendung)
Mit dem von der Anwendung "HRSkills" verwendeten Code werden mehrere Features des Entitätsdatenmodell (EDM) veranschaulicht. Die in vorherigen "HRSkills"-Themen beschriebenen Schemas bilden die Grundlage der vom Code dieses Abschnitts verwendeten Entitäten und Zuordnungen. Weitere Informationen über die in diesem Beispiel verwendeten Entitäten und Zuordnungen finden Sie unter Human Resources Skills-WinApp (EDM-Beispielanwendung). Informationen zu den Speichermetadaten finden Sie unter HR Skills-Speichermetadaten (EDM-Beispielanwendung). Weitere Informationen über die Mappingspezifikation finden Sie unter HR Skills-Mappingspezifikation (EDM-Beispielanwendung).
Typen, die in Schemas entworfen und Speicher zugeordnet wurden, sind als programmierbare Objektmodelle erstellt. Die Daten dieses Modells sind mit der Common Language Runtime (CLR)-Syntax programmierbar, ohne SQL-Abfragen als Zeichenfolgen in den Code einbetten zu müssen.
In der Anwendung werden Datenbindung an Entitäten, parametrisierte Abfragen und die Verwendung von Navigationseigenschaften von Zuordnungen veranschaulicht. Die Zuordnungen verbinden die Entitäten Employees mit References, Employees mit Skills und Skills mit SkillInfo, die Informationen über Fähigkeiten enthalten.
Konfigurationsdatei und Verbindungszeichenfolge
Für das Objektmodell ist eine Verbindung zu der Datenbank erforderlich, in der die Anwendungsdaten gespeichert werden. Zudem ist eine Entitätsverbindung zu den Laufzeitobjekten erforderlich, die von der aus den Schemas erstellten DLL bereitgestellt werden. Informationen zum Erstellen des Objektmodells aus Schemas finden Sie unter "Gewusst wie: Gewusst wie: Verwenden von 'EdmGen.exe' zum Generieren eines Entity Data Model (Entity Framework)".
Die Datei exe.config enthält eine Verbindungszeichenfolge, die verwendet wird, um eine Verbindung zu einer SQL Server-Datenbank sowie eine Entitätsverbindung herzustellen. Wenn eine Entitätsverbindung besteht, kann auf die Entitäten und Zuordnungen im Objektmodell vom Code aus zugegriffen werden.
Der Entwickler muss der Datei exe.config die Verbindungszeichenfolge hinzufügen. Diese Anwendung gibt die Klasse HRSkills an. Die Zuweisung providerName="System.Data.EntityClient" gibt eine Entitätsverbindung an, die das im HR Skills-Mappingspezifikation (EDM-Beispielanwendung) definierte Mapping-Schema verwendet.
Die Verbindungszeichenfolge identifiziert auch den Server, der von der SQL-Verbindung verwendet wird: provider connection string="server=servername;. provider connection string="server=servername;.
Im folgenden Beispiel wird der Inhalt der Datei exe.config angezeigt.
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<connectionStrings>
<add name="HRSkills"
connectionString='metadata=.;
provider=System.Data.SqlClient;
provider connection string="server=serverName;
database=HRSkills;
integrated security=true;
multipleactiveresultsets=true"'
providerName="System.Data.EntityClient"/>
</connectionStrings>
</configuration>
Anwendungscode
Der folgende Code enthält die konventionellen Ereignishandler, die von einer Windows Form initialisiert und ausgeführt werden. Diese dient in der Beispielanwendung als Benutzeroberfläche. using-Präprozessordirektiven schließen die für die Ausführung von Abfragen zum Finden von Mitarbeitern, Referenzen, Fähigkeiten und Fähigkeitsinformationen benötigten Namespaces ein. Die letzte using-Direktive schließt den Namespace HRSkillsModel ein, der die Laufzeitklassen für die Entitäten und Beziehungen im für diese Anwendung definierten und erstellten Objektmodell enthält. Dies ist in den vorherigen Themen dieses Abschnitts beschrieben.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.Mapping;
using System.Data.Objects;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.Metadata;
using System.Linq;
using HRSkillsModel;
namespace HR_Skills_WinApp
{
public partial class Form1 : Form
{
HRSkills DB = new HRSkills();
public Form1()
{
InitializeComponent();
Für den ObjectContext wird eine Variable deklariert und initialisiert: HRSkills DB = new HRSkills. Die Verbindung ist im ObjectContext enthalten und wird innerhalb der try-Klammern initialisiert, wie im folgenden Codesegment dargestellt. Beim Testen der Anwendung können die Verbindungsfehlermeldungen überprüft werden.
Die ursprüngliche Abfrage, mit der alle im Speicher befindlichen Employees angezeigt werden, verwendet die Employees-Entität. Bei der Employees-Klasse handelt es sich um eine ObjectQuery<T> im ObjectContext, die alle Mitarbeiterentitäten zurückgibt.
Ein DataGridView-Steuerelement wird verwendet, um die Ergebnisse der Employees-Abfrage anzuzeigen. Die Spalten werden dem DataGridView hinzugefügt. Die BindingSource wird mit einer Query<T> von Employee-Elementen initialisiert, und die DataSource-Eigenschaft des Steuerelements bindet die Daten. Mit dem Parameter true wird die Datenbank aktualisiert, wenn Änderungen im DataGrid-Steuerelement vorgenommen werden.
public Form1()
{
InitializeComponent();
try
{
bindingSource1.DataSource = DB.Employees;
dataGridView1.DataSource = bindingSource1;
dataGridView1.Columns[0].Visible = false;
}
catch(Exception e)
{
System.Windows.Forms.MessageBox.Show(e.ToString());
}
}
Wenn die Employees im DataGridView-Steuerelement angezeigt werden, können Benutzer der Anwendung auf eine Zeile klicken, um die Skills abzurufen, die der in dieser Zeile angezeigten Employee-Entität zugeordnet sind. Eine neue Abfrage sucht die EmployeeId der Employee-Entität, deren Daten in der DataGridView angezeigt werden. Die EmployeeId ist in der DataGridView-Anzeige ausgeblendet, wird jedoch zu Referenzzwecken beibehalten. Sie wird von einer parametrisierten ObjectQuery<T> für Employees verwendet. Der Parameter wird in der folgenden Zeile erstellt und initialisiert: ObjectParameter param = new ObjectParameter("p", empId). Der ObjectParameter wird in der folgenden Abfrage verwendet: DB.Employees.Where("it.EmployeeId = @p", param).First(). DB.Employees.Where("it.EmployeeId = @p", param).First().
Nachdem die Mitarbeiterklasse von der Abfrage identifiziert und zurückgegeben wurde, werden mithilfe der Skill_Employee-Zuordnung alle diesem Mitarbeiter zugeordneten Skills gesucht. Eine Codezeile verwendet die Navigationseigenschaft des Mitarbeiters, um alle Skills aus der Datenbank zu laden, die dem Mitarbeiter zugeordnet sind: Skill_Employee.GetSkillsEntities(employee).Load(). Skill_Employee.GetSkillsEntities(employee).Load(). In einer foreach-Schleife über dieselbe Navigationseigenschaft werden daraufhin die dem Mitarbeiter zugeordneten Skills in ein zweites DataGridView-Steuerelement gelesen.
private void dataGridView1_CellClick(object sender,
DataGridViewCellEventArgs e)
{
dataGridViewSkills.Columns.Clear();
// Get the Id of the Employee and
Guid empId = new Guid(dataGridView1.CurrentRow.Cells[0].Value.ToString());
// Find the Employee.
ObjectParameter param = new ObjectParameter("p", empId);
try
{
if (null != DB.Employees.Where(
"it.EmployeeId = @p", param).First())
{
Employees employee = DB.Employees.Where(
"it.EmployeeId = @p", param).First();
employee.Skills.Load();
List<Skills> skillsList = new List<Skills>();
foreach (Skills skill in employee.Skills)
{
skillsList.Add(skill);
}
bindingSource2.DataSource = skillsList;
dataGridViewSkills.DataSource = bindingSource2;
dataGridViewSkills.Columns[0].Visible = false;
dataGridViewSkills.Columns[2].Width = 300;
richTextBox1.Clear();
// Provide EmployeeId for new skill or
// reference association.
textBoxSkillEmployeeId.Text =
employee.EmployeeId.ToString();
textBoxSkillEmployeeAlias.Text = employee.Alias;
textBoxRefEmployeeId.Text =
employee.EmployeeId.ToString();
textBoxRefEmployeeAlias.Text = employee.Alias;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.InnerException.ToString());
}
}
Die nächste Methode zeigt die in SkillInfo-Entitäten enthaltenen Informationen über die Skills in einem RichTextBox-Steuerelement auf der Benutzeroberfläche an. Skills-Entitäten zugeordnete SkillInfo-Entitäten werden mit dem Verfahren der vorherigen Methode abgefragt und angezeigt. Einer Abfrage wird eine SkillId als Parameter übergeben, und die Abfrage sucht eine bestimmte Skills-Entität. Die Navigationseigenschaft der Skills-Entität wird navigiert, um alle dieser Fähigkeit zugeordneten SkillInfo-Entitäten zu finden.
Die Eigenschaften von SkillInfo-Entitäten enthalten URLs, die auf weitere Informationen über die zugeordneten Skills verweisen. Die URL in jeder SkillInfo-Entität wird im Rich-Text-Feld angezeigt.
Auf die der Skills-Entität zugeordnete Mitarbeiterentität, die in dieser Methode verwendet wird, kann auch über die Skills-Entität durch die Skill_Employee-Zuordnung zugegriffen werden. Ein Verweis auf den Mitarbeiter wird mithilfe einer Codezeile aus der Datenbank geladen: Skill_Employee.GetEmployeesRef(skill).Load(). In einer zweiten Zeile wird der Mitarbeiter einer Variable zugewiesen: Employees employee = Skill_Employee.GetEmployees(skill). Der Alias des Mitarbeiters wird in die Rich-Text-Feldanzeige geschrieben.
Dem Mitarbeiter zugeordnete Verweise werden aus der Reference_Employee-Zuordnung abgerufen. Name, Position und E-Mail-Adresse aller Verweise sind in Eigenschaften von References-Entitäten enthalten. Diese Informationen werden im Rich Text Box angezeigt, um die Links zu Informationen über Mitarbeiterfähigkeiten zu ergänzen.
private void dataGridViewSkills_CellClick(object sender,
DataGridViewCellEventArgs e)
{
richTextBox1.Clear();
// Write the name of the skill and brief
// description to richtext box.
richTextBox1.Text = richTextBox1.Text + "Skill Name: "
+ dataGridViewSkills.CurrentRow.Cells[1].
Value.ToString() + "\n" +
dataGridViewSkills.CurrentRow.Cells[2].
Value.ToString();
// Create ObjectParameter from the SkillId property
// and get the Skill.
Guid skillId =
new Guid(dataGridViewSkills.CurrentRow.Cells[0].Value.ToString());
ObjectParameter param =
new ObjectParameter("p", skillId);
Skills skill = DB.Skills.Where("it.SkillId = @p",
param).First();
// Load the SkillInfo entities using
// SkillInfo_Skill association.
skill.SkillInfo.Load();
foreach (SkillInfo skillInfo in skill.SkillInfo)
{
richTextBox1.Text = richTextBox1.Text +
"\n\nSkill Information: " + skillInfo.URL +
"\n";
}
dataGridView1.ClearSelection();
// Load the Employee associated with the
// Skill using Skill_Employee association.
skill.EmployeeReference.Load();
Employees employee = skill.Employee;
if (null == employee) return;
// Write the alias property of the Employee to rich text
// box and heading for references.
richTextBox1.Text = richTextBox1.Text +
"\n\nEmployee: " + employee.Alias +
"\n\n" + "References:";
// Load References of Employee using
// Reference_Employee association.
employee.References.Load();
foreach (References reference in employee.References )
{
// Write reference LastName and Position to
// richtext box.
richTextBox1.Text = richTextBox1.Text + "\n" +
reference.FirstName + " " + reference.LastName +
" Position: " + reference.Position +
" Email: " + reference.Email;
}
// Provide SkillId for new SkillInfo if needed.
textBoxSkillInfoSkillId.Text = skill.SkillId.ToString();
for (int i = 0; i < dataGridView1.RowCount; i++)
{
// Check to see if this is the employee associated
// with the skill.
if (dataGridView1.Rows[i].Cells[0].Value.ToString()
== employee.EmployeeId.ToString())
{
dataGridView1.Rows[i].Selected = true;
dataGridView1.CurrentCell = dataGridView1[1, i];
// Break out when the row is found.
break;
}
}
}
Mit dieser Anwendung können Employees abgefragt werden, um Mitarbeiterfähigkeiten zu ermitteln, und es können Skills abgefragt werden, um zu ermitteln, welche Mitarbeiter die Fähigkeiten haben, auf die im System verwiesen wird. Die folgende Methode erhält Benutzereingaben aus einem TextBox-Steuerelement und sucht nach Mitarbeitern mit den in der Benutzereingabe beschriebenen Fähigkeiten.
Diese Abfrage von Skills wird gestartet, wenn der Benutzer mit Leerzeichen getrennte Schlüsselwörter in das TextBox-Steuerelement eingibt. Wenn auf die Schaltfläche SkillSearch geklickt wird, wird die Liste von Schlüsselwörtern aus dem Text im TextBox-Steuerelement für die Suche erstellt.
Die einzelnen Schlüsselwörter in der Liste werden mit einer foreach-Schleife abgerufen. Aus jedem Schlüsselwort wird ein ObjectParameter erstellt: ObjectParameter param = new ObjectParameter("p", "%" + keyword + "%"). Jeder neue Schlüsselwortwert für den Parameter wird in einer neuen Abfrage verwendet, die die SkillName-Eigenschaft und die BriefDescription-Eigenschaft aller Skills-Entitäten im System sucht: skillsQuery = DB.Skills.Where("it.BriefDescription Like @p OR it.SkillName Like @p", param). skillsQuery = DB.Skills.Where("it.BriefDescription Like @p OR it.SkillName Like @p", param).
Das Ergebnis der Abfrage sind Skills-Entitäten, die ein oder mehrere Schlüsselwörter enthaltende Fähigkeitsnamen oder -beschreibungen haben. Diese Ergebnisse werden in die DataGridView für die Skills eingelesen. Auf die Zeilen der Anzeige in der DataGridView kann dann geklickt werden, um Informationen über Fähigkeits- und Mitarbeiterreferenzen zu erhalten. Wenn auf eine Zeile in der DataGridView für Skills geklickt wird, zeigt der vorher beschriebene Handler SkillInfo-URLs, Alias des Mitarbeiters und References im Rich Text Box-Steuerelement auf der Benutzeroberfläche an.
private void buttonSkillSearch_Click(object sender, EventArgs e)
{
dataGridViewSkills.DataSource = null;
dataGridViewSkills.Columns.Clear();
try
{
dataGridViewSkills.Columns.Add("idSkill",
"Skill Id");
dataGridViewSkills.Columns.Add("nameSkill",
"Skill");
dataGridViewSkills.Columns.Add("descSkill",
"Description");
dataGridViewSkills.Columns[2].Width = 300;
// Make a list of keywords to search for in
// Skill entity name and description.
List<string> keywords = new List<string>();
int i = 0;
int j = 0;
while (i < textBoxKeywords.Text.Length)
{
j = textBoxKeywords.Text.IndexOf(" ", i);
if (-1 == j) j = textBoxKeywords.Text.Length;
keywords.Add(
textBoxKeywords.Text.Substring(i, j - i));
i = ++j;
}
foreach (string keyword in keywords)
{
// Create ObjectParameter from each keyword
// and search properties of Skills.
ObjectParameter param = new ObjectParameter(
"p", "%" + keyword + "%");
ObjectQuery<Skills> skillsQuery =
DB.Skills.Where(
"it.BriefDescription Like @p " +
"OR it.SkillName Like @p", param);
foreach (Skills skill in skillsQuery)
{
// Create an array of Skill property
// strings for display.
string[] columnValues =
new string[3] {skill.SkillId.ToString(),
skill.SkillName,
skill.BriefDescription};
foreach (DataGridViewRow row in
dataGridViewSkills.Rows)
{
// break if duplicate of
// Skill already found.
if (row.Cells[0].Value != null)
{
if (row.Cells[0].Value.ToString()
== columnValues[0])
{
break;
}
}
}
dataGridViewSkills.Rows.Add(columnValues);
}
}
// Hide EmployeeId in datagrid,
// but keep for reference.
dataGridViewSkills.Columns[0].Visible = false;
richTextBox1.Clear();
}
catch(Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.ToString(),
"Error Message");
}
}
Der folgende Handler ermöglicht Benutzern, im TextBox zum Starten der Schlüsselwortsuche die <EINGABETASTE> zu drücken, statt auf die Schaltfläche Search zu klicken.
private void textBoxKeywords_PreviewKeyDown(object sender,
PreviewKeyDownEventArgs e)
{
// Provide Enter activation in Search text box.
if(e.KeyCode.Equals(Keys.Return))
buttonSkillSearch_Click(this, System.EventArgs.Empty );
}
Der folgende Handler wird aufgerufen, wenn der Benutzer Informationen übermittelt, die zur Erstellung einer neuen Employees-Entität verwendet werden. Die Methode überprüft zunächst die Eingabeinformationen. In diesem Fall wird lediglich sichergestellt, dass sowohl textBoxLastName als auch textBoxAlias Text enthalten. Nachdem die neue Employees-Entität erstellt wurde, wird von der Methode überprüft, ob es sich dabei um ein Duplikat einer bereits gespeicherten Employee-Entität handelt, bevor dem System eine neue Entität hinzugefügt wird.
Die Erstellung einer neuen Employees-Entität erfordert eine neue Guid für die EmployeeId-Eigenschaft. Die Eigenschaften LastName, FirstName, Alias und Email der neuen Entität werden aus den Textfeldern zugeordnet, in die der Benutzer Text eingegeben hat.
Zwei Methodenaufrufe sind erforderlich, um dem System eine Entität hinzuzufügen. Mit dem ersten wird dem Objektkontext das neue Objekt hinzugefügt: DB.AddToEmployees(newEmployee). Die neue Entität wird erst mit dem zweiten Methodenaufruf in der Datenbank gespeichert: DB.SaveChanges().
private void buttonSubmitEmployee_Click(object sender,
EventArgs e)
{
try
{
if ("".Equals(textBoxLastName.Text) ||
"".Equals(textBoxEmployeeAlias.Text))
{
MessageBox.Show("Incomplete Information");
return;
}
// Create new Employee and add to storage.
Employees newEmployee = new Employees();
newEmployee.EmployeeId = Guid.NewGuid();
newEmployee.LastName = textBoxLastName.Text;
newEmployee.Alias = textBoxEmployeeAlias.Text;
newEmployee.FirstName = textBoxFirstName.Text;
newEmployee.Email = textBoxEmployeeEmail.Text;
DB.AddToEmployees(newEmployee);
// Check for duplicate.
ObjectQuery<Employees> dbEmplQuery =
DB.Employees.Where("it.Alias = @p",
new ObjectParameter("p", newEmployee.Alias));
if (!dbEmplQuery.Any())
DB.SaveChanges();
//Refresh the Employees datagrid.
EmployeesLabel_DoubleClick(this, null);
textBoxFirstName.Clear();
textBoxLastName.Clear();
textBoxEmployeeAlias.Clear();
textBoxEmployeeEmail.Clear();
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.ToString(),
"Error Message");
}
}
Der folgende Handler wird aufgerufen, wenn der Benutzer Informationen übermittelt, die zur Erstellung einer neuen Skills-Entität verwendet werden.
private void buttonSubmitSkill_Click(object sender, EventArgs e)
{
try
{
if ("".Equals(textBoxSkillShortName.Text) ||
"".Equals(textBoxSkillBriefDescription.Text) ||
"".Equals(textBoxSkillEmployeeId.Text))
{
MessageBox.Show("Incomplete Information");
return;
}
// Create new Skills entity.
Skills newSkills = new Skills();
newSkills.SkillId = Guid.NewGuid();
newSkills.SkillName = textBoxSkillShortName.Text;
newSkills.BriefDescription =
textBoxSkillBriefDescription.Text;
DB.AddToSkills(newSkills);
// Make a Guid of EmployeeId of Employee who
// has this Skill and use it in query.
Guid empId =
new Guid(textBoxSkillEmployeeId.Text);
ObjectParameter param =
new ObjectParameter("p", empId);
Employees employee = DB.Employees.Where(
"it.EmployeeId = @p", param).First();
// Add the Skill to the Skill_Employee association.
employee.Skills.Add(newSkills);
DB.SaveChanges();
textBoxSkillShortName.Clear();
textBoxSkillBriefDescription.Clear();
textBoxSkillEmployeeId.Clear();
textBoxSkillEmployeeAlias.Clear();
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.ToString(),
"Error Message");
}
}
Der folgende Handler wird aufgerufen, wenn der Benutzer Informationen übermittelt, die zur Erstellung einer neuen SkillInfo-Entität verwendet werden.
private void buttonSubmitSkillInfo_Click(object sender,
EventArgs e)
{
try
{
if ("".Equals(textBoxSkillInfoSkillId.Text) ||
"".Equals(textBoxUrlUncSkillInfo.Text))
{
MessageBox.Show("Incomplete Information");
return;
}
// Create new SkillInfo entity.
SkillInfo newSkillInfo = new SkillInfo();
newSkillInfo.SkillInfoId = Guid.NewGuid();
newSkillInfo.URL = textBoxUrlUncSkillInfo.Text;
// Create query and find Skill to
// associate with SkillInfo.
Guid empId =
new Guid(textBoxSkillInfoSkillId.Text);
ObjectParameter param =
new ObjectParameter("p", empId);
Skills skill =
DB.Skills.Where("it.SkillId = @p",
param).First();
// Add SkillInfo to SkillInfo_Skill association.
skill.SkillInfo.Add(newSkillInfo);
DB.AddToSkillInfo(newSkillInfo);
DB.SaveChanges();
textBoxSkillInfoSkillId.Clear();
textBoxUrlUncSkillInfo.Clear();
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.ToString(),
"Error Message");
}
}
Der folgende Handler wird aufgerufen, wenn der Benutzer Informationen übermittelt, die zur Erstellung einer neuen References-Entität verwendet werden.
private void buttonSubmitReference_Click(
object sender, EventArgs e)
{
try
{
if ("".Equals(textBoxRefEmployeeId.Text) ||
"".Equals(textBoxRefEmployeeAlias.Text))
{
MessageBox.Show("Incomplete Information");
return;
}
// Create new Reference and add to
// Reference_Employee association.
References reference = new References();
reference.ReferenceId = Guid.NewGuid();
reference.LastName = textBoxRefLastName.Text;
reference.Email = textBoxRefEmail.Text;
reference.Alias =
textBoxRefEmail.Text.Remove(
textBoxRefEmail.Text.IndexOf('@'));
reference.FirstName = textBoxRefFirstName.Text;
reference.Position = textBoxRefPosition.Text;
Guid empId = new Guid(
dataGridView1.CurrentRow.Cells[0].
Value.ToString());
ObjectParameter param = new ObjectParameter(
"p", empId);
Employees employee = DB.Employees.Where(
"it.EmployeeId = @p", param).First();
DB.AddToReferences(reference);
employee.References.Add(reference);
DB.SaveChanges();
textBoxRefFirstName.Clear();
textBoxRefLastName.Clear();
textBoxRefEmail.Clear();
textBoxRefPosition.Clear();
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.ToString(),
"Error Message");
}
}
Der folgende Ereignishandler startet den Internetbrowser zur Anzeige der SkillInfo-URL, die von der vorherigen Methode in das Rich Text Box geschrieben wurde.
private void richTextBox1_LinkClicked(object sender,
LinkClickedEventArgs e)
{
// Display the SkillInfo URL in Web browser.
System.Diagnostics.Process.Start(e.LinkText);
}
Der folgende Handler wird aufgerufen, wenn der Benutzer auf die Beschriftung der DataGridView für die Employees doppelklickt. Dies geschieht, damit die DataGridView für die Employees aktualisiert wird, wenn dem System neue Employees-Entitäten hinzugefügt wurden. Er wird auch kurz vor dem Ende des buttonSubmitEmployee_Click-Handlers aufgerufen.
private void EmployeesLabel_DoubleClick(object sender,
EventArgs e)
{
try
{
DB.Dispose(); //Dispose to refresh the data.
DB = new HRSkills();
bindingSource1.DataSource = DB.Employees;
dataGridView1.DataSource = bindingSource1;
dataGridView1.Columns[0].Visible = false;
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.ToString(),
"Error Message");
}
}
Siehe auch
Konzepte
Human Resources Skills-WinApp (EDM-Beispielanwendung)
HR Skills-Speichermetadaten (EDM-Beispielanwendung)
HR Skills-Mappingspezifikation (EDM-Beispielanwendung)