static void Main(string[] args)
        {
            using(var fr = new FlowRuntime())
            {
                var frc = new FlowRuntimeConfiguration();

                var pageBufferContainer = new DataContainer<PageBuffer>();

                var frontend = new Frontend();

                frc.AddFlow(new Main(new Formatter(),
                                    frontend));
                frc.AddFlow(new Features(new CommandlineParser(pageBufferContainer),
                                        new TextFileAdapter(),
                                        new LineBuffer(pageBufferContainer),
                                        new Pager(pageBufferContainer)));
                fr.Configure(frc);

                frontend.displayFirstPage += fr.CreateEventProcessor(".displayFirstPage");
                frontend.displayLastPage += fr.CreateEventProcessor(".displayLastPage");
                frontend.displayNextPage += fr.CreateEventProcessor(".displayNextPage");
                frontend.displayPrevPage += fr.CreateEventProcessor(".displayPrevPage");

                //fr.Message += Console.WriteLine;

                fr.Process(new Message(".run", new[]{"test1.txt"}));

                fr.WaitForResult();
            }
        }

 void Start()
 {
     data = GameObject.FindGameObjectWithTag("GameContainer").GetComponent<DataContainer>();
     float TopScoreTime = PlayerPrefs.GetFloat("TopScore");
     TopScore.text = "Best time: " + CalculateTime(TopScoreTime);
     Time.timeScale = 1;
 }

    public RecordedRawOutput(string filename)
    {
        r = new System.Random();
        startTime = DateTime.Now;
        lastTime = DateTime.Now;

        if(File.Exists(filename)){
          // grab the XML serialized data from a file
          FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
          XmlSerializer xs = new XmlSerializer(typeof(DataContainer));

          // then try to deserialize it
          try {
        container = (DataContainer)xs.Deserialize(stream);
          }
          catch(FileNotFoundException e){
        container.dataPairs = new RawDataPair[0];
          }
          catch(Exception e){
        Debug.Log("General exception: " + e);
          }

          /*
          stream.Close();
          */
        }
        else {
          container.dataPairs = new RawDataPair[0];
        }
    }

 public virtual void Start()
 {
     animator = GetComponent<Animator>();
     audioSource = GetComponent<AudioSource>();
     data = GameObject.FindGameObjectWithTag("GameContainer").GetComponent<DataContainer>();
     Targets = GameObject.FindGameObjectsWithTag("Player");
     CurrentTarget = GetClosestTarget();
 }

 public DesisionTreeMainWindow()
 {
     InitializeComponent();
     dbHandler = new DataBaseHandler();
     desTreeInfo = new DataContainer<List<string[]>>();
     learningInfo = new DataContainer<DataContainer<List<string>>>();
     LoadInformationForUsingDesTrees();
 }

    public SettingsFileManager()
        : base()
    {
        fileName = "PlayerSettings.dat";
        pathFile += fileName;
        dataContainer = new DataContainer();

        FileInitialization();
    }

 public void LaunchGame()
 {
     SaveSystem.Registery.m_snapshot.m_partyName = charName.text;
     DataContainer playerContainer = new DataContainer("player");
     playerContainer.Addvalue("marine", selectedMarine);
     //...
     SaveSystem.RegisterPlayer(playerContainer);
     SaveSystem.LoadScene("scn_IntroScreen");
 }

        public override void Deserialize(XElement serializedData)
        {
            base.Deserialize(serializedData);

            foreach (XElement bone in serializedData.Element("bones").Elements())
            {
                DataContainer boneData = new DataContainer();
                boneData.Deserialize(bone);
                BoneAnimationData.Add(bone.Attribute("id").Value, boneData);
            }
        }

        public AccessFile( DataContainer _dc )
        {
            if ( _dc != null ) {
                dc = _dc;

                if ( dc.GetOwnerDB() == null )
                    throw new AccessException( " Database is not defined for this DataСontainer! " );

                filepath = dc.GetOwnerDB().DbPath+"/_dc_"+dc.Name+".access";
            }
        }

 public override void LoadData(DataContainer container)
 {
     try
     {
         waiting = container.GetValue<bool>("waiting");
     }
     catch(Exception)
     {
         return;
     }
 }

        public static void BuildIndex( string db_name, string container_name )
        {
            var db1 = DataBase.LoadFrom( db_name, null );
            var dc1 = new DataContainer( db1, container_name );
            var rec1 = new Record( dc1 );
            rec1.Id = 102;
            rec1.BuildIndex();
            var hash_expected = "2D8C1282A16592B40656F06F80D75172";

            Assert.AreEqual( hash_expected, rec1.GetIndex().DwarfHashCode );
        }

        public static string Generate(DataContainer container)
        {
            string output = "";

            foreach(DataGroup group in container.TopGroups)
            {
                output += GenerateDataGroup(group, 0) + "\n";
            }

            return output;
        }

 public Stream Serialize(object item)
 {
     Should.NotBeNull(item, nameof(item));
     EnsureInitialized();
     if (_knownTypes.Add(item.GetType()))
         _contractSerializer = new DataContractSerializer(typeof(DataContainer), _knownTypes);
     item = new DataContainer { Data = item };
     var ms = new MemoryStream();
     _contractSerializer.WriteObject(ms, item);
     return ms;
 }

        /// <summary>
        /// Save this object in the Resgistery
        /// </summary>
        public virtual void Save()
        {
            if (!m_volatile)
            {
                if (m_data == null)
                    m_data = new DataContainer(gameObject.name);

                CollectData(m_data);

                SaveSystem.RegisterData(m_data);
            }
        }

 public static void CreateContainer()
 {
     var user = User.User.New( "root", "12345678");
     string container_name = "nunit_container1";
     var db  = DataBase.LoadFrom( "nunit_db", null );
     var new_dc = new DataContainer( db, container_name );
     new_dc.AddAccess( user, AccessFunctions.Access.AccessLevel.READ_WRITE );
     new_dc.AddColumn( new Column( DataType.STRING, "col1" ), user );
     new_dc.AddColumn( new Column( DataType.FLOAT, "col2" ), user );
     new_dc.BuildIndex();
     new_dc.Save();
 }

 /// <summary>
 /// This method joins two data tuples.
 /// </summary>
 /// <param name="leftData">Left data tuple.</param>
 /// <param name="rightData">Right data tuple.</param>
 /// <returns>A data tuple.</returns>
 private static DataContainer JoinData(DataContainer leftData, DataContainer rightData)
 {
     return new DataContainer(
             new Tuple<IDChainDefinition, IDChainDefinition>(
                 leftData.IDChainDefinitions.Item1, 
                 rightData.IDChainDefinitions.Item1), 
             new Tuple<AExpressionDefinition, AExpressionDefinition>(
                 leftData.Operands.Item1, 
                 rightData.Operands.Item1), 
             new Tuple<AExpressionDefinition, AExpressionDefinition>(
                 leftData.Extraordinaries.Item1, 
                 rightData.Extraordinaries.Item1));
 }

        protected InquirerBase(DataContainer dataContainer, params InquirerBase[] dependencies)
        {
            if (dataContainer == null)
            {
                throw new StatisticsException(ExceptionMessages.Null_Data_Container, new ArgumentNullException("dataContainer"));
            }

            this.Container = dataContainer;

            AssertNotNull(dependencies);
            AssertUniqueDataContainer(dependencies);

            this.Id = Guid.NewGuid();
        }

        public static void DataBaseChunkCreation()
        {
            var time = Checks.ExecutionTimeCheck.DoCheck ( () => {
                                                          	Console.WriteLine("Creating DB...");
                                                          	var db = DataBase.Create( "testbase3" );
                                                          	User.User new_usr = User.User.New( "root", "12345678" );
                                                          	db.AddAccess( new_usr, Access.AccessLevel.ADMIN);
                                                          	var dc = new DataContainer( db, "DataC2" );
                                                          	db.AddNewDataContainer( dc, new_usr );
                                                          	db.chunk_manager.CreateChunk( db );
                                                          } );

            Console.WriteLine("Execution time, ms: "+time);
        }

 public void Save(String fileName)
 {
     try
     {
         XmlSerializer ser = new XmlSerializer(typeof(DataContainer));
         StreamWriter sw = new StreamWriter(fileName);
         DataContainer data = new DataContainer(mTradeDatas);
         ser.Serialize(sw, data);
         sw.Close();
     }
     catch (Exception ex)
     {
         Console.WriteLine(ex.Message);
     }
 }

        public NeuroNetsMainWindow()
        {
            InitializeComponent();

            Type ourtype = typeof(ActivateFunction); // Базовый тип
            Assembly ast = Assembly.GetAssembly(ourtype);
            Type[] types = ast.GetTypes();
            IEnumerable<Type> list = Assembly.GetAssembly(ourtype).GetTypes().Where(type => type.IsSubclassOf(ourtype));  // using System.Linq
            List<Type> aa = new List<Type>(list);

            foreach (Type itm in aa)
            {
                ActivateFunction af1 = (ActivateFunction)Activator.CreateInstance(itm);
                string name = af1.GetType().Name;
            }

            dbHandler = new DataBaseHandler();
            neuroNetsInfo = new DataContainer<List<string[]>>();
            learningInfo = new DataContainer<DataContainer<List<string>>>();

            dgwNeuroNets.ColumnHeadersDefaultCellStyle.Font = new Font("Book Antiqua", 9);
            dgwNeuroNets.Columns.Add("Name", "Имя");
            dgwNeuroNets.Columns.Add("TopologyTypeName", "Топология");
            dgwNeuroNets.Columns.Add("Task", "Задача");
            dgwNeuroNets.Columns.Add("NeuronCount", "Количество нейронов");
            dgwNeuroNets.Columns.Add("LayerCount", "Количество слоев");
            dgwNeuroNets.Columns.Add("ActivateFunction", "Активационная функция");

            dgwNeuronsInLayers.Columns.Add("Layer", "Слой");
            dgwNeuronsInLayers.Columns.Add("Neurons", "Число нейронов");

            dgwParamsAF.Columns.Add("Parameter", "Параметр");
            dgwParamsAF.Columns.Add("Value", "Значение");

            dgwNets.ColumnHeadersDefaultCellStyle.Font = new Font("Book Antiqua", 9);
            dgwNets.Columns.Add("NeuroNet", "Нейронная сеть");
            dgwNets.Columns.Add("TopologyTypeName", "Топология");
            dgwNets.Columns.Add("NeuronCount", "Количество нейронов");
            dgwNets.Columns.Add("LayerCount", "Количество слоев");

            dgwLA.ColumnHeadersDefaultCellStyle.Font = new Font("Book Antiqua", 9);
            dgwLA.Columns.Add("LearningAlgorithm", "Алгоритм обучения");
            dgwLA.Columns.Add("LearningStatus", "Статус обучения");

            LoadInformationForUsingNeuroNets();
            FillNeuroNetChangingTable();
        }