Ejemplo n.º 1
0
		public override INHibernateProxy GetProxy(object id, ISessionImplementor session)
		{
			INHibernateProxy proxy;
			try
			{
				var behaviorInfo = _behaviorConfigurator.GetProxyInformation(PersistentClass);


				var initializer = new LazyInitializer(EntityName, PersistentClass, id, GetIdentifierMethod,
				                                      SetIdentifierMethod, ComponentIdType, session);

				IInterceptor[] interceptors = behaviorInfo.Interceptors
														.Select(i => _kernel.Resolve(i))
														.OfType<IInterceptor>()
                                                        .Union(new[] {initializer}).ToArray();

				Type[] interfaces = Interfaces.Union(behaviorInfo.AdditionalInterfaces).ToArray();

				object obj2 = IsClassProxy
				              	? ProxyGenerator.CreateClassProxy(PersistentClass, interfaces, interceptors)
                                : ProxyGenerator.CreateInterfaceProxyWithoutTarget(interfaces[0], interfaces,
				              	                                                   new IInterceptor[] {initializer});
				initializer._constructed = true;
				proxy = (INHibernateProxy) obj2;
			}
			catch (Exception exception)
			{
				log.Error("Creating a proxy instance failed", exception);
				throw new HibernateException("Creating a proxy instance failed", exception);
			}
			return proxy;
		}
Ejemplo n.º 2
0
        public override INHibernateProxy GetProxy(object id, global::NHibernate.Engine.ISessionImplementor session)
        {
            try
            {
                var initializer = new LazyInitializer(EntityName, PersistentClass, id, GetIdentifierMethod, SetIdentifierMethod, ComponentIdType, session);

                object generatedProxy = IsClassProxy
                                            ? DataBindingFactory.Create(PersistentClass, Interfaces, initializer)
                                            : ProxyGenerator.CreateInterfaceProxyWithoutTarget(Interfaces[0], Interfaces,
                                                                                                initializer);

                initializer._constructed = true;
                return (INHibernateProxy) generatedProxy;
            }
            catch (Exception e)
            {
                throw new HibernateException("Creating a proxy instance failed", e);
            }
        }
Ejemplo n.º 3
0
		public override INHibernateProxy GetProxy(object id, ISessionImplementor session)
		{
			try
			{
				var initializer = new LazyInitializer(EntityName, PersistentClass.IsInterface ? typeof (object) : PersistentClass,
				                                      id, GetIdentifierMethod, SetIdentifierMethod, ComponentIdType, session);

				var proxyFactory = new SerializableProxyFactory
				                   	{Interfaces = Interfaces, TargetSource = initializer, ProxyTargetType = IsClassProxy};
				proxyFactory.AddAdvice(initializer);

				object proxyInstance = proxyFactory.GetProxy();
				return (INHibernateProxy) proxyInstance;
			}
			catch (Exception ex)
			{
				log.Error("Creating a proxy instance failed", ex);
				throw new HibernateException("Creating a proxy instance failed", ex);
			}
		}
 public IKey GetPrimaryKey()
 {
     return(LazyInitializer.EnsureInitialized(ref _key, LoadKey));
 }
 public override void OnActionExecuting(ActionExecutingContext filterContext)
 {
     // Обеспечение однократной инициализации ASP.NET Simple Membership при каждом запуске приложения
     LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
 }
Ejemplo n.º 6
0
 public override void OnActionExecuting(ActionExecutingContext filterContext)
 {
     // 确保每次启动应用程序时只初始化一次 ASP.NET Simple Membership
     LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
 }
 /// <summary>Gets the lazily-initialized completion state.</summary>
 private CompletionState EnsureCompletionStateInitialized()
 {
     // ValueLock not needed, but it's ok if it's held
     return(LazyInitializer.EnsureInitialized(ref m_completionState, () => new CompletionState()));
 }
Ejemplo n.º 8
0
        public static void EnsureInitialized_ComplexRefTypes()
        {
            string strTemplate = "foo";
            var    hdcTemplate = new HasDefaultCtor();

            // Activator.CreateInstance (uninitialized).
            HasDefaultCtor a     = null;
            bool           aInit = false;
            object         aLock = null;

            Assert.NotNull(LazyInitializer.EnsureInitialized(ref a, ref aInit, ref aLock));
            Assert.NotNull(a);
            Assert.True(aInit);
            Assert.NotNull(aLock);

            // Activator.CreateInstance (already initialized).
            HasDefaultCtor b     = hdcTemplate;
            bool           bInit = true;
            object         bLock = null;

            Assert.Equal(hdcTemplate, LazyInitializer.EnsureInitialized(ref b, ref bInit, ref bLock));
            Assert.Equal(hdcTemplate, b);
            Assert.True(bInit);
            Assert.Null(bLock);

            // Func based initialization (uninitialized).
            string c     = null;
            bool   cInit = false;
            object cLock = null;

            Assert.Equal(strTemplate, LazyInitializer.EnsureInitialized(ref c, ref cInit, ref cLock, () => strTemplate));
            Assert.Equal(strTemplate, c);
            Assert.True(cInit);
            Assert.NotNull(cLock);

            // Func based initialization (already initialized).
            string d     = strTemplate;
            bool   dInit = true;
            object dLock = null;

            Assert.Equal(strTemplate, LazyInitializer.EnsureInitialized(ref d, ref dInit, ref dLock, () => strTemplate + "bar"));
            Assert.Equal(strTemplate, d);
            Assert.True(dInit);
            Assert.Null(dLock);

            // Func based initialization (nulls *ARE* permitted).
            string e         = null;
            bool   einit     = false;
            object elock     = null;
            int    initCount = 0;

            Assert.Null(LazyInitializer.EnsureInitialized(ref e, ref einit, ref elock, () => { initCount++; return(null); }));
            Assert.Null(e);
            Assert.Equal(1, initCount);
            Assert.True(einit);
            Assert.NotNull(elock);
            Assert.Null(LazyInitializer.EnsureInitialized(ref e, ref einit, ref elock, () => { initCount++; return(null); }));

            // Func based initialization without tracking boolean (uninitialized).
            string f     = null;
            object fLock = null;

            Assert.Equal(strTemplate, LazyInitializer.EnsureInitialized(ref f, ref fLock, () => strTemplate));
            Assert.Equal(strTemplate, f);
            Assert.NotNull(fLock);

            // Func based initialization without tracking boolean (already initialized).
            string g     = strTemplate;
            object gLock = null;

            Assert.Equal(strTemplate, LazyInitializer.EnsureInitialized(ref g, ref gLock, () => strTemplate + "bar"));
            Assert.Equal(strTemplate, g);
            Assert.Null(gLock);

            // Func based initialization without tracking boolean (nulls not permitted).
            string h     = null;
            object hLock = null;

            Assert.Throws <InvalidOperationException>(() => LazyInitializer.EnsureInitialized(ref h, ref hLock, () => null));
        }
Ejemplo n.º 9
0
 public InitializeSimpleMembershipAttribute()
 {
     LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
 }
Ejemplo n.º 10
0
 internal SemaphoreSlim EnsureAsyncActiveSemaphoreInitialized()
 {
     // Lazily-initialize _asyncActiveSemaphore.  As we're never accessing the SemaphoreSlim's
     // WaitHandle, we don't need to worry about Disposing it.
     return(LazyInitializer.EnsureInitialized(ref _asyncActiveSemaphore, () => new SemaphoreSlim(1, 1)));
 }
Ejemplo n.º 11
0
 public IList <Damage> GetCleanDamages()
 {
     return(LazyInitializer.EnsureInitialized(ref _cleanDamages, CalculateCleanDamages));
 }
Ejemplo n.º 12
0
        private static string ReadXdgDirectory(string homeDir, string key, string fallback)
        {
            Debug.Assert(!string.IsNullOrEmpty(homeDir), $"Expected non-empty homeDir");
            Debug.Assert(!string.IsNullOrEmpty(key), $"Expected non-empty key");
            Debug.Assert(!string.IsNullOrEmpty(fallback), $"Expected non-empty fallback");

            string envPath = GetEnvironmentVariable(key);

            if (!string.IsNullOrEmpty(envPath) && envPath[0] == '/')
            {
                return(envPath);
            }

            // Use the user-dirs.dirs file to look up the right config.
            // Note that the docs also highlight a list of directories in which to look for this file:
            // "$XDG_CONFIG_DIRS defines the preference-ordered set of base directories to search for configuration files in addition
            //  to the $XDG_CONFIG_HOME base directory. The directories in $XDG_CONFIG_DIRS should be separated with a colon ':'. If
            //  $XDG_CONFIG_DIRS is either not set or empty, a value equal to / etc / xdg should be used."
            // For simplicity, we don't currently do that.  We can add it if/when necessary.

            string userDirsPath = Path.Combine(GetXdgConfig(homeDir), "user-dirs.dirs");

            if (Interop.Sys.Access(userDirsPath, Interop.Sys.AccessMode.R_OK) == 0)
            {
                try
                {
                    // TODO #11151: Replace with direct usage of File.ReadLines or equivalent once we have access to System.IO.FileSystem here.
                    Func <string, IEnumerable <string> > readLines = LazyInitializer.EnsureInitialized(ref s_fileReadLines, () =>
                    {
                        Type fileType = Type.GetType("System.IO.File, System.IO.FileSystem, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", throwOnError: false);
                        if (fileType != null)
                        {
                            foreach (MethodInfo mi in fileType.GetTypeInfo().GetDeclaredMethods("ReadLines"))
                            {
                                if (mi.GetParameters().Length == 1)
                                {
                                    return((Func <string, IEnumerable <string> >)mi.CreateDelegate(typeof(Func <string, IEnumerable <string> >)));
                                }
                            }
                        }
                        return(null);
                    });

                    IEnumerable <string> lines = readLines?.Invoke(userDirsPath);
                    if (lines != null)
                    {
                        foreach (string line in lines)
                        {
                            // Example lines:
                            // XDG_DESKTOP_DIR="$HOME/Desktop"
                            // XDG_PICTURES_DIR = "/absolute/path"

                            // Skip past whitespace at beginning of line
                            int pos = 0;
                            SkipWhitespace(line, ref pos);
                            if (pos >= line.Length)
                            {
                                continue;
                            }

                            // Skip past requested key name
                            if (string.CompareOrdinal(line, pos, key, 0, key.Length) != 0)
                            {
                                continue;
                            }
                            pos += key.Length;

                            // Skip past whitespace and past '='
                            SkipWhitespace(line, ref pos);
                            if (pos >= line.Length - 4 || line[pos] != '=')
                            {
                                continue; // 4 for ="" and at least one char between quotes
                            }
                            pos++;        // skip past '='

                            // Skip past whitespace and past first quote
                            SkipWhitespace(line, ref pos);
                            if (pos >= line.Length - 3 || line[pos] != '"')
                            {
                                continue; // 3 for "" and at least one char between quotes
                            }
                            pos++;        // skip past opening '"'

                            // Skip past relative prefix if one exists
                            bool         relativeToHome       = false;
                            const string RelativeToHomePrefix = "$HOME/";
                            if (string.CompareOrdinal(line, pos, RelativeToHomePrefix, 0, RelativeToHomePrefix.Length) == 0)
                            {
                                relativeToHome = true;
                                pos           += RelativeToHomePrefix.Length;
                            }
                            else if (line[pos] != '/') // if not relative to home, must be absolute path
                            {
                                continue;
                            }

                            // Find end of path
                            int endPos = line.IndexOf('"', pos);
                            if (endPos <= pos)
                            {
                                continue;
                            }

                            // Got we need.  Now extract it.
                            string path = line.Substring(pos, endPos - pos);
                            return(relativeToHome ?
                                   Path.Combine(homeDir, path) :
                                   path);
                        }
                    }
                }
                catch (Exception exc)
                {
                    // assembly not found, file not found, errors reading file, etc. Just eat everything.
                    Debug.Fail($"Failed reading {userDirsPath}: {exc}");
                }
            }

            return(Path.Combine(homeDir, fallback));
        }
Ejemplo n.º 13
0
 public virtual void NotifyReaderCreated([NotNull] DbDataReader dataReader)
 => LazyInitializer
 .EnsureInitialized(
     ref _valueBufferFactory,
     () => QuerySqlGeneratorFactory()
     .CreateValueBufferFactory(_valueBufferFactoryFactory, dataReader));
Ejemplo n.º 14
0
 public static SerialPort GetInstance()
 {
     return(LazyInitializer.EnsureInitialized(ref _instance, () => new SerialPort()));
 }
Ejemplo n.º 15
0
 public T EnsureInitialized()
 {
     return(LazyInitializer.EnsureInitialized <T>(ref _value, ref _initialized, ref _lock, _initializer));
 }
Ejemplo n.º 16
0
 void EnsureConsumerInitialized()
 => LazyInitializer.EnsureInitialized(ref consumer, InitializeConsumer);
Ejemplo n.º 17
0
 internal static T EnsureInitialized <T>(ref T field, Func <T> initializer) where T : class =>
 LazyInitializer.EnsureInitialized(ref field, ref InternalSyncObject, initializer);
Ejemplo n.º 18
0
 public override void OnActionExecuting(ActionExecutingContext filterContext)
 {
     // Asegúrese de que ASP.NET Simple Membership se inicialice solo una vez por inicio de la aplicación
     LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
 }
Ejemplo n.º 19
0
 public override void OnActionExecuting(ActionExecutingContext filterContext)
 {
     LazyInitializer.EnsureInitialized(ref membershipInitializer, ref isInitialized, ref initializationLock);
 }
 public override void OnActionExecuting(ActionExecutingContext filterContext)
 {
     // S'assurer qu'ASP.NET Simple Membership est initialisé une seule fois par démarrage d'application
     LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
 }
 private static void EnsureFixedInfo()
 {
     LazyInitializer.EnsureInitialized(ref s_fixedInfo, ref s_fixedInfoInitialized, ref s_syncObject, () => GetFixedInfo());
 }
Ejemplo n.º 22
0
 /// <summary>
 /// Returns the machine name.
 /// </summary>
 /// <returns>The machine name.</returns>
 public string GetMachineName()
 {
     return(LazyInitializer.EnsureInitialized(ref this.hostName, this.GetHostName));
 }
Ejemplo n.º 23
0
 /// <inheritdoc />
 public IReadOnlyCollection <ModuleHelpData> GetModuleHelpData()
 => LazyInitializer.EnsureInitialized(ref _cachedHelpData, () =>
                                      _commands.Modules
                                      .Where(x => !x.Attributes.Any(attr => attr is HiddenFromHelpAttribute))
                                      .Select(x => ModuleHelpData.FromModuleInfo(x))
                                      .ToArray());
Ejemplo n.º 24
0
 /// <summary>
 /// Initializes a new instance of the <see cref="WebUserSecurity"/> class.
 /// </summary>
 /// <param name="securityRepository">The security repository.</param>
 public WebUserSecurity(ISecurityRepository securityRepository)
 {
     _securityRepository = securityRepository;
     LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
 }
Ejemplo n.º 25
0
 /// <summary>
 /// Resolves type by <paramref name="typeResolver"/> if not yet resoved
 /// and activates it.
 /// </summary>
 /// <param name="typeResolver">Method to resolve type</param>
 /// <returns></returns>
 public object Activate(Func <Type> typeResolver)
 => Activator.CreateInstance(LazyInitializer.EnsureInitialized(ref cache,
                                                               typeResolver));
Ejemplo n.º 26
0
 public void EnsureInstalled()
 {
     LazyInitializer.EnsureInitialized(ref _initDummy, Install);
 }
Ejemplo n.º 27
0
 public SyncBootState GetSyncBootState()
 => LazyInitializer.EnsureInitialized(
     ref _syncBootState,
     ref _syncBootStateReady,
     ref _syncBootStateLock,
     () => InitializeColdBootState(_lastSyncedFileManager.LastSyncedId));
 private IProperty[] EnsurePropertiesInitialized()
 {
     return(LazyInitializer.EnsureInitialized(ref _properties, LoadProperties));
 }
Ejemplo n.º 29
0
        internal IChangeToken GetFilterChangeToken()
        {
            CancellationTokenSource cts = LazyInitializer.EnsureInitialized(ref _cancellationTokenSource, () => new CancellationTokenSource());

            return(new CancellationChangeToken(cts.Token));
        }
Ejemplo n.º 30
0
 public override void OnActionExecuting(ActionExecutingContext filterContext)
 {
     // Ensure ASP.NET Simple Membership is initialized only once per app start
     LazyInitializer.EnsureInitialized(ref _initializer, ref _isInitialized, ref _initializerLock);
 }
Ejemplo n.º 31
0
 public QCTestViewModel()
 {
     _model = LazyInitializer.EnsureInitialized <WarehouseModel>(ref _model, () => new WarehouseModel());
 }
Ejemplo n.º 32
0
 private SemaphoreSlim EnsureAsyncActiveSemaphoreInitialized()
 {
     return(LazyInitializer.EnsureInitialized(ref _asyncActiveSemaphore, () => new SemaphoreSlim(1, 1)));
 }
Ejemplo n.º 33
0
 /// <summary>
 /// Load settings from the AppSettings section of the config file.
 /// </summary>
 /// <returns></returns>
 public static IDictionary <string, string> LoadFromConfig()
 {
     return(LazyInitializer.EnsureInitialized(
                ref _fromConfigImplementation,
                () => new FromConfigImplementation()));
 }