Nested classes: accessing non-static fields of the outer class from inner class. Is it possible?

Thanks for the feedback. Ok. I admit I was writting this text in a hurry. Of course my example will not compile. I marked my code snippets with "..." before and after the snippet text. I didn't give the whole example program. But... please don't throw my example with the rubbish completely. I think it deserves a bit of attention. The program below will compile except for the line which is appropriately marked.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace OuterInner
{
    public class OuterClass
    {
        private int OuterField = 10;

        // Below the creation of InnerClass instance is made, so with the  
        // creation of OuterInstance InnerInstance will be created automatically.
        public InnerClass InnerInstance = new InnerClass(); 


        public class InnerClass
        {
            public void PrintOuterField(OuterClass OuterInstance)
            {
                // The line below will not compile. I thought inner instance 
                // of inner class can access directly to fields of instance of
                // outer class provided that inner class are instantiate in
                // the body of outer class. But.. probably it turns out
                // impossible to achieve.
                Console.WriteLine(OuterField); // <- this line will not compile
                
                // On the other hand this line WILL compile despite
                // 'OuterField' is private. This is obvious of course because
                // inner class (as you mentioned) has access to members of the
                // outer class.
                Console.WriteLine(OuterInstance.OuterField);  
            }
        }
        
    }
    
    public class Program
    {
        static void Main(string[] args)
        {
            // The line below creates instance of OuterClass so from that moment
            // OuterInstance (and InnerInstance) exists.
            OuterClass OuterInstance = new OuterClass();  
            OuterInstance.InnerInstance.PrintOuterField(OuterInstance);
            Console.ReadLine();
        }
    }
    
}

As you see I created OuterClass instance in the 'Main' method whereas InnerClass instance was created in the body of the OuterClase and (what is important I think) the InnerClass instance was created automatically in the moment when the OuterClass was instantiating. Therefore briefly speaking after creating instance of OuterClass we have actually both OuterClass and InnerClass instances. Of course I could make the 'OuterField' static. It would be easier to access such field from everywhere (of course provided that it would be public (eventually internal)). But I tried to find a solution to (I repeat this word again) to elegantly get rid of playing with static fields to make every instance of OuterClass completely distinct from its siblings. Actually I have such situation:
collection of collections. Let's name them SuperCollection and SubCollections. First I don't want SuperCollection class to be or to have fields with static apparition (so to speak). SubCollection instances have e.g. one information shared by them all (but again I don't want to store such info in a static field, I think for known reasons). I decided to create a field storing this information in the body of the SuperCollection class in order to every SubCollection instance could make use of it after instantiate SuperCollection without need of storing any reference to SuperCollection instance in every instance of SubCollection. To make completely non-static both SuperCollection and SubCollection classes so far I haven't found any other solution but (as mentioned above) to make another field in every SubCollection containing information about reference to its "container" to get access to mentioned shared SuperCollecttion instance reference-info field. It allows any instance of OuterCollection (and of course InnerCollections) to be unique but such solution is not very convenient (and... elegant) in my opinion on account of additional reference in every SubCollection instance. Maybe I try to ask the question in another way: In outer class is there a way to create some kind of global fields (without using static modifier) for nested classes, so every instance of nested class could use this "global field" transparently after instantiating outer class? If I'm wrong or confuse notions, please enlighten me.

Why could you not simply pass the outer class pointer as a constructor argument to the inner class? See my slightly modified code sample below. Your sample compiles fine and logic seems fine now.

-Sarah

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace OuterInner
{
    public class OuterClass
    {
        private int OuterField = 10;
 
        // Below the creation of InnerClass instance is made, so with the  
        // creation of OuterInstance InnerInstance will be created automatically.
        public InnerClass InnerInstance = new InnerClass(); 
 

        public class InnerClass
        {
			OuterClass m_oOuter = null;

			public InnerClass(OuterClass oOuter)
			{
				// Save the outer class pointer for use in a bit.
				this.m_oOuter = oOuter;
			}

            public void PrintOuterField(OuterClass OuterInstance)
            {
                // The line below will not compile. I thought inner instance 
                // of inner class can access directly to fields of instance of
                // outer class provided that inner class are instantiate in
                // the body of outer class. But.. probably it turns out
                // impossible to achieve.
                Console.WriteLine(this.m_oOuter); // <- this line will not compile
                
                // On the other hand this line WILL compile despite
                // 'OuterField' is private. This is obvious of course because
                // inner class (as you mentioned) has access to members of the
                // outer class.
                Console.WriteLine(OuterInstance.OuterField);  
            }
        }
        
    }
    
    public class Program
    {
        static void Main(string[] args)
        {
            // The line below creates instance of OuterClass so from that moment
            // OuterInstance (and InnerInstance) exists.
            OuterClass OuterInstance = new OuterClass();  
            OuterInstance.InnerInstance.PrintOuterField(OuterInstance);
            Console.ReadLine();
        }
    }
}