# InvalidOperationException

***

**1. Object is disposed**

```csharp
using System;

class Program
{
    static void Main()
    {
        var stream = new MemoryStream();
        stream.Dispose();

        try
        {
            stream.Write(new byte[1], 0, 1);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**2. Attempt to access a closed connection**

```csharp
using System;
using System.Net;

class Program
{
    static void Main()
    {
        var webClient = new WebClient();
        webClient.OpenRead("http://www.google.com");
        webClient.Dispose();

        try
        {
            webClient.OpenRead("http://www.google.com");
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**3. Attempt to modify an immutable object**

```csharp
using System;

class ImmutableClass
{
    public int Value { get; private set; }

    public ImmutableClass(int value)
    {
        Value = value;
    }
}

class Program
{
    static void Main()
    {
        var immutableClass = new ImmutableClass(1);

        try
        {
            immutableClass.Value = 2;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**4. Attempt to access a property or method on a null reference**

```csharp
using System;

class Program
{
    static void Main()
    {
        try
        {
            var nullObject = null;
            var propertyValue = nullObject.Value;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**5. Attempt to perform an invalid operation on a collection**

```csharp
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var list = new List<int>();
        list.Add(1);
        list.Add(2);

        try
        {
            list.Insert(-1, 3);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**6. Attempt to cast an object to an incompatible type**

```csharp
using System;

class Program
{
    static void Main()
    {
        var obj = new object();

        try
        {
            var intObject = (int)obj;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**7. Attempt to set an invalid value to a property**

```csharp
using System;

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main()
    {
        var person = new Person();

        try
        {
            person.Age = -1;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**8. Attempt to call a method on an invalid state**

```csharp
using System;

class Program
{
    static void Main()
    {
        var stateMachine = new StateMachine();

        try
        {
            stateMachine.TransitionTo(State.Finished);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

    enum State
    {
        Initial,
        Running,
        Finished
    }

    class StateMachine
    {
        private State _state = State.Initial;

        public void TransitionTo(State state)
        {
            if (_state != State.Running)
                throw new InvalidOperationException();

            _state = state;
        }
    }
}
```

**9. Attempt to perform an operation on a locked object**

```csharp
using System;
using System.Threading;

class Program
{
    static void Main()
    {
        var obj = new object();
        var lockTaken = false;

        try
        {
            lock (obj)
            {
                lockTaken = true;
                lock (obj)
                {
                    Console.WriteLine("Operation performed on locked object.");
                }
            }
        }
        finally
        {
            if (lockTaken)
                Monitor.Exit(obj);
        }
    }
}
```

**10. Attempt to access a protected member from outside its scope**

```csharp
using System;

class BaseClass
{
    protected int ProtectedValue { get; set; }
}

class DerivedClass : BaseClass
{
    public void AccessProtectedValue()
    {
        Console.WriteLine(ProtectedValue);
    }
}

class Program
{
    static void Main()
    {
        var baseClass = new BaseClass();

        try
        {
            Console.WriteLine(baseClass.ProtectedValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**11. Attempt to access a private member from outside its class**

```csharp
using System;

class Person
{
    private int SSN { get; set; }
}

class Program
{
    static void Main()
    {
        var person = new Person();

        try
        {
            Console.WriteLine(person.SSN);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**12. Attempt to access an internal member from outside its assembly**

```csharp
// Assembly1.cs
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Assembly2")]
namespace Assembly1
{
    class ClassWithInternalMember
    {
        internal int InternalValue { get; set; }
    }
}

// Assembly2.cs
using Assembly1;

namespace Assembly2
{
    class Program
    {
        static void Main()
        {
            var classWithInternalMember = new ClassWithInternalMember();

            try
            {
                Console.WriteLine(classWithInternalMember.InternalValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**13. Attempt to access a protected internal member from outside its assembly and derived class**

```csharp
// Assembly1.cs
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Assembly2")]
namespace Assembly1
{
    class BaseClass
    {
        protected internal int ProtectedInternalValue { get; set; }
    }
}

// Assembly2.cs
using Assembly1;

namespace Assembly2
{
    class DerivedClass : BaseClass
    {
        public void AccessProtectedInternalValue()
        {
            Console.WriteLine(ProtectedInternalValue);
        }
    }

    class Program
    {
        static void Main()
        {
            var baseClass = new BaseClass();

            try
            {
                Console.WriteLine(baseClass.ProtectedInternalValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**14. Attempt to access a protected internal member from outside its assembly and unrelated class**

```csharp
// Assembly1.cs
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("Assembly2")]
namespace Assembly1
{
    class ClassWithProtectedInternalMember
    {
        protected internal int ProtectedInternalValue { get; set; }
    }
}

// Assembly2.cs
using Assembly1;

namespace Assembly2
{
    class UnrelatedClass
    {
        public void AccessProtectedInternalValue()
        {
            var classWithProtectedInternalMember = new ClassWithProtectedInternalMember();
            Console.WriteLine(classWithProtectedInternalMember.ProtectedInternalValue);
        }
    }
}
```

**15. Attempt to access a private protected member from outside its class and derived class**

```csharp
using System;

class BaseClass
{
    private protected int PrivateProtectedValue { get; set; }
}

class DerivedClass : BaseClass
{
    public void AccessPrivateProtectedValue()
    {
        Console.WriteLine(PrivateProtectedValue);
    }
}

class Program
{
    static void Main()
    {
        var baseClass = new BaseClass();

        try
        {
            Console.WriteLine(baseClass.PrivateProtectedValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**16. Attempt to access a private protected member from outside its class and unrelated class**

```csharp
using System;

class ClassWithPrivateProtectedMember
{
    private protected int PrivateProtectedValue { get; set; }
}

class UnrelatedClass
{
    public void AccessPrivateProtectedValue()
    {
        var classWithPrivateProtectedMember = new ClassWithPrivateProtectedMember();
        Console.WriteLine(classWithPrivateProtectedMember.PrivateProtectedValue);
    }
}
```

**17. Attempt to access a public member from a private nested class**

```csharp
using System;

class OuterClass
{
    private class NestedClass
    {
        public int PublicValue { get; set; }
    }

    public void AccessNestedClassPublicMember()
    {
        var nestedClass = new NestedClass();
        Console.WriteLine(nestedClass.PublicValue);
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                var nestedClass = new NestedClass();
                Console.WriteLine(nestedClass.PublicValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**18. Attempt to access a protected member from a private nested class**

```csharp
using System;

class OuterClass
{
    protected class NestedClass
    {
        public int ProtectedValue { get; set; }
    }

    public void AccessNestedClassProtectedMember()
    {
        var nestedClass = new NestedClass();
        Console.WriteLine(nestedClass.ProtectedValue);
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            Console.WriteLine(nestedClass.ProtectedValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**19. Attempt to access a private member from a protected nested class**

```csharp
using System;

class OuterClass
{
    protected class NestedClass
    {
        private int PrivateValue { get; set; }
    }

    public void AccessNestedClassPrivateMember()
    {
        var nestedClass = new NestedClass();
        Console.WriteLine(nestedClass.PrivateValue);
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                var nestedClass = new NestedClass();
                Console.WriteLine(nestedClass.PrivateValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**20. Attempt to access a private member from a private nested class of a derived class**

```csharp
using System;

class BaseClass
{
    private class NestedClass
    {
        private int PrivateValue { get; set; }
    }
}

class DerivedClass : BaseClass
{
    public void AccessNestedClassPrivateMember()
    {
        var nestedClass = new NestedClass();
        Console.WriteLine(nestedClass.PrivateValue);
    }
}

class Program
{
    static void Main()
    {
        var derivedClass = new DerivedClass();

        try
        {
            var nestedClass = new NestedClass();
            Console.WriteLine(nestedClass.PrivateValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**21. Attempt to access a public field from a private nested class of a derived class**

```csharp
using System;

class BaseClass
{
    public int PublicField;
}

class DerivedClass : BaseClass
{
    private class NestedClass
    {
        public void AccessPublicField()
        {
            Console.WriteLine(PublicField);
        }
    }
}

class Program
{
    static void Main()
    {
        var derivedClass = new DerivedClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.AccessPublicField();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**22. Attempt to access a public method from a private nested class of a derived class**

```csharp
using System;

class BaseClass
{
    public void PublicMethod()
    {
        Console.WriteLine("Public method called.");
    }
}

class DerivedClass : BaseClass
{
    private class NestedClass
    {
        public void AccessPublicMethod()
        {
            PublicMethod();
        }
    }
}

class Program
{
    static void Main()
    {
        var derivedClass = new DerivedClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.AccessPublicMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**23. Attempt to access a protected field from a private nested class of a derived class**

```csharp
using System;

class BaseClass
{
    protected int ProtectedField;
}

class DerivedClass : BaseClass
{
    private class NestedClass
    {
        public void AccessProtectedField()
        {
            Console.WriteLine(ProtectedField);
        }
    }
}

class Program
{
    static void Main()
    {
        var derivedClass = new DerivedClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.AccessProtectedField();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**24. Attempt to access a protected method from a private nested class of a derived class**

```csharp
using System;

class BaseClass
{
    protected void ProtectedMethod()
    {
        Console.WriteLine("Protected method called.");
    }
}

class DerivedClass : BaseClass
{
    private class NestedClass
    {
        public void AccessProtectedMethod()
        {
            ProtectedMethod();
        }
    }
}

class Program
{
    static void Main()
    {
        var derivedClass = new DerivedClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.AccessProtectedMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**25. Attempt to access a private field from a private nested class of a derived class**

```csharp
using System;

class BaseClass
{
    private int PrivateField;
}

class DerivedClass : BaseClass
{
    private class NestedClass
    {
        public void AccessPrivateField()
        {
            Console.WriteLine(PrivateField);
        }
    }
}

class Program
{
    static void Main()
    {
        var derivedClass = new DerivedClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.AccessPrivateField();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**26. Attempt to access a private method from a private nested class of a derived class**

```csharp
using System;

class BaseClass
{
    private void PrivateMethod()
    {
        Console.WriteLine("Private method called.");
    }
}

class DerivedClass : BaseClass
{
    private class NestedClass
    {
        public void AccessPrivateMethod()
        {
            PrivateMethod();
        }
    }
}

class Program
{
    static void Main()
    {
        var derivedClass = new DerivedClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.AccessPrivateMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**27. Attempt to access a public member from a static nested class**

```csharp
using System;

class OuterClass
{
    public static class NestedClass
    {
        public int PublicValue { get; set; }
    }

    public void AccessNestedClassPublicMember()
    {
        Console.WriteLine(NestedClass.PublicValue);
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                Console.WriteLine(NestedClass.PublicValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**28. Attempt to access a protected member from a static nested class**

```csharp
using System;

class OuterClass
{
    protected static class NestedClass
    {
        public int ProtectedValue { get; set; }
    }

    public void AccessNestedClassProtectedMember()
    {
        Console.WriteLine(NestedClass.ProtectedValue);
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            Console.WriteLine(NestedClass.ProtectedValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**29. Attempt to access a private member from a static nested class**

```csharp
using System;

class OuterClass
{
    private static class NestedClass
    {
        private int PrivateValue { get; set; }
    }

    public void AccessNestedClassPrivateMember()
    {
        Console.WriteLine(NestedClass.PrivateValue);
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                Console.WriteLine(NestedClass.PrivateValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**30. Attempt to access a private member from an instance method of a static nested class**

```csharp
using System;

class OuterClass
{
    private static class NestedClass
    {
        public int PublicValue { get; set; }

        private void PrivateMethod()
        {
            Console.WriteLine("Private method called.");
        }
    }

    public void AccessNestedClassPrivateMethod()
    {
        var nestedClass = new NestedClass();

        try
        {
            nestedClass.PrivateMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.PrivateMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**31. Attempt to access a protected member from an instance method of a static nested class**

```csharp
using System;

class OuterClass
{
    private static class NestedClass
    {
        public int PublicValue { get; set; }

        protected void ProtectedMethod()
        {
            Console.WriteLine("Protected method called.");
        }
    }

    public void AccessNestedClassProtectedMethod()
    {
        var nestedClass = new NestedClass();

        try
        {
            nestedClass.ProtectedMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.ProtectedMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**32. Attempt to access a public member from an instance method of a private static nested class**

```csharp
using System;

class OuterClass
{
    private static class NestedClass
    {
        private int PrivateValue { get; set; }

        public void PublicMethod()
        {
            Console.WriteLine("Public method called.");
        }
    }

    public void AccessNestedClassPublicMethod()
    {
        var nestedClass = new NestedClass();

        try
        {
            nestedClass.PublicMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.PublicMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**33. Attempt to access a protected member from an instance method of a private static nested class**

```csharp
using System;

class OuterClass
{
    private static class NestedClass
    {
        private int PrivateValue { get; set; }

        protected void ProtectedMethod()
        {
            Console.WriteLine("Protected method called.");
        }
    }

    public void AccessNestedClassProtectedMethod()
    {
        var nestedClass = new NestedClass();

        try
        {
            nestedClass.ProtectedMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.ProtectedMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**34. Attempt to access a private member from an instance method of a protected static nested class**

```csharp
using System;

class OuterClass
{
    protected static class NestedClass
    {
        private int PrivateValue { get; set; }

        public void PublicMethod()
        {
            Console.WriteLine("Public method called.");
        }
    }

    public void AccessNestedClassPrivateMethod()
    {
        var nestedClass = new NestedClass();

        try
        {
            nestedClass.PrivateValue = 10;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.PrivateValue = 10;
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**35. Attempt to access a protected member from an instance method of a protected static nested class**

```csharp
using System;

class OuterClass
{
    protected static class NestedClass
    {
        private int PrivateValue { get; set; }

        protected void ProtectedMethod()
        {
            Console.WriteLine("Protected method called.");
        }
    }

    public void AccessNestedClassProtectedMethod()
    {
        var nestedClass = new NestedClass();

        try
        {
            nestedClass.ProtectedMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            nestedClass.ProtectedMethod();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**36. Attempt to access a public member from an instance method of an internal nested class**

```csharp
using System;

class OuterClass
{
    internal class NestedClass
    {
        public int PublicValue { get; set; }
    }

    public void AccessNestedClassPublicMember()
    {
        var nestedClass = new NestedClass();

        try
        {
            Console.WriteLine(nestedClass.PublicValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                var nestedClass = new NestedClass();
                Console.WriteLine(nestedClass.PublicValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**37. Attempt to access a protected member from an instance method of an internal nested class**

```csharp
using System;

class OuterClass
{
    internal class NestedClass
    {
        protected int ProtectedValue { get; set; }
    }

    public void AccessNestedClassProtectedMember()
    {
        var nestedClass = new NestedClass();

        try
        {
            Console.WriteLine(nestedClass.ProtectedValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            Console.WriteLine(nestedClass.ProtectedValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**38. Attempt to access a private member from an instance method of an internal nested class**

```csharp
using System;

class OuterClass
{
    internal class NestedClass
    {
        private int PrivateValue { get; set; }
    }

    public void AccessNestedClassPrivateMember()
    {
        var nestedClass = new NestedClass();

        try
        {
            Console.WriteLine(nestedClass.PrivateValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                var nestedClass = new NestedClass();
                Console.WriteLine(nestedClass.PrivateValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**39. Attempt to access a public member from an instance method of a protected internal nested class**

```csharp
using System;

class OuterClass
{
    protected internal class NestedClass
    {
        public int PublicValue { get; set; }
    }

    public void AccessNestedClassPublicMember()
    {
        var nestedClass = new NestedClass();

        try
        {
            Console.WriteLine(nestedClass.PublicValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                var nestedClass = new NestedClass();
                Console.WriteLine(nestedClass.PublicValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**40. Attempt to access a protected member from an instance method of a protected internal nested class**

```csharp
using System;

class OuterClass
{
    protected internal class NestedClass
    {
        protected int ProtectedValue { get; set; }
    }

    public void AccessNestedClassProtectedMember()
    {
        var nestedClass = new NestedClass();

        try
        {
            Console.WriteLine(nestedClass.ProtectedValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

class Program
{
    static void Main()
    {
        var outerClass = new OuterClass();

        try
        {
            var nestedClass = new NestedClass();
            Console.WriteLine(nestedClass.ProtectedValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}
```

**41. Attempt to access a private member from an instance method of a protected internal nested class**

```csharp
using System;

class OuterClass
{
    protected internal class NestedClass
    {
        private int PrivateValue { get; set; }
    }

    public void AccessNestedClassPrivateMember()
    {
        var nestedClass = new NestedClass();

        try
        {
            Console.WriteLine(nestedClass.PrivateValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                var nestedClass = new NestedClass();
                Console.WriteLine(nestedClass.PrivateValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**42. Attempt to access a public member from an instance method of a private protected nested class**

```csharp
using System;

class OuterClass
{
    private protected class NestedClass
    {
        public int PublicValue { get; set; }
    }

    public void AccessNestedClassPublicMember()
    {
        var nestedClass = new NestedClass();

        try
        {
            Console.WriteLine(nestedClass.PublicValue);
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

    class Program
    {
        static void Main()
        {
            var outerClass = new OuterClass();

            try
            {
                var nestedClass = new NestedClass();
                Console.WriteLine(nestedClass.PublicValue);
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
```

**43. Attempt to access a protected member from an instance method of a private protected nested class**

```csharp
using System;

class OuterClass
{
    private protected class NestedClass
    {
        protected int ProtectedValue { get; set; }
    }

    public void AccessNestedClassProtectedMember()
    {
        var nestedClass = new NestedClass();

        try
        {
            Console.WriteLine(nestedClass.ProtectedValue);

```