C#入门介绍及其面向对象思想

墨蓝 2023-02-20 02:39 28阅读 0赞

## C\#语言简介 ##

C\#是微软旗下写的一种类JAVA的编程语言(面向对象)，它是专门为与Microsoft的.NET Framework 一起使用而设计的，它是一种基于现代面向对象设计方法的语言

## C\#各类应用程序简介 ##

**Windows Forms(Old)：**

用于创建Windows桌面应用程序，Windows Forms窗体包含的只是封装了原生的Windows控件，所以是基于像素图形的。

**WPF(Windows Presentation Foundation)：**

WPF与Windows Forms一样用于创建Windows桌面应用程序，但是它是一种基于矢量图的新技术

**ASP.NET Web Forms(Old)：**

这是ASP.NET的最初形式，仅仅提供web窗体，其目标是按照Windows应用程序开发人员编写应用程序的方式轻松地创建Web应用程序，是不必编写HTML和JavaScript的。

**ASP.NET MVC(Model-View-Controller)：**

前端页面HTML和JavaScript的重要性变强，相应地，ASP.NET中出现了新的框架，不只方便编写了HTML和JavaScript，还基于流行的MVC模式提供了代码的分离，从而更便于进行单元测试，这个框架就是ASP,NET MVC。

**WCF(Windows Communication Foundation)：**

WCF是一种功能丰富的技术，是一种连接各种系统的强大的新方式，提供了多种通信选项，既可以使用基于REST的通信，也可以使用基于SOAP的通信。

**Windows Store Application：**

Windows Store应用程序将重点放在内容上，只提供用户与内容交互所需的任务，而不是提供他们可以使用的不同选项。Windows8的设计就是基于这样的思路。

## C\#的类与名称空间 ##

名称空间是.NET避免类名冲突的一种方式，相当于java中的packedge一样，比如在多个packedge中都有bag这个类，此时因为有不同包名的存在，所以这个bag类就不会存在冲突，C\#中的namespace也是这个意思。

## 类、对象、类成员简介 ##

类的三大成员：属性(Property)、方法(Method)、事件(Event)

## 面向对象的C\# ##

**C\#默认访问权限**

1.  在namespace中的类、接口默认是internal类型的，也可以显示的定义为public类型，不允许是其他访问类型
2.  在一个类中，属性和方法默认是private的，也可以显示的定义为public、private、protected、internal、protected internal
3.  接口中不能定义成员变量，接口中的方法默认为public的访问权限
4.  抽象类中必须有一个以上的抽象方法，抽象方法可以是public、internal、protected。不能是private的访问类型。

public可以被任意存取

protected只可以被本类和其继承子类存取

internal只可以被本组合体内所有的类存取

protected internal 只可以被本组合体内所有的类和这些类的继承子类所存取

private只可以被本类所存取。

**继承**：子类可以继承父类的属性和方法

**重写**：(virtual - override)

**多态**：当我们用一个父类的变量引用一个子类的实例时，调用一个被重写的成员时，我们总是能够调用到被继承类链上的最新的版本

一个结合抽象类和接口以及继承关系的例子：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3_size_16_color_FFFFFF_t_70][]

using System;
    using System.Collections.Generic;
    using System.Text;
    
    namespace Helloworld
    {
        interface  VehicleBase
        {
            void Stop();
            void run();
        }
        abstract class Vehicle : VehicleBase
        {
            public  void Stop()
            {
                Console.WriteLine("stopped");
            }
            abstract public void run();
        }
        class Car : Vehicle
        {
            public override void run()
            {
                Console.WriteLine("car is running");
            }
        }
        class Truck : Vehicle
        {
            public override void run()
            {
                Console.WriteLine("Truck is running");
            }
        }
    }

**抽象类接口总结**：

具体类->抽象类->接口:越来越抽象，内部实现的东西越来越少；

抽象类是未完全实现逻辑的类，抽象类为复用而生，专门作为基类来使用，也具有解耦功能

接口是完全未实现逻辑的“类“（”纯虚类“，只有函数成员，且成员全部public(隐藏)），接口为解耦而生，方便单元测试

接口和抽象类都不能实例化，只能用来声明变量，引用具体类的实例。

**接口(解耦依赖原则)**：

接口的解耦特性体现在，当我们构建一个类并且调用它时，如果这个类被调用时内部发生错误，那么此时我们需要去修改这个类，但是根据面向对象的封装原则，即当我们写好一个类以后，这个类就要尽可能的避免修改，所以这里引入接口这个概念，在接口中定义好抽象的类，我们写好实际的类去实现这个接口，当调用这个类出现错误时，我们就不用再去找到这个错误类的内部去修改，此时便完成了解耦。

**接口隔离原则，接口单一职责原则：**接口不可以有太多无关的方法，换句话说，接口必须有功能性，指定职责的功能。需要分离大接口，把本质不同的功能给隔离开。

小例子：

using System;
    
    namespace interfaceExample
    {
        class Program
        {
            static void Main(string[] args)
            {
                var driver = new Driver(new lightTank());
                driver.drive();
            }
        }
        class Driver
        {
            private Ivehicle _ivehicle;
            public Driver(Ivehicle ivehicle)
            {
                _ivehicle = ivehicle;
            }
            public void drive()
            {
                _ivehicle.run();
            }
        }
        interface Ivehicle {
            void run();
        }
    
        class car : Ivehicle
        {
            public void run()
            {
                Console.WriteLine("car is running");
            }
        }
    class Truck : Ivehicle
        {
            public void run()
            {
                Console.WriteLine("Truck is running");
            }
        }
        interface Iweapon
        {
            void fire();
        }
        interface itank : Ivehicle, Iweapon
        {
    
        }
        class lightTank : itank
        {
            public void fire()
            {
                Console.WriteLine("fire...");
            }
    
            public void run()
            {
                Console.WriteLine("tank is running");
            }
        }
    }

上述例子在构建坦克时，因为坦克拥有fire和run两个功能，如下两图所示，第一张图是违反了接口单一原则的，而第二张则对其进行了优化，上述代码为第二张图的陈述。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3_size_16_color_FFFFFF_t_70 1][]

**此外当类实现接口时，有一种显示实现接口的方式，**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3_size_16_color_FFFFFF_t_70 2][]

**一般情况下创建warmkiller时，这时是看不到kill方法的，需要自己构建ikiller对象，**

**IKiller killer = new WarmKiller();**

**Killer.kill();**

**如上所示，否则这个kill方法是无法被查看到的**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020062213590185.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200622140107272.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200622140124616.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NjYwOTU3,size_16,color_FFFFFF,t_70