static VirtualIcon()
{
ExtractIconQueue = new LazyInit<WorkQueue>(delegate {
ThreadQueue queue = new ThreadQueue(ApartmentState.STA, true);
queue.Error += delegate (object sender, ExceptionEventArgs e) {
Nomad.Trace.Error.TraceException(TraceEventType.Critical, e.ErrorException);
};
return queue;
});
}
void AssertLazyInit(ref LazyInit<int> value)
{
Assert.IsFalse(value.IsInitialized, "#1");
Assert.AreEqual(1, value.Value, "#2");
//Assert.IsTrue(value.IsInitialized, "#3");
Assert.AreEqual(value, value, "#4");
Assert.AreEqual(1.ToString(), value.ToString(), "#5");
Assert.AreEqual(1.GetHashCode(), value.GetHashCode(), "#6");
Assert.AreEqual(1, nTime, "#7");
}
static SlowPropertyProvider()
{
SlowPropertyQueue = new LazyInit<WorkQueue>(delegate {
ThreadPoolQueue queue = new ThreadPoolQueue();
queue.Error += delegate (object sender, ExceptionEventArgs e) {
Nomad.Trace.Error.TraceException(TraceEventType.Critical, e.ErrorException);
};
return queue;
});
}
/// <summary>
/// Creates a type parameter reference.
/// For common type parameter references, this method may return a shared instance.
/// </summary>
public static TypeParameterReference Create(SymbolKind ownerType, int index)
{
if (index >= 0 && index < 8 && (ownerType == SymbolKind.TypeDefinition || ownerType == SymbolKind.Method))
{
TypeParameterReference[] arr = (ownerType == SymbolKind.TypeDefinition) ? classTypeParameterReferences : methodTypeParameterReferences;
TypeParameterReference result = LazyInit.VolatileRead(ref arr[index]);
if (result == null)
{
result = LazyInit.GetOrSet(ref arr[index], new TypeParameterReference(ownerType, index));
}
return(result);
}
else
{
return(new TypeParameterReference(ownerType, index));
}
}
internal IMethod WrapAccessor(ref IMethod cachingField, IMethod accessorDefinition)
{
if (accessorDefinition == null)
{
return(null);
}
var result = LazyInit.VolatileRead(ref cachingField);
if (result != null)
{
return(result);
}
else
{
return(LazyInit.GetOrSet(ref cachingField, new SpecializedMethod(accessorDefinition, substitution)));
}
}
internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor)
{
if (unresolvedAccessor == null)
{
return(null);
}
IMethod result = LazyInit.VolatileRead(ref accessorField);
if (result != null)
{
return(result);
}
else
{
return(LazyInit.GetOrSet(ref accessorField, CreateResolvedAccessor(unresolvedAccessor)));
}
}
private void DecodeSignature()
{
var methodDef = module.metadata.GetMethodDefinition(handle);
var genericContext = new GenericContext(DeclaringType.TypeParameters, this.TypeParameters);
IType returnType;
IParameter[] parameters;
try {
var signature = methodDef.DecodeSignature(module.TypeProvider, genericContext);
(returnType, parameters) = DecodeSignature(module, this, signature, methodDef.GetParameters());
} catch (BadImageFormatException) {
returnType = SpecialType.UnknownType;
parameters = Empty <IParameter> .Array;
}
LazyInit.GetOrSet(ref this.returnType, returnType);
LazyInit.GetOrSet(ref this.parameters, parameters);
}
internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor)
{
if (unresolvedAccessor == null)
{
return(null);
}
IMethod result = accessorField;
if (result != null)
{
LazyInit.ReadBarrier();
return(result);
}
else
{
return(LazyInit.GetOrSet(ref accessorField, (IMethod)unresolvedAccessor.CreateResolved(context)));
}
}
Dictionary <FullNameAndTypeParameterCount, DefaultResolvedTypeDefinition> GetTypes()
{
var dict = this.typeDict;
if (dict != null)
{
LazyInit.ReadBarrier();
return(dict);
}
else
{
var comparer = FullNameAndTypeParameterCountComparer.Ordinal;
dict = projectContent.TopLevelTypeDefinitions
.GroupBy(t => new FullNameAndTypeParameterCount(t.Namespace, t.Name, t.TypeParameters.Count), comparer)
.ToDictionary(g => g.Key, g => new DefaultResolvedTypeDefinition(context, g.ToArray()), comparer);
return(LazyInit.GetOrSet(ref this.typeDict, dict));
}
}
Dictionary <string, INamespace> GetChildNamespaces()
{
var result = LazyInit.VolatileRead(ref this.childNamespaces);
if (result != null)
{
return(result);
}
else
{
result = new Dictionary <string, INamespace>(compilation.NameComparer);
foreach (var g in namespaces.SelectMany(ns => ns.ChildNamespaces).GroupBy(ns => ns.Name, compilation.NameComparer))
{
result.Add(g.Key, new MergedNamespace(this, g.ToArray()));
}
return(LazyInit.GetOrSet(ref this.childNamespaces, result));
}
}
internal IMethod WrapAccessor(ref IMethod cachingField, IMethod accessorDefinition)
{
if (accessorDefinition == null)
{
return(null);
}
var result = LazyInit.VolatileRead(ref cachingField);
if (result != null)
{
return(result);
}
else
{
var sm = accessorDefinition.Specialize(substitution);
//sm.AccessorOwner = this;
return(LazyInit.GetOrSet(ref cachingField, sm));
}
}
private IType DecodeTypeAndVolatileFlag()
{
var metadata = module.metadata;
var fieldDef = metadata.GetFieldDefinition(handle);
IType ty;
try {
ty = fieldDef.DecodeSignature(module.TypeProvider, new GenericContext(DeclaringType?.TypeParameters));
if (ty is ModifiedType mod && mod.Modifier.Name == "IsVolatile" && mod.Modifier.Namespace == "System.Runtime.CompilerServices")
{
Volatile.Write(ref this.isVolatile, true);
ty = mod.ElementType;
}
ty = ApplyAttributeTypeVisitor.ApplyAttributesToType(ty, Compilation,
fieldDef.GetCustomAttributes(), metadata, module.TypeSystemOptions);
} catch (BadImageFormatException) {
ty = SpecialType.UnknownType;
}
return(LazyInit.GetOrSet(ref this.type, ty));
}
Dictionary <FullNameAndTypeParameterCount, ITypeDefinition> GetTypes()
{
var dict = LazyInit.VolatileRead(ref this.typeDict);
if (dict != null)
{
return(dict);
}
else
{
// Always use the ordinal comparer for the main dictionary so that partial classes
// get merged correctly.
// The compilation's comparer will be used for the per-namespace dictionaries.
var comparer = FullNameAndTypeParameterCountComparer.Ordinal;
dict = projectContent.TopLevelTypeDefinitions
.GroupBy(t => new FullNameAndTypeParameterCount(t.Namespace, t.Name, t.TypeParameters.Count), comparer)
.ToDictionary(g => g.Key, g => CreateResolvedTypeDefinition(g.ToArray()), comparer);
return(LazyInit.GetOrSet(ref this.typeDict, dict));
}
}
public object GetConstantValue(bool throwOnInvalidMetadata)
{
object val = LazyInit.VolatileRead(ref this.constantValue);
if (val != null)
{
return(val);
}
try
{
var metadata = module.metadata;
var fieldDef = metadata.GetFieldDefinition(handle);
if (IsDecimalConstant && DecimalConstantHelper.AllowsDecimalConstants(module))
{
val = DecimalConstantHelper.GetDecimalConstantValue(module, fieldDef.GetCustomAttributes());
}
else
{
var constantHandle = fieldDef.GetDefaultValue();
if (constantHandle.IsNil)
{
return(null);
}
var constant = metadata.GetConstant(constantHandle);
var blobReader = metadata.GetBlobReader(constant.Value);
try
{
val = blobReader.ReadConstant(constant.TypeCode);
}
catch (ArgumentOutOfRangeException)
{
throw new BadImageFormatException($"Constant with invalid typecode: {constant.TypeCode}");
}
}
return(LazyInit.GetOrSet(ref this.constantValue, val));
}
catch (BadImageFormatException) when(!throwOnInvalidMetadata)
{
return(null);
}
}
internal IUnresolvedTypeDefinition GetTypeDefByToken(Mono.Cecil.MetadataToken token)
{
if (token.TokenType != Mono.Cecil.TokenType.TypeDef)
{
throw new ArgumentException("Token must be typedef-token.");
}
var lookup = LazyInit.VolatileRead(ref allTypesByMetadata);
if (lookup == null)
{
lookup = LazyInit.GetOrSet(ref allTypesByMetadata, BuildMetadataLookup());
}
if (token.RID < lookup.Length)
{
return(lookup[token.RID]);
}
else
{
return(null);
}
}
private void DecodeSignature()
{
var propertyDef = module.metadata.GetPropertyDefinition(propertyHandle);
var genericContext = new GenericContext(DeclaringType.TypeParameters);
IType returnType;
IParameter[] parameters;
try {
var signature = propertyDef.DecodeSignature(module.TypeProvider, genericContext);
var accessors = propertyDef.GetAccessors();
ParameterHandleCollection?parameterHandles;
Nullability nullableContext;
if (!accessors.Getter.IsNil)
{
var getter = module.metadata.GetMethodDefinition(accessors.Getter);
parameterHandles = getter.GetParameters();
nullableContext = getter.GetCustomAttributes().GetNullableContext(module.metadata)
?? DeclaringTypeDefinition?.NullableContext ?? Nullability.Oblivious;
}
else if (!accessors.Setter.IsNil)
{
var setter = module.metadata.GetMethodDefinition(accessors.Setter);
parameterHandles = setter.GetParameters();
nullableContext = setter.GetCustomAttributes().GetNullableContext(module.metadata)
?? DeclaringTypeDefinition?.NullableContext ?? Nullability.Oblivious;
}
else
{
parameterHandles = null;
nullableContext = DeclaringTypeDefinition?.NullableContext ?? Nullability.Oblivious;
}
(returnType, parameters) = MetadataMethod.DecodeSignature(module, this, signature, parameterHandles, nullableContext);
} catch (BadImageFormatException) {
returnType = SpecialType.UnknownType;
parameters = Empty <IParameter> .Array;
}
LazyInit.GetOrSet(ref this.returnType, returnType);
LazyInit.GetOrSet(ref this.parameters, parameters);
}
MemberList GetMemberList()
{
var result = LazyInit.VolatileRead(ref this.memberList);
if (result != null)
{
return(result);
}
List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>();
List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>();
bool addDefaultConstructorIfRequired = false;
foreach (IUnresolvedTypeDefinition part in parts)
{
ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext);
ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this);
foreach (var member in part.Members)
{
IUnresolvedMethod method = member as IUnresolvedMethod;
unresolvedMembers.Add(member);
contextPerMember.Add(contextForPart);
}
addDefaultConstructorIfRequired |= part.AddDefaultConstructorIfRequired;
}
if (addDefaultConstructorIfRequired)
{
TypeKind kind = this.Kind;
if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.SymbolKind == SymbolKind.Constructor && !m.IsStatic) ||
kind == TypeKind.Enum || kind == TypeKind.Struct)
{
contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this));
unresolvedMembers.Add(MethodCore.CreateDefaultConstructor(parts[0]));
}
}
result = new MemberList(contextPerMember, unresolvedMembers);
return(LazyInit.GetOrSet(ref this.memberList, result));
}
public static void PartFourStart()
{
int amount = 50;
string splitter = "=";
Program.center(amount, "Start of The Four Part", "*");
//////////////////////////////////////////////
Program.center(amount, "IEnumerable and IEnumerator", splitter);
IEnumerableStudy.StartExample();
//////////////////////////////////////////////
Program.center(amount, "Yield keyword", splitter);
YieldKeyword.StartExample();
//////////////////////////////////////////////
Program.center(amount, "Lazy loading", splitter);
LazyInit.StartExample(); // You can place breakpoint to see difference in memory concumed
//////////////////////////////////////////////
Program.center(amount, "Spans", splitter);
SpanStudy.StartExample();
//////////////////////////////////////////////
Program.center(amount, "Threads", splitter);
ThreadsStudy.StartExample();
}
private void DecodeSignature()
{
var methodDef = module.metadata.GetMethodDefinition(handle);
var genericContext = new GenericContext(DeclaringType.TypeParameters, this.TypeParameters);
IType returnType;
IParameter[] parameters;
ModifiedType mod;
try {
var nullableContext = methodDef.GetCustomAttributes().GetNullableContext(module.metadata) ?? DeclaringTypeDefinition.NullableContext;
var signature = methodDef.DecodeSignature(module.TypeProvider, genericContext);
(returnType, parameters, mod) = DecodeSignature(module, this, signature, methodDef.GetParameters(), nullableContext, module.OptionsForEntity(this));
} catch (BadImageFormatException) {
returnType = SpecialType.UnknownType;
parameters = Empty <IParameter> .Array;
mod = null;
}
this.isInitOnly = mod is { Modifier : { Name : "IsExternalInit", Namespace : "System.Runtime.CompilerServices" } };
LazyInit.GetOrSet(ref this.returnType, returnType);
LazyInit.GetOrSet(ref this.parameters, parameters);
}
IList <IAttribute> GetAttributes(ref IList <IAttribute> field, bool assemblyAttributes)
{
IList <IAttribute> result = LazyInit.VolatileRead(ref field);
if (result != null)
{
return(result);
}
else
{
result = new List <IAttribute>();
foreach (var unresolvedFile in projectContent.Files.OfType <CSharpUnresolvedFile>())
{
var attributes = assemblyAttributes ? unresolvedFile.AssemblyAttributes : unresolvedFile.ModuleAttributes;
var context = new CSharpTypeResolveContext(this, unresolvedFile.RootUsingScope.Resolve(compilation));
foreach (var unresolvedAttr in attributes)
{
result.Add(unresolvedAttr.CreateResolvedAttribute(context));
}
}
return(LazyInit.GetOrSet(ref field, result));
}
}
private void DecodeSignature()
{
var propertyDef = module.metadata.GetPropertyDefinition(propertyHandle);
var genericContext = new GenericContext(DeclaringType.TypeParameters);
var signature = propertyDef.DecodeSignature(module.TypeProvider, genericContext);
var accessors = propertyDef.GetAccessors();
ParameterHandleCollection?parameterHandles;
if (!accessors.Getter.IsNil)
{
parameterHandles = module.metadata.GetMethodDefinition(accessors.Getter).GetParameters();
}
else if (!accessors.Setter.IsNil)
{
parameterHandles = module.metadata.GetMethodDefinition(accessors.Setter).GetParameters();
}
else
{
parameterHandles = null;
}
var(returnType, parameters) = MetadataMethod.DecodeSignature(module, this, signature, parameterHandles);
LazyInit.GetOrSet(ref this.returnType, returnType);
LazyInit.GetOrSet(ref this.parameters, parameters);
}
public void AllowMultipleExecutionTestCase()
{
val = new LazyInit <int>(InitializationFunc, LazyInitMode.AllowMultipleExecution);
AssertLazyInit(ref val);
}
public void ThreadLocalTestCase()
{
val = new LazyInit<int>(InitializationFunc, LazyInitMode.ThreadLocal);
AssertLazyInit(ref val);
}
public void EnsureSingleExecutionTestCase()
{
val = new LazyInit<int>(InitializationFunc, LazyInitMode.EnsureSingleExecution);
AssertLazyInit(ref val);
}
public void AllowMultipleExecutionTestCase()
{
val = new LazyInit<int>(InitializationFunc, LazyInitMode.AllowMultipleExecution);
AssertLazyInit(ref val);
}
public void ThreadLocalTestCase()
{
val = new LazyInit <int>(InitializationFunc, LazyInitMode.ThreadLocal);
AssertLazyInit(ref val);
}
MemberList GetMemberList()
{
var result = LazyInit.VolatileRead(ref this.memberList);
if (result != null)
{
return(result);
}
List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>();
List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>();
List <PartialMethodInfo> partialMethodInfos = null;
bool addDefaultConstructorIfRequired = false;
foreach (IUnresolvedTypeDefinition part in parts)
{
ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext);
ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this);
foreach (var member in part.Members)
{
IUnresolvedMethod method = member as IUnresolvedMethod;
if (method != null && method.IsPartial)
{
// Merge partial method declaration and implementation
if (partialMethodInfos == null)
{
partialMethodInfos = new List <PartialMethodInfo>();
}
PartialMethodInfo newInfo = new PartialMethodInfo(method, contextForPart);
PartialMethodInfo existingInfo = null;
foreach (var info in partialMethodInfos)
{
if (newInfo.IsSameSignature(info, Compilation.NameComparer))
{
existingInfo = info;
break;
}
}
if (existingInfo != null)
{
// Add the unresolved method to the PartialMethodInfo:
existingInfo.AddPart(method, contextForPart);
}
else
{
partialMethodInfos.Add(newInfo);
}
}
else
{
unresolvedMembers.Add(member);
contextPerMember.Add(contextForPart);
}
}
addDefaultConstructorIfRequired |= part.AddDefaultConstructorIfRequired;
}
if (addDefaultConstructorIfRequired)
{
TypeKind kind = this.Kind;
if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.SymbolKind == SymbolKind.Constructor && !m.IsStatic) ||
kind == TypeKind.Enum || kind == TypeKind.Struct)
{
contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this));
unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0]));
}
}
result = new MemberList(contextPerMember, unresolvedMembers, partialMethodInfos);
return(LazyInit.GetOrSet(ref this.memberList, result));
}
static void Main(string[] args)
{
#region FactoryMethod
IMap worldMap = new PrefabricatedMapFactory().Generate(TerrainType.Arid);
var whereAreWe = worldMap.WhichImplementationAreWeIn();
worldMap = new RandomizedMapFactory().Generate(TerrainType.Oasis);
whereAreWe = worldMap.WhichImplementationAreWeIn();
#endregion
#region Builder (optionals in parameters - not in method invocation, chained interfaces)
TheQuote quote = new JanushKorwinMikkeQuoteBuilder()
.WithBehaviour(new WoeToTheUnionDeliveryMethod())
.WithOpeningStatement()
.WithAccusedGroup()
.WithAccusationSegue()
.WithAccusation()
.WithCriminalintentExplanation()
.WithClosingStatement()
.Get();
// should be a person delivering it, that's why this call is odd ;(
var quoteString = quote.speechPattern.Deliver(quote.FullQuote);
#endregion
#region Abstract Factory
var gameEngine = new ClientGameEngine(new WpfGuiFactory());
#endregion
#region ServiceLocator
var serviceLocator = new ServiceLocator.ServiceLocator();
serviceLocator.RegisterService <IGuiFactory, WpfGuiFactory>();
var retrievedService = serviceLocator.GetService <IGuiFactory>();
var gameEngineFromSL = new ClientGameEngine(retrievedService);
#endregion
#region LazyInitialization
var lazyInitializedVariable = new LazyInit <JanushKorwinMikkeQuoteBuilder>();
var retrievedInstance = lazyInitializedVariable.Value;
retrievedInstance.WithAccusation("durr");
#endregion
#region Multiton
var singletons = new List <MultitonClass>
{
MultitonClass.GetInstance(1),
MultitonClass.GetInstance(9)
};
foreach (var instance in singletons)
{
Console.WriteLine($"I is {instance.Identifier}");
}
var turningItUpTo9000 = MultitonClass.GetInstance(9000);
#endregion
#region Disposable
using (var disposableLib = new SomeNativeLibraryWrapper("some.dll"))
{
var retVal = disposableLib.SomeImpoertedMethod();
}
#endregion
#region ObjectPool
var objectPool = new ObjectPool <PoolableExpensiveObject>(40);
objectPool.Initialize();
var borrowedObject1 = objectPool.BorrowObject();
var borrowedObject2 = objectPool.BorrowObject();
var borrowedObject3 = objectPool.BorrowObject();
objectPool.ReturnObject(borrowedObject2);
#endregion
#region Chain of Responsibility
var normalAccessHandler = new NormalPrivilegesAccessHandler();
var uberPrivilegesAccessHandler = new UberPrivilegesAccessHandler(new RaisePrivilegesService());
normalAccessHandler.SetSuccessor(uberPrivilegesAccessHandler);
var accessRequest = new AccessRequest(AccessLevel.Elevated);
normalAccessHandler.HandleRequest(accessRequest);
#endregion
#region Observer
var stockValueNotifier = new StockValueNotifier(sessionOpeningPrice: 100);
var broker1 = new StockBroker("Johnny Utah");
var broker2 = new StockBroker("Shmitzi Kibbutz");
stockValueNotifier.Subscribe(broker1);
stockValueNotifier.Subscribe(broker2);
stockValueNotifier.Prop = 1_000_000;
#endregion
#region MediatorService
var mediatorService = new MediatorService();
//Mediator.ISubscriber sub1 = new Mediator.Subscriber(Mediator.Type.Transponder);
//Mediator.ISubscriber sub2 = new Mediator.Subscriber(Mediator.Type.Receiver);
//mediatorService.Register(sub1);
//mediatorService.Register(sub2);
#endregion
#region NullObject
var coolingModule = MissingModule.Instance;
var killSwitch = new FactoryKillSwitch();
var modulesChain = new List <IModule>
{
new Module("Assembly Module"),
new Module("Welding Module"),
MissingModule.Instance,
new Module("Cooling Module"),
};
killSwitch.AddModulesChain(modulesChain);
killSwitch.Engage();
#endregion
#region Registry
SomeRegistry.Register <FunctionalityClass>("ll");
SomeRegistry.Register("jeł", new FunctionalityClass());
var ll = SomeRegistry.GetInstanceOf("ll");
ll.DoStuff();
SomeRegistry.GetInstanceOf("jeł").DoStuff();
#endregion
#region Strategy
var shootingActor = new Actor(new ShootAtStrategy());
shootingActor.CurrentTarget = new Target(x: 1, y: 2);
shootingActor.PerformAssignedBehaviour();
shootingActor.Behaviour = new FollowStrategy();
shootingActor.PerformAssignedBehaviour();
#endregion
#region Visitor
var rootNode = new Node(null);
rootNode.GenerateChildren();
foreach (var node in rootNode.Children)
{
node.GenerateChildren();
}
var visitorInstance = new NestingLevelVisitor();
rootNode.Accept(visitorInstance);
var i = 0;
i++;
#endregion
}
public void EnsureSingleExecutionTestCase()
{
val = new LazyInit <int>(InitializationFunc, LazyInitMode.EnsureSingleExecution);
AssertLazyInit(ref val);
}
