プロジェクト

全般

プロフィール

リビジョン 463

堀内約5年前に追加

不要実行モジュール削除

差分を表示:

trunk/src/ProcessManagement/ProcessManagement/bin/Debug/log4net.xml
1
<?xml version="1.0"?>
2
<doc>
3
    <assembly>
4
        <name>log4net</name>
5
    </assembly>
6
    <members>
7
        <member name="T:log4net.Appender.AdoNetAppender">
8
            <summary>
9
            Appender that logs to a database.
10
            </summary>
11
            <remarks>
12
            <para>
13
            <see cref="T:log4net.Appender.AdoNetAppender"/> appends logging events to a table within a
14
            database. The appender can be configured to specify the connection 
15
            string by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionString"/> property. 
16
            The connection type (provider) can be specified by setting the <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/>
17
            property. For more information on database connection strings for
18
            your specific database see <a href="http://www.connectionstrings.com/">http://www.connectionstrings.com/</a>.
19
            </para>
20
            <para>
21
            Records are written into the database either using a prepared
22
            statement or a stored procedure. The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property
23
            is set to <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify a prepared statement
24
            or to <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify a stored
25
            procedure.
26
            </para>
27
            <para>
28
            The prepared statement text or the name of the stored procedure
29
            must be set in the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property.
30
            </para>
31
            <para>
32
            The prepared statement or stored procedure can take a number
33
            of parameters. Parameters are added using the <see cref="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)"/>
34
            method. This adds a single <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> to the
35
            ordered list of parameters. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/>
36
            type may be subclassed if required to provide database specific
37
            functionality. The <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> specifies
38
            the parameter name, database type, size, and how the value should
39
            be generated using a <see cref="T:log4net.Layout.ILayout"/>.
40
            </para>
41
            </remarks>
42
            <example>
43
            An example of a SQL Server table that could be logged to:
44
            <code lang="SQL">
45
            CREATE TABLE [dbo].[Log] ( 
46
              [ID] [int] IDENTITY (1, 1) NOT NULL ,
47
              [Date] [datetime] NOT NULL ,
48
              [Thread] [varchar] (255) NOT NULL ,
49
              [Level] [varchar] (20) NOT NULL ,
50
              [Logger] [varchar] (255) NOT NULL ,
51
              [Message] [varchar] (4000) NOT NULL 
52
            ) ON [PRIMARY]
53
            </code>
54
            </example>
55
            <example>
56
            An example configuration to log to the above table:
57
            <code lang="XML" escaped="true">
58
            <appender name="AdoNetAppender_SqlServer" type="log4net.Appender.AdoNetAppender">
59
              <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"/>
60
              <connectionString value="data source=SQLSVR;initial catalog=test_log4net;integrated security=false;persist security info=True;User ID=sa;Password=sa"/>
61
              <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)"/>
62
              <parameter>
63
                <parameterName value="@log_date"/>
64
                <dbType value="DateTime"/>
65
                <layout type="log4net.Layout.PatternLayout" value="%date{yyyy'-'MM'-'dd HH':'mm':'ss'.'fff}"/>
66
              </parameter>
67
              <parameter>
68
                <parameterName value="@thread"/>
69
                <dbType value="String"/>
70
                <size value="255"/>
71
                <layout type="log4net.Layout.PatternLayout" value="%thread"/>
72
              </parameter>
73
              <parameter>
74
                <parameterName value="@log_level"/>
75
                <dbType value="String"/>
76
                <size value="50"/>
77
                <layout type="log4net.Layout.PatternLayout" value="%level"/>
78
              </parameter>
79
              <parameter>
80
                <parameterName value="@logger"/>
81
                <dbType value="String"/>
82
                <size value="255"/>
83
                <layout type="log4net.Layout.PatternLayout" value="%logger"/>
84
              </parameter>
85
              <parameter>
86
                <parameterName value="@message"/>
87
                <dbType value="String"/>
88
                <size value="4000"/>
89
                <layout type="log4net.Layout.PatternLayout" value="%message"/>
90
              </parameter>
91
            </appender>
92
            </code>
93
            </example>
94
            <author>Julian Biddle</author>
95
            <author>Nicko Cadell</author>
96
            <author>Gert Driesen</author>
97
            <author>Lance Nehring</author>
98
        </member>
99
        <member name="T:log4net.Appender.BufferingAppenderSkeleton">
100
            <summary>
101
            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/> that 
102
            buffers events in a fixed size buffer.
103
            </summary>
104
            <remarks>
105
            <para>
106
            This base class should be used by appenders that need to buffer a 
107
            number of events before logging them. For example the <see cref="T:log4net.Appender.AdoNetAppender"/> 
108
            buffers events and then submits the entire contents of the buffer to 
109
            the underlying database in one go.
110
            </para>
111
            <para>
112
            Subclasses should override the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>
113
            method to deliver the buffered events.
114
            </para>
115
            <para>The BufferingAppenderSkeleton maintains a fixed size cyclic 
116
            buffer of events. The size of the buffer is set using 
117
            the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> property.
118
            </para>
119
            <para>A <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> is used to inspect 
120
            each event as it arrives in the appender. If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> 
121
            triggers, then the current buffer is sent immediately 
122
            (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>). Otherwise the event 
123
            is stored in the buffer. For example, an evaluator can be used to 
124
            deliver the events immediately when an ERROR event arrives.
125
            </para>
126
            <para>
127
            The buffering appender can be configured in a <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode. 
128
            By default the appender is NOT lossy. When the buffer is full all 
129
            the buffered events are sent with <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>.
130
            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property is set to <c>true</c> then the 
131
            buffer will not be sent when it is full, and new events arriving 
132
            in the appender will overwrite the oldest event in the buffer. 
133
            In lossy mode the buffer will only be sent when the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/>
134
            triggers. This can be useful behavior when you need to know about 
135
            ERROR events but not about events with a lower level, configure an 
136
            evaluator that will trigger when an ERROR event arrives, the whole 
137
            buffer will be sent which gives a history of events leading up to
138
            the ERROR event.
139
            </para>
140
            </remarks>
141
            <author>Nicko Cadell</author>
142
            <author>Gert Driesen</author>
143
        </member>
144
        <member name="T:log4net.Appender.AppenderSkeleton">
145
            <summary>
146
            Abstract base class implementation of <see cref="T:log4net.Appender.IAppender"/>. 
147
            </summary>
148
            <remarks>
149
            <para>
150
            This class provides the code for common functionality, such 
151
            as support for threshold filtering and support for general filters.
152
            </para>
153
            <para>
154
            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
155
            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method
156
            be called after the appenders properties have been configured.
157
            </para>
158
            </remarks>
159
            <author>Nicko Cadell</author>
160
            <author>Gert Driesen</author>
161
        </member>
162
        <member name="T:log4net.Appender.IAppender">
163
            <summary>
164
            Implement this interface for your own strategies for printing log statements.
165
            </summary>
166
            <remarks>
167
            <para>
168
            Implementors should consider extending the <see cref="T:log4net.Appender.AppenderSkeleton"/>
169
            class which provides a default implementation of this interface.
170
            </para>
171
            <para>
172
            Appenders can also implement the <see cref="T:log4net.Core.IOptionHandler"/> interface. Therefore
173
            they would require that the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method
174
            be called after the appenders properties have been configured.
175
            </para>
176
            </remarks>
177
            <author>Nicko Cadell</author>
178
            <author>Gert Driesen</author>
179
        </member>
180
        <member name="M:log4net.Appender.IAppender.Close">
181
            <summary>
182
            Closes the appender and releases resources.
183
            </summary>
184
            <remarks>
185
            <para>
186
            Releases any resources allocated within the appender such as file handles, 
187
            network connections, etc.
188
            </para>
189
            <para>
190
            It is a programming error to append to a closed appender.
191
            </para>
192
            </remarks>
193
        </member>
194
        <member name="M:log4net.Appender.IAppender.DoAppend(log4net.Core.LoggingEvent)">
195
            <summary>
196
            Log the logging event in Appender specific way.
197
            </summary>
198
            <param name="loggingEvent">The event to log</param>
199
            <remarks>
200
            <para>
201
            This method is called to log a message into this appender.
202
            </para>
203
            </remarks>
204
        </member>
205
        <member name="P:log4net.Appender.IAppender.Name">
206
            <summary>
207
            Gets or sets the name of this appender.
208
            </summary>
209
            <value>The name of the appender.</value>
210
            <remarks>
211
            <para>The name uniquely identifies the appender.</para>
212
            </remarks>
213
        </member>
214
        <member name="T:log4net.Appender.IBulkAppender">
215
            <summary>
216
            Interface for appenders that support bulk logging.
217
            </summary>
218
            <remarks>
219
            <para>
220
            This interface extends the <see cref="T:log4net.Appender.IAppender"/> interface to
221
            support bulk logging of <see cref="T:log4net.Core.LoggingEvent"/> objects. Appenders
222
            should only implement this interface if they can bulk log efficiently.
223
            </para>
224
            </remarks>
225
            <author>Nicko Cadell</author>
226
        </member>
227
        <member name="M:log4net.Appender.IBulkAppender.DoAppend(log4net.Core.LoggingEvent[])">
228
            <summary>
229
            Log the array of logging events in Appender specific way.
230
            </summary>
231
            <param name="loggingEvents">The events to log</param>
232
            <remarks>
233
            <para>
234
            This method is called to log an array of events into this appender.
235
            </para>
236
            </remarks>
237
        </member>
238
        <member name="T:log4net.Core.IOptionHandler">
239
            <summary>
240
            Interface used to delay activate a configured object.
241
            </summary>
242
            <remarks>
243
            <para>
244
            This allows an object to defer activation of its options until all
245
            options have been set. This is required for components which have
246
            related options that remain ambiguous until all are set.
247
            </para>
248
            <para>
249
            If a component implements this interface then the <see cref="M:log4net.Core.IOptionHandler.ActivateOptions"/> method 
250
            must be called by the container after its all the configured properties have been set 
251
            and before the component can be used.
252
            </para>
253
            </remarks>
254
            <author>Nicko Cadell</author>
255
        </member>
256
        <member name="M:log4net.Core.IOptionHandler.ActivateOptions">
257
            <summary>
258
            Activate the options that were previously set with calls to properties.
259
            </summary>
260
            <remarks>
261
            <para>
262
            This allows an object to defer activation of its options until all
263
            options have been set. This is required for components which have
264
            related options that remain ambiguous until all are set.
265
            </para>
266
            <para>
267
            If a component implements this interface then this method must be called
268
            after its properties have been set before the component can be used.
269
            </para>
270
            </remarks>
271
        </member>
272
        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferSize">
273
            <summary>
274
            Initial buffer size
275
            </summary>
276
        </member>
277
        <member name="F:log4net.Appender.AppenderSkeleton.c_renderBufferMaxCapacity">
278
            <summary>
279
            Maximum buffer size before it is recycled
280
            </summary>
281
        </member>
282
        <member name="M:log4net.Appender.AppenderSkeleton.#ctor">
283
            <summary>
284
            Default constructor
285
            </summary>
286
            <remarks>
287
            <para>Empty default constructor</para>
288
            </remarks>
289
        </member>
290
        <member name="M:log4net.Appender.AppenderSkeleton.Finalize">
291
            <summary>
292
            Finalizes this appender by calling the implementation's 
293
            <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> method.
294
            </summary>
295
            <remarks>
296
            <para>
297
            If this appender has not been closed then the <c>Finalize</c> method
298
            will call <see cref="M:log4net.Appender.AppenderSkeleton.Close"/>.
299
            </para>
300
            </remarks>
301
        </member>
302
        <member name="M:log4net.Appender.AppenderSkeleton.ActivateOptions">
303
            <summary>
304
            Initialize the appender based on the options set
305
            </summary>
306
            <remarks>
307
            <para>
308
            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
309
            activation scheme. The <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> method must 
310
            be called on this object after the configuration properties have
311
            been set. Until <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> is called this
312
            object is in an undefined state and must not be used. 
313
            </para>
314
            <para>
315
            If any of the configuration properties are modified then 
316
            <see cref="M:log4net.Appender.AppenderSkeleton.ActivateOptions"/> must be called again.
317
            </para>
318
            </remarks>
319
        </member>
320
        <member name="M:log4net.Appender.AppenderSkeleton.Close">
321
            <summary>
322
            Closes the appender and release resources.
323
            </summary>
324
            <remarks>
325
            <para>
326
            Release any resources allocated within the appender such as file handles, 
327
            network connections, etc.
328
            </para>
329
            <para>
330
            It is a programming error to append to a closed appender.
331
            </para>
332
            <para>
333
            This method cannot be overridden by subclasses. This method 
334
            delegates the closing of the appender to the <see cref="M:log4net.Appender.AppenderSkeleton.OnClose"/>
335
            method which must be overridden in the subclass.
336
            </para>
337
            </remarks>
338
        </member>
339
        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)">
340
            <summary>
341
            Performs threshold checks and invokes filters before 
342
            delegating actual logging to the subclasses specific 
343
            <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
344
            </summary>
345
            <param name="loggingEvent">The event to log.</param>
346
            <remarks>
347
            <para>
348
            This method cannot be overridden by derived classes. A
349
            derived class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method
350
            which is called by this method.
351
            </para>
352
            <para>
353
            The implementation of this method is as follows:
354
            </para>
355
            <para>
356
            <list type="bullet">
357
            	<item>
358
            		<description>
359
            		Checks that the severity of the <paramref name="loggingEvent"/>
360
            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
361
            		appender.</description>
362
            	</item>
363
            	<item>
364
            		<description>
365
            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
366
            		<paramref name="loggingEvent"/>.
367
            		</description>
368
            	</item>
369
            	<item>
370
            		<description>
371
            		Calls <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and checks that 
372
            		it returns <c>true</c>.</description>
373
            	</item>
374
            </list>
375
            </para>
376
            <para>
377
            If all of the above steps succeed then the <paramref name="loggingEvent"/>
378
            will be passed to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
379
            </para>
380
            </remarks>
381
        </member>
382
        <member name="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent[])">
383
            <summary>
384
            Performs threshold checks and invokes filters before 
385
            delegating actual logging to the subclasses specific 
386
            <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method.
387
            </summary>
388
            <param name="loggingEvents">The array of events to log.</param>
389
            <remarks>
390
            <para>
391
            This method cannot be overridden by derived classes. A
392
            derived class should override the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method
393
            which is called by this method.
394
            </para>
395
            <para>
396
            The implementation of this method is as follows:
397
            </para>
398
            <para>
399
            <list type="bullet">
400
            	<item>
401
            		<description>
402
            		Checks that the severity of the <paramref name="loggingEvent"/>
403
            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
404
            		appender.</description>
405
            	</item>
406
            	<item>
407
            		<description>
408
            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
409
            		<paramref name="loggingEvent"/>.
410
            		</description>
411
            	</item>
412
            	<item>
413
            		<description>
414
            		Calls <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> and checks that 
415
            		it returns <c>true</c>.</description>
416
            	</item>
417
            </list>
418
            </para>
419
            <para>
420
            If all of the above steps succeed then the <paramref name="loggingEvents"/>
421
            will be passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])"/> method.
422
            </para>
423
            </remarks>
424
        </member>
425
        <member name="M:log4net.Appender.AppenderSkeleton.FilterEvent(log4net.Core.LoggingEvent)">
426
            <summary>
427
            Test if the logging event should we output by this appender
428
            </summary>
429
            <param name="loggingEvent">the event to test</param>
430
            <returns><c>true</c> if the event should be output, <c>false</c> if the event should be ignored</returns>
431
            <remarks>
432
            <para>
433
            This method checks the logging event against the threshold level set
434
            on this appender and also against the filters specified on this
435
            appender.
436
            </para>
437
            <para>
438
            The implementation of this method is as follows:
439
            </para>
440
            <para>
441
            <list type="bullet">
442
            	<item>
443
            		<description>
444
            		Checks that the severity of the <paramref name="loggingEvent"/>
445
            		is greater than or equal to the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> of this
446
            		appender.</description>
447
            	</item>
448
            	<item>
449
            		<description>
450
            		Checks that the <see cref="T:log4net.Filter.IFilter"/> chain accepts the 
451
            		<paramref name="loggingEvent"/>.
452
            		</description>
453
            	</item>
454
            </list>
455
            </para>
456
            </remarks>
457
        </member>
458
        <member name="M:log4net.Appender.AppenderSkeleton.AddFilter(log4net.Filter.IFilter)">
459
            <summary>
460
            Adds a filter to the end of the filter chain.
461
            </summary>
462
            <param name="filter">the filter to add to this appender</param>
463
            <remarks>
464
            <para>
465
            The Filters are organized in a linked list.
466
            </para>
467
            <para>
468
            Setting this property causes the new filter to be pushed onto the 
469
            back of the filter chain.
470
            </para>
471
            </remarks>
472
        </member>
473
        <member name="M:log4net.Appender.AppenderSkeleton.ClearFilters">
474
            <summary>
475
            Clears the filter list for this appender.
476
            </summary>
477
            <remarks>
478
            <para>
479
            Clears the filter list for this appender.
480
            </para>
481
            </remarks>
482
        </member>
483
        <member name="M:log4net.Appender.AppenderSkeleton.IsAsSevereAsThreshold(log4net.Core.Level)">
484
            <summary>
485
            Checks if the message level is below this appender's threshold.
486
            </summary>
487
            <param name="level"><see cref="T:log4net.Core.Level"/> to test against.</param>
488
            <remarks>
489
            <para>
490
            If there is no threshold set, then the return value is always <c>true</c>.
491
            </para>
492
            </remarks>
493
            <returns>
494
            <c>true</c> if the <paramref name="level"/> meets the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> 
495
            requirements of this appender.
496
            </returns>
497
        </member>
498
        <member name="M:log4net.Appender.AppenderSkeleton.OnClose">
499
            <summary>
500
            Is called when the appender is closed. Derived classes should override 
501
            this method if resources need to be released.
502
            </summary>
503
            <remarks>
504
            <para>
505
            Releases any resources allocated within the appender such as file handles, 
506
            network connections, etc.
507
            </para>
508
            <para>
509
            It is a programming error to append to a closed appender.
510
            </para>
511
            </remarks>
512
        </member>
513
        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)">
514
            <summary>
515
            Subclasses of <see cref="T:log4net.Appender.AppenderSkeleton"/> should implement this method 
516
            to perform actual logging.
517
            </summary>
518
            <param name="loggingEvent">The event to append.</param>
519
            <remarks>
520
            <para>
521
            A subclass must implement this method to perform
522
            logging of the <paramref name="loggingEvent"/>.
523
            </para>
524
            <para>This method will be called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
525
            if all the conditions listed for that method are met.
526
            </para>
527
            <para>
528
            To restrict the logging of events in the appender
529
            override the <see cref="M:log4net.Appender.AppenderSkeleton.PreAppendCheck"/> method.
530
            </para>
531
            </remarks>
532
        </member>
533
        <member name="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent[])">
534
            <summary>
535
            Append a bulk array of logging events.
536
            </summary>
537
            <param name="loggingEvents">the array of logging events</param>
538
            <remarks>
539
            <para>
540
            This base class implementation calls the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/>
541
            method for each element in the bulk array.
542
            </para>
543
            <para>
544
            A sub class that can better process a bulk array of events should
545
            override this method in addition to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/>.
546
            </para>
547
            </remarks>
548
        </member>
549
        <member name="M:log4net.Appender.AppenderSkeleton.PreAppendCheck">
550
            <summary>
551
            Called before <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> as a precondition.
552
            </summary>
553
            <remarks>
554
            <para>
555
            This method is called by <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/>
556
            before the call to the abstract <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
557
            </para>
558
            <para>
559
            This method can be overridden in a subclass to extend the checks 
560
            made before the event is passed to the <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> method.
561
            </para>
562
            <para>
563
            A subclass should ensure that they delegate this call to
564
            this base class if it is overridden.
565
            </para>
566
            </remarks>
567
            <returns><c>true</c> if the call to <see cref="M:log4net.Appender.AppenderSkeleton.Append(log4net.Core.LoggingEvent)"/> should proceed.</returns>
568
        </member>
569
        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)">
570
            <summary>
571
            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
572
            </summary>
573
            <param name="loggingEvent">The event to render.</param>
574
            <returns>The event rendered as a string.</returns>
575
            <remarks>
576
            <para>
577
            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
578
            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
579
            set to render the <paramref name="loggingEvent"/> to 
580
            a string.
581
            </para>
582
            <para>If there is exception data in the logging event and 
583
            the layout does not process the exception, this method 
584
            will append the exception text to the rendered string.
585
            </para>
586
            <para>
587
            Where possible use the alternative version of this method
588
            <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)"/>.
589
            That method streams the rendering onto an existing Writer
590
            which can give better performance if the caller already has
591
            a <see cref="T:System.IO.TextWriter"/> open and ready for writing.
592
            </para>
593
            </remarks>
594
        </member>
595
        <member name="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(System.IO.TextWriter,log4net.Core.LoggingEvent)">
596
            <summary>
597
            Renders the <see cref="T:log4net.Core.LoggingEvent"/> to a string.
598
            </summary>
599
            <param name="loggingEvent">The event to render.</param>
600
            <param name="writer">The TextWriter to write the formatted event to</param>
601
            <remarks>
602
            <para>
603
            Helper method to render a <see cref="T:log4net.Core.LoggingEvent"/> to 
604
            a string. This appender must have a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/>
605
            set to render the <paramref name="loggingEvent"/> to 
606
            a string.
607
            </para>
608
            <para>If there is exception data in the logging event and 
609
            the layout does not process the exception, this method 
610
            will append the exception text to the rendered string.
611
            </para>
612
            <para>
613
            Use this method in preference to <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)"/>
614
            where possible. If, however, the caller needs to render the event
615
            to a string then <see cref="M:log4net.Appender.AppenderSkeleton.RenderLoggingEvent(log4net.Core.LoggingEvent)"/> does
616
            provide an efficient mechanism for doing so.
617
            </para>
618
            </remarks>
619
        </member>
620
        <member name="F:log4net.Appender.AppenderSkeleton.m_layout">
621
            <summary>
622
            The layout of this appender.
623
            </summary>
624
            <remarks>
625
            See <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> for more information.
626
            </remarks>
627
        </member>
628
        <member name="F:log4net.Appender.AppenderSkeleton.m_name">
629
            <summary>
630
            The name of this appender.
631
            </summary>
632
            <remarks>
633
            See <see cref="P:log4net.Appender.AppenderSkeleton.Name"/> for more information.
634
            </remarks>
635
        </member>
636
        <member name="F:log4net.Appender.AppenderSkeleton.m_threshold">
637
            <summary>
638
            The level threshold of this appender.
639
            </summary>
640
            <remarks>
641
            <para>
642
            There is no level threshold filtering by default.
643
            </para>
644
            <para>
645
            See <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> for more information.
646
            </para>
647
            </remarks>
648
        </member>
649
        <member name="F:log4net.Appender.AppenderSkeleton.m_errorHandler">
650
            <summary>
651
            It is assumed and enforced that errorHandler is never null.
652
            </summary>
653
            <remarks>
654
            <para>
655
            It is assumed and enforced that errorHandler is never null.
656
            </para>
657
            <para>
658
            See <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> for more information.
659
            </para>
660
            </remarks>
661
        </member>
662
        <member name="F:log4net.Appender.AppenderSkeleton.m_headFilter">
663
            <summary>
664
            The first filter in the filter chain.
665
            </summary>
666
            <remarks>
667
            <para>
668
            Set to <c>null</c> initially.
669
            </para>
670
            <para>
671
            See <see cref="T:log4net.Filter.IFilter"/> for more information.
672
            </para>
673
            </remarks>
674
        </member>
675
        <member name="F:log4net.Appender.AppenderSkeleton.m_tailFilter">
676
            <summary>
677
            The last filter in the filter chain.
678
            </summary>
679
            <remarks>
680
            See <see cref="T:log4net.Filter.IFilter"/> for more information.
681
            </remarks>
682
        </member>
683
        <member name="F:log4net.Appender.AppenderSkeleton.m_closed">
684
            <summary>
685
            Flag indicating if this appender is closed.
686
            </summary>
687
            <remarks>
688
            See <see cref="M:log4net.Appender.AppenderSkeleton.Close"/> for more information.
689
            </remarks>
690
        </member>
691
        <member name="F:log4net.Appender.AppenderSkeleton.m_recursiveGuard">
692
            <summary>
693
            The guard prevents an appender from repeatedly calling its own DoAppend method
694
            </summary>
695
        </member>
696
        <member name="F:log4net.Appender.AppenderSkeleton.m_renderWriter">
697
            <summary>
698
            StringWriter used to render events
699
            </summary>
700
        </member>
701
        <member name="P:log4net.Appender.AppenderSkeleton.Threshold">
702
            <summary>
703
            Gets or sets the threshold <see cref="T:log4net.Core.Level"/> of this appender.
704
            </summary>
705
            <value>
706
            The threshold <see cref="T:log4net.Core.Level"/> of the appender. 
707
            </value>
708
            <remarks>
709
            <para>
710
            All log events with lower level than the threshold level are ignored 
711
            by the appender.
712
            </para>
713
            <para>
714
            In configuration files this option is specified by setting the
715
            value of the <see cref="P:log4net.Appender.AppenderSkeleton.Threshold"/> option to a level
716
            string, such as "DEBUG", "INFO" and so on.
717
            </para>
718
            </remarks>
719
        </member>
720
        <member name="P:log4net.Appender.AppenderSkeleton.ErrorHandler">
721
            <summary>
722
            Gets or sets the <see cref="T:log4net.Core.IErrorHandler"/> for this appender.
723
            </summary>
724
            <value>The <see cref="T:log4net.Core.IErrorHandler"/> of the appender</value>
725
            <remarks>
726
            <para>
727
            The <see cref="T:log4net.Appender.AppenderSkeleton"/> provides a default 
728
            implementation for the <see cref="P:log4net.Appender.AppenderSkeleton.ErrorHandler"/> property. 
729
            </para>
730
            </remarks>
731
        </member>
732
        <member name="P:log4net.Appender.AppenderSkeleton.FilterHead">
733
            <summary>
734
            The filter chain.
735
            </summary>
736
            <value>The head of the filter chain filter chain.</value>
737
            <remarks>
738
            <para>
739
            Returns the head Filter. The Filters are organized in a linked list
740
            and so all Filters on this Appender are available through the result.
741
            </para>
742
            </remarks>
743
        </member>
744
        <member name="P:log4net.Appender.AppenderSkeleton.Layout">
745
            <summary>
746
            Gets or sets the <see cref="T:log4net.Layout.ILayout"/> for this appender.
747
            </summary>
748
            <value>The layout of the appender.</value>
749
            <remarks>
750
            <para>
751
            See <see cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/> for more information.
752
            </para>
753
            </remarks>
754
            <seealso cref="P:log4net.Appender.AppenderSkeleton.RequiresLayout"/>
755
        </member>
756
        <member name="P:log4net.Appender.AppenderSkeleton.Name">
757
            <summary>
758
            Gets or sets the name of this appender.
759
            </summary>
760
            <value>The name of the appender.</value>
761
            <remarks>
762
            <para>
763
            The name uniquely identifies the appender.
764
            </para>
765
            </remarks>
766
        </member>
767
        <member name="P:log4net.Appender.AppenderSkeleton.RequiresLayout">
768
            <summary>
769
            Tests if this appender requires a <see cref="P:log4net.Appender.AppenderSkeleton.Layout"/> to be set.
770
            </summary>
771
            <remarks>
772
            <para>
773
            In the rather exceptional case, where the appender 
774
            implementation admits a layout but can also work without it, 
775
            then the appender should return <c>true</c>.
776
            </para>
777
            <para>
778
            This default implementation always returns <c>true</c>.
779
            </para>
780
            </remarks>
781
            <returns>
782
            <c>true</c> if the appender requires a layout object, otherwise <c>false</c>.
783
            </returns>
784
        </member>
785
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE">
786
            <summary>
787
            The default buffer size.
788
            </summary>
789
            <remarks>
790
            The default size of the cyclic buffer used to store events.
791
            This is set to 512 by default.
792
            </remarks>
793
        </member>
794
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor">
795
            <summary>
796
            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
797
            </summary>
798
            <remarks>
799
            <para>
800
            Protected default constructor to allow subclassing.
801
            </para>
802
            </remarks>
803
        </member>
804
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.#ctor(System.Boolean)">
805
            <summary>
806
            Initializes a new instance of the <see cref="T:log4net.Appender.BufferingAppenderSkeleton"/> class.
807
            </summary>
808
            <param name="eventMustBeFixed">the events passed through this appender must be
809
            fixed by the time that they arrive in the derived class' <c>SendBuffer</c> method.</param>
810
            <remarks>
811
            <para>
812
            Protected constructor to allow subclassing.
813
            </para>
814
            <para>
815
            The <paramref name="eventMustBeFixed"/> should be set if the subclass
816
            expects the events delivered to be fixed even if the 
817
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to zero, i.e. when no buffering occurs.
818
            </para>
819
            </remarks>
820
        </member>
821
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush">
822
            <summary>
823
            Flush the currently buffered events
824
            </summary>
825
            <remarks>
826
            <para>
827
            Flushes any events that have been buffered.
828
            </para>
829
            <para>
830
            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
831
            of the buffer will NOT be flushed to the appender.
832
            </para>
833
            </remarks>
834
        </member>
835
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Flush(System.Boolean)">
836
            <summary>
837
            Flush the currently buffered events
838
            </summary>
839
            <param name="flushLossyBuffer">set to <c>true</c> to flush the buffer of lossy events</param>
840
            <remarks>
841
            <para>
842
            Flushes events that have been buffered. If <paramref name="flushLossyBuffer"/> is
843
            <c>false</c> then events will only be flushed if this buffer is non-lossy mode.
844
            </para>
845
            <para>
846
            If the appender is buffering in <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> mode then the contents
847
            of the buffer will only be flushed if <paramref name="flushLossyBuffer"/> is <c>true</c>.
848
            In this case the contents of the buffer will be tested against the 
849
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator"/> and if triggering will be output. All other buffered
850
            events will be discarded.
851
            </para>
852
            <para>
853
            If <paramref name="flushLossyBuffer"/> is <c>true</c> then the buffer will always
854
            be emptied by calling this method.
855
            </para>
856
            </remarks>
857
        </member>
858
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions">
859
            <summary>
860
            Initialize the appender based on the options set
861
            </summary>
862
            <remarks>
863
            <para>
864
            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
865
            activation scheme. The <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> method must 
866
            be called on this object after the configuration properties have
867
            been set. Until <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> is called this
868
            object is in an undefined state and must not be used. 
869
            </para>
870
            <para>
871
            If any of the configuration properties are modified then 
872
            <see cref="M:log4net.Appender.BufferingAppenderSkeleton.ActivateOptions"/> must be called again.
873
            </para>
874
            </remarks>
875
        </member>
876
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.OnClose">
877
            <summary>
878
            Close this appender instance.
879
            </summary>
880
            <remarks>
881
            <para>
882
            Close this appender instance. If this appender is marked
883
            as not <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> then the remaining events in 
884
            the buffer must be sent when the appender is closed.
885
            </para>
886
            </remarks>
887
        </member>
888
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.Append(log4net.Core.LoggingEvent)">
889
            <summary>
890
            This method is called by the <see cref="M:log4net.Appender.AppenderSkeleton.DoAppend(log4net.Core.LoggingEvent)"/> method. 
891
            </summary>
892
            <param name="loggingEvent">the event to log</param>
893
            <remarks>
894
            <para>
895
            Stores the <paramref name="loggingEvent"/> in the cyclic buffer.
896
            </para>
897
            <para>
898
            The buffer will be sent (i.e. passed to the <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/> 
899
            method) if one of the following conditions is met:
900
            </para>
901
            <list type="bullet">
902
            	<item>
903
            		<description>The cyclic buffer is full and this appender is
904
            		marked as not lossy (see <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>)</description>
905
            	</item>
906
            	<item>
907
            		<description>An <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> is set and
908
            		it is triggered for the <paramref name="loggingEvent"/>
909
            		specified.</description>
910
            	</item>
911
            </list>
912
            <para>
913
            Before the event is stored in the buffer it is fixed
914
            (see <see cref="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)"/>) to ensure that
915
            any data referenced by the event will be valid when the buffer
916
            is processed.
917
            </para>
918
            </remarks>
919
        </member>
920
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendFromBuffer(log4net.Core.LoggingEvent,log4net.Util.CyclicBuffer)">
921
            <summary>
922
            Sends the contents of the buffer.
923
            </summary>
924
            <param name="firstLoggingEvent">The first logging event.</param>
925
            <param name="buffer">The buffer containing the events that need to be send.</param>
926
            <remarks>
927
            <para>
928
            The subclass must override <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>.
929
            </para>
930
            </remarks>
931
        </member>
932
        <member name="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])">
933
            <summary>
934
            Sends the events.
935
            </summary>
936
            <param name="events">The events that need to be send.</param>
937
            <remarks>
938
            <para>
939
            The subclass must override this method to process the buffered events.
940
            </para>
941
            </remarks>
942
        </member>
943
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_bufferSize">
944
            <summary>
945
            The size of the cyclic buffer used to hold the logging events.
946
            </summary>
947
            <remarks>
948
            Set to <see cref="F:log4net.Appender.BufferingAppenderSkeleton.DEFAULT_BUFFER_SIZE"/> by default.
949
            </remarks>
950
        </member>
951
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_cb">
952
            <summary>
953
            The cyclic buffer used to store the logging events.
954
            </summary>
955
        </member>
956
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_evaluator">
957
            <summary>
958
            The triggering event evaluator that causes the buffer to be sent immediately.
959
            </summary>
960
            <remarks>
961
            The object that is used to determine if an event causes the entire
962
            buffer to be sent immediately. This field can be <c>null</c>, which 
963
            indicates that event triggering is not to be done. The evaluator
964
            can be set using the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> property. If this appender
965
            has the <see cref="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy"/> (<see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> property) set to 
966
            <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be set.
967
            </remarks>
968
        </member>
969
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossy">
970
            <summary>
971
            Indicates if the appender should overwrite events in the cyclic buffer 
972
            when it becomes full, or if the buffer should be flushed when the 
973
            buffer is full.
974
            </summary>
975
            <remarks>
976
            If this field is set to <c>true</c> then an <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must 
977
            be set.
978
            </remarks>
979
        </member>
980
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_lossyEvaluator">
981
            <summary>
982
            The triggering event evaluator filters discarded events.
983
            </summary>
984
            <remarks>
985
            The object that is used to determine if an event that is discarded should
986
            really be discarded or if it should be sent to the appenders. 
987
            This field can be <c>null</c>, which indicates that all discarded events will
988
            be discarded. 
989
            </remarks>
990
        </member>
991
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_fixFlags">
992
            <summary>
993
            Value indicating which fields in the event should be fixed
994
            </summary>
995
            <remarks>
996
            By default all fields are fixed
997
            </remarks>
998
        </member>
999
        <member name="F:log4net.Appender.BufferingAppenderSkeleton.m_eventMustBeFixed">
1000
            <summary>
1001
            The events delivered to the subclass must be fixed.
1002
            </summary>
1003
        </member>
1004
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Lossy">
1005
            <summary>
1006
            Gets or sets a value that indicates whether the appender is lossy.
1007
            </summary>
1008
            <value>
1009
            <c>true</c> if the appender is lossy, otherwise <c>false</c>. The default is <c>false</c>.
1010
            </value>
1011
            <remarks>
1012
            <para>
1013
            This appender uses a buffer to store logging events before 
1014
            delivering them. A triggering event causes the whole buffer
1015
            to be send to the remote sink. If the buffer overruns before
1016
            a triggering event then logging events could be lost. Set
1017
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> to <c>false</c> to prevent logging events 
1018
            from being lost.
1019
            </para>
1020
            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
1021
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
1022
            </remarks>
1023
        </member>
1024
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize">
1025
            <summary>
1026
            Gets or sets the size of the cyclic buffer used to hold the 
1027
            logging events.
1028
            </summary>
1029
            <value>
1030
            The size of the cyclic buffer used to hold the logging events.
1031
            </value>
1032
            <remarks>
1033
            <para>
1034
            The <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> option takes a positive integer
1035
            representing the maximum number of logging events to collect in 
1036
            a cyclic buffer. When the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is reached,
1037
            oldest events are deleted as new events are added to the
1038
            buffer. By default the size of the cyclic buffer is 512 events.
1039
            </para>
1040
            <para>
1041
            If the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.BufferSize"/> is set to a value less than
1042
            or equal to 1 then no buffering will occur. The logging event
1043
            will be delivered synchronously (depending on the <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/>
1044
            and <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> properties). Otherwise the event will
1045
            be buffered.
1046
            </para>
1047
            </remarks>
1048
        </member>
1049
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator">
1050
            <summary>
1051
            Gets or sets the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the 
1052
            buffer to be sent immediately.
1053
            </summary>
1054
            <value>
1055
            The <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> that causes the buffer to be
1056
            sent immediately.
1057
            </value>
1058
            <remarks>
1059
            <para>
1060
            The evaluator will be called for each event that is appended to this 
1061
            appender. If the evaluator triggers then the current buffer will 
1062
            immediately be sent (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>).
1063
            </para>
1064
            <para>If <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Lossy"/> is set to <c>true</c> then an
1065
            <see cref="P:log4net.Appender.BufferingAppenderSkeleton.Evaluator"/> must be specified.</para>
1066
            </remarks>
1067
        </member>
1068
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.LossyEvaluator">
1069
            <summary>
1070
            Gets or sets the value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
1071
            </summary>
1072
            <value>
1073
            The value of the <see cref="T:log4net.Core.ITriggeringEventEvaluator"/> to use.
1074
            </value>
1075
            <remarks>
1076
            <para>
1077
            The evaluator will be called for each event that is discarded from this 
1078
            appender. If the evaluator triggers then the current buffer will immediately 
1079
            be sent (see <see cref="M:log4net.Appender.BufferingAppenderSkeleton.SendBuffer(log4net.Core.LoggingEvent[])"/>).
1080
            </para>
1081
            </remarks>
1082
        </member>
1083
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.OnlyFixPartialEventData">
1084
            <summary>
1085
            Gets or sets a value indicating if only part of the logging event data
1086
            should be fixed.
1087
            </summary>
1088
            <value>
1089
            <c>true</c> if the appender should only fix part of the logging event 
1090
            data, otherwise <c>false</c>. The default is <c>false</c>.
1091
            </value>
1092
            <remarks>
1093
            <para>
1094
            Setting this property to <c>true</c> will cause only part of the
1095
            event data to be fixed and serialized. This will improve performance.
1096
            </para>
1097
            <para>
1098
            See <see cref="M:log4net.Core.LoggingEvent.FixVolatileData(log4net.Core.FixFlags)"/> for more information.
1099
            </para>
1100
            </remarks>
1101
        </member>
1102
        <member name="P:log4net.Appender.BufferingAppenderSkeleton.Fix">
1103
            <summary>
1104
            Gets or sets a the fields that will be fixed in the event
1105
            </summary>
1106
            <value>
1107
            The event fields that will be fixed before the event is buffered
1108
            </value>
1109
            <remarks>
1110
            <para>
1111
            The logging event needs to have certain thread specific values 
1112
            captured before it can be buffered. See <see cref="P:log4net.Core.LoggingEvent.Fix"/>
1113
            for details.
1114
            </para>
1115
            </remarks>
1116
            <seealso cref="P:log4net.Core.LoggingEvent.Fix"/>
1117
        </member>
1118
        <member name="M:log4net.Appender.AdoNetAppender.#ctor">
1119
            <summary> 
1120
            Initializes a new instance of the <see cref="T:log4net.Appender.AdoNetAppender"/> class.
1121
            </summary>
1122
            <remarks>
1123
            Public default constructor to initialize a new instance of this class.
1124
            </remarks>
1125
        </member>
1126
        <member name="M:log4net.Appender.AdoNetAppender.ActivateOptions">
1127
            <summary>
1128
            Initialize the appender based on the options set
1129
            </summary>
1130
            <remarks>
1131
            <para>
1132
            This is part of the <see cref="T:log4net.Core.IOptionHandler"/> delayed object
1133
            activation scheme. The <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> method must 
1134
            be called on this object after the configuration properties have
1135
            been set. Until <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> is called this
1136
            object is in an undefined state and must not be used. 
1137
            </para>
1138
            <para>
1139
            If any of the configuration properties are modified then 
1140
            <see cref="M:log4net.Appender.AdoNetAppender.ActivateOptions"/> must be called again.
1141
            </para>
1142
            </remarks>
1143
        </member>
1144
        <member name="M:log4net.Appender.AdoNetAppender.OnClose">
1145
            <summary>
1146
            Override the parent method to close the database
1147
            </summary>
1148
            <remarks>
1149
            <para>
1150
            Closes the database command and database connection.
1151
            </para>
1152
            </remarks>
1153
        </member>
1154
        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(log4net.Core.LoggingEvent[])">
1155
            <summary>
1156
            Inserts the events into the database.
1157
            </summary>
1158
            <param name="events">The events to insert into the database.</param>
1159
            <remarks>
1160
            <para>
1161
            Insert all the events specified in the <paramref name="events"/>
1162
            array into the database.
1163
            </para>
1164
            </remarks>
1165
        </member>
1166
        <member name="M:log4net.Appender.AdoNetAppender.AddParameter(log4net.Appender.AdoNetAppenderParameter)">
1167
            <summary>
1168
            Adds a parameter to the command.
1169
            </summary>
1170
            <param name="parameter">The parameter to add to the command.</param>
1171
            <remarks>
1172
            <para>
1173
            Adds a parameter to the ordered list of command parameters.
1174
            </para>
1175
            </remarks>
1176
        </member>
1177
        <member name="M:log4net.Appender.AdoNetAppender.SendBuffer(System.Data.IDbTransaction,log4net.Core.LoggingEvent[])">
1178
            <summary>
1179
            Writes the events to the database using the transaction specified.
1180
            </summary>
1181
            <param name="dbTran">The transaction that the events will be executed under.</param>
1182
            <param name="events">The array of events to insert into the database.</param>
1183
            <remarks>
1184
            <para>
1185
            The transaction argument can be <c>null</c> if the appender has been
1186
            configured not to use transactions. See <see cref="P:log4net.Appender.AdoNetAppender.UseTransactions"/>
1187
            property for more information.
1188
            </para>
1189
            </remarks>
1190
        </member>
1191
        <member name="M:log4net.Appender.AdoNetAppender.GetLogStatement(log4net.Core.LoggingEvent)">
1192
            <summary>
1193
            Formats the log message into database statement text.
1194
            </summary>
1195
            <param name="logEvent">The event being logged.</param>
1196
            <remarks>
1197
            This method can be overridden by subclasses to provide 
1198
            more control over the format of the database statement.
1199
            </remarks>
1200
            <returns>
1201
            Text that can be passed to a <see cref="T:System.Data.IDbCommand"/>.
1202
            </returns>
1203
        </member>
1204
        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseConnection">
1205
            <summary>
1206
            Connects to the database.
1207
            </summary>		
1208
        </member>
1209
        <member name="M:log4net.Appender.AdoNetAppender.ResolveConnectionType">
1210
            <summary>
1211
            Retrieves the class type of the ADO.NET provider.
1212
            </summary>
1213
            <remarks>
1214
            <para>
1215
            Gets the Type of the ADO.NET provider to use to connect to the
1216
            database. This method resolves the type specified in the 
1217
            <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> property.
1218
            </para>
1219
            <para>
1220
            Subclasses can override this method to return a different type
1221
            if necessary.
1222
            </para>
1223
            </remarks>
1224
            <returns>The <see cref="T:System.Type"/> of the ADO.NET provider</returns>
1225
        </member>
1226
        <member name="M:log4net.Appender.AdoNetAppender.InitializeDatabaseCommand">
1227
            <summary>
1228
            Prepares the database command and initialize the parameters.
1229
            </summary>
1230
        </member>
1231
        <member name="F:log4net.Appender.AdoNetAppender.m_usePreparedCommand">
1232
            <summary>
1233
            Flag to indicate if we are using a command object
1234
            </summary>
1235
            <remarks>
1236
            <para>
1237
            Set to <c>true</c> when the appender is to use a prepared
1238
            statement or stored procedure to insert into the database.
1239
            </para>
1240
            </remarks>
1241
        </member>
1242
        <member name="F:log4net.Appender.AdoNetAppender.m_parameters">
1243
            <summary>
1244
            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
1245
            </summary>
1246
            <remarks>
1247
            <para>
1248
            The list of <see cref="T:log4net.Appender.AdoNetAppenderParameter"/> objects.
1249
            </para>
1250
            </remarks>
1251
        </member>
1252
        <member name="F:log4net.Appender.AdoNetAppender.m_securityContext">
1253
            <summary>
1254
            The security context to use for privileged calls
1255
            </summary>
1256
        </member>
1257
        <member name="F:log4net.Appender.AdoNetAppender.m_dbConnection">
1258
            <summary>
1259
            The <see cref="T:System.Data.IDbConnection"/> that will be used
1260
            to insert logging events into a database.
1261
            </summary>
1262
        </member>
1263
        <member name="F:log4net.Appender.AdoNetAppender.m_dbCommand">
1264
            <summary>
1265
            The database command.
1266
            </summary>
1267
        </member>
1268
        <member name="F:log4net.Appender.AdoNetAppender.m_connectionString">
1269
            <summary>
1270
            Database connection string.
1271
            </summary>
1272
        </member>
1273
        <member name="F:log4net.Appender.AdoNetAppender.m_connectionType">
1274
            <summary>
1275
            String type name of the <see cref="T:System.Data.IDbConnection"/> type name.
1276
            </summary>
1277
        </member>
1278
        <member name="F:log4net.Appender.AdoNetAppender.m_commandText">
1279
            <summary>
1280
            The text of the command.
1281
            </summary>
1282
        </member>
1283
        <member name="F:log4net.Appender.AdoNetAppender.m_commandType">
1284
            <summary>
1285
            The command type.
1286
            </summary>
1287
        </member>
1288
        <member name="F:log4net.Appender.AdoNetAppender.m_useTransactions">
1289
            <summary>
1290
            Indicates whether to use transactions when writing to the database.
1291
            </summary>
1292
        </member>
1293
        <member name="F:log4net.Appender.AdoNetAppender.m_reconnectOnError">
1294
            <summary>
1295
            Indicates whether to use transactions when writing to the database.
1296
            </summary>
1297
        </member>
1298
        <member name="P:log4net.Appender.AdoNetAppender.ConnectionString">
1299
            <summary>
1300
            Gets or sets the database connection string that is used to connect to 
1301
            the database.
1302
            </summary>
1303
            <value>
1304
            The database connection string used to connect to the database.
1305
            </value>
1306
            <remarks>
1307
            <para>
1308
            The connections string is specific to the connection type.
1309
            See <see cref="P:log4net.Appender.AdoNetAppender.ConnectionType"/> for more information.
1310
            </para>
1311
            </remarks>
1312
            <example>Connection string for MS Access via ODBC:
1313
            <code>"DSN=MS Access Database;UID=admin;PWD=;SystemDB=C:\data\System.mdw;SafeTransactions = 0;FIL=MS Access;DriverID = 25;DBQ=C:\data\train33.mdb"</code>
1314
            </example>
1315
            <example>Another connection string for MS Access via ODBC:
1316
            <code>"Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\Work\cvs_root\log4net-1.2\access.mdb;UID=;PWD=;"</code>
1317
            </example>
1318
            <example>Connection string for MS Access via OLE DB:
1319
            <code>"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Work\cvs_root\log4net-1.2\access.mdb;User Id=;Password=;"</code>
1320
            </example>
1321
        </member>
1322
        <member name="P:log4net.Appender.AdoNetAppender.ConnectionType">
1323
            <summary>
1324
            Gets or sets the type name of the <see cref="T:System.Data.IDbConnection"/> connection
1325
            that should be created.
1326
            </summary>
1327
            <value>
1328
            The type name of the <see cref="T:System.Data.IDbConnection"/> connection.
1329
            </value>
1330
            <remarks>
1331
            <para>
1332
            The type name of the ADO.NET provider to use.
1333
            </para>
1334
            <para>
1335
            The default is to use the OLE DB provider.
1336
            </para>
1337
            </remarks>
1338
            <example>Use the OLE DB Provider. This is the default value.
1339
            <code>System.Data.OleDb.OleDbConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
1340
            </example>
1341
            <example>Use the MS SQL Server Provider. 
1342
            <code>System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
1343
            </example>
1344
            <example>Use the ODBC Provider. 
1345
            <code>Microsoft.Data.Odbc.OdbcConnection,Microsoft.Data.Odbc,version=1.0.3300.0,publicKeyToken=b77a5c561934e089,culture=neutral</code>
1346
            This is an optional package that you can download from 
1347
            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
1348
            search for <b>ODBC .NET Data Provider</b>.
1349
            </example>
1350
            <example>Use the Oracle Provider. 
1351
            <code>System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</code>
1352
            This is an optional package that you can download from 
1353
            <a href="http://msdn.microsoft.com/downloads">http://msdn.microsoft.com/downloads</a> 
1354
            search for <b>.NET Managed Provider for Oracle</b>.
1355
            </example>
1356
        </member>
1357
        <member name="P:log4net.Appender.AdoNetAppender.CommandText">
1358
            <summary>
1359
            Gets or sets the command text that is used to insert logging events
1360
            into the database.
1361
            </summary>
1362
            <value>
1363
            The command text used to insert logging events into the database.
1364
            </value>
1365
            <remarks>
1366
            <para>
1367
            Either the text of the prepared statement or the
1368
            name of the stored procedure to execute to write into
1369
            the database.
1370
            </para>
1371
            <para>
1372
            The <see cref="P:log4net.Appender.AdoNetAppender.CommandType"/> property determines if
1373
            this text is a prepared statement or a stored procedure.
1374
            </para>
1375
            </remarks>
1376
        </member>
1377
        <member name="P:log4net.Appender.AdoNetAppender.CommandType">
1378
            <summary>
1379
            Gets or sets the command type to execute.
1380
            </summary>
1381
            <value>
1382
            The command type to execute.
1383
            </value>
1384
            <remarks>
1385
            <para>
1386
            This value may be either <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>) to specify
1387
            that the <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> is a prepared statement to execute, 
1388
            or <see cref="F:System.Data.CommandType.StoredProcedure"/> (<c>System.Data.CommandType.StoredProcedure</c>) to specify that the
1389
            <see cref="P:log4net.Appender.AdoNetAppender.CommandText"/> property is the name of a stored procedure
1390
            to execute.
1391
            </para>
1392
            <para>
1393
            The default value is <see cref="F:System.Data.CommandType.Text"/> (<c>System.Data.CommandType.Text</c>).
1394
            </para>
1395
            </remarks>
1396
        </member>
1397
        <member name="P:log4net.Appender.AdoNetAppender.UseTransactions">
1398
            <summary>
1399
            Should transactions be used to insert logging events in the database.
1400
            </summary>
1401
            <value>
1402
            <c>true</c> if transactions should be used to insert logging events in
1403
            the database, otherwise <c>false</c>. The default value is <c>true</c>.
1404
            </value>
1405
            <remarks>
1406
            <para>
1407
            Gets or sets a value that indicates whether transactions should be used
1408
            to insert logging events in the database.
1409
            </para>
1410
            <para>
1411
            When set a single transaction will be used to insert the buffered events
1412
            into the database. Otherwise each event will be inserted without using
1413
            an explicit transaction.
1414
            </para>
1415
            </remarks>
1416
        </member>
1417
        <member name="P:log4net.Appender.AdoNetAppender.SecurityContext">
1418
            <summary>
1419
            Gets or sets the <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
1420
            </summary>
1421
            <value>
1422
            The <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> used to call the NetSend method.
1423
            </value>
1424
            <remarks>
1425
            <para>
1426
            Unless a <see cref="P:log4net.Appender.AdoNetAppender.SecurityContext"/> specified here for this appender
1427
            the <see cref="P:log4net.Core.SecurityContextProvider.DefaultProvider"/> is queried for the
1428
            security context to use. The default behavior is to use the security context
1429
            of the current thread.
1430
            </para>
1431
            </remarks>
1432
        </member>
1433
        <member name="P:log4net.Appender.AdoNetAppender.ReconnectOnError">
1434
            <summary>
1435
            Should this appender try to reconnect to the database on error.
1436
            </summary>
1437
            <value>
1438
            <c>true</c> if the appender should try to reconnect to the database after an
1439
            error has occurred, otherwise <c>false</c>. The default value is <c>false</c>, 
1440
            i.e. not to try to reconnect.
1441
            </value>
1442
            <remarks>
1443
            <para>
1444
            The default behaviour is for the appender not to try to reconnect to the
1445
            database if an error occurs. Subsequent logging events are discarded.
1446
            </para>
1447
            <para>
1448
            To force the appender to attempt to reconnect to the database set this
1449
            property to <c>true</c>.
1450
            </para>
1451
            <note>
1452
            When the appender attempts to connect to the database there may be a
1453
            delay of up to the connection timeout specified in the connection string.
1454
            This delay will block the calling application's thread. 
1455
            Until the connection can be reestablished this potential delay may occur multiple times.
1456
            </note>
1457
            </remarks>
1458
        </member>
1459
        <member name="P:log4net.Appender.AdoNetAppender.Connection">
1460
            <summary>
1461
            Gets or sets the underlying <see cref="T:System.Data.IDbConnection"/>.
1462
            </summary>
1463
            <value>
1464
            The underlying <see cref="T:System.Data.IDbConnection"/>.
1465
            </value>
1466
            <remarks>
1467
            <see cref="T:log4net.Appender.AdoNetAppender"/> creates a <see cref="T:System.Data.IDbConnection"/> to insert 
1468
            logging events into a database.  Classes deriving from <see cref="T:log4net.Appender.AdoNetAppender"/> 
1469
            can use this property to get or set this <see cref="T:System.Data.IDbConnection"/>.  Use the 
1470
            underlying <see cref="T:System.Data.IDbConnection"/> returned from <see cref="P:log4net.Appender.AdoNetAppender.Connection"/> if 
1471
            you require access beyond that which <see cref="T:log4net.Appender.AdoNetAppender"/> provides.
1472
            </remarks>
1473
        </member>
1474
        <member name="T:log4net.Appender.AdoNetAppenderParameter">
1475
            <summary>
1476
            Parameter type used by the <see cref="T:log4net.Appender.AdoNetAppender"/>.
1477
            </summary>
1478
            <remarks>
1479
            <para>
1480
            This class provides the basic database parameter properties
1481
            as defined by the <see cref="T:System.Data.IDbDataParameter"/> interface.
... 差分の行数が表示可能な上限を超えました。超過分は表示しません。

他の形式にエクスポート: Unified diff