public static ЦелоеЧисло Создать()
{
var этот = new ЦелоеЧисло();
var адрес = Хранилище.Добавить(этот);
return(этот);
}
public static СтрокаЮникода Создать(string строка)
{
var этот = new СтрокаЮникода()
{
Значение = строка
};
Хранилище.Добавить(этот);
return(этот);
}
// как его использовать
//
public static void Тест()
{
var адресДХ = Хранилище.Добавить(new ДисковоеХранилище()
{
ИмяФайла = "имя"
}); // теперь Дисковое хранилище может восстанавливается открываться
var хр = ((ДисковоеХранилище)адресДХ.АдресВКучеПамяти());
хр.Открыть();
var д = new ДисковоеХранилище()
{
ИмяФайла = "дисковое хранилище"
};
д.Создать();
var адресЦелого = д.ДобавитьВКонец(new ЦелоеЧисло(10));
var целое = д.СоздатьКопиюОбъект(адресЦелого);
var проксиЦелого = д.ДайПроксиОбъекта(0);
проксиЦелого.ИзменитьИзнутри(new ЦелоеЧисло(100));
var адресСтроки2 = д.ДобавитьВКонец(new СтрокаЮникода()
{
Значение = "с"
});
var строкаПрочитнная = д.СоздатьКопиюОбъект(адресСтроки2);
var адресСтроки3 = д.ДобавитьВКонец(new СтрокаЮникода()
{
Значение = "Строка"
});
var адресСтроки = хр.ДобавитьВКонец(new СтрокаЮникода()
{
Значение = "строка на диске"
}); // строка не добавляется в Память, только на Диск
Хранилище.Добавить(адресСтроки); // теперь можно по адресу добраться до самой строки
//примитивы должны сохраняться вместе с адресом,иначе они будут потеряны, Дисковое хранилище можно полностью прочитать, последовательно и просмотреть все объекты
// важна замена объекта по адресу, либо перезапись, либо перенаправление. Перезапись предполагает резервирование дополнительного места (байтов), перенаправление, должно содержать
//новый адрес, который должен уместиться в старое пространство, т.е. строка не может быть меньше 4 байт(минимального адреса)
var копияСтрокиВПамяти = адресСтроки.АдресВКучеПамяти();
// теперь добавим адрес строки на диск
var адресАдресаСтроки = хр.ДобавитьВКонец(адресСтроки); // теперь по этому адресу храниться (1.номер ДХ в Хранилище и 2.номер строки в ДХ) 1 здеь лишниее
//похоже адрес в файле не должен содержать адреса ДХ в хранилище- это уже
}
static КлассCSharp()
{
//создать группу типов
// группа типов состоит из пар( ИмяТипа, адрес ОписанияТипа)
// как найти адресОписания
// в группе слов найти адрес искомого слова
// группаТипов.Найти просмотреть все пары= если (первый член == искомому имени), то вернуть второй член
// группа состоит из адресов
// смотриться первый адрес, если это слово "команда" запускается метод, который берет имя из первого, аргументы из второго адреса, возвращает в третий адрес
// справочник методов в статическом словаре для простых методов типа "ВыполнитьПоследовательность методов" = если это метод -выполнить, группа содержит уже список адресов и примитивов
// можно сделать примитив команда, который будет сразу выполняться !!!не стоит усложнит перенос проще проверить нулевой член группы, э тогда числа тоже придется составлять из групп
//
var группаТипов = new ГруппаОбъектов();
группаТипов.Добавить(Строка.Создать("Тип")); // это группа адресов
var адресГруппыТипов = Хранилище.Добавить(группаТипов);
}
//возврат должен быть адрес
// это описание типа или описание экземпляров типов
// список методов одинаков для всех экземпляров
public static Адрес СоздатьТип(string имя)
{
var Тип = new ГруппаОбъектов
{
[0] = new Строка("тип"), //это общее для группы схожих объектов , если объекту задать вопрос (провести измерение) объект переадресует этот вопрос к этому адресу
[1] = new Строка(имя), // это по сути описание словосочетания и одновременно матрица для экземпляров типа (объектов)
[2] = new ГруппаОбъектов {
[0] = new Строка("список полей")
}, // это список полей "имеет" эта группа типа "список" т.е. содержит однотипные объекты типа "поле", т.е. тип "поле" можно убрать
[3] = new ГруппаОбъектов {
[0] = new Строка("список методов")
} // это список методов "имеет"
};
// создание Списка например типов, позволяет исключить [0]-ой элемент(самоописания), добавление туда группы авоматом делает ее "типом",это группа (самого типа) без самописания
// Куча C# это группа экземпляров. И есть отдельная группа типов
// это метод минимизации ресурсов, выделение общего объекта и объединение в группу с усечением общего элемента
return(Хранилище.Добавить(Тип));
}
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("ВыполнитьМетод")
}
};
// Описание сценариев общения (шаблон диалога)- метод программирования
// А: Вася? - установление связи
// Б: Да / Нет /Ну
// А: Ты кто? /Пардон, конец связи / Что ну?
// Б: бот /Ну Вася
}