public void GetListTest()
{
List <TableLists> value = TableList.GetList(_databasePath, _crColumnTableId, out _errOut);
PrintList(value);
General.HasTrueValue(value.Count > 0, _errOut);
}
public void UpdateOrderStatus()
{
OrderData orderV = null;
OrderData prevOrderV = null;
try
{
orderV = TableList.First(x => x.Id.Equals(CurrentTable)).OrderList.First(o => o.OrderId.Equals(CurrentOrder));
}
catch
{
}
try
{
prevOrderV = TableList.First(x => x.Id.Equals(_previousTable)).OrderList.First(o => o.OrderId.Equals(_previousOrder));
}
catch
{
}
if (orderV != null)
{
orderV.OrderProcessing = _processingOrder;
}
if (prevOrderV != null)
{
prevOrderV.OrderProcessing = false;
}
}
private void BindGrid()
{
try
{
string query = "select EMPNO ,MEDICAL_CONDITION, HOSPITAL from TRAINEE01.HR where FLAG='N'";
DataSet myDataSet = SqlHelper.ExecuteDataset(Resource.ResConnectionString, CommandType.Text, query);
if (myDataSet.Tables[0].Rows.Count > 0)
{
TableList.DataSource = myDataSet;
TableList.DataBind();
}
else
{
myDataSet.Tables[0].Rows.Add(myDataSet.Tables[0].NewRow());
TableList.DataSource = myDataSet;
TableList.DataBind();
}
}
catch (Exception)
{
throw;
}
}
public void Generatcontrols(TableList item, StringBuilder _FullViewPage)
{
if (item.ColumnType == "T")
{
_FullViewPage.AppendLine("@Html.Kendo().TextBoxFor(m => m." + item.ColumnName + ").HtmlAttributes(new { placeholder = \"Enter " + (item.GridTitle == null ? item.ColumnName : item.GridTitle) + "\", style = \"width:100%;\" })");
}
else if (item.ColumnType == "D")
{
_FullViewPage.AppendLine("@(Html.Kendo().DropDownListFor(model => model." + item.ColumnName + ")");
_FullViewPage.AppendLine(".HtmlAttributes(new { style = \"width: 100%;\" })");
_FullViewPage.AppendLine(".DataTextField(\"Text\")");
_FullViewPage.AppendLine(".DataValueField(\"Value\")");
_FullViewPage.AppendLine(".Filter(\"contains\")");
_FullViewPage.AppendLine(".BindTo(Model." + item.ColumnName.Replace("Id", "") + "List)");
_FullViewPage.AppendLine(".DataSource(source =>");
_FullViewPage.AppendLine("{");
_FullViewPage.AppendLine("source.ServerFiltering(false);");
_FullViewPage.AppendLine("})");
_FullViewPage.AppendLine(")");
}
else if (item.ColumnType == "C")
{
_FullViewPage.AppendLine("@Html.Kendo().CheckBoxFor(m => m." + item.ColumnName + ").HtmlAttributes(new { style = \"width: 100%;\" })");
}
}
public async void ExecuteTableBTCommand(string TableNo)
{
try
{
LoadingMessage = "Please Wait, Loading Table Data";
IsLoading = true;
Helpers.Data.SelectedTable = TableList.Find(x => x.TableNo == TableNo);
var functionResponse = await TableDataAccess.GetTableDetailsAsync(TableNo);
if (functionResponse.status == "ok")
{
var result = JsonConvert.DeserializeObject <List <KOTProd> >(functionResponse.result.ToString());
Helpers.Data.OrderItemsList = result;
if (Helpers.Data.OrderItemsList != null && Helpers.Data.OrderItemsList.Count > 0)
{
Helpers.Data.PAX = Helpers.Data.OrderItemsList[0].PAX;
}
else
{
Helpers.Data.PAX = "0";
}
}
IsLoading = false;
await App.Current.MainPage.Navigation.PushAsync(new KOTProdTabbedPage());
}
catch (Exception ex)
{
IsLoading = false;
DependencyService.Get <IMessage>().ShortAlert(ex.Message);
//await App.Current.MainPage.Navigation.PushAsync(new KOTProdTabbedPage());
}
}
protected override void Context()
{
var client = CreateClient();
// ensure tables from previous tests are cleaned up
TableList tables = client.ListTablesAsync().Result;
foreach (string name in tables.name)
{
if (name.StartsWith(TestTablePrefix, StringComparison.Ordinal))
{
client.DeleteTableAsync(name).Wait();
}
}
// add a table specific to this test
testTableName = TestTablePrefix + _random.Next(10000);
_testTableSchema = new TableSchema();
_testTableSchema.name = testTableName;
_testTableSchema.columns.Add(new ColumnSchema {
name = "d"
});
client.CreateTableAsync(_testTableSchema).Wait();
}
private int InsertValueByTableName(string Value, TableList tableName)
{
int result = 0;
using (SqlConnection connection = DBConnectionFactory.GetConnection())
{
connection.Open();
SqlCommand insertCommand = null;
switch (tableName)
{
case TableList.Artist:
{
insertCommand = new SqlCommand(@"ArtistInsert_SP", connection);
}
break;
case TableList.Album:
{
insertCommand = new SqlCommand(@"AlbumInsert_SP", connection);
}
break;
case TableList.Bitrate:
{
insertCommand = new SqlCommand(@"BitrateInsert_SP", connection);
}
break;
case TableList.Genre:
{
insertCommand = new SqlCommand(@"GenreInsert_SP", connection);
}
break;
case TableList.Path:
{
insertCommand = new SqlCommand(@"PathInsert_SP", connection);
}
break;
}
if (insertCommand != null)
{
insertCommand.CommandType = CommandType.StoredProcedure;
SqlParameter returnValue = new SqlParameter("@return_value", null);
insertCommand.Parameters.Add(returnValue);
returnValue.Direction = ParameterDirection.ReturnValue;
SqlParameter nameParameter = new SqlParameter("@ValueToInsert", Value);
insertCommand.Parameters.Add(nameParameter);
nameParameter.Direction = ParameterDirection.Input;
int affectedRows = (int)insertCommand.ExecuteNonQuery();
result = Convert.ToInt32(returnValue.Value);
}
}
return(result);
}
private void Enter_Click(object sender, EventArgs e)
{
TableList f = new TableList();
f.Show();
this.Hide();
}
protected void Sort_Grid(object sender, DataGridSortCommandEventArgs e)
{
//DataView dataView = new DataView(Posts.GetPostTableList());
//dataView.Sort = e.SortExpression.ToString();
//this.DataGrid1.DataSource = dataView;
var list = TableList.GetAllPostTable();
if (!String.IsNullOrEmpty(e.SortExpression))
{
var name = e.SortExpression;
var desc = false;
var p = e.SortExpression.IndexOf(" ");
if (p >= 0)
{
name = e.SortExpression.Substring(0, p);
var dir = e.SortExpression.Substring(p + 1).Trim();
if (dir.EqualIgnoreCase("desc"))
{
desc = true;
}
}
list.Sort(name, desc);
}
this.DataGrid1.DataSource = list;
this.DataGrid1.DataBind();
}
public List <string> GetListByTableName(TableList tableName)
{
List <string> nameList = new List <string>();
using (SqlConnection connection = DBConnectionFactory.GetConnection())
{
connection.Open();
SqlCommand insertCommand = null;
string sqlCommand = string.Empty;
string parameter = "Name";
switch (tableName)
{
case TableList.Artist:
{
sqlCommand = @"SELECT [Name] FROM [MediaLibrary].[dbo].[Artist]";
}
break;
case TableList.Album:
{
sqlCommand = @"SELECT [Name] FROM [MediaLibrary].[dbo].[Album]";
}
break;
case TableList.Genre:
{
sqlCommand = @"SELECT [Name] FROM [MediaLibrary].[dbo].[Genre]";
}
break;
case TableList.Title:
{
sqlCommand = @"SELECT [TrackTitle] FROM [MediaLibrary].[dbo].[Track]";
parameter = "TrackTitle";
} break;
case TableList.FileName:
{
sqlCommand = @"SELECT [FileName] FROM [MediaLibrary].[dbo].[Track]";
parameter = "FileName";
} break;
}
using (insertCommand = new SqlCommand(sqlCommand, connection))
{
insertCommand.CommandType = CommandType.Text;
using (SqlDataReader dataReader = insertCommand.ExecuteReader())
{
while (dataReader.Read())
{
nameList.Add(dataReader[parameter].ToString());
}
}
}
}
return(nameList);
}
private async Task <Response> GetResponse(SqlResponseCommand command)
{
//var responder = command switch {
// SqlResponseCommand.GeneralInfo => new GeneralInfo(ConnectionString),
// SqlResponseCommand.TableList => new TableList(ConnectionString),
// _ => new Error()
//};
//return responder.GetResponse();
ICommandResponder responder;
switch (command)
{
case SqlResponseCommand.GeneralInfo:
responder = new GeneralInfo(ConnectionString);
break;
case SqlResponseCommand.TableList:
responder = new TableList(ConnectionString);
break;
default:
responder = new Error();
break;
}
return(await responder.GetResponse());
}
private void BindGrid()
{
try
{
string query = "select USER_ID, NAME,DEPT,EMAIL from TRAINEE01.EMPLOYEEDB ";
DataSet myDataSet = SqlHelper.ExecuteDataset(Resource.ResConnectionString, CommandType.Text, query);
if (myDataSet.Tables[0].Rows.Count > 0)
{
TableList.DataSource = myDataSet;
TableList.DataBind();
}
else
{
myDataSet.Tables[0].Rows.Add(myDataSet.Tables[0].NewRow());
TableList.DataSource = myDataSet;
TableList.DataBind();
}
}
catch (Exception)
{
throw;
}
}
public void UpdateTableStatus(TableList t)
{
var tableList = _rDBContext.TableList.First(x => x.TableID == t.TableID);
tableList.BookingStatus = t.BookingStatus;
_rDBContext.SaveChanges();
}
public static void editName(Reference reference, string oldName, string newName)
{
TableList tablelist = TableList.getTableList();
Table table = tablelist.getTable(reference.getTableName());
table.getColumn(oldName).getReference().setColumnName(newName);
}
public void CreateTableList()
{
try
{
SampleData.Current.Tables.ForEach(t =>
{
var orders = new ObservableCollection <OrderData>();
SampleData.Current.Orders.FindAll(o => o.TableId.Equals(t.Id)).ForEach(item =>
{
orders.Add(new OrderData()
{
OrderId = item.Id, OrderCost = item.AmountOwing, OrderStatus = item.OrderState.ToString(), OrderName = item.DisplayName
});
});
if (orders.Count > 0)
{
TableList.Add(new TableData {
Id = t.Id, OrderList = orders, TableName = t.DisplayName
});
}
});
}
catch (Exception ex)
{
Log($"Error: {ex.Message}");
}
}
public void GetFullNameTest()
{
string value = TableList.GetTableName(_databasePath, _crColumnTableId, out _errOut);
TestContext.WriteLine($"Returned value: {value}");
General.HasTrueValue(value.Length > 0, _errOut);
}
public void ReadOffsetTables()
{
ScalarType = _file.GetUint32();
var numTables = _file.GetUint16();
SearchRange = _file.GetUint16();
EntrySelector = _file.GetUint16();
RangeShift = _file.GetUint16();
for (var i = 0; i < numTables; i++)
{
var tag = _file.GetString(4);
var table = new Table()
{
Checksum = _file.GetUint32(),
Offset = _file.GetUint32(),
Length = _file.GetUint32()
};
TableList.Add(tag);
Tables.Add(table);
}
}
public async Task <Response <TableList> > ListTablesAsync(string subscriptionId, string resourceGroupName, string accountName, CancellationToken cancellationToken = default)
{
if (subscriptionId == null)
{
throw new ArgumentNullException(nameof(subscriptionId));
}
if (resourceGroupName == null)
{
throw new ArgumentNullException(nameof(resourceGroupName));
}
if (accountName == null)
{
throw new ArgumentNullException(nameof(accountName));
}
using var message = CreateListTablesRequest(subscriptionId, resourceGroupName, accountName);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
TableList value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
value = TableList.DeserializeTableList(document.RootElement);
return(Response.FromValue(value, message.Response));
}
protected override void Context()
{
_credentials = ClusterCredentialsFactory.CreateFromFile(@".\credentials.txt");
var client = new HBaseClient(_credentials);
// ensure tables from previous tests are cleaned up
TableList tables = client.ListTables();
foreach (string name in tables.name)
{
if (name.StartsWith(TestTablePrefix, StringComparison.Ordinal))
{
client.DeleteTable(name);
}
}
// add a table specific to this test
_testTableName = TestTablePrefix + _random.Next(10000);
_testTableSchema = new TableSchema();
_testTableSchema.name = _testTableName;
_testTableSchema.columns.Add(new ColumnSchema {
name = "d"
});
client.CreateTable(_testTableSchema);
}
protected override void Context()
{
if (!_arrangementCompleted)
{
// at present, no tables are modified so only arrange the tables once per test pass
// and putting the arrangement into a static context.
// (this knocked test runs down to ~30 seconds from ~5 minutes).
_credentials = ClusterCredentialsFactory.CreateFromFile(@".\credentials.txt");
var client = new HBaseClient(_credentials);
// ensure tables from previous tests are cleaned up
TableList tables = client.ListTables();
foreach (string name in tables.name)
{
string pinnedName = name;
if (name.StartsWith(TableNamePrefix, StringComparison.Ordinal))
{
client.DeleteTable(pinnedName);
}
}
AddTable();
PopulateTable();
_arrangementCompleted = true;
}
}
private async void ExecuteRemarksOkCommand(object obj)
{
try
{
LoadingMessage = "Please Wait, Loading Table Data";
IsLoading = true;
Helpers.Data.SelectedTable = TableList.Find(x => x.TableNo == SelectedTableNo);
var functionResponse = await TableDataAccess.CancelOrdersAsync(SelectedTableNo, Helpers.Constants.User.UserName, Remarks);
if (functionResponse.ToLower() == "success")
{
DependencyService.Get <IMessage>().ShortAlert("Table order canceled successfully");
}
else
{
DependencyService.Get <IMessage>().ShortAlert(functionResponse);
}
IsLoading = false;
IsRemarks = false;
Remarks = "";
ExecuteRefreshCommand();
}catch (Exception ex)
{
IsLoading = false;
IsRemarks = false;
DependencyService.Get <IMessage>().ShortAlert(ex.Message);
}
}
private void btnOK_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(this.txtFileName.Text))
{
MessageBox.Show(this, "設計書ファイル名を指定してください。", "", MessageBoxButtons.OK);
return;
}
if (this.cmbTemplate.SelectedItem == null)
{
MessageBox.Show(this, "テンプレートを選択してください。", "", MessageBoxButtons.OK);
return;
}
this._createInfo.FileName = this.txtFileName.Text;
this._createInfo.SystemName = this.txtSystemName.Text;
this._createInfo.SubSystemName = this.txtSubSystemName.Text;
this._createInfo.TemplateInfo = (TemplateInfo.DocumentTemplateRow)((DataRowView)this.cmbTemplate.SelectedItem).Row;
foreach (DataGridViewRow row in this.dataGridView1.Rows)
{
bool isChecked = (bool)row.Cells[0].FormattedValue;
if (isChecked)
{
TableList selectedTable = row.DataBoundItem as TableList;
this._createInfo.TableNames.Add(selectedTable.TableName);
}
}
this.DialogResult = System.Windows.Forms.DialogResult.OK;
}
/// <inheritdoc />
public int Read(BinaryReader reader)
{
var byteCount = 0;
var header = reader.ReadBytes(MagicHead.Length);
byteCount += MagicHead.Length;
if (!CompareBytes(header, MagicHead))
{
throw new ConfigException("Invalid Header");
}
TableCount = reader.ReadUInt16();
byteCount += sizeof(ushort);
for (ushort i = 0; i < TableCount; ++i)
{
var tableItem = new TableItem {
TableIdx = i
};
byteCount += tableItem.Read(reader);
TableList.Add(tableItem);
var sep = reader.ReadBytes(TableSeparator.Length);
byteCount += TableSeparator.Length;
if (!CompareBytes(sep, GetHashedBytes(TableSeparator, i)))
{
throw new ConfigException("Invalid Table Separator");
}
}
var end = reader.ReadBytes(MagicEnd.Length);
byteCount += MagicEnd.Length;
if (!CompareBytes(end, MagicEnd))
{
throw new ConfigException("Invalid End");
}
return(byteCount);
}
private void PopulateTableList()
{
TableList.DataSource = GetTableNames().DefaultView;
TableList.DataTextField = "TableName";
TableList.DataValueField = "TableId";
TableList.DataBind();
TableList.Items.Insert(0, new ListItem("", ""));
}
/// <summary>
/// Creates a new instance of the TableCustomTreeNode class.
/// </summary>
public TableCustomTreeNode(object contextOfUse, object id, string display, TableList table)
{
this.contextOfUse = contextOfUse;
this.id = id;
this.display = display;
this.table = table;
this.Text = display;
}
public static List <BonusLogInfo> GetLogs(TopicInfo topic)
{
if (topic.Tid <= 0 || topic.Special != 3)
{
return(null);
}
return(BBX.Data.Bonus.GetLogs(topic.Tid, TableList.GetPostTableId(topic.Tid)));
}
public Table getTable(string tableName)
{
//return workTable = new Table(IO.LoadXMLTable(tableName, path), tableName);
Table table = TableList.getTableList().getTable(tableName);
return(table);
}
public TablesClass(ProductsList products, BillList bills,
User employee)
{
Tables = new TableList();
Products = products;
Bills = bills;
Employee = employee;
}
/// <summary>
/// Start this instance.
/// </summary>
public void Start()
{
Table = GetComponent <TableList>();
Table.Init();
Table.DataSource = Generate(100, 10);
Header.Refresh();
}
private void LoadPostTableList()
{
//DataTable allPostTable = Posts.GetAllPostTable();
//foreach (DataRow dataRow in allPostTable.Rows)
foreach (var item in TableList.GetAllPostTable())
{
this.tablelist.Items.Add(new ListItem(BaseConfigs.GetTablePrefix + "posts" + item.ID, item.ID.ToString()));
}
}
public void TestMethod1()
{
ITableList<Usuario> table = new TableList<Usuario>();
table.AddToList(new Usuario() { Id = 1, Login = "******", Nome = "test"});
table.AddToList(new Usuario() { Id = 2, Login = "******", Nome = "tebg" });
table.AddPropertyToShow(x => x.Nome);
}
public TestViewModel()
{
Table = new TableList<Usuario>();
Table.AddToList(new Usuario() { Id = 1, Login = "******", Nome = "Fulano", Perfil = new Perfil() { Tipo = "test" } });
Table.AddToList(new Usuario() { Id = 2, Login = "******", Nome = "Tal" });
Table.AddPropertyToShow(x => x.Login);
Table.AddPropertyToShow(x => x.Nome);
}
private int InsertValueByTableName(string Value, TableList tableName)
{
int result = 0;
using (SqlConnection connection = DBConnectionFactory.GetConnection())
{
connection.Open();
SqlCommand insertCommand = null;
switch (tableName)
{
case TableList.Artist:
{
insertCommand = new SqlCommand(@"ArtistInsert_SP", connection);
}
break;
case TableList.Album:
{
insertCommand = new SqlCommand(@"AlbumInsert_SP", connection);
}
break;
case TableList.Bitrate:
{
insertCommand = new SqlCommand(@"BitrateInsert_SP", connection);
}
break;
case TableList.Genre:
{
insertCommand = new SqlCommand(@"GenreInsert_SP", connection);
}
break;
case TableList.Path:
{
insertCommand = new SqlCommand(@"PathInsert_SP", connection);
}
break;
}
if (insertCommand != null)
{
insertCommand.CommandType = CommandType.StoredProcedure;
SqlParameter returnValue = new SqlParameter("@return_value", null);
insertCommand.Parameters.Add(returnValue);
returnValue.Direction = ParameterDirection.ReturnValue;
SqlParameter nameParameter = new SqlParameter("@ValueToInsert", Value);
insertCommand.Parameters.Add(nameParameter);
nameParameter.Direction = ParameterDirection.Input;
int affectedRows = (int)insertCommand.ExecuteNonQuery();
result = Convert.ToInt32(returnValue.Value);
}
}
return result;
}
public SchemaExtractor()
{
string dataMapping = Utility.GetResource("TotalSafety.DataTierGenerator.Resource.DataMapping.xml");
m_DataMappingXml = new XmlDocument();
m_DataMappingXml.LoadXml(dataMapping);
m_TableList = new TableList();
m_ViewList = new List<object>();
m_StoredProcedureList = new List<object>();
}
private int InsertValueByTableName(string value, TableList tableName)
{
Database database = (new DbFactory()).CreateDatabase();
string spName = ((new Resources()).CreateInsertSPList())[tableName].ToString();
ExecuteStoredProcWithParam executeStoredProcWithParam = new ExecuteStoredProcWithParam(database, spName);
executeStoredProcWithParam.AddInParameter(database, value, @"ValueToInsert");
executeStoredProcWithParam.AddOutParameter(database, @"return_value");
return executeStoredProcWithParam.ExecuteSpSetResultValue(database, @"return_value");
}
private string FormatTableList(TableList comment)
{
return formatInlineList(comment.Items, "<table>{0}</table>", "<tr>{0}{1}</tr>", "<td>{0}</td>", "<td>{0}</td>");
}
private void frmMain_Load(object sender, EventArgs e)
{
button1.Enabled = false;
tableList = Table.GetTables();
listBox1.Items.Clear();
foreach (Table tbl in tableList)
{
string line = string.Format("[{0}].[{1}].[{2}]", tbl.Catalog, tbl.Schema, tbl.Name);
listBox1.Items.Add(line);
}
}
public IList GetListByTableName(TableList tableName)
{
Database database = (new DbFactory()).CreateDatabase();
IDataProvider<SimpleTable> resultTableProvider =
new DataProviderWithSynchronouseAccessor<SimpleTable>();
resultTableProvider.StoredProcedureName =
(new Resources().CreateSelectSPList())[tableName].ToString();
IRowMapper<SimpleTable> mapper = MapBuilder<SimpleTable>.MapAllProperties()
.MapByName(x => x.Name)
.Build();
return resultTableProvider.GetDataFromStoredProcedureAccessor(database, null, mapper).ToList();
}
public void Restore()
{
if (PostParameters != null && PostParameters["file"] != null) {
new BatchJob(this, delegate() {
Batch.Status = "Loading new data";
UploadedFile data = PostParameters.As<UploadedFile>("file");
Database.Logging = LogLevel.None;
Database.BeginTransaction();
JObject d = data.Content.JsonTo<JObject>();
List<Table> tables = Database.TableNames.Select(n => Database.TableFor(n)).ToList();
Batch.Records = tables.Count * 4;
foreach (Table t in tables) {
if (d[t.Name] != null) {
Batch.Records += ((JArray)d[t.Name]).Count;
}
}
Batch.Status = "Deleting existing data";
TableList orderedTables = new TableList(tables);
foreach(Table t in orderedTables) {
Database.Execute("DELETE FROM " + t.Name);
Batch.Record += 4;
}
Database.Logging = LogLevel.None;
foreach (Table t in orderedTables.Reverse<Table>()) {
if (d[t.Name] != null) {
Batch.Status = "Restoring " + t.Name + " data";
foreach (JObject record in (JArray)d[t.Name]) {
Database.Insert(t.Name, record);
Batch.Record++;
}
}
}
Batch.Status = "Checking database version";
Database.Upgrade();
Database.Commit();
Batch.Status = "Compacting database";
Database.Clean();
_settings = Database.QueryOne<Settings>("SELECT * FROM Settings");
Batch.Status = Message = "Database restored successfully";
});
}
}
public List<string> GetListByTableName(TableList tableName)
{
List<string> nameList = new List<string>();
using (SqlConnection connection = DBConnectionFactory.GetConnection())
{
connection.Open();
SqlCommand insertCommand = null;
string sqlCommand = string.Empty;
string parameter = "Name";
switch (tableName)
{
case TableList.Artist:
{
sqlCommand = @"SELECT [Name] FROM [MediaLibrary].[dbo].[Artist]";
}
break;
case TableList.Album:
{
sqlCommand = @"SELECT [Name] FROM [MediaLibrary].[dbo].[Album]";
}
break;
case TableList.Genre:
{
sqlCommand = @"SELECT [Name] FROM [MediaLibrary].[dbo].[Genre]";
}
break;
case TableList.Title:
{
sqlCommand = @"SELECT [TrackTitle] FROM [MediaLibrary].[dbo].[Track]";
parameter = "TrackTitle";
} break;
case TableList.FileName:
{
sqlCommand = @"SELECT [FileName] FROM [MediaLibrary].[dbo].[Track]";
parameter = "FileName";
} break;
}
using (insertCommand = new SqlCommand(sqlCommand, connection))
{
insertCommand.CommandType = CommandType.Text;
using (SqlDataReader dataReader = insertCommand.ExecuteReader())
{
while (dataReader.Read())
{
nameList.Add(dataReader[parameter].ToString());
}
}
}
}
return nameList;
}
