https://m.vk.com/@-218286812-prakticheskaya-rabota...

python
import os, zipfile, textwrap, json, datetime, pathlib, shutil, io, sys

python
base_dir = "/mnt/data/LabProjects"
if os.path.exists(base_dir):
    shutil.rmtree(base_dir)
os.makedirs(base_dir)

def write_file(rel_path, content):
    full_path = os.path.join(base_dir, rel_path)
    os.makedirs(os.path.dirname(full_path), exist_ok=True)
    with open(full_path, "w", encoding="utf-8") as f:
        f.write(content)

net_csproj = """<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>
"""

# Lab1
lab1_dir = "Lab1_GeometryInheritance"
write_file(f"{lab1_dir}/{lab1_dir}.csproj", net_csproj)

figure_cs = """
using System;

namespace Lab1_GeometryInheritance;

public abstract class Figure : IComparable<Figure>
{
    public string Name { get; protected set; } = string.Empty;
    public abstract double GetArea();
    public abstract double GetPerimeter();
    public virtual void PrintInfo()
    {
        Console.WriteLine($"{Name}: Area={GetArea():F2}, Perimeter={GetPerimeter():F2}");
    }
    public int CompareTo(Figure? other)
    {
        if (other is null) return 1;
        return GetArea().CompareTo(other.GetArea());
    }
}
"""
write_file(f"{lab1_dir}/Figure.cs", figure_cs)

rect_cs = """
namespace Lab1_GeometryInheritance;

public class Rectangle : Figure
{
    public double Width { get; }
    public double Height { get; }
    public Rectangle(double width, double height)
    {
        Name = "Rectangle";
        Width = width;
        Height = height;
    }
    public override double GetArea() => Width * Height;
    public override double GetPerimeter() => 2 * (Width + Height);
}
"""
write_file(f"{lab1_dir}/Rectangle.cs", rect_cs)

circle_cs = """
namespace Lab1_GeometryInheritance;

public class Circle : Figure
{
    public double Radius { get; }
    public Circle(double r)
    {
        Name = "Circle";
        Radius = r;
    }
    public override double GetArea() => Math.PI * Radius * Radius;
    public override double GetPerimeter() => 2 * Math.PI * Radius;
}
"""
write_file(f"{lab1_dir}/Circle.cs", circle_cs)

square_cs = """
namespace Lab1_GeometryInheritance;

public class Square : Figure
{
    public double Side { get; }
    public Square(double side)
    {
        Name = "Square";
        Side = side;
    }
    public override double GetArea() => Side * Side;
    public override double GetPerimeter() => 4 * Side;
}
"""
write_file(f"{lab1_dir}/Square.cs", square_cs)

triangle_cs = """
using System;

namespace Lab1_GeometryInheritance;

public class Triangle : Figure
{
    public double A { get; }
    public double B { get; }
    public double C { get; }
    public Triangle(double a, double b, double c)
    {
        if (a + b <= c || a + c <= b || b + c <= a)
            throw new ArgumentException("Invalid triangle sides");
        Name = "Triangle";
        A = a; B = b; C = c;
    }
    public override double GetPerimeter() => A + B + C;
    public override double GetArea()
    {
        double p = GetPerimeter() / 2;
        return Math.Sqrt(p * (p - A) * (p - B) * (p - C));
    }
}
"""
write_file(f"{lab1_dir}/Triangle.cs", triangle_cs)

trapezoid_cs = """
namespace Lab1_GeometryInheritance;

public class Trapezoid : Figure
{
    public double BaseA { get; }
    public double BaseB { get; }
    public double Height { get; }
    public double SideC { get; }
    public double SideD { get; }
    public Trapezoid(double a, double b, double h, double c, double d)
    {
        Name = "Trapezoid";
        BaseA = a; BaseB = b; Height = h; SideC = c; SideD = d;
    }
    public override double GetArea() => (BaseA + BaseB) * Height / 2;
    public override double GetPerimeter() => BaseA + BaseB + SideC + SideD;
}
"""
write_file(f"{lab1_dir}/Trapezoid.cs", trapezoid_cs)

program1 = """
using Lab1_GeometryInheritance;
using System.Collections.Generic;

var figures = new List<Figure>
{
    new Rectangle(3,4),
    new Circle(2),
    new Square(3),
    new Triangle(3,4,5),
    new Trapezoid(3,5,4,4,4)
};

figures.Sort();

foreach(var f in figures)
    f.PrintInfo();
"""
write_file(f"{lab1_dir}/Program.cs", program1)

# Lab2
lab2_dir = "Lab2_EditionInheritance"
write_file(f"{lab2_dir}/{lab2_dir}.csproj", net_csproj)

edition_cs = """
using System;

namespace Lab2_EditionInheritance;

public abstract class Edition : IComparable<Edition>
{
    public string Title { get; protected set; } = string.Empty;
    public string AuthorSurname { get; protected set; } = string.Empty;
    public int Year { get; protected set; }

    public abstract void PrintInfo();

    public int CompareTo(Edition? other)
        => string.Compare(AuthorSurname, other?.AuthorSurname, StringComparison.OrdinalIgnoreCase);
}
"""
write_file(f"{lab2_dir}/Edition.cs", edition_cs)

book_cs = """
namespace Lab2_EditionInheritance;

public class Book : Edition
{
    public string Publisher { get; }
    public Book(string title, string authorSurname, int year, string publisher)
    {
        Title = title; AuthorSurname = authorSurname; Year = year; Publisher = publisher;
    }
    public override void PrintInfo()
    {
        Console.WriteLine($"Book: {Title}, {AuthorSurname}, {Year}, {Publisher}");
    }
}
"""
write_file(f"{lab2_dir}/Book.cs", book_cs)

article_cs = """
namespace Lab2_EditionInheritance;

public class Article : Edition
{
    public string Journal { get; }
    public int Number { get; }
    public Article(string title, string authorSurname, string journal, int number, int year)
    {
        Title = title; AuthorSurname = authorSurname; Journal = journal; Number = number; Year = year;
    }
    public override void PrintInfo()
    {
        Console.WriteLine($"Article: {Title}, {AuthorSurname}, {Journal} №{Number}, {Year}");
    }
}
"""
write_file(f"{lab2_dir}/Article.cs", article_cs)

online_cs = """
namespace Lab2_EditionInheritance;

public class OnlineResource : Edition
{
    public string Url { get; }
    public string Annotation { get; }
    public OnlineResource(string title, string authorSurname, string url, string annotation, int year)
    {
        Title = title; AuthorSurname = authorSurname; Url = url; Annotation = annotation; Year = year;
    }
    public override void PrintInfo()
    {
        Console.WriteLine($"Online: {Title}, {AuthorSurname}, {Url}, {Year}\\n{Annotation}");
    }
}
"""
write_file(f"{lab2_dir}/OnlineResource.cs", online_cs)

program2 = """
using Lab2_EditionInheritance;
using System.Collections.Generic;

var list = new List<Edition>
{
    new Book("CLR via C#","Richter",2024,"MS Press"),
    new Article("Quantum", "Feynman", "PhysicsToday", 12, 1964),
    new OnlineResource("ChatGPT Docs","OpenAI","https://openai.com","LLM docs",2025)
};

list.Sort();
foreach(var e in list) e.PrintInfo();
"""
write_file(f"{lab2_dir}/Program.cs", program2)

# Lab3
lab3_dir = "Lab3_TransportInheritance"
write_file(f"{lab3_dir}/{lab3_dir}.csproj", net_csproj)

transport_cs = """
using System;

namespace Lab3_TransportInheritance;

public abstract class Transport : IComparable<Transport>
{
    public string Brand { get; protected set; } = string.Empty;
    public string Number { get; protected set; } = string.Empty;
    public int MaxSpeed { get; protected set; }

    public abstract int GetLoadCapacity();

    public virtual void PrintInfo()
    {
        Console.WriteLine($"{Brand} ({Number}) speed={MaxSpeed} load={GetLoadCapacity()}");
    }

    public int CompareTo(Transport? other)
        => string.Compare(Brand, other?.Brand, StringComparison.OrdinalIgnoreCase);
}
"""
write_file(f"{lab3_dir}/Transport.cs", transport_cs)

car_cs = """
namespace Lab3_TransportInheritance;

public class Car : Transport
{
    public int Seats { get; }
    public Car(string brand,string number,int speed,int seats)
    {
        Brand=brand;Number=number;MaxSpeed=speed;Seats=seats;
    }
    public override int GetLoadCapacity()=>Seats*75; // approx kg per seat
}
"""
write_file(f"{lab3_dir}/Car.cs", car_cs)

motor_cs = """
namespace Lab3_TransportInheritance;

public class Motorcycle : Transport
{
    public bool HasSideCar { get; }
    private int baseCapacity;
    public Motorcycle(string brand,string number,int speed,bool sidecar)
    {
        Brand=brand;Number=number;MaxSpeed=speed;HasSideCar=sidecar;
        baseCapacity=150;
    }
    public override int GetLoadCapacity()=>HasSideCar?baseCapacity:0;
}
"""
write_file(f"{lab3_dir}/Motorcycle.cs", motor_cs)

truck_cs = """
namespace Lab3_TransportInheritance;

public class Truck : Transport
{
    public int Capacity { get; private set; }
    public bool HasTrailer { get; }
    public Truck(string brand,string number,int speed,int capacity,bool trailer)
    {
        Brand=brand;Number=number;MaxSpeed=speed;HasTrailer=trailer;
        Capacity=trailer?capacity*2:capacity;
    }
    public override int GetLoadCapacity()=>Capacity;
}
"""
write_file(f"{lab3_dir}/Truck.cs", truck_cs)

program3 = """
using Lab3_TransportInheritance;

var fleet = new List<Transport>
{
    new Car("Toyota","A123BC",180,5),
    new Motorcycle("Harley","M777AA",160,false),
    new Truck("Volvo","T999TT",120,8000,true)
};

fleet.Sort();
foreach(var t in fleet) t.PrintInfo();
"""
write_file(f"{lab3_dir}/Program.cs", program3)

# Lab6 - WinForms1 sample
lab6_dir = "Lab6_WinForms1"
write_file(f"{lab6_dir}/{lab6_dir}.csproj", net_csproj.replace("</Project>","  <UseWindowsForms>true</UseWindowsForms>\n</Project>"))

prog6 = """
using System;
using System.Drawing;
using System.Windows.Forms;

namespace Lab6_WinForms1;

static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        Application.Run(new MainForm());
    }
}

public class MainForm : Form
{
    Point dragStart;
    public MainForm()
    {
        Text = "Hello World!";
        BackColor = Color.Aquamarine;
        Width = 250;
        Height = 250;
        FormBorderStyle = FormBorderStyle.None;

        var closeBtn = new Button{Text="Закрыть"};
        closeBtn.Size = new Size(100,30);
        closeBtn.Location = new Point((Width-closeBtn.Width)/2,(Height-closeBtn.Height)/2);
        closeBtn.Click += (_,__)=>Close();
        Controls.Add(closeBtn);

        Load += (_,__)=>
        {
            var path = new System.Drawing.Drawing2D.GraphicsPath();
            path.AddEllipse(0,0,Width,Height);
            Region = new Region(path);
        };

        MouseDown += (s,e)=>{ if(e.Button==MouseButtons.Left) dragStart=e.Location; };
        MouseMove += (s,e)=>{
            if(e.Button==MouseButtons.Left){
                var delta = new Point(e.X-dragStart.X,e.Y-dragStart.Y);
                Location = new Point(Location.X+delta.X,Location.Y+delta.Y);
            }
        };
    }
}
"""
write_file(f"{lab6_dir}/Program.cs", prog6)

# Lab7 - WinForms2 sample focusing on TableLayoutPanel demonstration
lab7_dir = "Lab7_WinForms2"
write_file(f"{lab7_dir}/{lab7_dir}.csproj", net_csproj.replace("</Project>","  <UseWindowsForms>true</UseWindowsForms>\n</Project>"))

prog7 = """
using System;
using System.Drawing;
using System.Windows.Forms;

namespace Lab7_WinForms2;

static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        Application.Run(new DemoForm());
    }
}

public class DemoForm : Form
{
    public DemoForm()
    {
        Text="WinForms Layout Demo";
        Size=new Size(600,400);

        var tlp = new TableLayoutPanel
        {
            Dock = DockStyle.Fill,
            ColumnCount = 3,
            RowCount = 3
        };
        for(int i=0;i<3;i++){
            tlp.ColumnStyles.Add(new ColumnStyle(SizeType.Percent,33.33f));
            tlp.RowStyles.Add(new RowStyle(SizeType.Percent,33.33f));
        }

        for(int r=0;r<3;r++)
            for(int c=0;c<3;c++){
                var btn=new Button{Text=$\"{r},{c}\", Dock=DockStyle.Fill};
                tlp.Controls.Add(btn,c,r);
            }

        Controls.Add(tlp);
    }
}
"""
write_file(f"{lab7_dir}/Program.cs", prog7)

# Lab4 - Polymorphism (draw figures)
lab4_dir = "Lab4_Polymorphism"
write_file(f"{lab4_dir}/{lab4_dir}.csproj", net_csproj.replace("</Project>","  <UseWindowsForms>true</UseWindowsForms>\n</Project>"))

figure4_cs = """
using System.Drawing;

namespace Lab4_Polymorphism;

public abstract class Figure
{
    public string Name { get; init; } = string.Empty;
    public Color Color { get; init; } = Color.Black;
    public Point Position { get; init; }

    public Figure(string name, Color color, Point position)
        => (Name, Color, Position) = (name, color, position);

    public abstract double GetArea();
    public abstract Point GetCenter();
    public abstract void Draw(Graphics g);
}
"""
write_file(f"{lab4_dir}/Figure.cs", figure4_cs)

rect4_cs = """
using System.Drawing;
namespace Lab4_Polymorphism;

public class RectangleFigure : Figure
{
    public int Width { get; }
    public int Height { get; }
    public RectangleFigure(Color color, Point pos,int width,int height)
        : base("Rectangle",color,pos) => (Width,Height)=(width,height);

    public override double GetArea()=>Width*Height;
    public override Point GetCenter()=> new(Position.X+Width/2, Position.Y+Height/2);
    public override void Draw(Graphics g)
    {
        using var pen=new Pen(Color,2);
        g.DrawRectangle(pen,Position.X,Position.Y,Width,Height);
        using var brush = new SolidBrush(Color.FromArgb(40,Color));
        g.FillRectangle(brush,Position.X,Position.Y,Width,Height);
        g.DrawString($"{GetArea():F0}", SystemFonts.CaptionFont, Brushes.Black, GetCenter());
    }
}
"""
write_file(f"{lab4_dir}/RectangleFigure.cs", rect4_cs)

prog4 = """
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Windows.Forms;
using Lab4_Polymorphism;

namespace Lab4_Polymorphism;

static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        Application.Run(new FigureForm());
    }
}

public class FigureForm : Form
{
    readonly List<Figure> figures = new()
    {
        new RectangleFigure(Color.DarkRed,new Point(30,30),50,50),
        new RectangleFigure(Color.Green,new Point(100,100),100,100),
        new RectangleFigure(Color.Blue,new Point(200,200),120,60)
    };

    public FigureForm()
    {
        Text="Лабораторная №3 – Полиморфизм";
        ClientSize=new Size(800,600);
        StartPosition=FormStartPosition.CenterScreen;
        Paint+=OnPaint;
    }

    void OnPaint(object? sender, PaintEventArgs e)
    {
        foreach(var f in figures)
            f.Draw(e.Graphics);
    }
}
"""
write_file(f"{lab4_dir}/Program.cs", prog4)

# Create zip
zip_path = "/mnt/data/LabProjects.zip"
with zipfile.ZipFile(zip_path,"w",zipfile.ZIP_DEFLATED) as zf:
    for root, dirs, files in os.walk(base_dir):
        for file in files:
            full = os.path.join(root,file)
            rel = os.path.relpath(full, base_dir)
            zf.write(full, arcname=os.path.join("LabProjects",rel))

zip_path

'/mnt/data/LabProjects.zip'