六虎

C#学习笔记(一)

C#学习笔记(一)

作者：

前端小智

在

记载一下c#学习笔记吧,编译软件下载Visual Studio Installer

注释

单行注释快捷键: (ctrl + k   ctrl + l)
撤销单行注释:(ctrl + k   ctrul + u)

Hello World！

using System; // 运用System命名空间
namespace ConsoleApp // 命名空间
{
    class demo // 界说类,类名为demo
    {
        static void Main(string[] args) // c#的进口函数
        {
            Console.Write("Hello World！");
            Console.WriteLine("hello world！");
        }
    }
}

Main办法是 C# 应用程序的进口点。
Write和WriteLine的区别是:Write输出不会换行,WriteLine会换行。

控制台输出

Console.Write("Hello World！");
Console.WriteLine("hello world！");

控制台输入

Console.ReadLine()
// 输入一行数据,会等到按下回车为一行输入结束,持续向下履行。 接收到的为字符串,假如想要转化为数值型的能够运用Convert.ToInt32(<要转化的变量>);
Console.ReadKey();
// 一次只读取一个字符,当用户按下恣意字符才会持续向下履行。

数据类型

在c#中数据类型分为三种:
1. 值类型
2. 引证类型
3. 指针类型

值类型

类型 描绘 范围 默许值
bool 布尔值 True 或 False False
byte 8 位无符号整数 0 到 255 0
char 16 位 Unicode 字符 U +0000 到 U +ffff ‘\0’
decimal 128 位精确的十进制值，28-29 有效位数 (-7.9 x 1028到 7.9 x 1028) / 100 到 28 0.0M
double 64 位双精度浮点型 (+/-)5.0 x 10-324到 (+/-)1.7 x 10308 0.0D
float 32 位单精度浮点型 -3.4 x 1038到 + 3.4 x 1038 0.0F
int 32 位有符号整数类型 -2,147,483,648 到 2,147,483,647 0
long 64 位有符号整数类型 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 0L
sbyte 8 位有符号整数类型 -128 到 127 0
short 16 位有符号整数类型 -32,768 到 32,767 0
uint 32 位无符号整数类型 0 到 4,294,967,295 0
ulong 64 位无符号整数类型 0 到 18,446,744,073,709,551,615 0
ushort 16 位无符号整数类型 0 到 65,535 0 
// 常用的几种数据类型
int a= 3; // 整型
float b = 3.5f; // 浮点型,数据后边需求加上f或许F
bool c = false; // 布尔类型
char d = 'a'; // 字符型(单引号为字符型)
string e = "11232eee"; // 字符串类型(双引号为字符串型)
// 能够用sizeof来查看详细类型所占字节数
Console.WriteLine("Size of int: {0}", sizeof(int));

数据类型转化

C# 是一门强类型语言，对类型要求比较严厉，可是在必定的条件下也是能够彼此转化的,数据类型转化分为两种一种是隐式类型转化,另一种是显现类型转化。

//隐式数据类型转化
int a = 1;
double b = a;
// 显现数据类型转化
double a = 1;
int b = (int)a;

常用的数据类型转化办法

// Parse办法
关于string类型是互相兼容的数据类型，将string类型转化为恣意根本类型。
string a = "34583764586438756";
int b = int.Parse(a);
double c = double.Parse(a);
// Convert类型转化能够将恣意数据类型转化为恣意类型
Convert.ToInt32(<要转化的变量>); // 转化为整型(int)
Convert.等....

隐式类型转化是安全的的,属于低精度转向高精度,显现转化需求强制转化,可能会造成精度丢掉。

引证类型

目标类型

目标类型是 C# 通用类型系统中所有数据类型的终极基类。Object是System.Object类的别名。所以目标类型能够被分配任何其他类型(值类型、引证类型、预界说类型或用户自界说类型)的值。可是，在分配值之前，需求先进行类型转化。当一个值类型转化为目标类型时，则被称为装箱；另一方面，当一个目标类型转化为值类型时,则被称为拆箱。

object obj;
obj = 100; // 这是装箱
int x = (int)obj; // 这是拆箱

动态类型

能够存储任何类型的值在动态数据类型变量中。这些变量的类型查看是在运行时产生的。与目标类型类似，可是目标类型变量的类型查看是在编译时产生的，而动态类型变量的类型查看是在运行时产生的。

dynamic <变量名> = value;

C#学习笔记(一)

C#学习笔记(一)

字符串类型

字符串类型答应给变量分配任何字符串值。字符串类型是 System.String 类的别名。它是从目标（Object）类型派生的。字符串（String）类型的值能够经过两种方式进行分配：引号和 @引号。

string str = @"C:\Windows";

加上@符号,这被称为”逐字字符串”,他能够将转义字符变成普通字符运用(空格,换行符等也会被计算在其中),假如需求在里面输出一个引号则需求写一对引号,如下:

string x = @"123\123""123";  // 123\123"123

指针类型

C# 为了类型安全，默许并不支撑指针。可是也并不是说 C# 不支撑指针，我们能够运用unsafe关键词，敞开不安全代码(unsafe code)开发形式。在不安全形式下，我们能够直接操作内存，这样就能够运用指针了。在不安全形式下，CLR并不检测unsafe代码的安全，而是直接履行代码。unsafe代码的安全需求开发人员自行检测。

// unsafe 关键词的运用
// 声明整个办法作为不安全代码
usingSystem;  
namespace ConsoleApp
{
    class Program
    {
        static unsafe void Main(string[] args)
        {
        }
    }
}
// 声明办法的一部分作为不安全代码
using System;
namespace ConsoleApp
{
    class Program
    {
        public static void Main()
        {
            unsafe
            {
                int i = 20;
                int* p = &i;
                Console.WriteLine("Address is: {0} ", (int)p);
            }
            Console.ReadKey();
        }
    }
}

C#在有限的范围内支撑指针。C#的指针是一个持有另一类型内存地址的变量。在C#中，指针只能被声明为持有值类型和数组的内存地址。与引证类型不同，指针类型不被默许的废物收集机制所跟踪。出于相同的原因，指针不答应指向引证类型,甚至不答应指向包括引证类型的结构类型。

界说指针

实例 描绘
int* p p是指向整数的指针。
double* p p是指向双精度数的指针。
float* p p是指向浮点数的指针。
int** p p是指向整数的指针的指针。
int*[] p p是指向整数的指针的一维数组。
char* p p是指向字符的指针。
void* p p是指向未知类型的指针。

声明多个指针的写法如下:

int* p1, p2, p3;

指针操作符

操作符 说明
* 取值运算符
& 取址运算符
-> 经过指针处理结构体中的数据（获取或赋值）
++与– 指针增、减操作
fixed 用户暂时固定保管代码中引证类型的位置。
Stackallc 分配内存

unsafe修饰符时指针的运用

// 运用了**unsafe**修饰符时指针的运用
usingSystem;  
namespaceConsoleApp  
{  
 classProgram  
 {  
   staticunsafevoidMain(string[]args)  
   {  
     intvar=20;  
     int*p=&var;  
      Console.WriteLine("数据是: {0} ", var);  
      Console.WriteLine(数据寄存的地址是: {0}", (int)p);  
      Console.ReadKey();  
   }  
 }  
}

C#学习笔记(一)

运用指针检索数据值

// 运用指针检索数据值
// 不用声明整个办法作为不安全代码，只声明办法的一部分作为不安全代码。
namespace UnsafeCodeApplication
{
    class Program
    {
        public static void Main()
        {
            unsafe
            {
                int var = 20;
                int* p = &var;
                Console.WriteLine("数据是: {0} ", var);
                Console.WriteLine("数据是: {0} ", p->ToString());
                Console.WriteLine("数据寄存的地址是: {0} ", (int)p);
            }
        }
    }
}

C#学习笔记(一)

传递指针作为办法的参数

class TestPointer
{
    public unsafe void swap(int* p, int* q)
    {
        int temp = *p;
        *p = *q;
        *q = temp;
    }
    public unsafe static void Main()
    {
        TestPointer p = new TestPointer();
        int var1 = 10;
        int var2 = 20;
        int* x = &var1;
        int* y = &var2;
        Console.WriteLine("转化前: var1:{0}, var2: {1}", var1, var2);
        p.swap(x, y);
        Console.WriteLine("转化后: var1:{0}, var2: {1}", var1, var2);
        Console.ReadKey();
    }
}

C#学习笔记(一)

固定Fixed

在废物收集过程中，C#废物收集器能够随意移动内存中的目标。C#提供了一个特别的关键字fixed来告知废物收集器不要移动一个目标。

在语句块前输入关键字fixed，将会告知CLR块内的目标不能重定位，这样CLR就不会重定位指针指向的数据存储方位。因而在C#固定指针时，运用关键字fixed将能阻挠程序运行时无效指针的产生。

class TestPointer
{
    public unsafe static void Main()
    {
        int[] list = { 10, 100, 200 };
        fixed (int* ptr = list)
            /* 显现指针中数组地址 */
            for (int i = 0; i < 3; i++)
            {
                Console.WriteLine("Address of list[{0}]={1}", i, (int)(ptr + i));
                Console.WriteLine("Value of list[{0}]={1}", i, *(ptr + i));
            }
        Console.ReadKey();
    }
}

常量

常量是固定值，程序履行期间不会改动。常量能够是任何根本数据类型，比方整数常量、浮点常量、字符常量或许字符串常量，还有枚举常量。

// 界说常量
const <数据类型> <常量名称> = 值;
const int i = 10;

封装

封装被界说为”把一个或多个项目封闭在一个物理的或许逻辑的包中”。在面向目标程序设计办法论中，封装是为了防止对完成细节的拜访。

  • public：所有目标都能够拜访；
  • private：目标自身在目标内部能够拜访；
  • protected：只要该类目标及其子类目标能够拜访
  • internal：同一个程序集的目标能够拜访；
  • protected internal：拜访限于当时程序集或派生自包括类的类型。

public

所有目标都能够拜访

using System;
namespace packaging
{
    class APP1
    {
        public int lenght = 10;
    }
    class APP2
    {
        public static void Main (String[] args)
        {
            var p = new APP1();
            Console.WriteLine(p.lenght);
        }
    }
}

C#学习笔记(一)

假如将public改为private或protected则会收到过错音讯不行拜访，因为它受维护等级约束。

C#学习笔记(一)

protected

只要在经过派生类类型进行拜访时，基类的受维护成员在派生类中才是可拜访的。

    class Point
    {
        protected int x;
        protected int y;
    }
    class DerivedPoint : Point
    {
        static void Main()
        {
            var dpoint = new DerivedPoint();
            var p = new Point();
            // p.x = 20;
            dpoint.x = 10;
            dpoint.y = 15;
            Console.WriteLine($"x = {dpoint.x}, y = {dpoint.y}");
        }
    }

语句p.x = 20;生成过错，因为它是在静态办法 Main 中生成的，而不是类 Point 的实例。

C#学习笔记(一)

internal

只要在同一程序集的文件中，内部类型或成员才可拜访

// APP1.cs
using System;
namespace demo1
{
    public class APP1
    {
        internal int i = 30;
    }
}
// APP2.cs
using System;
using static demo1.APP1;
namespace demo1
{
    internal class APP2
    {
        static void Main()
        {
            var P = new demo1.APP1();
            Console.WriteLine(P.i);
        }
    }
}

C#学习笔记(一)

private

私有拜访是答应的最低拜访等级。 私有成员只要在声明它们的类和结构体中才是可拜访的，如以下示例所示：

    class demo
    {
        private readonly string i = "私有成员";
        public string GetData()
        {
            Console.WriteLine(i);
            return i;
        }
    }
    class read
    {
    static void Main()
        {
            var p = new demo();
            //Console.WriteLine(p.i);
            p.GetData();
        }
    }

语句Console.WriteLine(p.i);生成过错不行拜访,因为它具有必定的维护等级

C#学习笔记(一)

小结

先发布一下,还挺长的,分明上学的时候学过,有种死去的回忆在攻击自己的感觉,哈哈哈！只好从头学起了！

本文正在参与「金石方案」

更多文章