c#快速入门（下）

欢迎来到Cefler的博客
博客主页：那个传说中的man的主页
个人专栏：题目解析
推荐文章：题目大解析2

---

Inline和lambda

在C#中，inline和lambda都是用于函数的简写方式。inline函数是一种将函数体直接插入到调用点的函数，而lambda函数是一种匿名函数，可以在需要时定义和使用。
下面是一些示例：

// Inline function example
public class MyClass
{
  
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

// Lambda function example
public class Program
{
    static void Main(string[] args)
    {
    //Func square = new  Func((int x)=>{return x*x;});
        Func<int, int> square = x => x * x;
        Console.WriteLine(square(5)); // Output: 25
    }
}

委托和lambda

在C#中，委托是一种类型，它可以封装一个或多个方法，并允许将这些方法作为参数传递给其他方法。委托可以让你编写更灵活、更可扩展的代码，从而提高代码的可维护性和可重用性。委托的声明语法如下：

delegate void MyDelegate(int arg);

在这个示例中，我们定义了一个名为MyDelegate的委托，它可以封装一个参数为int类型、返回值为void的方法。

委托还可以使用匿名方法和Lambda表达式来创建。例如，下面是一个使用Lambda表达式创建委托的示例：

MyDelegate del = arg => Console.WriteLine("The argument is: " + arg);
del(10); // outputs "The argument is: 10"

在这个示例中，我们使用Lambda表达式创建了一个MyDelegate对象，并将其赋值给del变量。Lambda表达式定义了一个参数为arg的方法体，它输出arg的值。然后，我们调用MyDelegate对象，并传递一个int类型的参数。由于MyDelegate对象封装了Lambda表达式，因此在调用MyDelegate对象时，实际上是调用了Lambda表达式。

Linq

在C#中，LINQ是一种用于查询数据的语言集成查询（Language Integrated Query）技术。它允许你使用类似于SQL的语法来查询各种数据源，包括数组、集合、数据库和XML文档等。下面是一些示例：

// Querying an array
int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = from n in numbers
                  where n % 2 == 0
                  select n;

// Querying a collection
List<Person> people = new List<Person>();
people.Add(new Person { Name = "John", Age = 30 });
people.Add(new Person { Name = "Jane", Age = 25 });
var adults = from p in people
             where p.Age >= 18
             select p;

// Querying a database
var db = new MyDatabaseContext();
var customers = from c in db.Customers
                where c.City == "New York"
                select c;

// Querying an XML document
var doc = XDocument.Load("data.xml");
var products = from p in doc.Descendants("product")
               where (int)p.Element("price") < 50
               select new {
                   Name = (string)p.Element("name"),
                   Price = (decimal)p.Element("price")
               };

在这些示例中，我们使用LINQ查询了不同类型的数据源。在每个查询中，我们使用from子句指定要查询的数据源，然后使用where子句指定要筛选的条件，最后使用select子句指定要返回的结果。在查询结果中，我们可以使用var关键字来推断出返回的类型，也可以使用匿名类型来返回自定义的结果。

from,where,select关键字

from
from子句用于指定要查询的数据源，可以是数组、集合、数据库表或XML文档等。例如，我们可以使用from子句查询一个整数数组中的所有偶数：

int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = from n in numbers
                  where n % 2 == 0
                  select n;

where
where子句用于指定要筛选的条件，可以是任何返回布尔值的表达式。例如，我们可以使用where子句筛选一个人员列表中的所有成年人：

List<Person> people = new List<Person>();
people.Add(new Person { Name = "John", Age = 30 });
people.Add(new Person { Name = "Jane", Age = 25 });
var adults = from p in people
             where p.Age >= 18
             select p;

select
select子句用于指定要返回的结果，可以是任何表达式。例如，我们可以使用select子句返回一个整数数组中的所有偶数的平方：

int[] numbers = { 1, 2, 3, 4, 5 };
var evenSquares = from n in numbers
                  where n % 2 == 0
                  select n * n;

聊聊c#中的静态

c#中为什么要有静态类，静态成员,静态函数，意义是什么呢？

实际上，静态类、静态成员和静态函数是用于在类级别上定义数据和行为的方法。它们与实例成员不同，因为它们不需要实例化对象就可以访问。
静态类
静态类是一种只包含静态成员的类。它们不能被实例化，因为它们没有实例构造函数。静态类通常用于定义全局数据和行为，例如数学函数库或常量集合。下面是一个示例：

public static class MathUtils
{
    public const double Pi = 3.14159265358979323846;

    public static double DegreesToRadians(double degrees)
    {
        return degrees * Pi / 180.0;
    }
}

静态成员
静态成员是在类级别上定义的数据和行为。它们与实例成员不同，因为它们不需要实例化对象就可以访问。静态成员通常用于定义全局数据和行为，例如单例模式或全局计数器。下面是一个示例：

public class MyClass
{
    private static int instanceCount = 0;

    public MyClass()
    {
        instanceCount++;
    }

    public static int InstanceCount
    {
        get { return instanceCount; }
    }
}

静态函数
静态函数是在类级别上定义的行为。它们与实例函数不同，因为它们不需要实例化对象就可以访问。静态函数通常用于定义全局行为，例如工具函数或工厂方法。下面是一个示例：

public class StringUtils
{
    public static bool IsNullOrEmpty(string value)
    {
        return string.IsNullOrEmpty(value);
    }
}

实例构造函数、静态构造函数、析构函数

在C#中，实例构造函数、静态构造函数和析构函数是用于类的特殊方法。它们分别在创建对象、初始化类和销毁对象时被调用。它们具有与类相同的名称，并且没有参数或返回类型
一、构造函数
实例构造函数是用于创建对象时初始化对象的方法。具有与类相同的名称，并且没有返回类型。例如，下面是一个示例：

public class MyClass
{
    public int MyProperty { get; set; } 

    public MyClass(int myProperty)
    {
        MyProperty = myProperty;
    }
}

二、静态构造函数
静态构造函数是用于初始化类的静态成员的方法。具有与类相同的名称，并且没有参数或返回类型。例如，下面是一个示例：

public class MyClass
{
    public static int MyStaticProperty { get; set; }

    static MyClass()
    {
        MyStaticProperty = 42;
    }
}

三、析构函数
析构函数是用于销毁对象时执行清理操作的方法。具有与类相同的名称，但前面加上一个波浪号(~)，并且没有参数或返回类型。例如，下面是一个示例：

public class MyClass
{
    ~MyClass()
    {
        // Cleanup code here
    }
}

this 关键字

在C#中，this关键字用于引用当前对象。它可以用于访问当前对象的成员变量、成员函数和构造函数。在以下情况下，你可以使用this关键字：

1. 区分局部变量和成员变量：如果一个成员变量和一个局部变量同名，你可以使用this关键字来引用成员变量。例如：

public class MyClass
{
    private int myProperty;

    public void SetMyProperty(int myProperty)
    {
        this.myProperty = myProperty;
    }
}

在这个示例中，我们定义了一个名为MyClass的类，它包含一个名为myProperty的成员变量和一个名为SetMyProperty的函数。当我们调用SetMyProperty函数时，我们使用this关键字来引用成员变量myProperty，以区分它和函数参数myProperty。

2. 在构造函数中调用其他构造函数：如果一个类有多个构造函数，你可以使用this关键字在一个构造函数中调用另一个构造函数。例如：

public class MyClass
{
    private int myProperty;

    public MyClass() : this(0)
    {
    }

    public MyClass(int myProperty)
    {
        this.myProperty = myProperty;
    }
}

在这个示例中，我们定义了一个名为MyClass的类，它包含一个名为myProperty的成员变量和两个构造函数。第一个构造函数调用第二个构造函数，并将myProperty初始化为0。第二个构造函数接受一个整数参数，并将myProperty初始化为该参数的值。

总结：

在C#中，你可以使用this关键字来引用当前对象。它可以用于访问当前对象的成员变量、成员函数和构造函数。在构造函数或方法中引用成员变量时，你可以选择使用或不使用this关键字，因为它的意义就是为了方便你区分局部变量和成员变量。如果一个成员变量和一个局部变量同名，你可以使用this关键字来引用成员变量，以区分它和函数参数。
2.
在C#中，this关键字用于引用当前对象，它可以用于访问当前对象的成员变量、成员函数和构造函数。然而，this关键字只能用于访问实例成员，而不能用于访问静态成员。静态成员是在类级别上定义的数据和行为，它们与实例成员不同，因为它们不需要实例化对象就可以访问。因此，如果你想访问静态成员，你应该使用类名来引用它们，而不是使用this关键字

重写和多态

在C#中，重写和多态是面向对象编程的两个重要概念。重写是指在派生类中重新定义基类中已有的成员函数，以便在派生类中提供更具体的实现。多态是指在运行时根据对象的实际类型来调用相应的成员函数，以便实现动态绑定。
重写可以通过在派生类中使用override关键字来实现。例如，下面是一个示例：

public class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("The animal makes a sound");
    }
}

public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("The dog barks");
    }
}

在这个示例中，我们定义了一个名为Animal的基类和一个名为Dog的派生类。Animal类包含一个名为MakeSound的虚函数，它在派生类中可以被重写。Dog类重写了MakeSound函数，并提供了更具体的实现。
多态可以通过在基类中使用虚函数和在派生类中使用重写函数来实现。例如，下面是一个示例：

Animal animal = new Animal();
animal.MakeSound(); // The animal makes a sound

Animal dog = new Dog();
dog.MakeSound(); // The dog barks

在这个示例中，我们创建了一个Animal对象和一个Dog对象，并调用它们的MakeSound函数。由于Animal类的MakeSound函数是虚函数，因此在运行时会根据对象的实际类型来调用相应的成员函数，从而实现了多态。

我可以简单理解多态就是实例化一个对象后，对这个对象进行实时传参实现动态变化，然后这就叫做多态吗？
答案是：

多态是指在运行时根据对象的实际类型来调用相应的成员函数，以便实现动态绑定。它可以让你编写更灵活、更可扩展的代码，从而提高代码的可维护性和可重用性。实现多态需要使用虚函数和重写函数。虚函数是在基类中声明的函数，它可以在派生类中被重写。重写函数是在派生类中重新定义基类中已有的成员函数，以便在派生类中提供更具体的实现。因此，多态的实现前提是要先创建虚函数并且重写函数。

接口

什么是接口?

在C#中，接口是一种定义类之间协作的契约。它定义了一组方法、属性和事件，这些方法、属性和事件可以被实现该接口的类所使用。接口声明的语法如下：

interface IMyInterface
{
    void MyMethod();
    int MyProperty { get; set; }
    event EventHandler MyEvent;
}

在这个示例中，我们定义了一个名为IMyInterface的接口，它包含一个名为MyMethod的方法、一个名为MyProperty的属性和一个名为MyEvent的事件。实现该接口的类必须实现这些成员。例如：

class MyClass : IMyInterface
{
    public void MyMethod()
    {
        // implementation
    }

    public int MyProperty { get; set; }

    public event EventHandler MyEvent;
}

在这个示例中，我们定义了一个名为MyClass的类，它实现了IMyInterface接口。我们必须实现IMyInterface接口中定义的所有成员，包括MyMethod方法、MyProperty属性和MyEvent事件。现在，我们可以创建一个MyClass对象，并使用它的成员，例如：

IMyInterface obj = new MyClass();
obj.MyMethod();
obj.MyProperty = 10;
obj.MyEvent += (sender, args) => Console.WriteLine("Event raised");

在这个示例中，我们创建了一个IMyInterface对象，并将MyClass对象传递给它。由于MyClass类实现了IMyInterface接口，因此我们可以使用IMyInterface类型的参数来传递它。这种方式可以让我们在不知道对象的具体类型的情况下，使用它的成员。

接口实现多态

在C#中，接口是一种用于定义行为的抽象类型。它们是一组方法、属性和事件的声明，没有实现。接口可以被类或结构体实现，以便提供特定的行为。接口可以用于实现多态和解耦，从而提高代码的可维护性和可扩展性。

下面是一个示例：

public interface IShape
{
    double Area { get; }
    double Perimeter { get; }
}

public class Rectangle : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }

    public double Area
    {
        get { return Width * Height; }
    }

    public double Perimeter
    {
        get { return 2 * (Width + Height); }
    }
}

public class Circle : IShape
{
    public double Radius { get; set; }

    public double Area
    {
        get { return Math.PI * Radius * Radius; }
    }

    public double Perimeter
    {
        get { return 2 * Math.PI * Radius; }
    }
}

在这个示例中，我们定义了一个名为IShape的接口，它包含两个属性：Area和Perimeter。我们还定义了两个类：Rectangle和Circle，它们都实现了IShape接口。Rectangle类实现了Area和Perimeter属性，以便计算矩形的面积和周长。Circle类实现了Area和Perimeter属性，以便计算圆形的面积和周长。

接口可以用于实现多态，例如：

IShape shape1 = new Rectangle { Width = 10, Height = 20 };
IShape shape2 = new Circle { Radius = 5 };

Console.WriteLine("Shape 1 area: {0}", shape1.Area);
Console.WriteLine("Shape 1 perimeter: {0}", shape1.Perimeter);

Console.WriteLine("Shape 2 area: {0}", shape2.Area);
Console.WriteLine("Shape 2 perimeter: {0}", shape2.Perimeter);

在这个示例中，我们创建了一个Rectangle对象和一个Circle对象，并将它们赋值给IShape类型的变量。由于Rectangle和Circle类都实现了IShape接口，因此我们可以使用IShape类型的变量来访问它们的Area和Perimeter属性，从而实现了多态。

解耦

在C#中，解耦是指将代码中的不同部分分离开来，以便实现更高的可维护性和可扩展性。解耦可以通过使用接口、抽象类、委托和事件等技术来实现。例如，使用接口可以将代码中的实现与接口分离开来，从而使得代码更容易维护和扩展。
下面是一个示例：

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

public class FileLogger : ILogger
{
    public void Log(string message)
    {
        // write message to file
    }
}

public class MyClass
{
    private readonly ILogger _logger;

    public MyClass(ILogger logger)
    {
        _logger = logger;
    }

    public void DoSomething()
    {
        // do something
        _logger.Log("Something was done");
    }
}

在这个示例中，我们定义了一个名为ILogger的接口，它包含一个名为Log的方法。我们还定义了两个类：ConsoleLogger和FileLogger，它们都实现了ILogger接口。MyClass类包含一个名为DoSomething的方法，它使用ILogger类型的参数来记录日志。现在，我们可以创建一个MyClass对象，并将ConsoleLogger或FileLogger对象传递给它的构造函数，例如：

var myClass = new MyClass(new ConsoleLogger());
myClass.DoSomething(); // logs "Something was done" to the console

var myClass2 = new MyClass(new FileLogger());
myClass2.DoSomething(); // logs "Something was done" to a file

在这个示例中，我们创建了一个MyClass对象，并将ConsoleLogger或FileLogger对象传递给它的构造函数。由于ConsoleLogger和FileLogger类都实现了ILogger接口，因此我们可以使用ILogger类型的参数来传递它们。这种方式可以将代码中的实现与接口分离开来，从而使得代码更容易维护和扩展。

我是否可以认为，解耦就是将接口中的方法具体扩展成其它方法实现更多功能，比如接口中的方法只是一个传参函数，但是我通过接口实现对该传参函数的加减功能，这样理解对吗？

将接口中的方法具体扩展成其他方法实现更多功能是一种实现解耦的方式。例如，你可以定义一个接口，其中包含一个名为DoSomething的方法，然后在实现该接口的类中，通过重写DoSomething方法来实现不同的功能。例如：

public interface IMyInterface
{
    void DoSomething(int value);
}

public class MyClass : IMyInterface
{
    public void DoSomething(int value)
    {
        Console.WriteLine("The value is: " + value);
    }
}

public class MyOtherClass : IMyInterface
{
    public void DoSomething(int value)
    {
        Console.WriteLine("The value plus 1 is: " + (value + 1));
    }
}

在这个示例中，我们定义了一个名为IMyInterface的接口，它包含一个名为DoSomething的方法。我们还定义了两个类：MyClass和MyOtherClass，它们都实现了IMyInterface接口。MyClass类实现了DoSomething方法，以便输出传入的值。MyOtherClass类重写了DoSomething方法，并在输出传入的值之前将其加1。现在，我们可以创建一个IMyInterface对象，并将MyClass或MyOtherClass对象传递给它，例如：

IMyInterface obj1 = new MyClass();
obj1.DoSomething(10); // outputs "The value is: 10"

IMyInterface obj2 = new MyOtherClass();
obj2.DoSomething(10); // outputs "The value plus 1 is: 11"

在这个示例中，我们创建了一个IMyInterface对象，并将MyClass或MyOtherClass对象传递给它。由于MyClass和MyOtherClass类都实现了IMyInterface接口，因此我们可以使用IMyInterface类型的参数来传递它们。这种方式可以将接口中的方法具体扩展成其他方法实现更多功能，从而实现解耦。

事件

在C#中，事件是一种特殊的委托，它允许对象在发生特定的操作时通知其他对象。
事件的声明语法如下：

public event EventHandler MyEvent;

在这个示例中，我们定义了一个名为MyEvent的事件，它使用EventHandler委托作为其类型。EventHandler委托是一种预定义的委托，它可以封装一个没有参数和返回值的方法。现在，我们可以创建一个包含MyEvent事件的类，并在该事件发生时通知其他对象，例如：

public class MyClass
{
    public event EventHandler MyEvent;

    public void DoSomething()
    {
        // do something
        OnMyEvent();
    }

    protected virtual void OnMyEvent()
    {
        MyEvent?.Invoke(this, EventArgs.Empty);
      
    }
}

public class MyOtherClass
{
    public void HandleMyEvent(object sender, EventArgs e)
    {
        Console.WriteLine("MyEvent was raised");
    }
}

MyClass obj1 = new MyClass();
MyOtherClass obj2 = new MyOtherClass();
obj1.MyEvent += obj2.HandleMyEvent;
obj1.DoSomething(); // outputs "MyEvent was raised"

MyEvent?.Invoke(this, EventArgs.Empty)是一个调用MyEvent事件的语句，它会触发MyEvent事件，并将当前对象和一个空的EventArgs对象作为参数传递给事件处理程序。这个语句中的==问号是一个空值条件运算符，它可以确保在MyEvent为null时不会引发NullReferenceException异常。
在这个语句中，this指的是包含MyEvent事件的类的实例，也就是MyClass的实例。因此，MyEvent?.Invoke(this, EventArgs.Empty)会将MyClass的实例和一个空的EventArgs对象作为参数传递给事件处理程序。

在这个示例中，我们定义了一个名为MyClass的类，它包含一个名为MyEvent的事件和一个名为DoSomething的方法。当DoSomething方法被调用时，它会调用OnMyEvent方法，以便触发MyEvent事件。我们还定义了一个名为MyOtherClass的类，它包含一个名为HandleMyEvent的方法，用于处理MyEvent事件。现在，我们可以创建一个MyClass对象和一个MyOtherClass对象，并将MyOtherClass对象的HandleMyEvent方法注册到MyClass对象的MyEvent事件上。当MyClass对象的DoSomething方法被调用时，它会触发MyEvent事件，并调用MyOtherClass对象的HandleMyEvent方法。

在我们之前的示例中，MyClass类是事件的拥有者，它包含了一个名为MyEvent的事件。MyOtherClass类是事件的响应者，它包含了一个名为HandleMyEvent的方法，用于处理MyEvent事件。MyClass类中的OnMyEvent方法是事件处理器，它用于触发MyEvent事件。MyClass类中的MyEvent事件是事件订阅，它允许其他对象将其方法注册到该事件上，以便在事件发生时得到通知。

事件还可以使用自定义委托来声明。
例如，下面是一个使用自定义委托声明事件的示例：

public delegate void MyEventHandler(object sender, MyEventArgs e);

public class MyClass
{
    public event MyEventHandler MyEvent;

    public void DoSomething()
    {
        // do something
        OnMyEvent(new MyEventArgs());
    }

    protected virtual void OnMyEvent(MyEventArgs e)
    {
        MyEvent?.Invoke(this, e);
    }
}

public class MyEventArgs : EventArgs
{
    // event data
}

public class MyOtherClass
{
    public void HandleMyEvent(object sender, MyEventArgs e)
    {
        Console.WriteLine("MyEvent was raised");
    }
}

MyClass obj1 = new MyClass();
MyOtherClass obj2 = new MyOtherClass();
obj1.MyEvent += obj2.HandleMyEvent;
obj1.DoSomething(); // outputs "MyEvent was raised"

在这个示例中，我们定义了一个名为MyEventHandler的自定义委托，它可以封装一个包含两个参数的方法：一个object类型的sender参数和一个MyEventArgs类型的e参数。我们还定义了一个名为MyEventArgs的类，它继承自EventArgs类，并包含一些事件数据。现在，我们可以创建一个MyClass对象和一个MyOtherClass对象，并将MyOtherClass对象的HandleMyEvent方法注册到MyClass对象的MyEvent事件上。当MyClass对象的DoSomething方法被调用时，它会触发MyEvent事件，并调用MyOtherClass对象的HandleMyEvent方法。

泛型

泛型可以让你定义一种通用的类型或方法，它可以在编译时确定具体的类型或参数。
泛型的声明语法如下：

class MyClass<T>
{
    // class definition
}

void MyMethod<T>(T arg)
{
    // method body
}

在这个示例中，我们定义了一个名为MyClass的泛型类，它使用T作为其类型参数。现在，我们可以创建一个MyClass对象，并指定T的具体类型，例如：

MyClass<int> obj = new MyClass<int>();

在这个示例中，我们创建了一个MyClass对象，并指定T的具体类型为int。这意味着我们可以在MyClass类中使用int类型的变量和方法。类似地，我们还可以定义一个名为MyMethod的泛型方法，并使用T作为其类型参数。现在，我们可以调用MyMethod方法，并传递一个具体的参数，例如：

MyMethod<int>(10);

使用场景：

1. 集合类：C#中的集合类（如List、Dictionary等）都是使用泛型实现的。这意味着你可以使用这些集合类来存储任何类型的数据，而不需要进行类型转换。

2. 数据库访问：在访问数据库时，你可能需要编写一些通用的代码来处理不同类型的数据。使用泛型可以让你编写更灵活、更可重用的代码，从而提高代码的可维护性和可重用性。

3. 委托和事件：在C#中，委托和事件都可以使用泛型来实现。这意味着你可以定义一种通用的委托或事件，并在编译时确定具体的参数类型。

4. LINQ：LINQ是C#中的一种查询语言，它可以让你使用类似SQL的语法来查询数据。LINQ使用泛型来实现，这意味着你可以在查询时使用任何类型的数据。

---

如上便是本期的所有内容了，如果喜欢并觉得有帮助的话，希望可以博个点赞+收藏+关注❤️ ,学海无涯苦作舟,愿与君一起共勉成长

---