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 = 0;
foreach (var func in keySelector)
{
if (i == 0)
{
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) <= 0)
{
continue;
}

if (!isMax && candidate.CompareTo(maxValue) > 0)
{
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[1];
// ReSharper disable once StringIndexOfIsCultureSpecific.2
int index = source.IndexOf(separator, 0);
if (index < 0)
{
strtmp[0] = source;
return strtmp;
}

strtmp[0] = source.Substring(0, 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 + 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;
}

strtmp[attachArray.Length] = source.Substring(0, 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(0, SeekOrigin.Begin);
retval = xml.Deserialize(ms);
ms.Close();
}

return (T)retval;
}

时间： 2024-12-13 21:06:42

Enumerable扩展方法的相关文章

C#的扩展方法解析

在使用面向对象的语言进行项目开发的过程中,较多的会使用到"继承"的特性,但是并非所有的场景都适合使用"继承"特性,在设计模式的一些基本原则中也有较多的提到. 继承的有关特性的使用所带来的问题:对象的继承关系实在编译时就定义好了,所以无法在运行时改变从父类继承的实现.子类的实现与它父类有非常紧密的依赖关系,以至于父类实现中的任何变化必然会导致子类发生变化.当你需要复用子类时,如果继承下来的实现不适合解决新的问题,则父类必须重写它或被其他更适合的类替换,这种依赖关系限制

ABP框架源码中的Linq扩展方法

文件目录:aspnetboilerplate-dev\aspnetboilerplate-dev\src\Abp\Collections\Extensions\EnumerableExtensions.cs using System; using System.Collections.Generic; using System.Linq; namespace Abp.Collections.Extensions { /// <summary> /// Extension methods for

23.C#Queryable的扩展方法(十二章12.1-12.2)

今天要写的知识还真心有点绕呢,对于第一节的内容,其实是把原先在内存中的数据源,换成了从数据库中提取出来的数据.从代码的使用方式上是一样的,直接跳过,来看看IEnumerable和IQueryable的区别. 正如Enumerable类型包含着关于IEnumerable<T>的扩展方法来实现LINQ标准查询操作符一样,Queryabl类型包含着关于IQueryable<T>的扩展方法.IEnumerable<T>和IQueryable<T>有两个重要的区别.

19.C#逐一介绍IEnumerable和IEnumerable&lt;T&gt;中的扩展方法(10.3-10.5)

今天没有太多的言语,只有代码,扩展方法多得太多,不能一一列完,书中一些,看多了也就会使用了. 1 //Enumerable.Range 返回起始到结束范围,是一个Enumrable<int>类型 2 //Range方法并不会真的构造含有适当数字的列表,它只是在恰当的时间生成那些数,"just in time" 3 var c0 = Enumerable.Range(1, 10); 4 foreach (var e in c0) 5 { 6 Console.WriteLine

【C#】详解使用Enumerable.Distinct方法去重

Enumerable.Distinct 方法 是常用的LINQ扩展方法,属于System.Linq的Enumerable方法,可用于去除数组.集合中的重复元素,还可以自定义去重的规则. 有两个重载方法: // // 摘要: // 通过使用默认的相等比较器对值进行比较返回序列中的非重复元素. // // 参数: // source: // 要从中移除重复元素的序列. // // 类型参数: // TSource: // source 中的元素的类型. // // 返回结果: // 一个 Syste

LINQ中的扩展方法

LINQ中的where(),OderByDescending().Select()并不是IEnumerable<T>的方法,却能使用这些方法,查阅了资料发现是用到了C#的扩展方法. 举个小例子: 定义一个静态类StringExtension和静态方法Foo,关键字this. public static class StringExtension { public static void Foo(this string s) { Console.WriteLine("Foo invok

扩展方法解决LinqToSql Contains超过2100行报错问题

1.扩展方法 using System; using System.Collections.Generic; using System.Linq; using System.Web; using System.Linq.Expressions; using System.Reflection; namespace Utils { //http://stackoverflow.com/questions/567963/linq-expression-to-return-property-value

Linq扩展方法获取单个元素

在使用Linq 提供的扩展方法时,First(OrDefault), Single(OrDefault), Last(OrDefault)都具有返回单个元素的功能.MSDN对这些方法的描述只有功能说明,没有关于内部的相关实现的描述说明. 首先我们来看下MSDN上关于这些扩展方法的官方描述: First: 返回序列中的第一个元素 . FirstOrDefault: 返回序列中的第一个元素:如果未找到元素,则返回默认值. Last:返回序列的最后一个元素. LastOrDefault: 返回序列中的

泛型集合的静态扩展方法

C# 中的泛型集合提供了很多基于 Enumerable 的静态扩展方法,例如  Find,  OrderBy , Average ,Distinct 等,在使用基础数据类型的集合时,可以直接调用这些方法,但如果是自定义类型就应当根据扩展方法所要求的接口,实现自定类型的扩展接口类,其实质就是使用扩展类的实例方法完成特定的操作逻辑,否则对集合的操作将是无效的.本文以 OrderBy 为例进行说明 . 首先需要一个自定义的类 ,这是一个表示自然人属性的简单类,列出了姓名.年龄和性别(这里使用了枚举类型