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
|
//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel
{
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Runtime;
using System.ServiceModel.Channels;
using System.Threading;
public class MessageHeader<T>
{
string actor;
bool mustUnderstand;
bool relay;
T content;
public MessageHeader()
{
}
public MessageHeader(T content)
: this(content, false, "", false)
{
}
public MessageHeader(T content, bool mustUnderstand, string actor, bool relay)
{
this.content = content;
this.mustUnderstand = mustUnderstand;
this.actor = actor;
this.relay = relay;
}
public string Actor
{
get { return this.actor; }
set { this.actor = value; }
}
public T Content
{
get { return this.content; }
set { this.content = value; }
}
public bool MustUnderstand
{
get { return this.mustUnderstand; }
set { this.mustUnderstand = value; }
}
public bool Relay
{
get { return this.relay; }
set { this.relay = value; }
}
internal Type GetGenericArgument()
{
return typeof(T);
}
public MessageHeader GetUntypedHeader(string name, string ns)
{
return MessageHeader.CreateHeader(name, ns, this.content, this.mustUnderstand, this.actor, this.relay);
}
}
// problem: creating / getting content / settings content on a MessageHeader<T> given the type at runtime
// require reflection.
// solution: This class creates a cache of adapters that provide an untyped wrapper over a particular
// MessageHeader<T> instantiation.
// better solution: implement something like "IUntypedTypedHeader" that has a "object Content" property,
// privately implement this on TypedHeader, and then just use that iface to operation on the header (actually
// you'd still have the creation problem...). the issue with that is you now have a new public interface
internal abstract class TypedHeaderManager
{
static Dictionary<Type, TypedHeaderManager> cache = new Dictionary<Type, TypedHeaderManager>();
static ReaderWriterLock cacheLock = new ReaderWriterLock();
static Type GenericAdapterType = typeof(GenericAdapter<>);
internal static object Create(Type t, object content, bool mustUnderstand, bool relay, string actor)
{
return GetTypedHeaderManager(t).Create(content, mustUnderstand, relay, actor);
}
internal static object GetContent(Type t, object typedHeaderInstance, out bool mustUnderstand, out bool relay, out string actor)
{
return GetTypedHeaderManager(t).GetContent(typedHeaderInstance, out mustUnderstand, out relay, out actor);
}
internal static Type GetMessageHeaderType(Type contentType)
{
return GetTypedHeaderManager(contentType).GetMessageHeaderType();
}
internal static Type GetHeaderType(Type headerParameterType)
{
if (headerParameterType.IsGenericType && headerParameterType.GetGenericTypeDefinition() == typeof(MessageHeader<>))
return headerParameterType.GetGenericArguments()[0];
return headerParameterType;
}
[SuppressMessage(FxCop.Category.Usage, "CA2301:EmbeddableTypesInContainersRule", MessageId = "cache", Justification = "No need to support type equivalence here.")]
static TypedHeaderManager GetTypedHeaderManager(Type t)
{
TypedHeaderManager result = null;
bool lockHeld = false;
try
{
try { }
finally
{
cacheLock.AcquireReaderLock(int.MaxValue);
lockHeld = true;
}
if (!cache.TryGetValue(t, out result))
{
cacheLock.UpgradeToWriterLock(int.MaxValue);
if (!cache.TryGetValue(t, out result))
{
result = (TypedHeaderManager)Activator.CreateInstance(GenericAdapterType.MakeGenericType(t));
cache.Add(t, result);
}
}
}
finally
{
if (lockHeld)
{
cacheLock.ReleaseLock();
}
}
return result;
}
protected abstract object Create(object content, bool mustUnderstand, bool relay, string actor);
protected abstract object GetContent(object typedHeaderInstance, out bool mustUnderstand, out bool relay, out string actor);
protected abstract Type GetMessageHeaderType();
class GenericAdapter<T> : TypedHeaderManager
{
protected override object Create(object content, bool mustUnderstand, bool relay, string actor)
{
MessageHeader<T> header = new MessageHeader<T>();
header.Content = (T)content;
header.MustUnderstand = mustUnderstand;
header.Relay = relay;
header.Actor = actor;
return header;
}
protected override object GetContent(object typedHeaderInstance, out bool mustUnderstand, out bool relay, out string actor)
{
mustUnderstand = false;
relay = false;
actor = null;
if (typedHeaderInstance == null)
return null;
MessageHeader<T> header = typedHeaderInstance as MessageHeader<T>;
if (header == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException("typedHeaderInstance"));
mustUnderstand = header.MustUnderstand;
relay = header.Relay;
actor = header.Actor;
return header.Content;
}
protected override Type GetMessageHeaderType()
{
return typeof(MessageHeader<T>);
}
}
}
}
|
