C# 基本OOPs相关查询

我有一个基本的疑问，我想在用C#编程时可能会很常见

这里基本上描述了我当前代码的结构：

文件：api.cs

namespace API
{
    class OutputClass{
        private int var1;
        private int var2;
        int getVar1()
        {
            return var1;
        }
        int getVar2()
        {
            return var2;
        }
    }

    class APICore {
        public event Action<OutputClass> FrameDecodeComplete;
        void someFunction() {
            OutputClass myOutput;

            myOutput.var1 = 1;    
            myOutput.var2 = 2;

            FrameDecodeComplete(myOutput);
        }
    }
}

名称空间API
{
类输出类{
私有int var1；
私有int var2；
int getVar1（）
{
返回变量1；
}
int getVar2（）
{
返回变量2；
}
}
顶端类{
公共事件行动框架完整；
void函数（）{
输出类myOutput；
myOutput.var1=1；
myOutput.var2=2；
帧解码完成（myOutput）；
}
}
}

我的要求是该API的用户创建APICore类型的对象，并以OutputClass对象的形式接收输出

显然，行

myOutput.var1=1

和

myOutput.var2=2将引发错误

但我还需要确保API的用户无法为var1、var2设置值。因此，我不想将var1和var2的访问级别更改为public。我也不想定义setVar1（）、setVar2（）等函数

请发表评论。
检查关键字，看起来它可以解决您的问题

但您也可以使用2个参数向OutputClass添加内部构造函数方法，这样someFunction将调用构造函数并返回对象，在构造函数中您将能够初始化私有变量检查关键字，看起来它解决了您的问题

但您也可以使用2个参数向OutputClass添加内部构造函数方法，这样someFunction将调用构造函数并返回对象，在构造函数中您将能够初始化私有变量
听起来它们的保护级别应该是
内部
。这样，
var1
和
var2
将只在声明它们的程序集中可见

听起来他们的保护级别应该是
内部的
。这样，
var1
和
var2
将只在声明它们的程序集中可见

如果您希望用户能够访问
get
属性，而不是
set
属性，那么您可以像这样创建访问者属性

public int var1 { get; private set; }

通过这种方式，您可以在类中自己修改变量，类的使用者可以访问该值，但不能更改它。
如果您希望用户能够访问
获取属性，但不能
设置属性，那么您可以像这样创建访问器属性

public int var1 { get; private set; }

这样，您可以在类中自己修改变量，类的使用者可以访问该值，但不能更改该值。
如果您不希望外部程序集能够访问您的变量，则可以使用internal关键字

class OutputClass
{
    public int Var1 { get; internal set; }
}



该语法是一个属性，您可以使用该语法为字段生成getter和setter

我向您展示的语法是以下内容的简写

class OutputClass
{    
    private int _var1;
    public int Var1 
    {
        get
        {
            return _var1;
        }
        internal set
        {
            _var1 = value;
        }
    }
}

如果不希望外部程序集能够访问变量，那么就不能使用内部关键字

class OutputClass
{
    public int Var1 { get; internal set; }
}



该语法是一个属性，您可以使用该语法为字段生成getter和setter

我向您展示的语法是以下内容的简写

class OutputClass
{    
    private int _var1;
    public int Var1 
    {
        get
        {
            return _var1;
        }
        internal set
        {
            _var1 = value;
        }
    }
}

给
OutputClass
一个受保护的构造函数，该构造函数使用参数设置
var1
和
var2
，然后给
APICore
一个私有嵌套类，该类派生自
OutputClass
，并将参数传递给受保护的基本构造函数

比如：

class OutputClass{
    private int var1;
    private int var2;
    int getVar1()
    {
        return var1;
    }
    int getVar2()
    {
        return var2;
    }

    protected OutputClass(int _var1, int _var2)
    {
        var1 = _var1;
        var2 = _var2;
    }
}

class APICore {
    public event Action<OutputClass> FrameDecodeComplete;
    void someFunction() {
        SubOutputClass myOutput = new SubOutputClass(1,2);

        FrameDecodeComplete(myOutput);
    }

    private SubOutputClass : OutputClass
    {
        public SubOutputClass(int var1, int var2) : base(var1, var2)
        {
        }
    }
}

类输出类{
私有int var1；
私有int var2；
int getVar1（）
{
返回变量1；
}
int getVar2（）
{
返回变量2；
}
受保护的输出类（int\u var1，int\u var2）
{
var1=_var1；
var2=_var2；
}
}
顶端类{
公共事件行动框架完整；
void函数（）{
SubOutputClass myOutput=新的SubOutputClass（1,2）；
帧解码完成（myOutput）；
}
私有子输出类：输出类
{
公共子输出类（intvar1，intvar2）：基（var1，var2）
{
}
}
}

使用
internal
时，同一程序集中的任何类都可以访问它。这对您来说可能是问题，也可能不是问题。
给出一个受保护的构造函数，该构造函数接受参数来设置
var1
和
var2
，然后给出
APICore
一个私有嵌套类，该类派生自
OutputClass
，并将参数传递给受保护的基本构造函数

比如：

class OutputClass{
    private int var1;
    private int var2;
    int getVar1()
    {
        return var1;
    }
    int getVar2()
    {
        return var2;
    }

    protected OutputClass(int _var1, int _var2)
    {
        var1 = _var1;
        var2 = _var2;
    }
}

class APICore {
    public event Action<OutputClass> FrameDecodeComplete;
    void someFunction() {
        SubOutputClass myOutput = new SubOutputClass(1,2);

        FrameDecodeComplete(myOutput);
    }

    private SubOutputClass : OutputClass
    {
        public SubOutputClass(int var1, int var2) : base(var1, var2)
        {
        }
    }
}

类输出类{
私有int var1；
私有int var2；
int getVar1（）
{
返回变量1；
}
int getVar2（）
{
返回变量2；
}
受保护的输出类（int\u var1，int\u var2）
{
var1=_var1；
var2=_var2；
}
}
顶端类{
公共事件行动框架完整；
void函数（）{
SubOutputClass myOutput=新的SubOutputClass（1,2）；
帧解码完成（myOutput）；
}
私有子输出类：输出类
{
公共子输出类（intvar1，intvar2）：基（var1，var2）
{
}
}
}

使用
internal
时，同一程序集中的任何类都可以访问它。这对您来说可能是问题，也可能不是问题。
这对
APICore
access
var1
中的
OutputClass
没有帮助。我不明白。你能解释一下吗？如果var1是带有隐式getter的公共属性，则APICore可以从实例访问它。
APICore
无法设置
var1
，这是OP提出的问题。问题是：“我还需要确保API的用户无法为