【C#】C#超急速举例入门-适用有C/C++语言基础

CrazyPanda发表于：2024-01-30 23:00:43浏览：339次TAG：

前提

编程环境：vs2022

电脑系统：win10

学习目的：

能看懂c#，不纠结各种细节，快速适应开发。

入门篇

程序结构

变量类型

类似c语言，不掌握细节，int，float，double都有。

输入输出

Console.WriteLine("变量0：{0}", para0);
var a=Console.ReadLine();

运算符

几乎相同。

sizeof();

typeof();

取地址，取值：&，*；

三元运算符：？：

判断类型：is

强制转换：as。

注释

多行与当行还有文档

两种交互模式

.net 平台：c/s，b/s。

中级篇

方法

基本同函数。

参数

引用参数，输出参数，值传递参数。

体现为ref，out以及普通参数。

void getnames( int id,out name,ref nickname)

类

成员：字段、方法

属性：例子：public string name{ get;set;}

扩充：public string name{ get{return name;}set{name=value;}}

name是此类中的字段。

属性用于保护字段。

属性（Property）的访问器（accessor）包含有助于获取（读取或计算）或设置（写入）属性的可执行语句。访问器（accessor）声明可包含一个 get 访问器、一个 set 访问器，或者同时包含二者。

总而言之，我们给属性赋值，最终去向了字段。

派生类

class 派生类：父类（基类）

抽象

抽象关键字：abstract

未完成的方法或者类等等。

抽象类，抽象属性，抽象方法。

接口

定义类似于类，可以搭配实现多继承。

多态与重载

方法多态

同一个事件发生在不同的对象上会产生不同的结果。

运算符重载

方法重载

public int Add(int a, int b, int c)  
        {  
            return a + b + c;  
        }  
        public int Add(int a, int b)  
        {  
            return a + b;  
        }

对象的多态特性，以及多继承举例

在参数类型为fulei1的情况下，输入进去的是zilei也可，说明了zilei也是fulei1，但是反之不行，也就是zilei类型的参数不能填入fulei1.

    internal class Program
    {
        static void Main(string[] args)
        {
            zilei zl = new zilei();
            zl.draw2(zl);
        }
    }
 
    public abstract class fulei1 {
 
        public abstract void draw();
         
    }
    public class fulei2 { 
    public virtual void draw2() {
            Console.WriteLine("虚方法");
        }
    }
    public interface jiekou {
        void  draw2(fulei1 );
    }
 
    public class jiekou2 {
        void draw2() { }
    }
 
    public class zilei:fulei1,jiekou
    {
        public override void draw() {
            Console.WriteLine();
        }
        public void draw2(fulei1 zl) {
            Console.WriteLine();
 
        }
    }

高级篇

文件读写

static void Main(string[] args)
        {
            FileStream fs = new FileStream("text.txt",FileMode.Open,FileAccess.ReadWrite);
            byte[] buffer = new byte[4096];//4kb读取
            int r=fs.Read(buffer,0,buffer.Length);
            Console.WriteLine(r);
            string s=Encoding.UTF8.GetString(buffer,0,r);
            Console.WriteLine("内容1："+s);
            fs.Close();
            Console.ReadLine();
            fs.Dispose();
            //写入
            FileStream fs2 = new FileStream("text.txt", FileMode.Open, FileAccess.ReadWrite);
            string str = "my test2!";
            byte[] bufferout = Encoding.UTF8.GetBytes(str);
            fs2.Write(bufferout,0,str.Length);
            Console.WriteLine("写入"+str);
            fs2.Close();
            Console.ReadLine();
            fs2.Dispose();
 
            FileStream fs3 = new FileStream("text.txt", FileMode.Open, FileAccess.ReadWrite);
            byte[] buffer3 = new byte[4096];//4kb读取
            int r1 = fs3.Read(buffer, 0, buffer.Length);
            Console.WriteLine(r1);
            string s1 = Encoding.UTF8.GetString(buffer, 0, r1);
            Console.WriteLine("内容2："+s1);
 
            fs3.Close();
            Console.ReadLine();
            fs3.Dispose();
        }

函数具体参数可以百度。

读取大文件，复制文件

            string filesource = @"录音.m4a";
            string target = @"复制.m4a";
 
            FileStream fs = new FileStream(filesource,FileMode.Open,FileAccess.Read);
 
            FileStream fsout=new FileStream(target,FileMode.Create,FileAccess.Write);
 
            fs.CopyTo(fsout);
            
            
            
            
            
            fs.Close();
            fsout.Close();
            fs.Dispose();
            fsout.Dispose();

复制文件2

internal class Program{static void Main(string[] args){string filesource = @"录音.m4a";string target = @"复制.m4a";//using会自动释放资源using (FileStream fs = new FileStream(filesource, FileMode.Open, FileAccess.Read)){//读//写using (FileStream fsout = new FileStream(target, FileMode.OpenOrCreate, FileAccess.ReadWrite)){//缓存字节流数组byte[] buffer = new byte[4*1024*1024];//循环读取4mbwhile (true){//实际读取字节数int r = fs.Read(buffer, 0, buffer.Length);if (r == 0) break;//输出fsout.Write(buffer, 0, r);}}}}} internal class Program
    {
        static void Main(string[] args)
        {
            string filesource = @"录音.m4a";
            string target = @"复制.m4a";
            //using会自动释放资源
            using (FileStream fs = new FileStream(filesource, FileMode.Open, FileAccess.Read))
            {
                //读
 
                //写
                using (FileStream fsout = new FileStream(target, FileMode.OpenOrCreate, FileAccess.ReadWrite))
                {
                    //缓存字节流数组
                    byte[] buffer = new byte[4*1024*1024];
                    //循环读取4mb
                    while (true)
                    {
                        //实际读取字节数
                        int r = fs.Read(buffer, 0, buffer.Length);
                        if (r == 0) break;
                        //输出
                        fsout.Write(buffer, 0, r);
                    }
                   
 
                }
 
 
            }
        }
    }

文字文本读写：操作文本streamreader与streamwriter

namespace streamwr
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = @"小说.txt";
            using (StreamReader sr=new StreamReader(path)) 
            {
                //读全文
                string quanwen=sr.ReadToEnd();
                //从头开始
                sr.BaseStream.Seek(0, SeekOrigin.Begin);
               
                //读一行
                string yihang=sr.ReadLine();
                //同上
                sr.BaseStream.Seek(0, SeekOrigin.Begin);
 
                //读一个字符，结果为-1时说明文件结尾。还有其他用法，自行百度。
                string zifu=sr.Read().ToString();
                Console.WriteLine("全文：\n"+quanwen+"\n一行：\n"+yihang+"\n字符：\n"+zifu);
            }
            Console.ReadKey();
        }
    }
}

关于read()的多种用法，以及就基本流返回文件头的探讨：

 
namespace streamwr
{
    internal class Program
    {
        static void Main(string[] args)
        {
            string path = @"小说.txt";
            using (StreamReader sr=new StreamReader(path)) 
            {
                //读全文
                string quanwen=sr.ReadToEnd();
                //从头开始
                sr.BaseStream.Seek(0, SeekOrigin.Begin);
               
                //读一行
                string yihang=sr.ReadLine();
                //同上，但是根据结果，这里是无效的
                sr.BaseStream.Seek(0, SeekOrigin.Begin);
                //Console.WriteLine("\n回到开头\n");
                string yihang2 = sr.ReadLine();
 
                //读一个字符，结果为-1时说明文件结尾。还有其他用法，自行百度。
                sr.BaseStream.Seek(0, SeekOrigin.Begin);
                char[] buff=new char[2];
                //这里应该也是从头开始读
                char zifu= (char)sr.Read();               //(char)sr.Read(buff,0,2);
 
                sr.BaseStream.Seek(0, SeekOrigin.Begin);
                int a1=sr.Read();
                
                int a2=sr.Read();
                Console.WriteLine(a1+"\n"+a2);
                char zifu2 = (char)a1;
                char zifu3 = (char)a2;
 
 
                Console.WriteLine("全文：\n"+quanwen+"\n回到开头读\n一行：\n"+yihang+"\n回到开头\n读一行：\n" + yihang2 + "\n字符1：\n"+zifu+ "\n字符2：\n" + zifu2 + "\n字符3：\n" + zifu3);
            }
            Console.ReadKey();
        }
    }
}

也就是说，read是会读到换行和回车的。并且返回文件头部的方法只在第一次read to end起效了，虽然一般来说不应该读完一行想回头再读就是了。

在文件后添加还是覆盖文件的选项在path后的true上体现。true为添加，false为覆盖。

 using (StreamWriter sw = new StreamWriter(path,true)) {
                sw.WriteLine("我喜欢你");
            
            
            }

访问权限修饰

可以修饰类的：public和internal。

其他：private，protect，internal。

public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
protected：只有该类对象及其子类对象可以访问
internal：同一个程序集的对象可以访问；
protected internal：访问限于当前程序集或派生自包含类的类型。

序列化与反序列化

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
 
namespace xuliehua
{
    internal class Program
    {
        static void Main(string[] args)
        {
            person p = new person();
            p.Age = 1;
            p.Sex = "man";
            p.Name = "wuyi";
            using (FileStream fsw = new FileStream("text.txt", FileMode.OpenOrCreate, FileAccess.ReadWrite)) 
            {
                //开始序列化对象
                BinaryFormatter binaryFormatter = new BinaryFormatter();
                binaryFormatter.Serialize(fsw, p);
                
            }
            Console.WriteLine("序列化成功");
 
            //接受文件，反序列化
            using (FileStream fsr = new FileStream("text.txt",FileMode.Open,FileAccess.Read)) 
            {
                BinaryFormatter binaryFormatter = new BinaryFormatter();
                person p2=(person)binaryFormatter.Deserialize(fsr);
                Console.WriteLine(p2.Name);
            }
            Console.WriteLine("反序列化成功");
            Console.ReadKey();
 
        }
    }
 
    [Serializable]
    class person {
        string _name;
        int age;
        string sex;
        public string Name{ get { return _name; } set { _name = value; } }
        public int Age { get { return age; }set { age = value; } }
        public string Sex { get { return sex; } set { sex = value; } }
    }
}

部分类

partial关键字

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace 部分类
{
    internal class Program
    {
        static void Main(string[] args)
        {
        }
    }
     public partial class person{
        string myname;
    }
    public partial class person
    {
        string getname() {
            return myname;
                }
    }
}

密封类

拒绝继承

sealed关键字

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace 部分类
{
    internal class Program
    {
        static void Main(string[] args)
        {
        }
    }
     public sealed  class person{
        string myname;
    }
    
    public class person2 :person
    { }
}

接口的显式实现

 
namespace 显式实现接口
{
    internal class Program
    {
        static void Main(string[] args)
        {
        }
        public class bird : flyable
        {
            public void fly() {
                Console.WriteLine("我会飞");
            }
            //显式实现就可以避免与方法重名
             void flyable.fly(){
                Console.WriteLine("接口的飞");
            }
        }
        public interface flyable {
 
             void fly();
        }
    }
}

原文链接https://blog.csdn.net/m0_54138660/article/details/132327278