public static void На_ИмяТипа(ГруппаОбъектов класс, Строка имяТипа)
{
if (класс[0] == new Строка("тип")) // не корректое сравнение исправить, присваивает имя только типам
{
класс[1] = имяТипа;
}
}
public ПримитивИлиАдрес this[Строка ключ]
{
get
{
var индекс = Найти(ключ);
if (индекс != null)
{
var объект = СПисокОбъектов[индекс.Value];
объект.СобственныйАдресПримитива = new АдресВГруппе()
{
НомерВГруппе = индекс.Value
};
return(объект);
}
return(new Пустота());
}
set
{
var индекс = Найти(ключ);
if (индекс != null)
{
СПисокОбъектов[индекс.Value] = value;
return;
}
СПисокИмен.Add(ключ);
СПисокОбъектов.Add(value);
}
}
public Команда(string имя, params ПримитивИлиАдрес[] параметры)
{
Имя = new Строка(имя); Параметры = new ГруппаОбъектов();
foreach (var пар in параметры)
{
Параметры.Добавить(пар);
}
}
public static ГруппаОбъектов СоздайЭкземплярКласса(ГруппаОбъектов класс)
{
var экземпляр = new ГруппаОбъектов();
экземпляр[0] = new Строка("экземпляр типа (адрес типа имя)"); // это группа словосочетания 0=экземмпляр, 1 = вычисление (адрес типа- адрес имени типа)
экземпляр[1] = класс; // так можно найти тип
//экземпляр содержит только значения полей
экземпляр.Список.Capacity = ((ГруппаОбъектов)класс[2]).Список.Count; // пустые первое поле начинается с 1
return(экземпляр);
}
public static Строка Создать(string строка)
{
var этот = new Строка()
{
Значение = строка
};
Хранилище.Добавить(этот);
return(этот);
}
int?Найти(Строка ключ)
{
for (int и = 0; и < СПисокИмен.Count; и++)
{
if (СПисокИмен[и].Значение == ключ.Значение)
{
return(и);
}
}
return(null);
}
public static ПримитивИлиАдрес СоздатьТип(Строка ИмяКласса)
{
var класс = new ГруппаОбъектов();
var пара = new ГруппаОбъектов();
пара.Добавить(new АдресВХранилище()
{
НомерВХранилище = 1
}); // Хранилище.Найти( "Имя") - это индекс фиксированный
пара.Добавить(ИмяКласса); // здесь содержиться имя класса-
класс.Добавить(пара);
return(класс);
// скопировать пару можно, но дорого
}
static КлассCSharp()
{
//создать группу типов
// группа типов состоит из пар( ИмяТипа, адрес ОписанияТипа)
// как найти адресОписания
// в группе слов найти адрес искомого слова
// группаТипов.Найти просмотреть все пары= если (первый член == искомому имени), то вернуть второй член
// группа состоит из адресов
// смотриться первый адрес, если это слово "команда" запускается метод, который берет имя из первого, аргументы из второго адреса, возвращает в третий адрес
// справочник методов в статическом словаре для простых методов типа "ВыполнитьПоследовательность методов" = если это метод -выполнить, группа содержит уже список адресов и примитивов
// можно сделать примитив команда, который будет сразу выполняться !!!не стоит усложнит перенос проще проверить нулевой член группы, э тогда числа тоже придется составлять из групп
//
var группаТипов = new ГруппаОбъектов();
группаТипов.Добавить(Строка.Создать("Тип")); // это группа адресов
var адресГруппыТипов = Хранилище.Добавить(группаТипов);
}
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();
}
// закрывается процессор
}
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("ВыполнитьМетод")
}
};
// Описание сценариев общения (шаблон диалога)- метод программирования
// А: Вася? - установление связи
// Б: Да / Нет /Ну
// А: Ты кто? /Пардон, конец связи / Что ну?
// Б: бот /Ну Вася
}
public override ПримитивИлиАдрес Восстановить(Stream поток)
{
Имя = (Строка)ПримитивИлиАдрес.Создать(поток);
Параметры = (ГруппаОбъектов)ПримитивИлиАдрес.Создать(поток);
return(this);
}
public Связь ДайСвязьПоИмени(Строка имяСвязи)
{
return((Связь)СписокСвязей.Список.Find(связь => ((Связь)связь).ИмяСвязи == имяСвязи.Значение));
}
