Exemplo n.º 1
0
 public static void На_ИмяТипа(ГруппаОбъектов класс, Строка имяТипа)
 {
     if (класс[0] == new Строка("тип")) // не корректое сравнение исправить, присваивает имя только типам
     {
         класс[1] = имяТипа;
     }
 }
Exemplo n.º 2
0
 public ПримитивИлиАдрес this[Строка ключ]
 {
     get
     {
         var индекс = Найти(ключ);
         if (индекс != null)
         {
             var объект = СПисокОбъектов[индекс.Value];
             объект.СобственныйАдресПримитива = new АдресВГруппе()
             {
                 НомерВГруппе = индекс.Value
             };
             return(объект);
         }
         return(new Пустота());
     }
     set
     {
         var индекс = Найти(ключ);
         if (индекс != null)
         {
             СПисокОбъектов[индекс.Value] = value;
             return;
         }
         СПисокИмен.Add(ключ);
         СПисокОбъектов.Add(value);
     }
 }
Exemplo n.º 3
0
 public Команда(string имя, params ПримитивИлиАдрес[] параметры)
 {
     Имя = new Строка(имя); Параметры = new ГруппаОбъектов();
     foreach (var пар in параметры)
     {
         Параметры.Добавить(пар);
     }
 }
Exemplo n.º 4
0
        public static ГруппаОбъектов СоздайЭкземплярКласса(ГруппаОбъектов класс)
        {
            var экземпляр = new ГруппаОбъектов();

            экземпляр[0] = new Строка("экземпляр типа (адрес типа имя)");        // это группа словосочетания 0=экземмпляр, 1 = вычисление (адрес типа- адрес имени типа)
            экземпляр[1] = класс;                                                // так можно найти тип
            //экземпляр содержит только значения полей
            экземпляр.Список.Capacity = ((ГруппаОбъектов)класс[2]).Список.Count; // пустые первое поле начинается с 1
            return(экземпляр);
        }
Exemplo n.º 5
0
        public static Строка Создать(string строка)
        {
            var этот = new Строка()
            {
                Значение = строка
            };

            Хранилище.Добавить(этот);
            return(этот);
        }
Exemplo n.º 6
0
 int?Найти(Строка ключ)
 {
     for (int и = 0; и < СПисокИмен.Count; и++)
     {
         if (СПисокИмен[и].Значение == ключ.Значение)
         {
             return(и);
         }
     }
     return(null);
 }
Exemplo n.º 7
0
        public static ПримитивИлиАдрес  СоздатьТип(Строка ИмяКласса)
        {
            var класс = new ГруппаОбъектов();

            var пара = new ГруппаОбъектов();

            пара.Добавить(new АдресВХранилище()
            {
                НомерВХранилище = 1
            });                           // Хранилище.Найти( "Имя") - это индекс фиксированный
            пара.Добавить(ИмяКласса);     // здесь содержиться имя класса-
            класс.Добавить(пара);
            return(класс);

            // скопировать пару можно, но дорого
        }
Exemplo n.º 8
0
        static КлассCSharp()
        {
            //создать группу типов
            // группа типов состоит из пар( ИмяТипа, адрес ОписанияТипа)
            // как найти адресОписания
            // в группе слов найти адрес искомого слова
            // группаТипов.Найти просмотреть все пары= если (первый член == искомому имени), то вернуть второй член
            // группа состоит из адресов
            // смотриться первый адрес, если это слово "команда" запускается метод, который берет имя из первого,  аргументы из второго адреса, возвращает в третий адрес
            // справочник методов в статическом словаре для простых методов типа "ВыполнитьПоследовательность методов" = если это метод -выполнить, группа содержит уже список адресов и примитивов
            // можно сделать примитив команда, который будет сразу выполняться !!!не стоит усложнит перенос проще проверить нулевой член группы, э тогда числа тоже придется составлять из групп
            //

            var группаТипов = new ГруппаОбъектов();

            группаТипов.Добавить(Строка.Создать("Тип")); // это группа адресов
            var адресГруппыТипов = Хранилище.Добавить(группаТипов);
        }
Exemplo n.º 9
0
        public void ЗапуститьСервер()
        {
            // регистрация в службе TCPIP
            Слушатель = new TcpListener(IPAddress.Parse(АдресТСП.IPАдрес), АдресТСП.порт);

            //var задача = Слушатель.AcceptTcpClientAsync();
            //object состояние = null;
            //var результатВызова = Слушатель.BeginAcceptTcpClient(обратныйВызов, состояние);


            Слушатель.Start();

            Активен = true;

            while (Активен) //цикл обработки подключений
            {
                // ожидание подключения
                состояние = "ожидание подключения";
                сокет     = Слушатель.Server;
                //сокет.Listen(1);

                //ЦиклОбработкиСоединений();
                состояние = "новое входящее соединение установлено"; // событие

                клиент = Слушатель.AcceptTcpClient();                //  получение первого

                состояние = "новое входящее соединение установлено"; // событие
                //Начало сеанса

                var адресПодключившегося = (IPEndPoint)клиент.Client.RemoteEndPoint;
                var IP = адресПодключившегося.Address;    // здесь можно отфильтровать входящие соединения

                NetworkStream поток = клиент.GetStream(); //не очень удобный вариант совмещение входящего и исходящего буфера

                var читатель = new BinaryReader(поток);

                // получить команду
                // протокол обмена сообщениями
                состояние = "получение сообщениий";
                var протокол = ПримитивИлиАдрес.Создать(поток);         // получается Метка протокола общения, например "http" или описанный ниже, протокол это набор методов по обработке получаемых байт (распознования их)
                                                                        // список поддерживаемых команд, сценарии обмена сообщениями (в том числе команды)

                var команда = (Команда)ПримитивИлиАдрес.Создать(поток); //здесь придти может любой примитив

                состояние = "получение закончено, обработка команды";
                ПримитивИлиАдрес результат = new Строка()
                {
                    Значение = "ошибка"
                };
                if (команда.Имя.Значение == "ТипОбъекта")
                {
                    результат = new Строка(ОбслуживаемыйПРимитив.GetType().Name);
                }

                if (команда.Имя.Значение == "ДайОбъект") // это уже внутренние команды Сервера
                {
                    результат = ОбслуживаемыйПРимитив.ВыполнитьКоманду(команда);
                }
                if (команда.Имя.Значение == "НаОбъект")
                {
                    // если тип пришедшего примитива совпадает с типом местного, то (а так вместо Целого здесь появиться что угодно )
                    // по идее здесь нужно создать новый Примитив и воостановить тот что передан в Параметрах
                    // АдресОбсуживаемогоПРимитваВКуче содержит эту команду "НаЗначение" если там ЦелоеВфайле
                    ОбслуживаемыйПРимитив = команда.Параметры[0];
                    ОбслуживаемыйПРимитив.ВыполнитьКоманду(команда);// = команда.Параметры[0]; //здесь надо отдавать команду , переадресовывать команду
                    // так можно запустить любую команду, хотя там где потоки они не запустяться, запустяться только 2 дай/на и запустить сервер
                    // можно сделать список команд из делегатов, лучше сделать команды примитивы, которые будут сохраняться и востанавливаться
                }


                //выполнить команду - это сообщение появляется если это уже не примитив
                if (команда.Имя.Значение == "ВыполнитьКоманду")
                {
                    результат = ОбслуживаемыйПРимитив.ВыполнитьКоманду((Команда)команда.Параметры[0]);
                }
                // если это группа то дайОбъект дополняется  ДайОбъект(номер), ДайЧастьОбъектов (начало, конец)
                // НаОбъет(номер, объект) На ЧастьОбъектов(начало, конец, группаОбъектов) - это команды к Группе, не нужны
                // есть еще потоки ДайДанныеПотока - здесь надо связь сохранить и даже поддерживать отправлять данные и прослушивать паралельно входящие команды
                // хотя в команду ДанныеПотока передается адрес куда давать или сам поток и там в отдельном логпроцессе идет передача
                // ВОЗМОЖНО нужен другой объект-сервер специально для этого

                // это сообщение появляется когда у активности одновременно более одной входящей связи
                // если связь одна, то активность блокирована- никто не может внести изменение
                //
                if (команда.Имя.Значение == "СообщиОбИзмененииОбъекта") // добавь меня к событию изменения объекта , удали меня из подписки
                {
                    var обратныйАдрес = команда.Параметры[0];
                    ПодписчсикиНаСобытия.Add(обратныйАдрес);//+ сохранить запускаемое действие, действие простейшее = установить связь и все = сигнал = преывание
                    // можно добавить сюда клиент, поток
                    // режимы: сохранять связь, разорвать связь (тогда удаленный должен быть сервером)
                    // значение примитива меняется через группу, группа вносит изменение в элемент

                    результат = new Строка("Готово");
                }

                // попытаться отправить результат (связь может быть уже потеряна)отправить результат
                состояние = "передача";
                результат.СохранисьВ(поток);

                // завершить сеанс - сеанс может быть продлен, тогда нужны внутренние команды начала сеанса и конца (конец может быть + истечение времени ожидания)
                клиент.Close();
            }
            // закрывается процессор
        }
Exemplo n.º 10
0
        public static void Тест()
        {
            var класс = new Класс()
            {
                Имя = "Пробный"
            };

            класс.ПоляИлиМетоды.Add("Поле1", new object());
            класс.ПоляИлиМетоды.Add("Метод", new План());
            класс.ПоляИлиМетоды.Add("Метод2", new Сложение());

            класс.Свойства[0] = new Строка("Имя класса");
            var поле1 = new ГруппаОбъектов();

            класс.Свойства[1] = поле1;
            поле1[0]          = new Строка("это Поле");
            поле1[1]          = new Строка("имяПоля1");
            поле1[2]          = new Строка("ТипаЗначения"); //может быть не опрееделен, может иметь группу типов
            поле1[3]          = new Строка("ЗначениеПоля");

            var класс2 = new ГруппаОбъектов();          // это класс

            класс2[0] = new Строка("Это тип объектов"); // или адрес на строку что это Тип. Описание типа это группа которая может иметь группу полей и группу методов
            класс2[1] = new Строка("Имя типа (Целое)"); // имеет имя
            класс2[2] = поле1;                          // имеет поле

            var тип = new ГруппаОбъектов();
            var адресОписанияТипов = Хранилище.Добавить(тип);

            тип[0] = new Строка("Это описание типов");
            тип[1] = new Строка("имеет список полей (создать ГруппуОбъектов с именем список полей)");; // это список полей
            ((ГруппаОбъектов)тип[1])[0] = new Строка("это список полей");
            тип[2] = new ГруппаОбъектов();                                                             // это список методов
            ((ГруппаОбъектов)тип[2])[0] = new Строка("это список методов");

            //клонирование типа
            // создать новый тип
            var класс3 = new ГруппаОбъектов();

            класс3[0] = адресОписанияТипов;
            for (int индекс = 1; индекс < тип.Список.Count; индекс++)
            {
                класс3[индекс] = тип[индекс].Копировать();
            }


            var локальныйСписокТипов = new ГруппаОбъектов(); // сюда добавляются типы

            локальныйСписокТипов[0] = new Строка("Это локальный список типов");
            локальныйСписокТипов.Добавить(класс2);



            var матрицаТипа  = new ГруппаОбъектов();
            var адресматрицы = Хранилище.Добавить(матрицаТипа);

            матрицаТипа[0] = new Строка("это матрица тип");
            матрицаТипа[1] = new Строка("Имя типа");
            матрицаТипа[2] = new ГруппаОбъектов();;                // это список полей
            ((ГруппаОбъектов)матрицаТипа[2])[0] = new Строка("это список полей");
            матрицаТипа[3] = new ГруппаОбъектов();                 // это список методов
            ((ГруппаОбъектов)матрицаТипа[3])[0] = new Строка("это список методов");
            матрицаТипа[4] = адресматрицы;                         //new Строка("Здесь должен быть адрес матрицы");

            var класс4 = (ГруппаОбъектов)матрицаТипа.Копировать(); //клонировать это копирование структуры, но не значений, здесь это клонирование

            класс4[0] = матрицаТипа;                               // в 0 хранится родитель

            var адресКласс4 = СоздатьТип("Бар");                   // создание без матрицы

            На_ИмяТипа(класс4, new Строка("Бар"));                 //

            Класс.ДобавитьПоле(адресКласс4, Класс.СоздатьПоле("ЦенаОткрытия", new АдресВХранилище()));

            var экземпляр = Класс.СоздайЭкземплярКласса(класс4);

            var значениеПоля = Класс.ДайЗначение(экземпляр, "ЦенаОткрытия");

            // выделение в независимый объект это перемещение из группыОбъектов в Хранилище (или другую группу)
            // вместо объекта там появляется адрес объекта
            // включение в группуобъектов означает что команды посылаются от группы к членам, но не оборот
            // часть объектов может быть помечена как некопируемая
            // команды всегда отдаются активности(процессору), данные пассивны Процессор Сформируй (рез)бар (вход данные) из списка тиков за интервал И
            // (кому) список тиков (команда)( сформируй (рез) бар ) (параметр) за интервал - Это не корректное выражение, может (активнсть хранящая тики) правильно
            // (рез)бар (ком=страдательый залог) сформируйся (параметр) из списка тиков (парметр) за интервал И - здесь бар превращается в живое существо
            // в проге мы оперируем экземплярами: бар это сокращение от бар бар1 В определении достаточно бар, при исполнении получается конкретный бар1
            // все ООП бред!!!
            // програмирование надо вести в форме диалогов , т.к.
            // бар невсегда получается в форме результата, может быть и ошибка, программа всегда пишется будто нет ошибок

            var метод = new ГруппаОбъектов
            {
                [0]  = new Строка("метод"),
                [1]  = new Строка("Имя метода"),
                [2]  = new ГруппаОбъектов(),    //определение параметров Параметры иогут иметь ссылки на этот метод и название у метода тогда меняется
                [21] = new Адрес(),             // адрес типа , там еще есть параметры или конкретного экземпляра данные там
                [3]  = new ПримитивИлиАдрес(),  // определение типа результата
                [4]  = new АппаратноеДействие() // список действий
            };
            // метод состоит из имени, списка параметров, возврат значений, список действий
            // один из параметров адрес экземпляра типа, все специальные параметры владеют этим методом (целое число как правило не является владельцем методов)
            // определение метода сигнатура



            var действие = (План)метод[4]; //=Действие

            действие.Выполнить(null);      // сдесь в качестве параметра надо задавать список аргументов

            //Создание новой модели (Группы методов и описаний структуры - должна быть замкнутая структура, полная подмена , нужно использовать только ее)
            // эти методы применимы только к данной структуре
            // эти методы позволяют убрать самоописание из структуры, т.к. заранее знают, что где
            // это еще перевод в понятные для внутреннего процесора команды
            // ЭТО ЕЩЕ ДАННЫЕ ДЛЯ ПРЕПРОЦЕССОРА который сжимает данные заменяет имена на адреса,
            //                                          проводит проверку соотвествия типов после чего выкидывает их из методов,
            //                                          заменяет вычислимые данные результатами

            var модель = new ГруппаОбъектов
            {
                [0] = new АппаратноеДействие()
                {
                    Метод = typeof(Класс).GetMethod("СоздатьТип"), Имя = new Строка("Создать тип")
                },
                [1] = new АппаратноеДействие()
                {
                    Метод = typeof(Класс).GetMethod("ЧтоЭто")
                },
                [2] = new АппаратноеДействие()
                {
                    Метод = typeof(Класс).GetMethod("Дай_ИмяТипа")
                },
                [3] = new АппаратноеДействие()
                {
                    Метод = typeof(Класс).GetMethod("СоздатьПоле")
                },
                [4] = new АппаратноеДействие()
                {
                    Метод = typeof(Класс).GetMethod("СоздатьЭкземплярТипа")
                },
                [5] = new АппаратноеДействие()
                {
                    Метод = typeof(Класс).GetMethod("ПрисвоитьЗначениеПолюЭкземпляра")
                },
                [6] = new АппаратноеДействие()
                {
                    Метод = typeof(Класс).GetMethod("ВыполнитьМетод")
                }
            };

            // Описание сценариев общения (шаблон диалога)- метод программирования
            // А: Вася? - установление связи
            // Б: Да        / Нет                   /Ну
            // А: Ты кто?   /Пардон, конец связи    / Что ну?
            // Б: бот                               /Ну Вася
        }
Exemplo n.º 11
0
 public override ПримитивИлиАдрес Восстановить(Stream поток)
 {
     Имя       = (Строка)ПримитивИлиАдрес.Создать(поток);
     Параметры = (ГруппаОбъектов)ПримитивИлиАдрес.Создать(поток);
     return(this);
 }
Exemplo n.º 12
0
 public Связь ДайСвязьПоИмени(Строка имяСвязи)
 {
     return((Связь)СписокСвязей.Список.Find(связь => ((Связь)связь).ИмяСвязи == имяСвязи.Значение));
 }