public Result Create(string name, string owner)
        {
            if (string.IsNullOrEmpty(name))
            {
                name = "Новый документ";
            }

            lock (_sync)
            {
                name = UniqueName(name);
                var document = Invoke.Safe(() => _factory.Create(name), LastError);
                if (document == null)
                {
                    return(new Result {
                        State = State.Deleted, Success = false, Buffer = _lastResult.ToString()
                    });
                }

                document.Creator      = owner;
                document.CreationTime = DateTime.Now;
                _hash[name]           = document;
                return(new Result {
                    State = State.Created, Success = true
                });
            }
        }
        /// <summary>
        /// Closing without deleting.
        /// User informs that he won't edit the text.
        /// </summary>
        public Result Close(string name, string user)
        {
            lock (_sync)
            {
                if (!_hash.ContainsKey(name))
                {
                    return new Result {
                               State = State.Deleted, Success = false
                    }
                }
                ;
                if (IsOpened(name) && !IsOwner(name, user))
                {
                    return new Result {
                               State = State.Opened, Success = false
                    }
                }
                ;

                var document = _hash[name];

                if (_factory.SupportClose())
                {
                    Invoke.Safe(() => _factory.Close(document), LastError);
                }

                document.IsOpened = false;
                document.Owner    = string.Empty;
            }

            return(new Result {
                State = State.Closed, Success = true
            });
        }
        public Result Write(string name, string user, string text)
        {
            lock (_sync)
            {
                if (!_hash.ContainsKey(name))
                {
                    return new Result {
                               State = State.Deleted, Success = false
                    }
                }
                ;
                if (IsOpened(name) && !IsOwner(name, user))
                {
                    return new Result {
                               State = State.Opened, Success = false
                    }
                }
                ;

                var document = _hash[name];
                var result   = Invoke.Safe(() => _factory.Write(document, text), LastError);
                return(new Result {
                    State = State.Opened, Success = result
                });
            }
        }
        /// <summary>
        /// Closing and deleting.
        /// </summary>
        public Result Delete(string name, string user)
        {
            var result = Close(name, user);

            if (!result.Success)
            {
                return(result);
            }

            var deleted = true;

            lock (_sync)
            {
                if (!_hash.ContainsKey(name))
                {
                    return new Result {
                               State = State.Deleted, Success = false
                    }
                }
                ;
                if (IsOpened(name) && !IsOwner(name, user))
                {
                    return new Result {
                               State = State.Opened, Success = false
                    }
                }
                ;

                if (_factory.SupportDelete())
                {
                    deleted = Invoke.Safe(() => _factory.Delete(_hash[name]), LastError);
                }

                if (deleted)
                {
                    _hash.Remove(name);
                }
            }

            return(new Result {
                State = deleted ? State.Deleted : State.Closed, Success = deleted
            });
        }
        public Result Open(string name, string user)
        {
            lock (_sync)
            {
                if (!_hash.ContainsKey(name))
                {
                    return new Result {
                               State = State.Deleted, Success = false
                    }
                }
                ;
                if (IsOpened(name) && !IsOwner(name, user))
                {
                    return new Result {
                               State = State.Opened, Success = false
                    }
                }
                ;

                var document = _hash[name];
                var text     = Invoke.Safe(() => _factory.Read(document), LastError);

                if (_lastResult.Success)
                {
                    document.IsOpened = true;

                    document.Owner = user;
                }

                return
                    (_lastResult.Success
                                                ? new Result {
                    Success = true, Buffer = text, State = State.Opened
                }
                                                : new Result {
                    Success = false, Buffer = _lastResult.ToString()
                });
            }
        }