/// <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]);
}
}
