C# 类型、变量与对象

news2025/1/18 6:49:53

变量一共7种：

静态变量（静态字段）、实例变量（成员变量、字段）、数组元素、值参数、引用参数、输出形参、局部变量

狭义的变量就是局部变量

内存的最小单位是比特（byte），8个比特为1个字节

内存为每个字节准备一个编号。

内存地址就是一个字节在计算机科学当中的编号。

byte类型数据的内存大小：8byte，即1个字节，范围：0-255（无符号数）

sbyte，所占内存大小与byte相同，但是有符号数。范围：-128-127

当存入正数时首位为0，其余转二进制；若存入负数，则先将其正数转二进制，然后按位取反再加1

ushort, 占16byte，2个字节。取值范围：0-65535

short，有符号数，占16byte，取值范围：-32768-32767

引用类型变量里存储的是引用类型的实例在堆内存上的内存地址

通过地址访问实例

局部变量在栈上分配内存

方法永远都是类（或结构体）的成员，是类（或结构体）最基本的成员之一。

类最基本的成员只有两个：字段和方法（成员变量和成员函数），本质还是数据+算法

耦合是指不同类之间方法的依赖性，方法在一个类中只会增加内聚而不会耦合。

parameter: 形参

argument：实参

快捷生成：ctor+2下Tab自动生成构造器

int? 表示此int值可以是空值

方法的重载：

方法签名唯一，由方法的名称、类型形参的个数和它的每一个形参（从左到右顺序）的类型和种类（值、引用或输出）组成。方法签名不包含返回类型。

逐语句：Step Into F11

逐过程：Step Over F10

跳出： Step Out shift + F11

带有赋值的操作符从右向左运算。

为匿名类型创建对象，并用隐式类型变量引用这个实例：

var person = new {Name="Mr.Okay", Age=34};

new作为操作符使用： Form myForm = new Form();

重写方法是override，隐藏方法是new

C++匿名函数例子：

auto add = [](int x, int y) -> int { return x + y; }; // 定义一个匿名函数，用于两个整数相加

cout << add(3, 4) << endl; // 调用匿名函数，输出7

使用sizeof关键字，只能得到struct类型的内存大小，string和object都不可以。

在获取自定义struct类型的内存大小时，需要将sizeof()代码放在unsafe下。

class Program
    {
        static void Main(string[] args)
        {
          	unsafe
          	{
            	int l = sizeof(Student);
          	}
        }
		}
struct Student
{
	int ID;
	long Score;
}

C#的指针只能用来操作struct类型。

不安全的上下文：sizeof、->、&x、*x

原码取反加1得相反数。

checked关键字使用例子

namespace checkedExample
{
    class Program
    {
        static void Main(string[] args)
        {
            uint x = uint.MaxValue;
            Console.WriteLine(x);
            string binStr = Convert.ToString(x, 2);
            Console.WriteLine(binStr);
            
            //try
            //{
            //    uint y = checked(x + 1); //检查是否溢出
            //    //uint y = unchecked(x + 1);
            //    Console.WriteLine(y);
            //}
            //catch (OverflowException ex)
            //{
            //    Console.WriteLine("This is overflow!");
          
            //}

            //写法2
            checked
            {
                try
                {
                    uint y = x + 1;
                    Console.WriteLine(y);
                }
                catch (OverflowException ex)
                {
                    Console.WriteLine("This is overflow!");

                }
            }
            Console.ReadKey();

        }
    }
}

判断字符串是否为空，若为空抛出异常。

namespace checkedExample
{
    class Program
    {
        static void Main(string[] args)
        {
            Student s = new Student(null);
            Console.WriteLine(s.Name);

        }
    }
    class Student
    {
        public Student(string initName)
        {
            //判断字符是否为空
            if (!string.IsNullOrEmpty(initName))
            {
                this.Name = initName;
            }
            else
            {
                throw new ArgumentException("initName cannot be null or empty!");
            }

        }
        public string Name;
    }

}

块语句：block

迭代器

foreach

最佳使用场景：对集合遍历

属性

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AttributeExample
{
    class Program
    {
        static void Main(string[] args)
        {
            
            try
            {
                Student stu1 = new Student();
                stu1.Age = 20;
                Student stu2 = new Student();
                stu2.Age = 30;
                Student stu3 = new Student();
                stu3.Age = 490;
                int avgAge = (stu1.Age + stu2.Age + stu3.Age) / 3;
                Console.WriteLine(avgAge);

            }
            catch (Exception e)
            {

                Console.WriteLine(e.Message);
            }
            Console.ReadKey();
            
        }
    }
    class Student
    {
        private int age;
        public int Age
        {       
            get
            {
                return this.age;
            }
            set
            {
                if(value>0 && value<=120)
                {
                    this.age = value;
                }
                else
                {
                    throw new Exception("Age was has error!");
                }
            }
        }
    }

}

属性的完整声明：

快捷键：propfull+俩下tab键

属性的简略声明：

快捷键：prop+俩下tab键

public string Name{get; set;}

ctrl+R+E定义get set中的内容

静态只读字段VS常量

常量不能定义类类型或结构体类型；

可以用static resdonly来代替。

传值参数

当无法靠属性值来判断两个对象是否一致，可使用GetHashCode()，每个对象的hashCode都不一样。

在方法中创建新对象时，原对象和方法中的对象不一样

static void Main(string[] args)
{
	Student stu = new Student(){Name="Tim");
	SomeMethod(stu);
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);
}
static void SomeMethod(Student stu)
{
	stu = new Student(){Name="Tim");
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);
}
class Student
{
	public string Name{get; set;}
}

方法中没有创建新对象时，原对象和方法中的对象一样

static void Main(string[] args)
{
	Student stu = new Student(){Name="Tim");
	SomeMethod(stu);
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);
}
static void SomeMethod(Student stu)
{
	stu.Name="Tom"; //副作用，side-effect
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);
}
class Student
{
	public string Name{get; set;}
}

引用参数

static void Main(string[] args)
{
	int y = 1;
	IWantSideEffect(ref y);
	Console.WriteLine(y);
}
static void IWantSideEffect(ref int x)
{
	x += 100;

}

static void Main(string[] args)
{
	Student outterStu = new Student(){Name="Tim"};
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);
	Console.WriteLine("----------------------------------");
	IWantSideEffect(ref outterStu);
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);
}
static void IWantSideEffect(ref Student stu)
{
	stu = new Student(){Name="Tom");
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);

}

class Student
{
	public string Name{get; set;}
}

static void Main(string[] args)
{
	Student outterStu = new Student(){Name="Tim"};
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);
	Console.WriteLine("----------------------------------");
	IWantSideEffect(ref outterStu);
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);
}
static void IWantSideEffect(ref Student stu)
{
	stu.Name="Tom";
	Console.WriteLine("{0}, {1}", stu.GetHashCode(), stu.Name);

}

class Student
{
	public string Name{get; set;}
}

此种对象操作引用参数和传值参数得到的结果一样，

但是传值参数在内存当中创建了实际参数的副本，即outterStu和stu两个变量所指向的内存地址不一样，但是两个不同的内存地址中却存储着一个相同的地址，即实例在堆内存中的地址。

对于引用参数来说，outterStu和stu两个变量所指向的内存地址是同一个内存地址

输出参数

使用输出参数实例：

class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Please input first number:");
            string arg1 = Console.ReadLine();
            double x = 0;
            bool b1 = double.TryParse(arg1, out x);
            if(b1==false)
            {
                Console.WriteLine("Input error!");
                return;
            }
            Console.WriteLine("Please input second number:");
            string arg2 = Console.ReadLine();
            double y = 0;
            bool b2 = double.TryParse(arg2, out y);
            if(b2==false)
            {
                Console.WriteLine("Input error");
                return;
            }
            Console.WriteLine("{0}+{1}={2}", x, y, x+y); 
        }
    }

实现TryParse内容：

class DoubleParser
    {
        public static bool TryParse(string input, out double result)
        {
            try
            {
                result = double.Parse(input);
                return true;
            }
            catch 
            {
                result = 0;
                return false;
            }
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            Student stu = null;
            bool b = StudentFactory.Create("Tim", 34, out stu);
            if(b==true)
            {
                Console.WriteLine("Student {0}, age is {1}.", stu.Name, stu.Age);
            }


        }
    }
    class Student
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    class StudentFactory
    {
        public static bool Create(string stuName, int stuAge, out Student result)
        {
            result = null;
            if(string.IsNullOrEmpty(stuName))
            {
                return false;
            }
            if(stuAge<20 || stuAge>80)
            {
                return false;
            }
            result = new Student() { Name = stuName, Age = stuAge };
            return true;
        }
    }

数组参数

关键字：params

class Program
    {
        static void Main(string[] args)
        {
            //int[] arr = { 1, 2, 3 };
          	int[] arr = new int{1, 2, 3};
            int sum = CalculateSum(arr);
            Console.WriteLine(sum);


        }
        static int CalculateSum(int[] intArray)
        {
            int sum = 0;
            foreach (var item in intArray)
            {
                sum += item;
            }
            return sum;
        }
    }

如上面代码，没有params参数时，函数CalculateSum中引用的必须是提前初始化好的数组；

当引用params参数后，可以不提前初始化数组直接填写数组中的内容即可，结果与上面代码相同。如下代码：

class Program
    {
        static void Main(string[] args)
        {
            int sum = CalculateSum(1, 2, 3);
            Console.WriteLine(sum);


        }
        static int CalculateSum(params int[] intArray)
        {
            int sum = 0;
            foreach (var item in intArray)
            {
                sum += item;
            }
            return sum;
        }
    }
将字符串按指定字符分割
 class Program
    {
        static void Main(string[] args)
        {
            string str = "Tim;Tom,Army,Lisa";
            string[] result = str.Split(',', ';', '.');
            foreach (var item in result)
            {
                Console.WriteLine(item);
            }
        }    
    }

具名参数

class Program
    {
        static void Main(string[] args)
        {
            PrintInfo(age: 34, name: "Tim");
        }   
        static void PrintInfo(string name, int age)
        {
            Console.WriteLine("Hello {0}, you are {1}.", name, age);
        }
    }

可选参数

class Program
    {
        static void Main(string[] args)
        {
            PrintInfo();
        }   
        static void PrintInfo(string name="Tim", int age=34)
        {
            Console.WriteLine("Hello {0}, you are {1}.", name, age);
        }
    }

扩展方法（this 参数）

class Program
    {
        static void Main(string[] args)
        {
            double x = 3.14159;
            //double类型不具有Round方法，使用Math.Round实现
            double y = Math.Round(x, 4);
            Console.WriteLine(y);
            //使用扩展类型为double类型自定义Round方法，
            //下面x是第一个参数，4是第二个参数
            double ny = x.Round(4);
            Console.WriteLine(ny);
        }   
        
    }
    static class DoubleExtension
    {
        public static double Round(this double input, int digits)
        {
            double result = Math.Round(input, digits);
            return result;
        }
    }

注意，定义中有this关键字：public static double Round(this double input, int digits)

class Program
    {
        static void Main(string[] args)
        {
            List<int> arr = new List<int>{ 12, 11, 42 };
            //常规判断数组中是否所有数都大于10
            bool result = AllGreaterThanTen(arr);
            Console.WriteLine(result);
            //使用引用 添加命名空间 using System.Linq;
            bool result2 = arr.All(i => i > 10);
            Console.WriteLine(result2);

        }
        static bool AllGreaterThanTen(List<int> intList)
        {
            foreach (var item in intList)
            {
                if(item<10)
                {
                    return false;
                }
            }
            return true;
        }  
    }

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1052090.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【数据结构】【C++】封装哈希表模拟实现unordered_map和unordered_set容器

【数据结构】【C++】封装哈希表模拟实现unordered_map和unordered_set容器

【数据结构】&&【C】封装哈希表模拟实现unordered_map和unordered_set容器 一.哈希表的完成二.改造哈希表(泛型适配)三.封装unordered_map和unordered_set的接口四.实现哈希表迭代器(泛型适配)五.封装unordered_map和unordered_set的迭代器六.解决key不能修改问题七.实…
阅读更多...
Stm32_标准库_5_呼吸灯_按键控制

Stm32_标准库_5_呼吸灯_按键控制

Stm32按键和输出差不多 PA1为LED供给正电&#xff0c;PB5放置按键&#xff0c;按键一端接PB5,另一端接负极 void Key_Init(void){RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); //APB2总线连接着GPIOBGPIO_InitStructur.GPIO_Mode GPIO_Mode_IPU;GPIO_InitStructur.…
阅读更多...
Java下对象的序列化和反序列化（写出和读入）

Java下对象的序列化和反序列化（写出和读入）

代码如下&#xff1a; public class MyWork {public static void main(String[] args) throws IOException, ClassNotFoundException {//序列化File f new File("testFile/testObject.txt");ObjectOutputStream oos new ObjectOutputStream(new FileOutputStream(…
阅读更多...
数据结构:堆的实现和堆排序及TopK问题

数据结构:堆的实现和堆排序及TopK问题

文章目录 1. 堆的概念和性质1.1 堆的概念1.2 堆的性质1.3 堆的作用 2. 堆的声明3. 堆的实现3.1 堆的插入3.2 删除堆顶元素3.3 利用数组建堆3.4 完整代码 4. 堆的应用4.1 堆排序4.2 TopK问题代码实现 物理结构有顺序结构存储和链式结构存储两种,二叉树理所应当也是可以顺序结构存…
阅读更多...
实时通信协议

实时通信协议

本文旨在简要解释如何在Web上实现客户端/服务器和客户端/客户端之间的实时通信&#xff0c;以及它们的内部工作原理和最常见的用例。 TCP vs UDP TCP和UDP都位于OSI模型的传输层&#xff0c;负责在网络上传输数据包。它们之间的主要区别在于&#xff0c;TCP在传输数据之前会打开…
阅读更多...
26960-2011 半自动捆扎机 学习笔记

26960-2011 半自动捆扎机 学习笔记

声明 本文是学习GB-T 26960-2011 半自动捆扎机. 而整理的学习笔记,分享出来希望更多人受益,如果存在侵权请及时联系我们 1 范围 本标准规定了半自动捆扎机(以下简称"捆扎机")的术语和定义、型号、型式与基本参数、技术要求、 试验方法、检验规则及标志、包装、运…
阅读更多...
Python变量的三个特征

Python变量的三个特征

嗨喽&#xff0c;大家好呀~这里是爱看美女的茜茜呐 我们来看这些代码 x 10 print(x) # 获取变量的变量值 print(id(x)) # 获取变量的id&#xff0c;可以理解成变量在内存中的地址python的内置功能id()&#xff0c;内存地址不一样&#xff0c;则id()后打印的结果不一样&…
阅读更多...
【HTML】表格行和列的合并

【HTML】表格行和列的合并

概述 当我们需要在 HTML 表格中展示复杂的数据时&#xff0c;行和列的合并可以帮助我们实现更灵活的布局和结构。通过合并行和列&#xff0c;我们可以创建具有更多层次和结构的表格&#xff0c;使数据更易于理解和分析。 在 HTML 表格中&#xff0c;我们可以使用 rowspan 和 …
阅读更多...
【Spring Cloud】深入探索 Nacos 注册中心的原理，服务的注册与发现，服务分层模型，负载均衡策略，微服务的权重设置，环境隔离

【Spring Cloud】深入探索 Nacos 注册中心的原理，服务的注册与发现，服务分层模型，负载均衡策略，微服务的权重设置，环境隔离

文章目录 前言一、初识 Nacos 注册中心1.1 什么是 Nacos1.2 Nacos 的安装&#xff0c;配置&#xff0c;启动 二、服务的注册与发现三、Nacos 服务分层模型3.1 Nacos 的服务分级存储模型3.2 服务跨集群调用问题3.3 服务集群属性设置3.4 修改负载均衡策略为集群策略 四、根据服务…
阅读更多...
【JUC】一文弄懂@Async的使用与原理

【JUC】一文弄懂@Async的使用与原理

文章目录 1. Async异步任务概述2. 深入Async的底层2.1 Async注解2.2 EnableAsync注解2.3 默认线程池 1. Async异步任务概述 在Spring3.X的版本之后&#xff0c;内置了Async解决了多个任务同步进行导致接口响应迟缓的情况。 使用Async注解可以异步执行一个任务&#xff0c;这个…
阅读更多...
棱镜七彩受邀参加“数字政府建设暨数字安全技术研讨会”

棱镜七彩受邀参加“数字政府建设暨数字安全技术研讨会”

近日&#xff0c;为深入学习贯彻党的二十大精神&#xff0c;落实《数字中国建设整体布局规划》中关于“发展高效协同的数字政务”的要求&#xff0c;由国家信息中心主办、复旦大学义乌研究院承办、苏州棱镜七彩信息科技有限公司等单位协办的“数字政府建设暨数字安全技术研讨会…
阅读更多...
zemax埃尔弗目镜

zemax埃尔弗目镜

可以认为是一种对称设计&#xff0c;在两个双胶合透镜之间增加一个双凹单透镜 将半视场增大到30&#xff0c;所有的轴外像差维持在可以接受的水平。 入瞳直径4mm波长0.51、0.56、0.61半视场30焦距27.9mm 镜头参数&#xff1a; 成像效果&#xff1a;
阅读更多...
Win11配置多个CUDA环境

Win11配置多个CUDA环境

概述 由于跑项目发现需要配置不同版本的Pytorch&#xff0c;而不同版本的Pytorch又对应不同版本的CUDA&#xff0c;于是有了在Win上装多个CUDA的打算 默认已经在电脑上装了一个CUDA 现在开始下载第二个CUDA版本&#xff0c;前面下载的操作和普通安装的几乎一样 安装CUDA CU…
阅读更多...
CFS内网穿透靶场实战

CFS内网穿透靶场实战

一、简介 不久前做过的靶场。 通过复现CFS三层穿透靶场&#xff0c;让我对漏洞的利用&#xff0c;各种工具的使用以及横向穿透技术有了更深的理解。 一开始nmap探测ip端口,直接用thinkphpv5版本漏洞工具反弹shell&#xff0c;接着利用蚁剑对服务器直接进行控制&#xff0c;留下…
阅读更多...
识别消费陷阱，反消费主义书单推荐

识别消费陷阱，反消费主义书单推荐

在消费主义无所不在的今天&#xff0c;商家是如何设置消费陷阱的&#xff1f;人们在做出消费决策时又是如何“犯错”的&#xff1f;如何才能做出更加理性的选择&#xff1f; 本书单适合对经济学、市场营销感兴趣的朋友阅读。 《小狗钱钱》 “你的自信程度决定了你是否相信自已…
阅读更多...
kaggle_competition1_CIFAR10_Reg

kaggle_competition1_CIFAR10_Reg

一、查漏补缺、熟能生巧&#xff1a; 1.关于shutil.copy或者这个copyfile的作用和用法&#xff1a; 将对应的文件复制到对应的文件目录下 2.关于python中dict的键值对的获取方式&#xff1a; #终于明白了&#xff0c;原来python中的键_值 对的用法就是通过调用dict.keys()和…
阅读更多...
Windows/Linux下进程信息获取

Windows/Linux下进程信息获取

Windows/Linux下进程信息获取 前言一、windows部分二、Linux部分三、完整代码四、结果 前言 Windows/Linux下进程信息获取&#xff0c;目前可获取进程名称、进程ID、进程状态 理论分析&#xff1a; Windows版本获取进程列表的API: CreateToolhelp32Snapshot() 创建进程快照,…
阅读更多...
GPIO的输入模式

GPIO的输入模式

1. GPIO支持4种输入模式&#xff08;浮空输入、上拉输入、下拉输入、模拟输入&#xff09; 1. 模拟输入 首先GPIO输出部分(N-MOS,P-MOS)是不起作用的。并且TTL施密特触发器也是不工作的。 上下拉电阻的开关都是关闭的。相当于I/o直接接在模拟输入。 模拟输入模式下&#xff…
阅读更多...
测试开源下载模块Downloader

测试开源下载模块Downloader

微信公众号“DotNet”的文章《.NET 异步、跨平台、支持分段下载的开源项目 》&#xff08;参考文献1&#xff09;介绍了GitHub中的开源下载模块Downloader的基本用法&#xff0c;本文学习Downloader的主要参数设置方式及基本用法&#xff0c;最后编写简单的测试程序进行文件下载…
阅读更多...
[尚硅谷React笔记]——第2章 React面向组件编程

[尚硅谷React笔记]——第2章 React面向组件编程

目录&#xff1a; 基本理解和使用&#xff1a; 使用React开发者工具调试函数式组件复习类的基本知识类式组件组件三大核心属性1: state 复习类中方法this指向&#xff1a; 复习bind函数&#xff1a;解决changeWeather中this指向问题&#xff1a;一般写法&#xff1a;state.htm…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023