Question

I’m going through a really hard time finding the answer to the question below, about inheritance and OOP. Can anyone please help?

Here is the question :

Let’s assume that I have a class named ServiceManager inside an assembly named KioskFramework, which implements 2 different interfaces named IServiceManager and IServiceProvider.

public interface IServiceManager
{
    string SerialNumber { get; }
    string Description { get; set; }

    int DoFoo(IServiceManager instance, int a, int b);
}

public interface IServiceProvider
{
    void DoSomethingRESTRICTED();
}

class ServiceManager : IServiceManager, IServiceProvider
{
    public void DoSomethingRESTRICTED();

    …  // some other properties and methods...

    public string SerialNumber { get { … } }

    public string Description { get { … } set { … } }

    public int DoFoo(int a, int b)
    {
       …
    }
}

I have another class named MonitoringService inside an assembly named KioskFramework.MonitoringService, which uses certain properties of ServiceManager class (The ones that are defined in the IServiceManager).

class MonitoringService
{
    …  // some other properties and methods...

    public int DoBar(IServiceManager instance, int a, int b)
    {
       // an example to show that I need access to ServiceManager's properties
       return instance.SerialNumber.Length + 
              instance.Description.Length + 
              instance.DooFoo(a, b);
    }
}

All I want to do is, that I want to be able to use that certain properties in MonitoringService, but no other class or assembly (such as ControllingService inside KioskFramework.ControllingService), could access that properties.

class ControllingService
{
    public void DoSomethingElse(IServiceProvider instance)
    {
        // this method should not have access to the IServiceManager's 
        // properties and methods, even if it has an instance of
        // IServiceProvider, or even if it has referenced the assembly 
        // containing IServiceManager interface
    }
}

Is it possible? How? Is there a design pattern for solving this?

Maybe I’m thinking in a wrong manner or way, but my goal is to restrict certain members of a class to only be seen/used in certain assemblies not all of them.

edit : After Mark Cidade’s answer, I edited this post, to say that I don’t want to expose other internal members and classes of “KioskFramework” assembly to “KioskFramework.MonitoringService” assembly.

Thanks in advance.

Answer 1

You can mark the interface as internal and apply an InternalsVisibleTo attribute to the assembly:

From KioskFramework.dll:

[assembly:InternalsVisibleTo("KioskFramework.MonitoringService")]