Phương pháp mở rộng yêu thích của bạn cho C # là gì? (codeplex.com/extensionoverflow)

Hãy tạo một danh sách các câu trả lời nơi bạn đăng các phương thức mở rộng tuyệt vời và yêu thích của mình .

Yêu cầu là mã đầy đủ phải được đăng và một ví dụ và giải thích về cách sử dụng nó.

Dựa trên sự quan tâm cao độ trong chủ đề này, tôi đã thiết lập Dự án nguồn mở có tên là phần mở rộng trên Codeplex .

Vui lòng đánh dấu câu trả lời của bạn với sự chấp nhận để đặt mã trong dự án Codeplex.

Xin vui lòng gửi mã nguồn đầy đủ và không phải là một liên kết.

Tin tức Codeplex:

24.08.2010 Trang Codeplex hiện có tại đây: http://extensionoverflow.codeplex.com/

11.11.2008 XmlSerialize / XmlDeserialize hiện được triển khai và thử nghiệm đơn vị .

11.11.2008 Vẫn còn chỗ cho nhiều nhà phát triển hơn. ;-) Tham gia NGAY!

11.11.2008 Người đóng góp thứ ba đã tham gia ExtensionOverflow , chào mừng bạn đến với BKristensen

11.11.2008 FormatWith hiện được triển khai và thử nghiệm đơn vị .

09.11.2008 Người đóng góp thứ hai đã tham gia ExtensionOverflow . Chào mừng đến với chakrit .

09.11.2008 Chúng tôi cần nhiều nhà phát triển hơn. ;-)

09.11.2008 Ném IfArgumentIsNull ngay bây giờ Đã triển khai và Đơn vị được thử nghiệm trên Codeplex.

public static bool In<T>(this T source, params T[] list)
{
  if(null==source) throw new ArgumentNullException("source");
  return list.Contains(source);
}

Cho phép tôi thay thế:

if(reallyLongIntegerVariableName == 1 || 
    reallyLongIntegerVariableName == 6 || 
    reallyLongIntegerVariableName == 9 || 
    reallyLongIntegerVariableName == 11)
{
  // do something....
}

and

if(reallyLongStringVariableName == "string1" || 
    reallyLongStringVariableName == "string2" || 
    reallyLongStringVariableName == "string3")
{
  // do something....
}

and

if(reallyLongMethodParameterName == SomeEnum.Value1 || 
    reallyLongMethodParameterName == SomeEnum.Value2 || 
    reallyLongMethodParameterName == SomeEnum.Value3 || 
    reallyLongMethodParameterName == SomeEnum.Value4)
{
  // do something....
}

Với:

if(reallyLongIntegerVariableName.In(1,6,9,11))
{
      // do something....
}

and

if(reallyLongStringVariableName.In("string1","string2","string3"))
{
      // do something....
}

and

if(reallyLongMethodParameterName.In(SomeEnum.Value1, SomeEnum.Value2, SomeEnum.Value3, SomeEnum.Value4)
{
  // do something....
}

Tôi có nhiều phương thức mở rộng khác nhau trong dự án MiscUtil của mình (nguồn đầy đủ có sẵn ở đó - Tôi sẽ không lặp lại ở đây). Mục ưa thích của tôi, một số trong đó liên quan đến các lớp khác (chẳng hạn như phạm vi):

Ngày và thời gian thứ - chủ yếu cho các bài kiểm tra đơn vị. Không chắc chắn tôi sẽ sử dụng chúng trong sản xuất :)

var birthday = 19.June(1976);
var workingDay = 7.Hours() + 30.Minutes();

Phạm vi và bước tiến - rất lớn nhờ Marc Gravell cho công cụ điều hành của mình để thực hiện điều này có thể:

var evenNaturals = 2.To(int.MaxValue).Step(2);
var daysSinceBirth = birthday.To(DateTime.Today).Step(1.Days());

So sánh:

var myComparer = ProjectionComparer.Create(Person p => p.Name);
var next = myComparer.ThenBy(p => p.Age);
var reversed = myComparer.Reverse();

Kiểm tra đối số:

x.ThrowIfNull("x");

LINQ to XML được áp dụng cho các loại ẩn danh (hoặc các loại khác có thuộc tính phù hợp):

// <Name>Jon</Name><Age>32</Age>
new { Name="Jon", Age=32}.ToXElements();
// Name="Jon" Age="32" (as XAttributes, obviously)
new { Name="Jon", Age=32}.ToXAttributes()

Đẩy LINQ - sẽ mất quá nhiều thời gian để giải thích ở đây, nhưng hãy tìm kiếm nó.

chuỗi. Phím tắt định dạng:

public static class StringExtensions
{
    // Enable quick and more natural string.Format calls
    public static string F(this string s, params object[] args)
    {
        return string.Format(s, args);
    }
}

Thí dụ:

var s = "The co-ordinate is ({0}, {1})".F(point.X, point.Y);

Để sao chép và dán nhanh chóng vào đây .

Bạn không thấy nó tự nhiên hơn để gõ "some string".F("param")thay vì string.Format("some string", "param")?

Để có tên dễ đọc hơn , hãy thử một trong những gợi ý sau:

s = "Hello {0} world {1}!".Fmt("Stack", "Overflow");
s = "Hello {0} world {1}!".FormatBy("Stack", "Overflow");
s = "Hello {0} world {1}!".FormatWith("Stack", "Overflow");
s = "Hello {0} world {1}!".Display("Stack", "Overflow");
s = "Hello {0} world {1}!".With("Stack", "Overflow");

..

Đây có phải là bất kỳ sử dụng?

public static bool CoinToss(this Random rng)
{
    return rng.Next(2) == 0;
}

public static T OneOf<T>(this Random rng, params T[] things)
{
    return things[rng.Next(things.Length)];
}

Random rand;
bool luckyDay = rand.CoinToss();
string babyName = rand.OneOf("John", "George", "Radio XBR74 ROCKS!");

public static class ComparableExtensions
{
  public static bool Between<T>(this T actual, T lower, T upper) where T : IComparable<T>
  {
    return actual.CompareTo(lower) >= 0 && actual.CompareTo(upper) < 0;
  }
}

Thí dụ:

if (myNumber.Between(3,7))
{
  // ....
}

Phương pháp mở rộng:

public static void AddRange<T, S>(this ICollection<T> list, params S[] values)
    where S : T
{
    foreach (S value in values)
        list.Add(value);
}

Phương pháp áp dụng cho tất cả các loại và cho phép bạn thêm một loạt các mục vào danh sách dưới dạng tham số.

Thí dụ:

var list = new List<Int32>();
list.AddRange(5, 4, 8, 4, 2);

Bằng mọi cách đặt điều này trong dự án codeplex.

Các đối tượng tuần tự hóa / giải tuần tự hóa thành XML:

/// <summary>Serializes an object of type T in to an xml string</summary>
/// <typeparam name="T">Any class type</typeparam>
/// <param name="obj">Object to serialize</param>
/// <returns>A string that represents Xml, empty otherwise</returns>
public static string XmlSerialize<T>(this T obj) where T : class, new()
{
    if (obj == null) throw new ArgumentNullException("obj");

    var serializer = new XmlSerializer(typeof(T));
    using (var writer = new StringWriter())
    {
        serializer.Serialize(writer, obj);
        return writer.ToString();
    }
}

/// <summary>Deserializes an xml string in to an object of Type T</summary>
/// <typeparam name="T">Any class type</typeparam>
/// <param name="xml">Xml as string to deserialize from</param>
/// <returns>A new object of type T is successful, null if failed</returns>
public static T XmlDeserialize<T>(this string xml) where T : class, new()
{
    if (xml == null) throw new ArgumentNullException("xml");

    var serializer = new XmlSerializer(typeof(T));
    using (var reader = new StringReader(xml))
    {
        try { return (T)serializer.Deserialize(reader); }
        catch { return null; } // Could not be deserialized to this type.
    }
}

ForEach cho IEnumerables

public static class FrameworkExtensions
{
    // a map function
    public static void ForEach<T>(this IEnumerable<T> @enum, Action<T> mapFunction)
    {
        foreach (var item in @enum) mapFunction(item);
    }
}

Ví dụ ngây thơ:

var buttons = GetListOfButtons() as IEnumerable<Button>;

// click all buttons
buttons.ForEach(b => b.Click());

Ví dụ tuyệt vời:

// no need to type the same assignment 3 times, just
// new[] up an array and use foreach + lambda
// everything is properly inferred by csc :-)
new { itemA, itemB, itemC }
    .ForEach(item => {
        item.Number = 1;
        item.Str = "Hello World!";
    });

Ghi chú:

Điều này là không thích Selectbởi vì Select hy vọng chức năng của bạn sẽ trả về một cái gì đó như để chuyển đổi sang một danh sách khác.

ForEach chỉ đơn giản cho phép bạn thực thi một cái gì đó cho mỗi mục mà không có bất kỳ biến đổi / thao tác dữ liệu nào.

Tôi đã thực hiện điều này để tôi có thể lập trình theo phong cách chức năng hơn và tôi đã ngạc nhiên khi Danh sách có ForEach trong khi IEnumerable thì không.

Đặt điều này trong dự án codeplex

Tiện ích mở rộng chuyển đổi của tôi cho phép bạn thực hiện:

int i = myString.To<int>();

Đây là, như được đăng trên TheSoftwareJedi.com

public static T To<T>(this IConvertible obj)
{
  return (T)Convert.ChangeType(obj, typeof(T));
}

public static T ToOrDefault<T>
             (this IConvertible obj)
{
    try
    {
        return To<T>(obj);
    }
    catch
    {
        return default(T);
    }
}

public static bool ToOrDefault<T>
                    (this IConvertible obj,
                     out T newObj)
{
    try
    {
        newObj = To<T>(obj); 
        return true;
    }
    catch
    {
        newObj = default(T); 
        return false;
    }
}

public static T ToOrOther<T>
                       (this IConvertible obj,
                       T other)
{
  try
  {
      return To<T>obj);
  }
  catch
  {
      return other;
  }
}

public static bool ToOrOther<T>
                         (this IConvertible obj,
                         out T newObj,
                         T other)
{
    try
    {
        newObj = To<T>(obj);
        return true;
    }
    catch
    {
        newObj = other;
        return false;
    }
}

public static T ToOrNull<T>
                      (this IConvertible obj)
                      where T : class
{
    try
    {
        return To<T>(obj);
    }
    catch
    {
        return null;
    }
}

public static bool ToOrNull<T>
                  (this IConvertible obj,
                  out T newObj)
                  where T : class
{
    try
    {
        newObj = To<T>(obj);
        return true;
    }
    catch
    {
        newObj = null;
        return false;
    }
}

Bạn có thể yêu cầu mặc định (gọi hàm tạo trống hoặc "0" cho số) khi không thành công, chỉ định giá trị "mặc định" (tôi gọi nó là "khác") hoặc yêu cầu null (trong đó lớp T:). Tôi cũng đã cung cấp cả các mô hình ngoại lệ im lặng và một mô hình TryPude điển hình trả về một bool chỉ ra hành động được thực hiện và một tham số ngoài giữ giá trị mới. Vì vậy, mã của chúng tôi có thể làm những việc như thế này

int i = myString.To<int>();
string a = myInt.ToOrDefault<string>();
//note type inference
DateTime d = myString.ToOrOther(DateTime.MAX_VALUE);
double d;
//note type inference
bool didItGiveDefault = myString.ToOrDefault(out d);
string s = myDateTime.ToOrNull<string>();

Tôi không thể có được các loại Nullable để cuộn vào toàn bộ mọi thứ rất sạch sẽ. Tôi đã thử trong khoảng 20 phút trước khi ném vào khăn.

Tôi có một phương pháp mở rộng để ghi lại các ngoại lệ:

public static void Log(this Exception obj)
{
  //your logging logic here
}

Và nó được sử dụng như thế này:

try
{
    //Your stuff here
}
catch(Exception ex)
{
    ex.Log();
}

[xin lỗi vì đã đăng hai lần; cái thứ 2 được thiết kế tốt hơn :-)]

public static class StringExtensions {

    /// <summary>
    /// Parses a string into an Enum
    /// </summary>
    /// <typeparam name="T">The type of the Enum</typeparam>
    /// <param name="value">String value to parse</param>
    /// <returns>The Enum corresponding to the stringExtensions</returns>
    public static T EnumParse<T>(this string value) {
        return StringExtensions.EnumParse<T>(value, false);
    }

    public static T EnumParse<T>(this string value, bool ignorecase) {

        if (value == null) {
            throw new ArgumentNullException("value");
        }

        value = value.Trim();

        if (value.Length == 0) {
            throw new ArgumentException("Must specify valid information for parsing in the string.", "value");
        }

        Type t = typeof(T);

        if (!t.IsEnum) {
            throw new ArgumentException("Type provided must be an Enum.", "T");
        }

        return (T)Enum.Parse(t, value, ignorecase);
    }
}

Hữu ích để phân tích một chuỗi thành một Enum.

public enum TestEnum
{
    Bar,
    Test
}

public class Test
{
    public void Test()
    {
        TestEnum foo = "Test".EnumParse<TestEnum>();
    }
 }

Tín dụng cho Scott Dorman

--- Chỉnh sửa cho dự án Codeplex ---

Tôi đã hỏi Scott Dorman rằng anh ấy có phiền chúng tôi xuất bản mã của anh ấy trong dự án Codeplex không. Đây là câu trả lời tôi nhận được từ anh ấy:

Cảm ơn bạn đã ủng hộ cả bài SO và dự án CodePlex. Tôi đã nâng cao câu trả lời của bạn cho câu hỏi. Có, mã này có hiệu quả trong phạm vi công cộng hiện tại theo Giấy phép mở CodeProject ( http://www.codeproject.com/info/cpol10.aspx ).

Tôi không có vấn đề gì với việc này được bao gồm trong dự án CodePlex và nếu bạn muốn thêm tôi vào dự án (tên người dùng là sdorman) tôi sẽ thêm phương thức đó cộng với một số phương thức trợ giúp enum bổ sung.

Tôi thấy cái này khá hữu ích:

public static class PaulaBean
{
    private static String paula = "Brillant";
    public static String GetPaula<T>(this T obj) {
        return paula;
    }
}

Bạn có thể sử dụng nó trên CodePlex.

DateTimeExtensions

Ví dụ:

DateTime firstDayOfMonth = DateTime.Now.First();
DateTime lastdayOfMonth = DateTime.Now.Last();
DateTime lastFridayInMonth = DateTime.Now.Last(DayOfWeek.Friday);
DateTime nextFriday = DateTime.Now.Next(DayOfWeek.Friday);
DateTime lunchTime = DateTime.Now.SetTime(11, 30);
DateTime noonOnFriday = DateTime.Now.Next(DayOfWeek.Friday).Noon();
DateTime secondMondayOfMonth = DateTime.Now.First(DayOfWeek.Monday).Next(DayOfWeek.Monday).Midnight();

gitorious.org/cadenza là một thư viện đầy đủ của một số phương pháp mở rộng hữu ích nhất mà tôi đã thấy.

Đây là một cái tôi sử dụng thường xuyên để định dạng trình bày.

public static string ToTitleCase(this string mText)
{
    if (mText == null) return mText;

    System.Globalization.CultureInfo cultureInfo = System.Threading.Thread.CurrentThread.CurrentCulture;
    System.Globalization.TextInfo textInfo = cultureInfo.TextInfo;

    // TextInfo.ToTitleCase only operates on the string if is all lower case, otherwise it returns the string unchanged.
    return textInfo.ToTitleCase(mText.ToLower());
}

Đây là một và từ cho các chữ số La Mã. Không thường xuyên được sử dụng, nhưng có thể có ích. Sử dụng:

if ("IV".IsValidRomanNumeral())
{
   // Do useful stuff with the number 4.
}

Console.WriteLine("MMMDCCCLXXXVIII".ParseRomanNumeral());
Console.WriteLine(3888.ToRomanNumeralString());

Nguồn:

    public static class RomanNumeralExtensions
    {
        private const int NumberOfRomanNumeralMaps = 13;

        private static readonly Dictionary<string, int> romanNumerals =
            new Dictionary<string, int>(NumberOfRomanNumeralMaps)
            {
                { "M", 1000 }, 
                { "CM", 900 }, 
                { "D", 500 }, 
                { "CD", 400 }, 
                { "C", 100 }, 
                { "XC", 90 }, 
                { "L", 50 }, 
                { "XL", 40 }, 
                { "X", 10 }, 
                { "IX", 9 }, 
                { "V", 5 }, 
                { "IV", 4 }, 
                { "I", 1 }
            };

        private static readonly Regex validRomanNumeral = new Regex(
            "^(?i:(?=[MDCLXVI])((M{0,3})((C[DM])|(D?C{0,3}))"
            + "?((X[LC])|(L?XX{0,2})|L)?((I[VX])|(V?(II{0,2}))|V)?))$", 
            RegexOptions.Compiled);

        public static bool IsValidRomanNumeral(this string value)
        {
            return validRomanNumeral.IsMatch(value);
        }

        public static int ParseRomanNumeral(this string value)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            value = value.ToUpperInvariant().Trim();

            var length = value.Length;

            if ((length == 0) || !value.IsValidRomanNumeral())
            {
                throw new ArgumentException("Empty or invalid Roman numeral string.", "value");
            }

            var total = 0;
            var i = length;

            while (i > 0)
            {
                var digit = romanNumerals[value[--i].ToString()];

                if (i > 0)
                {
                    var previousDigit = romanNumerals[value[i - 1].ToString()];

                    if (previousDigit < digit)
                    {
                        digit -= previousDigit;
                        i--;
                    }
                }

                total += digit;
            }

            return total;
        }

        public static string ToRomanNumeralString(this int value)
        {
            const int MinValue = 1;
            const int MaxValue = 3999;

            if ((value < MinValue) || (value > MaxValue))
            {
                throw new ArgumentOutOfRangeException("value", value, "Argument out of Roman numeral range.");
            }

            const int MaxRomanNumeralLength = 15;
            var sb = new StringBuilder(MaxRomanNumeralLength);

            foreach (var pair in romanNumerals)
            {
                while (value / pair.Value > 0)
                {
                    sb.Append(pair.Key);
                    value -= pair.Value;
                }
            }

            return sb.ToString();
        }
    }

Một cách thuận tiện để đối phó với kích thước:

public static class Extensions {
    public static int K(this int value) {
        return value * 1024;
    }
    public static int M(this int value) {
        return value * 1024 * 1024;
    }
}

public class Program {
    public void Main() {
        WSHttpContextBinding serviceMultipleTokenBinding = new WSHttpContextBinding() {
            MaxBufferPoolSize = 2.M(), // instead of 2097152
            MaxReceivedMessageSize = 64.K(), // instead of 65536
        };
    }
}

Đối với điều khiển Winform:

/// <summary>
/// Returns whether the function is being executed during design time in Visual Studio.
/// </summary>
public static bool IsDesignTime(this Control control)
{
    if (LicenseManager.UsageMode == LicenseUsageMode.Designtime)
    {
        return true;
    }

    if (control.Site != null && control.Site.DesignMode)
    {
        return true;
    }

    var parent = control.Parent;
    while (parent != null)
    {
        if (parent.Site != null && parent.Site.DesignMode)
        {
            return true;
        }
        parent = parent.Parent;
    }
    return false;
}

/// <summary>
/// Sets the DropDownWidth to ensure that no item's text is cut off.
/// </summary>
public static void SetDropDownWidth(this ComboBox comboBox)
{
    var g = comboBox.CreateGraphics();
    var font = comboBox.Font;
    float maxWidth = 0;

    foreach (var item in comboBox.Items)
    {
        maxWidth = Math.Max(maxWidth, g.MeasureString(item.ToString(), font).Width);
    }

    if (comboBox.Items.Count > comboBox.MaxDropDownItems)
    {
        maxWidth += SystemInformation.VerticalScrollBarWidth;
    }

    comboBox.DropDownWidth = Math.Max(comboBox.Width, Convert.ToInt32(maxWidth));
}

Cách sử dụng IsDesignTime:

public class SomeForm : Form
{
    public SomeForm()
    {
        InitializeComponent();

        if (this.IsDesignTime())
        {
            return;
        }

        // Do something that makes the visual studio crash or hang if we're in design time,
        // but any other time executes just fine
    }
}

Cách sử dụng SetDropdownWidth:

ComboBox cbo = new ComboBox { Width = 50 };
cbo.Items.Add("Short");
cbo.Items.Add("A little longer");
cbo.Items.Add("Holy cow, this is a really, really long item. How in the world will it fit?");
cbo.SetDropDownWidth();

Tôi quên đề cập đến, cứ thoải mái sử dụng những thứ này trên Codeplex ...

Throw IfArgumentIsNull là một cách hay để kiểm tra null mà tất cả chúng ta nên làm.

public static class Extensions
{
    public static void ThrowIfArgumentIsNull<T>(this T obj, string parameterName) where T : class
    {
        if (obj == null) throw new ArgumentNullException(parameterName + " not allowed to be null");
    }
}

Dưới đây là cách sử dụng nó và nó hoạt động trên tất cả các lớp trong không gian tên của bạn hoặc bất cứ nơi nào bạn sử dụng không gian tên bên trong nó.

internal class Test
{
    public Test(string input1)
    {
        input1.ThrowIfArgumentIsNull("input1");
    }
}

Bạn có thể sử dụng mã này trong dự án CodePlex .

Tôi nhớ câu lệnh With của Visual Basic khi chuyển sang C #, vì vậy nó sẽ xuất hiện:

public static void With<T>(this T obj, Action<T> act) { act(obj); }

Và đây là cách sử dụng nó trong C #:

someVeryVeryLonggggVariableName.With(x => {
    x.Int = 123;
    x.Str = "Hello";
    x.Str2 = " World!";
});

Tiết kiệm rất nhiều gõ!

So sánh điều này với:

someVeryVeryLonggggVariableName.Int = 123;
someVeryVeryLonggggVariableName.Str = "Hello";
someVeryVeryLonggggVariableName.Str2 = " World!";

đưa vào dự án codeplex

Lấy một con lạc đàCaseWord hoặc PascalCaseWord và "diễn đạt" nó, tức là camelCaseWord => lạc đà Word

public static string Wordify( this string camelCaseWord )
{
    // if the word is all upper, just return it
    if( !Regex.IsMatch( camelCaseWord, "[a-z]" ) )
        return camelCaseWord;

    return string.Join( " ", Regex.Split( camelCaseWord, @"(?<!^)(?=[A-Z])" ) );
}

Tôi thường sử dụng nó trong kết hợp với Capitalize

public static string Capitalize( this string word )
{
    return word[0].ToString( ).ToUpper( ) + word.Substring( 1 );
}

Ví dụ sử dụng

SomeEntityObject entity = DataAccessObject.GetSomeEntityObject( id );
List<PropertyInfo> properties = entity.GetType().GetPublicNonCollectionProperties( );

// wordify the property names to act as column headers for an html table or something
List<string> columns = properties.Select( p => p.Name.Capitalize( ).Wordify( ) ).ToList( );

Miễn phí sử dụng trong dự án codeplex

Tôi thấy cái này hữu ích

public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> pSeq)
{
    return pSeq ?? Enumerable.Empty<T>();
}

Nó loại bỏ kiểm tra null trong mã gọi. Bây giờ bạn có thể làm

MyList.EmptyIfNull().Where(....)

Chuyển đổi một chuỗi thành chuỗi được định dạng bằng văn hóa đã chỉ định:

public static class ExtensionMethods 
{
  public static string ToCurrency(this double value, string cultureName)
  {
    CultureInfo currentCulture = new CultureInfo(cultureName);
    return (string.Format(currentCulture, "{0:C}", value));
  }
}

Thí dụ:

double test = 154.20;
string testString = test.ToCurrency("en-US"); // $154.20

Dưới đây là một phương pháp mở rộng điều chỉnh mã của Rick Strahl (và cả các nhận xét) để ngăn bạn phải đoán hoặc đọc dấu thứ tự byte của một mảng byte hoặc tệp văn bản mỗi khi bạn chuyển đổi nó thành một chuỗi.

Đoạn mã cho phép bạn chỉ cần làm:

byte[] buffer = File.ReadAllBytes(@"C:\file.txt");
string content = buffer.GetString();

Nếu bạn tìm thấy bất kỳ lỗi xin vui lòng thêm vào các ý kiến. Hãy đưa nó vào dự án Codeplex.

public static class Extensions
{
    /// <summary>
    /// Converts a byte array to a string, using its byte order mark to convert it to the right encoding.
    /// Original article: http://www.west-wind.com/WebLog/posts/197245.aspx
    /// </summary>
    /// <param name="buffer">An array of bytes to convert</param>
    /// <returns>The byte as a string.</returns>
    public static string GetString(this byte[] buffer)
    {
        if (buffer == null || buffer.Length == 0)
            return "";

        // Ansi as default
        Encoding encoding = Encoding.Default;       

        /*
            EF BB BF    UTF-8 
            FF FE UTF-16    little endian 
            FE FF UTF-16    big endian 
            FF FE 00 00 UTF-32, little endian 
            00 00 FE FF UTF-32, big-endian 
         */

        if (buffer[0] == 0xef && buffer[1] == 0xbb && buffer[2] == 0xbf)
            encoding = Encoding.UTF8;
        else if (buffer[0] == 0xfe && buffer[1] == 0xff)
            encoding = Encoding.Unicode;
        else if (buffer[0] == 0xfe && buffer[1] == 0xff)
            encoding = Encoding.BigEndianUnicode; // utf-16be
        else if (buffer[0] == 0 && buffer[1] == 0 && buffer[2] == 0xfe && buffer[3] == 0xff)
            encoding = Encoding.UTF32;
        else if (buffer[0] == 0x2b && buffer[1] == 0x2f && buffer[2] == 0x76)
            encoding = Encoding.UTF7;

        using (MemoryStream stream = new MemoryStream())
        {
            stream.Write(buffer, 0, buffer.Length);
            stream.Seek(0, SeekOrigin.Begin);
            using (StreamReader reader = new StreamReader(stream, encoding))
            {
                return reader.ReadToEnd();
            }
        }
    }
}

Đây là một cái tôi vừa tạo hôm nay.

// requires .NET 4

public static TReturn NullOr<TIn, TReturn>(this TIn obj, Func<TIn, TReturn> func,
        TReturn elseValue = default(TReturn)) where TIn : class
    { return obj != null ? func(obj) : elseValue; }

// versions for CLR 2, which doesn't support optional params

public static TReturn NullOr<TIn, TReturn>(this TIn obj, Func<TIn, TReturn> func,
        TReturn elseValue) where TIn : class
    { return obj != null ? func(obj) : elseValue; }
public static TReturn NullOr<TIn, TReturn>(this TIn obj, Func<TIn, TReturn> func)
        where TIn : class
    { return obj != null ? func(obj) : default(TReturn); }

Nó cho phép bạn làm điều này:

var lname = thingy.NullOr(t => t.Name).NullOr(n => n.ToLower());

thông thạo hơn và (IMO) dễ đọc hơn thế này:

var lname = (thingy != null ? thingy.Name : null) != null
    ? thingy.Name.ToLower() : null;

"Vui lòng đánh dấu câu trả lời của bạn với sự chấp nhận để đặt mã vào dự án Codeplex."

Tại sao? Tất cả nội dung trên trang web này theo CC-by-sa-2.5 , vì vậy chỉ cần đặt Dự án tràn tiện ích mở rộng của bạn theo cùng một giấy phép và bạn có thể tự do sử dụng nó.

Dù sao, đây là một hàm String.Reverse, dựa trên câu hỏi này .

/// <summary>
/// Reverse a String
/// </summary>
/// <param name="input">The string to Reverse</param>
/// <returns>The reversed String</returns>
public static string Reverse(this string input)
{
    char[] array = input.ToCharArray();
    Array.Reverse(array);
    return new string(array);
}

Tôi cảm thấy mệt mỏi với việc kiểm tra null tẻ nhạt trong khi lấy các giá trị từ MySqlDataReader, vì vậy:

public static DateTime? GetNullableDateTime(this MySqlDataReader dr, string fieldName)
{
    DateTime? nullDate = null;
    return dr.IsDBNull(dr.GetOrdinal(fieldName)) ? nullDate : dr.GetDateTime(fieldName);
}

public static string GetNullableString(this MySqlDataReader dr, string fieldName)
{
    return dr.IsDBNull(dr.GetOrdinal(fieldName)) ? String.Empty : dr.GetString(fieldName);
}

public static char? GetNullableChar(this MySqlDataReader dr, string fieldName)
{
    char? nullChar = null;
    return dr.IsDBNull(dr.GetOrdinal(fieldName)) ? nullChar : dr.GetChar(fieldName);
}

Tất nhiên điều này có thể được sử dụng với bất kỳ SqlDataReader.

Cả hangy và Joe đều có một số nhận xét tốt về cách thực hiện điều này và từ đó tôi đã có cơ hội thực hiện một cái gì đó tương tự trong một bối cảnh khác, vì vậy đây là một phiên bản khác:

public static int? GetNullableInt32(this IDataRecord dr, int ordinal)
{
    int? nullInt = null;
    return dr.IsDBNull(ordinal) ? nullInt : dr.GetInt32(ordinal);
}

public static int? GetNullableInt32(this IDataRecord dr, string fieldname)
{
    int ordinal = dr.GetOrdinal(fieldname);
    return dr.GetNullableInt32(ordinal);
}

public static bool? GetNullableBoolean(this IDataRecord dr, int ordinal)
{
    bool? nullBool = null;
    return dr.IsDBNull(ordinal) ? nullBool : dr.GetBoolean(ordinal);
}

public static bool? GetNullableBoolean(this IDataRecord dr, string fieldname)
{
    int ordinal = dr.GetOrdinal(fieldname);
    return dr.GetNullableBoolean(ordinal);
}

Điều đó làm tôi bực mình khi LINQ đưa cho tôi một OrderBy lấy một lớp triển khai IComparer làm đối số, nhưng không hỗ trợ chuyển vào một hàm so sánh ẩn danh đơn giản. Tôi đã khắc phục điều đó.

Lớp này tạo ra một IComparer từ chức năng so sánh của bạn ...

/// <summary>
///     Creates an <see cref="IComparer{T}"/> instance for the given
///     delegate function.
/// </summary>
internal class ComparerFactory<T> : IComparer<T>
{
    public static IComparer<T> Create(Func<T, T, int> comparison)
    {
        return new ComparerFactory<T>(comparison);
    }

    private readonly Func<T, T, int> _comparison;

    private ComparerFactory(Func<T, T, int> comparison)
    {
        _comparison = comparison;
    }

    #region IComparer<T> Members

    public int Compare(T x, T y)
    {
        return _comparison(x, y);
    }

    #endregion
}

... và các phương thức mở rộng này cho thấy tình trạng quá tải OrderBy mới của tôi trên bảng liệt kê. Tôi nghi ngờ điều này hoạt động với LINQ to SQL, nhưng thật tuyệt vời cho LINQ to Object.

public static class EnumerableExtensions
{
    /// <summary>
    /// Sorts the elements of a sequence in ascending order by using a specified comparison delegate.
    /// </summary>
    public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
                                                                     Func<TKey, TKey, int> comparison)
    {
        var comparer = ComparerFactory<TKey>.Create(comparison);
        return source.OrderBy(keySelector, comparer);
    }

    /// <summary>
    /// Sorts the elements of a sequence in descending order by using a specified comparison delegate.
    /// </summary>
    public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector,
                                                                               Func<TKey, TKey, int> comparison)
    {
        var comparer = ComparerFactory<TKey>.Create(comparison);
        return source.OrderByDescending(keySelector, comparer);
    }
}

Bạn có thể đặt nó trên codeplex nếu bạn thích.

Cái này là dành cho MVC, nó bổ sung khả năng tạo <label /> thẻ cho Htmlbiến có sẵn trong mỗi ViewPage. Hy vọng nó sẽ được sử dụng cho những người khác đang cố gắng phát triển các tiện ích mở rộng tương tự.

Sử dụng:

<%= Html.Label("LabelId", "ForId", "Text")%>

Đầu ra:

<label id="LabelId" for="ForId">Text</label>

Mã số:

public static class HtmlHelperExtensions
{
    public static string Label(this HtmlHelper Html, string @for, string text)
    {
        return Html.Label(null, @for, text);
    }

    public static string Label(this HtmlHelper Html, string @for, string text, object htmlAttributes)
    {
        return Html.Label(null, @for, text, htmlAttributes);
    }

    public static string Label(this HtmlHelper Html, string @for, string text, IDictionary<string, object> htmlAttributes)
    {
        return Html.Label(null, @for, text, htmlAttributes);
    }

    public static string Label(this HtmlHelper Html, string id, string @for, string text)
    {
        return Html.Label(id, @for, text, null);
    }

    public static string Label(this HtmlHelper Html, string id, string @for, string text, object htmlAttributes)
    {
        return Html.Label(id, @for, text, new RouteValueDictionary(htmlAttributes));
    }

    public static string Label(this HtmlHelper Html, string id, string @for, string text, IDictionary<string, object> htmlAttributes)
    {
        TagBuilder tag = new TagBuilder("label");

        tag.MergeAttributes(htmlAttributes);

        if (!string.IsNullOrEmpty(id))
            tag.MergeAttribute("id", Html.AttributeEncode(id));

        tag.MergeAttribute("for", Html.AttributeEncode(@for));

        tag.SetInnerText(Html.Encode(text));

        return tag.ToString(TagRenderMode.Normal);
    }
}

Biến điều này:

DbCommand command = connection.CreateCommand();
command.CommandText = "SELECT @param";

DbParameter param = command.CreateParameter();
param.ParameterName = "@param";
param.Value = "Hello World";

command.Parameters.Add(param);

... vào đây:

DbCommand command = connection.CreateCommand("SELECT {0}", "Hello World");

... sử dụng phương thức mở rộng này:

using System;
using System.Data.Common;
using System.Globalization;
using System.Reflection;

namespace DbExtensions {

   public static class Db {

      static readonly Func<DbConnection, DbProviderFactory> getDbProviderFactory;
      static readonly Func<DbCommandBuilder, int, string> getParameterName;
      static readonly Func<DbCommandBuilder, int, string> getParameterPlaceholder;

      static Db() {

         getDbProviderFactory = (Func<DbConnection, DbProviderFactory>)Delegate.CreateDelegate(typeof(Func<DbConnection, DbProviderFactory>), typeof(DbConnection).GetProperty("DbProviderFactory", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(true));
         getParameterName = (Func<DbCommandBuilder, int, string>)Delegate.CreateDelegate(typeof(Func<DbCommandBuilder, int, string>), typeof(DbCommandBuilder).GetMethod("GetParameterName", BindingFlags.Instance | BindingFlags.NonPublic, Type.DefaultBinder, new Type[] { typeof(Int32) }, null));
         getParameterPlaceholder = (Func<DbCommandBuilder, int, string>)Delegate.CreateDelegate(typeof(Func<DbCommandBuilder, int, string>), typeof(DbCommandBuilder).GetMethod("GetParameterPlaceholder", BindingFlags.Instance | BindingFlags.NonPublic, Type.DefaultBinder, new Type[] { typeof(Int32) }, null));
      }

      public static DbProviderFactory GetProviderFactory(this DbConnection connection) {
         return getDbProviderFactory(connection);
      }

      public static DbCommand CreateCommand(this DbConnection connection, string commandText, params object[] parameters) {

         if (connection == null) throw new ArgumentNullException("connection");

         return CreateCommandImpl(GetProviderFactory(connection).CreateCommandBuilder(), connection.CreateCommand(), commandText, parameters);
      }

      private static DbCommand CreateCommandImpl(DbCommandBuilder commandBuilder, DbCommand command, string commandText, params object[] parameters) {

         if (commandBuilder == null) throw new ArgumentNullException("commandBuilder");
         if (command == null) throw new ArgumentNullException("command");
         if (commandText == null) throw new ArgumentNullException("commandText");

         if (parameters == null || parameters.Length == 0) {
            command.CommandText = commandText;
            return command;
         }

         object[] paramPlaceholders = new object[parameters.Length];

         for (int i = 0; i < paramPlaceholders.Length; i++) {

            DbParameter dbParam = command.CreateParameter();
            dbParam.ParameterName = getParameterName(commandBuilder, i);
            dbParam.Value = parameters[i] ?? DBNull.Value;
            command.Parameters.Add(dbParam);

            paramPlaceholders[i] = getParameterPlaceholder(commandBuilder, i);
         }

         command.CommandText = String.Format(CultureInfo.InvariantCulture, commandText, paramPlaceholders);

         return command;
      }
   }
}

Các phương thức mở rộng ADO.NET khác: DbExtensions