C#基类系统全面整理与实践

于 2024-10-08 15:52:48 发布
阅读量935 收藏 24
点赞数 8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42356162/article/details/142783788
版权

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：C#是一种面向对象的编程语言，特别适用于Windows平台和.NET框架。基类作为C#中构建层次化代码结构的核心，通过继承机制实现代码重用。本资料包深入介绍了C#基类的关键概念，包括继承机制、构造函数、访问修饰符、虚方法重写、抽象类、接口、密封类、属性和字段、事件、静态成员、多态性以及析构函数等。开发者可使用这些资料深入学习C#基类系统，提升编程效率和代码质量。

1. C#中的继承机制与基类使用

在C#中，继承是面向对象编程的核心特性之一，它允许创建一个新类（派生类）继承一个已存在的类（基类）的属性和方法。通过继承，派生类可以扩展基类的功能，而无需重复编写相同的代码。继承还促进了代码的复用和模块化。

继承在C#中通过冒号（:）操作符后跟基类名称来实现。例如： 

public class DerivedClass : BaseClass
{
    // 派生类成员
}

继承的使用不仅限于单继承，C#还支持多重继承通过接口实现。当一个派生类继承多个接口时，必须实现所有接口中声明的成员。继承层次的深度没有限制，但过于复杂的继承层次可能会使代码难以维护。因此，正确使用继承，包括何时使用继承，以及如何设计类层次结构，是每个C#开发者需要掌握的技能。

本章我们将深入探讨继承机制，包括继承的语法、如何正确使用继承以及继承带来的挑战和解决方案。理解并能够高效地利用继承，将提升代码的可维护性和可扩展性。

2. C#中构造函数与对象初始化

2.1 构造函数的作用与类型

2.1.1 无参构造函数与默认初始化

在C#编程语言中，构造函数是一种特殊的方法，它在创建对象时被自动调用，以初始化对象的状态。无参构造函数，也就是不带任何参数的构造函数，是一种简单的构造函数形式，它会在创建对象时提供默认的初始化机制。无参构造函数对于类的使用者来说非常方便，因为它不需要用户提供任何参数就能创建对象实例。 

public class ExampleClass
{
    public int ExampleField; // 一个简单的字段

    // 无参构造函数
    public ExampleClass()
    {
        ExampleField = 0; // 默认值初始化为0
    }
}

在上述代码中， ExampleClass 类拥有一个无参构造函数，当使用 new ExampleClass(); 语句创建对象时， ExampleField 会被自动设置为0。无参构造函数的使用简化了对象的创建过程，但是请注意，如果类中没有定义任何构造函数，编译器会自动提供一个默认的无参构造函数。然而，一旦定义了构造函数（无论是无参还是带参），编译器将不再提供默认的无参构造函数，开发者必须显式提供。

2.1.2 带参构造函数与参数传递

带参构造函数则允许开发者在创建对象时提供额外的信息，以实现更复杂的初始化需求。通过带参构造函数，对象的状态可以在创建时被精确地设定。 

public class ExampleClass
{
    public int ExampleField; // 一个简单的字段

    // 带参构造函数
    public ExampleClass(int value)
    {
        ExampleField = value;
    }
}

在这个例子中， ExampleClass 类具有一个带整型参数的构造函数。创建对象时，必须提供一个整数参数，比如 new ExampleClass(5); ，这会创建一个对象，其 ExampleField 字段值被初始化为5。

带参构造函数的灵活性在于它允许开发者针对不同的使用场景定制不同的初始化方式，这样可以确保创建的对象总是处于一个已知的、有效的状态。同时，这也提供了良好的封装性，因为类的实现细节被隐藏，外部通过构造函数与类交互。

2.2 子类对象的初始化过程

2.2.1 基类构造函数的调用规则

当在C#中创建一个继承自基类的子类对象时，子类对象的初始化过程首先会调用其基类的构造函数。这种调用是自动进行的，确保了基类的字段和属性在子类的任何代码执行之前都被正确初始化。 

public class BaseClass
{
    public BaseClass()
    {
        // 基类构造函数的实现
    }
}

public class DerivedClass : BaseClass
{
    public DerivedClass() : base() // 显式调用基类构造函数
    {
        // 子类构造函数的实现
    }
}

在上述代码中， DerivedClass 继承自 BaseClass 。在 DerivedClass 的构造函数中，使用 : base() 语法显式调用基类的无参构造函数。如果基类没有无参构造函数，那么必须在子类的构造函数中显式调用一个带有相应参数的基类构造函数。这种显式调用是强制的，否则会编译失败。

2.2.2 子类构造函数的链式调用

在子类构造函数的初始化列表中，除了可以调用基类的构造函数，还可以调用同一类中的其他构造函数，这种机制被称为构造函数的链式调用。链式调用允许开发者在不同的构造函数之间共享初始化代码，提高代码的复用性和减少重复。 

public class DerivedClass : BaseClass
{
    public DerivedClass() : this(0) // 链式调用另一个构造函数
    {
    }

    public DerivedClass(int value) : base() // 调用基类的构造函数
    {
        // 初始化代码
    }
}

在这个例子中， DerivedClass 有两个构造函数。当我们通过 new DerivedClass(); 创建对象时，首先会调用无参的子类构造函数。而无参的子类构造函数内部通过 this(0); 语法调用了带有一个整型参数的子类构造函数。这样，无论我们使用哪个构造函数创建对象，都会执行带参数的子类构造函数中的初始化代码。同时，基类构造函数 : base() 被显式调用以确保基类部分的初始化。

需要注意的是，这种链式调用必须在构造函数体开始执行之前完成。如果在构造函数体开始执行后再尝试调用其他构造函数，则会导致编译错误。这是因为构造函数体的执行应该是在所有基类构造和成员初始化之后进行。

3. C#中访问修饰符与成员可访问性控制

在C#编程语言中，访问修饰符是用于控制代码访问权限的关键字。它们定义了类成员（方法、属性、字段、事件等）和嵌套类的可见性以及可访问性。正确地使用访问修饰符是编写健壮、安全代码的重要部分。

3.1 访问修饰符概述

3.1.1 私有、公共与受保护成员

在C#中，最基本也是最常用的访问修饰符有三个： private 、 public 和 protected 。

  • private ：私有成员只能在定义它的类内部访问。这限制了类的外部代码（包括派生类）对这些成员的访问。

  • public ：公共成员可以在程序中的任何地方访问。这意味着任何客户端代码都可以读取或修改公开的数据，调用公开的方法或访问公开的事件。

  • protected ：受保护成员只能在定义它的类或派生自该类的任何其他类中访问。这允许派生类访问和使用基类中的特定成员，但阻止了类外部的访问。 

public class BaseClass
{
    private int privateVar;
    public int PublicVar;
    protected int ProtectedVar;
}

public class DerivedClass : BaseClass
{
    void AccessVars()
    {
        // privateVar = 10; // Error: Cannot access private member from derived class
        PublicVar = 10;    // Ok: PublicVar is public
        ProtectedVar = 10; // Ok: ProtectedVar is protected and accessible from derived class
    }
}

3.1.2 内部与友元访问修饰符

C#还提供了其他两个访问修饰符： internal 和 protected internal 。

  • internal ：内部成员只在它所在的程序集内可见。这在创建大型应用程序时很有用，可以避免公开过多的类实现细节。

  • protected internal ：当成员修饰为 protected internal 时，它可以被任何继承自定义它的类或者同一个程序集中的任何类访问。 

internal class InternalClass
{
    public void InternalMethod() { }
}

class DerivedClass : InternalClass
{
    void AccessInternal()
    {
        InternalMethod(); // Ok: DerivedClass is in the same assembly
    }
}

class OtherClass
{
    void AccessInternal()
    {
        var obj = new InternalClass();
        // obj.InternalMethod(); // Error: InternalClass is internal and OtherClass is in a different assembly
    }
}

3.2 成员访问权限的应用

3.2.1 在类内部和外部的访问规则

成员的访问权限根据声明的访问修饰符不同，在类内外的访问规则也不同：

  • 在类的内部：成员的访问没有限制，无论是私有、受保护还是公共，都可以在类的内部自由访问。
  • 在类的外部：必须根据成员的访问修饰符来决定是否可以访问。例如，只有 public 成员可以在类外部访问。 
class MyClass
{
    private void PrivateMethod() { }
    public void PublicMethod() { }
    protected void ProtectedMethod() { }

    void AccessMembersInClass()
    {
        PrivateMethod();   // Ok: In the same class
        PublicMethod();    // Ok: Public is accessible anywhere
        ProtectedMethod();// Ok: Protected is accessible within the class and derived classes
    }
}

3.2.2 访问修饰符对继承的影响

当一个类继承另一个类时，基类的成员访问修饰符会影响派生类的访问能力：

  • 如果基类成员是 private ，则派生类无法访问它，因为私有成员只能在定义它们的类内部访问。
  • 如果基类成员是 public 或 protected ，派生类可以访问它们。但要注意，如果基类成员是 public ，派生类不能通过基类的类型将其实例化，而是应当通过派生类本身。 
public class BaseClass
{
    protected void MethodToAccess() { }
}

public class DerivedClass : BaseClass
{
    void AccessInDerived()
    {
        MethodToAccess(); // Ok: DerivedClass can access protected members of the BaseClass
    }
}

class UnrelatedClass
{
    void AccessBase()
    {
        BaseClass bc = new BaseClass();
        // bc.MethodToAccess(); // Error: BaseClass is not accessible from UnrelatedClass
    }
}

通过本节的介绍，我们可以了解到访问修饰符是C#中控制封装和信息隐藏的重要机制。它们让开发者可以精确地控制类成员的访问范围，从而维护了类的封装性，增强了程序的模块性和安全性。

4. C#中虚方法、重写与多态性实现

4.1 虚方法与重写的机制

4.1.1 虚方法的基本概念与用法

在C#中，虚方法（virtual method）是一种在基类中被声明为 virtual 的方法，它允许子类通过 override 关键字来重新定义或扩展该方法的功能。虚方法的目的是在不改变原有类结构的基础上，允许派生类自定义自己的行为。

一个虚方法的典型应用场景是在基类中定义一个方法的行为框架，而具体的实现则留给派生类来完成。这样，当一个基类的实例被当作派生类使用时，就会调用派生类中重写后的方法。

下面是一个简单的虚方法的示例代码： 

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("This is Animal speaking.");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Woof! Woof!");
    }
}

public class Program
{
    public static void Main()
    {
        Animal animal = new Animal();
        animal.Speak(); // 输出: This is Animal speaking.

        Animal dog = new Dog();
        dog.Speak(); // 输出: Woof! Woof!
    }
}

4.1.2 override与new关键字的区别

override 和 new 关键字在C#中都用于方法的重写，但它们的行为和用途有显著差异。

  • 当使用 override 关键字重写一个虚方法时，子类提供了一个新的实现来替换基类中的方法。如果在子类中使用 override 声明一个与基类方法签名相同的方法，那么在运行时，该方法的调用将基于对象的实际类型而不是声明类型，从而实现多态性。

  • new 关键字用于隐藏继承的成员。当你使用 new 来修饰一个方法时，实际上是创建了一个与基类成员名称相同的新成员，而不是替换它。在子类的上下文中，如果使用了 new 关键字，那么派生类的实例将不会调用基类中的方法，即使该方法在基类中被声明为虚方法。

下面展示了 override 和 new 关键字的使用差异： 

public class BaseClass
{
    public virtual void SomeMethod()
    {
        Console.WriteLine("BaseClass: SomeMethod");
    }
}

public class DerivedClass : BaseClass
{
    public override void SomeMethod()
    {
        Console.WriteLine("DerivedClass: SomeMethod - Override");
    }

    public new void SomeMethod()
    {
        Console.WriteLine("DerivedClass: SomeMethod - New");
    }
}

public class Program
{
    public static void Main()
    {
        BaseClass obj1 = new BaseClass();
        obj1.SomeMethod(); // 输出: BaseClass: SomeMethod

        DerivedClass obj2 = new DerivedClass();
        obj2.SomeMethod(); // 输出: DerivedClass: SomeMethod - Override
        ((BaseClass)obj2).SomeMethod(); // 输出: BaseClass: SomeMethod

        BaseClass obj3 = new DerivedClass();
        obj3.SomeMethod(); // 输出: DerivedClass: SomeMethod - Override
    }
}

在此代码中，可以看到使用 override 重写方法时，当基类的实例是派生类对象时，会调用派生类中的方法。而使用 new 关键字时，即使基类的实例是派生类对象，也会调用基类中的方法，因为 new 关键字隐藏了继承的成员。

5. C#中的高级类特性与实践

C#作为一门面向对象的编程语言，除了提供基本的类和对象创建机制外，还提供了一系列高级特性，以便开发者创建更灵活、可维护和高效的代码。本章节将深入探讨C#中的一些高级类特性，并通过实际案例展示如何在实践中应用这些特性。

5.1 抽象类与接口的定义与作用

抽象类和接口是实现多态和封装常用的一种方式，在C#编程中扮演着核心角色。理解它们的定义、规则和作用对于构建灵活的设计至关重要。

5.1.1 抽象类的创建与规则

在C#中，抽象类是不能被实例化的类。它通常包含一个或多个抽象方法，这些方法没有具体的实现，仅作为继承的蓝本。抽象类可以包含具体的方法、属性、字段和其他类型的成员。 

public abstract class Shape
{
    // 抽象属性
    public abstract double Area { get; }

    // 具体方法
    public void Draw()
    {
        // 绘制形状的逻辑
    }
}

public class Circle : Shape
{
    private double radius;

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

    public Circle(double radius)
    {
        this.radius = radius;
    }
}

在上述代码中， Shape 是一个抽象类，它定义了一个抽象属性 Area 。 Circle 类继承自 Shape 并提供了 Area 属性的具体实现。

5.1.2 接口的声明与实现

接口在C#中定义了一组方法、属性或事件的契约，任何实现接口的类都必须实现这些成员。接口不提供任何成员的实现，仅定义它们必须存在。 

public interface IDrawable
{
    void Draw();
}

public class Triangle : IDrawable
{
    public void Draw()
    {
        // 绘制三角形的逻辑
    }
}

在这个例子中， IDrawable 是一个接口，它声明了一个 Draw 方法。 Triangle 类实现了 IDrawable 接口，并提供了 Draw 方法的具体实现。

5.2 密封类与方法的使用限制

密封类和方法是防止继承或重写的机制，这在确保某些类或方法不被进一步扩展或修改时非常有用。

5.2.1 密封类的定义与应用场景

密封类是指不能被继承的类。在C#中，使用 sealed 关键字定义密封类。密封类适用于那些设计为最终类，且不希望被其他类继承的场景。 

public sealed class FinalClass
{
    // 类的成员
}

5.2.2 方法的密封限制与继承链优化

与密封类类似，C#允许你密封类中的个别方法，防止它们被子类覆盖。在设计库或框架时，这可以用来保护关键功能不被无意覆盖。 

public class BaseClass
{
    public virtual void MyMethod()
    {
        // 默认实现
    }
}

public class DerivedClass : BaseClass
{
    public sealed override void MyMethod()
    {
        // 自定义实现
    }
}

5.3 属性、字段与事件的继承规则

在面向对象设计中，属性和字段是类状态的主要表现形式，而事件则是类状态变化的声明方式。它们的继承特性对构建复杂对象模型至关重要。

5.3.1 属性与字段的继承特性

在C#中，字段是类的成员变量，它们是不继承的。然而，属性是可以通过继承访问的，子类可以访问和重写父类的属性。 

public class ParentClass
{
    public int Number { get; set; }
}

public class ChildClass : ParentClass
{
    // 重写Number属性
    public new int Number
    {
        get { return base.Number * 2; }
        set { base.Number = value / 2; }
    }
}

5.3.2 事件的定义、触发与处理

事件在C#中是一种特殊的多播委托，允许一个类通知其他对象发生了某件事情。事件是继承的，这意味着子类可以触发和处理继承自父类的事件。 

public class Publisher
{
    public event EventHandler MyEvent;

    public void DoSomething()
    {
        // 触发事件
        OnMyEvent(new EventArgs());
    }

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

public class Subscriber : Publisher
{
    public Subscriber()
    {
        MyEvent += HandleEvent;
    }

    private void HandleEvent(object sender, EventArgs e)
    {
        // 处理事件
    }
}

5.4 静态成员与多态性的运行时绑定

静态成员与实例成员相对，它们属于类本身，而非类的实例。在多态性中，静态成员提供了一种在运行时解析方法的机制。

5.4.1 静态成员的类级特性与作用

静态成员在C#中使用 static 关键字声明，它们可以用来存储类级别的数据或实现不需要实例化即可调用的功能。 

public static class Utils
{
    public static int Add(int a, int b)
    {
        return a + b;
    }
}

// 使用静态方法
int result = Utils.Add(5, 3);

5.4.2 运行时绑定在多态性中的应用

静态成员在运行时绑定允许你调用一个方法，该方法的选择是基于对象的实际类型，而非引用变量的类型。这是实现多态性的一种机制。

5.5 析构函数与资源清理机制

析构函数是C#中的一种特殊方法，用于在对象生命周期结束时执行清理工作。正确处理资源清理对于防止内存泄漏和资源浪费至关重要。

5.5.1 析构函数的作用与使用时机

析构函数通常用于释放非托管资源，如文件句柄、数据库连接等。它们不能被直接调用，而是由.NET运行时自动调用。 

public class ResourceHolder
{
    ~ResourceHolder()
    {
        // 执行资源清理工作
    }
}

5.5.2 资源清理的最佳实践与异常安全

资源清理的最佳实践是使用 IDisposable 接口。当类实现 IDisposable 时，它必须提供一个 Dispose 方法来允许对象的显式释放。 

public class PreciseResourceCleaner : IDisposable
{
    public void Dispose()
    {
        // 显式释放资源
        GC.SuppressFinalize(this);
    }

    // 析构函数
    ~PreciseResourceCleaner()
    {
        Dispose();
    }
}

通过实现 Dispose 方法，开发者可以控制资源的释放时机，即使在发生异常的情况下也能保证资源被正确清理。

在本章中，我们探索了C#的高级类特性，并通过实例深入理解了抽象类、接口、密封类和方法、属性、字段、事件的继承规则，以及静态成员和析构函数在多态性和资源清理中的应用。掌握这些高级特性对于编写高质量、可维护和可扩展的C#应用程序至关重要。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：C#是一种面向对象的编程语言，特别适用于Windows平台和.NET框架。基类作为C#中构建层次化代码结构的核心，通过继承机制实现代码重用。本资料包深入介绍了C#基类的关键概念，包括继承机制、构造函数、访问修饰符、虚方法重写、抽象类、接口、密封类、属性和字段、事件、静态成员、多态性以及析构函数等。开发者可使用这些资料深入学习C#基类系统，提升编程效率和代码质量。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

Kimgoeunlaogong
关注
【面试系列】C#高频面试题
在路上的专栏
06-25 1433
在C#技术面试中，候选人需展示对基础语法、面向对象原则、集合框架和异常处理的扎实理解。熟悉泛型、LINQ、事件与委托、线程并发、以及ASP.NET Core和Entity Framework Core等框架是关键。此外，候选人应掌握RESTful API设计、单元测试、设计模式、性能优化技巧、内存管理、垃圾回收机制，以及Web安全和软件工程实践。对.NET Core/.NET 5/6的新特性、跨平台开发能力、以及持续学习新技术的态度也是评估的重要方面。
C#笔试面试精典全集
03-29
《C#笔试面试精典全集》是一份涵盖了C#编程语言核心知识点和面试常见问题的集合，由作者精心筛选并结合自身经验整理而成。这份资料对于正在准备C#相关岗位笔试和面试的求职者来说，无疑是一份极具价值的学习资源。 ...
C#概念基础
qq_53739504的博客
08-30 469
1.面向对象的三大特点 封装、继承、多态 1.封装 封装是将数据和行为相结合，通过行为约束代码修改数据的程度，增强数据的安全性，属性是C#封装的最好表现。 （将实现细节，通过接口形式暴漏给第三方，而第三方者不需要关心实现细节。） (virtual) 代表虚函数，意味着子类可以覆盖其实现，如果子类不覆盖那将是用父类的同名函数。 2.继承 提高代码重用度，增强软件可维护性的重要手段，符合开闭原则。 （就是将共用的属性或方法抽离到父类的过程。） （protected）只能子类调用，外界类不能访
c# 所有类的最终基类:Object
最新发布
naer_chongya的博客
05-04 504
所有C#中的类都继承了Object类，Object类是C#中最基本和最通用的类。Object类定义了一组方法，包括ToString()GetType()Equals()和。这些方法可以用于某些基本操作，如获取对象的类型、比较对象是否相等以及创建对象的副本。重写这些方法可以让我们更好地控制对象的行为，并且可以让我们更容易地进行调试和日志记录。
C#开发之——基类和派生类(6.1)
我的博客
07-21 2055
一 概述 继承时面向对象程序设计中最重要的概念之一 在C#语言中仅支持单重继承，主要用于解决代码的重用问题 继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易，同时也有利于重用代码和节省开发时间 <!--more--> 二 基类和派生类 当创建一个类时，我们不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可 这个已有的类被称为基类，这个新的类被称为派生类 继承的思想实现了属于(I
c#入门-访问基类成员
zms9110750的博客
12-13 857
在构建派生类前，会首先构建出完整的基类。，也会存在。因此才能保证派生类能完全地当作基类来使用。因此，在执行派生类的构造器前，首先需要先调用基类的构造器。而如果基类没有，或是无权访问他的，那么你就需要显式地声明派生类构造器，并指明如何调用基类构造器。显式调用基类构造器地语法是，把调用自己构造器的语法中的this改成base。关键字base即指代直接基类。
C#基础笔记（2）—— C#中的类
Dukenone的博客
09-14 5740
C#中的类
C#基类库(苏飞版)
05-16
《C#基类库(苏飞版)》是C#编程领域中一份极其珍贵的资源，它包含了广泛而深入的通用类库，旨在为开发者提供一套全面的工具集，简化开发过程并提高代码复用性。苏飞作为该资源的整理者，其贡献在于将这些分散的类库...
C#代码规范实施
02-17
本文档基于公司多年的开发经验和实践总结，旨在为C#项目提供一套全面且实用的代码规范。良好的代码规范不仅能提高代码的可读性和可维护性，还能增强团队协作效率。本文档详细介绍了在C#项目中应该遵循的各种规范，...
CSharp基类
01-13
asp.net类库,C#读取AD域里用户名和租，Common类库,Dot NET基础类库大全,SqlHelper基类,字符串加密
[C#基类库大全]---某飞版 2.0
12-20
苏飞C#基类库大全2.0版。全部源代码（包含DLL）。 SufeiUtil_V2.0
C#基类库大全（最全面的）
08-19
C#基类库大全（最全面的）
C#基类整理
10-12
我收集的C#基类，比较全.我收集的C#基类，比较全. 包含有： ASP.NET类库 C#读取AD域里用户名或组 Common类库 DotNet基础类大全 SqlHelper基类 字符串加密
c#继承
12-28 233
继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类来定义一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。 当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。 基类的初始化 派生类继承了基类的成员变量和成员方法。因...
C# 基础知识(七)_封装，继承，多态
个人学习笔记
03-02 692
C# 基础知识(七)_封装，继承，多态
C# 基类和派生类
热门推荐
DEV HOME
10-04 1万+
1. 基类和派生类的一些基本概念     class B : A{}   A 是基类 ,B 是派生类 .   一个类最多只允许从一个类中派生 .   class C : B{}   B 还可以充当 C 的派生类     继承总是隐式为 public 的 ,System.Object 是所有类的根     编译器会把你的类悄悄的编译
C#基础整理
qq_45497910的博客
10-31 1151
C#是一种面向对象的编程语言，由微软开发，由Ecma和ISO核准认可C#由Anders Hejlsberg和他的团队在.Net框架开发期间开发C#是专为公共语言基础结构（CLI）设计的现代的、通用的面向对象面向组件容易学习结构化语言产生高效率的程序可在多种计算机平台编译.Net框架的一部分C#中变量定义的语法C#中定义变量并变量初始化的语法正确的初始化变量可以减少很多程序的错误，不对变量进行初始化时会自动赋予默认值常量的定义需要用到const关键字。
C#基类全收集：深入理解与应用
资源摘要信息:"C#基类整理" C#（发音为“看井”）是一种由微软开发的面向对象的、运行于.NET框架之上的编程语言。C#的设计目标是为开发人员提供一种快速、简单、功能全面且类型安全的编程语言。在C#的世界里，基类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值