System.Runtime.Remoting.Messaging.StackBuilderSink.PreserveThreadPrincipalIfNecessary C# (CSharp) Method

        internal static void PreserveThreadPrincipalIfNecessary(
            LogicalCallContext messageCallContext, 
            LogicalCallContext threadCallContext)
        {
            BCLDebug.Assert(messageCallContext != null, "message should always have a call context");

            if (threadCallContext != null)
            {
                if (messageCallContext.Principal == null)
                {                
                    IPrincipal currentPrincipal = threadCallContext.Principal;
                    if (currentPrincipal != null)
                    {
                        messageCallContext.Principal = currentPrincipal;
                    }
                }
            }
        } // PreserveThreadPrincipalIfNecessary

        public virtual IMessage SyncProcessMessage(IMessage msg)
        {
            IMessage message = InternalSink.ValidateMessage(msg);

            if (message != null)
            {
                return(message);
            }
            IMethodCallMessage methodCallMessage   = msg as IMethodCallMessage;
            LogicalCallContext logicalCallContext  = null;
            LogicalCallContext logicalCallContext2 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
            object             data = logicalCallContext2.GetData("__xADCall");
            bool     flag           = false;
            IMessage message2;

            try
            {
                object server = this._server;
                StackBuilderSink.VerifyIsOkToCallMethod(server, methodCallMessage);
                LogicalCallContext logicalCallContext3;
                if (methodCallMessage != null)
                {
                    logicalCallContext3 = methodCallMessage.LogicalCallContext;
                }
                else
                {
                    logicalCallContext3 = (LogicalCallContext)msg.Properties["__CallContext"];
                }
                logicalCallContext = CallContext.SetLogicalCallContext(logicalCallContext3);
                flag = true;
                logicalCallContext3.PropagateIncomingHeadersToCallContext(msg);
                StackBuilderSink.PreserveThreadPrincipalIfNecessary(logicalCallContext3, logicalCallContext);
                if (this.IsOKToStackBlt(methodCallMessage, server) && ((Message)methodCallMessage).Dispatch(server))
                {
                    message2 = new StackBasedReturnMessage();
                    ((StackBasedReturnMessage)message2).InitFields((Message)methodCallMessage);
                    LogicalCallContext logicalCallContext4 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
                    logicalCallContext4.PropagateOutgoingHeadersToMessage(message2);
                    ((StackBasedReturnMessage)message2).SetLogicalCallContext(logicalCallContext4);
                }
                else
                {
                    MethodBase methodBase = StackBuilderSink.GetMethodBase(methodCallMessage);
                    object[]   array      = null;
                    RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
                    object[] args = Message.CoerceArgs(methodCallMessage, reflectionCachedData.Parameters);
                    object   ret  = this.PrivateProcessMessage(methodBase.MethodHandle, args, server, out array);
                    this.CopyNonByrefOutArgsFromOriginalArgs(reflectionCachedData, args, ref array);
                    LogicalCallContext logicalCallContext5 = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
                    if (data != null && (bool)data && logicalCallContext5 != null)
                    {
                        logicalCallContext5.RemovePrincipalIfNotSerializable();
                    }
                    message2 = new ReturnMessage(ret, array, (array == null) ? 0 : array.Length, logicalCallContext5, methodCallMessage);
                    logicalCallContext5.PropagateOutgoingHeadersToMessage(message2);
                    CallContext.SetLogicalCallContext(logicalCallContext);
                }
            }
            catch (Exception e)
            {
                message2 = new ReturnMessage(e, methodCallMessage);
                ((ReturnMessage)message2).SetLogicalCallContext(methodCallMessage.LogicalCallContext);
                if (flag)
                {
                    CallContext.SetLogicalCallContext(logicalCallContext);
                }
            }
            return(message2);
        }