/// <summary> /// /// </summary> /// <param name="commandText"></param> /// <param name="value"></param> public static void AppendToCommandText( StringBuilder commandText, string value) { FoundationContract.Requires <ArgumentException>(commandText != null); var s = value.ToTSqlNVarChar(); commandText.Append(s); }
public DataViewPropertiesForm(DataViewProperties properties) { FoundationContract.Requires <ArgumentException>(properties != null); _properties = properties; InitializeComponent(); rowFilterTextBox.Text = properties.RowFilter; sortTextBox.Text = properties.Sort; }
/// <summary> /// /// </summary> /// <param name="s"></param> /// <param name="index"></param> /// <param name="ch"></param> public static unsafe void SetChar(string s, int index, char ch) { FoundationContract.Requires <ArgumentException>(index >= 0); FoundationContract.Requires <ArgumentException>(index < s.Length); fixed(char *p = s) { p[index] = ch; } }
internal CacheItem(string key, Func <T> getValue, TimeSpan slidingExpiration) { FoundationContract.Requires <ArgumentException>(key != null); FoundationContract.Requires <ArgumentException>(getValue != null); FoundationContract.Requires <ArgumentException>(slidingExpiration > TimeSpan.Zero); this.key = key; this.slidingExpiration = slidingExpiration; this.getValue = getValue; }
/// <summary> /// /// </summary> /// <param name="container"></param> /// <param name="flag"></param> /// <returns></returns> public static bool HasFlag(this Enum container, Enum flag) { FoundationContract.Requires <ArgumentException>(container.GetType() == flag.GetType()); UInt64 containerUInt64 = Convert.ToUInt64(container); UInt64 flagUInt64 = Convert.ToUInt64(flag); bool hasFlag = (containerUInt64 & flagUInt64) == flagUInt64; return(hasFlag); }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <returns></returns> public static T Last <T>(this IList <T> source) { Assert.IsNotNull(source); FoundationContract.Requires <ArgumentException>(source.Count > 0); var lastIndex = source.Count - 1; var last = source[lastIndex]; return(last); }
/// <summary> /// /// </summary> /// <param name="value"></param> /// <returns></returns> public override int Add(object value) { Assert.IsNotNull(value); FoundationContract.Requires <ArgumentException>(value is TextDataParameter); var parameter = (TextDataParameter)value; _collection.Add(parameter); return(_collection.Count - 1); }
public static string GetSchemas(string database) { FoundationContract.Requires <ArgumentOutOfRangeException>(!database.IsNullOrWhiteSpace()); return(string.Format(@"if exists(select * from sys.databases (nolock) where name = '{0}') begin select null,name from [{0}].sys.schemas (nolock) order by name end", database)); }
private static ushort ToSmallDateValue(DateTime dateTime) { FoundationContract.Requires <ArgumentOutOfRangeException>(MinDateTime <= dateTime); FoundationContract.Requires <ArgumentOutOfRangeException>(dateTime <= MaxDateTime); var timeSpan = dateTime - MinDateTime; var totalDays = timeSpan.TotalDays; var value = (ushort)totalDays; return(value); }
/// <summary> /// /// </summary> /// <param name="increment"></param> /// <param name="adjustment"></param> public LocalTime(int increment, int adjustment) { FoundationContract.Requires <ArgumentOutOfRangeException>(increment >= 0); FoundationContract.Requires <ArgumentOutOfRangeException>(increment <= adjustment); _increment = increment; _adjustment = adjustment; _lastTickCount = UniversalTime.GetTickCount(); _lastDateTime = DateTime.Now; }
public static string GetTables(string tableSchema, IEnumerable <string> tableTypes) { FoundationContract.Requires <ArgumentException>(!tableSchema.IsNullOrWhiteSpace()); FoundationContract.Requires <ArgumentException>(tableTypes != null && tableTypes.Any()); return($@"select TABLE_NAME from information_schema.TABLES where TABLE_SCHEMA = {tableSchema.ToTSqlVarChar()} and TABLE_TYPE in({string.Join(",", tableTypes.Select(o => o.ToTSqlVarChar()))}) order by TABLE_NAME"); }
/// <summary> /// /// </summary> /// <param name="list"></param> /// <param name="offset"></param> /// <param name="count"></param> public ReadOnlyListSegment(IReadOnlyList <T> list, int offset, int count) { Assert.IsNotNull(list); FoundationContract.Requires <ArgumentOutOfRangeException>(offset >= 0); FoundationContract.Requires <ArgumentOutOfRangeException>(count >= 0); FoundationContract.Requires <ArgumentOutOfRangeException>(0 <= offset && offset < list.Count); FoundationContract.Requires <ArgumentOutOfRangeException>(0 <= offset + count && offset + count <= list.Count); _list = list; _offset = offset; Count = count; }
public static T SetFlag <T>(this T container, T flag) { FoundationContract.Requires <ArgumentException>(typeof(T).IsEnum); var type = typeof(T); var containerUInt64 = Convert.ToUInt64(container, CultureInfo.InvariantCulture); var flagUInt64 = Convert.ToUInt64(flag, CultureInfo.InvariantCulture); containerUInt64 |= flagUInt64; return((T)Enum.ToObject(type, containerUInt64)); }
/// <summary> /// /// </summary> /// <param name="childNode"></param> public void AddChildNode(ConfigurationNode childNode) { FoundationContract.Requires <ArgumentException>(childNode.Parent == null); if (childNode.Name == null) { childNode.Name = ConfigurationElementName.Node + "[" + _index + ']'; _index++; } ChildNodes.Add(childNode); childNode.Parent = this; }
/// <summary> /// /// </summary> /// <param name="increment">increment interval in milliseconds</param> /// <param name="adjustment">adjustement interval in millseconds</param> public UniversalTime(int increment, int adjustment) { FoundationContract.Requires <ArgumentOutOfRangeException>(increment >= 0); FoundationContract.Requires <ArgumentOutOfRangeException>(increment <= adjustment); this._increment = increment; this._adjustment = adjustment; _sharedDateTime = DateTime.Now; _incrementedTickCount = _sharedTickCount; _incrementedDateTime = _sharedDateTime; }
/// <summary> /// /// </summary> /// <param name="index"></param> /// <param name="childNode"></param> public void InsertChildNode(int index, ConfigurationNode childNode) { FoundationContract.Requires <ArgumentException>(childNode.Parent == null); if (childNode.Name == null) { childNode.Name = ConfigurationElementName.Node + "[" + index + ']'; index++; } ChildNodes.Insert(index, childNode); childNode.Parent = this; }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="collection"></param> /// <param name="items"></param> public static void Add <T>(this ICollection <T> collection, IEnumerable <T> items) { FoundationContract.Requires <ArgumentException>(collection != null || items == null); if (items != null) { foreach (var item in items) { collection.Add(item); } } }
/// <summary> /// /// </summary> /// <param name="columns"></param> /// <param name="convert"></param> public TextDataRow(TextDataColumnCollection columns, Convert convert) { FoundationContract.Requires <ArgumentException>(columns != null); FoundationContract.Requires <ArgumentException>(convert != null); Columns = columns; _convert = convert; ItemArray = new object[columns.Count]; for (var i = 0; i < ItemArray.Length; i++) { ItemArray[i] = DBNull.Value; } }
/// <summary> /// /// </summary> /// <param name="factory"></param> /// <param name="minSize"></param> /// <param name="maxSize"></param> public ObjectPool( IPoolableObjectFactory <T> factory, int minSize, int maxSize) { Assert.IsNotNull(factory); FoundationContract.Requires <ArgumentOutOfRangeException>(minSize >= 0); FoundationContract.Requires <ArgumentOutOfRangeException>(minSize <= maxSize); _factory = factory; MinSize = minSize; MaxSize = maxSize; _timer = new Timer(TimerCallback, null, 30000, 30000); }
/// <summary> /// /// </summary> public string this[int columnIndex] { get { FoundationContract.Requires <ArgumentException>(0 <= columnIndex && columnIndex < Table.Columns.Count); return(_cells[columnIndex]); } set { FoundationContract.Requires <ArgumentException>(0 <= columnIndex && columnIndex < Table.Columns.Count); _cells[columnIndex] = value; } }
/// <summary> /// /// </summary> /// <param name="source"></param> /// <returns></returns> public static T?ToNullableEnum(int?source) { FoundationContract.Requires <ArgumentException>(typeof(T).IsEnum); T?target; if (source != null) { target = (T)Enum.ToObject(typeof(T), source.Value); } else { target = null; } return(target); }
/// <summary> /// /// </summary> /// <param name="values"></param> /// <param name="keySelector"></param> /// <param name="comparison"></param> public ReadOnlySortedList( IReadOnlyList <TValue> values, Func <TValue, TKey> keySelector, Comparison <TKey> comparison) { Assert.IsNotNull(values); Assert.IsNotNull(keySelector); Assert.IsNotNull(comparison); FoundationContract.Requires <ArgumentException>( values.Select(keySelector).SelectPreviousAndCurrent().All(k => comparison(k.Previous, k.Current) < 0), "keys must be unique and ordered"); _values = values; _keySelector = keySelector; _comparison = comparison; }
/// <summary> /// /// </summary> /// <typeparam name="TSource"></typeparam> /// <param name="source"></param> /// <param name="count"></param> /// <param name="partitionCount"></param> /// <returns></returns> public static IEnumerable <List <TSource> > GetPartitions <TSource>( this IEnumerable <TSource> source, int count, int partitionCount) { Assert.IsNotNull(source); FoundationContract.Requires <ArgumentOutOfRangeException>(count >= 0); FoundationContract.Requires <ArgumentOutOfRangeException>(partitionCount > 0); FoundationContract.Ensures(Contract.Result <IEnumerable <List <TSource> > >().Count() <= partitionCount); FoundationContract.Ensures(Contract.ForAll(Contract.Result <IEnumerable <List <TSource> > >().ToList(), partition => partition.Count > 0)); var partitionSize = count / partitionCount; var remainder = count % partitionCount; using (var enumerator = source.GetEnumerator()) { for (var partitionIndex = 0; partitionIndex < partitionCount; partitionIndex++) { var currentPartitionSize = partitionSize; if (remainder > 0) { currentPartitionSize++; remainder--; } if (currentPartitionSize > 0) { var partition = enumerator.Take(currentPartitionSize); if (partition.Count > 0) { yield return(partition); } else { break; } } else { break; } } } }
/// <summary> /// /// </summary> /// <param name="values"></param> /// <param name="keySelector"></param> /// <param name="comparison"></param> public ReadOnlyNonUniqueSortedList( IReadOnlyList <TValue> values, Func <TValue, TKey> keySelector, Comparison <TKey> comparison) { Assert.IsNotNull(values); Assert.IsNotNull(keySelector); Assert.IsNotNull(comparison); FoundationContract.Requires <ArgumentException>( values.SelectPreviousAndCurrentKey(keySelector).All(key => comparison(key.Previous, key.Current) <= 0), "keys must be ordered"); _values = values; _keySelector = keySelector; _comparison = comparison; InitializeGroups(); }
/// <summary> /// /// </summary> /// <param name="inputStream"></param> /// <param name="outputStream"></param> /// <param name="bufferSize"></param> public static void CopyTo(this Stream inputStream, Stream outputStream, int bufferSize) { Assert.IsNotNull(inputStream != null); Assert.IsNotNull(outputStream != null); FoundationContract.Requires <ArgumentOutOfRangeException>(bufferSize > 0); var buffer = new byte[bufferSize]; while (true) { int read = inputStream.Read(buffer, 0, buffer.Length); if (read == 0) { break; } outputStream.Write(buffer, 0, read); } }
public static T SetFlag <T>(this T container, T flag, bool set) { FoundationContract.Requires <ArgumentException>(typeof(T).IsEnum); var type = typeof(T); var containerUInt64 = Convert.ToUInt64(container); var flagUInt64 = Convert.ToUInt64(flag); if (set) { containerUInt64 |= flagUInt64; } else { containerUInt64 &= ~flagUInt64; } return((T)Enum.ToObject(type, containerUInt64)); }
public static int Remove <T>(this ICollection <T> collection, IEnumerable <T> items) { FoundationContract.Requires <ArgumentException>(collection != null || items == null); var count = 0; if (items != null) { foreach (var item in items) { var removed = collection.Remove(item); if (removed) { count++; } } } return(count); }
public SqlBulkCopyResultWriter( Action <InfoMessage> addInfoMessage, IProvider destinationProvider, ConnectionBase destinationConnection, string tableName, Action <IDbTransaction> setTransaction, CancellationToken cancellationToken) { FoundationContract.Requires <ArgumentException>(destinationProvider.DbProviderFactory == SqlClientFactory.Instance); _destinationSqlConnection = (SqlConnection)destinationConnection.Connection; _logResultWriter = new LogResultWriter(addInfoMessage); _addInfoMessage = addInfoMessage; _destinationProvider = destinationProvider; _canConvertCommandToString = destinationProvider.CanConvertCommandToString; _destinationConnection = destinationConnection; _tableName = tableName; _setTransaction = setTransaction; _cancellationToken = cancellationToken; }
/// <summary> /// /// </summary> /// <param name="enumerator"></param> /// <param name="count"></param> /// <returns></returns> public static List <T> Take <T>(this IEnumerator <T> enumerator, int count) { Assert.IsNotNull(enumerator); FoundationContract.Requires <ArgumentOutOfRangeException>(count >= 0); var list = new List <T>(count); for (var i = 0; i < count; i++) { if (enumerator.MoveNext()) { var item = enumerator.Current; list.Add(item); } else { break; } } return(list); }
public static IEnumerable <STATPROPSETSTG> AsEnumerable(this IPropertySetStorage propertySetStorage) { FoundationContract.Requires <ArgumentException>(propertySetStorage != null); IEnumSTATPROPSETSTG enumStatPropSetStg; propertySetStorage.Enum(out enumStatPropSetStg); while (true) { var statPropSetStgArray = new STATPROPSETSTG[1]; uint fetched; enumStatPropSetStg.Next(1, statPropSetStgArray, out fetched); if (fetched == 0) { break; } yield return(statPropSetStgArray[0]); } }