Q:

Access instance members through local static instance

I have a communication manager who is an instanced by de-serialization.
Now I want to create some static methods to access instance data.
On other posts i see people be advice not to access static fields of instance objects. But now I create the following code and this work like expected, i can de-serialize and use the static method without a new instance of the CommManager. Great! 
The question:
Is this is approach safe? 
I want to apply Threading, GetChannel is a core of my application and will be used by many application parts on multiple threads. I find it important that i do not create a performance penalty or into other consequences. Please advice.
I ask this cause i find it strange that i cannot find any similar example of this approach, The way i see it now, i can easily make every method static without disadvantages.
public class CommManager
{
    public ObservableCollection<ChannelConfig> channelConfigs;        
    private List<iChannel> channels;        
    private static CommManager StaticMe;

    public CommManager()
    {
        channelConfigs.CollectionChanged += ChannelCollectionChanged;
        StaticMe = this;            
    }

    private void ChannelCollectionChanged(object sender, 
        NotifyCollectionChangedEventArgs args)
    {
        if (channels == null)
            channels = new List<iChannel>();
        switch (args.Action)
        {
            case NotifyCollectionChangedAction.Add:
                foreach (ChannelConfig newItem in args.NewItems)
                    channels.Add(CreateChannel(newItem));
                break;
            case Notif.. /// etc. etc.
        }
    }

    /// <summary>
    /// I can access this method without instance and i get normal de-serialized values
    /// </summary>
    public static iChannel GetChannel(CommChannel channelnr)
    {
         return StaticMe.Channels[(int)channelnr];
    }
}

A:

A problem might arise the moment you create a second instance of your class.
A static field can only exist once. The moment you overwrite a static field, it will change the reference to the new object. 
Any old reference set to the old object that might still be used elsewhere will not update - or worse, if it holds any data, it might change unexpectedly.
CommManager manager = new CommManager();
manager.GetChannel(); 
// refers to the static field StaticMe.channels which is manager.channels.

CommManager manager2 = new CommManager();
manager2.GetChannel();
// refers to the static field StaticMe.channels which is manager2.channels.
manager.GetChannel();
// still exists, now refers to manager2.channels because of StaticMe now being manager2
// It is not retaining any of the original channels because of the changed reference.

Because of that, static fields or properties should better be immutable and not rely on anything stored within the static property other than default or fixed values.
If you really have to store mutable values globally, don't assign them in a constructor or in any instance method but on the definition. 
If your channels should be available globally, then make the List globally available by making that one static readonly (as the List reference will stay the same, only the contents may change).
// for brevity, removed all unchanged parts...
public class CommManager
{
    private static readonly List<IChannel> channels = new List<IChannel>();

    private void ChannelCollectionChanged(object sender, 
        NotifyCollectionChangedEventArgs args)
    {
        switch (args.Action)
        {
            case NotifyCollectionChangedAction.Add:
                foreach (ChannelConfig newItem in args.NewItems)
                    CommManager.channels.Add(CreateChannel(newItem));
                break;
            case Notif.. /// etc. etc.
        }
    }

    public static IChannel GetChannel(CommChannel channelNr)
    {
        return CommManager.channels[(int)channelNr];
    }
}

Also if you are going to a multi threading approach, you might need a ConcurrentBag<T> that is thread safe instead of a normal List<T> which is not.

