Cách tạo các hàm nội tuyến trong C #

Question 1

Tôi đang sử dụng Linq To XML

new XElement("Prefix", Prefix == null ? "" : Prefix)

nhưng tôi muốn thực hiện một số tính toán đối với tiền tố trước khi thêm nó vào xml, như loại bỏ dấu cách, ký tự đặc biệt, một số phép tính, v.v.

Tôi không muốn tạo các hàm vì những hàm này sẽ không giúp ích gì cho bất kỳ phần nào khác của chương trình của tôi nhưng điều này, vậy có cách nào để tạo các hàm nội tuyến không ??

Question 2

Có, C # hỗ trợ điều đó. Có một số cú pháp có sẵn.

Các phương thức ẩn danh đã được thêm vào C # 2.0:

Func<int, int, int> add = delegate(int x, int y)
{
    return x + y;
};
Action<int> print = delegate(int x)
{
    Console.WriteLine(x);
}
Action<int> helloWorld = delegate // parameters can be elided if ignored
{
    Console.WriteLine("Hello world!");
}

Lambdas mới trong C # 3.0 và có hai hương vị.

Biểu thức lambdas:

Func<int, int, int> add = (int x, int y) => x + y; // or...
Func<int, int, int> add = (x, y) => x + y; // types are inferred by the compiler

Tuyên bố lambdas:

Action<int> print = (int x) => { Console.WriteLine(x); };
Action<int> print = x => { Console.WriteLine(x); }; // inferred types
Func<int, int, int> add = (x, y) => { return x + y; };

Các hàm cục bộ đã được giới thiệu với C # 7.0:

int add(int x, int y) => x + y;
void print(int x) { Console.WriteLine(x); }

Về cơ bản có hai loại khác nhau cho những điều này: Funcvà Action. Funcs trả về giá trị nhưng Actionkhông. Tham số kiểu cuối cùng của a Funclà kiểu trả về; tất cả những cái khác là các loại tham số.

Có những loại tương tự với tên khác nhau, nhưng cú pháp để khai báo chúng nội dòng là như nhau. Một ví dụ về điều này là Comparison<T>, gần tương đương với Func<T, T, int>.

Func<string, string, int> compare1 = (l,r) => 1;
Comparison<string> compare2 = (l, r) => 1;
Comparison<string> compare3 = compare1; // this one only works from C# 4.0 onwards

Chúng có thể được gọi trực tiếp như thể chúng là các phương thức thông thường:

int x = add(23, 17); // x == 40
print(x); // outputs 40
helloWorld(x); // helloWorld has one int parameter declared: Action<int>
               // even though it does not make any use of it.

Question 3

C # 7 bổ sung hỗ trợ cho các chức năng cục bộ

Đây là ví dụ trước sử dụng hàm cục bộ

void Method()
{
    string localFunction(string source)
    {
        // add your functionality here
        return source ;
    };

   // call the inline function
   localFunction("prefix");
}

Question 4

Câu trả lời cho câu hỏi của bạn là có và không, tùy thuộc vào ý bạn muốn nói đến "hàm nội tuyến". Nếu bạn đang sử dụng thuật ngữ giống như nó được sử dụng trong phát triển C ++ thì câu trả lời là không, bạn không thể làm điều đó - ngay cả một biểu thức lambda cũng là một lời gọi hàm. Mặc dù đúng là bạn có thể xác định các biểu thức lambda nội tuyến để thay thế các khai báo hàm trong C #, nhưng cuối cùng trình biên dịch vẫn tạo ra một hàm ẩn danh.

Đây là một số mã thực sự đơn giản mà tôi đã sử dụng để kiểm tra điều này (VS2015):

    static void Main(string[] args)
    {
        Func<int, int> incr = a => a + 1;
        Console.WriteLine($"P1 = {incr(5)}");
    }

Trình biên dịch tạo ra gì? Tôi đã sử dụng một công cụ tiện lợi có tên ILSpy hiển thị lắp ráp IL thực tế được tạo. Hãy xem (Tôi đã bỏ qua rất nhiều công cụ thiết lập lớp)

Đây là chức năng chính:

        IL_001f: stloc.0
        IL_0020: ldstr "P1 = {0}"
        IL_0025: ldloc.0
        IL_0026: ldc.i4.5
        IL_0027: callvirt instance !1 class [mscorlib]System.Func`2<int32, int32>::Invoke(!0)
        IL_002c: box [mscorlib]System.Int32
        IL_0031: call string [mscorlib]System.String::Format(string, object)
        IL_0036: call void [mscorlib]System.Console::WriteLine(string)
        IL_003b: ret

Xem những dòng IL_0026 và IL_0027? Hai lệnh đó tải số 5 và gọi một hàm. Sau đó định dạng IL_0031 và IL_0036 và in kết quả.

Và đây là hàm được gọi là:

        .method assembly hidebysig 
            instance int32 '<Main>b__0_0' (
                int32 a
            ) cil managed 
        {
            // Method begins at RVA 0x20ac
            // Code size 4 (0x4)
            .maxstack 8

            IL_0000: ldarg.1
            IL_0001: ldc.i4.1
            IL_0002: add
            IL_0003: ret
        } // end of method '<>c'::'<Main>b__0_0'

Đó là một hàm thực sự ngắn, nhưng nó là một hàm.

Điều này có đáng để nỗ lực tối ưu hóa không? Không. Có thể nếu bạn đang gọi nó hàng nghìn lần một giây, nhưng nếu hiệu suất là quan trọng thì bạn nên cân nhắc gọi mã gốc được viết bằng C / C ++ để thực hiện công việc.

Theo kinh nghiệm của tôi, khả năng đọc và khả năng bảo trì hầu như luôn quan trọng hơn việc tối ưu hóa để đạt được tốc độ vài micro giây. Sử dụng các hàm để làm cho mã của bạn có thể đọc được và kiểm soát phạm vi thay đổi và không lo lắng về hiệu suất.

"Tối ưu hóa sớm là gốc rễ của mọi điều xấu (hoặc ít nhất là hầu hết) trong lập trình." - Donald Knuth

"Một chương trình không chạy chính xác thì không cần chạy nhanh" - Tôi

Question 5

Đúng.

Bạn có thể tạo các phương thức ẩn danh hoặc biểu thức lambda :

Func<string, string> PrefixTrimmer = delegate(string x) {
    return x ?? "";
};
Func<string, string> PrefixTrimmer = x => x ?? "";

Question 6

Bạn có thể sử dụng Func để đóng gói một phương thức có một tham số và trả về một giá trị của kiểu được chỉ định bởi tham số TResult.

void Method()
{
    Func<string,string> inlineFunction = source => 
    {
        // add your functionality here
        return source ;
     };


    // call the inline function
   inlineFunction("prefix");
}

Question 7

Không chỉ các phương thức Inside, nó cũng có thể được sử dụng bên trong các lớp.

class Calculator
    {
        public static int Sum(int x,int y) => x + y;
        public static Func<int, int, int>  Add = (x, y) => x + y;
        public static Action<int,int> DisplaySum = (x, y) => Console.WriteLine(x + y);
    }