什么相当于“朋友”？ C Sharp 中的关键字？

Question

C Sharp 中的“friend”关键字相当于什么？

如何使用“内部”关键字？

我读到“internal”关键字是 C# 中“friend”的替代品。

我在我的 C# 项目中使用一个 DLL，我拥有该项目的源代码，但我不想修改现有代码。 我继承了该类，并且可以以任何我想要的方式使用我继承的类。 问题是父类中的大部分代码都有受保护的方法。 使用朋友是否可以以某种方式访问​​或调用这些受保护的方法？

Answer 1

1. 您可以使用关键字访问修饰符内部< /a> 将类型或类型成员声明为只能由同一程序集中的代码访问。

2. 您可以使用InternalsVisibleToAttribute在 System.Rutime 中定义的类.CompilerServices 将类型声明为只能在同一程序集中或指定程序集中的代码访问。

您可以像使用任何其他访问修饰符（例如 私有。 也就是说：

internal class MyClass {
    ...
}

您可以按如下方式使用第二个：

[assembly:InternalsVisibleTo("MyFriendAssembly", PublicKey="...")]
internal class MyVisibleClass {
    ...
}

这两个都可以正确地视为 C# 中的 friend 的等价物。

受保护的方法已可供派生类。

Answer 2

不，“内部”与“朋友”不同（至少是 C++ 的“朋友”），

朋友指定该类只能由一个特定类访问。
内部指定该类可由程序集中的任何类访问。

Answer 3

1. 内部 是 VB.NET friend 关键字的 C# 等效项（而不是替换）

2. 用法如下

   内部 void Function() {} 
     内部类 类名() {} 
     内部 int myInt; 
     内部 int MyProperty { 获取；   放;   } 
     

3. 它基本上是一个访问修饰符，规定标记为内部的类/函数/变量/属性的可访问性就好像它对程序集是公共的一样被编译，并且对任何其他程序集都是私有的

Answer 4

您的子类将能够访问您继承的类的受保护成员。

您是否希望将这些受保护成员的访问权限授予另一个类？

Answer 5

这是我用来添加类似于 C++ 的 friend 关键字的行为的奇怪技巧。 这仅适用于嵌套类 AFAIK。

1. 使用您想要通过属性授予访问权限的变量创建一个嵌套的 protected 或 private 接口。
2. 让嵌套类继承此接口并显式实现它。
3. 每当使用此嵌套类的对象时，请将其强制转换为接口并调用相应的属性。

这是来自 Unity 的示例。

using System;
using UnityEngine;
using UnityEngine.Assertions;

namespace TL7.Stats
{
    [CreateAssetMenu(fileName = "Progression", menuName = "TL7/Stats/New Progression", order = 0)]
    public class Progression : ScriptableObject
    {
        // Provides access to private members only to outer class Progression
        protected interface IProgressionClassAccess
        {
            CharacterClass CharacterClass { get; set; }
        }

        [System.Serializable]
        public struct ProgressionClass : IProgressionClassAccess
        {
            [Header("DO NOT EDIT THIS VALUE.")]
            [SerializeField] private CharacterClass characterClass;
            [Tooltip("Levels are 0 indexed.")]
            [SerializeField] float[] healthOverLevels;

            public float[] HealthOverLevels => healthOverLevels;

            CharacterClass IProgressionClassAccess.CharacterClass
            {
                get => characterClass;
                set => characterClass = value;
            }
        }

        static readonly Array characterClasses = Enum.GetValues(typeof(CharacterClass));
        [SerializeField] ProgressionClass[] classes = new ProgressionClass[characterClasses.Length];

        public ProgressionClass this[in CharacterClass index] => classes[(int)index];

        void Awake()
        {
            for (int i = 0; i < classes.Length; ++i)
            {
                // Needs to be cast to obtain access
                (classes[i] as IProgressionClassAccess).CharacterClass = (CharacterClass)characterClasses.GetValue(i);
            }
        }

#if UNITY_EDITOR
        public void AssertCorrectSetup()
        {
            for (int i = 0; i < characterClasses.Length; ++i)
            {
                CharacterClass characterClass = (CharacterClass)characterClasses.GetValue(i);
                Assert.IsTrue(
                    (this[characterClass] as IProgressionClassAccess).CharacterClass == characterClass,
                    $"You messed with the class values in {GetType()} '{name}'. This won't do."
                );
            }
        }
#endif
    }
}

我认为这只适用于嵌套类。 如果您想对常规类执行此操作，则需要将它们嵌套在部分外部类中，这在理论上应该有效，并使用 protected 或 private嵌套接口（或两个，如果你愿意的话）为他们提供对彼此隐私的访问......结果是错误的。

Answer 6

内部相当于朋友。 受保护的方法仅在同一类中或从继承者中可用。 如果您尝试从继承者公开受保护的方法，则可以将它们包装在公共方法中。

Answer 7

将一个大类分成两个部分类文件可以达到所需的朋友效果。 它并不等效，但在某些情况下有效。