jt
2021-06-10 5d0d028456874576560552f5a5c4e8b801786f11
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#region Apache License
//
// Licensed to the Apache Software Foundation (ASF) under one or more 
// contributor license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright ownership. 
// The ASF licenses this file to you under the Apache License, Version 2.0
// (the "License"); you may not use this file except in compliance with 
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#endregion
 
using System;
using System.Collections;
 
namespace log4net.Util
{
    /// <summary>
    /// Implementation of Properties collection for the <see cref="log4net.ThreadContext"/>
    /// </summary>
    /// <remarks>
    /// <para>
    /// Class implements a collection of properties that is specific to each thread.
    /// The class is not synchronized as each thread has its own <see cref="PropertiesDictionary"/>.
    /// </para>
    /// </remarks>
    /// <author>Nicko Cadell</author>
    public sealed class ThreadContextProperties : ContextPropertiesBase
    {
        #region Private Instance Fields
 
        /// <summary>
        /// The thread local data slot to use to store a PropertiesDictionary.
        /// </summary>
        private readonly static LocalDataStoreSlot s_threadLocalSlot = System.Threading.Thread.AllocateDataSlot();
 
        #endregion Private Instance Fields
 
        #region Public Instance Constructors
 
        /// <summary>
        /// Internal constructor
        /// </summary>
        /// <remarks>
        /// <para>
        /// Initializes a new instance of the <see cref="ThreadContextProperties" /> class.
        /// </para>
        /// </remarks>
        internal ThreadContextProperties()
        {
        }
 
        #endregion Public Instance Constructors
 
        #region Public Instance Properties
 
        /// <summary>
        /// Gets or sets the value of a property
        /// </summary>
        /// <value>
        /// The value for the property with the specified key
        /// </value>
        /// <remarks>
        /// <para>
        /// Gets or sets the value of a property
        /// </para>
        /// </remarks>
        override public object this[string key]
        {
            get 
            { 
                PropertiesDictionary dictionary = GetProperties(false);
                if (dictionary != null)
                {
                    return dictionary[key]; 
                }
                return null;
            }
            set 
            { 
                GetProperties(true)[key] = value; 
            }
        }
 
        #endregion Public Instance Properties
 
        #region Public Instance Methods
 
        /// <summary>
        /// Remove a property
        /// </summary>
        /// <param name="key">the key for the entry to remove</param>
        /// <remarks>
        /// <para>
        /// Remove a property
        /// </para>
        /// </remarks>
        public void Remove(string key)
        {
            PropertiesDictionary dictionary = GetProperties(false);
            if (dictionary != null)
            {
                dictionary.Remove(key);
            }
        }
 
        /// <summary>
        /// Clear all properties
        /// </summary>
        /// <remarks>
        /// <para>
        /// Clear all properties
        /// </para>
        /// </remarks>
        public void Clear()
        {
            PropertiesDictionary dictionary = GetProperties(false);
            if (dictionary != null)
            {
                dictionary.Clear();
            }
        }
 
        #endregion Public Instance Methods
 
        #region Internal Instance Methods
 
        /// <summary>
        /// Get the <c>PropertiesDictionary</c> for this thread.
        /// </summary>
        /// <param name="create">create the dictionary if it does not exist, otherwise return null if is does not exist</param>
        /// <returns>the properties for this thread</returns>
        /// <remarks>
        /// <para>
        /// The collection returned is only to be used on the calling thread. If the
        /// caller needs to share the collection between different threads then the 
        /// caller must clone the collection before doing so.
        /// </para>
        /// </remarks>
        internal PropertiesDictionary GetProperties(bool create)
        {
            PropertiesDictionary properties = (PropertiesDictionary)System.Threading.Thread.GetData(s_threadLocalSlot);
            if (properties == null && create)
            {
                properties  = new PropertiesDictionary();
                System.Threading.Thread.SetData(s_threadLocalSlot, properties);
            }
            return properties;
        }
 
        #endregion Internal Instance Methods
    }
}