public RecordingStorage(IStorage storage)
        {
            _innerStorage = storage;

            Loaded = new HashSet<Uri>();
            Saved = new HashSet<Uri>();
        }

        protected override ResourceSaveOperation CreateSaveOperationForItem(IStorage storage, CatalogContext context, CatalogItem item, CancellationToken cancellationToken)
        {
            // This method decides what to do with the item.
            // If it's a RegistrationMakerCatalogItem and it already exists, then don't write content.
            var registrationMakerCatalogItem = item as RegistrationMakerCatalogItem;
            if (registrationMakerCatalogItem != null)
            {
                var content = item.CreateContent(Context); // note: always do this first
                var resourceUri = item.GetItemAddress();

                var saveOperation = new ResourceSaveOperation();
                saveOperation.ResourceUri = resourceUri;

                if (!registrationMakerCatalogItem.IsExistingItem && content != null)
                {
                    saveOperation.SaveTask = storage.Save(resourceUri, content, cancellationToken);
                }
                else
                {
                    Trace.WriteLine(string.Format("Resource {0} already exists. Skipping.", resourceUri), "Debug");
                }

                return saveOperation;
            }

            return base.CreateSaveOperationForItem(storage, context, item, cancellationToken);
        }

 public PlayersController(IStorage<Models.Player> playerStorage, IStorage<Models.BoardGame> boardGamesStorage,
     DistanceCalculator distanceCalculator)
 {
     _playerStorage = playerStorage;
     _boardGamesStorage = boardGamesStorage;
     _distanceCalculator = distanceCalculator;
 }

 public object Deserialize(IStorage storage, Data.Node data, object result)
 {
     return data is Data.DateTime ? (data as Data.DateTime).Value :
         data is Data.Binary ? new System.DateTime(BitConverter.ToInt64((data as Data.Binary).Value, 0)) :
         data is Data.String ? System.DateTime.Parse((data as Data.String).Value) :
         new System.DateTime();
 }

        internal PObject(IStorage repository, int id, Dictionary<int, IPObject> objectsIndex, bool deferredLoad)
        {
            if (repository == null)
                throw new Exception("Хранилище данных не задано");

            Id = id;
            _ownerCollection = null;

            this.storage = repository;
            this.objectsIndex = objectsIndex;
            this._deferredLoad = deferredLoad;

            // получение значений атрибутов
            _attrs = repository.ListAttributes(Id);

            if (objectsIndex != null)
                objectsIndex.Add(id, this);

            // загрузка коллекций
            _collections = new Dictionary<string, PCollection>();

            List<string> collectsNames = storage.ListCollections(Id);
            foreach (string name in collectsNames)
            {
                string lowName = name.ToLower();
                _collections.Add(lowName, new PCollection(this, lowName, deferredLoad));
            }
        }

        public void PolymorphicEnumeration()
        {
            var stgs = new IStorage[]
            {
                new MemoryStorage(),
                //new PersistedMemoryStorage(),
                new FileSystemStorage("fs"),
                //new EsentStorage("esent"),
                new SqlSeverStorage("server=.;database=overdb;integrated security=true"),
            };

            foreach (var stg in stgs)
            {
                using (var db = new Database(stg, null, new GuidIdFactory()))
                {
                    db.Delete(db.GetEnumerable());
                    db.SaveMany(new Animal[]
                    {
                        new Cat(), new Dog(), new Cow(),
                    }.AsEnumerable());

                    var animals = db.GetEnumerable<Animal>();
                    Assert.That(animals.Count(), Is.EqualTo(3), "{0} not polymorphic", stg.GetType().Name);
                }
            }
        }

 public SerfidCore(IListener listener, IFilter filter, IStorage storage, IUser user)
 {
     _listener = listener;
     _filter = filter;
     _storage = storage;
     _user = user;
 }

        public BarsTimeIntervalEnumerator(DataFeed dataFeed, IStorage storage, string symbol, PriceType priceType, BarPeriod period, DateTime startTime, DateTime endTime, int preferredBufferSize)
            : base(dataFeed, storage, symbol, priceType, period, startTime, preferredBufferSize)
        {
            this.endTime = endTime;

            this.Reset();
        }

        IList<string> GetCodes(IStorage storage, IList<string> codes=null) {
            var items= storage.ListItems("");
            foreach (var item in items) {

            }
            return codes;
        }

 public object Deserialize(IStorage storage, Data.Node data, object result)
 {
     return data is Data.Byte ? (data as Data.Byte).Value :
         data is Data.Binary ? (data as Data.Binary).Value[0] :
         data is Data.String ? byte.Parse((data as Data.String).Value, System.Globalization.CultureInfo.InvariantCulture.NumberFormat) :
         (byte)0;
 }

        public static async Task AddStorage(this MockServerHttpClientHandler handler, IStorage storage)
        {
            var files = await storage.List(CancellationToken.None);
            foreach (var file in files)
            {
                var storageFileUrl = file;
                var relativeFileUrl = "/" + storageFileUrl.ToString().Replace(storage.BaseAddress.ToString(), string.Empty);

                handler.SetAction(relativeFileUrl, async message =>
                {
                    var content = await storage.Load(storageFileUrl, CancellationToken.None);

                    var response = new HttpResponseMessage(HttpStatusCode.OK);

                    if (!string.IsNullOrEmpty(content.CacheControl))
                    {
                        response.Headers.CacheControl = CacheControlHeaderValue.Parse(content.CacheControl);
                    }
                    response.Content = new StreamContent(content.GetContentStream());

                    if (!string.IsNullOrEmpty(content.ContentType))
                    {
                        response.Content.Headers.ContentType = new MediaTypeHeaderValue(content.ContentType);
                    }

                    return response;
                });
            }
        }

 /***********************************************************************/
 private StorageRoot(IStorage root, bool readOnly )
     : base( root ) 
 {
     rootIStorage = root; 
     containerIsReadOnly = readOnly; 
     dataSpaceManagerInitializationInProgress = false;
 } 

 public Computer(ICpu cpu, IRam ram, IVideoCard gpu, IStorage storage)
 {
     Storage = storage;
     Gpu = gpu;
     Ram = ram;
     Cpu = cpu;
 }

 public Regulus.Project.Crystal.Game.Core CreateUser(Regulus.Remoting.ISoulBinder binder, IStorage storage, IMap zone , Battle.IZone battle)
 {
     var core = new Regulus.Project.Crystal.Game.Core(binder, storage, zone, battle);
     _Users.AddFramework(core);
     core.InactiveEvent += () => { _Users.RemoveFramework(core); };
     return core;
 }

        internal CompoundFile(IStorage storage, System.Runtime.InteropServices.ComTypes.STATSTG statstg)
        {
            if (storage == null) { throw new ArgumentNullException("storage"); }

            _rootStorage = storage;
            _statstg = statstg;
        }

 public JsonClient(IStorage storedCredentials, string url, string scopes)
 {
     _scopes = scopes;
     _url = new Uri(url);
     _storedCredentials = storedCredentials;
     _client = new WebClient { Encoding = Encoding.UTF8 };
 }

        public object Deserialize(IStorage storage, Data.Node data, object result)
        {
            Kean.Collection.IList<Data.Node> nodes;
            Reflect.Type type;
            Reflect.Type elementType;
            type = data.Type;
            elementType = this.GetElementType(type);
            if (data is Data.Collection)
                nodes = (data as Data.Collection).Nodes;
            else
            { // only one element so it was impossible to know it was a collection
                nodes = new Kean.Collection.List<Data.Node>(data);
                data.Type = data.OriginalType ?? elementType;
                Uri.Locator locator = data.Locator.Copy();
                locator.Fragment += "0";
                data.Locator = locator;
            }

            if (result.IsNull())
                result = this.Create(type, elementType, nodes.Count);
            int i = 0;
            foreach (Data.Node child in nodes)
            {
                int c = i++; // ensure c is unique in every closure of lambda function below
                storage.Deserialize(child, elementType, d => this.Set(result, d, c));
            }
            return result;
        }

 public PaymentProcessor(string pool, IDaemonClient daemonClient, IStorage storage , IWalletConfig walletConfig)
 {
     _daemonClient = daemonClient;
     _storage = storage;
     _walletConfig = walletConfig;
     _logger = Log.ForContext<PaymentProcessor>().ForContext("Component", pool);
 }

 public AdventureStage(IMap map , IStorage storage , User user)
 {
     _User = user;
     _Observeds = new List<IObservedAbility>();
     _Stroage = storage;
     _Map = map;
 }

 public object Deserialize(IStorage storage, Data.Node data, object result)
 {
     return data is Data.String ? (data as Data.String).Value :
         data is Data.Binary ? System.Text.Encoding.UTF8.GetString((data as Data.Binary).Value) :
         data is Data.Null ? null :
         "";
 }