Enumerable扩展方法
主要记录一些平时在工作中用到操作Enumerable的常用方法
/// <summary>
/// The i enumerable extension.
/// </summary>
public static class IEnumerableExtension
{
#region Join
/// <summary>
/// 根据字符串拆分数组
/// </summary>
/// <param name="source">
/// 要拆分的数组
/// </param>
/// <param name="separator">
/// 拆分符
/// </param>
/// <returns>
/// 字符串
/// </returns>
public static string Join(this IEnumerable<string> source, string separator)
{
if (source == null)
{
throw new ArgumentNullException("source");
} if (separator == null)
{
throw new ArgumentNullException("separator");
} return source.Aggregate((x, y) => x + separator + y);
} /// <summary>
/// 根据字符串拆分数组
/// </summary>
/// <typeparam name="TSource">类型</typeparam>
/// <param name="soucre"> 要拆分的数组</param>
/// <param name="separator">拆分符</param>
/// <param name="map">拆分条件</param>
/// <returns>字符串 <see cref="string"/></returns>
public static string Join<TSource>(this IEnumerable<TSource> soucre, string separator, Func<TSource, string> map)
{
if (soucre == null)
{
throw new ArgumentNullException("source");
} if (separator == null)
{
throw new ArgumentNullException("separator");
} if (map == null)
{
throw new ArgumentNullException("map");
} var enumerable = soucre as TSource[] ?? soucre.ToArray();
return Join(enumerable.Select(map), separator);
}
#endregion #region Sort
/// <summary>
/// 多条件排序扩展方法
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="sources">sources</param>
/// <param name="keySelector">keySelector</param>
/// <returns>排序结果</returns>
public static IEnumerable<TSource> Sort<TSource>(this IEnumerable<TSource> sources, params KeyValuePair<bool, Func<TSource, object>>[] keySelector)
{
if (sources == null)
{
throw new ArgumentNullException("sources");
} IOrderedEnumerable<TSource> orderBys = null;
int i = ;
foreach (var func in keySelector)
{
if (i == )
{
orderBys = func.Key ? sources.OrderBy(func.Value) : sources.OrderByDescending(func.Value);
}
else
{
if (orderBys != null)
{
orderBys = func.Key ? orderBys.ThenBy(func.Value) : orderBys.ThenByDescending(func.Value);
}
} i++;
} return orderBys;
}
#endregion #region MaxElement
/// <summary>
/// 获取最大值的当前对象
/// </summary>
/// <typeparam name="TElement">TElement</typeparam>
/// <typeparam name="TData">TData</typeparam>
/// <param name="source">source</param>
/// <param name="selector">selector</param>
/// <returns>MaxValue</returns>
public static TElement MaxElement<TElement, TData>(this IEnumerable<TElement> source, Func<TElement, TData> selector)
where TData : IComparable<TData>
{
return ComparableElement(source, selector, true);
}
#endregion #region MinElement
/// <summary>
/// 获取最小值的当前对象
/// </summary>
/// <typeparam name="TElement">TElement</typeparam>
/// <typeparam name="TData">TData</typeparam>
/// <param name="source">source</param>
/// <param name="selector">selector</param>
/// <returns>MaxValue</returns>
public static TElement MinElement<TElement, TData>(this IEnumerable<TElement> source, Func<TElement, TData> selector)
where TData : IComparable<TData>
{
return ComparableElement(source, selector, false);
}
#endregion #region Max
/// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static decimal Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, decimal> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static double Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, double> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static int Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, int> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static long Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, long> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static float Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, float> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static decimal? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, decimal?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static double? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, double?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static int? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, int?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static long? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, long?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
} /// <summary>
/// 求最大值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最大值</returns>
public static float? Max<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, float?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Max();
}
#endregion #region Min
/// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static decimal Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, decimal> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static double Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, double> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static int Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, int> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static long Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, long> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static float Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, float> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static decimal? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, decimal?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static double? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, double?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static int? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, int?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static long? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, long?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
} /// <summary>
/// 求最小值
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>最小值</returns>
public static float? Min<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, float?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Min();
}
#endregion #region Sum
/// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static decimal Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, decimal> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static double Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, double> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, int> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static long Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, long> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static float Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, float> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static decimal? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, decimal?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum(result => result.GetValueOrDefault());
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static double? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, double?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static int? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, int?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static long? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, long?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} /// <summary>
/// 求和
/// </summary>
/// <typeparam name="TSource">TSource</typeparam>
/// <param name="source">source</param>
/// <param name="predicate">predicate</param>
/// <param name="selector">selector</param>
/// <returns>和</returns>
public static float? Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, float?> selector)
{
if (source == null)
{
throw new ArgumentNullException("source");
} return source.Where(predicate).Select(selector).Sum();
} #endregion #region private
/// <summary>
/// 获取最大or最小值的当前对象
/// </summary>
/// <typeparam name="TElement">TElement</typeparam>
/// <typeparam name="TData">TData</typeparam>
/// <param name="source">source</param>
/// <param name="selector">selector</param>
/// <param name="isMax">最大还是最小</param>
/// <returns>MaxValue</returns>
private static TElement ComparableElement<TElement, TData>(IEnumerable<TElement> source, Func<TElement, TData> selector, bool isMax)
where TData : IComparable<TData>
{
if (source == null)
{
throw new ArgumentNullException("source");
} if (selector == null)
{
throw new ArgumentNullException("selector");
} bool firstElement = true;
TElement result = default(TElement);
TData maxValue = default(TData);
foreach (TElement element in source)
{
var candidate = selector(element);
if (!firstElement)
{
if (isMax && candidate.CompareTo(maxValue) <= )
{
continue;
} if (!isMax && candidate.CompareTo(maxValue) > )
{
continue;
}
} firstElement = false;
maxValue = candidate;
result = element;
} return result;
}
#endregion #region 拆分字符串
/// <summary>
/// 根据字符串拆分字符串
/// </summary>
/// <param name="source">要拆分的字符串</param>
/// <param name="separator">拆分符</param>
/// <returns>数组</returns>
public static string[] Split(this string source, string separator)
{
if (source == null)
{
throw new ArgumentNullException("source");
} if (separator == null)
{
throw new ArgumentNullException("separator");
} string[] strtmp = new string[];
// ReSharper disable once StringIndexOfIsCultureSpecific.2
int index = source.IndexOf(separator, );
if (index < )
{
strtmp[] = source;
return strtmp;
} strtmp[] = source.Substring(, index);
return Split(source.Substring(index + separator.Length), separator, strtmp);
} /// <summary>
/// 采用递归将字符串分割成数组
/// </summary>
/// <param name="source">要拆分的字符串</param>
/// <param name="separator">拆分符</param>
/// <param name="attachArray">attachArray</param>
/// <returns>string[]</returns>
private static string[] Split(string source, string separator, string[] attachArray)
{
// while循环的方式
while (true)
{
string[] strtmp = new string[attachArray.Length + ];
attachArray.CopyTo(strtmp, ); // ReSharper disable once StringIndexOfIsCultureSpecific.2
int index = source.IndexOf(separator, );
if (index < )
{
strtmp[attachArray.Length] = source;
return strtmp;
} strtmp[attachArray.Length] = source.Substring(, index);
source = source.Substring(index + separator.Length);
attachArray = strtmp;
} // 递归的方式
/*
string[] strtmp = new string[attachArray.Length + 1];
attachArray.CopyTo(strtmp, 0); // ReSharper disable once StringIndexOfIsCultureSpecific.2
int index = source.IndexOf(separator, 0);
if (index < 0)
{
strtmp[attachArray.Length] = source;
return strtmp;
}
else
{
strtmp[attachArray.Length] = source.Substring(0, index);
return Split(source.Substring(index + separator.Length), separator, strtmp);
}*/
} #endregion /// <summary>
/// JavaScript方式序列化json
/// </summary>
/// <param name="obj">输出对象</param>
/// <returns>JSON字符串</returns>
public static string Serialization(this object obj)
{
JavaScriptSerializer json = new JavaScriptSerializer();
return json.Serialize(obj);
} /// <summary>
/// 获取Json的Model(反序列化)
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="json">json字符串</param>
/// <returns>T对象</returns>
public static T Deserializ<T>(this string json)
{
T t = default(T);
try
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
return serializer.Deserialize<T>(json);
}
catch (Exception)
{
return t;
}
} /// <summary>
/// XML序列化方式深复制
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="obj">复制对象</param>
/// <returns>结果</returns>
public static T DeepCopy<T>(this T obj)
{
object retval;
using (MemoryStream ms = new MemoryStream())
{
XmlSerializer xml = new XmlSerializer(typeof(T));
xml.Serialize(ms, obj);
ms.Seek(, SeekOrigin.Begin);
retval = xml.Deserialize(ms);
ms.Close();
} return (T)retval;
}
}
Enumerable扩展方法的更多相关文章
- Enumerable 下又有新的扩展方法啦，快来一起一睹为快吧
一:背景 1. 讲故事 前段时间将公司的一个项目从 4.5 升级到了 framework 4.8 ,编码的时候发现 Enumerable 中多了三个扩展方法: Append, Prepend, ToH ...
- 为IEnumerable<T>添加RemoveAll<IEnumerable<T>>扩展方法--高性能篇
最近写代码,遇到一个问题,微软基于List<T>自带的方法是public bool Remove(T item);,可是有时候我们可能会用到诸如RemoveAll<IEnumerab ...
- C#的扩展方法解析
在使用面向对象的语言进行项目开发的过程中,较多的会使用到“继承”的特性,但是并非所有的场景都适合使用“继承”特性,在设计模式的一些基本原则中也有较多的提到. 继承的有关特性的使用所带来的问题:对象的继 ...
- 扩展方法解决LinqToSql Contains超过2100行报错问题
1.扩展方法 using System; using System.Collections.Generic; using System.Linq; using System.Web; using Sy ...
- .NET中那些所谓的新语法之二：匿名类、匿名方法与扩展方法
开篇:在上一篇中,我们了解了自动属性.隐式类型.自动初始化器等所谓的新语法,这一篇我们继续征程,看看匿名类.匿名方法以及常用的扩展方法.虽然,都是很常见的东西,但是未必我们都明白其中蕴含的奥妙.所以, ...
- c# 扩展方法奇思妙用基础篇八：Distinct 扩展（转载）
转载地址:http://www.cnblogs.com/ldp615/archive/2011/08/01/distinct-entension.html 刚看了篇文章 <Linq的Distin ...
- c# 扩展方法奇思妙用
# 扩展方法出来已久,介绍扩展方法的文章也很多,但都是笼统的.本人最近一直在思考扩展方法的应用,也悟出了一些,准备将这最近一段时间对扩展方法的思考,写成一个系列文章.每个文章只介绍一个应用方面,篇幅不 ...
- 23.C#Queryable的扩展方法(十二章12.1-12.2)
今天要写的知识还真心有点绕呢,对于第一节的内容,其实是把原先在内存中的数据源,换成了从数据库中提取出来的数据.从代码的使用方式上是一样的,直接跳过,来看看IEnumerable和IQueryable的 ...
- 19.C#逐一介绍IEnumerable和IEnumerable<T>中的扩展方法(10.3-10.5)
今天没有太多的言语,只有代码,扩展方法多得太多,不能一一列完,书中一些,看多了也就会使用了. //Enumerable.Range 返回起始到结束范围,是一个Enumrable<int>类 ...
随机推荐
- Razor中的@:和语法
用Razor实现流畅编程 Razor尽量减少编写一个视图模板需要敲入的字符数,实现快速流畅的编程工作流.与大部分模板的语法不同,你不必在HTML中为了明确地标记出服务模块 的开始和结束而中断编程.Ra ...
- docker 批量删除容器和镜像
docker 批量删除容器和镜像 1,删除单个镜像或者容器 docker rmi 镜像ID/镜像名字:TAG docker rm 容器ID/容器名字 1.停止所有的container,这样才能 ...
- selenium webdriver显示等待时间
当页面加载很慢时,推荐使用显示等待:等到需要操作的那个元素加载成功之后就直接操作这个元素,不需要等待其他元素的加载 WebDriverWait wait = new WebDriverWait(dri ...
- 第三章基本的SQl查询语言
---恢复内容开始--- ---恢复内容结束---
- 019-centos的yum用法
1.检测系统是否已经安装过mysql或其依赖:# yum list installed | grep mysql(当然也可以用 rpm -qa | grep mysql) 2.卸载已经存在的mysql ...
- Filter—过滤器
过滤器的作用是什么? 1.拦截传入的请求和传出的响应,能拿到请求和响应中的数据 2.监视,修改,或处理正在客户端和服务器之间交换的数据流 3.利用过滤器的执行时机,实现Web程序的预处理,和后期的处 ...
- wkhtmtopdf--高分辨率HTML转PDF（二）
命令行 wkhtmtopdf有一些很实用的命令,平时如果不用代码,可以直接使用命令行来把你喜欢的任意网页转换为PDF, 命令行参考网址:http://madalgo.au.dk/~jakobt/wkh ...
- 710 Random Pick with Blacklist
1. 问题 给定一个黑名单,包含[0, N)的一些数,从[0, N)之间的非黑名单数中随机采样一个值. 2. 思路 字典映射 (1)计算黑名单数的长度,记作B,因为已经排除掉了B个元素,所以最后是从N ...
- python认识快速入门（一）
接下来的一个多月开始学习python,在记录这些随笔的同时,如果你们能看到,希望能帮助到你们,如果有错误也请你们给指教! 主要记录的是对python的一个整体认识. 1.print 语句及“Hello ...
- Js基础知识7-JavaScript所有内置对象属性和方法汇总
对象什么的,程序员可是有很多呢... JS三大对象 对象,是任何一个开发者都无法绕开和逃避的话题,她似乎有些深不可测,但如此伟大和巧妙的存在,一定值得你去摸索.发现.征服. 我们都知道,JavaScr ...