public static void Upload(this System.Data.DataTable dt, string tableName) { string query = "SELECT * from " + tableName; using (SqlConnection conn = new SqlConnection(SqlConnStr)) { using (SqlDataAdapter oda = new SqlDataAdapter()) { using (SqlCommandBuilder bu = new SqlCommandBuilder()) { using (SqlBulkCopy bulkcopy = new SqlBulkCopy(conn)) { oda.SelectCommand = new SqlCommand(query, conn); bulkcopy.DestinationTableName = "dbo." + tableName; DataTable dtsql = new DataTable(); oda.Fill(dtsql); List<DataRow> lst_temp = dt.AsEnumerable().ToList(); foreach (DataRow row in lst_temp) { dtsql.ImportRow(row); } conn.Open(); bulkcopy.WriteToServer(dtsql); conn.Close(); } } } } }
public static DataTable CalculateSum(this DataTable source) { var query = source.AsEnumerable(); var table = query.CopyToDataTable(); var newRow = table.NewRow(); //Summe Heizperiode newRow[0] = "Summe Heizperiode"; int cellsCount = table.Columns.Count - 1; for (int i = 1; i <= cellsCount; i++) { newRow[i] = CalcColumnSumme(table, i, true); } //Summe Jahr var newRow2 = table.NewRow(); newRow2[0] = "Summe Jahr"; for (int i = 1; i <= cellsCount; i++) { newRow2[i] = CalcColumnSumme(table, i, false); } table = GetTableWithMonts(table); table.Rows.Add(newRow); table.Rows.Add(newRow2); return table; }
public static bool IsEqualTo(this DataTable source, DataTable other) { if (other == null) { return false; } return source.AsEnumerable().SequenceEqual(other.AsEnumerable(), DataRowComparer.Default); }
public static IEnumerable<ListItem> GenerateItems(this DataTable Table, string ValueField, string TextField) { IEnumerable<ListItem> Result = new List<ListItem>(); var datos = Table.AsEnumerable(); Result = datos.Select(p => new ListItem { Value = p[ValueField].ToString(), Text = p[TextField].ToString() }); return Result; }
/// <summary> /// Get Authors as SelectedList (for Views) /// </summary> /// <param name="Authors">List of Athors</param> /// <param name="currAuthor">Current Author will be selected</param> /// <returns></returns> public static List<SelectListItem> AsSelectedList(this IQueryable<Author> Authors, int currAuthor = 0) { return (from author in Authors.AsEnumerable() select new SelectListItem { Value = author.Id.ToString(), Text = author.FirstName + " " + author.LastName, Selected = author.Id == currAuthor }).ToList(); }
public static AMSChannelCollection ToAMSChannels(this IEnumerable<IChannel> channels) { channels.NullCheck("channels"); AMSChannelCollection result = new AMSChannelCollection(); channels.AsEnumerable().ForEach(c => result.Add(c.ToAMSChannel())); return result; }
/// <summary> /// Get Themes as SelectedList (for Views) /// </summary> /// <param name="Themes">List of Themes</param> /// <param name="currTheme">Current Theme will be selected</param> /// <returns></returns> public static List<SelectListItem> AsSelectedList(this IQueryable<Theme> Themes, int currTheme = 0) { return (from theme in Themes.AsEnumerable() select new SelectListItem { Value = theme.Id.ToString(), Text = theme.ThemeName, Selected = theme.Id == currTheme }).ToList(); }
public static HashSet<Field> FieldsIn (this LispList<PathElement> path) { var result = new HashSet<Field> (); if (path != null) { foreach (PathElement element in path.AsEnumerable ()) { Field f; if (element.TryField (out f)) result.Add (f); } } return result; }
/// <summary>DataTableの各RowをExpandoObjectに変換します。</summary> public static IEnumerable<dynamic> AsDynamic(this DataTable table) { return table.AsEnumerable().Select(x => { IDictionary<string, object> dict = new ExpandoObject(); foreach (DataColumn column in x.Table.Columns) { var value = x[column]; if (value is System.DBNull) value = null; dict.Add(column.ColumnName, value); } return (dynamic)dict; }); }
public static IObservable<KeyValuePair<string, string>> AsObservable(this IConfiguration configuration) { return Observable.Create<KeyValuePair<string, string>>(observer => { var dictionary = configuration.AsEnumerable().ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase); var token = ChangeToken.OnChange(() => configuration.GetReloadToken(), () => { var value = (string)null; foreach(var kvp in configuration.AsEnumerable()) { if(dictionary.TryGetValue(kvp.Key, out value) && value.Equals(kvp.Value, StringComparison.OrdinalIgnoreCase)) { continue; } else { dictionary[kvp.Key] = kvp.Value; observer.OnNext(kvp); } } }); return () => { observer.OnCompleted(); token.Dispose(); }; }); }
public static IDictionary<string, object> ToRouteValues( this IDictionary<string, MethodArgumentTestContext> dictionary, Func<KeyValuePair<string, MethodArgumentTestContext>, bool> filter = null) { var result = dictionary.AsEnumerable(); if (filter != null) { result = result.Where(filter); } return result.ToDictionary( a => a.Key, a => a.Value.Value); }
public static SimpleModelState ToJsonValidation(this ModelStateDictionary modelState) { var v = from m in modelState.AsEnumerable() from e in m.Value.Errors select new SimpleError { Key = m.Key, ErrorMessage = e.ErrorMessage }; v = v.ToList(); var pe = v.Where(x => !string.IsNullOrEmpty(x.Key)).ToList(); var me = v.Where(x => string.IsNullOrEmpty(x.Key)).ToList(); return new SimpleModelState { IsValid = modelState.IsValid, PropertyErrors = pe, ModelErrors = me }; }
public static IQueryable<Message> Sort(this IQueryable<Message> source, MessageSort sortedBy, bool des) { if (sortedBy == MessageSort.PublishTime) { source = source.OrderBy(m => m.CreateTime); } else if (sortedBy == MessageSort.ReadTime) { source = source.OrderBy(m => m.ReadTime); } if (des) { source = source.AsEnumerable().Reverse().AsQueryable(); } return source; }
/// <summary> /// DataTableの各RowをExpandoObjectに変換します。 /// </summary> /// <param name="table"></param> /// <returns></returns> public static dynamic AsDynamic(this DataTable table) { // return table.AsEnumerable() var dynamic = table.AsEnumerable() .Select(row => { IDictionary<string, object> expando = new ExpandoObject(); foreach (DataColumn column in row.Table.Columns) { var value = row[column]; if (value is DBNull) { value = null; } expando.Add(column.ColumnName, value); } return (dynamic) expando; }); return dynamic; }
public static DataTable GroupBy(this DataTable inputDataTable, string[] columnNames) { var groupedDataTable = new DataTable(); var distinctColumnNames = columnNames.Distinct().ToArray(); foreach (var columnName in distinctColumnNames) { groupedDataTable.Columns.Add(columnName, inputDataTable.Columns[columnName].DataType); } foreach ( var grouping in inputDataTable.AsEnumerable() .GroupBy(r => new NTuple<object>(distinctColumnNames.Select(cn => r[cn])))) { var row = groupedDataTable.NewRow(); for (int i = 0; i < distinctColumnNames.Length; i++) { row[i] = grouping.Key.Values[i]; } groupedDataTable.Rows.Add(row); } return groupedDataTable; }
public static string[] GetErrors(this ModelStateDictionary modelState, string prefix) { if (!modelState.IsValid) { List<string> errors = new List<string>(); IEnumerable<KeyValuePair<string, ModelState>> states = prefix.IsNullOrEmpty() ? modelState.AsEnumerable() : modelState.Where(x => x.Key.StartsWith(prefix + ".")); foreach (var modelStateKvp in states) { foreach (var modelError in modelStateKvp.Value.Errors) { errors.Add(modelError.ErrorMessage); } } return errors.ToArray(); } return null; }
public static List<SuiteUserModel> ToModel(this ICollection<SuiteUser> input) { return input.AsEnumerable().Select(model => model.ToModel()).ToList(); }
public static IEnumerable<Task> ApplyFilters(this IEnumerable<Task> taskList, IEnumerable<TaskFilter> filters) { IEnumerable<Task> filterResults = taskList.AsEnumerable(); return filters.Aggregate(filterResults, (current, taskFilter) => current.Where(taskFilter.Filter)); }
public static IQueryable<Task> Sort(this IQueryable<Task> source, string sort, bool des) { if (sort == TaskList.Sort_By_ActualComplete) { source = source.OrderBy(t => t.ActualCompleteTime); } else if (sort == TaskList.Sort_By_ExpectedComplete) { source = source.OrderBy(t => t.ExpectCompleteTime); } else if (sort == TaskList.Sort_By_ActualWorkPeriod) { source = source.OrderBy(t => t.ActualWorkPeriod); } else if (sort == TaskList.Sort_By_ExpectedWorkPeriod) { source = source.OrderBy(t => t.ExpectWorkPeriod); } else if (sort == TaskList.Sort_By_Created) { source = source.OrderBy(t => t.CreateTime); } else if (sort == TaskList.Sort_By_Own) { source = source.OrderBy(t => t.OwnTime); } else if (sort == TaskList.Sort_By_Assign) { source = source.OrderBy(t => t.AssignTime); } else if (sort == TaskList.Sort_By_LatestUpdate) { source = source.OrderBy(t => t.LatestUpdateTime); } else if (sort == TaskList.Sort_By_OverDue) { source = source.OrderBy(t => t.OverDue); } else if (sort == TaskList.Sort_By_Delay) { source = source.OrderBy(t => t.Delay); } else if (sort == TaskList.Sort_By_Priority) { source = source.OrderBy(t => t.Priority); } else { throw new Exception(string.Format("the sort parameter ({0}) is not correct.", sort)); } if (des) { source = source.AsEnumerable().Reverse().AsQueryable(); } return source; }
public static List<LogData> ReferenceCheck(this DataTable dataTable, string field, DataTable referenceTable, string referenceField) { var logs = new List<LogData>(); if (referenceTable != null) { var ValuesNotInRefs = dataTable.AsEnumerable().Select(a => Convert.ToString(a.Field<object>(field))) .Except(referenceTable.AsEnumerable().Select(a => Convert.ToString(a.Field<object>(referenceField)))); if (ValuesNotInRefs.Count() > 0) { var inValidRows = (from row in dataTable.AsEnumerable() join id in ValuesNotInRefs on Convert.ToString(row.Field<object>(field)) equals id select row).CopyToDataTable(); foreach (var row in inValidRows.Rows.Cast<DataRow>()) { logs.Add(new LogData { WorkSheet = dataTable.TableName, ColumnName = field, RowNumber = dataTable.Rows.IndexOf(row) + 2, LogMessage = Convert.ToString(row.Field<object>(field)) + " is not available in reference sheet." }); //str.AppendFormat("{0} : {1} : Row {2} : {3}", dataTable.TableName, field, dataTable.Rows.IndexOf(row) + 2, // Convert.ToString(row.Field<object>(field)) + " is not available in reference sheet.\n"); } } } return logs; }
public static IEnumerable<ClassifiedSpan> ToClassifiedSpans(this ImmutableArray<SymbolDisplayPart> parts) { return parts.AsEnumerable().ToClassifiedSpans(); }
public static string GetFullText(this ImmutableArray<SymbolDisplayPart> parts) { // CONSIDER: this does the same thing as parts.ToDisplayString(), but more slowly. return parts.AsEnumerable().GetFullText(); }
private static string GetSecondaryUrl(this IEnumerable<ChannelEndpoint> endpoints) { string result = string.Empty; int index = 0; foreach (ChannelEndpoint endpoint in endpoints.AsEnumerable()) { if (index == 1) { if (endpoint != null && endpoint.Url != null) result = endpoint.Url.ToString(); break; } index++; } return result; }
public static IEnumerable<DataRow> TableToList(this DataTable table) { return table.AsEnumerable(); //as EnumerableRowCollection<T>; }
public static List<MappingModel> ToModel(this List<Mapping> input) { return input.AsEnumerable().Select(model => model.ToModel()).ToList(); }
public static List<LogData> GroupCheck(this DataTable dataTable, string basefield, List<string> ignoreFields) { var logs = new List<LogData>(); ignoreFields.ForEach(a => dataTable.Columns.Remove(a)); var blankColumns = dataTable.Columns.Cast<DataColumn>().Where(a => a.DataType == typeof(object) && a.ColumnName.StartsWith("Column")).ToList(); blankColumns.ForEach(a => dataTable.Columns.Remove(a)); var distinctRecords = dataTable.AsEnumerable().Distinct(System.Data.DataRowComparer.Default).ToList(); var groupedData = from row in distinctRecords.AsEnumerable() group row by new { placeCol = row[basefield] } into groupby select new { Name = groupby.Key, CountOfClients = groupby.Count() }; foreach (var data in groupedData) { if (data.CountOfClients > 1) { logs.Add(new LogData { WorkSheet = dataTable.TableName, ColumnName = basefield, RowNumber = 0, LogMessage = "Common data is not matching for " + data.Name.placeCol + " " + basefield }); } } return logs; }
internal static Imports Single(this ImportChain importChain) { return importChain.AsEnumerable().Single(); }
public static List<EnvironmentModel> ToModel(this ICollection<Environment> input) { return input.AsEnumerable().Select(applicationModel => applicationModel.ToModel()).ToList(); }
public static List<ParameterModel> ToModel(this ICollection<Parameter> input) { return input.AsEnumerable().Select(parameterModel => parameterModel.ToModel()).ToList(); }
public static List<RegionModel> ToModel(this ICollection<Region> input) { return input.AsEnumerable().Select(RegionModel => RegionModel.ToModel()).ToList(); }