{"id":1433,"date":"2023-04-08T21:37:06","date_gmt":"2023-04-08T14:37:06","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1433"},"modified":"2023-04-09T10:31:51","modified_gmt":"2023-04-09T03:31:51","slug":"csharp-internal","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-internal\/","title":{"rendered":"C# Internal"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll how to use the C# internal<\/code> keyword to restrict types and their members to be accessible within the same assembly.<\/p>\n\n\n\n

Introduction to C# internal keyword<\/h2>\n\n\n\n

In .NET, an assembly is a package of code and resources that the .NET runtime can deploy, version, and execute, and developers can use to create applications or libraries.<\/p>\n\n\n\n

To create an assembly from code, you compile the code into DLL<\/code> or EXE<\/code> file. Then, you or other developers can reference the assembly from another project.<\/p>\n\n\n\n

C# internal<\/code> keyword specifies that types like classes<\/a> and interfaces<\/a> or members of types should be accessible only within the same assembly, also known as assembly scope. In other words, if a type or member of a type is marked as internal<\/code>, other assemblies cannot access it directly.<\/p>\n\n\n\n

The internal<\/code> keyword allows you to effectively hide implementation detail. It also ensures that your library is used as intended, without exposing the internal details to external assemblies. This makes your code more maintainable and secure.<\/p>\n\n\n\n

Let’s say you develop a C# library called MyLib<\/code> that contains a Utility<\/code> class that you want to use in your projects within the same solution. But you don’t want other developers to access the Utility<\/code> class and its methods from their assemblies outside of your library.<\/p>\n\n\n\n

To do it, you can use the internal<\/code> keyword for the Utility<\/code> class and its method like this:<\/p>\n\n\n

namespace<\/span> MyLib<\/span>\n{\n    internal<\/span> class<\/span> Utility<\/span>\n    {\n        internal<\/span> static<\/span> void<\/span> Calculate<\/span>(<\/span>)<\/span>\n        {\n        }\n    }\n\n    class<\/span> MyClass<\/span>\n    {\n        public<\/span> static<\/span> void<\/span> DoSomething<\/span>(<\/span>)<\/span>\n        {\n            Utility.Calculate();\n            \n            \/\/ ...<\/span>\n        }\n    }\n\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we mark the Utility<\/code> class and its Calculate()<\/code> method as internal<\/code>. It means that we only allow access to them within the same assembly (MyLib<\/code> project).<\/p>\n\n\n\n
On the other hand, we mark the MyClass<\/code> as public<\/code>, meaning that we allow other assemblies to reference the MyClass<\/code>.<\/p>\n\n\n\n
It’s important to note that if you attempt to access the Utility<\/code> class or its Calculate()<\/code> method from another assembly, you’ll get a compilation error.<\/p>\n\n\n\n
Protected Internal<\/h2>\n\n\n\n
The protected internal<\/code> access modifier is a combination of the protected<\/code> and internal<\/code> modifiers. The protected internal<\/code> allows access to members from within the same assembly, as well as from within derived classes in any assembly, more specifically:<\/p>\n\n\n\n
    \n
  • A protected internal<\/code> member can be accessed from any class within the same assembly, just like an internal<\/code> member.<\/li>\n\n\n\n
  • A protected internal<\/code> member can also be accessed from a derived class in any assembly, just like a protected<\/code> member.<\/li>\n<\/ul>\n\n\n\n
    Here’s an example of using the protected internal<\/code> access modifier:<\/p>\n\n\n
    \/\/ Assembly1<\/span>\n\nnamespace<\/span> MyLib<\/span>;\n\npublic<\/span> class<\/span> MyBaseClass<\/span>\n{\n    protected<\/span> internal<\/span> int<\/span> MyProtectedInternalField;\n}\n\npublic<\/span> class<\/span> MyDerivedClass<\/span>: MyBaseClass<\/span>\n{\n    public<\/span> void<\/span> DoSomething<\/span>(<\/span>)<\/span>\n    {\n        var<\/span> value<\/span> = MyProtectedInternalField;\n        Console.WriteLine(value<\/span>);\n    }\n}\n<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, the MyBaseClass<\/code> has a protected internal<\/code> member. Hence, we can access it from the DoSomething()<\/code> method of the derived class within the same assembly.<\/p>\n\n\n
    \/\/ Assembly2<\/span>\nusing<\/span> MyLib;\n\nnamespace<\/span> MyLib2<\/span>;\n\npublic<\/span> class<\/span> MyClass<\/span> : MyDerivedClass<\/span>\n{\n    public<\/span> void<\/span> MyMethod<\/span>(<\/span>)<\/span>\n    {\n        \/\/ reference the protected internal field <\/span>\n        \/\/ from the MyDerivedClass in another assembly<\/span>\n        var<\/span> value<\/span> = MyProtectedInternalField;\n        \n        \/\/...<\/span>\n        \n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this assembly, we define the MyClass<\/code> that extends the MyDerivedClass<\/code> class from Assembly1<\/code>. <\/p>\n\n\n\n
    The MyMethod()<\/code> of the MyClass<\/code> can access the MyProtectedInternalField<\/code> member of the MyDerivedClass<\/code> of the Assembly1<\/code>.<\/p>\n\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • Use the C# internal<\/code> keyword to allow types and their members to be accessible within the same assembly.<\/li>\n\n\n\n
    • Use he protected internal<\/code> modifier to allow a member to be accessed within the same assembly, as well as from the derived class from the same or another assembly.<\/li>\n<\/ul>\n
      \n\t
      \n\t\t
      Was this tutorial helpful ?<\/div>\n\t\t
      \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
      \n\t\t
      \n\t\t\t
      <\/div>\n\t\t\t\n\t\t\t