private void InitFunctions() { if (!this.initFunctions) { _lock.AcquireWriterLock(Timeout.Infinite); try { if (!this.initFunctions) { if (this.contextType != typeof(DataContext)) { for (Type type = this.contextType; type != typeof(DataContext); type = type.BaseType) { foreach (MethodInfo mi in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)) { if (IsUserFunction(mi)) { if (mi.IsGenericMethodDefinition) { // Added this constraint because XML mapping model didn't support mapping sprocs to generic method. // The attribute mapping model was, however, able to support it. This check is for parity between // the two models. throw Error.InvalidUseOfGenericMethodAsMappedFunction(mi.Name); } MetaPosition mp = new MetaPosition(mi); if (!this.metaFunctions.ContainsKey(mp)) { MetaFunction metaFunction = new AttributedMetaFunction(this, mi); this.metaFunctions.Add(mp, metaFunction); // pre-set all known function result types into metaType map foreach (MetaType rt in metaFunction.ResultRowTypes) { foreach (MetaType it in rt.InheritanceTypes) { if (!this.metaTypes.ContainsKey(it.Type)) { this.metaTypes.Add(it.Type, it); } } } } } } } } this.initFunctions = true; } } finally { _lock.ReleaseWriterLock(); } } }
private void InitFunctions() { if (!initFunctions) { @lock.AcquireWriterLock(-1); try { if (!initFunctions) { if (contextType != typeof(DataContext)) { Type baseType = contextType; while (baseType != typeof(DataContext)) { MethodInfo[] methods = baseType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); foreach (MethodInfo methodInfo in methods) { if (IsUserFunction(methodInfo)) { if (methodInfo.IsGenericMethodDefinition) { throw System.Data.Linq.Mapping.Error.InvalidUseOfGenericMethodAsMappedFunction(methodInfo.Name); } MetaPosition key = new MetaPosition(methodInfo); if (!metaFunctions.ContainsKey(key)) { MetaFunction metaFunction = new AttributedMetaFunction(this, methodInfo); metaFunctions.Add(key, metaFunction); foreach (MetaType resultRowType in metaFunction.ResultRowTypes) { foreach (MetaType inheritanceType in resultRowType.InheritanceTypes) { if (!metaTypes.ContainsKey(inheritanceType.Type)) { metaTypes.Add(inheritanceType.Type, inheritanceType); } } } } } } baseType = baseType.BaseType; } } initFunctions = true; } } finally { @lock.ReleaseWriterLock(); } } }
private void InitFunctions() { if (!this.initFunctions) { @lock.AcquireWriterLock(Timeout.Infinite); try { if (!this.initFunctions) { if (this.contextType != typeof(DataContext)) { for (Type type = this.contextType; type != typeof(DataContext); type = type.BaseType) { foreach (MethodInfo mi in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)) { if (IsUserFunction(mi)) { if (mi.IsGenericMethodDefinition) { // Added this constraint because XML mapping model didn't support mapping sprocs to generic method. // The attribute mapping model was, however, able to support it. This check is for parity between // the two models. throw Error.InvalidUseOfGenericMethodAsMappedFunction(mi.Name); } MetaPosition mp = new MetaPosition(mi); if (!this.metaFunctions.ContainsKey(mp)) { MetaFunction metaFunction = new AttributedMetaFunction(this, mi); this.metaFunctions.Add(mp, metaFunction); // pre-set all known function result types into metaType map foreach (MetaType rt in metaFunction.ResultRowTypes) { foreach (MetaType it in rt.InheritanceTypes) { if (!this.metaTypes.ContainsKey(it.Type)) { this.metaTypes.Add(it.Type, it); } } } } } } } } this.initFunctions = true; } } finally { @lock.ReleaseWriterLock(); } } }
private void InitFunctions() { if (areFunctionsInitialized) { return; } metaModelLock.AcquireWriterLock(Timeout.Infinite); try { if (areFunctionsInitialized) { return; } if (contextType != typeof(DataContext)) { for (var type = contextType; type != typeof(DataContext); type = type.BaseType) { foreach (var method in type.GetMethods( BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly)) { if (IsUserFunction(method)) { // Added this constraint because XML mapping model didn't support // mapping sprocs to generic method. // The attribute mapping model was, however, able to support it. This check is for parity between // the two models. if (method.IsGenericMethodDefinition) { throw Error.InvalidUseOfGenericMethodAsMappedFunction(method.Name); } var metaPosition = new MetaPosition(method); if (!metaFunctions.ContainsKey(metaPosition)) { var metaFunction = new AttributedMetaFunction(this, method); metaFunctions.Add(metaPosition, metaFunction); // pre-set all known function result types into metaType map foreach (var resultRowType in metaFunction.ResultRowTypes) { foreach (var inheritanceType in resultRowType.InheritanceTypes) { if (!metaTypes.ContainsKey(inheritanceType.Type)) { metaTypes.Add(inheritanceType.Type, inheritanceType); } } } } } } } } areFunctionsInitialized = true; } finally { metaModelLock.ReleaseWriterLock(); } }