Using String as a Lock to Do Thread Synchronization

Inconsistent accessibility error with the following c# code. Why?

your "Interface1" isn't public..

public interface Interface1<T>
{
    bool IsDataValid();
    /* Other interfaces */
}

Inconsistent accessibility error C#

You should define your interface public since the method that exposes it is public. If you don't do that, the consumer of that method doesn't know the actual type of the receiving parameter.

The solution would be to add the public keyword before interface:

public interface IObjects
{
    string GetSqlInfo();
    int GetId();
    void InsertData();
}

Or make the method not public, but internal, the default accessibility of classes and interfaces.

internal static void Insert(IObjects classType) //insert tool data
{ }

Inconsistent accessibility' error when exposing a public property of a nested private type

What you're trying to do makes no sense. You want your callers to be able to call XYZ.Bar, but they don't get to know the type of the object they get back.

You could change the type of the Bar property to SomethingIWantToInheritFrom, if that is a public type.

Compiler inconsistent accessibility error with passing nested class as a function parameter

Top-level types default to being internal, but nested types default to being private. You've therefore got an internal type with a public method that has a private type as a parameter. Making all the access modifiers explicit:

internal class Program
{
    private class BaseClass
    {
        public class NestedClass {}
    }

    public static bool Function1(BaseClass.NestedClass obj)
    {
        return true;
    }

    private static void Main(string[] args)
    {
        Function1(new BaseClass.NestedClass());
        new BaseClass.NestedClass();
        Console.ReadLine();
    }
}

That means any code in the rest of the assembly could "see" Function1 but not understand it - hence the inconsistent accessibility error.

You can fix this by either making BaseClass internal or public or by making Function1 private. Note that BaseClass doesn't have to be public just because Function1 is public, because the accessibility domain of Program is just the assembly containing it. That makes the accessibility domain of Function1 the same. See section 3.5.2 of the C# spec for more details.

Personally I would avoid using nested classes too heavily - and by the time you have a nested type within a nested type, I would strongly consider a redesign.

Inconsistent accessibility

Messagetypes is private, but is a parameter to a public function. The only people that would ever be able to call it are other private members. Either change your function to private, or change your enum to public.

Inconsistent accessibility error: parameter is less accessible than method

Your ModBoxUpdateInfoForm constructor is public and requires a parameter of type ModBoxUpdateXml which is internal. You get this exception because a caller outside of your assembly couldn't call the public ModBoxUpdateInfoForm constructor, because the caller is not allowed to have knowledge of what a ModBoxUpdateXml is.

Either make ModBoxUpdateXml public, or make the ModBoxUpdateInfoForm constructor internal.

Here is a simple MCVE example:

Causes Compiler Error:

internal class A{}

public class B
{
    public B(A a){}
}

Fix:

//Make this public
public class A{}

public class B
{
    public B(A a){}
}

Or:

internal class A{}

//Make this internal
internal class B
{
    public B(A a){}
}

Or:

internal class A{}

public class B
{
    //Make only the constructor internal
    internal B(A a){}
}

How to solve the Error: Inconsistent accessibility: parameter type for generic c# interface?

Without posting your entire relevant code i'll try a hunch:

the class Childrendata is declared as not-public and (as we can see) the variable m_children is public

Threfore a public variable cannot expose a less accessible type, in this case, Childrendata

Additionally, what you might want is to turn m_children private as well as this is usually the best practice

What causes the 'Inconsistent Accesibility' error in the follow code?

If you are exposing a type on a class then the type must be at least as accessible as the class.

In your case, Star and CalculateGeometry are public, so Lines, as it's exposed on a public method, must also be public.

You can either make it public, or reduce the accessibility of the class to be equal or less than the Lines class.

Lines is probably internal, as that's the default if you don't add a access modifier.

From the docs:

• public
  
  • Access is not restricted.
• protected
  
  • Access is limited to the containing class or types derived from the containing class.
• internal
  
  • Access is limited to the current assembly.
• protected internal
  
  • Access is limited to the current assembly or types derived from the containing class.
• private
  
  • Access is limited to the containing type.

Inconsistent accessibility problem

Your DB class is not public, so you can't make a public method (or constructor) that takes it as a parameter. (What would callers outside your assembly do?)

You need to either make the DB class public or make the SqlCatalogRepository class (or its constructor) internal.

Which one you do will depend where your types are being used.

If the SqlCatalogRepository is only meant to be used inside your assembly, you should make it internal. (internal means that it's only visible to other types in the same assembly)

If it's meant to be exposed by your assembly to other assemblies, you should make the class public but the constructor internal.

If the DB class itself is meant to be used by types outside your assembly, you should make the DB class itself public.

---

Related Topics