Subversion Repositories SoapBoxCore

Rev

Rev 8 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
8 scott 1
#region "SoapBox.Core License"
2
/// <header module="SoapBox.Core"> 
3
/// Copyright (C) 2009 SoapBox Automation Inc., All Rights Reserved.
4
/// Contact: SoapBox Automation Licencing (license@soapboxautomation.com)
5
/// 
6
/// This file is part of SoapBox Core.
7
/// 
8
/// Commercial Usage
9
/// Licensees holding valid SoapBox Automation Commercial licenses may use  
10
/// this file in accordance with the SoapBox Automation Commercial License
11
/// Agreement provided with the Software or, alternatively, in accordance 
12
/// with the terms contained in a written agreement between you and
13
/// SoapBox Automation Inc.
14
/// 
15
/// GNU Lesser General Public License Usage
16
/// SoapBox Core is free software: you can redistribute it and/or modify 
17
/// it under the terms of the GNU Lesser General Public License
18
/// as published by the Free Software Foundation, either version 3 of the
19
/// License, or (at your option) any later version.
20
/// 
21
/// SoapBox Core is distributed in the hope that it will be useful, 
22
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
23
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24
/// GNU Lesser General Public License for more details.
25
/// 
26
/// You should have received a copy of the GNU Lesser General Public License 
27
/// along with SoapBox Core. If not, see <http://www.gnu.org/licenses/>.
28
/// </header>
29
#endregion
30
 
31
using System;
32
using System.Collections.Generic;
33
using System.Linq;
34
using System.Text;
35
using System.ComponentModel.Composition;
36
using NLog;
37
 
38
namespace SoapBox.Core
39
{
12 scott 40
    [Export(Services.Logging.LoggingService, typeof(ILoggingService))]
8 scott 41
    class NLogLoggingService : ILoggingService
42
    {
43
        Logger log;
44
 
45
        public NLogLoggingService()
46
                {
47
            log = LogManager.GetCurrentClassLogger();
48
                }
49
 
50
                public void Debug(object message)
51
                {
52
                        log.Debug(message);
53
                }
54
 
55
        public void DebugWithFormat(string format, params object[] args)
56
                {
57
            if (args.Length == 0)
58
            {
59
                log.Debug(format);
60
            }
61
            else
62
            {
63
                Debug(string.Format(format, args));
64
            }
65
                }
66
 
67
                public void Info(object message)
68
                {
69
                        log.Info(message);
70
                }
71
 
72
        public void InfoWithFormat(string format, params object[] args)
73
                {
74
            if (args.Length == 0)
75
            {
76
                log.Info(format);
77
            }
78
            else
79
            {
80
                Info(string.Format(format, args));
81
            }
82
                }
83
 
84
                public void Warn(object message)
85
                {
86
                        log.Warn(message);
87
                }
88
 
89
                public void Warn(object message, Exception exception)
90
                {
91
            log.WarnException(message.ToString(), exception);
92
                }
93
 
94
        public void WarnWithFormat(string format, params object[] args)
95
                {
96
            if (args.Length == 0)
97
            {
98
                log.Warn(format);
99
            }
100
            else
101
            {
102
                log.Warn(string.Format(format, args));
103
            }
104
                }
105
 
106
                public void Error(object message)
107
                {
108
                        log.Error(message);
109
                }
110
 
111
                public void Error(object message, Exception exception)
112
                {
113
                        log.ErrorException(message.ToString(), exception);
114
                }
115
 
116
        public void ErrorWithFormat(string format, params object[] args)
117
                {
118
            if (args.Length == 0)
119
            {
120
                log.Error(format);
121
            }
122
            else
123
            {
124
                log.Error(string.Format(format, args));
125
            }
126
                }
127
 
128
                public void Fatal(object message)
129
                {
130
                        log.Fatal(message);
131
                }
132
 
133
                public void Fatal(object message, Exception exception)
134
                {
135
                        log.FatalException(message.ToString(), exception);
136
                }
137
 
138
        public void FatalWithFormat(string format, params object[] args)
139
                {
140
            if (args.Length == 0)
141
            {
142
                log.Fatal(format);
143
            }
144
            else
145
            {
146
                log.Fatal(string.Format(format, args));
147
            }
148
                }
149
 
150
                public bool IsDebugEnabled {
151
                        get {
152
                                return log.IsDebugEnabled;
153
                        }
154
                }
155
 
156
                public bool IsInfoEnabled {
157
                        get {
158
                                return log.IsInfoEnabled;
159
                        }
160
                }
161
 
162
                public bool IsWarnEnabled {
163
                        get {
164
                                return log.IsWarnEnabled;
165
                        }
166
                }
167
 
168
                public bool IsErrorEnabled {
169
                        get {
170
                                return log.IsErrorEnabled;
171
                        }
172
                }
173
 
174
                public bool IsFatalEnabled {
175
                        get {
176
                                return log.IsFatalEnabled;
177
                        }
178
                }
179
    }
180
}