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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
//
// System.ComponentModel.LicenseManager.cs
//
// Authors:
// Ivan Hamilton (ivan@chimerical.com.au)
// Martin Willemoes Hansen (mwh@sysrq.dk)
// Andreas Nahr (ClassDevelopment@A-SoftTech.com)
//
// (C) 2004 Ivan Hamilton
// (C) 2003 Martin Willemoes Hansen
// (C) 2003 Andreas Nahr
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
namespace System.ComponentModel
{
public sealed class LicenseManager
{
static LicenseContext mycontext;
static object contextLockUser;
static object lockObject = new object ();
private LicenseManager ()
{
}
public static LicenseContext CurrentContext {
get {
lock (lockObject) {
//Tests indicate a System.ComponentModel.Design.RuntimeLicenseContext should be returned.
if (mycontext==null)
mycontext = new Design.RuntimeLicenseContext();
return mycontext;
}
}
set {
lock (lockObject) {
if (contextLockUser==null) {
mycontext = value;
} else {
throw new InvalidOperationException("The CurrentContext property of the LicenseManager is currently locked and cannot be changed.");
}
}
}
}
public static LicenseUsageMode UsageMode {
get {
return CurrentContext.UsageMode;
}
}
public static object CreateWithContext (Type type,
LicenseContext creationContext)
{
return CreateWithContext (type, creationContext, new object [0]);
}
public static object CreateWithContext (Type type,
LicenseContext creationContext,
object[] args)
{
object newObject = null;
lock (lockObject) {
object contextUser = new object ();
LicenseContext oldContext = CurrentContext;
CurrentContext = creationContext;
LockContext (contextUser);
try {
newObject = Activator.CreateInstance (type, args);
} catch (Reflection.TargetInvocationException exception) {
throw exception.InnerException;
} finally {
UnlockContext (contextUser);
CurrentContext = oldContext;
}
}
return newObject;
}
public static bool IsLicensed (Type type)
{
License license = null;
if (!privateGetLicense (type, null, false, out license)) {
return false;
} else {
if (license != null)
license.Dispose ();
return true;
}
}
public static bool IsValid (Type type)
//This method does not throw a LicenseException when it cannot grant a valid License
{
License license=null;
if (!privateGetLicense (type, null, false, out license)) {
return false;
} else {
if (license != null)
license.Dispose ();
return true;
}
}
public static bool IsValid (Type type, object instance,
out License license)
//This method does not throw a LicenseException when it cannot grant a valid License
{
return privateGetLicense (type, null, false, out license);
}
public static void LockContext (object contextUser)
{
lock (lockObject) {
contextLockUser = contextUser;
}
}
public static void UnlockContext (object contextUser)
{
lock (lockObject) {
//Ignore if we're not locked
if (contextLockUser == null)
return;
//Don't unlock if not locking user
if (contextLockUser != contextUser)
throw new ArgumentException ("The CurrentContext property of the LicenseManager can only be unlocked with the same contextUser.");
//Remove lock
contextLockUser = null;
}
}
public static void Validate (Type type)
// Throws a LicenseException if the type is licensed, but a License could not be granted.
{
License license = null;
if (!privateGetLicense (type, null, true, out license))
throw new LicenseException (type, null);
if (license != null)
license.Dispose ();
}
public static License Validate (Type type, object instance)
// Throws a LicenseException if the type is licensed, but a License could not be granted.
{
License license=null;
if (!privateGetLicense(type, instance, true, out license))
throw new LicenseException(type, instance);
return license;
}
private static bool privateGetLicense (Type type, object instance, bool allowExceptions, out License license)
//Returns if a component is licensed, and the license if provided
{
bool isLicensed = false;
License foundLicense = null;
//Get the LicProc Attrib for our type
LicenseProviderAttribute licenseproviderattribute = (LicenseProviderAttribute) Attribute.GetCustomAttribute(type, typeof (LicenseProviderAttribute), true);
//Check it's got an attrib
if (licenseproviderattribute != null) {
Type licenseprovidertype = licenseproviderattribute.LicenseProvider;
//Check the attrib has a type
if (licenseprovidertype != null) {
//Create the provider
LicenseProvider licenseprovider = (LicenseProvider) Activator.CreateInstance(licenseprovidertype);
//Check we've got the provider
if (licenseprovider != null) {
//Call provider, throw an LicenseException if error.
foundLicense = licenseprovider.GetLicense(CurrentContext, type, instance, allowExceptions);
if (foundLicense != null)
isLicensed = true;
//licenseprovider.Dispose();
} else {
//There is was some problem creating the provider
}
//licenseprovidertype.Dispose();
} else {
//licenseprovidertype is null
}
//licenseproviderattribute.Dispose ();
} else {
//Didn't have a LicenseProviderAttribute, so it's licensed
isLicensed = true;
}
license = foundLicense;
return isLicensed;
}
}
}
|
